脚本代码混淆-Python篇-pyminifier（2）

2019-11-06阅读 8900

微信公众号：七夜安全博客 关注信息安全技术、关注 系统底层原理。问题或建议，请公众号留言。

前言

在上文中，我们讲解了pyminifier中简化和压缩代码的功能。本篇作为第二篇，也是最终篇，讲解一下最重要的功能：代码混淆，学习一下这个项目的混淆策略。大家如果觉得不错的话，一定要分享到朋友圈哈，写了快5000字，基本上每一个细节都给大家拆分出来了，贴了一部分关键代码，会长一些，一定要有耐心哟。

一.混淆效果

在讲解混淆策略之前，先看一下混淆的效果，恶不恶心，哈哈。对比着混淆的结果，再结合我的讲解，会理解地更加深入。

原始代码

专门设计了一段代码，基本上涵盖了经常出现的语法内容。

import io
import tokenize

abvcddfdf = int("10")
def enumerate_keyword_args(tokens=None):
    keyword_args = {}
    inside_function = False
    dsfdsf,flag = inside_function,1
    a = str(flag)
    for index, tok in enumerate(tokens):
        token_type = tok[0]
        token_string = tok[1]
        a = str(token_string)
        b=a
        if token_type == tokenize.NAME:
            if token_string == "def":
                function_name = tokens[index+1][1]
                keyword_args.update({function_name: []})
            elif inside_function:
                if tokens[index+1][1] == '=': # keyword argument
                    print(api(text=token_string))
                    keyword_args[function_name].append(token_string)
def api(text):
    print(text)

def listified_tokenizer(source):
    io_obj = io.StringIO(source)
    return [list(a) for a in tokenize.generate_tokens(io_obj.readline)]

code = u'''
def api(text):
    print(text)
'''
abcd=1212
bcde=abcd
cdef=(abcd,bcde)
defg=[abcd,bcde,cdef]
efgh = {abcd:"cvcv","b":"12121"}
f12212="hhah"
f112122="hheeereah"
tokens_list = listified_tokenizer(code)
print(tokens_list)
enumerate_keyword_args(tokens_list)

混淆后的效果

#!/usr/bin/env python
#-*- coding:utf-8 -*-
흞=int
ݽ=None
ﮄ=False
ﻟ=str
嬯=enumerate
눅=list
import io
ﭢ=io.StringIO
import tokenize
ﰅ=tokenize.generate_tokens
ނ=tokenize.NAME

嘢 = 흞("10")
def ܪ(tokens=ݽ):
    蘩 = {}
    ﭷ = ﮄ
    dsfdsf,flag = ﭷ,1
    a = ﻟ(flag)
    for ﶨ, tok in 嬯(tokens):
        ﶗ = tok[0]
        ﯢ = tok[1]
        a = ﻟ(ﯢ)
        b=a
        if ﶗ == ނ:
            if ﯢ == "def":
                齬 = tokens[ﶨ+1][1]
                蘩.update({齬: []})
            elif ﭷ:
                if tokens[ﶨ+1][1] == '=': # keyword argument
                    print(ݖ(text=ﯢ))
                    蘩[齬].append(ﯢ)
def ݖ(ﲖ):
    print(ﲖ)

def ﰭ(source):
    د = ﭢ(source)
    return [눅(a) for a in ﰅ(د.readline)]

ﳵ = u'''
def api(text):
    print(text)
'''
횗=1212
ﮪ=횗
ﲊ=(횗,ﮪ)
딲=[횗,ﮪ,ﲊ]
ࢹ = {횗:"cvcv","b":"12121"}
ﮤ="hhah"
ﱄ="hheeereah"
狾 = ﰭ(ﳵ)
print(狾)
ܪ(狾)

二.混淆策略

pyminifier的混淆策略分成五大部分，主要是针对变量名，函数名，类名，内置模块名和外部模块进行混淆。每种混淆又分成两步，第一步是确定要混淆的内容，第二步进行内容替换，替换成随机字符。

1.变量名混淆

针对变量名的混淆，并不是所有变量名都能混淆的，因为要保证安全性，混淆过头了，程序就无法运行了。在 函数obfuscatable_variable对变量名进行了过滤，保留着可以混淆的变量名。

def obfuscatable_variable(tokens, index, ignore_length=False):

    tok = tokens[index]
    token_type = tok[0]
    token_string = tok[1]
    line = tok[4]
    if index > 0:
        prev_tok = tokens[index-1]#获取上一个Token
    else: # Pretend it's a newline (for simplicity)
        prev_tok = (54, '\n', (1, 1), (1, 2), '#\n')
    prev_tok_type = prev_tok[0]
    prev_tok_string = prev_tok[1]
    try:
        next_tok = tokens[index+1]#获取下一个Token
    except IndexError: # Pretend it's a newline
        next_tok = (54, '\n', (1, 1), (1, 2), '#\n')
    next_tok_string = next_tok[1]
    if token_string == "=":# 跳过赋值 = 后面的token
        return '__skipline__'
    if token_type != tokenize.NAME:#不是变量名称忽略
        return None # Skip this token
    if token_string.startswith('__'):## __ 开头的不管，比如__init__
        return None
    if next_tok_string == ".":# 导入的模块名（已经导入的）忽略
        if token_string in imported_modules:
            return None
    if prev_tok_string == 'import':#导入的包名忽略
        return '__skipline__'
    if prev_tok_string == ".":#导入模块中的变量/函数忽略
        return '__skipnext__'
    if prev_tok_string == "for":#for循环中的变量如果长度大于2则进行混淆
        if len(token_string) > 2:
            return token_string
    if token_string == "for":# for 关键字忽略
        return None
    if token_string in keyword_args.keys():#函数名忽略
        return None
    if token_string in ["def", "class", 'if', 'elif', 'import']:#关键字忽略
        return '__skipline__'
    if prev_tok_type != tokenize.INDENT and next_tok_string != '=':
        return '__skipline__'
    if not ignore_length:
        if len(token_string) < 3:#长度小于3个则忽略
            return None
    if token_string in RESERVED_WORDS:#在保留字中也忽略
        return None
    return token_string

从函数中可以看到，有以下几类变量名不能混淆：

1. token属性不是tokenize.NAME的过滤掉，例如数字token，字符串token，符号token。
2. 以 __ 开头的名称过滤掉，例如 init
3. 导入的第三方的模块名和变量过滤掉，例如 import os，os不能修改。
4. for循环中的变量名长度小于等于2的过滤掉。
5. 函数名过滤掉(接下来会有专门针对函数的处理方式)。
6. 关键字和保留字过滤掉，长度小于3的名称也过滤掉。

 

确定了要混淆的内容，接下来进行替换，主要涉及replace_obfuscatables和obfuscate_variable函数，核心代码如下：

if token_string == replace and prev_tok_string != '.':# 不是导入的变量
        if inside_function:#在函数里面
            if token_string not in keyword_args[inside_function]:#判断是否在参数列表中
                if not right_of_equal: #token所在的这一行没有 = 或者token在 = 的左边
                    if not inside_parens: # token不在( )之间
                        return return_replacement(replacement) # 例如 a=123 ,str.length() 中的str
                    else:
                        if next_tok[1] != '=':# token在( )之间  api(text) 中的 text，
                            return return_replacement(replacement)
                elif not inside_parens:#token在 = 的右边，token不在( )之间   例如 a = b 中的b
                    return return_replacement(replacement)
                else:#token在 = 的右边，token在( )之间
                    if next_tok[1] != '=': #例如a=api(text) text需要改变
                        return return_replacement(replacement)
        elif not right_of_equal:#token所在的这一行没有 = 或者token在 = 的左边
            if not inside_parens:
                return return_replacement(replacement)
            else:
                if next_tok[1] != '=':
                    return return_replacement(replacement)
        elif right_of_equal and not inside_parens:# 例如 a = b 中的b
            return return_replacement(replacement)

在上述代码中可以看出，混淆变量名称需要区分作用域，即模块中的变量和函数中的变量，即使名称是一样的，但不是一回事，所以需要区分对待。通过如下三个变量进行划分：

• inside_function 代表变量是在函数中
• right_of_equal 代表着变量是在 = 的右侧
• inside_parens 代表变量是在()中

大家可能奇怪，right_of_equal 和 inside_parens 是用来干什么的？其实是为了区分函数调用使用参数名的情况。例如：

def api(text):
    print(text)

api(text="123")

在函数调用的时候, api(text="123")中的text是不能混淆的，不然会报错的。

2.函数名混淆

通过obfuscatable_function函数确定要混淆的函数名称，原理上很简单，排除类似_init_的函数，然后前一个token是def，那当前的token就是函数名称。

def obfuscatable_function(tokens, index, **kwargs):
     ......
    prev_tok_string = prev_tok[1]
    if token_type != tokenize.NAME:
        return None # Skip this token
    if token_string.startswith('__'): # Don't mess with specials
        return None
    if prev_tok_string == "def": #获取函数名称
        return token_string

对于函数名称的替换主要是在两个部位，一个是函数定义的时候，另一个是在函数调用的时候。函数定义的时候容易确定，函数调用的时候大体分成两种情况，一种是静态函数，另一种是动态函数，主要是要确认一下是否需要替换。具体代码位于obfuscate_function函数中：

def obfuscate_function(tokens, index, replace, replacement, *args):

    def return_replacement(replacement):
        FUNC_REPLACEMENTS[replacement] = replace
        return replacement
          ......
    if token_string.startswith('__'):
        return None
    if token_string == replace:
        if prev_tok_string != '.':
            if token_string == replace: #函数定义
                return return_replacement(replacement)
        else:#函数调用
            parent_name = tokens[index-2][1]
            if parent_name in CLASS_REPLACEMENTS:#classmethod
                # This should work for @classmethod methods
                return return_replacement(replacement)
            elif parent_name in VAR_REPLACEMENTS:#实例函数
                # This covers regular ol' instance methods
                return return_replacement(replacement)

在代码的末尾 通过prev_tok_string来判断是定义函数还是调用，如果prev_tok_string!=“.”，代表着定义。

通过parent_name是否在CLASS_REPLACEMENTS 和 VAR_REPLACEMENTS中，判断是静态函数还是动态函数，但是写的有点冗余，最后的处理方式都是一样的。

3.类名混淆

通过obfuscatable_class函数来确认要混淆的类名称，只要判断 prev_tok_string=="class" 即可。

def obfuscatable_class(tokens, index, **kwargs):
    ......
    prev_tok_string = prev_tok[1]
    if token_type != tokenize.NAME:
        return None # Skip this token
    if token_string.startswith('__'): # Don't mess with specials
        return None
#通过判断前一个token是class，就可以知道当前的是类名称
    if prev_tok_string == "class":
        return token_string

对于类名称的替换，这个项目进行了简化处理，无法跨模块跨文件进行混淆，这样的设定就简单了很多，关键代码在obfuscate_class函数中，其实直接就替换了，没啥复杂的。

def obfuscate_class(tokens, index, replace, replacement, *args):

    def return_replacement(replacement):
        CLASS_REPLACEMENTS[replacement] = replace
        return replacement
    ......
    if prev_tok_string != '.': ##无法跨模块混淆
        if token_string == replace:
            return return_replacement(replacement)

4.builtin模块混淆

首先遍历token发现内置模块中的函数和类，代码中内置了 builtins表，enumerate_builtins函数通过比对里面的值来确定token是否是内置的。

builtins = [
    'ArithmeticError',
    'AssertionError',
    'AttributeError',
    ......
    'str',
    'sum',
    'super',
    'tuple',
    'type',
    'unichr',
    'unicode',
    'vars',
    'xrange',
    'zip'
]

内置模块的混淆通过赋值的方式来实现，举个例子，在Python 中有个str的内置函数，正常代码如下：

sum = str(10)

混淆后：

xxxx= str
sum = xxxx(19)

原理如上所示，具体是通过obfuscate_builtins函数来实现的，将所有符合的内置函数/类，都转化成赋值等式，插入到token链的前面，但是有一点需要注意：新的token必须要放到解释器路径(#!/usr/bin/env python)和编码('# -- coding: utf-8 --')之后，这样才不会报错。代码如下：

for tok in tokens[0:4]: # Will always be in the first four tokens
        line = tok[4]
        if analyze.shebang.match(line): # (e.g. '#!/usr/bin/env python')
            if not matched_shebang:
                matched_shebang = True
                skip_tokens += 1
        elif analyze.encoding.match(line): # (e.g. '# -*- coding: utf-8 -*-')
            if not matched_encoding:
                matched_encoding = True
                skip_tokens += 1
    insert_in_next_line(tokens, skip_tokens, obfuscated_assignments)

5.第三方模块与函数的混淆

针对第三方模块与函数的混淆，pyminifier进行了简化处理,具体逻辑在obfuscate_global_import_methods中，通过以下两种方式导入的模块忽略：

import xxx as ppp
from xxx import ppp

只处理 importpackage类型的导入。

枚举模块

首先通过 enumerate_global_imports 函数枚举所有通过import导入的模块，忽略了类里面和函数中导入的模块，只接受全局导入，核心代码如下：

elif token_type == tokenize.NAME:
            if token_string in ["def", "class"]:
                function_count += 1
            if indentation == function_count - 1: #出了函数之后才会相等
                function_count -= 1
            elif function_count >= indentation: #排除了在函数内部和类内部的import导入
                if token_string == "import":
                    import_line = True
                elif token_string == "from":
                    from_import = True
                elif import_line:
                    if token_type == tokenize.NAME  and tokens[index+1][1] != 'as':# 排除 import as
                        if not from_import and token_string not in reserved_words:#排除from import
                            if token_string not in imported_modules:
                                if tokens[index+1][1] == '.': # module.module
                                    parent_module = token_string + '.'
                                else:
                                    if parent_module:
                                        module_string = (
                                            parent_module + token_string)
                                        imported_modules.append(module_string)
                                        parent_module = ''
                                    else:
                                        imported_modules.append(token_string)

遍历函数并混淆

获取导入的模块后，接着遍历token，获取源文件中模块调用的函数，和之前的方法一样通过赋值的方式进行替换，举个例子：原代码：

import os
os.path.exists("text")

混淆后的代码：

import os
ﳀ=os.path
ﳀ.exists("text")

具体函数调用的替换代码很简短,module_method形如os.path，即ﳀ.exists("text")这部分：

if token_string == module_method.split('.')[0]:
    if tokens[index+1][1] == '.':
        if tokens[index+2][1] == module_method.split('.')[1]:
            tokens[index][1] = replacement_dict[module_method]
            tokens[index+1][1] = ""
            tokens[index+2][1] = ""

接下来将替换变量进行定义，形如ﳀ=os.path，并通过insert_in_next_line函数插入到import模块的下方。有一点需要注意的是token索引index + 6,原因很简单， ﳀ=os.path\n转化为token的长度就是6。

elif import_line:
    if token_string == module_method.split('.')[0]:
        # Insert the obfuscation assignment after the import
        ......
        else:
            line = "%s=%s\n" % ( # This ends up being 6 tokens
                replacement_dict[module_method], module_method)
        for indent in indents: # Fix indentation
            line = "%s%s" % (indent[1], line)
            index += 1
        insert_in_next_line(tokens, index, line)
        index += 6 # To make up for the six tokens we inserted
index += 1

混淆源生成

从上面讲解的混淆策略中，我们大体了解了pyminifier的工作方式，但是还有一点没有讲解，那就是混淆源的生成，什么意思呢？如下所示， os.path为啥会被替换成 ﳀ。

ﳀ=os.path

混淆源生成位于obfuscation_machine函数中，分成了两种情况。

在Py3中,支持unicode字符作为变量名称，所以基本上是使用unicode字符作为数据源，混淆后会出现各个国家的语言符号，看着着实恶心，而Py2则是使用的ASCII码的大小写作为数据源。数据源有了，然后进行随机化，让其变得更混乱一些。

代码如下：

# This generates a list of the letters a-z:
    lowercase = list(map(chr, range(97, 123)))
    # Same thing but ALL CAPS:
    uppercase = list(map(chr, range(65, 90)))
    if use_unicode:
        # Python 3 lets us have some *real* fun:
        allowed_categories = ('LC', 'Ll', 'Lu', 'Lo', 'Lu')
        # All the fun characters start at 1580 (hehe):
        big_list = list(map(chr, range(1580, HIGHEST_UNICODE)))
        max_chars = 1000 # Ought to be enough for anybody :)
        combined = []
        rtl_categories = ('AL', 'R') # AL == Arabic, R == Any right-to-left
        last_orientation = 'L'       # L = Any left-to-right
        # Find a good mix of left-to-right and right-to-left characters
        while len(combined) < max_chars:
            char = choice(big_list)
            if unicodedata.category(char) in allowed_categories:
                orientation = unicodedata.bidirectional(char)
                if last_orientation in rtl_categories:
                    if orientation not in rtl_categories:
                        combined.append(char)
                else:
                    if orientation in rtl_categories:
                        combined.append(char)
                last_orientation = orientation
    else:
        combined = lowercase + uppercase
    shuffle(combined) # Randomize it all to keep things interesting

数据源有了，那按照什么顺序输出呢？

这就用到了permutations 函数，生成迭代器，对数据进行排列组合然后输出。

for perm in permutations(combined, identifier_length):
            perm = "".join(perm)
            if perm not in RESERVED_WORDS: # Can't replace reserved words
                yield perm

总结

pyminifier 算是一个不错的入门项目，帮助大家学习脚本混淆，但是不要用在生产环境中，bug挺多，而且混淆能力并不是很强。接下来我会接着讲解脚本混淆的技术手段，不限于python。

本文分享自微信公众号 - 七夜安全博客（qiye_safe），作者：七夜安全

原文出处及转载信息见文内详细说明，如有侵权，请联系 yunjia_community@tencent.com 删除。

原始发表时间：2019-10-29

本文参与腾讯云自媒体分享计划，欢迎正在阅读的你也加入，一起分享。