混淆“世界你好！” Python 上的混淆
来源：dev.to
时间：2025-01-18 08:01:13 126浏览 收藏
在文章实战开发的过程中，我们经常会遇到一些这样那样的问题，然后要卡好半天，等问题解决了才发现原来一些细节知识点还是没有掌握好。今天golang学习网就整理分享《混淆“世界你好！” Python 上的混淆》，聊聊，希望可以帮助到正在努力赚钱的你。
创建最奇怪的混淆程序，打印字符串“hello world！”。我决定写一篇解释它到底是如何工作的。所以，这是 python 2.7 中的条目：
(lambda _, __, ___, ____, _____, ______, _______, ________:
getattr(
__import__(true.__class__.__name__[_] + [].__class__.__name__[__]),
().__class__.__eq__.__class__.__name__[:__] +
().__iter__().__class__.__name__[_____:________]
)(
_, (lambda _, __, ___: _(_, __, ___))(
lambda _, __, ___:
chr(___ % __) + _(_, __, ___ // __) if ___ else
(lambda: _).func_code.co_lnotab,
_ << ________,
(((_____ << ____) + _) << ((___ << _____) - ___)) + (((((___ << __)
- _) << ___) + _) << ((_____ << ____) + (_ << _))) + (((_______ <<
__) - _) << (((((_ << ___) + _)) << ___) + (_ << _))) + (((_______
<< ___) + _) << ((_ << ______) + _)) + (((_______ << ____) - _) <<
((_______ << ___))) + (((_ << ____) - _) << ((((___ << __) + _) <<
__) - _)) - (_______ << ((((___ << __) - _) << __) + _)) + (_______
<< (((((_ << ___) + _)) << __))) - ((((((_ << ___) + _)) << __) +
_) << ((((___ << __) + _) << _))) + (((_______ << __) - _) <<
(((((_ << ___) + _)) << _))) + (((___ << ___) + _) << ((_____ <<
_))) + (_____ << ______) + (_ << ___)
)
)
)(
*(lambda _, __, ___: _(_, __, ___))(
(lambda _, __, ___:
[__(___[(lambda: _).func_code.co_nlocals])] +
_(_, __, ___[(lambda _: _).func_code.co_nlocals:]) if ___ else []
),
lambda _: _.func_code.co_argcount,
(
lambda _: _,
lambda _, __: _,
lambda _, __, ___: _,
lambda _, __, ___, ____: _,
lambda _, __, ___, ____, _____: _,
lambda _, __, ___, ____, _____, ______: _,
lambda _, __, ___, ____, _____, ______, _______: _,
lambda _, __, ___, ____, _____, ______, _______, ________: _
)
)
)
不允许使用字符串文字，但我为了好玩设置了一些其他限制：它必须是单个表达式（因此没有打印语句），具有最少的内置用法，并且没有整数文字。
开始使用
由于我们无法使用打印，我们可以写入 stdout 文件对象：
import sys
sys.stdout.write("hello world!\n")
但是让我们使用较低级别的东西：os.write()。我们需要 stdout 的文件描述符，它是 1（可以使用 print sys.stdout.fileno() 检查）。
import os os.write(1, "hello world!\n")
我们想要一个表达式，所以我们将使用 import():
__import__("os").write(1, "hello world!\n")
我们还希望能够混淆 write()，因此我们将引入 getattr()：
getattr(__import__("os"), "write")(1, "hello world!\n")
这是起点。从现在开始，一切都将混淆三个字符串和整数。
将字符串串在一起
“os”和“write”相当简单，因此我们将通过连接各个内置类的部分名称来创建它们。有很多不同的方法可以做到这一点，但我选择了以下方法：
"o" from the second letter of bool: true.__class__.__name__[1] "s" from the third letter of list: [].__class__.__name__[2] "wr" from the first two letters of wrapper_descriptor, an implementation detail in cpython found as the type of some builtin classes’ methods (more on that here): ().__class__.__eq__.__class__.__name__[:2] "ite" from the sixth through eighth letters of tupleiterator, the type of object returned by calling iter() on a tuple: ().__iter__().__class__.__name__[5:8]
我们开始取得一些进展！
getattr(
__import__(true.__class__.__name__[1] + [].__class__.__name__[2]),
().__class__.__eq__.__class__.__name__[:2] +
().__iter__().__class__.__name__[5:8]
)(1, "hello world!\n")
“hello world!n”更复杂。我们将把它编码为一个大整数，它由每个字符的 ascii 代码乘以 256 的字符在字符串中的索引次方组成。换句话说，以下总和：
Σn=0l−1cn(256n)
哪里l
是字符串的长度，cn 是 n
个字符。要创建号码：
>>> codes = [ord(c) for c in "hello world!\n"] >>> num = sum(codes[i] * 256 ** i for i in xrange(len(codes))) >>> print num 802616035175250124568770929992
现在我们需要代码将此数字转换回字符串。我们使用一个简单的递归算法：
>>> def convert(num): ... if num: ... return chr(num % 256) + convert(num // 256) ... else: ... return "" ... >>> convert(802616035175250124568770929992) 'hello world!\n'
用 lambda 重写一行：
convert = lambda num: chr(num % 256) + convert(num // 256) if num else ""
现在我们使用匿名递归将其转换为单个表达式。这需要一个组合器。从这个开始：
>>> comb = lambda f, n: f(f, n) >>> convert = lambda f, n: chr(n % 256) + f(f, n // 256) if n else "" >>> comb(convert, 802616035175250124568770929992) 'hello world!\n'
现在我们只需将这两个定义代入表达式中，我们就得到了我们的函数：
>>> (lambda f, n: f(f, n))( ... lambda f, n: chr(n % 256) + f(f, n // 256) if n else "", ... 802616035175250124568770929992) 'hello world!\n'
现在我们可以将其粘贴到之前的代码中，一路替换一些变量名称 (f → , n → _):
getattr(
__import__(true.__class__.__name__[1] + [].__class__.__name__[2]),
().__class__.__eq__.__class__.__name__[:2] +
().__iter__().__class__.__name__[5:8]
)(
1, (lambda _, __: _(_, __))(
lambda _, __: chr(__ % 256) + _(_, __ // 256) if __ else "",
802616035175250124568770929992
)
)
函数内部
我们在转换函数的主体中留下了一个“”（记住：没有字符串文字！），以及我们必须以某种方式隐藏的大量数字。让我们从空字符串开始。我们可以通过检查某个随机函数的内部结构来即时制作一个：
>>> (lambda: 0).func_code.co_lnotab ''
我们在这里真正要做的是查看函数中包含的代码对象的行号表。由于它是匿名的，因此没有行号，因此字符串为空。将 0 替换为 _ 以使其更加混乱（这并不重要，因为该函数没有被调用），然后将其插入。我们还将把 256 重构为一个参数，该参数传递给我们混淆的 convert()连同号码。这需要向组合器添加一个参数：
getattr(
__import__(true.__class__.__name__[1] + [].__class__.__name__[2]),
().__class__.__eq__.__class__.__name__[:2] +
().__iter__().__class__.__name__[5:8]
)(
1, (lambda _, __, ___: _(_, __, ___))(
lambda _, __, ___:
chr(___ % __) + _(_, __, ___ // __) if ___ else
(lambda: _).func_code.co_lnotab,
256,
802616035175250124568770929992
)
)
绕道
让我们暂时解决一个不同的问题。我们想要一种方法来混淆代码中的数字，但每次使用它们时重新创建它们会很麻烦（而且不是特别有趣）。如果我们可以实现 range(1, 9) == [1, 2, 3, 4, 5, 6, 7, 8]，那么我们可以将当前的工作包装在一个函数中，该函数接受包含数字的变量1 到 8，并用这些变量替换正文中出现的整数文字：
(lambda n1, n2, n3, n4, n5, n6, n7, n8:
getattr(
__import__(true.__class__.__name__[n1] + [].__class__.__name__[n2]),
...
)(
...
)
)(*range(1, 9))
即使我们还需要形成 256 和 802616035175250124568770929992，它们也可以通过对这八个“基本”数字进行算术运算来创建。 1-8 的选择是任意的，但似乎是一个很好的中间立场。
我们可以通过函数的代码对象获取函数接受的参数数量：
>>> (lambda a, b, c: 0).func_code.co_argcount
构建参数计数在 1 到 8 之间的函数元组：
funcs = (
lambda _: _,
lambda _, __: _,
lambda _, __, ___: _,
lambda _, __, ___, ____: _,
lambda _, __, ___, ____, _____: _,
lambda _, __, ___, ____, _____, ______: _,
lambda _, __, ___, ____, _____, ______, _______: _,
lambda _, __, ___, ____, _____, ______, _______, ________: _
)
使用递归算法，我们可以将其转换为 range(1, 9) 的输出：
>>> def convert(l): ... if l: ... return [l[0].func_code.co_argcount] + convert(l[1:]) ... else: ... return [] ... >>> convert(funcs) [1, 2, 3, 4, 5, 6, 7, 8]
和之前一样，我们将其转换为 lambda 形式：
convert = lambda l: [l[0].func_code.co_argcount] + convert(l[1:]) if l else []
然后，进入匿名递归形式：
>>> (lambda f, l: f(f, l))( ... lambda f, l: [l[0].func_code.co_argcount] + f(f, l[1:]) if l else [], ... funcs) [1, 2, 3, 4, 5, 6, 7, 8]
为了好玩，我们将 argcount 操作分解为一个附加函数参数，并混淆一些变量名称：
(lambda _, __, ___: _(_, __, ___))(
(lambda _, __, ___:
[__(___[0])] + _(_, __, ___[1:]) if ___ else []
),
lambda _: _.func_code.co_argcount,
funcs
)
现在有一个新问题：我们仍然需要一种隐藏 0 和 1 的方法。我们可以通过检查任意函数中局部变量的数量来获得这些：
>>> (lambda: _).func_code.co_nlocals 0 >>> (lambda _: _).func_code.co_nlocals 1
尽管函数体看起来相同，但第一个函数中的 _ 不是参数，也不是在函数中定义的，因此 python 将其解释为全局变量：
>>> import dis
>>> dis.dis(lambda: _)
1 0 load_global 0 (_)
3 return_value
>>> dis.dis(lambda _: _)
1 0 load_fast 0 (_)
3 return_value
无论 _ 是否实际在全局范围内定义，都会发生这种情况。
将其付诸实践：
(lambda _, __, ___: _(_, __, ___))(
(lambda _, __, ___:
[__(___[(lambda: _).func_code.co_nlocals])] +
_(_, __, ___[(lambda _: _).func_code.co_nlocals:]) if ___ else []
),
lambda _: _.func_code.co_argcount,
funcs
)
现在我们可以替换 funcs 的值，然后使用 * 将结果整数列表作为八个单独的变量传递，我们得到：
(lambda n1, n2, n3, n4, n5, n6, n7, n8:
getattr(
__import__(true.__class__.__name__[n1] + [].__class__.__name__[n2]),
().__class__.__eq__.__class__.__name__[:n2] +
().__iter__().__class__.__name__[n5:n8]
)(
n1, (lambda _, __, ___: _(_, __, ___))(
lambda _, __, ___:
chr(___ % __) + _(_, __, ___ // __) if ___ else
(lambda: _).func_code.co_lnotab,
256,
802616035175250124568770929992
)
)
)(
*(lambda _, __, ___: _(_, __, ___))(
(lambda _, __, ___:
[__(___[(lambda: _).func_code.co_nlocals])] +
_(_, __, ___[(lambda _: _).func_code.co_nlocals:]) if ___ else []
),
lambda _: _.func_code.co_argcount,
(
lambda _: _,
lambda _, __: _,
lambda _, __, ___: _,
lambda _, __, ___, ____: _,
lambda _, __, ___, ____, _____: _,
lambda _, __, ___, ____, _____, ______: _,
lambda _, __, ___, ____, _____, ______, _______: _,
lambda _, __, ___, ____, _____, ______, _______, ________: _
)
)
)
移位
快到了！我们将用 、_、、_ 等替换 n{1..8} 变量，因为它会与中使用的变量产生混淆我们的内在功能。这不会造成实际问题，因为范围规则意味着将使用正确的规则。这也是我们将 256 重构为 _ 指代 1 而不是我们混淆的 convert() 函数的原因之一。有点长了，就只贴前半部分了：
(lambda _, __, ___, ____, _____, ______, _______, ________:
getattr(
__import__(true.__class__.__name__[_] + [].__class__.__name__[__]),
().__class__.__eq__.__class__.__name__[:__] +
().__iter__().__class__.__name__[_____:________]
)(
_, (lambda _, __, ___: _(_, __, ___))(
lambda _, __, ___:
chr(___ % __) + _(_, __, ___ // __) if ___ else
(lambda: _).func_code.co_lnotab,
256,
802616035175250124568770929992
)
)
)
只剩下两件事了。我们从简单的开始：256. 256=28
，所以我们可以将其重写为 1 << 8 （使用左移位），或者使用我们的混淆变量 _ << ________。
我们将对 802616035175250124568770929992 使用相同的想法。一个简单的分而治之算法可以将其分解为数字之和，这些数字本身就是移位在一起的数字之和，依此类推。例如，如果我们有 112，我们可以将其分解为 96 16，然后 (3 << 5) (2 << 3)。我喜欢使用位移位，因为 << 让我想起 c 中的 std::cout << "foo" 或 python 中的 print chevron (print >>)，这两者都是涉及其他 i/o 方式的转移注意力的内容。
数字可以用多种方式分解；没有一种方法是正确的（毕竟，我们可以将其分解为 (1 << 0) (1 << 0) ...，但这并不有趣）。我们应该有大量的嵌套，但仍然使用大部分数值变量。显然，手动执行此操作并不有趣，因此我们将提出一种算法。伪代码：
func encode(num):
if num <= 8:
return "_" * num
else:
return "(" + convert(num) + ")"
func convert(num):
base = shift = 0
diff = num
span = ...
for test_base in range(span):
for test_shift in range(span):
test_diff = |num| - (test_base << test_shift)
if |test_diff| < |diff|:
diff = test_diff
base = test_base
shift = test_shift
encoded = "(" + encode(base) + " << " + encode(shift) + ")"
if diff == 0:
return encoded
else:
return encoded + " + " + convert(diff)
convert(802616035175250124568770929992)
这里的基本思想是，我们在一定范围内测试数字的各种组合，直到得到两个数字，base 和 shift，这样 base << shift 尽可能接近 num （即我们最小化它们的绝对差） ，差异）。然后，我们使用分而治之算法来分解 best_base 和 best_shift，然后在 diff 上重复该过程，直到它达到零，一路上对各项进行求和。
range() 的参数 span 表示搜索空间的宽度。这不能太大，否则我们最终将得到 num 作为我们的基数和 0 作为我们的移位（因为 diff 为零），并且由于基数不能表示为单个变量，所以它会重复，无限递归。如果它太小，我们最终会得到类似上面提到的 (1 << 0) (1 << 0) ... 的结果。在实践中，我们希望跨度随着递归深度的增加而变小。经过反复试验，我发现这个方程效果很好：
span=⌈log1.5|num|⌉ ⌊24−深度⌋
将伪代码翻译成 python 并进行一些调整（支持深度参数，以及一些涉及负数的警告），我们得到：
from math import ceil, log
def encode(num, depth):
if num == 0:
return "_ - _"
if num <= 8:
return "_" * num
return "(" + convert(num, depth + 1) + ")"
def convert(num, depth=0):
result = ""
while num:
base = shift = 0
diff = num
span = int(ceil(log(abs(num), 1.5))) + (16 >> depth)
for test_base in xrange(span):
for test_shift in xrange(span):
test_diff = abs(num) - (test_base << test_shift)
if abs(test_diff) < abs(diff):
diff = test_diff
base = test_base
shift = test_shift
if result:
result += " + " if num > 0 else " - "
elif num < 0:
base = -base
if shift == 0:
result += encode(base, depth)
else:
result += "(%s << %s)" % (encode(base, depth),
encode(shift, depth))
num = diff if num > 0 else -diff
return result
现在，当我们调用convert(802616035175250124568770929992)时，我们得到了一个很好的分解：
>>> convert(802616035175250124568770929992) (((_____ << ____) + _) << ((___ << _____) - ___)) + (((((___ << __) - _) << ___) + _) << ((_____ << ____) + (_ << _))) + (((_______ << __) - _) << (((((_ << ___) + _)) << ___) + (_ << _))) + (((_______ << ___) + _) << ((_ << ______) + _)) + (((_______ << ____) - _) << ((_______ << ___))) + (((_ << ____) - _) << ((((___ << __) + _) << __) - _)) - (_______ << ((((___ << __) - _) << __) + _)) + (_______ << (((((_ << ___) + _)) << __))) - ((((((_ << ___) + _)) << __) + _) << ((((___ << __) + _) << _))) + (((_______ << __) - _) << (((((_ << ___) + _)) << _))) + (((___ << ___) + _) << ((_____ << _))) + (_____ << ______) + (_ << ___)
将其作为 802616035175250124568770929992 的替代品，并将所有部件放在一起：
(lambda _, __, ___, ____, _____, ______, _______, ________:
getattr(
__import__(true.__class__.__name__[_] + [].__class__.__name__[__]),
().__class__.__eq__.__class__.__name__[:__] +
().__iter__().__class__.__name__[_____:________]
)(
_, (lambda _, __, ___: _(_, __, ___))(
lambda _, __, ___:
chr(___ % __) + _(_, __, ___ // __) if ___ else
(lambda: _).func_code.co_lnotab,
_ << ________,
(((_____ << ____) + _) << ((___ << _____) - ___)) + (((((___ << __)
- _) << ___) + _) << ((_____ << ____) + (_ << _))) + (((_______ <<
__) - _) << (((((_ << ___) + _)) << ___) + (_ << _))) + (((_______
<< ___) + _) << ((_ << ______) + _)) + (((_______ << ____) - _) <<
((_______ << ___))) + (((_ << ____) - _) << ((((___ << __) + _) <<
__) - _)) - (_______ << ((((___ << __) - _) << __) + _)) + (_______
<< (((((_ << ___) + _)) << __))) - ((((((_ << ___) + _)) << __) +
_) << ((((___ << __) + _) << _))) + (((_______ << __) - _) <<
(((((_ << ___) + _)) << _))) + (((___ << ___) + _) << ((_____ <<
_))) + (_____ << ______) + (_ << ___)
)
)
)(
*(lambda _, __, ___: _(_, __, ___))(
(lambda _, __, ___:
[__(___[(lambda: _).func_code.co_nlocals])] +
_(_, __, ___[(lambda _: _).func_code.co_nlocals:]) if ___ else []
),
lambda _: _.func_code.co_argcount,
(
lambda _: _,
lambda _, __: _,
lambda _, __, ___: _,
lambda _, __, ___, ____: _,
lambda _, __, ___, ____, _____: _,
lambda _, __, ___, ____, _____, ______: _,
lambda _, __, ___, ____, _____, ______, _______: _,
lambda _, __, ___, ____, _____, ______, _______, ________: _
)
)
)
这就是你的。
附录：python 3 支持
自从写这篇文章以来，有几个人询问了 python 3 支持的问题。我当时没有想到这一点，但随着 python 3 不断受到关注（感谢您！），这篇文章显然早就该更新了。
幸运的是，python 3（截至撰写本文时为 3.6）不需要我们进行太多更改：
the func_code function object attribute has been renamed to __code__. easy fix with a find-and-replace. the tupleiterator type name has been changed to tuple_iterator. since we use this to extract the substring "ite", we can get around this by changing our indexing in ().__iter__().__class__.__name__ from [_____:________] to [_:][_____:________]. os.write() requires bytes now instead of a str, so chr(...) needs to be changed to bytes([...]).
这是完整的 python 3 版本：
(lambda _, __, ___, ____, _____, ______, _______, ________:
getattr(
__import__(True.__class__.__name__[_] + [].__class__.__name__[__]),
().__class__.__eq__.__class__.__name__[:__] +
().__iter__().__class__.__name__[_:][_____:________]
)(
_, (lambda _, __, ___: _(_, __, ___))(
lambda _, __, ___:
bytes([___ % __]) + _(_, __, ___ // __) if ___ else
(lambda: _).__code__.co_lnotab,
_ << ________,
(((_____ << ____) + _) << ((___ << _____) - ___)) + (((((___ << __)
- _) << ___) + _) << ((_____ << ____) + (_ << _))) + (((_______ <<
__) - _) << (((((_ << ___) + _)) << ___) + (_ << _))) + (((_______
<< ___) + _) << ((_ << ______) + _)) + (((_______ << ____) - _) <<
((_______ << ___))) + (((_ << ____) - _) << ((((___ << __) + _) <<
__) - _)) - (_______ << ((((___ << __) - _) << __) + _)) + (_______
<< (((((_ << ___) + _)) << __))) - ((((((_ << ___) + _)) << __) +
_) << ((((___ << __) + _) << _))) + (((_______ << __) - _) <<
(((((_ << ___) + _)) << _))) + (((___ << ___) + _) << ((_____ <<
_))) + (_____ << ______) + (_ << ___)
)
)
)(
*(lambda _, __, ___: _(_, __, ___))(
(lambda _, __, ___:
[__(___[(lambda: _).__code__.co_nlocals])] +
_(_, __, ___[(lambda _: _).__code__.co_nlocals:]) if ___ else []
),
lambda _: _.__code__.co_argcount,
(
lambda _: _,
lambda _, __: _,
lambda _, __, ___: _,
lambda _, __, ___, ____: _,
lambda _, __, ___, ____, _____: _,
lambda _, __, ___, ____, _____, ______: _,
lambda _, __, ___, ____, _____, ______, _______: _,
lambda _, __, ___, ____, _____, ______, _______, ________: _
)
)
)
感谢您的阅读！我仍然对这篇文章的受欢迎程度感到惊讶。
文中关于的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《混淆“世界你好！” Python 上的混淆》文章吧，也可关注golang学习网公众号了解相关技术文章。
-
501 收藏
-
501 收藏
-
501 收藏
-
501 收藏
-
501 收藏
-
435 收藏
-
185 收藏
-
112 收藏
-
170 收藏
-
184 收藏
-
389 收藏
-
- 前端进阶之JavaScript设计模式
- 设计模式是开发人员在软件开发过程中面临一般问题时的解决方案，代表了最佳的实践。本课程的主打内容包括JS常见设计模式以及具体应用场景，打造一站式知识长龙服务，适合有JS基础的同学学习。
- 立即学习 542次学习
-
- GO语言核心编程课程
- 本课程采用真实案例，全面具体可落地，从理论到实践，一步一步将GO核心编程技术、编程思想、底层实现融会贯通，使学习者贴近时代脉搏，做IT互联网时代的弄潮儿。
- 立即学习 507次学习
-
- 简单聊聊mysql8与网络通信
- 如有问题加微信：Le-studyg；在课程中，我们将首先介绍MySQL8的新特性，包括性能优化、安全增强、新数据类型等，帮助学生快速熟悉MySQL8的最新功能。接着，我们将深入解析MySQL的网络通信机制，包括协议、连接管理、数据传输等，让
- 立即学习 497次学习
-
- JavaScript正则表达式基础与实战
- 在任何一门编程语言中,正则表达式,都是一项重要的知识,它提供了高效的字符串匹配与捕获机制,可以极大的简化程序设计。
- 立即学习 487次学习
-
- 从零制作响应式网站—Grid布局
- 本系列教程将展示从零制作一个假想的网络科技公司官网，分为导航，轮播，关于我们，成功案例，服务流程，团队介绍，数据部分，公司动态，底部信息等内容区块。网站整体采用CSSGrid布局，支持响应式，有流畅过渡和展现动画。
- 立即学习 484次学习