MalwareBazaar Sample #1

#extract rsrc
data = open("unknown.exe", "rb").read();
open("pkg.bin", "wb").write(data[0x48E00:0x48E00 + 0xD52476]);

struct PyAPI {
  void *pad0[2];
  void (__fastcall *Py_DecRef)(void *);
  void *pad1[28];
  void *(__fastcall *PyImport_ImportModule)(const char *);
  /* ... */
};

struct TOC {
  uint32_t structlen;  // +0   длина всей записи
  uint32_t pos;        // +4   смещение данных
  uint32_t len;        // +8   сжатый размер
  uint32_t ulen;       // +12  распакованный размер
  char     cflag;      // +16  сжато ли
  char     typcd;      // +17  тип
  char     name[1];    // +18  имя, до конца записи
};

*(_QWORD *)Buffer = 0xE0B0A0B0D49454Di64;

#extract payload
"""
cookie is at the end of the archive, TOC is at the offset (cookie related). + big endian 

  python3 pkg_parse.py pkg.bin              # листинг
  python3 pkg_parse.py pkg.bin -x out/      # extraction
"""

import argparse
import os
import struct
import sys
import zlib

COOKIE_21 = 88          # 8 magic + 4*4 + 64 pylibname (PyInstaller 2.1+)
COOKIE_20 = 24          # older versions

TYPE_NAMES = {
    b"a": "ARCHIVE (nested)",
    b"b": "BINARY (.dll/.pyd)",
    b"d": "DEPENDENCY",
    b"l": "SPLASH",
    b"m": "PYMODULE",
    b"M": "PYPACKAGE",
    b"o": "RUNTIME_OPTION",
    b"s": "PYSOURCE  <-- точка входа",
    b"x": "DATA",
    b"z": "PYZ",
    b"Z": "PYZ (uncompressed)",
}

# magic word -> версия, для восстановления заголовков pyc
PYC_MAGIC = {
    3394: "3.7", 3413: "3.8", 3425: "3.9", 3439: "3.10",
    3495: "3.11", 3531: "3.12", 3571: "3.13", 3600: "3.14",
}


def read_cookie(data):
    """returns (magic, pkg_len, toc_pos, toc_len, pyvers, pylib)"""
    for size in (COOKIE_21, COOKIE_20):
        if len(data) < size:
            continue
        blob = data[-size:]
        if size == COOKIE_21:
            magic, pkg_len, toc_pos, toc_len, pyvers, pylib = struct.unpack(
                "!8sIIII64s", blob)
            pylib = pylib.rstrip(b"\x00").decode("ascii", "replace")
        else:
            magic, pkg_len, toc_pos, toc_len, pyvers = struct.unpack(
                "!8sIIII", blob)
            pylib = ""
        # sanity check вместо проверки magic\
        if 0 < toc_pos < len(data) and 0 < toc_len <= len(data) - toc_pos:
            return magic, pkg_len, toc_pos, toc_len, pyvers, pylib
    return None


def parse_toc(data, toc_pos, toc_len):
    entries = []
    off = toc_pos
    end = toc_pos + toc_len
    while off < end:
        (structlen,) = struct.unpack("!I", data[off:off + 4])
        if structlen < 18 or off + structlen > end:
            print("[!] bad TOC entry на %#x (structlen=%d)" % (off, structlen),
                  file=sys.stderr)
            break
        pos, dlen, ulen = struct.unpack("!III", data[off + 4:off + 16])
        cflag = data[off + 16]
        typcd = data[off + 17:off + 18]
        name = data[off + 18:off + structlen].rstrip(b"\x00")
        entries.append({
            "pos": pos, "len": dlen, "ulen": ulen,
            "cflag": cflag, "type": typcd,
            "name": name.decode("utf-8", "replace"),
        })
        off += structlen
    return entries


def get_data(data, e):
    raw = data[e["pos"]:e["pos"] + e["len"]]
    if e["cflag"]:
        try:
            raw = zlib.decompress(raw)
        except zlib.error as err:
            print("[!] couldnt unpack %s (%s)" % (e["name"], err),
                  file=sys.stderr)
            return None
    return raw


def sniff_pyc_magic(data, entries):
    """retrieve magic word питона из заголовка PYZ"""
    for e in entries:
        if e["type"] in (b"z", b"Z"):
            blob = get_data(data, e)
            if blob and blob[:4] == b"PYZ\x00":
                return blob[4:8]
    return None


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("archive")
    ap.add_argument("-x", "--extract", metavar="DIR")
    args = ap.parse_args()

    data = open(args.archive, "rb").read()
    ck = read_cookie(data)
    if not ck:
        sys.exit("куки нет; оверлей вырезан не целиком?")

    magic, pkg_len, toc_pos, toc_len, pyvers, pylib = ck
    print("MAGIC:      %s  (%s)" % (
        magic.hex(" "),
        "дефолт" if magic == b"MEI\x0c\x0b\x0a\x0b\x0e" else "ИЗМЕНеН"))
    print("размер:     %d (файл %d)" % (pkg_len, len(data)))
    print("TOC:        offset %#x, len %d" % (toc_pos, toc_len))
    print("pyvers:     %d  -> Python %d.%d" % (pyvers, pyvers // 100, pyvers % 100))
    print("pylib:      %s" % pylib)

    entries = parse_toc(data, toc_pos, toc_len)
    print("\nзаписей в TOC: %d" % len(entries))

    pyc_magic = sniff_pyc_magic(data, entries)
    if pyc_magic:
        mw = struct.unpack("<H", pyc_magic[:2])[0]
        print("pyc magic:  %s  -> Python %s"
              % (pyc_magic.hex(" "), PYC_MAGIC.get(mw, "неизвестно (%d)" % mw)))

    # сначала то, что определяет дальнейшую работу
    print("\n=== важное ===")
    for e in entries:
        if e["type"] in (b"s", b"z", b"Z", b"o"):
            print("  [%s] %-45s %8d -> %8d  %s"
                  % (e["type"].decode(), e["name"], e["len"], e["ulen"],
                     TYPE_NAMES.get(e["type"], "?")))

    # сводка по типам
    print("\n=== типы ===")
    counts = {}
    for e in entries:
        counts[e["type"]] = counts.get(e["type"], 0) + 1
    for t, n in sorted(counts.items()):
        print("  %s  %-24s %d" % (t.decode(), TYPE_NAMES.get(t, "?"), n))

    # модули верхнего уровня - по ним видно, что за софт
    mods = sorted({e["name"].split(".")[0] for e in entries
                   if e["type"] in (b"m", b"M")})
    if mods:
        print("\n=== МОДУЛИ (верхний уровень, %d) ===" % len(mods))
        for i in range(0, len(mods), 4):
            print("  " + "  ".join("%-22s" % m for m in mods[i:i + 4]))

    if not args.extract:
        return

    outdir = args.extract
    os.makedirs(outdir, exist_ok=True)
    hdr = None
    if pyc_magic:
        # 3.7+ : magic(4) + flags(4) + timestamp(4) + size(4)
        hdr = pyc_magic + b"\x00" * 12

    written = 0
    for e in entries:
        blob = get_data(data, e)
        if blob is None:
            continue
        name = e["name"].replace("\\", "/").lstrip("/")
        if e["type"] in (b"m", b"M", b"s"):
            name = name.replace(".", "/") + ".pyc"
            if hdr and blob[:4] != pyc_magic:
                blob = hdr + blob
        path = os.path.join(outdir, name)
        os.makedirs(os.path.dirname(path) or outdir, exist_ok=True)
        with open(path, "wb") as f:
            f.write(blob)
        written += 1

    print("\nизвлечено: %d -> %s" % (written, outdir))

if __name__ == "__main__":
    main()

python xor_solve.py --pool data_p002/* -o decrypted/

#!/usr/bin/env python3
"""
xor_solve.py — восстановление ключа повторяющегося XOR без известного открытого текста.

1) Байты ключа по колонкам: перебираем 256 вариантов и берём тот, при котором
колонка больше похожа на осмысленные данные. Гипотезы две — «доминирует
текст» и «доминирует 0x00» (UTF-16, бинарные форматы). Выбор между ними
по сигнатурам в расшифрованном результате

2)Проверка: сигнатуры, доля печатаемых, начало файла

Если файлы зашифрованы одним ключом, искать надёжнее по всем сразу (--pool):
на маленьком файле статистики не хватает.

    python3 xor_solve.py --pool data_p002/*
    python3 xor_solve.py file1 file2
    python3 xor_solve.py -k zSItEBKDC2TD -o out/ data_p002/*
"""

import argparse
import collections
import math
import os

FREQ = {}
for ch in b' etaoinshrdlucmfwypvbgkjqxz':
    FREQ[ch] = 5
for ch in b'ETAOINSHRDLUCMFWYPVBGKJQXZ':
    FREQ[ch] = 3
for ch in b'0123456789':
    FREQ[ch] = 3
for ch in b'.,;:()[]{}<>=+-*/_"\'\\|&!?#$%@^~`':
    FREQ[ch] = 2
for ch in b'\r\n\t':
    FREQ[ch] = 2

SIGNATURES = [
    (b'<?xml', 'XML'), (b'\xff\xfe', 'BOM UTF-16LE'), (b'\xef\xbb\xbf', 'BOM UTF-8'),
    (b'MZ', 'PE'), (b'var ', 'JavaScript'), (b'function', 'JavaScript'),
    (b'#!/', 'shebang'), (b'PK\x03\x04', 'ZIP'), (b'\x1f\x8b', 'gzip'),
    (b'{"', 'JSON'), (b'-----BEGIN', 'PEM'), (b'<html', 'HTML'),
]


def entropy(d):
    c = collections.Counter(d)
    n = len(d)
    return -sum((v / n) * math.log2(v / n) for v in c.values())


def xor(data, key):
    n = len(key)
    return bytes(b ^ key[i % n] for i, b in enumerate(data))


def printable_ratio(d):
    if not d:
        return 0.0
    return sum(1 for c in d if 32 <= c < 127 or c in (9, 10, 13)) / len(d)


def utf16_ratio(d):
    pairs = len(d) // 2
    if not pairs:
        return 0.0
    ok = sum(1 for i in range(pairs)
             if (32 <= d[2 * i] < 127 or d[2 * i] in (9, 10, 13)) and d[2 * i + 1] == 0)
    return ok / pairs


def find_signatures(d):
    head = d[:4096]
    return sorted({name for sig, name in SIGNATURES if sig in head})


def index_of_coincidence(data, period):
    total, used = 0.0, 0
    for i in range(period):
        col = data[i::period]
        if len(col) < 2:
            continue
        c = collections.Counter(col)
        n = len(col)
        total += sum(v * (v - 1) for v in c.values()) / (n * (n - 1))
        used += 1
    return total / used if used else 0.0


def guess_keylen(data, maxlen=64, verbose=True):
    scores = sorted(((index_of_coincidence(data, p), p) for p in range(1, maxlen + 1)),
                    reverse=True)
    if verbose:
        print('  топ периодов по IC:')
        for ic, p in scores[:6]:
            print('    p=%-3d IC=%.4f' % (p, ic))
    top = scores[0][0]
    good = sorted(p for ic, p in scores if ic > top * 0.85)
    best = good[0]
    if verbose and best != scores[0][1]:
        print('  пики на %s — кратные, базовый период %d'
              % (', '.join(map(str, good[:5])), best))
    return best


def collapse_key(key):
    n = len(key)
    for p in range(1, n):
        if n % p == 0 and key == key[:p] * (n // p):
            return key[:p]
    return key


def score_column(col, allow_null):
    s = 0
    for c in col:
        if c == 0:
            s += 5 if allow_null else -6
        elif 32 <= c < 127 or c in (9, 10, 13):
            s += FREQ.get(c, 1)
        else:
            s -= 6
    return s


def recover_key(data, klen, allow_null=False, verbose=True):
    key = bytearray()
    weak = []
    for i in range(klen):
        col = data[i::klen]
        sc = sorted(((score_column(bytes(c ^ k for c in col), allow_null), k)
                     for k in range(256)), reverse=True)
        key.append(sc[0][1])
        # отрыв лидера от второго места относительно разброса «лидер — медиана»:
        # так видно, действительно ли один вариант выделяется
        vals = [v for v, _ in sc]
        median = vals[len(vals) // 2]
        span = (sc[0][0] - median) or 1
        z = (sc[0][0] - sc[1][0]) / span
        if z < 0.01:
            weak.append(i)
        if verbose:
            ch = chr(sc[0][1]) if 32 <= sc[0][1] < 127 else '.'
            print('    колонка %-2d 0x%02x %-4s отрыв %.0f%%%s'
                  % (i, sc[0][1], repr(ch), z * 100, '  <- ненадёжно' if z < 0.01 else ''))
    if verbose and weak:
        print('    колонки со слабым отрывом: %s — проверь их по результату' % weak)
    return bytes(key)


def pick_hypothesis(data, klen, verbose=True):
    res = []
    for allow_null, label in ((False, 'доминирует текст'), (True, 'доминирует 0x00')):
        if verbose:
            print('\n  гипотеза: %s' % label)
        k = recover_key(data, klen, allow_null, verbose)
        dec = xor(data, k)
        sigs = find_signatures(dec)
        pr, ur = printable_ratio(dec), utf16_ratio(dec)
        score = len(sigs) * 10 + max(pr, ur)
        if verbose:
            print('    ключ %r' % k)
            print('    печатаемых %.1f%%, UTF-16 пар %.1f%%, сигнатуры: %s'
                  % (pr * 100, ur * 100, ', '.join(sigs) or '—'))
        res.append((score, k, label))
    res.sort(key=lambda r: -r[0])
    if verbose:
        print('\n  выбрана гипотеза: %s' % res[0][2])
    return res[0][1]


def report(name, data, key, outdir):
    dec = xor(data, key)
    print('\n  --- %s ---' % os.path.basename(name))
    print('    печатаемых %.1f%%, UTF-16 пар %.1f%%, сигнатуры: %s'
          % (printable_ratio(dec) * 100, utf16_ratio(dec) * 100,
             ', '.join(find_signatures(dec)) or '—'))
    print('    начало: %r' % dec[:70])
    if outdir:
        os.makedirs(outdir, exist_ok=True)
        out = os.path.join(outdir, os.path.basename(name) + '.dec')
        with open(out, 'wb') as f:
            f.write(dec)
        print('    -> %s' % out)


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument('files', nargs='+')
    ap.add_argument('-k', '--key')
    ap.add_argument('-o', '--outdir', default='decrypted')
    ap.add_argument('--pool', action='store_true',
                    help='один общий ключ по всем файлам сразу')
    ap.add_argument('--maxlen', type=int, default=64)
    args = ap.parse_args()

    blobs = [(f, open(f, 'rb').read()) for f in args.files]

    if args.key:
        key = (bytes.fromhex(args.key[2:]) if args.key.startswith('0x')
               else args.key.encode('latin-1'))
        print('ключ задан: %r' % key)
        for n, d in blobs:
            report(n, d, key, args.outdir)
        return

    if args.pool:
        biggest = max(blobs, key=lambda b: len(b[1]))[1]
        print('[0] период по самому большому файлу')
        klen = guess_keylen(biggest, args.maxlen)
        print('  период = %d' % klen)
        # обрезаем каждый файл по границе периода, иначе колонки съедут
        pool = b''.join(d[:len(d) - len(d) % klen] for _, d in blobs)
        print('\n[1] объединено файлов: %d, байт: %d' % (len(blobs), len(pool)))
        print('  энтропия %.3f, байт >= 0x80: %d'
              % (entropy(pool), sum(1 for b in pool if b & 0x80)))
        print('\n[2] уточнение периода на объединённых данных')
        klen = guess_keylen(pool, args.maxlen)
        print('  период = %d' % klen)
        print('\n[3] подбор байтов ключа')
        key = collapse_key(pick_hypothesis(pool, klen))
        print('\n[4] XOR key: %r  (длина %d, hex %s)'
              % (key, len(key), key.hex(' ')))
        for n, d in blobs:
            report(n, d, key, args.outdir)
        return

    for name, data in blobs:
        print('\n' + '=' * 68)
        print('%s  (%d байт)' % (os.path.basename(name), len(data)))
        print('=' * 68)
        H = entropy(data)
        hi = sum(1 for b in data if b & 0x80)
        print('\n[1] оценка')
        print('  энтропия %.3f/8.0, байт >= 0x80: %d (%.1f%%), уникальных %d'
              % (H, hi, hi / len(data) * 100, len(set(data))))
        if H > 7.9:
            print('  => почти максимум: сжатие или шифр, XOR не подойдёт')
            continue
        if hi == 0:
            print('  => старший бит нулевой везде: текст и ключ семибитные')
        if len(data) < 4096:
            print('  [!] файл мелкий, статистики мало — надёжнее через --pool')
        print('\n[2] длина ключа')
        klen = guess_keylen(data, args.maxlen)
        print('  период = %d' % klen)
        print('\n[3] байты ключа')
        key = collapse_key(pick_hypothesis(data, klen))
        print('\n[4] ключ: %r (hex %s)' % (key, key.hex(' ')))
        report(name, data, key, args.outdir)


if __name__ == '__main__':
    main()

<Task version="1.2">
  <Triggers>
    <TimeTrigger>
      <Repetition>
        <Interval>PT1M</Interval>
        <Duration>PT99998H58M</Duration>
      </Repetition>
      <StartBoundary>2025-06-01T01:01:01</StartBoundary>
    </TimeTrigger>
  </Triggers>
  <Principals>
    <Principal id="Author">
      <GroupId>S-1-5-4</GroupId>
      <RunLevel>LeastPrivilege</RunLevel>
    </Principal>
  </Principals>
  <Actions Context="Author">
    <Exec>
      <Command>C:\Windows\System32\wscript.exe</Command>
      <Arguments>C:\Users\Public\AccountPictures\%FOLD%\%NAME%.js</Arguments>
    </Exec>
  </Actions>
</Task>

var _0x59fbac = _0x2ca5;
(function (_0x4677d2, _0x270a57) {
  var _0x577bec = _0x2ca5, _0x2c679d = _0x4677d2();
  while (!![]) { try { /* арифметика с parseInt и проверка */ } catch (e) { ... } }
}(...));

#!/usr/bin/env python3
"""
deob_obfuscatorio.py — разворот массива строк obfuscator.io без выполнения кода.

Схема обфускатора: массив строковых литералов, поворот массива в IIFE
с проверкой контрольной суммы, доступ через функцию-индексатор _0xNNNN(0xIDX).

Содержимое массива лежит в файле открыто — поворот меняет только соответствие
индексов. Значит достаточно восстановить два параметра:

  base — смещение индекса (idx - base = позиция в массиве)
  rot  — величина поворота

base берётся из диапазона используемых индексов: если индексов ровно столько же,
сколько элементов, то base = min(индекс).

rot подбирается по ограничению — известному значению по известному индексу
(--anchor) либо по тому, что результат конкатенации обязан быть валидным
(--check-onion проверяет сборку onion-URL).

    python3 deob_obfuscatorio.py 002_n.js --check-onion
    python3 deob_obfuscatorio.py file.js --anchor 0xf6=yid.onion/
    python3 deob_obfuscatorio.py file.js --base 0xa0 --rot 161
"""

import argparse
import collections
import re
import sys

STR_RE = r"'((?:[^'\\]|\\.)*)'"


def unescape(x):
    x = re.sub(r'\\x([0-9a-fA-F]{2})', lambda m: chr(int(m.group(1), 16)), x)
    x = re.sub(r'\\u([0-9a-fA-F]{4})', lambda m: chr(int(m.group(1), 16)), x)
    return x.replace("\\'", "'").replace('\\"', '"').replace('\\\\', '\\')


def extract_array(src):
    """Самый длинный массив строковых литералов в файле."""
    best = None
    for m in re.finditer(r'\[((?:\s*' + STR_RE + r'\s*,?)+)\]', src):
        items = re.findall(STR_RE, m.group(1))
        if best is None or len(items) > len(best):
            best = items
    return [unescape(x) for x in best] if best else None


def decoder_name(src):
    calls = re.findall(r'(_0x[0-9a-fA-F]{4,8})\(\s*(0x[0-9a-fA-F]+)\s*\)', src)
    if not calls:
        return None, []
    name = collections.Counter(n for n, _ in calls).most_common(1)[0][0]
    idxs = sorted({int(v, 16) for n, v in calls if n == name})
    return name, idxs


def substitute(src, name, arr, base):
    def repl(m):
        j = int(m.group(1), 16) - base
        if not (0 <= j < len(arr)):
            return m.group(0)
        return "'" + arr[j].replace('\\', '\\\\').replace("'", "\\'") + "'"
    return re.sub(re.escape(name) + r'\(\s*(0x[0-9a-fA-F]+)\s*\)', repl, src)


def join_literals(src):
    prev = None
    while prev != src:
        prev = src
        src = re.sub(STR_RE + r"\s*\+\s*" + STR_RE,
                     lambda m: "'" + m.group(1) + m.group(2) + "'", src)
    return src


def onion_ok(text):
    return bool(re.search(r"http://[a-z2-7]{56}\.onion/", text))


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument('path')
    ap.add_argument('-o', '--out')
    ap.add_argument('--base', help='смещение индекса, напр. 0xa0')
    ap.add_argument('--rot', type=int, help='поворот массива')
    ap.add_argument('--anchor', action='append', default=[],
                    metavar='IDX=VALUE', help='известное значение, напр. 0xf6=yid.onion/')
    ap.add_argument('--check-onion', action='store_true',
                    help='считать верным поворот, дающий валидный onion-URL')
    args = ap.parse_args()

    src = open(args.path, encoding='utf-8', errors='replace').read()
    arr = extract_array(src)
    if not arr:
        sys.exit('массив строк не найден — возможно, другой вариант обфускатора')
    name, idxs = decoder_name(src)
    if not name:
        sys.exit('вызовы декодера не найдены')

    n = len(arr)
    print('массив: %d строк, декодер: %s, индексов: %d (%#x..%#x)'
          % (n, name, len(idxs), idxs[0], idxs[-1]))

    bases = ([int(args.base, 16)] if args.base
             else list(range(idxs[-1] - n + 1, idxs[0] + 1)))
    if len(bases) == 1:
        print('base = %#x' % bases[0])
    elif idxs[-1] - idxs[0] + 1 == n:
        bases = [idxs[0]]
        print('индексов ровно столько же, сколько элементов -> base = %#x' % bases[0])

    anchors = {}
    for a in args.anchor:
        k, v = a.split('=', 1)
        anchors[int(k, 16)] = v

    rots = [args.rot] if args.rot is not None else range(n)
    hits = []
    for base in bases:
        for rot in rots:
            r = arr[rot:] + arr[:rot]
            if any(not (0 <= i - base < n) or r[i - base] != v
                   for i, v in anchors.items()):
                continue
            out = substitute(src, name, r, base)
            out = join_literals(out)
            if args.check_onion and not onion_ok(out):
                continue
            hits.append((base, rot, out))

    if not hits:
        sys.exit('подходящих параметров не найдено — задай --anchor или --base/--rot')
    if len(hits) > 1 and not (args.rot is not None):
        print('[!] вариантов несколько (%d) — добавь --anchor для однозначности'
              % len(hits))

    base, rot, out = hits[0]
    print('принято: base=%#x rot=%d' % (base, rot))
    for u in sorted(set(re.findall(r'https?://[^\s\'"]{6,120}', out))):
        print('  URL: %s' % u)

    dst = args.out or (args.path + '.deob.js')
    open(dst, 'w', encoding='utf-8').write(out)
    print('записано: %s' % dst)


if __name__ == '__main__':
    main()