# from `ELF RELA Relocation Table`
base = 0
table = [
    (0x55DB00, 0x549504),
    (0x55DB08, 0x5495B4),
    (0x55DB10, 0x549D08),
    (0x55DB20, 0x549490),
    (0x55DB28, 0x54949C),
    (0x55DE30, 0x55F5B0),
    (0x55DE68, 0x55F5A8),
    (0x55DE70, 0x55E008),
    (0x55DEA0, 0x553A88),
    (0x55DEB0, 0x557268),
    (0x55DEC0, 0x55F550),
    (0x55DED0, 0x54B288),
    (0x55DEE0, 0x55F5C0),
    (0x55DF10, 0x55E130),
    (0x55DF60, 0x55723C),
    (0x55DF78, 0x55FA30),
    (0x55DF90, 0x55FB88),
    (0x55DFB0, 0x55FB50),
    (0x55DFC0, 0x54AFE0),
    (0x55DFD0, 0x55F5B8),
    (0x55DFD8, 0x54B070),
    (0x55DFE0, 0x55F9E0),
    (0x55F5B0, 0x63BF68),
    (0x55F5B8, 0),
]

def main():
    import utils_ida
    for old, new in table:
        print(f"patch {hex(old)} -> {hex(base + new)}")
        utils_ida.DelItem(old, 8)
        utils_ida.CreateQword(old)
        utils_ida.Patch(old, (base + new).to_bytes(8, 'little'))
        utils_ida.SetType(old, "void (*)(void)")

if __name__ == "__main__":
    main()

def fix_dynstr():
    key = 0x56312342
    start = int('00000000005BA5E8', 16)
    end = int('000000000063BBBC', 16)

    utils_ida.DelItem(start, end - start)
    b = utils_ida.GetBytesFromEA(start, end - start)
    print(f"patch {hex(start)} -> {hex(end)}, length: {len(b)}")
    assert len(b) % 4 == 0, "length must be multiple of 4"
    
    new_b = bytearray()
    for i in range(0, len(b) // 4):
        v = int.from_bytes(b[i*4:i*4+4], 'little')
        new_v = v ^ (key & 0xFFFFFFFF)
        key = (key + i * 4) & 0xFFFFFFFF
        new_b += new_v.to_bytes(4, 'little')
    utils_ida.Patch(start, new_b)

def fix_dynsym():
    start = int('000000000055FD38', 16)
    end = int('00000000005A68F8', 16) # dynsym 结束与 HASH 表之前

    b = utils_ida.GetBytesFromEA(start, end - start)
    
    assert len(b) % 0x18 == 0, "length must be multiple of 0x18"
    
    new_b = bytearray()
    the_start = 0
    for i in range(0, len(b) // 0x18):
        st_name, st_info, st_other, st_shndx, st_value, st_size = struct.unpack('<IBBHQQ', b[i * 0x18: (i + 1) * 0x18])

        # skip external symbol
        if st_shndx != 0:
            if the_start == 0:
                the_start = i

            assert the_start == 58, "the_start must be 58"
            st_value ^= (the_start + 0x151) & 0xFFFFFFFFFFFFFFFF
            st_size ^= (the_start + 0x15B) & 0xFFFFFFFFFFFFFFFF
        new_b += struct.pack('<IBBHQQ', st_name, st_info, st_other, st_shndx, st_value, st_size)
    utils_ida.Patch(start, new_b)

if __name__ == "__main__":
    fix_dynstr()
    fix_dynsym()

"""Decode and patch the packed ELF for the current flags=3 sample."""

import struct
import zlib

import ida_bytes
import ida_kernwin

MAIN_VA = 0x190
MAIN_SIZE = 0x5062E0
META_VA = 0x63C020
META_SIZE = 0x6CC18
PHNUM = 6
PHENTSIZE = 0x38
PT_LOAD = 1

def u32(data: bytes | bytearray, offset: int) -> int:
    return struct.unpack_from("<I", data, offset)[0]

def put_u32(data: bytearray, offset: int, value: int) -> None:
    struct.pack_into("<I", data, offset, value & 0xFFFFFFFF)

def calc_payload_seed(data: bytes) -> int:
    table = []
    polynomial = 0x53B20C96
    for index in range(256):
        value = index
        for _ in range(8):
            value = ((value >> 1) ^ polynomial) if value & 1 else value >> 1
            value &= 0xFFFFFFFF
        table.append(value)

    current = 0xFFFFFFFF
    for value in data:
        current = table[(value ^ (current & 0xFF)) & 0xFF] ^ (current >> 8)
        current = (current + 16) & 0xFFFFFFFF
    return (-current - 516327184) & 0xFFFFFFFF

def rc4_variant_xor(data: bytearray, key_u32: int) -> None:
    state = list(range(256))
    key = struct.pack("<I", key_u32 & 0xFFFFFFFF)
    state_index = 0
    for index in range(256):
        old_value = state[index]
        state_index = (key[index & 3] + old_value + state_index) & 0xFF
        state[index] = state[state_index]
        state[state_index] = old_value

    index = 0
    state_index = 0
    for position in range(len(data)):
        index = (index + 1) & 0xFF
        old_value = state[index]
        state_index = (old_value + state_index) & 0xFF
        state[index] = state[state_index]
        state[state_index] = old_value
        stream_value = state[(old_value + state[index]) & 0xFF]
        mask = (((stream_value >> 2) | (stream_value << 6)) + 0x3A) & 0xFF
        data[position] ^= mask

def core_decode(src: bytes) -> bytearray:
    decode_len = len(src)
    output = bytearray(src)
    seed_input = struct.pack(
        "<IIIII",
        u32(output, 0x0C),
        u32(output, 0x04),
        u32(output, 0x30),
        decode_len,
        u32(output, 0x08),
    )
    seed_main = calc_payload_seed(seed_input)
    head_mask = bytes([0xD7]) * 0x40
    body_length = decode_len - 0x40

    if body_length <= 0x7F:
        body = bytearray(output[0x40:decode_len])
        rc4_variant_xor(body, seed_main)
        output[0x40:decode_len] = body
        for index in range(0x40):
            output[index] ^= head_mask[index]
        return output

    saved_block = bytearray(output[0x40:0xC0])
    first_block = bytearray(saved_block)
    rc4_variant_xor(first_block, seed_main)
    output[0x40:0xC0] = first_block

    key0 = ((seed_main ^ u32(output, 0x34)) + 8217) & 0xFFFFFFFF
    key2 = ((seed_main ^ decode_len) + 8213) & 0xFFFFFFFF
    key1 = ((seed_main ^ u32(output, 0x3C)) + 6502) & 0xFFFFFFFF
    key3 = ((seed_main ^ u32(output, 0x38)) + 6534) & 0xFFFFFFFF
    key4 = [key0, key1, key2, key3]

    for index in range(0x40):
        output[index] ^= head_mask[index]
    rc4_variant_xor(saved_block, key2)

    block_count = (decode_len - 0xC0) >> 7
    range1_begin = (decode_len - 0xC0) >> 9
    range1_end = range1_begin << 1
    range3_begin = range1_end + range1_begin
    schedule = [21605, key3, 17477, 1383, key0, key1, 309, key2, 26740]
    saved_words = [u32(saved_block, index * 4) for index in range(32)]

    for block_index in range(block_count):
        block_offset = 0xC0 + block_index * 0x80
        words = [u32(output, block_offset + index * 4) for index in range(32)]
        mode = schedule[block_index % 9] & 3
        if mode == 0:
            if range1_end <= block_index <= range3_begin:
                words = [word ^ 0xB2 for word in words]
            else:
                words = [word ^ saved_words[i] ^ key4[saved_words[i] & 3] for i, word in enumerate(words)]
        elif mode == 1:
            if range1_begin <= block_index <= range1_end:
                words = [word ^ 0xA1 for word in words]
            else:
                words = [word ^ saved_words[i] ^ (32 - i) ^ schedule[i % 9] for i, word in enumerate(words)]
        elif mode == 2:
            words = [word ^ saved_words[i] ^ i ^ key4[schedule[i % 9] & 3] for i, word in enumerate(words)]
        else:
            if block_index >= range3_begin:
                words = [word ^ 0xC3 for word in words]
            else:
                words = [word ^ saved_words[i] ^ i ^ key4[saved_words[i] & 3] for i, word in enumerate(words)]

        for index, word in enumerate(words):
            put_u32(output, block_offset + index * 4, word)

    tail_length = (decode_len + 0x40) & 0x7F
    if tail_length:
        tail_offset = decode_len - tail_length
        for index in range(tail_length):
            position = tail_offset + index
            schedule_value = schedule[key4[index & 3] % 9]
            output[position] ^= ((schedule_value % 0xFF) ^ saved_block[index] ^ index) & 0xFF
    return output

def parse_load_segments(decoded_meta: bytes):
    for index in range(PHNUM):
        phdr = struct.unpack_from("<IIQQQQQQ", decoded_meta, index * PHENTSIZE)
        p_type, _, p_offset, p_vaddr, _, p_filesz, p_memsz, _ = phdr
        if p_type == PT_LOAD:
            yield p_offset, p_vaddr, p_filesz, p_memsz

def patch_load_segments(final_image: bytes, decoded_meta: bytes) -> None:
    for p_offset, p_vaddr, p_filesz, p_memsz in parse_load_segments(decoded_meta):
        skip = 0x190 if p_offset == 0 else 0
        source_begin = p_offset + skip
        source_end = p_offset + p_filesz
        ida_bytes.patch_bytes(
            p_vaddr + skip,
            final_image[source_begin:source_end],
        )
        if p_memsz > p_filesz:
            ida_bytes.patch_bytes(
                p_vaddr + p_filesz,
                bytes(p_memsz - p_filesz),
            )
        print(
            f"PT_LOAD final[0x{source_begin:X}:0x{source_end:X}] "
            f"-> VA 0x{p_vaddr + skip:X}"
        )

def main() -> None:
    decoded_meta = core_decode(ida_bytes.get_bytes(META_VA, META_SIZE))
    decoded_main = core_decode(ida_bytes.get_bytes(MAIN_VA, MAIN_SIZE))

    unpacked_size, compressed_size = struct.unpack_from("<II", decoded_main)
    final_image = zlib.decompress(decoded_main[8:8 + compressed_size])
    assert len(final_image) == unpacked_size

    # The first six decoded metadata records are Elf64_Phdr entries.
    patch_load_segments(final_image, decoded_meta)
    ida_kernwin.refresh_idaview_anyway()
    print(f"unpacked 0x{len(final_image):X} bytes")

if __name__ == "__main__":
    main()

import json
import struct
from pathlib import Path

import ida_bytes
import ida_name
import ida_nalt
import ida_segment

DYNSYM_START = 0x63C170
DYNSTR_START = 0x5BA5E8
RELA_START = 0x63CE90
RELA_END = 0x6A8B78

ELF64_SYM_SIZE = 0x18
ELF64_RELA_SIZE = 0x18

R_AARCH64_ABS64 = 1025
R_AARCH64_JUMP_SLOT = 1026
R_AARCH64_RELATIVE = 1027

VALID_RELOCATION_TYPES = {R_AARCH64_ABS64, R_AARCH64_JUMP_SLOT, R_AARCH64_RELATIVE}
MAX_SYMBOL_COUNT = 0x1000
MAX_RELOCATION_OFFSET = 0x700000

RELOCATION_NAMES = {
    R_AARCH64_ABS64: "R_AARCH64_ABS64",
    R_AARCH64_JUMP_SLOT: "R_AARCH64_JUMP_SLOT",
    R_AARCH64_RELATIVE: "R_AARCH64_RELATIVE",
}

def read_bytes(address, size):
    data = ida_bytes.get_bytes(address, size)
    if data is None or len(data) != size:
        raise RuntimeError(f"无法读取 IDA 地址 0x{address:X} 的 0x{size:X} 字节")
    return data

def read_c_string(address):
    data = ida_bytes.get_strlit_contents(address, -1, 0)
    if data is None:
        return ""
    return data.decode("utf-8", errors="replace")

def parse_symbol(index):
    address = DYNSYM_START + index * ELF64_SYM_SIZE
    st_name, st_info, st_other, st_shndx, st_value, st_size = struct.unpack(
        "<IBBHQQ", read_bytes(address, ELF64_SYM_SIZE)
    )
    return {
        "index": index,
        "address": address,
        "name_offset": st_name,
        "name": read_c_string(DYNSTR_START + st_name) if st_name else "",
        "info": st_info,
        "other": st_other,
        "section_index": st_shndx,
        "value": st_value,
        "size": st_size,
    }

def validate_decrypted_tables():
    symbol_zero = read_bytes(DYNSYM_START, ELF64_SYM_SIZE)
    if symbol_zero != b"\x00" * ELF64_SYM_SIZE:
        raise RuntimeError(
            "0x63C170 处不是有效的 Elf64_Sym[0]，动态符号表可能尚未解密；"
            "请先完成 private relocation 解密"
        )

    first_relocation = struct.unpack("<QQq", read_bytes(RELA_START, ELF64_RELA_SIZE))
    first_type = first_relocation[1] & 0xFFFFFFFF
    first_symbol = first_relocation[1] >> 32
    if (
        first_type not in VALID_RELOCATION_TYPES
        or first_symbol >= MAX_SYMBOL_COUNT
        or first_relocation[0] >= MAX_RELOCATION_OFFSET
    ):
        raise RuntimeError(
            "0x63CE90 处不是有效的 Elf64_Rela；请确认 IDA 中的地址是否正确，"
            "并确保已经加载解密后的 unidbg dump 文件"
        )

def parse_relocations():
    validate_decrypted_tables()
    count = (RELA_END - RELA_START) // ELF64_RELA_SIZE
    raw_relocations = []
    maximum_symbol_index = 0

    for index in range(count):
        address = RELA_START + index * ELF64_RELA_SIZE
        offset, info, addend = struct.unpack(
            "<QQq", read_bytes(address, ELF64_RELA_SIZE)
        )
        symbol_index = info >> 32
        relocation_type = info & 0xFFFFFFFF
        if relocation_type not in VALID_RELOCATION_TYPES:
            raise RuntimeError(
                f"重定位项 #{index} @ 0x{address:X} 类型无效: {relocation_type}"
            )
        if symbol_index >= MAX_SYMBOL_COUNT:
            raise RuntimeError(
                f"重定位项 #{index} @ 0x{address:X} 符号索引越界: {symbol_index}"
            )
        if offset >= MAX_RELOCATION_OFFSET:
            raise RuntimeError(
                f"重定位项 #{index} @ 0x{address:X} 偏移地址越界: 0x{offset:X}"
            )

        maximum_symbol_index = max(maximum_symbol_index, symbol_index)
        raw_relocations.append(
            {
                "index": index,
                "address": address,
                "offset": offset,
                "info": info,
                "symbol_index": symbol_index,
                "type": relocation_type,
                "type_name": RELOCATION_NAMES.get(
                    relocation_type, f"UNKNOWN_{relocation_type}"
                ),
                "addend": addend,
            }
        )

    symbols = [parse_symbol(index) for index in range(maximum_symbol_index + 1)]

    for relocation in raw_relocations:
        symbol_index = relocation["symbol_index"]
        symbol = symbols[symbol_index] if symbol_index < len(symbols) else None
        relocation["symbol_name"] = symbol["name"] if symbol else ""
        relocation["symbol_value"] = symbol["value"] if symbol else 0

        if relocation["type"] == R_AARCH64_RELATIVE:
            relocation["resolved_value"] = relocation["addend"]
        elif relocation["type"] == R_AARCH64_ABS64 and symbol:
            relocation["resolved_value"] = symbol["value"] + relocation["addend"]
        else:
            relocation["resolved_value"] = None

        resolved_value = relocation["resolved_value"]
        relocation["resolved_name"] = (
            ida_name.get_name(resolved_value) if resolved_value is not None else ""
        )

    return symbols, raw_relocations

def sanitize_name(name):
    result = []
    for character in name:
        if character.isalnum() or character == "_":
            result.append(character)
        else:
            result.append("_")
    return "".join(result).strip("_")

def apply_relocations(relocations):
    patched = 0
    unchanged = 0
    named_jump_slots = 0
    skipped = 0

    for relocation in relocations:
        target_address = relocation["offset"]
        resolved_value = relocation["resolved_value"]
        relocation_type = relocation["type"]

        if relocation_type in (R_AARCH64_RELATIVE, R_AARCH64_ABS64):
            if resolved_value is None or ida_segment.getseg(target_address) is None:
                skipped += 1
                continue

            current_value = struct.unpack("<Q", read_bytes(target_address, 8))[0]
            patch_value = resolved_value & 0xFFFFFFFFFFFFFFFF
            if current_value == patch_value:
                unchanged += 1
            elif ida_bytes.patch_qword(target_address, patch_value):
                patched += 1
            else:
                skipped += 1
            continue

        if relocation_type == R_AARCH64_JUMP_SLOT:
            symbol_name = relocation["symbol_name"]
            if not symbol_name or ida_segment.getseg(target_address) is None:
                skipped += 1
                continue
            got_name = "got_" + sanitize_name(symbol_name)
            if ida_name.set_name(target_address, got_name, ida_name.SN_FORCE):
                named_jump_slots += 1
            else:
                skipped += 1
            continue

        skipped += 1

    return {
        "patched": patched,
        "unchanged": unchanged,
        "named_jump_slots": named_jump_slots,
        "skipped": skipped,
    }

def format_hex(value):
    if value is None:
        return "-"
    if value < 0:
        return f"-0x{-value:X}"
    return f"0x{value:X}"

def write_outputs(symbols, relocations):
    idb_path = Path(ida_nalt.get_input_file_path())
    output_directory = idb_path.parent
    json_path = output_directory / "private-relocations.json"
    text_path = output_directory / "private-relocations.txt"

    result = {
        "dynsym_start": DYNSYM_START,
        "dynstr_start": DYNSTR_START,
        "rela_start": RELA_START,
        "rela_end": RELA_END,
        "symbol_count": len(symbols),
        "relocation_count": len(relocations),
        "symbols": symbols,
        "relocations": relocations,
    }
    json_path.write_text(json.dumps(result, ensure_ascii=False, indent=2), encoding="utf-8")

    lines = [
        f"dynsym: 0x{DYNSYM_START:X}",
        f"dynstr: 0x{DYNSTR_START:X}",
        f"rela:   [0x{RELA_START:X}, 0x{RELA_END:X})",
        f"symbols: {len(symbols)}",
        f"relocations: {len(relocations)}",
        "",
        "index  relocation  offset      type                     symbol                         addend       resolved",
    ]
    for relocation in relocations:
        symbol_name = relocation["symbol_name"] or "-"
        resolved = format_hex(relocation["resolved_value"])
        if relocation["resolved_name"]:
            resolved += f" ({relocation['resolved_name']})"
        lines.append(
            f"{relocation['index']:5d}  "
            f"0x{relocation['address']:08X}  "
            f"0x{relocation['offset']:08X}  "
            f"{relocation['type_name']:<24} "
            f"{symbol_name:<30} "
            f"{format_hex(relocation['addend']):<12} "
            f"{resolved}"
        )
    text_path.write_text("\n".join(lines) + "\n", encoding="utf-8")
    return json_path, text_path

def main():
    symbols, relocations = parse_relocations()
    patch_result = apply_relocations(relocations)
    json_path, text_path = write_outputs(symbols, relocations)

    type_counts = {}
    for relocation in relocations:
        type_name = relocation["type_name"]
        type_counts[type_name] = type_counts.get(type_name, 0) + 1

    print(f"解析符号数量: {len(symbols)}")
    print(f"解析重定位数量: {len(relocations)}")
    for type_name, count in sorted(type_counts.items()):
        print(f"{type_name}: {count}")

    print(f"实际写入补丁: {patch_result['patched']}")
    print(f"原值已经正确: {patch_result['unchanged']}")
    print(f"命名外部 GOT: {patch_result['named_jump_slots']}")
    print(f"跳过项目: {patch_result['skipped']}")

    for relocation in relocations:
        if relocation["offset"] == 0x533D50:
            print("0x533D50:", relocation)
            break

    print(f"JSON: {json_path}")
    print(f"文本: {text_path}")

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Minimal fixed-value PoC for:
1. submit zip password -> /api/v3/sync/ads
2. query zip password  -> /api/v3/search/info

Usage:
    python min_zip_password_poc.py submit "a.zip" "123456"
    python min_zip_password_poc.py query  "a.zip"
"""

import argparse
import base64
import hashlib
import hmac
import json
import os
from pathlib import Path

import requests
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad

REGION = "CN"

PACKAGE_NAME = "com.fileunzip.zxwknight"
VERSION_NAME = "3.2.23"
APP_ID = "zipa"
PLATFORM = "android"
CTX_VALUE = 516622220

QUERY_URL = "https://file.unisapps.com/api/v3/search/info"
SUBMIT_URL = "https://file.unisapps.com/api/v3/sync/ads"

ACCESS_KEY = b"gwFG#9P!ad+*PMUnisapps$Rs#L!_1G9"
AES_KEY = b"EyR2JvBXJXaUdY9auxetvhpEeQ8DmC6L"

def file_md5(path: Path) -> str:
    md5 = hashlib.md5()
    with path.open("rb") as fp:
        for chunk in iter(lambda: fp.read(1024 * 1024), b""):
            md5.update(chunk)
    return md5.hexdigest()

def build_user_client_access(file_name: str, file_size: int) -> str:
    tail = 2 * ((CTX_VALUE >> 2) - 169) + 127
    text = f"{CTX_VALUE}{PACKAGE_NAME}{file_name}{file_size}{tail}".encode("utf-8")
    digest = hmac.new(ACCESS_KEY, text, hashlib.sha1).digest()
    return base64.b64encode(digest).decode("ascii")

def encrypt_json(obj: dict) -> str:
    plain = json.dumps(obj, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
    iv = os.urandom(16)
    cipher = AES.new(AES_KEY, AES.MODE_CBC, iv)
    data = cipher.encrypt(pad(plain, AES.block_size))
    body = {
        "data": base64.b64encode(data).decode("ascii"),
        "iv": base64.b64encode(iv).decode("ascii"),
    }
    return json.dumps(body, ensure_ascii=False, separators=(",", ":"))

def try_decrypt_response(text: str) -> str | None:
    try:
        obj = json.loads(text)
        data = base64.b64decode(obj["data"])
        iv = base64.b64decode(obj["iv"])
    except Exception:
        return None

    cipher = AES.new(AES_KEY, AES.MODE_CBC, iv)
    try:
        plain = unpad(cipher.decrypt(data), AES.block_size)
    except Exception:
        return None
    return plain.decode("utf-8", errors="replace")

def submit_password(file_name: str, file_size: int, md5_value: str, password: str) -> None:
    body = encrypt_json(
        {
            "fileName": file_name,
            "fileSize": file_size,
            "pd": password,
            "region": REGION,
            "md5": md5_value,
        }
    )
    headers = {
        "Content-Type": "application/json; charset=utf-8",
        "appid": APP_ID,
        "version": VERSION_NAME,
        "platform": PLATFORM,
    }
    resp = requests.post(SUBMIT_URL, data=body.encode("utf-8"), headers=headers, timeout=20)
    print("[submit] status =", resp.status_code)
    print("[submit] body   =", resp.text)

def query_password(file_name: str, file_size: int, md5_value: str) -> None:
    body = encrypt_json(
        {
            "fileName": file_name,
            "fileSize": file_size,
            "md5": md5_value,
        }
    )
    headers = {
        "Content-Type": "application/json; charset=utf-8",
        "User-Client-Access": build_user_client_access(file_name, file_size),
        "appid": APP_ID,
        "version": VERSION_NAME,
        "platform": PLATFORM,
    }
    resp = requests.post(QUERY_URL, data=body.encode("utf-8"), headers=headers, timeout=20)
    print("[query]  status =", resp.status_code)
    print("[query]  body   =", resp.text)

    plain = try_decrypt_response(resp.text)
    if plain is not None:
        print("[query]  decrypted =", plain)

def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Minimal zip password submit/query PoC")
    parser.add_argument("action", choices=["submit", "query"])
    parser.add_argument("path", help="local archive path")
    parser.add_argument("password", nargs="?", help="required for submit")
    args = parser.parse_args()
    if args.action == "submit" and not args.password:
        parser.error("password is required for submit")
    return args

def main() -> None:
    args = parse_args()
    file_path = Path(args.path)
    if not file_path.is_file():
        raise SystemExit(f"file not found: {file_path}")

    file_name = file_path.name
    file_size = file_path.stat().st_size
    md5_value = file_md5(file_path)

    print("fileName =", file_name)
    print("fileSize =", file_size)
    print("md5      =", md5_value)

    if args.action == "submit":
        submit_password(file_name, file_size, md5_value, args.password)
    if args.action == "query":
        query_password(file_name, file_size, md5_value)

if __name__ == "__main__":
    main()