关于模糊：模糊C代码竞赛2006。请解释一下sykes2.c

Obfuscated C Code Contest 2006. Please explain sykes2.c

这个C程序是如何工作的？

1	main(_){_^448&&main(-~_);putchar(--_%64?32\|-~7[__TIME__-_/8%8][">'txiZ^(~z?"-48]>>";;;====~$::199"[_*2&8\|_/64]/(_&2?1:8)%8&1:10);}

它按原样编译(在gcc 4.6.3上测试)。它打印编译时的时间。我的制度：

1
2
3
4
5
6
7

!! !!!!!! !! !!!!!! !! !!!!!!
!! !! !! !! !! !! !! !!
!! !! !! !! !! !! !! !!
!! !!!!!! !! !! !! !! !! !!!!!!
!! !! !! !! !! !! !!
!! !! !! !! !! !! !!
!! !!!!!! !! !! !! !!!!!!

来源：Sykes2-一行一个时钟，Sykes2作者提示

一些提示：默认情况下没有编译警告。用-Wall编译，发出以下警告：

1
2
3
4
5
6
7

sykes2.c:1:1: warning: return type defaults to ‘int’ [-Wreturn-type]
sykes2.c: In function ‘main’:
sykes2.c:1:14: warning: value computed is not used [-Wunused-value]
sykes2.c:1:1: warning: implicit declaration of function ‘putchar’ [-Wimplicit-function-declaration]
sykes2.c:1:1: warning: suggest parentheses around arithmetic in operand of ‘|’ [-Wparentheses]
sykes2.c:1:1: warning: suggest parentheses around arithmetic in operand of ‘|’ [-Wparentheses]
sykes2.c:1:1: warning: control reaches end of non-void function [-Wreturn-type]

相关讨论

让我们把它弄模糊。

Indenting：

1
2
3
4
5
6

main(_) {
_^448 && main(-~_);
putchar(--_%64
? 32 | -~7[__TIME__-_/8%8][">'txiZ^(~z?"-48] >>";;;====~$::199"[_*2&8|_/64]/(_&2?1:8)%8&1
: 10);
}

引入变量来解决这一混乱局面：

1
2
3
4
5
6
7
8
9
10
11

main(int i) {
if(i^448)
main(-~i);
if(--i % 64) {
char a = -~7[__TIME__-i/8%8][">'txiZ^(~z?"-48];
char b = a >>";;;====~$::199"[i*2&8|i/64]/(i&2?1:8)%8;
putchar(32 | (b & 1));
} else {
putchar(10); // newline
}
}

注意，-~i == i+1是因为有两个补码。因此，我们有

1
2
3
4
5
6
7
8
9
10
11
12
13

main(int i) {
if(i != 448)
main(i+1);
i--;
if(i % 64 == 0) {
putchar('
');
} else {
char a = -~7[__TIME__-i/8%8][">'txiZ^(~z?"-48];
char b = a >>";;;====~$::199"[i*2&8|i/64]/(i&2?1:8)%8;
putchar(32 | (b & 1));
}
}

现在，请注意，a[b]与b[a]相同，并再次应用-~ == 1+更改：

1
2
3
4
5
6
7
8
9
10
11
12
13

main(int i) {
if(i != 448)
main(i+1);
i--;
if(i % 64 == 0) {
putchar('
');
} else {
char a = (">'txiZ^(~z?"-48)[(__TIME__-i/8%8)[7]] + 1;
char b = a >>";;;====~$::199"[(i*2&8)|i/64]/(i&2?1:8)%8;
putchar(32 | (b & 1));
}
}

将递归转换为循环，并进一步简化：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// please don't pass any command-line arguments
main() {
int i;
for(i=447; i>=0; i--) {
if(i % 64 == 0) {
putchar('
');
} else {
char t = __TIME__[7 - i/8%8];
char a =">'txiZ^(~z?"[t - 48] + 1;
int shift =";;;====~$::199"[(i*2&8) | (i/64)];
if((i & 2) == 0)
shift /= 8;
shift = shift % 8;
char b = a >> shift;
putchar(32 | (b & 1));
}
}
}

每次迭代输出一个字符。每64个字符输出一个换行符。否则，它使用一对数据表来计算输出内容，并将字符32(空格)或字符33(!)放入其中。第一个表(">'txiZ^(~z?"是描述每个字符外观的一组10位映射，第二个表(";;;====~$::199"选择要从位图显示的适当位。

第二张桌子

让我们从检查第二张表开始，int shift =";;;====~$::199"[(i*2&8) | (i/64)];。i/64是行号(6到0)，i*2&8是8，如果i是4、5、6或7 mod 8。

if((i & 2) == 0) shift /= 8; shift = shift % 8选择表值的高八进制数字(对于i%8=0,1,4,5)或低八进制数字(对于i%8=2,3,6,7)。轮班表的结果是这样的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

row col val
6 6-7 0
6 4-5 0
6 2-3 5
6 0-1 7
5 6-7 1
5 4-5 7
5 2-3 5
5 0-1 7
4 6-7 1
4 4-5 7
4 2-3 5
4 0-1 7
3 6-7 1
3 4-5 6
3 2-3 5
3 0-1 7
2 6-7 2
2 4-5 7
2 2-3 3
2 0-1 7
1 6-7 2
1 4-5 7
1 2-3 3
1 0-1 7
0 6-7 4
0 4-5 4
0 2-3 3
0 0-1 7

或以表格形式

1
2
3
4
5
6
7

00005577
11775577
11775577
11665577
22773377
22773377
44443377

注意，作者在前两个表条目中使用了空终止符(鬼鬼祟祟！).

这是在七段显示之后设计的，其中7s为空白。因此，第一个表中的条目必须定义被点亮的段。

第一张桌子

__TIME__是由预处理器定义的一个特殊宏。它扩展到一个字符串常量，其中包含运行预处理器的时间，格式为"HH:MM:SS"。注意它正好包含8个字符。请注意，0-9的ASCII值为48到57，而:的ASCII值为58。输出为每行64个字符，因此每行__TIME__只剩下8个字符。

因此，7 - i/8%8是目前正在输出的__TIME__的索引(因为我们正在向下迭代i，所以需要7-)。因此，t是__TIME__输出的特征。

根据输入t，a最终等于以下二进制数：

1
2
3
4
5
6
7
8
9
10
11

0 00111111
1 00101000
2 01110101
3 01111001
4 01101010
5 01011011
6 01011111
7 00101001
8 01111111
9 01111011
: 01000000

每个数字都是一个位图，描述在七段显示中亮起的段。因为字符都是7位ASCII，所以高位总是被清除。因此，段表中的7始终打印为空白。第二张表是这样的，其中7是空白的：

1
2
3
4
5
6
7

000055
11 55
11 55
116655
22 33
22 33
444433

例如，4是01101010(位1、3、5和6集)，打印为

1
2
3
4
5
6
7

----!!--
!!--!!--
!!--!!--
!!!!!!--
----!!--
----!!--
----!!--

为了证明我们真正理解代码，让我们用下表稍微调整一下输出：

1
2
3
4
5
6
7

00
11 55
11 55
66
22 33
22 33
44

编码为"?;;?==? '::799\x07"。出于艺术目的，我们将在几个字符中添加64个字符(因为只使用了低6位，这不会影响输出)；这将产生"?{{?}}?gg::799G"(请注意，第8个字符是未使用的，因此我们可以实际制作我们想要的任何字符)。将新表放入原始代码：

1	main(_){_^448&&main(-~_);putchar(--_%64?32\|-~7[__TIME__-_/8%8][">'txiZ^(~z?"-48]>>"?{{?}}?gg::799G"[_*2&8\|_/64]/(_&2?1:8)%8&1:10);}

我们得到

1
2
3
4
5
6
7

!! !! !!
!! !! !! !! !! !! !! !! !!
!! !! !! !! !! !! !! !! !!
!! !! !! !!
!! !! !! !! !! !! !! !! !!
!! !! !! !! !! !! !! !! !!
!! !! !!

如我们所料。它不像原版那样结实，这就解释了作者为什么选择使用他做的表格。

相关讨论

每个人都要记住，[]只是一个伪装的+。
大坝…我还遇到了前一个开发人员留在我公司的"deobfuscing"代码问题。
@从技术上讲，它既是一个*(取消引用)又是一个+：p
@大约30分钟，但我回来编辑了不少。我经常使用C，我以前为个人利益做过一些IOCCC的介绍(我做的最后一个，只是为了个人利益，就是这个漂亮的光线跟踪器)。如果你想问它是如何工作的，我很乐意效劳；)
哇，太棒了！！示踪剂带你走了多久？
@АртмЦарионов：大约一天的IIRC(也计算理解光线跟踪器几何结构所花费的时间)。这个程序也非常聪明，因为它不使用关键字。
@德雷恩：你能告诉我更多关于[]是伪装的+的意思吗？
C.。汇编语言的所有功能与汇编语言的可读性相结合
@确切地说，是的，但重要的一点是，+不是被认为是理所当然的取消引用。
@尼昂尼奥：好的，我们想看看你现在对光线跟踪器或任何其他你喜欢的IOCC的看法(而且是相互关联的)。很好，很好的答案！谢谢你的时间！
@用户13267 foo[bar]是通过获取foo的地址并添加bar*sizeof(typestoredinarray)来获取数组中barth元素的地址来实现的。
这是一个很好的解释-我觉得我自己做得不好。我首先写了这个程序：)
更多关于这方面的信息，请看唐利比的《模糊的C和其他的秘密》。它通过分析模糊的C竞赛条目来教授C技巧。
真的！！！！你怎么能把你的头围起来呢！？请解释一下，在运行win vista，mingw32 gcc 4.6.1版的机器上，应用程序只打印编译应用程序时的系统时间，当您再次运行它而不编译时，它打印原始系统编译时间。
在前2行中，main(_) { _^448 && main(-~_);如何成为main(int i) { if(i^448) main(-~i);。我看不出这里有什么定义，但即使有，_不能同时是int i和if(i。
@ L？紫外线？为了清晰起见，我重新命名了一些变量。
@那么"u"是一个有效的变量名？如何使用变量withoud首先声明它。我还是不知道_^448 && main(-~_);是怎么变成if(i^448) main(-~i)的。
@ L？紫外线？nhph&250；c:main(_) {...}隐式声明_为int类型的参数。另一方面，想想&&在做什么。
我有点明白。但是，为什么隐式声明_也自动分配_ = 0呢？我只看到了main没有参数，或者有2个参数，比如int main ( int argc, char *argv[] )，1个参数版本如何有效？
@ L？紫外线？nhph&250；c:main的第一个参数是脚本的参数数目加上一个(通常称为argc)；对于这个程序，它是1，因为脚本是在没有参数的情况下启动的。main非常特殊，可以指定在不引起问题的情况下采用不同数量的参数。
哇，太好了。我刚刚在这里找到了一个三元主体的例子
@gath：这个程序打印出EDOCX1的值(22)，它是一个常量值的宏——编译应用程序的时间。它不打算打印当前时间。
我投降…下颚脱落…
仍然让我热泪盈眶。
有没有其他人还不明白？
@我对移位表的计算有点困惑。对于第6行，应该不是像00005757，因为对于第3列(i=443)，我们从shift=61开始。既然我是奇数，我们取低八进制位(101=5)。但是对于第2列(i=442)，我们取更高的八进制位(111=7)，同样对于第1列和第0列。根据类似的论点，所有其他行都应该有交替模式，例如，第5行应该是17175757？我错过了点什么吗？
@易卜拉欣5253：测试并不是看i是否是奇数，而是测试i的第二个最低有效位的i & 2。

让我们将其格式化以便于阅读：

1
2
3
4

main(_){
_^448&&main(-~_);
putchar((--_%64) ? (32|-(~7[__TIME__-_/8%8])[">'txiZ^(~z?"-48]>>(";;;====~$::199")[_*2&8|_/64]/(_&2?1:8)%8&1):10);
}

因此，在没有参数的情况下运行它时(argc传统上)是1。main()将递归地调用自身，传递-(~_)的结果(负的位不是_的结果)，因此实际上它将执行448次递归(仅在_^448 == 0的情况下)。

这样，它将打印7 64个字符宽的行(外部三元条件和448/64 == 7)。让我们把它改写得更清楚一点：

1
2
3
4
5
6
7

main(int argc) {
if (argc^448) main(-(~argc));
if (argc % 64) {
putchar((32|-(~7[__TIME__-argc/8%8])[">'txiZ^(~z?"-48]>>(";;;====~$::199")[argc*2&8|argc/64]/(argc&2?1:8)%8&1));
} else putchar('
');
}

现在，32是ASCII空间的十进制。它要么打印一个空格要么打印一个"！"(33是‘！’"最后是"EDOCX1"(7)。让我们关注中间的斑点：

1 2	-(~(7[__TIME__-argc/8%8][">'txiZ^(~z?"-48]) >> (";;;====~$::199"[argc*2&8\|argc/64]) / (argc&2?1:8) % 8

正如另一个海报所说，__TIME__是程序的编译时间，是一个字符串，因此有一些字符串算法正在进行，同时利用数组下标的双向性：a[b]与b[a]对于字符数组是相同的。

1	7[__TIME__ - (argc/8)%8]

这将选择__TIME__中的前8个字符之一。然后索引到[">'txiZ^(~z?"-48](0-9个字符是48-57位小数)。必须为其ASCII值选择此字符串中的字符。同样的字符ascii代码操作在表达式中继续进行，从而导致打印""或"！"取决于角色glyph中的位置。

除其他方案外，-~x等于x+1，因为~x等于(0xffffffff-x)。这相当于2s补码中的(-1-x)，所以-~x是-(-1-x) = x+1。