DotNet Renamer (Obfuscation/renommage d'assembly DotNet) : Code source enfin disponible

[DESCRIPTION]

DNR est un projet Open source qui permet d'obfusquer/renommer très modestement les assembly Dotnet (C# et VbNet uniquement) , grâce à la librairie MonoCecil.
Ce projet est basé sur la librairie de renommage de de mon autre projet DotNet Patcher
Cette librairie a été largement améliorée et ne cesse de mon côté d'évoluer en vue de faire mon obfuscateur privé comme je l'avais annoncé lors de l'arrêt du développement de DotNet Patcher !

Le projet est bien commenté afin de pouvoir l'adapter à vos besoins et il est composé essentiellement de 2 librairies :

- Core20Reader : un simple PE DotNet Parser/Reader que j'ai codé spécialement pour les besoins de DNR.
- Le renamer : composé des fichiers suivants : Core20Reader.dll, DotNetRenamer.Helper.dll, DotNetRenamer.Implementer.dll

[SCREENSHOT]

Fenêtre principale de DNR :

Résultat après renommage de l'assembly ouvert dans DotNet Reflector :

[FONCTIONNALITES]

* Ne supporte pas les programmes codés en WPF !

* Interface en anglais uniquement !

* Affiche les informations du programme sélectionné (assembly name, Version, TargetRuntime, TargetCPU, SubSystemType)

* Sélection d'un mode : Full, Medium, Customize

* Sélection du type d'encodage des caractères : Alphabetic, Dots, Invisible, Chinese, Japanese

* Possibilité de renommage : Namespaces, Types, Methods, Properties, Fields, Custom Attributes, Events, Parameters, .....

* Affiche le nombre de renommage par type lorsque la tache s'est achevée correctement.

........

........... etc...........

[REMERCIEMENTS]

* jbevains : pour la librairie MonoCecil

* Xertz : pour son thème Login GDI+ theme que je me suis permis de quelque peu modifier

* Paupino : pour ces quelques fonctions utiles de son projet open source : NCloak

[PRE-REQUIS]

- EDI VS2012 minimum

- Windows NT x.x.x (32 et 64 Bits)

- Ne nécessite pas d'installation

- Framework 4

[INFOS IMPORTANTES]

NB : Le type d'encodage des caractères qui ne pourra être renommé par un déobfuscteur (De4Dot,...etc....) est Alphabetic et qui ne fait pas gonfler la taille du binaire obfu !

NB : Cependant pour tous type de retour :
Veuillez créer une branche (forker) depuis mon Bitbucket, modifiez et requêtez (request a commit) : un bitbucket peut aussi servir à travailler ensemble et pas uniquement à se servir ! Merci.

[TELECHARGEMENT]

- Projet :

Bitbucket

Core20Reader : Reader/Parser de fichier PE DotNet

Mon dernier projet DotNet Renamer a nécessité que je code une librairie afin d'extraire quelques informations depuis un fichier PE DotNet.
Ceette librairie se nomme : Core20Reader et elle sera disponible sur mon Bitbucket au même titre que DotNet renamer.

Core20Reader est une modeste librairie qui offre la possibilité d'extraire les infos suivantes :
- TargetProcessor (x64, x86, AnyCPU)
- TargetRuntime (Version de framework prise en charge par le programme)
- isExecutableFile (ou DLL)
- isManagedFile (est un fichier DotNet)
- SubSystemType (Forms, Console)
- is32BitHeader

J'ai opté pour le développement de ce projet car je ne voulais pas charger les information depuis l'espace de noms "Reflection" du framework qui génère des erreurs lorsque le fichier DotNet que l'on souhaite inspecter est déjà chargé dans le GAC ou que des dépendances sont manquantes.....Mono Cecil est également limité lorsque le fichier en question est obfusqué ou packé.... ou qu'il contient du code "Over et Controlflow".....

.......
..........pour le reste il faut consulter toute l'implémentation interne. ;)

DotNet Renamer : obfuscation d'assembly DotNet

Le code source de DotNet Renamer (librairie de renommage d'assembly) sera bientôt disponible sur mon Bitbucket

Cela fait maintenant 15 jours que je travail sur un vieux projet déterré de l'année passée !
Ce projet n'est en somme que l'ossature de mon dernier projet du même genre nommé : DotNet Patcher


Cette librairie permet actuellement le renommage des types et membres suivants :

• Namespaces
• Types
• Methods
• Properties
• Fields 
• CustomAttributes (uniquement l'attribut "AccessedThroughPropertyAttribute" !)
• Events
• Variables
• Parameters

Il est bien évidement possible de tout paramétrer à souhait ou d'utiliser des paramètres définis (cf code en bas) ainsi que le choix des caractères de renommage aléatoire parmi lesquels :

• Alphabétique (A à Z en minuscule et majuscule)
• Chinois 
• Braie
• Invisible

Le renommage des noms de ressources est également pris en compte en adéquation avec le renommage des types et namespaces !

Voilà actuellement comment j'utilise ma librairie :

 
    Dim param As New Cls_Parameters("C:\AssemblyToRename.exe", "C:\AssemblyToRename-Renamed.exe")
    param.ReadAssembly()
 
    Dim context As New Cls_Context(param)
    context.RenamingAccept = New Cls_RenamerState() With _
       {.ReplaceSetting = Cls_RenamerState.ReplaceNamespaces.Empty, _
        .RenameSetting = Cls_RenamerState.RenameNamespaces.Full}
    context.RenamingType = Cls_RandomizerType.RenameEnum.Normal
 
    context.RenameAssembly()
    context.WriteAssembly()
    context.Clean()

L'explorateur de solutions de mon projet :

Je suis actuellement en train de commenter la source et ne cesserais de l'agrémenter les jours qui viennent.

A bientôt et bon codage !

Tuto : Fusionner dll(s) dans exe depuis Visual Studio sans passer par ILMerge ...etc...

I - Pré-requis :

Votre projet principal VBNET est obligatoirement paramétré comme suit pour suivre ce tuto :

II - Le projet :

Mon projet principal se nomme "ImaboxUploader".
Les 2 autres projets attenants sont des librairies de classes ou fichiers ".dll et se nomment :
- ImaboxUploader.Components (fichier .dll : ImaboxUploader.Components.dll)
- ImaboxUploader.Core (fichier .dll : ImaboxUploader.Core.dll)

III - Quand je génère mon projet principal :

Lorsque je génère mon projet principal, les autres projets attenants sont aussi générés ce qui créé 3 fichiers dans mon répertoire ...\Bin\Release\ :
(ces 3 fichiers étant nécessaires au bon fonctionnement de mon application lorsqu'elle sera délivrée) :

Cependant je ne veux pas livrer mon projet final avec 2 autres fichiers à côté donc il va me falloir fusionner les assemblys dépendantes (2 fichiers .dll) à mon exécutable principal (1 fichier .exe) afin de distribuer qu'un unique fichier exécutable (imaboxUploader.exe) !

IV - Ajouter les assemblys dépendantes dans les ressources :

- Tout d'abord il faut que votre projet soit fonctionnel en l'état !
- Dans mon exemple les 2 fichiers dll sont bien ajoutées en tant que références :

- Nous allons maintenant ajouter ces 2 fichiers dll dans les ressources de notre projet en vue d'obtenir ceci dans les propriétés de mon projet principal :

...et grâce à l'ajout dans les ressources on obtient donc cela dans l'explorateur de solutions :

IMPORTANT : n'oubliez pas de générer l'ensemble de votre projet afin que les fichiers dlls soient correctement intégrées dans les ressources !

V - Ajouter le code pour charger les assemblys dépendantes en mémoire au démarrage de l'application :

- Dans les propriétés du projet on clique sur le bouton suivant :

....on obtient ceci :

Namespace My
 
    ' Les événements suivants sont disponibles pour MyApplication*:
    ' 
    ' Startup*: déclenché au démarrage de l'application avant la création du formulaire de démarrage.
    ' Shutdown*: déclenché après la fermeture de tous les formulaires de l'application. Cet événement n'est pas déclenché si l'application se termine de façon anormale.
    ' UnhandledException*: déclenché si l'application rencontre une exception non gérée.
    ' StartupNextInstance*: déclenché lors du lancement d'une application à instance unique et si cette application est déjà active. 
    ' NetworkAvailabilityChanged*: déclenché lorsque la connexion réseau est connectée ou déconnectée.
    Friend Class MyApplication
 
    End Class
 
 
End Namespace

- Dans mon cas avec mes 2 dll je remplace le code existant par ceci :

Namespace My
    Friend Class MyApplication
        Private WithEvents DLLDomain As AppDomain = AppDomain.CurrentDomain
 
        Private Function DLL_AssemblyResolve(ByVal sender As Object, ByVal args As System.ResolveEventArgs) As System.Reflection.Assembly Handles DLLDomain.AssemblyResolve
            If args.Name.Contains("ImaboxUploader.Components") Then
                Return System.Reflection.Assembly.Load(My.Resources.ImaboxUploader_Components)
            ElseIf args.Name.Contains("ImaboxUploader.Core") Then
                Return System.Reflection.Assembly.Load(My.Resources.ImaboxUploader_Core)
            Else
                Return Nothing
            End If
        End Function
    End Class
 
 
End Namespace

IMPORTANT :
- N'oubliez pas de générer de nouveau votre projet !
- Si vous voulez tester que cela fonctionne alors assurez-vous de déporter votre fichier executable à l'extérieur de votre répertoire de génération de projet et que vos fichiers dll ne soient pas à côté car il sont maintenant censés être intégrés dans les ressources !

Si vous avez des questions ???

Source d'inspiration du tuto : Source d'inspiration