{"id":224,"date":"2021-07-28T18:54:33","date_gmt":"2021-07-28T16:54:33","guid":{"rendered":"https:\/\/theredwindows.net\/?p=224"},"modified":"2021-07-28T20:13:07","modified_gmt":"2021-07-28T18:13:07","slug":"psreflect-ftw","status":"publish","type":"post","link":"https:\/\/theredwindows.net\/index.php\/2021\/07\/28\/psreflect-ftw\/","title":{"rendered":"PSReflect FTW"},"content":{"rendered":"\n

Bien que les possibilit\u00e9s offertes par .NET sont extr\u00eamement puissantes, il est parfois n\u00e9cessaire d\u2019avoir une interaction directe avec la WinAPI. En C#, le Pinvoke y est d\u00e9di\u00e9. Dans cet article, nous verrons comment faire une impl\u00e9mentation discr\u00e8te, stable et viable du Pinvoke. L\u2019exemple principal de ce poste sera celui d\u2019un outil que j\u2019ai \u00e9crit, SweetBackup. Je dois vous avertir cependant qu\u2019il ne s\u2019agit pas d\u2019un article ais\u00e9 de compr\u00e9hension, il vous faudra une bonne connaissance de PowerShell et de la r\u00e9flexion.<\/p>\n\n\n\n

PInvoke<\/h2>\n\n\n\n

Pour \u00eatre tout \u00e0 fait rigoureux, je devrais l\u2019appeler P\/Invoke mais je risque d\u2019utiliser PInvoke. Le “platform Invoke” est une impl\u00e9mentation dans le framework .NET qui permet l\u2019utilisation de code natif de dlls (aussi appel\u00e9 code non manag\u00e9). Autrement dit, l\u2019acc\u00e8s \u00e0 la WinAPI. En C#, on utilise l’espace de nom System.Runtime.InteropServices<\/code> qui exporte un attribut [DllImport()]<\/code>. Voici un exemple pour la fonction AdjustTokenPrivilege<\/code>, en C#.<\/p>\n\n\n\n

[DllImport(\"advapi32.dll\", SetLastError=true)]\n[return: MarshalAs(UnmanagedType.Bool)]\nstatic extern bool AdjustTokenPrivileges(IntPtr TokenHandle,\n   [MarshalAs(UnmanagedType.Bool)]bool DisableAllPrivileges,\n   ref TOKEN_PRIVILEGES NewState,\n   UInt32 BufferLengthInBytes,\n   ref TOKEN_PRIVILEGES PreviousState,\n   out UInt32 ReturnLengthInBytes);<\/pre>\n\n\n\n
Ou encore possible en VB:<\/p>\n\n\n\n
<DllImport(\"advapi32.dll\", SetLastError:=True)> _\nPrivate Function AdjustTokenPrivileges( _\n    ByVal TokenHandle As IntPtr, _\n    ByVal DisableAllPrivileges As Boolean, _\n    ByRef NewState As TOKEN_PRIVILEGES, _\n    ByVal Zero As Integer, _\n    ByVal Null1 As IntPtr, _\n    ByVal Null2 As IntPtr _\n  ) As Boolean<\/pre>\n\n\n\n
Pinvoke est tr\u00e8s pratique car il permet d\u2019\u00e9tendre les fonctionnalit\u00e9s de .NET, et puisqu\u2019il est possible de l\u2019utiliser en m\u00e9moire (sans toucher le disque) il devient d\u2019autant plus puissant. En effet, tous les programmes qui n\u00e9cessitaient d\u2019\u00eatre \u00e9crit en C++ ou en C peuvent d\u00e9sormais avoir une impl\u00e9mentation en code manag\u00e9. En tant qu\u2019attaquant, il y a donc tout int\u00e9r\u00eat \u00e0 l\u2019utiliser. Mais comment fonctionne ce fameux attribut ? Il va dans un premier temps chercher la dll, puis il va utiliser LoadLibrary()<\/code> pour la charger en m\u00e9moire, et enfin utiliser la fonction GetProcAddress()<\/code> pour charger la fonction. Bien que les derni\u00e8res fonctions cit\u00e9es soient des fonctions natives, elles sont accessible via la dll mscoree.dll<\/code> qui est la librairie o\u00f9 CLR est impl\u00e9ment\u00e9.<\/p>\n\n\n\n
\u00c9quivalence de type<\/h2>\n\n\n\n
Avant de rentrer dans le c\u0153ur du sujet, il est n\u00e9cessaire de parler objet. Les types qu\u2019utilisent C# et PowerShell sont des objets, or ce n\u2019est absolument pas le cas du C, o\u00f9 un type ne repr\u00e9sente qu\u2019un espace en m\u00e9moire. Il faut donc \u00e9tablir une \u00e9quivalence entre les types .NET et les types non manag\u00e9s pour pouvoir appeler des fonctions natives. Petit point d\u00e9finition, on appelle “marshaling” l\u2019op\u00e9ration de transformation d\u2019un objet en un ensemble de type plus simple (on retrouve ainsi la d\u00e9finition de la s\u00e9rialisation). Voici un tableau assez complet\u00a0:<\/p>\n\n\n\n
Nom dans la
documentation Microsoft<\/td>		Nom du type en C<\/td>Nom du type en C#<\/td><\/td><\/td><\/td><\/td><\/tr>
 VOID<\/code><\/td>void<\/code><\/td>System.Void<\/code><\/td><\/td><\/td><\/td><\/td><\/tr>
HANDLE<\/code><\/td>void *<\/code><\/td>System.IntPtr<\/code><\/td><\/td><\/td><\/td><\/td><\/tr>
BYTE<\/code><\/td>unsigned char<\/code><\/td>System.Byte<\/code><\/td><\/td><\/td><\/td><\/td><\/tr>
SHORT<\/code><\/td>short<\/code><\/td>System.Int16<\/code><\/td><\/td><\/td><\/td><\/td><\/tr>
WORD<\/code><\/td>unsigned short<\/code><\/td>System.UInt16<\/code><\/td><\/td><\/td><\/td><\/td><\/tr>
INT<\/code><\/td>int<\/code><\/td>System.Int32<\/code><\/td><\/td><\/td><\/td><\/td><\/tr>
UINT<\/code><\/td>unsigned int<\/code><\/td>System.UInt32<\/code><\/td><\/td><\/td><\/td><\/td><\/tr>
LONG<\/code><\/td>long<\/code><\/td>System.Int32<\/code><\/td><\/td><\/td><\/td><\/td><\/tr>
BOOL<\/code><\/td>long<\/code><\/td>System.Bool<\/code><\/td><\/td><\/td><\/td><\/td><\/tr>
DWORD<\/code><\/td>unsigned long<\/code><\/td>System.UInt32<\/code><\/td><\/td><\/td><\/td><\/td><\/tr>
ULONG<\/code><\/td>unsigned long<\/code><\/td>System.UInt32<\/code> <\/td><\/td><\/td><\/td><\/td><\/tr>
CHAR<\/code><\/td>char<\/code><\/td>System.Char<\/code><\/td><\/td><\/td><\/td><\/td><\/tr>
WCHAR<\/code><\/td>wchar_t<\/code><\/td> System.Char<\/code> <\/td><\/td><\/td><\/td><\/td><\/tr>
LPSTR<\/code><\/td>char *<\/code><\/td>System.String<\/code><\/td><\/td><\/td><\/td><\/td><\/tr>
LPCSTR<\/code><\/td>const char *<\/code><\/td> System.String <\/code><\/td><\/td><\/td><\/td><\/td><\/tr>
LPWSTR<\/code><\/td>wchar_t *<\/code><\/td>System.String <\/code><\/td><\/td><\/td><\/td><\/td><\/tr>
FLOAT<\/code><\/td>float<\/code><\/td>System.Single<\/code><\/td><\/td><\/td><\/td><\/td><\/tr>
DOUBLE<\/code><\/td>double<\/code><\/td>System.Double<\/code><\/td><\/td><\/td><\/td><\/td><\/tr>
LPCWSTR<\/code><\/td>const wchar_t *<\/code><\/td>System.String <\/code><\/td><\/td><\/td><\/td><\/td><\/tr><\/tbody><\/table>

Les types System.String peuvent \u00eatre remplac\u00e9 par System.Text.StringBuilder
r\u00e9f\u00e9rence: https:\/\/docs.microsoft.com\/fr-fr\/dotnet\/framework\/interop\/marshaling-data-with-platform-invoke<\/a><\/figcaption><\/figure>\n\n\n\n
Si un pointeur est requis, il faudra simplement ajouter .MakeByRefType()<\/code> apr\u00e8s le type, et on utilisera [ref]<\/code> devant la variable qui contient le contient. Lorsqu\u2019il s\u2019agira de structures ou d\u2019\u00e9num\u00e9rations, il sera alors n\u00e9cessaire de les d\u00e9finir au pr\u00e9alable.<\/p>\n\n\n\n
La mani\u00e8re la plus simple<\/h2>\n\n\n\n
Dans le but de faire du Pinvoke depuis PowerShell, le plus simple est d\u2019ajouter du code .NET \u00e0 la session actuelle. Vous vous rappelez peut-\u00eatre alors que Add-Type<\/code>, est une Cmdlet qui permet de r\u00e9pondre \u00e0 ce besoin. L\u2019avantage de cette m\u00e9thode est sa simplicit\u00e9. En effet, les signatures des fonctions \u00e0 importer sont les m\u00eames que celles en C#. En cela, notre travail r\u00e9sidera seulement \u00e0 aller sur pinvoke.net<\/a> chercher notre fonction, et l\u2019importer. Voici un exemple avec la MessageBox<\/code> qui permet d\u2019ouvrir une boite de dialogue contenant un message.<\/p>\n\n\n\n
$Signature = @'\n    [DllImport(\"user32.dll\", CharSet = CharSet.Unicode, EntryPoint = \"MessageBoxW\", ExactSpelling = true)]\n    public static extern int MessageBox(IntPtr hWnd, string text, string caption, int type);\n'@\n\nAdd-Type -MemberDefinition $Signature -Name User32 -Namespace Win32Functions\n\n[Win32Functions.User32]::MessageBox([IntPtr]::Zero, \"hello\", \"PInvoke\", 0x40)<\/pre>\n\n\n\n
Cependant, Add-Type<\/code> laisse des fichiers de compilation et appelle un processus non-trivial csc.exe<\/code> qui n\u2019est pas utilis\u00e9 pour autre chose que cela. Pour importer son code, il va d\u2019abord le compiler, et l\u2019ajouter en utilisant System.Reflection<\/code>. Ce qui, dans une perspective de discr\u00e9tion, n\u2019est clairement pas recommandable. Ainsi, on souhaite une meilleure m\u00e9thode pour acc\u00e9der \u00e0 du code non manag\u00e9. @Mattifestation<\/a> nous a alors offert le fruit de son travail: PSReflect<\/a>.<\/p>\n\n\n\n
PSReflect<\/h2>\n\n\n\n
PSReflect est assur\u00e9ment la mani\u00e8re la plus \u00e9l\u00e9gante de faire du Pinvoke en PowerShell. Il se base principalement sur les pouvoirs de la r\u00e9flexion puisqu\u2019il va utiliser l\u2019attribut [DllImport()]<\/code>. L\u2019id\u00e9e g\u00e9n\u00e9rale de cette librairie est “d\u2019\u00e9muler une syntaxe type C”. Ainsi beaucoup de fonctions ne sont pas des fonctions Cmdlets (aussi appel\u00e9es fonctions avanc\u00e9es). Le module exporte les fonctions suivantes:<\/p>\n\n\n\n