Как определить, что файл зашифрован ransomware, и какой алгоритм использован — руководство для IR и форензики 2026

. При запуске ransomware генерирует:

   Session Key — симметричный ключ (AES-256 или ChaCha20)

   Этим ключом шифруется СОДЕРЖИМОЕ файлов (быстро)



2. Session Key шифруется:

   Public Key злоумышленника (RSA-2048/4096 или Curve25519)

   Зашифрованный Session Key сохраняется рядом с файлами

   или отправляется на C2-сервер



3. Оригинальный Session Key уничтожается в памяти



Результат: без приватного ключа злоумышленника — 

дешифрование вычислительно невозможно.

Артефакты схемы шифрования, которые можно обнаружить:



В зашифрованных файлах:

  - Зашифрованный симметричный ключ (если prepend/append к файлу)

  - IV (Initialization Vector) для AES-CBC / nonce для ChaCha20

  - Magic marker идентификации от некоторых семейств



В памяти процесса (при живом анализе):

  - Незашифрованный Session Key (до его уничтожения)

  - RSA Public Key (иногда встроен в бинарник)



На диске:

  - Временные ключевые файлы (некоторые семейства)

  - Реестровые ключи (некоторые семейства Windows)

Алгоритмы актуальных семейств (2025–2026):



LockBit 3.0:  AES-256 (файлы) + RSA-2048 (ключ)

BlackCat:     ChaCha20 (файлы) + RSA-4096 (ключ)

Akira:        ChaCha20 (файлы) + RSA (ключ)

Qilin.B:      AES-256-CTR или ChaCha20 + RSA-4096

Cloak:        HC-128 + Curve25519 + SHA512

GhostLocker:  AES-128-CBC (Fernet) + PKCS7 padding

Babuk/Gizm:   ChaCha20 + RSA

Примеры расширений по семействам:

  LockBit 3.0:     .lockbit, .abcd, или случайное (8 символов)

  BlackCat/ALPHV:  .alphv, случайное (5–8 символов hex)

  Akira:           .akira

  Cloak:           .cloak

  Qilin:           случайное расширение + .README.txt

  Ryuk:            .RYK

  REvil/Sodinokibi: случайное (5–10 символов)

  Conti:           .CONTI

  Phobos:          .[ID].[email].phobos

  STOP/Djvu:       .djvu, .djvus, .djvut, .nomad, .beast...

  Cuba:            .cuba

  Makop:           .makop

  Dharma:          .[ID].[email].dharma

Характерные имена файлов записок:

  LockBit 3.0:  Restore-My-Files.txt

  BlackCat:     RECOVER-[случайно]-FILES.txt

  Akira:        akira_readme.txt

  Conti:        CONTI_README.txt

  REvil:        [случайно]-readme.txt

  Ryuk:         RyukReadMe.txt

  Phobos:       info.hta, info.txt

  Dharma:       FILES ENCRYPTED.txt

  Cloak:        CLOAK_README.txt

  

Характерные расположения:

  - Корень каждой зашифрованной папки

  - Рабочий стол пользователя

  - Корень каждого диска (C:\, D:\...)

<h2 id="proverit-sledy-ransomware-v-reestre">Проверить следы ransomware в реестре:</h2>

<h2 id="nekotorye-semeystva-dobavlyayut-klyuchi-zapuska">Некоторые семейства добавляют ключи запуска:</h2>

Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Run"

Get-ItemProperty "HKCU:\SOFTWARE\Microsoft\Windows\CurrentVersion\Run"



<h2 id="sledy-izmeneniya-oboev">Следы изменения обоев:</h2>

Get-ItemProperty "HKCU:\Control Panel\Desktop" -Name Wallpaper

<h2 id="proverit-byli-li-udaleny-vss">Проверить, были ли удалены VSS:</h2>

Get-WmiObject Win32_ShadowCopy



<h2 id="esli-vyvod-pust-pri-vklyuchyonnoy-vss-udaleny">Если вывод пуст при включённой VSS — удалены</h2>

<h2 id="tipichnye-komandy-udaleniya-sled-v-event-log">Типичные команды удаления (след в Event Log):</h2>

<h2 id="vssadmin-delete-shadows-all-quiet">vssadmin delete shadows /all /quiet</h2>

<h2 id="wmic-shadowcopy-delete">wmic shadowcopy delete</h2>

<h2 id="bcdedit-set-default-recoveryenabled-no">bcdedit /set {default} recoveryenabled No</h2>

<h2 id="powershell-get-wmiobject-win32-shadowcopy-remove-wmiobject">PowerShell: Get-WmiObject Win32_ShadowCopy | Remove-WmiObject</h2>

<h2 id="poisk-v-event-log-komand-udaleniya-vss">Поиск в Event Log команд удаления VSS:</h2>

Get-WinEvent -FilterHashtable @{

    LogName='Security'; Id=4688

    StartTime=(Get-Date).AddDays(-7)

} | Where-Object {

    $_.Message -match "vssadmin|shadowcopy|bcdedit"

}

Типичные значения энтропии:

  Текстовый файл (.txt, .docx):        4.0–6.5

  Исполняемый файл (.exe, .dll):       5.5–7.0

  Сжатый файл (.zip, .gz):             7.5–8.0

  Зашифрованный файл:                  7.8–8.0

  Случайные данные:                    ~8.0

Правило интерпретации:



Энтропия 7.8–8.0:

  + расширение изменено → ВЫСОКАЯ вероятность шифрования

  + расширение сохранено → проверить magic bytes



Энтропия 7.5–7.8:

  → Возможно сжатый файл (ZIP, PDF с изображениями)

  → Проверить оригинальное расширение и magic bytes

  → Возможно интермиттирующее шифрование (частичное)



Энтропия < 7.0:

  → Маловероятно полное шифрование

  → Исключить: могло быть зашифровано частично

    (первые/последние N байт или каждый N-й блок)

import math

from collections import Counter



def shannon_entropy(data: bytes) -> float:

    """Вычислить энтропию Шеннона в битах на байт."""

    if not data:

        return 0.0

    counts = Counter(data)

    total = len(data)

    entropy = 0.0

    for count in counts.values():

        p = count / total

        entropy -= p * math.log2(p)

    return entropy



<h2 id="sravnenie">Сравнение:</h2>

with open("original.docx", "rb") as f:

    orig_data = f.read()

with open("suspicious.docx.encrypted", "rb") as f:

    susp_data = f.read()



print(f"Оригинал:       {shannon_entropy(orig_data):.3f} бит/байт")

print(f"Подозрительный: {shannon_entropy(susp_data):.3f} бит/байт")

<h2 id="original-6-21-bit-bayt">Оригинал:       6.21 бит/байт</h2>

<h2 id="podozritelnyy-7-97-bit-bayt-yavnyy-priznak-shifrovaniya">Подозрительный: 7.97 бит/байт → явный признак шифрования</h2>

def block_entropy_map(filepath: str, block_size: int = 512) -> list:

    """Вычислить энтропию для каждого блока файла."""

    results = []

    with open(filepath, "rb") as f:

        offset = 0

        while True:

            block = f.read(block_size)

            if not block:

                break

            ent = shannon_entropy(block)

            results.append((offset, ent))

            offset += len(block)

    return results



<h2 id="primer-vyvoda-blochnoy-karty">Пример вывода блочной карты:</h2>

<h2 id="offset-entropy">Offset    Entropy</h2>

<h2 id="0-6-21-originalnyy-zagolovok-ne-zashifrovan">0         6.21   ← оригинальный заголовок (не зашифрован)</h2>

<h2 id="512-7-98-zashifrovano">512       7.98   ← зашифровано</h2>

<h2 id="1024-7-97-zashifrovano">1024      7.97   ← зашифровано</h2>

<h2 id="1536-7-96-zashifrovano">1536      7.96   ← зашифровано</h2>

<h2 id="">...</h2>

<h2 id="50000-1-23-nulevye-bayty-padding-ne-zashifrovano">50000     1.23   ← нулевые байты (паддинг, не зашифровано)</h2>




<h2 id="pri-intermittiruyuschem-shifrovanii-pattern-budet-cheredovatsya">При интермиттирующем шифровании паттерн будет чередоваться:</h2>

<h2 id="0-6-21-ne-zashifrovano">0         6.21   ← не зашифровано</h2>

<h2 id="512-7-98-zashifrovano">512       7.98   ← зашифровано</h2>

<h2 id="1024-5-85-ne-zashifrovano-cheredovanie">1024      5.85   ← не зашифровано  ← чередование!</h2>

<h2 id="1536-7-96-zashifrovano">1536      7.96   ← зашифровано</h2>

Исходные magic bytes распространённых форматов:

  PDF:        25 4D 46 2D        (%PDF-)

  DOCX/XLSX:  50 4B 03 04        (PK — это ZIP)

  JPEG:       FF D8 FF           (ÿØÿ)

  PNG:        89 50 4E 47 0D 0A  (‰PNG\r\n)

  ZIP:        50 4B 03 04        (PK)

  EXE/DLL:    4D 5A              (MZ)

  MP4:        00 00 00 XX 66 74  (....ft)

<h2 id="proverka-cherez-xxd-linux-mac">Проверка через xxd (Linux/Mac):</h2>

xxd suspicious_document.pdf | head -4



<h2 id="ozhidaemyy-rezultat-dlya-neshifrovannogo-pdf">Ожидаемый результат для нешифрованного PDF:</h2>

<h2 id="00000000-2550-4446-2d31-2e34-0a25-c7ec-8fa2-0a35-pdf-1-4-5">00000000: 2550 4446 2d31 2e34 0a25 c7ec 8fa2 0a35  %PDF-1.4.%....5</h2>




<h2 id="rezultat-dlya-zashifrovannogo-fayla-s-sohranyonnym-rasshireniem-pdf">Результат для зашифрованного файла с сохранённым расширением .pdf:</h2>

<h2 id="00000000-a3f7-2b9e-14cc-8821-7e4d-33ab-00f2-6741-m3-ga">00000000: a3f7 2b9e 14cc 8821 7e4d 33ab 00f2 6741  ..+....!~M3...gA</h2>

<h2 id="magic-bytes-razrusheny-fayl-zashifrovan">Magic bytes разрушены → файл зашифрован</h2>

<h2 id="python-proverit-magic-bytes-fayla">Python: проверить magic bytes файла</h2>

MAGIC_SIGNATURES = {

    b'\x25\x50\x44\x46': 'PDF',

    b'\x50\x4B\x03\x04': 'ZIP/DOCX/XLSX',

    b'\xFF\xD8\xFF':      'JPEG',

    b'\x89\x50\x4E\x47': 'PNG',

    b'\x4D\x5A':          'PE (EXE/DLL)',

    b'\x37\x7A\xBC\xAF': '7-ZIP',

    b'\x1F\x8B':          'GZIP',

}



def check_magic(filepath: str) -> str:

    with open(filepath, 'rb') as f:

        header = f.read(8)

    for sig, name in MAGIC_SIGNATURES.items():

        if header.startswith(sig):

            return f"Соответствует: {name}"

    return "Неизвестная сигнатура — возможно зашифровано"



<h2 id="dopolnitelno-sravnit-rasshirenie-fayla-s-ego-realnym-tipom">Дополнительно: сравнить расширение файла с его реальным типом</h2>

import os

ext = os.path.splitext("document.pdf")[1].lower()

magic_result = check_magic("document.pdf")

if ext == '.pdf' and 'PDF' not in magic_result:

    print("НЕСООТВЕТСТВИЕ: файл имеет расширение .pdf, но не является PDF")

    print("Вероятно зашифрован ransomware")

3.0 добавляет заголовок в конец файла:

[зашифрованные данные][зашифрованный ключ 256 байт][маркер LB3]



Dharma prepend-заголовок (начало файла):

[magic marker 4 байта][зашифрованный ключ][зашифрованные данные]



STOP/Djvu заголовок:

[зашифрованные данные][уникальный ID жертвы 32 байта]

<h2 id="file-opredelenie-tipa-fayla-po-magic-bytes">file — определение типа файла по magic bytes:</h2>

file suspicious_document.pdf

<h2 id="suspicious-document-pdf-data-data-vmesto-pdf-net-magic-bytes">suspicious_document.pdf: data  ← «data» вместо PDF = нет magic bytes</h2>




<h2 id="xxd-hexdump-prosmotr-hex-dampa">xxd / hexdump — просмотр hex-дампа:</h2>

xxd suspicious.pdf | head -10

hexdump -C suspicious.pdf | head -10



<h2 id="python-magic-biblioteka">python-magic (библиотека):</h2>

pip install python-magic

python3 -c "import magic; print(magic.from_file('suspicious.pdf'))"



<h2 id="binwalk-poisk-vstroennyh-signatur-i-kastomnyh-markerov">binwalk — поиск встроенных сигнатур и кастомных маркеров:</h2>

binwalk suspicious.pdf

. Записку с выкупом (README.txt, RECOVER-*.txt и т.п.)

   → Обязательно, если есть



2. Зашифрованный файл

   → Необязательно, но повышает точность

   → Сервис анализирует: расширение, кастомный заголовок,

     размер файла, паттерн



3. Email из записки (если указан)

   → Некоторые семейства идентифицируются именно по email

Алгоритм работы с NoMoreRansom:

1. Перейти на nomoreransom.org → Crypto Sheriff

2. Загрузить 2 зашифрованных файла + записку

3. Сервис идентифицирует семейство и проверяет 

   наличие дешифратора в базе

4. Если дешифратор есть — скачать и применить

<h2 id="zagruzka-zapiski-s-vykupom-na-virustotal">Загрузка записки с выкупом на VirusTotal:</h2>

<h2 id="virustotal-com-zagruzit-fayl-readme-txt">virustotal.com → загрузить файл README.txt</h2>

<h2 id="rezultat-detektiruetsya-kak-semeystvo-x-mnogimi-av-dvizhkami">Результат: детектируется как семейство X многими AV-движками</h2>




<h2 id="cli-cherez-vt-cli">CLI через vt-cli:</h2>

pip install vt-cli

vt file scan README.txt

vt file report <sha256_of_sample>



<h2 id="poisk-po-heshu-obraztsa">Поиск по хэшу образца:</h2>

<h2 id="esli-obrazets-uzhe-proanalizirovan-naydyote-detalnyy-otchyot">Если образец уже проанализирован — найдёте детальный отчёт</h2>

<h2 id="s-identifikatsiey-semeystva-i-povedeniem">с идентификацией семейства и поведением</h2>

— публичный реестр известных Bitcoin-адресов из 

ransomware-записок. Если адрес из вашей записки там есть — 

семейство идентифицировано.



Emsisoft (emsisoft.com/ransomware-decryption-tools/) — 

официальные бесплатные дешифраторы от Emsisoft для 

конкретных семейств. Проверять при каждом инциденте.

<h2 id="ustanovka-yara">Установка YARA:</h2>

apt install yara          # Linux

brew install yara         # macOS

pip install yara-python   # Python-биндинг



<h2 id="bazovyy-zapusk">Базовый запуск:</h2>

yara rules.yar suspicious_file.exe



<h2 id="rekursivno-po-direktorii">Рекурсивно по директории:</h2>

yara -r rules.yar /infected_directory/



<h2 id="s-vyvodom-sovpadeniy-i-smescheniy">С выводом совпадений и смещений:</h2>

yara -s rules.yar suspicious.exe

<h2 id="repozitoriy-yara-pravil-florian-roth-neo23x0">Репозиторий YARA правил Florian Roth (Neo23x0):</h2>

git clone https://github.com/Neo23x0/signature-base

ls signature-base/yara/ | grep -i ransom



<h2 id="valhalla-yara-feed-besplatnyy-publichnyy">Valhalla YARA Feed (бесплатный публичный):</h2>

<h2 id="valhalla-nextron-systems-com">valhalla.nextron-systems.com</h2>




<h2 id="cert-gib-av-vendory-publikuyut-yara-v-blogah">CERT-GIB, AV-вендоры публикуют YARA в блогах:</h2>

<h2 id="github-com-elastic-detection-rules">github.com/elastic/detection-rules</h2>

<h2 id="github-com-mandiant-red-team-tool-countermeasures">github.com/mandiant/red_team_tool_countermeasures</h2>

// Пример: YARA-правило для LockBit 3.0

// Базируется на строках из записки и характерных импортах



rule Ransomware_LockBit3 {

    meta:

        description = "Detects LockBit 3.0 ransomware"

        author      = "Incident Response Team"

        date        = "2026-01-15"

        severity    = "critical"

        reference   = "https://malpedia.caad.fkie.fraunhofer.de/details/win.lockbit"



    strings:

        // Строки из типичной записки LockBit 3.0

        $note1 = "Restore-My-Files.txt" ascii nocase

        $note2 = "LockBit" ascii wide

        $note3 = "darknetspy" ascii nocase



        // Характерные API-вызовы в бинарнике

        $api1 = "CryptGenRandom" ascii

        $api2 = "CryptEncrypt" ascii

        $api3 = "vssadmin" ascii nocase



        // Маркер удаления теневых копий

        $vss1 = "delete shadows /all" ascii nocase wide

        $vss2 = "shadowcopy delete" ascii nocase wide



    condition:

        uint16(0) == 0x5A4D    // PE файл (MZ заголовок)

        and filesize < 5MB

        and (

            2 of ($note*)

            or (1 of ($note*) and 2 of ($api*))

            or (1 of ($vss*) and 1 of ($api*))

        )

}



// Правило для идентификации ЗАШИФРОВАННЫХ файлов LockBit

rule LockBit3_Encrypted_File {

    meta:

        description = "Encrypted file marker - LockBit 3.0"



    strings:

        // LockBit 3.0 appends marker to end of encrypted files

        // Точный маркер зависит от версии — уточнять по образцу

        $marker = { ?? ?? ?? ?? 6C 6F 63 6B 62 69 74 }  // "lockbit" в конце



    condition:

        $marker at (filesize - 16)

}

rule RansomNote_Generic_Extortion {

    meta:

        description = "Generic ransom note detection"



    strings:

        // Универсальные фразы из записок

        $bitcoin  = "bitcoin" ascii nocase

        $tor1     = ".onion" ascii

        $decrypt  = "decryption key" ascii nocase

        $pay1     = "ransom" ascii nocase

        $recover1 = "your files have been encrypted" ascii nocase wide

        $recover2 = "все ваши файлы зашифрованы" wide    // RU-таргетинг



    condition:

        (2 of ($bitcoin, $tor1, $decrypt, $pay1))

        or ($recover1 or $recover2)

}

<h2 id="izvlech-stroki-iz-obraztsa-bez-zapuska">Извлечь строки из образца (без запуска):</h2>

strings -a suspicious.exe | grep -iE "(aes|chacha|rsa|crypt|encrypt|rand)"



<h2 id="harakternye-stroki-po-algoritmam">Характерные строки по алгоритмам:</h2>

<h2 id="aes-aes-256-rijndael-cryptencrypt-bcryptencrypt">AES:     &quot;AES-256&quot;, &quot;Rijndael&quot;, &quot;CryptEncrypt&quot;, &quot;BCryptEncrypt&quot;</h2>

<h2 id="chacha20-chacha20-chacha-salsa20-rodstvennyy">ChaCha20: &quot;ChaCha20&quot;, &quot;ChaCha&quot;, &quot;salsa20&quot; (родственный)</h2>

<h2 id="rsa-rsaencrypt-cryptimportpublickeyinfo-begin-public-key">RSA:     &quot;RSAEncrypt&quot;, &quot;CryptImportPublicKeyInfo&quot;, &quot;BEGIN PUBLIC KEY&quot;</h2>




<h2 id="proverit-importirovannye-windows-api">Проверить импортированные Windows API:</h2>

<h2 id="objdump-d-suspicious-exe-grep-i-crypt-mingw-linux">objdump -d suspicious.exe | grep -i crypt  (MinGW/Linux)</h2>

<h2 id="dumpbin-imports-suspicious-exe-msvc">dumpbin /imports suspicious.exe  (MSVC)</h2>




<h2 id="ili-cherez-python-s-pefile">Или через Python с pefile:</h2>

pip install pefile

import pefile



def analyze_imports(pe_path: str):

    """Анализ импортированных функций для идентификации крипто-API."""

    pe = pefile.PE(pe_path)

    

    crypto_imports = []

    if hasattr(pe, 'DIRECTORY_ENTRY_IMPORT'):

        for entry in pe.DIRECTORY_ENTRY_IMPORT:

            dll_name = entry.dll.decode('utf-8', errors='replace')

            for imp in entry.imports:

                if imp.name:

                    func_name = imp.name.decode('utf-8', errors='replace')

                    # Список криптографических API Windows

                    if any(kw in func_name.lower() for kw in 

                           ['crypt', 'bcrypt', 'ncrypt', 'rand']):

                        crypto_imports.append((dll_name, func_name))

    

    return crypto_imports



<h2 id="zapusk">Запуск:</h2>

imports = analyze_imports("suspicious.exe")

for dll, func in imports:

    print(f"  {dll}: {func}")



<h2 id="harakternye-api">Характерные API:</h2>

<h2 id="cryptgenrandom-generatsiya-sluchaynyh-klyuchey-lyuboy-algoritm">CryptGenRandom    → генерация случайных ключей (любой алгоритм)</h2>

<h2 id="bcryptencrypt-windows-cng-aes-chacha20">BCryptEncrypt     → Windows CNG (AES, ChaCha20)</h2>

<h2 id="cryptencrypt-cryptoapi-ustarevshiy-aes-rc4">CryptEncrypt      → CryptoAPI устаревший (AES, RC4)</h2>

<h2 id="rtlgenrandom-getrandom-klyuchi">RtlGenRandom      → GetRandom (ключи)</h2>

<h2 id="any-run-any-run-interaktivnaya-onlayn-pesochnitsa">Any.run (any.run) — интерактивная онлайн-песочница:</h2>

<h2 id="zagruzit-obrazets-poluchit-polnyy-povedencheskiy-otchyot">Загрузить образец → получить полный поведенческий отчёт</h2>

<h2 id="vklyuchaet-sozdanie-faylov-reestrovye-izmeneniya-setevoy-trafik">Включает: создание файлов, реестровые изменения, сетевой трафик</h2>




<h2 id="cuckoo-sandbox-self-hosted-reshenie">Cuckoo Sandbox — self-hosted решение:</h2>

<h2 id="pip-install-cuckoo">pip install cuckoo</h2>

<h2 id="cuckoo-submit-suspicious-exe">cuckoo submit suspicious.exe</h2>




<h2 id="chto-iskat-v-otchyote-pesochnitsy">Что искать в отчёте песочницы:</h2>

<h2 id="import-zagruzka-kripto-bibliotek">- Импорт/загрузка крипто-библиотек</h2>

<h2 id="generatsiya-klyuchey-cryptgenrandom-bcryptgenrandom">- Генерация ключей (CryptGenRandom / BCryptGenRandom)</h2>

<h2 id="massovoe-otkrytie-faylov-na-zapis">- Массовое открытие файлов на запись</h2>

<h2 id="udalenie-tenevyh-kopiy">- Удаление теневых копий</h2>

<h2 id="c2-kommunikatsiya-dlya-polucheniya-publichnogo-klyucha">- C2-коммуникация (для получения публичного ключа)</h2>

S-box начинается с: 63 7C 77 7B F2 6B 6F C5 30 01 67 2B FE D7 AB 76

(первые 16 байт из 256)



В hex-редакторе или Ghidra:

  Поиск байтовой последовательности 63 7C 77 7B F2 6B 6F C5

  → Найдено → AES реализован в данном бинарнике

<h2 id="poisk-s-box-konstanty-v-binarnike">Поиск S-box константы в бинарнике:</h2>

python3 -c "

import sys



AES_SBOX = bytes([

    0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5,

    0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76

])



with open(sys.argv[1], 'rb') as f:

    data = f.read()



offset = data.find(AES_SBOX)

if offset >= 0:

    print(f'AES S-box найден на смещении 0x{offset:X} — файл использует AES')

else:

    print('AES S-box не найден напрямую')

" suspicious.exe

Алгоритм:     AES-256 (файлы) + RSA-2048 (ключ)

Расширение:   .lockbit или случайное (8 hex-символов)

Записка:      Restore-My-Files.txt

Удаление VSS: vssadmin delete shadows /all /quiet

Платформы:    Windows, Linux (ESXi)

Особенности:  Intermittent encryption (первые N байт каждого файла)

Идентификация: ID Ransomware, наличие ECDH-публичного ключа в образце

Алгоритм:     ChaCha20 (файлы) + RSA-4096 (ключ)

Расширение:   Случайное (5–8 hex-символов)

Записка:      RECOVER-[расширение]-FILES.txt

Написан:      Rust (сложнее поддаётся реверсингу)

Платформы:    Windows, Linux, VMware ESXi

Особенности:  Настраиваемый режим шифрования (полное / intermittent)

Идентификация: Наличие Rust-рантайма, ChaCha20 sigma-константы

Алгоритм:     ChaCha20 (текущие версии) + RSA

              (ранние версии использовали AES-256-CBC)

Расширение:   .akira

Записка:      akira_readme.txt

Платформы:    Windows (C++), Linux/ESXi

Особенности:  Intermittent encryption — шифрует блоки по 

              1,5 МБ через интервалы (зависит от размера файла)

Идентификация: Расширение .akira, характерный паттерн 

              блочного шифрования

Алгоритм:     AES-256-CTR (если есть AES-NI) 

              или ChaCha20 + RSA-4096 + OAEP

Написан:      Rust

Расширение:   Случайное

Особенности:  Удаляет Event Log, самоудаляется после шифрования,

              удаляет VSS, специализируется на VMware ESXi

Платформы:    Windows, Linux

Алгоритм:     HC-128 (потоковый шифр) + Curve25519 + SHA512

Расширение:   .cloak

Записка:      CLOAK_README.txt

Особенности:  Поддерживает полное и интермиттирующее шифрование

              Базируется на утечках исходников Babuk

Идентификация: HC-128 — нетипичный алгоритм, 

              идентифицируется по константам генератора

Алгоритм:     Salsa20 (файлы) + RSA-1024 (ключ)

              Важно: если нет интернета при шифровании — 

              использует OFFLINE KEY (один и тот же для всех)

Расширение:   .djvu, .djvus, .nomad, .beast, .ousa и сотни других

Записка:      _readme.txt

Особенности:  Offline-ключ означает возможность дешифрования

              через STOPDecrypter / Emsisoft STOP Djvu Decryptor

Идентификация: _readme.txt с email restorealldata@firemail.cc

              или аналогичными адресами

идентификаторы:

  Строка "expand 32-byte k" в бинарнике (sigma-константа)

  Строка "expand 16-byte k" (для ChaCha20 с 128-bit ключом)



AES идентификаторы:

  S-box константа (63 7C 77 7B ...)

  Вызовы BCryptEncrypt / CryptEncrypt

  Строка "AES" или константа AES_KEY_SIZE



RSA идентификаторы:

  PEM-строка "-----BEGIN PUBLIC KEY-----" в бинарнике

  Большие простые числа в качестве констант

  Вызовы CryptImportPublicKeyInfo или аналогов

Режим "первые N байт":

  [зашифровано: первые 512 КБ][не зашифровано: остаток файла]

  Файл неиспользуем, но шифрование быстрее в 10–100 раз



Режим "каждый N-й блок":

  [шифр][открыт][шифр][открыт][шифр][открыт]...

  Паттерн чередования — энтропия усреднена



Режим "процент файла":

  BlackCat/ALPHV: шифрует заданный % от размера файла

  LockBit 3.0: шифрует первые N байт (N зависит от размера файла)

  Akira: блоки по 1,5 МБ через интервалы

При шифровании первых 10% большого файла:

  Общая энтропия файла: 5.2 (высокая только первые 10%)

  → Простой энтропийный детектор скажет: "не зашифровано"

  → Блочный анализ покажет: высокая энтропия в начале, низкая в конце



При режиме "каждый 2-й блок":

  Общая энтропия файла: ~6.5–7.0

  → Порогово-энтропийный детектор: неопределённо / промах

  → Блочная карта: чёткое чередование высокой/низкой энтропии

def detect_intermittent_encryption(

    filepath: str,

    block_size: int = 4096,

    high_threshold: float = 7.5,

    low_threshold:  float = 6.5

) -> dict:

    """

    Обнаружить интермиттирующее шифрование по паттерну 

    чередования блоков с высокой/низкой энтропией.

    """

    blocks = block_entropy_map(filepath, block_size)

    if not blocks:

        return {"status": "empty"}



    high_blocks = sum(1 for _, e in blocks if e >= high_threshold)

    low_blocks  = sum(1 for _, e in blocks if e <  low_threshold)

    total       = len(blocks)



    # Подсчёт переходов (высокий→низкий и низкий→высокий)

    transitions = 0

    for i in range(1, len(blocks)):

        prev_high = blocks[i-1][1] >= high_threshold

        curr_high = blocks[i][1]   >= high_threshold

        if prev_high != curr_high:

            transitions += 1



    alternating = transitions > total * 0.3  # >30% переходов = чередование



    return {

        "total_blocks":  total,

        "high_entropy":  high_blocks,

        "low_entropy":   low_blocks,

        "transitions":   transitions,

        "alternating":   alternating,

        "verdict": (

            "ПОЛНОЕ шифрование"         if high_blocks / total > 0.90 else

            "ИНТЕРМИТТИРУЮЩЕЕ шифрование" if alternating           else

            "ЧАСТИЧНОЕ шифрование"      if high_blocks / total > 0.30 else

            "Шифрование не обнаружено"

        )

    }

#!/usr/bin/env python3

"""

ransomware_file_analyzer.py

Первичный анализ файлов на признаки ransomware-шифрования.



Использование:

  python ransomware_file_analyzer.py file.pdf

  python ransomware_file_analyzer.py /infected_folder/ --recursive

  python ransomware_file_analyzer.py file.enc --block-map

"""



import os

import sys

import math

import argparse

from collections import Counter

from pathlib import Path



<h2 id="konstanty">─── Константы ────────────────────────────────────────────────────────────</h2>

MAGIC_SIGNATURES = {

    b'\x25\x50\x44\x46':         ('PDF', '.pdf'),

    b'\x50\x4B\x03\x04':         ('ZIP/Office', '.zip .docx .xlsx .pptx'),

    b'\xFF\xD8\xFF':              ('JPEG', '.jpg .jpeg'),

    b'\x89\x50\x4E\x47\x0D\x0A': ('PNG', '.png'),

    b'\x47\x49\x46\x38':         ('GIF', '.gif'),

    b'\x42\x4D':                  ('BMP', '.bmp'),

    b'\x4D\x5A':                  ('PE Executable', '.exe .dll'),

    b'\x7F\x45\x4C\x46':         ('ELF Executable', ''),

    b'\x37\x7A\xBC\xAF\x27\x1C': ('7-ZIP', '.7z'),

    b'\x1F\x8B':                  ('GZIP', '.gz'),

    b'\x52\x61\x72\x21':         ('RAR', '.rar'),

    b'\x25\x21\x50\x53':         ('PostScript', '.ps'),

    b'\xD0\xCF\x11\xE0':         ('MS OLE (old Office)', '.doc .xls .ppt'),

    b'\x30\x82':                  ('DER Certificate/Key', '.der .cer'),

}



AES_SBOX_START = bytes([

    0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5,

    0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76

])

CHACHA20_SIGMA = b"expand 32-byte k"



<h2 id="entropiya">─── Энтропия ─────────────────────────────────────────────────────────────</h2>

def shannon_entropy(data: bytes) -> float:

    if not data:

        return 0.0

    counts = Counter(data)

    total  = len(data)

    return -sum((c / total) * math.log2(c / total)

                for c in counts.values())



def block_entropy(filepath: str, block_size: int = 4096) -> list[tuple]:

    results = []

    with open(filepath, "rb") as f:

        offset = 0

        while chunk := f.read(block_size):

            results.append((offset, shannon_entropy(chunk), len(chunk)))

            offset += len(chunk)

    return results



<h2 id="magic-bytes">─── Magic bytes ──────────────────────────────────────────────────────────</h2>

def check_magic(header: bytes) -> str | None:

    for sig, (name, _) in MAGIC_SIGNATURES.items():

        if header[:len(sig)] == sig:

            return name

    return None



<h2 id="kriptokonstanty">─── Криптоконстанты ──────────────────────────────────────────────────────</h2>

def check_crypto_constants(data: bytes) -> list[str]:

    found = []

    if AES_SBOX_START in data:

        found.append("AES S-box")

    if CHACHA20_SIGMA in data:

        found.append("ChaCha20 sigma")

    if b"-----BEGIN PUBLIC KEY-----" in data:

        found.append("RSA Public Key (PEM)")

    if b"-----BEGIN CERTIFICATE-----" in data:

        found.append("X.509 Certificate")

    return found



<h2 id="osnovnoy-analiz">─── Основной анализ ──────────────────────────────────────────────────────</h2>

def analyze_file(filepath: str, show_block_map: bool = False) -> dict:

    path = Path(filepath)

    result = {

        "file":    str(path),

        "size":    path.stat().st_size,

        "ext":     path.suffix.lower(),

        "entropy": None,

        "magic":   None,

        "ext_mismatch": False,

        "verdict": "Unknown",

        "crypto_constants": [],

        "block_map": [],

    }



    with open(filepath, "rb") as f:

        header = f.read(16)

        f.seek(0)

        data = f.read()



    # Энтропия всего файла

    result["entropy"] = shannon_entropy(data)



    # Magic bytes

    detected_type = check_magic(header)

    result["magic"] = detected_type or "Unknown / No valid magic bytes"



    # Несоответствие расширения и типа

    if detected_type:

        for sig, (name, extensions) in MAGIC_SIGNATURES.items():

            if name == detected_type and result["ext"]:

                if result["ext"] not in extensions:

                    result["ext_mismatch"] = True



    # Криптоконстанты (для исполняемых файлов или образцов малвари)

    result["crypto_constants"] = check_crypto_constants(data)



    # Блочная карта (если запрошена)

    if show_block_map:

        result["block_map"] = block_entropy(filepath)



    # Вердикт

    ent = result["entropy"]

    if ent >= 7.8:

        if detected_type is None:

            result["verdict"] = "ВЫСОКАЯ ВЕРОЯТНОСТЬ ШИФРОВАНИЯ"

        else:

            # Сжатый файл тоже может иметь высокую энтропию

            result["verdict"] = "Высокая энтропия (сжатый или зашифрованный)"

    elif ent >= 7.5:

        result["verdict"] = "СРЕДНЯЯ вероятность — проверить блочную карту"

    elif result["ext_mismatch"]:

        result["verdict"] = "НЕСООТВЕТСТВИЕ расширения — подозрительно"

    else:

        result["verdict"] = "Признаков шифрования не выявлено"



    return result



<h2 id="vyvod-rezultatov">─── Вывод результатов ────────────────────────────────────────────────────</h2>

def print_result(r: dict, show_map: bool = False):

    print(f"\n{'─'*60}")

    print(f"  Файл:    {r['file']}")

    print(f"  Размер:  {r['size']:,} байт")

    print(f"  Расш.:   {r['ext'] or 'нет'}")

    print(f"  Magic:   {r['magic']}")

    print(f"  Энтропия:{r['entropy']:.4f} бит/байт")

    if r["ext_mismatch"]:

        print(f"  ⚠️  НЕСООТВЕТСТВИЕ: расширение не совпадает с типом файла")

    if r["crypto_constants"]:

        print(f"  Крипто:  {', '.join(r['crypto_constants'])}")

    print(f"  Вердикт: {r['verdict']}")



    if show_map and r["block_map"]:

        print(f"\n  Блочная карта энтропии (каждые 4 КБ):")

        print(f"  {'Смещение':>12}  Энтропия  Визуализация")

        for offset, ent, sz in r["block_map"]:

            bar = "█" * int(ent / 8.0 * 20)

            print(f"  {offset:>12,}  {ent:5.2f}     {bar}")



<h2 id="cli">─── CLI ──────────────────────────────────────────────────────────────────</h2>

if __name__ == "__main__":

    parser = argparse.ArgumentParser(

        description="Анализ файлов на признаки ransomware-шифрования")

    parser.add_argument("target",

        help="Файл или директория для анализа")

    parser.add_argument("-r", "--recursive", action="store_true",

        help="Рекурсивный анализ директории")

    parser.add_argument("--block-map", action="store_true",

        help="Показать блочную карту энтропии")

    parser.add_argument("--threshold", type=float, default=7.5,

        help="Порог энтропии для алерта (по умолчанию 7.5)")

    args = parser.parse_args()



    target = Path(args.target)

    files  = []



    if target.is_file():

        files = [str(target)]

    elif target.is_dir() and args.recursive:

        files = [str(p) for p in target.rglob("*") if p.is_file()]

    elif target.is_dir():

        files = [str(p) for p in target.glob("*") if p.is_file()]

    else:

        print(f"Ошибка: {args.target} не найден")

        sys.exit(1)



    suspicious = []

    for filepath in files:

        try:

            result = analyze_file(filepath, args.block_map)

            if result["entropy"] >= args.threshold or result["ext_mismatch"]:

                suspicious.append(result)

                print_result(result, args.block_map)

        except (PermissionError, OSError) as e:

            print(f"  Ошибка чтения {filepath}: {e}")



    print(f"\n{'='*60}")

    print(f"Проверено файлов: {len(files)}")

    print(f"Подозрительных:   {len(suspicious)}")

. ИЗОЛЯЦИЯ (в первые минуты):

   Отключить заражённые хосты от сети

   Не выключать — это уничтожит данные в памяти

   Сделать образ оперативной памяти (если активный процесс ещё жив):

     winpmem.exe memory.raw  (Windows)

     avml /proc/kcore memory.raw  (Linux)



2. ОЦЕНКА МАСШТАБА:

   Сколько файлов зашифровано?

   Какие директории затронуты?

   Есть ли незашифрованные резервные копии?

   Достигла ли атака Active Directory?



3. ИДЕНТИФИКАЦИЯ ВЕКТОРА:

   Как ransomware попал в систему?

   Закрыт ли вектор (уязвимость, учётная запись)?



4. НОТИФИКАЦИЯ:

   Регулятор (если персональные данные — РОСКОМНАДЗОР)

   Страховая компания (если есть кибер-страховка)

   Правоохранители (при необходимости)

Приоритетные ресурсы для проверки:



1. nomoreransom.org/crypto-sheriff.php

   Загрузить 2 зашифрованных файла + записку

   

2. id-ransomware.malwarehunterteam.com

   Идентификация + проверка доступности дешифратора



3. emsisoft.com/ransomware-decryption-tools/

   Официальные бесплатные дешифраторы Emsisoft



4. bleepingcomputer.com/news/security/free-ransomware-decryptors/

   Актуальный список бесплатных дешифраторов с описаниями



5. Malpedia (malpedia.caad.fkie.fraunhofer.de)

   Профиль семейства с ссылками на ресурсы

Порядок проверки резервных копий:



1. Облачное хранилище (если не было синхронизировано 

   в момент атаки — версии могут быть целы)



2. Оффлайн-резервные копии (не подключённые в момент атаки)



3. Previous Versions в Windows (если VSS не удалены):

   Правая кнопка на файле → Properties → Previous Versions



4. Резервные копии на изолированных серверах



5. Восстановление из snapshots виртуальных машин

   (если хранятся отдельно от основной инфраструктуры)

НИКОГДА не платить без консультации с:

  - Юристом (санкционные риски — платёж организациям из SDN-листа

    может быть незаконен)

  - Правоохранителями (у них может быть ключ или данные об акторе)

  - Киберстраховщиком (условия полиса)

  - Специалистом по переговорам (если рассматриваете оплату)



Данные: в 2025 году 63% жертв отказались платить, 

97% восстановили данные через резервные копии или другие средства.

Расширение .akira → семейство Akira

Записка akira_readme.txt → подтверждение



Немедленное действие: изолировать хост от сети

(не выключать — у Akira есть особенности завершения)

Загружаем akira_readme.txt на id-ransomware.malwarehunterteam.com

Результат: Akira Ransomware — идентифицировано

Статус дешифратора: недоступен для текущих версий



(Напоминание: ранний дешифратор от Avast уже не работает 

 с обновлёнными версиями Akira)

<h2 id="zapusk-analizatora-na-zashifrovannyh-faylah">Запуск анализатора на зашифрованных файлах:</h2>

python ransomware_file_analyzer.py /srv/fileserver/finance/ -r



<h2 id="vyvod">Вывод:</h2>

<h2 id="">─────────────────────────────────────────────</h2>

<h2 id="fayl-q4-report-2025-docx-akira">Файл:     Q4_report_2025.docx.akira</h2>

<h2 id="razmer-2-847-382-bayt">Размер:   2,847,382 байт</h2>

<h2 id="entropiya-7-94-bit-bayt">Энтропия: 7.94 бит/байт</h2>

<h2 id="magic-unknown-no-valid-magic-bytes">Magic:    Unknown / No valid magic bytes</h2>

<h2 id="verdikt-vysokaya-veroyatnost-shifrovaniya">Вердикт:  ВЫСОКАЯ ВЕРОЯТНОСТЬ ШИФРОВАНИЯ</h2>

<h2 id="fayl-contracts-archive-zip-akira">#   Файл:     contracts_archive.zip.akira</h2>

<h2 id="razmer-15-284-910-bayt">Размер:   15,284,910 байт</h2>

<h2 id="entropiya-7-93-bit-bayt">Энтропия: 7.93 бит/байт</h2>

<h2 id="verdikt-vysokaya-veroyatnost-shifrovaniya">Вердикт:  ВЫСОКАЯ ВЕРОЯТНОСТЬ ШИФРОВАНИЯ</h2>

python ransomware_file_analyzer.py Q4_report_2025.docx.akira --block-map



<h2 id="vyvod-pervye-bloki">Вывод (первые блоки):</h2>

<h2 id="blochnaya-karta-entropii">Блочная карта энтропии:</h2>

<h2 id="smeschenie-entropiya-vizualizatsiya">Смещение  Энтропия  Визуализация</h2>

<h2 id="0-7-96">0    7.96    ████████████████████</h2>

<h2 id="4-096-7-94">4,096    7.94    ████████████████████</h2>

<h2 id="8-192-7-97">8,192    7.97    ████████████████████</h2>

<h2 id="12-288-7-95">12,288    7.95    ████████████████████</h2>

<h2 id="">...</h2>

<h2 id="pattern-vse-bloki-8-0-polnoe-shifrovanie-ili-pervaya-chast">Паттерн: все блоки ~8.0 → полное шифрование (или первая часть)</h2>

<h2 id="poisk-obraztsa-na-zarazhyonnom-hoste">Поиск образца на заражённом хосте:</h2>

strings akira_payload.exe | grep -iE "(chacha|aes|expand 32)"

<h2 id="naydeno-expand-32-byte-k-chacha20-podtverzhdyon">Найдено: &quot;expand 32-byte k&quot; → ChaCha20 подтверждён</h2>




<h2 id="analiz-importov">Анализ импортов:</h2>

python ransomware_file_analyzer.py akira_payload.exe

<h2 id="vyvod-kripto-chacha20-sigma">Вывод: Крипто: ChaCha20 sigma</h2>

Идентифицировано:  Akira Ransomware (актуальная версия)

Алгоритм:          ChaCha20 (файлы) + RSA (ключ сессии)

Дешифратор:        Недоступен

Масштаб:           Зашифровано 4,847 файлов на файловом сервере

VSS:               Удалены (vssadmin delete shadows /all)



Действия:

  1. Восстановление из последней резервной копии (вчерашней 22:00)

  2. Потеря данных: ~6 часов работы

  3. Анализ вектора проникновения: открытый RDP с брутфорсом

  4. Нотификация руководства и юридического отдела

  5. Создание YARA-правила для детектирования повторного появления