public abstract class ClassVisitor {
    public ClassVisitor(int api);
    public ClassVisitor(int api, ClassVisitor cv);
    public void visit(int version, int access, String name,String signature, String superName, String[] interfaces);
    public void visitSource(String source, String debug);
    public void visitOuterClass(String owner, String name, String desc);
    AnnotationVisitor visitAnnotation(String desc, boolean visible);
    public void visitAttribute(Attribute attr);
    public void visitInnerClass(String name, String outerName,String innerName, int access);
    public FieldVisitor visitField(int access, String name, String desc,String signature, Object value);
    public MethodVisitor visitMethod(int access, String name, String desc,String signature, String[] exceptions);
    void visitEnd();
}

apktool d APKs/xxx.apk -o dir

apktool d APKs/xxx.apk -o dir

.class public Lcom/social_touch/demo/MainActivity;.super Landroid/app/Activity;#指定MainActivity的父类.source "MainActivity.java"#源文件名称 #表明实现了View.OnClickListener接口# interfaces.implements Landroid/view/View$OnClickListener; #定义float静态字段pi# static fields.field private static final pi:F = 3.14f #定义了String类型字段TAG# instance fields.field private TAG:Ljava/lang/String; #定义了boolean类型的字段running.field public volatile running:Z #构造方法,如果你还纳闷这个方法是怎么出来的化,就去看看jvm的基础知识吧# direct methods.method public constructor <init>()V    .locals 1#表示函数中使用了一个局部变量     .prologue#表示方法中代码正式开始    .line 8#表示对应与java源文件的低8行    #调用Activity中的init()方法    invoke-direct {p0}, Landroid/app/Activity;-><init>()V     .line 10    const-string v0, "MainActivity"     iput-object v0, p0, Lcom/social_touch/demo/MainActivity;->TAG:Ljava/lang/String;     .line 13    const/4 v0, 0x0     iput-boolean v0, p0, Lcom/social_touch/demo/MainActivity;->running:Z     return-void.end method #静态方法log().method public static log(I)V    .locals 3    .parameter "result"#表示result参数     .prologue    .line 42    #v0寄存器中赋值为"MainActivity"    const-string v0, "MainActivity"    #创建StringBuilder对象,并将其引用赋值给v1寄存器    new-instance v1, Ljava/lang/StringBuilder;     #调用StringBuilder中的构造方法    invoke-direct {v1}, Ljava/lang/StringBuilder;-><init>()V     #v2寄存器中赋值为ther result:    const-string v2, "the result:"     #{v1,v2}大括号中v1寄存器中存储的是StringBuilder对象的引用.    #调用StringBuilder中的append(String str)方法,v2寄存器则是参数寄存器.    invoke-virtual {v1, v2}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;     #获取上一个方法的执行结果,此时v1中存储的是append()方法执行后的结果,此处之所以仍然返回v1的    #原因在与append()方法返回的就是自身的引用    move-result-object v1     #继续调用append方法(),p0表示第一个参数寄存器,即上面提到的result参数    invoke-virtual {v1, p0}, Ljava/lang/StringBuilder;->append(I)Ljava/lang/StringBuilder;     #同上    move-result-object v1     #调用StringBuilder对象的toString()方法    invoke-virtual {v1}, Ljava/lang/StringBuilder;->toString()Ljava/lang/String;     #获取上一个方法执行结果,toString()方法返回了一个新的String对象,因此v1中此时存储了String对象的引用    move-result-object v1     #调用Log类中的静态方法e().因为e()是静态方法,因此{v0,v1}中的成了参数寄存器    invoke-static {v0, v1}, Landroid/util/Log;->d(Ljava/lang/String;Ljava/lang/String;)I     .line 43    #调用返回指令,此处没有返回任何值    return-void.end method  # virtual methods.method public add(II)I    .locals 1    .parameter "x"#第一个参数    .parameter "y"#第二个参数     .prologue    .line 34     #调用add-int指令求和之后将结果赋值给v0寄存器    add-int v0, p1, p2     #返回v0寄存器中的值    return v0.end method  .method public onClick(Landroid/view/View;)V    .locals 4    .parameter "view" #参数view     .prologue    const/4 v3, 0x4 #v3寄存器中赋值为4     .line 23#java源文件中的第23行    const/4 v1, 0x5#v1寄存器中赋值为5     #调用add()方法    invoke-virtual {p0, v3, v1}, Lcom/social_touch/demo/MainActivity;->add(II)I     #从v0寄存器中获取add方法的执行结果    move-result v0     .line 24#java源文件中的24行    .local v0, result:I     #v1寄存器中赋值为PrintStream对象的引用out    sget-object v1, Ljava/lang/System;->out:Ljava/io/PrintStream;     #执行out对象的println()方法    invoke-virtual {v1, v0}, Ljava/io/PrintStream;->println(I)V     .line 26     const/16 v1, 0x9#v1寄存器中赋值为9    const/4 v2, 0x3#v2寄存器中赋值为3     #调用sub()方法,{p0,v1,v2},p0指的是this,即当前对象,v1,v2则是参数    invoke-virtual {p0, v1, v2}, Lcom/social_touch/demo/MainActivity;->sub(II)I    #从v0寄存器中获取sub()方法的执行结果    move-result v0     .line 28    if-le v0, v3, :cond_0#如果v0寄存器的值小于v3寄存器中的值,则跳转到cond_0处继续执行     .line 29     #调用静态方法log()    invoke-static {v0}, Lcom/social_touch/demo/MainActivity;->log(I)V     .line 31    :cond_0    return-void.end method .method protected onCreate(Landroid/os/Bundle;)V    .locals 1    .parameter "savedInstanceState" #参数savedInstancestate     .prologue    .line 17     #调用父类方法onCreate()    invoke-super {p0, p1}, Landroid/app/Activity;->onCreate(Landroid/os/Bundle;)V     .line 18     const v0, 0x7f04001a#v0寄存器赋值为0x7f04001a     #调用方法setContentView()    invoke-virtual {p0, v0}, Lcom/social_touch/demo/MainActivity;->setContentView(I)V     .line 19    return-void.end method #declared-synchronized表示该方法是同步方法.method public declared-synchronized sub(II)I    .locals 1    .parameter "x"    .parameter "y"     .prologue    .line 38     monitor-enter p0#为该方法添加锁对象p0     add-int v0, p1, p2    #释放锁对象    monitor-exit p0     return v0.end method

python3 obfuscapk/cli.py -p  -i -e --use-aapt2 \-o LibEncryption -o AssetEncryption -o CallIndirection -o ArithmeticBranch -o Goto -o FieldRename -o MethodRename  -o ClassRename \-o Rebuild -o NewAlignment \"$1" -d "$2" \--obfuscate-packages-file "$OBFUSCATE_PACKAGES_FILE"

def perform_obfuscation(    input_apk_path: str,    obfuscator_list: List[str],    working_dir_path: str = None,    obfuscated_apk_path: str = None,    extend_dex: bool = False,    ignore_libs: bool = False,    interactive: bool = False,    virus_total_api_key: str = None,    keystore_file: str = None,    keystore_password: str = None,    key_alias: str = None,    key_password: str = None,    ignore_packages_file: str = None,    obfuscate_packages_file: str = None,    use_aapt2: bool = False,):    check_external_tool_dependencies()     if not os.path.isfile(input_apk_path):        logger.critical('Unable to find application file "{0}"'.format(input_apk_path))        raise FileNotFoundError(            'Unable to find application file "{0}"'.format(input_apk_path)        )     obfuscation = Obfuscation(        input_apk_path,        working_dir_path,        obfuscated_apk_path,        extend_dex,        ignore_libs,        interactive,        virus_total_api_key,        keystore_file,        keystore_password,        key_alias,        key_password,        ignore_packages_file,        obfuscate_packages_file,        use_aapt2,    )     manager = ObfuscatorManager()    obfuscator_name_to_obfuscator_object = {        ob.name: ob.plugin_object for ob in manager.get_all_obfuscators()    }    obfuscator_name_to_function = {        ob.name: ob.plugin_object.obfuscate for ob in manager.get_all_obfuscators()    }    valid_obfuscators = manager.get_obfuscators_names()     # Check how many obfuscators in list will add new fields/methods.    for obfuscator_name in obfuscator_list:        # Make sure all the provided obfuscator names are valid.        if obfuscator_name not in valid_obfuscators:            raise ValueError(                'There is no obfuscator named "{0}"'.format(obfuscator_name)            )        if obfuscator_name_to_obfuscator_object[obfuscator_name].is_adding_fields:            obfuscation.obfuscators_adding_fields += 1        if obfuscator_name_to_obfuscator_object[obfuscator_name].is_adding_methods:            obfuscation.obfuscators_adding_methods += 1     obfuscator_progress = util.show_list_progress(        obfuscator_list,        interactive=interactive,        unit="obfuscator",        description="Running obfuscators",    )     try:        for obfuscator_name in obfuscator_progress:            try:                if interactive:                    obfuscator_progress.set_description(                        "Running obfuscators ({0})".format(obfuscator_name)                    )                (obfuscator_name_to_function[obfuscator_name])(obfuscation)            except Exception as e:                logger.critical("Error during obfuscation: {0}".format(e), exc_info=True)                raise    finally:        obfuscation.cleanup()

class IBaseObfuscator(ABC, IPlugin):    def __init__(self):        super().__init__()         self.is_adding_fields = False        self.is_adding_methods = False     @abstractmethod    def obfuscate(self, obfuscation_info: Obfuscation):        raise NotImplementedError()  class ITrivialObfuscator(IBaseObfuscator):    @abstractmethod    def obfuscate(self, obfuscation_info: Obfuscation):        raise NotImplementedError()  class IRenameObfuscator(IBaseObfuscator):    @abstractmethod    def obfuscate(self, obfuscation_info: Obfuscation):        raise NotImplementedError()  class IEncryptionObfuscator(IBaseObfuscator):    @abstractmethod    def obfuscate(self, obfuscation_info: Obfuscation):        raise NotImplementedError()  class ICodeObfuscator(IBaseObfuscator):    @abstractmethod    def obfuscate(self, obfuscation_info: Obfuscation):        raise NotImplementedError()  class IResourcesObfuscator(IBaseObfuscator):    @abstractmethod    def obfuscate(self, obfuscation_info: Obfuscation):        raise NotImplementedError()  class IOtherObfuscator(IBaseObfuscator):    @abstractmethod    def obfuscate(self, obfuscation_info: Obfuscation):        raise NotImplementedError()

class Obfuscation(object):    """    This class holds the details and the internal state of an obfuscation operation.    When obfuscating a new application, an instance of this class has to be instantiated    and passed to all the obfuscators (in sequence).    """     def __init__(        self,        apk_path: str,        working_dir_path: str = None,        obfuscated_apk_path: str = None,        extend_dex: bool = False,        ignore_libs: bool = False,        interactive: bool = False,        virus_total_api_key: str = None,        keystore_file: str = None,        keystore_password: str = None,        key_alias: str = None,        key_password: str = None,        ignore_packages_file: str = None,        obfuscate_packages_file: str = None,        use_aapt2: bool = False,    ):        self.logger = logging.getLogger(__name__)         self.apk_path: str = apk_path        self.working_dir_path: str = working_dir_path        self.obfuscated_apk_path: str = obfuscated_apk_path        self.extend_dex: bool = extend_dex        self.ignore_libs: bool = ignore_libs        self.interactive: bool = interactive        self.virus_total_api_key: str = virus_total_api_key        self.keystore_file: str = keystore_file        self.keystore_password: str = keystore_password        self.key_alias: str = key_alias        self.key_password: str = key_password        self.ignore_packages_file: str = ignore_packages_file        self.obfuscate_packages_file: str = obfuscate_packages_file        self.use_aapt2 = use_aapt2        if apk_path.endswith("aab"):            self.is_bundle = True        else:            self.is_bundle = False         # Random string (32 chars long) generation with ASCII letters and digits        self.encryption_secret = "".join(            secrets.choice(string.ascii_letters + string.digits) for _ in range(32)        )        self.logger.debug(            'Auto-generated random secret key for encryption: "{0}"'.format(                self.encryption_secret            )        )         # The list of obfuscators already used on the application.        self.used_obfuscators: List[str] = []         # How many obfuscators will add new fields/methods during this obfuscation        # operation.        self.obfuscators_adding_fields: int = 0        self.obfuscators_adding_methods: int = 0         # Flags indicating if certain files have already been added to the application        # during this obfuscation operation. This is used to avoid adding the files        # more than once (in that case the application rebuild wouldn't succeed).        self.decrypt_asset_smali_file_added_flag: bool = False        self.decrypt_string_smali_file_added_flag: bool = False         self._remaining_fields_per_obfuscator = None        self._remaining_methods_per_obfuscator = None         self._is_decoded: bool = False        self._decoded_apk_path: Union[str, None] = None        self._is_multidex: bool = False        self._manifest_file: Union[str, None] = None        self._smali_files: List[str] = []        self._multidex_smali_files: List[List[str]] = []  # A list for each dex file.        self._native_lib_files: List[str] = []         # Check if the apk file to obfuscate is a valid file.        if not os.path.isfile(self.apk_path):            self.logger.error('Unable to find file "{0}"'.format(self.apk_path))            raise FileNotFoundError('Unable to find file "{0}"'.format(self.apk_path))         # If no working directory is specified, use a temp directory to obfuscate.        if not self.working_dir_path:            working_root = os.path.join(tempfile.gettempdir(), "obfuscapk")            file_base = os.path.splitext(os.path.basename(self.apk_path))[0]            dir_name = "{0}_{1}".format(file_base, datetime.now().strftime("%Y-%m-%d_%H-%M-%S"))            self.working_dir_path = os.path.join(working_root, dir_name)             if not os.path.isdir(self.working_dir_path):                os.makedirs(self.working_dir_path)             self.logger.debug(                "No working directory provided, the operations will take place in the "                'same directory as the input file, in the directory "{0}"'.format(                    self.working_dir_path                )            )         if not os.path.isdir(self.working_dir_path):            try:                os.makedirs(self.working_dir_path, exist_ok=True)            except Exception as e:                self.logger.error(                    'Unable to create working directory "{0}": {1}'.format(                        self.working_dir_path, e                    )                )                raise         # If the path of the output obfuscated apk is not specified, save it in the        # working directory.        if not self.obfuscated_apk_path:            if self.is_bundle:                self.obfuscated_apk_path = "{0}_obfuscated.aab".format(                    os.path.join(                        self.working_dir_path,                        os.path.splitext(os.path.basename(self.apk_path))[0],                    )                )            else:                self.obfuscated_apk_path = "{0}_obfuscated.apk".format(                    os.path.join(                        self.working_dir_path,                        os.path.splitext(os.path.basename(self.apk_path))[0],                    )                )            self.logger.debug(                "No obfuscated apk path provided, the result will be saved "                'as "{0}"'.format(self.obfuscated_apk_path)

class Obfuscation(object):    """    This class holds the details and the internal state of an obfuscation operation.    When obfuscating a new application, an instance of this class has to be instantiated    and passed to all the obfuscators (in sequence).    """     def __init__(...):    def _get_total_fields(self) -> Union[int, List[int]]:    def _get_remaining_fields(self) -> Union[int, List[int]]:    def _get_total_methods(self) -> Union[int, List[int]]:    def _get_remaining_methods(self) -> Union[int, List[int]]:    def decode_apk(self) -> None:    def process_extend_dex(self):    def get_smali_root_directory(self, root_name:str, decode_apk_path: str) -> str:    def scan_smali_files(self, decode_apk_path:str) -> List[str]:    def filter_ignore_libs(self, smali_files: List[str], decode_apk_path:str)-> List[str]:    def check_is_multidex(self, decode_apk_path: str)-> bool:    def scan_multidex_smali_files(self, smali_files: List[str], decode_apk_path: str)-> List[List[str]]:    def insert_smali_file(self, name:str, content:str):    def get_remaining_fields_per_obfuscator(self) -> Union[int, List[int]]:    def get_remaining_methods_per_obfuscator(self) -> Union[int, List[int]]:    def build_obfuscated_apk(self) -> None:    def sign_obfuscated_apk(self) -> None:    def align_obfuscated_apk(self) -> None:    def is_multidex(self) -> bool:    def get_manifest_file(self) -> str:    def get_smali_files(self) -> List[str]:    def get_multidex_smali_files(self) -> List[List[str]]:    def get_native_lib_files(self) -> List[str]:    def get_assets_directory(self) -> str:    def get_resource_directory(self) -> str:    def get_ignore_package_names(self) -> List[str]:    def get_obfuscate_package_names(self) -> List[str]:    def cleanup(self):

com.github.kr329.clahh.commoncom.github.kr329.clahh.core

python3 obfuscapk/cli.py -p  -i -e --use-aapt2 \-o ClassRename \-o Rebuild -o NewAlignment \"/working/clahh/clahh.apk" \-d "/working/clahh/clahh-mod.apk" \--ignore-packages-file "/working/clahh/ignore_packages.txt" \--obfuscate-packages-file "/working/clahh/obfuscate_packages.txt"

#!/usr/bin/env python3 import loggingimport randomimport refrom typing import List from obfuscapk import obfuscator_categoryfrom obfuscapk import utilfrom obfuscapk.obfuscation import Obfuscation  class CodeBlock:    def __init__(self, jump_id=0, smali_code=""):        self.jump_id = jump_id        self.smali_code = smali_code     def add_smali_code_to_block(self, smali_code):        self.smali_code += smali_code  class Reorder(obfuscator_category.ICodeObfuscator):    def __init__(self):        self.logger = logging.getLogger(            "{0}.{1}".format(__name__, self.__class__.__name__)        )        super().__init__()         self.if_mapping = {            "if-eq": "if-ne",            "if-ne": "if-eq",            "if-lt": "if-ge",            "if-ge": "if-lt",            "if-gt": "if-le",            "if-le": "if-gt",            "if-eqz": "if-nez",            "if-nez": "if-eqz",            "if-ltz": "if-gez",            "if-gez": "if-ltz",            "if-gtz": "if-lez",            "if-lez": "if-gtz",        }     def obfuscate(self, obfuscation_info: Obfuscation):        self.logger.info('Running "{0}" obfuscator'.format(self.__class__.__name__))         try:            op_codes = util.get_code_block_valid_op_codes()            op_code_pattern = re.compile(r"\s+(?P<op_code>\S+)")            if_pattern = re.compile(                r"\s+(?P<if_op_code>\S+)"                r"\s(?P<register>[vp0-9,\s]+?),\s:(?P<goto_label>\S+)"            )             for smali_file in util.show_list_progress(                obfuscation_info.get_smali_files(),                interactive=obfuscation_info.interactive,                description="Code reordering",            ):                self.logger.debug('Reordering code in file "{0}"'.format(smali_file))                with util.inplace_edit_file(smali_file) as (in_file, out_file):                    editing_method = False                    inside_try_catch = False                    jump_count = 0                    for line in in_file:                        if (                            line.startswith(".method ")                            and " abstract " not in line                            and " native " not in line                            and not editing_method                        ):                            # If at the beginning of a non abstract/native method                            out_file.write(line)                            editing_method = True                            inside_try_catch = False                            jump_count = 0                         elif line.startswith(".end method") and editing_method:                            # If a the end of the method.                            out_file.write(line)                            editing_method = False                            inside_try_catch = False                         elif editing_method:                            # Inside method. Check if this line contains an op code at                            # the beginning of the string.                            match = op_code_pattern.match(line)                            if match:                                op_code = match.group("op_code")                                 # Check if we are entering or leaving a try-catch                                # block of code.                                if op_code.startswith(":try_start_"):                                    out_file.write(line)                                    inside_try_catch = True                                elif op_code.startswith(":try_end_"):                                    out_file.write(line)                                    inside_try_catch = False                                 # If this is a valid op code, and we are not inside a                                # try-catch block, mark this section with a special                                # label that will be used later and invert the if                                # conditions (if any).                                elif op_code in op_codes and not inside_try_catch:                                    jump_name = util.get_random_string(16)                                    out_file.write(                                        "\tgoto/32 :l_{label}_{count}\n\n".format(                                            label=jump_name, count=jump_count                                        )                                    )                                    out_file.write("\tnop\n\n")                                    out_file.write("#!code_block!#\n")                                    out_file.write(                                        "\t:l_{label}_{count}\n".format(                                            label=jump_name, count=jump_count                                        )                                    )                                    jump_count += 1                                     new_if = self.if_mapping.get(op_code, None)                                    if new_if:                                        if_match = if_pattern.match(line)                                        random_label_name = util.get_random_string(16)                                        out_file.write(                                            "\t{if_cond} {register}, "                                            ":gl_{new_label}\n\n".format(                                                if_cond=new_if,                                                register=if_match.group("register"),                                                new_label=random_label_name,                                            )                                        )                                        out_file.write(                                            "\tgoto/32 :{0}\n\n".format(                                                if_match.group("goto_label")                                            )                                        )                                        out_file.write(                                            "\t:gl_{0}".format(random_label_name)                                        )                                    else:                                        out_file.write(line)                                else:                                    out_file.write(line)                            else:                                out_file.write(line)                         else:                            out_file.write(line)                 # Reorder code blocks randomly.                with util.inplace_edit_file(smali_file) as (in_file, out_file):                    editing_method = False                    block_count = 0                    code_blocks: List[CodeBlock] = []                    current_code_block = None                    for line in in_file:                        if (                            line.startswith(".method ")                            and " abstract " not in line                            and " native " not in line                            and not editing_method                        ):                            # If at the beginning of a non abstract/native method                            out_file.write(line)                            editing_method = True                            block_count = 0                            code_blocks = []                            current_code_block = None                         elif line.startswith(".end method") and editing_method:                            # If a the end of the method.                            editing_method = False                            random.shuffle(code_blocks)                            for code_block in code_blocks:                                out_file.write(code_block.smali_code)                            out_file.write(line)                         elif editing_method:                            # Inside method. Check if this line is marked with                            # a special label.                            if line.startswith("#!code_block!#"):                                block_count += 1                                current_code_block = CodeBlock(block_count, "")                                code_blocks.append(current_code_block)                            else:                                if block_count > 0 and current_code_block:                                    current_code_block.add_smali_code_to_block(line)                                else:                                    out_file.write(line)                         else:                            out_file.write(line)         except Exception as e:            self.logger.error(                'Error during execution of "{0}" obfuscator: {1}'.format(                    self.__class__.__name__, e                )            )            raise         finally:            obfuscation_info.used_obfuscators.append(self.__class__.__name__)