SILVERPICK

VERSION

• v1.1

DESCRIPTION

Le projet SILVERPICK est un Windows User-Mode Shellcode Development Framework (WUMSDF) dont l'unique objectif est de permettre aux développeurs de capacités de créer des blobs de Position Independent Code (PIC) pour Windows x64 en C/C++ de manière simple, afin de réduire les coûts de développement d'une telle entreprise.

Il dérive du projet WILDBEAST et, à ce titre, s'appuie sur :

1. Visual Studio Code comme éditeur de code
2. La chaîne d'outils MinGW-w64 comme chaîne de compilation
3. GNU Make comme système de construction

INSTALLATION

Vous trouverez les instructions d'installation ici : GCC-Clang-Setup-Windows

Veuillez noter que ce projet utilise MSYS2.

FONCTIONNALITÉS

Écrire du shellcode dans des langages de programmation de haut niveau n'a rien de nouveau, et d'innombrables articles de blog et documents de recherche ont été publiés sur le sujet depuis 2010. Alors, qu'y a-t-il de nouveau dans SILVERPICK ?

Eh bien, je suis ravi que vous posiez la question.

SILVERPICK cache un joli petit sac d'astuces dans sa manche, mais surtout, c'est ma vision du sujet.

Sans plus attendre, je vous présente ma première astuce.

ASTUCE 01

Depuis que Matt Graeber a popularisé l'écriture de shellcode en C, la plupart des gens utilisent son stub d'alignement de pile de 16 octets écrit en langage Assembly.

Bien que cela ne soit pas un problème, étant donné que nous ne sommes pas IKEA, l'assembleur ne devrait pas être nécessaire, et il ne l'est effectivement pas.

Il existe un attribut de fonction GCC qui émet le stub d'alignement de pile pour vous.

Voici l'attribut de fonction force_align_arg_pointer sous la forme d'une macro pratique ALIGN_STACK, qui génère l'assembleur suivant :

Disassembly of section .init:

<PicEntry>:
	push   rbp
	mov    rbp,rsp
	and    rsp,0xfffffffffffffff0
	sub    rsp,0x20
	call   <PicEntry+0x11>	IMAGE_REL_AMD64_REL32	.text$payload
	leave
	ret

Qu'est-ce que la section .init, demanderez-vous ? Eh bien, cela constitue une belle transition vers ma deuxième astuce.

ASTUCE 02

Matt Graeber a peut-être popularisé l'écriture de shellcode en C à un moment donné, mais c'est en réalité Paul Ungur qui a ravivé cet art noir avec Stardust.

Stardust utilise un script de liaison Binutils pour contrôler le placement des fonctions et des données dans la section PE appropriée, dans le bon ordre. Cette technique est elle-même dérivée des travaux d'Austin Hudson, et de nombreuses personnes utilisent une variante de ses scripts de liaison.

Bien que les scripts de liaison soient parfaits pour ordonner les sections du lieur, ils sont inutiles si tout ce dont vous avez besoin est de placer une fonction donnée au début de la section de code.

C'est ici qu'intervient l'attribut de fonction section avec un nom de section spécial appelé .init, qui indique au lieur que la fonction contient du code d'initialisation d'exécution pré-main() et qu'elle doit être première dans l'ordre de liaison.

À cette fin, la macro CODE_BEGIN a été créée.

ASTUCE 03

Pour ma troisième astuce, je vous présente la macro STACK_STRING.

En C, vous pouvez créer une chaîne de pile (une chaîne construite dynamiquement sur la pile) en déclarant la chaîne littérale comme un tableau de caractères ANSI :

char charrHelloKitty[] = { 'H', 'e', 'l', 'l', 'o', 'K', 'i', 't', 't', 'y', '\0' };

En C++, vous pouvez créer une chaîne de pile en marquant simplement un tableau char comme constexpr :

constexpr char charrHelloKitty[]{ "HelloKitty" };

Cependant, ces deux techniques deviennent inutiles face aux optimisations du compilateur si les chaînes littérales sont suffisamment grandes, contrairement à notre solution, qui fonctionnera quelle que soit la longueur de la chaîne et le niveau d'optimisation du compilateur, grâce à une astuce intelligente de métaprogrammation de templates C++ offerte par Can Bölük.

L'utilisation de cette macro est assez simple :

STACK_STRING(sstrText, "an extra long hello world!");
STACK_STRING(sstrCaption, "Demo");

MessageBoxA(nullptr, sstrText.data(), sstrCaption.data(), MB_OK);

Cela générera l'assembleur suivant :

mov     [rsp+58h+var_23], 61h ; 'a'
mov     [rsp+58h+var_22], 6Eh ; 'n'
mov     [rsp+58h+var_21], 20h ; ' '
mov     [rsp+58h+var_20], 65h ; 'e'
mov     [rsp+58h+var_1F], 78h ; 'x'
mov     [rsp+58h+var_1E], 74h ; 't'
mov     [rsp+58h+var_1D], 72h ; 'r'
mov     [rsp+58h+var_1C], 61h ; 'a'
mov     [rsp+58h+var_1B], 20h ; ' '
mov     [rsp+58h+var_1A], 6Ch ; 'l'
mov     [rsp+58h+var_19], 6Fh ; 'o'
mov     [rsp+58h+var_18], 6Eh ; 'n'
mov     [rsp+58h+var_17], 67h ; 'g'
mov     [rsp+58h+var_16], 20h ; ' '
mov     [rsp+58h+var_15], 68h ; 'h'
mov     [rsp+58h+var_14], 65h ; 'e'
mov     [rsp+58h+var_13], 6Ch ; 'l'
mov     [rsp+58h+var_12], 6Ch ; 'l'
mov     [rsp+58h+var_11], 6Fh ; 'o'
mov     [rsp+58h+var_10], 20h ; ' '
mov     [rsp+58h+var_2F], 0
mov     [rsp+58h+var_F], 77h ; 'w'
mov     [rsp+58h+var_E], 6Fh ; 'o'
mov     [rsp+58h+var_D], 72h ; 'r'
mov     [rsp+58h+var_C], 6Ch ; 'l'
mov     [rsp+58h+var_B], 64h ; 'd'
mov     [rsp+58h+var_A], 21h ; '!'
mov     [rsp+58h+var_33], 44h ; 'D'
mov     [rsp+58h+var_32], 65h ; 'e'
mov     [rsp+58h+var_31], 6Dh ; 'm'
mov     [rsp+58h+var_30], 6Fh ; 'o'

ASTUCE 04

En parlant de C++, je vous présente le hachage de chaînes à la compilation pour ma quatrième astuce.

Bien que ce ne soit pas un concept nouveau, SILVERPICK offre quelques améliorations par rapport aux implémentations publiques existantes.

Premièrement, nous utilisons la variante 64 bits de la célèbre fonction de hachage non cryptographique FNV-1a afin de réduire la probabilité d'une attaque par collision de hachage réussie.

Deuxièmement, nous utilisons un paramètre modifié pour la fonction de hachage afin de nous défendre contre les recherches de tables de hachage précalculées, comme HashDB. Point crucial, cela ne change pas les propriétés de la fonction de hachage.

Pour hacher une chaîne courte au moment de l'exécution, utilisez simplement la macro HASH_STRING_RUN_TIME.

Pour hacher une chaîne littérale courte à la compilation, utilisez simplement la macro HASH_STRING_COMPILE_TIME. L'évaluation uniquement à la compilation est garantie via consteval.

ASTUCE 05

Il s'avère que l'on peut implémenter pas mal de fonctions de la C Runtime Library (CRT) à l'aide des instructions de chaîne x86. Alors, bien sûr, j'ai dû les implémenter en utilisant un mélange d'intrinsèques du compilateur et d'assembleur inline.

Vous voulez utiliser la fonction msvcrt!memset dans votre code ? Utilisez plutôt la macro ZERO_MEMORY, qui utilise l'instruction rep stosb émise via un intrinsèque du compilateur.