# test.py
s = "Hello"

def func(a, b=3, *args):
	c = 114514
	print(a, b)
	print(args)

>>> dis.dis(b.co_consts[2].co_code)
          # c = 114514
          0 LOAD_CONST               1 (1)	# push 114514
          2 STORE_FAST               3 (3)  # c = 114514
          # print(a, b)
          4 LOAD_GLOBAL              0 (0)  # push global_obj co_names[0] == "print"
          6 LOAD_FAST                0 (0)  # push a
          8 LOAD_FAST                1 (1)  # push b --> 这个在最顶端
         10 CALL_FUNCTION            2      # 其中最右边的参数在最顶端，即从左往右push；区别于C式栈，从右往左push
         12 POP_TOP                         # 不要返回值，直接弹掉
          # print(args)
         14 LOAD_GLOBAL              0 (0)  # push global_obj co_names[0] == "print"
         16 LOAD_FAST                2 (2)  # push args
         18 CALL_FUNCTION            1
         20 POP_TOP
        
          # return None
         22 LOAD_CONST               0 (0)  # push None
         24 RETURN_VALUE

>>> dis.dis(b.co_consts[2].co_code)
          # c = 114514
          0 LOAD_CONST               1 (1)	# push 114514
          2 STORE_FAST               3 (3)  # c = 114514
          # print(a, b)
          4 LOAD_GLOBAL              0 (0)  # push global_obj co_names[0] == "print"
          6 LOAD_FAST                0 (0)  # push a
          8 LOAD_FAST                1 (1)  # push b --> 这个在最顶端
         10 CALL_FUNCTION            2      # 其中最右边的参数在最顶端，即从左往右push；区别于C式栈，从右往左push
         12 POP_TOP                         # 不要返回值，直接弹掉
          # ============================魔改部分==========================================
          # print(a, b)
          4 LOAD_GLOBAL              0 (0)  # push global_obj co_names[0] == "print"
          6 LOAD_FAST                0 (0)  # push a
          8 LOAD_FAST                1 (1)  # push b --> 这个在最顶端
         10 CALL_FUNCTION            2      # 其中最右边的参数在最顶端，即从左往右push；区别于C式栈，从右往左push
         12 POP_TOP                         # 不要返回值，直接弹掉
          # =============================================================================
          # print(args)
         14 LOAD_GLOBAL              0 (0)  # push global_obj co_names[0] == "print"
         16 LOAD_FAST                2 (2)  # push args
         18 CALL_FUNCTION            1
         20 POP_TOP
        
          # return None
         22 LOAD_CONST               0 (0)  # push None
         24 RETURN_VALUE

#flag可以是一些计算的结果
#或者是隐藏在某处的预置常量
#也可以是某次函数调用的返回值
if flag is condition:
    normal_processing()
else
    useless_but_complicated_obfuscating_code()
    or_even_invalid_code()

try:
    some_processing()
    raise_exeception = __import__('module_does_not_exist')
    #上面的调用将抛出一个'ImportError'的意外，控制流将转向except分支
    useless_but_complicated_obfuscating_code()
except:
    continue_normal_processing()

try:
    some_processing()
    raise_exeception = __import__('sys').non_exist_function()
    #上面的调用将抛出一个'AttributeError'的意外，控制流将转向except分支
    useless_but_complicated_obfuscating_code()
except:
    continue_normal_processing()

try:
    some_processing()
    raise_exeception = 1/0
    #上面的语句将抛出一个'ZeroDivisionError'的意外，控制流将转向except分支
    useless_but_complicated_obfuscating_code()
except:
    continue_normal_processing()

import marshal, zlib, base64

f = open('hello.pyc', 'rb')
f.seek(16)
co = marshal.load(f)
f.close()
cs = marshal.dumps(co)

messed_code = base64.b64encode(zlib.compress(cs))

"""
b'eJx7zIAEmIDYAYiLeYBEKkMKQzMjI0MKYzCDJlMVt0dqTk6+Qnh+UU6KnybjLdaCosy8kpUMRSBNYKKKSy8mA6RIr6DyFodNbn5KaU6qHSNQ5jPIcADnBhab'
"""

import marshal, zlib, base64
messed_code = b'eJx7zIAEmIDYAYiLeYBEKkMKQzMjI0MKYzCDJlMVt0dqTk6+Qnh+UU6KnybjLdaCosy8kpUMRSBNYKKKSy8mA6RIr6DyFodNbn5KaU6qHSNQ5jPIcADnBhab'

exec(marshal.loads(zlib.decompress(base64.b64decode(messed_code))))

import sys
import dis
import rhstestobfus3

def mytrace(frame, why, arg):
    print(frame, why, arg)
    # print( "Trace", frame, why, arg)
    return mytrace

sys.settrace(mytrace)
rhstestobfus3.func(1,2)

sys.gettrace()

def func(a):
    if a == 1:
        print("a")
    else:
        print("b")
        
func(1)

def dis(x=None, *, file=None, depth=None):
    """Disassemble classes, methods, functions, and other compiled objects.

    With no argument, disassemble the last traceback.

    Compiled objects currently include generator objects, async generator
    objects, and coroutine objects, all of which store their code object
    in a special attribute.
    """
    # 无参则返回上一次的traceback
    if x is None:
        distb(file=file)
        return
    # 对象内方法
    """
    >>> class A:
    ...     def foo(self):
    ...             pass
    ...     bar = foo
    ...
    
    c = A()
    hasattr(c.foo, "__func__") # True
	"""
    if hasattr(x, '__func__'):
        x = x.__func__
    # Extract compiled code objects from...
    # 函数
    if hasattr(x, '__code__'):  # ...a function, or
        x = x.__code__
    elif hasattr(x, 'gi_code'):  #...a generator object, or
        x = x.gi_code
    elif hasattr(x, 'ag_code'):  #...an asynchronous generator object, or
        x = x.ag_code
    elif hasattr(x, 'cr_code'):  #...a coroutine.
        x = x.cr_code
    # Perform the disassembly.
    # 类会有__dict__属性，会列举出类内的所有对应成员。
    if hasattr(x, '__dict__'):  # Class or module
        items = sorted(x.__dict__.items())
        for name, x1 in items:
            if isinstance(x1, _have_code):
                print("Disassembly of %s:" % name, file=file)
                try:
                    dis(x1, file=file, depth=depth)
                except TypeError as msg:
                    print("Sorry:", msg, file=file)
                print(file=file)
    # __code__对象
    elif hasattr(x, 'co_code'): # Code object
        _disassemble_recursive(x, file=file, depth=depth)
    # 字节码对象
    elif isinstance(x, (bytes, bytearray)): # Raw bytecode
        _disassemble_bytes(x, file=file)
    # 源码字符串
    elif isinstance(x, str):    # Source code
        _disassemble_str(x, file=file, depth=depth)
    else:
        raise TypeError("don't know how to disassemble %s objects" %
                        type(x).__name__)
        
        
def _disassemble_recursive(co, *, file=None, depth=None):
    disassemble(co, file=file)	# __code__
    if depth is None or depth > 0:
        if depth is not None:
            depth = depth - 1
        for x in co.co_consts:
            if hasattr(x, 'co_code'):
                print(file=file)
                print("Disassembly of %r:" % (x,), file=file)
                _disassemble_recursive(x, file=file, depth=depth)
                
def disassemble(co, lasti=-1, *, file=None):
    """Disassemble a code object."""
    cell_names = co.co_cellvars + co.co_freevars
    linestarts = dict(findlinestarts(co))
    # 还是调用到这个，解码co_code
    _disassemble_bytes(co.co_code, lasti, co.co_varnames, co.co_names,
                       co.co_consts, cell_names, linestarts, file=file)
    
def _disassemble_bytes(code, lasti=-1, varnames=None, names=None,
                       constants=None, cells=None, linestarts=None,
                       *, file=None, line_offset=0):
    # Omit the line number column entirely if we have no line number info
    show_lineno = bool(linestarts)
    if show_lineno:
        maxlineno = max(linestarts.values()) + line_offset
        if maxlineno >= 1000:
            lineno_width = len(str(maxlineno))
        else:
            lineno_width = 3
    else:
        lineno_width = 0
    maxoffset = len(code) - 2
    if maxoffset >= 10000:
        offset_width = len(str(maxoffset))
    else:
        offset_width = 4
    # _get_instructions_bytes遍历字节码，返回元组
    for instr in _get_instructions_bytes(code, varnames, names,
                                         constants, cells, linestarts,
                                         line_offset=line_offset):
        new_source_line = (show_lineno and
                           instr.starts_line is not None and
                           instr.offset > 0)
        if new_source_line:
            print(file=file)
        is_current_instr = instr.offset == lasti
        print(instr._disassemble(lineno_width, is_current_instr, offset_width),
              file=file)

# 用yield生成一个Instruction()对象的生成器
# 核心逻辑
def _get_instructions_bytes(code, varnames=None, names=None, constants=None,
                      cells=None, linestarts=None, line_offset=0):
    """Iterate over the instructions in a bytecode string.

    Generates a sequence of Instruction namedtuples giving the details of each
    opcode.  Additional information about the code's runtime environment
    (e.g. variable names, constants) can be specified using optional
    arguments.

    """
    labels = findlabels(code)
    starts_line = None
    for offset, op, arg in _unpack_opargs(code):
        if linestarts is not None:
            starts_line = linestarts.get(offset, None)
            if starts_line is not None:
                starts_line += line_offset
        is_jump_target = offset in labels
        argval = None
        argrepr = ''
        if arg is not None:
            #  Set argval to the dereferenced value of the argument when
            #  available, and argrepr to the string representation of argval.
            #    _disassemble_bytes needs the string repr of the
            #    raw name index for LOAD_GLOBAL, LOAD_CONST, etc.
            argval = arg
            if op in hasconst:
                argval, argrepr = _get_const_info(arg, constants)
            elif op in hasname:
                argval, argrepr = _get_name_info(arg, names)
            elif op in hasjabs:
                argval = arg*2
                argrepr = "to " + repr(argval)
            elif op in hasjrel:
                argval = offset + 2 + arg*2
                argrepr = "to " + repr(argval)
            elif op in haslocal:
                argval, argrepr = _get_name_info(arg, varnames)
            elif op in hascompare:
                argval = cmp_op[arg]
                argrepr = argval
            elif op in hasfree:
                argval, argrepr = _get_name_info(arg, cells)
            elif op == FORMAT_VALUE:
                argval, argrepr = FORMAT_VALUE_CONVERTERS[arg & 0x3]
                argval = (argval, bool(arg & 0x4))
                if argval[1]:
                    if argrepr:
                        argrepr += ', '
                    argrepr += 'with format'
            elif op == MAKE_FUNCTION:
                argrepr = ', '.join(s for i, s in enumerate(MAKE_FUNCTION_FLAGS)
                                    if arg & (1<<i))
        yield Instruction(opname[op], op,
                          arg, argval, argrepr,
                          offset, starts_line, is_jump_target)
# 这个主要是格式化打印
class Instruction():
    	# ...
        def _disassemble(self, lineno_width=3, mark_as_current=False, offset_width=4):
        """Format instruction details for inclusion in disassembly output

        *lineno_width* sets the width of the line number field (0 omits it)
        *mark_as_current* inserts a '-->' marker arrow as part of the line
        *offset_width* sets the width of the instruction offset field
        """
        fields = []
        # Column: Source code line number
        if lineno_width:
            if self.starts_line is not None:
                lineno_fmt = "%%%dd" % lineno_width
                fields.append(lineno_fmt % self.starts_line)
            else:
                fields.append(' ' * lineno_width)
        # Column: Current instruction indicator
        if mark_as_current:
            fields.append('-->')
        else:
            fields.append('   ')
        # Column: Jump target marker
        if self.is_jump_target:
            fields.append('>>')
        else:
            fields.append('  ')
        # Column: Instruction offset from start of code sequence
        fields.append(repr(self.offset).rjust(offset_width))
        # Column: Opcode name
        fields.append(self.opname.ljust(_OPNAME_WIDTH))
        # Column: Opcode argument
        if self.arg is not None:
            fields.append(repr(self.arg).rjust(_OPARG_WIDTH))
            # Column: Opcode argument details
            if self.argrepr:
                fields.append('(' + self.argrepr + ')')
        return ' '.join(fields).rstrip()

class SampleClass:
    def __init__(self):
        self.data = None

    def method1SampleClass(self, arg):
        self.data = arg

def function_with_if(arg):
    if arg == True:
        pass
    else:
        pass

def function_with_if1(arg=True):
    if arg == True:
        print('True')
    else:
        print('False')

def function_with_if2():
    if True:
        print('True')
    else:
        print('False')

def function_with_try_except1():
    try:
        data = 1/0
    except:
        print('Constructed Control Flow')

def function_with_try_except2():
    try:
        pass
        print('Constructed Control Flow')
    except:
        pass

global_var1, global_var2, global_var3
pass

a = SampleClass()
a.method1SampleClass()
function_with_if(False)
function_with_if1()
del global_var1, global_var2, global_var3

class N:
y=None
T=True
H=False
 def __init__(P):
  P.data=y
 def b(P,R):
  P.data=R
def x(R):
 if R==T:
  pass
 else:
  pass
def L(arg=T):
 if arg==T:
  print('True')
 else:
  print('False')
def I():
 if T:
  print('True')
 else:
  print('False')
def d():
 try:
  n=1/0
 except:
  print('Constructed Control Flow')
def E():
 try:
  pass
  print('Constructed Control Flow')
 except:
  pass
global_var1,global_var2,global_var3
pass
a=N()
a.method1SampleClass()
x(H)
L()
del global_var1,global_var2,global_var3
# Created by pyminifier (https://github.com/liftoff/pyminifier)