社区
学习
工具库
AI工具
休闲
搜索
简体中文
首页 后端开发 Python教程 混淆'世界你好！” Python 上的混淆

混淆'世界你好！” Python 上的混淆

Linda Hamilton
Linda Hamilton
Jan 04, 2025 am 03:37 AM

Obfuscating “Hello world!” obfuscate on 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

的 ASCII 码 字符串中的第

个字符。要创建号码：

>>> 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 _, __, ___, ____, _____, ______, _______, ________:
    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 _, __, ___, ____, _____, ______, _______, ________: _
        )
    )
)
登录后复制
登录后复制
登录后复制
登录后复制

我们在这里真正要做的是查看函数中包含的代码对象的行号表。由于它是匿名的，因此没有行号，因此字符串为空。将 0 替换为 _ 以使其更加混乱（这并不重要，因为该函数没有被调用），然后将其插入。我们还将把 256 重构为一个参数，该参数传递给我们混淆的 Convert()连同号码。这需要向组合器添加一个参数：

import sys
sys.stdout.write("Hello world!\n")
登录后复制
登录后复制
登录后复制
登录后复制

绕道

让我们暂时解决一个不同的问题。我们想要一种方法来混淆代码中的数字，但是每次使用它们时重新创建它们会很麻烦（而且不是特别有趣）。如果我们可以实现 range(1, 9) == [1, 2, 3, 4, 5, 6, 7, 8]，那么我们可以将当前的工作包装在一个函数中，该函数接受包含以下数字的变量1 到 8，并用这些变量替换正文中出现的整数文字：

import os
os.write(1, "Hello world!\n")
登录后复制
登录后复制
登录后复制

即使我们还需要形成 256 和 802616035175250124568770929992，它们也可以通过对这八个“基本”数字进行算术运算来创建。 1-8 的选择是任意的，但似乎是一个很好的中间立场。

我们可以通过函数的代码对象获取函数接受的参数数量：

__import__("os").write(1, "Hello world!\n")
登录后复制
登录后复制
登录后复制

构建参数计数在 1 到 8 之间的函数元组：

getattr(__import__("os"), "write")(1, "Hello world!\n")
登录后复制
登录后复制
登录后复制

使用递归算法，我们可以将其转换为 range(1, 9) 的输出：

"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]
登录后复制
登录后复制

和之前一样，我们将其转换为 lambda 形式：

getattr(
    __import__(True.__class__.__name__[1] + [].__class__.__name__[2]),
    ().__class__.__eq__.__class__.__name__[:2] +
    ().__iter__().__class__.__name__[5:8]
)(1, "Hello world!\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
登录后复制
登录后复制

为了好玩，我们将 argcount 操作分解为一个附加函数参数，并混淆一些变量名称：

>>> def convert(num):
...     if num:
...         return chr(num % 256) + convert(num // 256)
...     else:
...         return ""
...
>>> convert(802616035175250124568770929992)
'Hello world!\n'
登录后复制
登录后复制

现在有一个新问题：我们仍然需要一种隐藏 0 和 1 的方法。我们可以通过检查任意函数中局部变量的数量来获得这些：

convert = lambda num: chr(num % 256) + convert(num // 256) if num else ""
登录后复制
登录后复制

尽管函数体看起来相同，但第一个函数中的 _ 不是参数，也不是在函数中定义的，因此 Python 将其解释为全局变量：

>>> 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'
登录后复制
登录后复制

现在我们可以替换 funcs 的值，然后使用 * 将结果整数列表作为八个单独的变量传递，我们得到：

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
    )
)
登录后复制
登录后复制

移位

快到了！我们将用 、_、、_ 等替换 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,
            _ << ________,
            (((_____ << ____) + _) << ((___ << _____) - ___)) + (((((___ << __)
            - _) << ___) + _) << ((_____ << ____) + (_ << _))) + (((_______ <<
            __) - _) << (((((_ << ___) + _)) << ___) + (_ << _))) + (((_______
            << ___) + _) << ((_ << ______) + _)) + (((_______ << ____) - _) <<
            ((_______ << ___))) + (((_ << ____) - _) << ((((___ << __) + _) <<
            __) - _)) - (_______ << ((((___ << __) - _) << __) + _)) + (_______
            << (((((_ << ___) + _)) << __))) - ((((((_ << ___) + _)) << __) +
            _) << ((((___ << __) + _) << _))) + (((_______ << __) - _) <<
            (((((_ << ___) + _)) << _))) + (((___ << ___) + _) << ((_____ <<
            _))) + (_____ << ______) + (_ << ___)
        )
    )
)(
    *(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 _, __, ___, ____, _____, ______, _______, ________: _
        )
    )
)
登录后复制
登录后复制
登录后复制
登录后复制

只剩下两件事了。我们从简单的开始：256. 256=28

，所以我们可以将其重写为 1 << 8（使用左移位），或 _ << ________ 使用我们混淆的变量。

我们将对 802616035175250124568770929992 使用相同的想法。一个简单的分而治之算法可以将其分解为数字之和，这些数字本身就是移位在一起的数字之和，依此类推。例如，如果我们有 112，我们可以将其分解为 96 16，然后是 (3 << 5) (2 << 3)。我喜欢使用位移位，因为 <<让我想起了 std::cout << C 中的“foo”，或 Python 中的 print chevron (print >>)，这两者都是涉及其他 I/O 方式的转移注意力的内容。

数字可以用多种方式分解；没有一种方法是正确的（毕竟，我们可以将其分解为 (1 

import sys
sys.stdout.write("Hello world!\n")
登录后复制
登录后复制
登录后复制
登录后复制

这里的基本思想是，我们测试一定范围内的数字的各种组合，直到得出两个数字，基数和移位，使得基数

range() 的参数 span 表示搜索空间的宽度。这不能太大，否则我们最终将得到 num 作为我们的基数和 0 作为我们的移位（因为 diff 为零），并且由于基数不能表示为单个变量，所以它会重复，无限递归。如果它太小，我们最终会得到类似于上面提到的 (1 span=⌈log1.5|num|⌉ ⌊24−深度⌋

将伪代码翻译成 Python 并进行一些调整（支持深度参数，以及一些涉及负数的警告），我们得到：

(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 _, __, ___, ____, _____, ______, _______, ________: _
        )
    )
)
登录后复制
登录后复制
登录后复制
登录后复制

现在，当我们调用convert(802616035175250124568770929992)时，我们得到了一个很好的分解：

import sys
sys.stdout.write("Hello world!\n")
登录后复制
登录后复制
登录后复制
登录后复制

将其作为 802616035175250124568770929992 的替代品，并将所有部件放在一起：

import os
os.write(1, "Hello world!\n")
登录后复制
登录后复制
登录后复制

这就是你的。
附录：Python 3 支持

自从写这篇文章以来，有几个人询问了 Python 3 支持的问题。我当时没有想到这一点，但随着 Python 3 不断获得关注（感谢您！），这篇文章显然早就该更新了。

幸运的是，Python 3（截至撰写本文时为 3.6）不需要我们进行太​​多更改：

__import__("os").write(1, "Hello world!\n")
登录后复制
登录后复制
登录后复制

这是完整的 Python 3 版本：

getattr(__import__("os"), "write")(1, "Hello world!\n")
登录后复制
登录后复制
登录后复制

感谢您的阅读！我仍然对这篇文章的受欢迎程度感到惊讶。

以上是混淆'世界你好！” Python 上的混淆的详细内容。更多信息请关注PHP中文网其他相关文章！

本站声明
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系admin@php.cn

热AI工具

Undresser.AI Undress

Undresser.AI Undress

人工智能驱动的应用程序，用于创建逼真的裸体照片

AI Clothes Remover

AI Clothes Remover

用于从照片中去除衣服的在线人工智能工具。

Undress AI Tool

Undress AI Tool

免费脱衣服图片

Clothoff.io

Clothoff.io

AI脱衣机

Video Face Swap

Video Face Swap

使用我们完全免费的人工智能换脸工具轻松在任何视频中换脸！

显示更多

热门文章

Windows 11 KB5054979中的新功能以及如何解决更新问题
4 周前 By DDD
如何修复KB5055523无法在Windows 11中安装？
3 周前 By DDD
Inzoi：如何申请学校和大学
1 个月前 By DDD
如何修复KB5055518无法在Windows 10中安装？
3 周前 By DDD
在哪里可以找到Atomfall中的站点办公室钥匙
4 周前 By DDD
显示更多

热工具

记事本++7.3.1

记事本++7.3.1

好用且免费的代码编辑器

SublimeText3汉化版

SublimeText3汉化版

中文版，非常好用

禅工作室 13.0.1

禅工作室 13.0.1

功能强大的PHP集成开发环境

Dreamweaver CS6

Dreamweaver CS6

视觉化网页开发工具

SublimeText3 Mac版

SublimeText3 Mac版

神级代码编辑软件(SublimeText3)

显示更多

热门话题

gmail邮箱登陆入口在哪里
7889
15
Java教程
1650
14
CakePHP 教程
1411
52
Laravel 教程
1302
25
PHP教程
1248
29
显示更多
Related knowledge
如何在使用 Fiddler Everywhere 进行中间人读取时避免被浏览器检测到？ 如何在使用 Fiddler Everywhere 进行中间人读取时避免被浏览器检测到？ Apr 02, 2025 am 07:15 AM

使用FiddlerEverywhere进行中间人读取时如何避免被检测到当你使用FiddlerEverywhere...

FastAPI中如何处理逗号分隔的列表查询参数？ FastAPI中如何处理逗号分隔的列表查询参数？ Apr 02, 2025 am 06:51 AM

在Linux终端中使用python --version命令时如何解决权限问题？ 在Linux终端中使用python --version命令时如何解决权限问题？ Apr 02, 2025 am 06:36 AM

Linux终端中使用python...

如何在10小时内通过项目和问题驱动的方式教计算机小白编程基础？ 如何在10小时内通过项目和问题驱动的方式教计算机小白编程基础？ Apr 02, 2025 am 07:18 AM

如何在10小时内教计算机小白编程基础？如果你只有10个小时来教计算机小白一些编程知识，你会选择教些什么�...

Python asyncio Telnet连接立即断开：如何解决服务器端阻塞问题？ Python asyncio Telnet连接立即断开：如何解决服务器端阻塞问题？ Apr 02, 2025 am 06:30 AM

关于Pythonasyncio...

如何绕过Investing.com的反爬虫机制获取新闻数据？ 如何绕过Investing.com的反爬虫机制获取新闻数据？ Apr 02, 2025 am 07:03 AM

攻克Investing.com的反爬虫策略许多人尝试爬取Investing.com（https://cn.investing.com/news/latest-news）的新闻数据时，常常�...

Python 3.6加载pickle文件报错ModuleNotFoundError: No module named '__builtin__'怎么办？ Python 3.6加载pickle文件报错ModuleNotFoundError: No module named '__builtin__'怎么办？ Apr 02, 2025 am 06:27 AM

Python3.6环境下加载pickle文件报错：ModuleNotFoundError:Nomodulenamed...

使用Scapy爬虫时，管道文件无法写入的原因是什么？ 使用Scapy爬虫时，管道文件无法写入的原因是什么？ Apr 02, 2025 am 06:45 AM

使用Scapy爬虫时管道文件无法写入的原因探讨在学习和使用Scapy爬虫进行数据持久化存储时，可能会遇到管道文�...

See all articles