난독화 'Hello world!' 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 _, __, ___, ____, _____, ______, _______, ________: _
        )
    )
)

문자열 리터럴은 허용되지 않았지만 재미를 위해 몇 가지 다른 제한 사항을 설정했습니다. 기본 제공 사용을 최소화하고 정수 리터럴이 없는 단일 표현식이어야 했습니다(따라서 인쇄 문이 없어야 함).
시작하기

print를 사용할 수 없으므로 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")

이것이 출발점입니다. 이제부터 모든 것은 세 개의 문자열과 int를 난독화할 것입니다.
끈을 하나로 묶기

"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)

어디
는 문자열의 길이이고 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'

람다를 사용하여 한 줄로 다시 작성:

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도 형성해야 하지만 이러한 8개의 "기본" 숫자에 대한 산술 연산을 사용하여 이러한 숫자를 생성할 수 있습니다. 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]

이전과 마찬가지로 이를 람다 형식으로 변환합니다.

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 값을 대체한 다음 *를 사용하여 결과 정수 목록을 8개의 개별 변수로 전달할 수 있으며 다음과 같은 결과를 얻습니다.

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} 변수를 , _, , _ 등으로 대체하겠습니다. 우리의 내부 기능. 범위 지정 규칙은 올바른 규칙이 사용된다는 것을 의미하므로 이는 실제 문제를 일으키지 않습니다. 이는 또한 난독화된 변환() 함수 대신 _가 1을 참조하도록 256을 리팩토링한 이유 중 하나입니다. 내용이 길어져서 전반부만 첨부하겠습니다:

(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에서는 chevron(print >>)을 인쇄합니다. 둘 다 I/O를 수행하는 다른 방법과 관련된 위험 요소입니다.

숫자는 다양한 방법으로 분해될 수 있습니다. 어떤 방법도 정확하지 않습니다(결국 우리는 그것을 (1

import sys
sys.stdout.write("Hello world!\n")

여기서 기본 아이디어는 기본과 시프트라는 두 개의 숫자가 나올 때까지 특정 범위에서 다양한 숫자 조합을 테스트하는 것입니다. Shift는 가능한 한 num에 가장 가깝습니다(즉, 절대 차이 diff를 최소화합니다). 그런 다음 분할 정복 알고리즘을 사용하여 best_base와 best_shift를 분리한 다음 diff에서 0에 도달할 때까지 절차를 반복하여 항을 합산합니다.

range()의 인수인span은 검색 공간의 너비를 나타냅니다. 너무 클 수는 없습니다. 그렇지 않으면 num을 베이스로, 0을 시프트로 사용하게 됩니다(diff는 0이므로). 베이스는 단일 변수로 표현할 수 없으므로 무한히 반복됩니다. . 너무 작으면 위에서 언급한 (1 범위=⌈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")

읽어주셔서 감사합니다! 이 게시물의 인기에 계속 놀라고 있습니다.

위 내용은 난독화 'Hello world!' Python에서 난독화의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!