51friend模块逆向分析

## 前言
闲来无事，你想看了一下一款微信密友插件，海王必用 ::Heo:傻笑:: 
## 请求分析
[hide]
打开httpcanary或者proxypin抓包看一下软件请求链接主要有如下三个：
```
/we/st/setup
/we/st/add
/we/st/stats
```
前两个都是明文请求，且试用卡过期仍然可以请求到数据，所以可以放一放。主要是第三个请求，请求体和返回数据均是加密的，一看主要验证就是在这里，不然加密干啥 ::Heo:抬眼镜:: ，既然加密了，我们就要具体去分析了。[/hide]
## 混淆对抗与字符串解密
[hide]
用mt管理器打开dex一看，类名及方法均被混淆过，没事直接使用mt管理器混淆对抗解决（只是让类名及方法名可读，帮助分析），再次打开尝试搜索任何字符串都没结果，随便打开一个方法看一下，字符串也被加密了，具体形式如下：：
```
const-string v9, "ZbOd+Q==\n"

const-string v10, "B+zCpmsL3XE=\n"

invoke-static {v9, v10}, Lcom/asdf51/friend/b;->a(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;

move-result-object v9
```
尝试使用mt管理器一键解密，发现没用，无法完成解密 ::Heo:痛哭:: ，那这样只有自己分析了，被迫开始啃代码。。。
通过跟进解密代码，可得到如下逻辑：b.a接受两个字符串参数调用cu.a转换为字节数组，然后传递给decrypt进行xor解密处理，多的不说，直接让deepseek帮我们写成python代码试一下：
```
import base64

def base64_decode(encoded_str):
    """Decode a Base64 encoded string."""
    return base64.b64decode(encoded_str)

def xor_decrypt(encrypted_bytes, key_bytes):
    """Decrypt bytes using XOR with the provided key."""
    decrypted_bytes = bytearray(len(encrypted_bytes))
    key_length = len(key_bytes)

for i in range(len(encrypted_bytes)):
        decrypted_bytes[i] = encrypted_bytes[i] ^ key_bytes[i % key_length]

return bytes(decrypted_bytes)

def decrypt_multiple(pairs):
    """Decrypt multiple pairs of encoded strings."""
    decrypted_texts = []
    for encoded_encrypted_str, encoded_key_str in pairs:
        # Decode the Base64 encoded strings
        encrypted_bytes = base64_decode(encoded_encrypted_str)
        key_bytes = base64_decode(encoded_key_str)

# Decrypt using XOR
        decrypted_bytes = xor_decrypt(encrypted_bytes, key_bytes)

# Convert to string using UTF-8 encoding and add to the list
        decrypted_texts.append(decrypted_bytes.decode('utf-8'))
    
    return decrypted_texts

# Example usage
pairs = [
    ("HA==\n", "LKjbg8qJRN8=\n"),
    ("xg==\n", "91RwdG4QxuM=\n"),
]

# Perform decryption for multiple pairs
decrypted_texts = decrypt_multiple(pairs)
for i, decrypted_text in enumerate(decrypted_texts):
    print(f"Decrypted text {i+1}: {decrypted_text}")
```
测试正常解密，但是dex里面加密的字符串万万千，不可能一个个都这样手动解密 ::Heo:纠结:: ，所以还是需要一个自动化的程序。当然也可以通过打log或者其他方法定位到关键代码处，选择性解密部分字符串，但还是全部解密更直观，更容易分析。最后得到代码如下：
```
import os
import re
import base64
import subprocess
import logging
from datetime import datetime

def setup_logger(dex_name):
    """分片日志记录器"""
    log_file = f"decrypt_{datetime.now().strftime('%Y%m%d-%H%M')}_{dex_name}.log"
    logger = logging.getLogger(dex_name)
    logger.setLevel(logging.DEBUG)

file_handler = logging.FileHandler(log_file, encoding='utf-8')
    file_formatter = logging.Formatter(
        '%(asctime)s [%(levelname)s] %(message)s',
        datefmt='%Y-%m-%d %H:%M:%S'
    )
    file_handler.setFormatter(file_formatter)

console_handler = logging.StreamHandler()
    console_handler.setLevel(logging.INFO)
    console_handler.setFormatter(logging.Formatter('>>  %(message)s'))

logger.addHandler(file_handler)
    logger.addHandler(console_handler)
    return logger

def base64_decode(encoded_str):
    """增强型Base64解码"""
    encoded_str = encoded_str.replace('\\n', '').replace('\n', '')
    missing_padding = len(encoded_str) % 4
    if missing_padding:
        encoded_str += '=' * (4 - missing_padding)
    try:
        return base64.b64decode(encoded_str)
    except Exception as e:
        raise ValueError(f"Base64解码失败: {str(e)}")

def xor_decrypt(encrypted_bytes, key_bytes):
    """高性能XOR解密"""
    key_len = len(key_bytes)
    return bytes([b ^ key_bytes[i % key_len] for i, b in enumerate(encrypted_bytes)])

def decrypt_pair(encrypted_b64, key_b64, logger):
    """带详细日志的解密入口"""
    logger.debug(f"解密参数: enc[{len(encrypted_b64)}]={encrypted_b64[:30]}..., key[{len(key_b64)}]={key_b64[:30]}...")
    try:
        encrypted = base64_decode(encrypted_b64)
        key = base64_decode(key_b64)
        decrypted = xor_decrypt(encrypted, key)
        return decrypted.decode('utf-8', errors='replace')
    except Exception as e:
        logger.error(f"解密失败: {str(e)}")
        return None

def process_smali_file(file_path, logger):
    with open(file_path, 'r', encoding='utf-8') as f:
        content = f.read()

pattern = re.compile(r'''
        ^(\s*)const-string(/jumbo)?\s+    
        ([vp]\d+),\s*"((?:\\"|[^"\n])+)"\s*\n
        (\s*)const-string(/jumbo)?\s+     
        ([vp]\d+),\s*"((?:\\"|[^"\n])+)"\s*\n
        (                                  
          (?:\s*(?:\.\w+.*?)?\s*\n)        
          (?:\s*(?:\.\w+.*?)?\s*\n)?       
        )
        (\s*)invoke-static\s+\{\s*
        ([vp]\d+),\s*([vp]\d+)\s*\},\s*   
        Lcom/asdf51/friend/Ԩ;->Ϳ\(Ljava/lang/String;Ljava/lang/String;\)Ljava/lang/String;\s*\n
        (\s*)move-result-object\s+([vp]\d+)\s*\n  
    ''', re.MULTILINE | re.VERBOSE)

modified = False

def replacer(match):
        nonlocal modified, logger
        groups = match.groups()
        (indent1, _, reg1, str1,
         indent2, _, reg2, str2,
         middle_code,
         invoke_indent, arg_reg1, arg_reg2,
         move_indent, target_reg) = groups

if {arg_reg1, arg_reg2} != {reg1, reg2}:
            return match.group(0)

encrypted_str = str1 if arg_reg1 == reg1 else str2
        key_str = str2 if arg_reg1 == reg1 else str1

decrypted = decrypt_pair(encrypted_str, key_str, logger)
        if not decrypted:
            return match.group(0)

def safe_escape(s, max_len=2000):
            replacements = [
                ('\\', r'\\'),   
                ('\t', r'\t'),  
                ('\n', r'\n'),  
                ('\r', r'\r'),   
                ('"', r'\"')    
            ]

for char, esc in replacements:
                s = s.replace(char, esc)
            
            escaped = []
            for c in s:
                code = ord(c)
                if code < 32 or code > 126: 
                    escaped.append(f'\\u{code:04x}')
                else:
                    escaped.append(c)
            s = ''.join(escaped)
            
            if len(s) > max_len:
                cut_pos = max_len
                for i in range(min(max_len-5, len(s)-6), max(0, max_len-10), -1):
                    if s.startswith('\\u', i) and len(s[i:]) >=6:
                        cut_pos = i + 6
                        break
                s = s[:cut_pos] + '...[TRUNCATED]'
                logger.warning(f"安全截断字符串（原始长度：{len(s)} → {cut_pos}）")
            
            return s

try:
            escaped = safe_escape(decrypted)
            new_code = f"{indent1}const-string {target_reg}, \"{escaped}\"\n"
            modified = True
            logger.info(f"替换成功 → {target_reg} = {escaped[:50]}...")
            return new_code

except Exception as e:
            logger.error(f"字符串处理失败：{str(e)}\n原始内容：{decrypted[:100]}")
            return match.group(0)

new_content = pattern.sub(replacer, content)
    if modified:
        with open(file_path, 'w', encoding='utf-8') as f:
            f.write(new_content)
        logger.info(f"文件更新完成: {os.path.basename(file_path)}")
    else:
        logger.debug(f"无匹配内容: {os.path.basename(file_path)}")

def process_dex(dex_path):
    """DEX处理主流程"""
    logger = setup_logger(os.path.basename(dex_path))
    logger.info(f"▌ 开始处理：{dex_path}")

try:
        temp_dir = f"temp_{os.path.basename(dex_path)}"
        os.makedirs(temp_dir, exist_ok=True)

logger.info("⏳ 正在反编译DEX...")
        subprocess.run(
            ['java', '-jar', 'd2j-dex2smali', 'disassemble', '-o', temp_dir, dex_path],
            check=True,
            stdout=subprocess.PIPE,
            stderr=subprocess.STDOUT
        )

processed_files = 0
        for root, _, files in os.walk(temp_dir):
            for file in files:
                if file.endswith('.smali'):
                    process_smali_file(os.path.join(root, file), logger)
                    processed_files += 1
        logger.info(f"✅ 已处理 {processed_files} 个smali文件")

output_dex = f"decrypted_{os.path.basename(dex_path)}"
        logger.info("⏳ 正在重新编译...")
        subprocess.run(
            ['java', '-jar', 'd2j-smali', 'assemble', '-o', output_dex, temp_dir],
            check=True
        )
        logger.info(f"🎉 最终输出：{output_dex}")

except subprocess.CalledProcessError as e:
        logger.error(f"子进程错误：{e.output.decode()}")
    except Exception as e:
        logger.error(f"处理失败：{str(e)}", exc_info=True)
    finally:
        logger.info("="*50 + "\n")

if __name__ == '__main__':
    for entry in os.listdir():
        if entry.endswith('.dex') and os.path.isfile(entry):
            process_dex(entry)
```
具体使用方法，将dex与程序代码放同一个文件夹，依次执行如下代码，最后会得到解密后的dex文件、解密后的smali文件和解密的具体log文件：
```
apt install openjdk-17-jdk
wget https://bitbucket.org/JesusFreke/smali/downloads/smali-2.5.2.jar
mv smali-2.5.2.jar d2j-smali
chmod +x d2j-smali
wget https://bitbucket.org/JesusFreke/smali/downloads/baksmali-2.5.2.jar
mv baksmali-2.5.2.jar d2j-dex2smali
chmod +x d2j-dex2smali
python3 decrypt.py
```
[/hide]
## 后记
先到这里，得到解密后的dex就容易分析多了,下次再写，这样就能水两篇了 ::Heo:狗头::

AI摘要：本文对一款微信密友插件的51friend模块进行了逆向分析，重点分析了其请求和加密机制。通过抓包发现主要请求有三个，其中一个请求的数据是加密的。使用mt管理器进行混淆对抗后，作者编写了Python代码实现了Base64解码和XOR解密，最终自动化处理了大量加密字符串，成功解密了DEX文件，便于后续分析。文章提供了详细的代码和使用方法。