AVML (Acquire Volatile Memory for Linux)

Riepilogo

Uno strumento portatile per l'acquisizione di memoria volatile su Linux.

AVML è uno strumento di acquisizione di memoria volatile in userland per X86_64 scritto in Rust, pensato per essere distribuito come binario statico. AVML può essere utilizzato per acquisire la memoria senza conoscere a priori la distribuzione del sistema operativo target o il kernel. Non è necessaria alcuna compilazione o fingerprinting sul target.

Funzionalità

• Salva le immagini registrate su posizioni esterne tramite Azure Blob Store o HTTP PUT
• I caricamenti su Azure Blob Storage ritentano i fallimenti transitori tramite la policy di backoff esponenziale predefinita dell'SDK Azure (8 tentativi, con un limite di un minuto di tempo totale trascorso).
• Compressione opzionale a livello di pagina tramite Snappy.
• Utilizza il formato di output di LiME (quando non si utilizza la compressione).

Sorgenti di memoria

• /dev/crash
• /proc/kcore
• /dev/mem

Se la sorgente di memoria non è specificata sulla riga di comando, AVML itererà sulle sorgenti di memoria per trovare una sorgente funzionante.

NOTA: Se la funzionalità del kernel kernel_lockdown è abilitata, AVML non sarà in grado di acquisire la memoria.

Distribuzioni testate

La matrice di test delle VM Azure è definita in eng/images.txt e attualmente copre:

• Ubuntu: 16.04, 18.04, 20.04, 22.04, 24.04, 26.04
• CentOS: 7.9
• RHEL: 7.9, 8.5, 8.10, 9.0, 9.8, 10.2
• Debian: 11, 12, 13
• Oracle Linux: 8.10, 9.8, 10.2
• CBL-Mariner: 2.0
• Azure Linux: 3.0
• SUSE Linux Enterprise Server: 12 SP5, 15 SP7, 16.0
• AlmaLinux: 8, 9, 10

Sottocomandi

avml è un singolo binario con sottocomandi. Ogni sottocomando è controllato da una feature di Cargo, così una build minimale include solo la funzionalità di cui hai bisogno:

Sottocomando	Feature	Predefinito	Cosa fa
acquire	(sempre)	sì	Cattura la memoria in un file locale (caricamento opzionale successivo).
convert	convert	sì	Converte tra i formati AVML / LiME / raw.
upload	upload	sì	Carica un file locale tramite HTTP PUT o su Azure Block Blob.
stream	stream	sì	Trasmette in streaming uno snapshot direttamente a una destinazione, senza file locale.

Crea un binario minimale solo per l'acquisizione con cargo build --release --no-default-features.

Per iniziare

Catturare un'immagine di memoria compressa

Sull'host target:

avml acquire --compress output.lime.compressed

Catturare un'immagine di memoria non compressa

Sull'host target:

avml acquire output.lime

Catturare un'immagine di memoria e caricarla su Azure Blob Store

Su un host sicuro con credenziali az cli, genera un SAS URL.

EXPIRY=$(date -d '1 day' '+%Y-%m-%dT%H:%MZ')
SAS_URL=$(az storage blob generate-sas --account-name ACCOUNT --container CONTAINER test.lime --full-uri --permissions c --output tsv --expiry ${EXPIRY})

Sull'host target, esegui avml con il token SAS generato.

avml acquire --sas-url ${SAS_URL} --delete output.lime

Trasmettere in streaming un'immagine di memoria senza scrivere su disco locale

Per host in cui scrivere prima lo snapshot su un file locale non è desiderabile (root in sola lettura, disco limitato, problemi di catena di custodia forense), usa il sottocomando stream. Seleziona la sorgente di memoria una volta all'inizio (stesso ordine di preferenza del percorso /dev/stdout di acquire — /proc/kcore, poi /dev/crash, poi /dev/mem; passa --source per sovrascrivere) e scrive i byte in modo sequenziale alla destinazione scelta. La sorgente non può essere cambiata a metà stream, quindi non c'è fallback automatico della sorgente.

Verso Azure Block Blob Storage

avml stream blob ${SAS_URL}

• La dimensione del blocco è derivata automaticamente in modo che lo snapshot rientri nel limite di 50.000 blocchi per blob di Azure. --sas-block-size (MiB) funge da minimo; se il minimo derivato è maggiore, vince il valore maggiore.
• --sas-block-concurrency limita il numero di chiamate stage_block in corso. La RAM di picco è approssimativamente (concurrency + 1) * block_size.
• Se lo snapshot fallisce a metà caricamento, i blocchi preparati vengono abbandonati senza essere confermati; Azure li scarta automaticamente secondo la sua policy standard.

Verso un listener TCP remoto

Sull'host collector:

nc -l 9000 > snapshot.lime

Sull'host target:

avml stream tcp collector.example.com:9000

avml si connette una volta e scrive lo snapshot in modo sequenziale. Se la connessione cade a metà stream, lo snapshot si interrompe; non c'è ripresa. Nessun TLS — abbinalo a un tunnel SSH o stunnel per riservatezza e integrità, se necessario.

Caricare uno snapshot catturato in precedenza

avml upload put  ./output.lime ${URL}              # HTTP PUT
avml upload blob ./output.lime ${SAS_URL}          # Azure Block Blob

Catturare un'immagine di memoria di una VM Azure usando le VM Extensions

Su un host sicuro con credenziali az cli, esegui le seguenti operazioni:

1. Genera un SAS URL (vedi sopra)
2. Crea config.json contenente le seguenti informazioni:

{
    "commandToExecute": "./avml acquire --compress --sas-url <GENERATED_SAS_URL> --delete",
    "fileUris": ["https://FULL.URL.TO.AVML.example.com/avml"]
}

3. Esegui l'estensione customScript con il config.json specificato

az vm extension set -g RESOURCE_GROUP --vm-name VM_NAME --publisher Microsoft.Azure.Extensions -n customScript --settings config.json

Per caricare su AWS S3 o GCP Cloud Storage

Su un host sicuro, genera un S3 pre-signed URL oppure genera un GCP pre-signed URL.

Sull'host target, esegui avml con il pre-signed URL generato.

avml acquire --url ${URL} --delete output.lime

Per decomprimere un'immagine compressa con AVML

avml convert ./compressed.lime ./uncompressed.lime

Per comprimere un'immagine LiME non compressa

avml convert --source-format lime --format lime_compressed ./uncompressed.lime ./compressed.lime

Utilizzo

A portable volatile memory acquisition tool for Linux

Usage: avml <COMMAND>

Commands:
  acquire  Acquire a memory snapshot to a local file (and optionally upload it)
  convert  Convert between AVML and LiME snapshot formats and a raw memory image
  upload   Upload an already-acquired snapshot file to remote storage
  stream   Stream a memory snapshot directly to remote storage, without writing it to a local file
  help     Print this message or the help of the given subcommand(s)

Esegui avml <COMMAND> --help per le opzioni di ciascun comando.

Compilazione su Ubuntu

# Install MUSL
sudo apt-get install musl-dev musl-tools musl

# Install Rust via rustup
curl https://sh.rustup.rs -sSf | sh -s -- -y

# Add the MUSL target for Rust
rustup target add x86_64-unknown-linux-musl

# Build
cargo build --release --target x86_64-unknown-linux-musl

# Build without upload functionality
cargo build --release --target x86_64-unknown-linux-musl --no-default-features