vendredi 19 décembre 2014

DotNet Renamer & Dnlib : Changement de crèmerie

DotNet Renamer utilisait jusqu'ici la librairie Mono.Cecil mais depuis cet-après-midi j'ai décidé d'utiliser Dnlib, cette librairie développée par 0xd4d me semble être un très bon compromis en terme de perspectives d'évolutions du projet !

Vous pouvez dors et déjà télécharger cette nouvelle mouture ici :

Bon codage. 

mercredi 17 décembre 2014

DotNet Renamer : MAJ vers 1.1.7.0

BugFix : Mauvais renommage des noms de propriétés et noms de resources !

--> Projet accessible ici

dimanche 7 décembre 2014

Imabox Uploader : MAJ vers 3.2.0.0


BugFix : Aucune action lors de l'hébergement car le niveau d'obfuscation était trop agressif !

http://wallace87000.upd.fr/ImaboxUploader.exe


Un merci à RoroXP, GDB et Nash pour le retour de ce Bug.

samedi 29 novembre 2014

DotNet Patcher v4.5.5 : Obfuscator, Packer, Dependency merging, Assembly Changer, ....

[DESCRIPTION]

Cet utilitaire permet en toute modestie d'obfusquer vos binaires DotNet (C#, VbNet principalement).



Ne prends pas en charge les binaires codés en WPF !


[SCREENSHOT]



 [FONCTIONNALITES]

* Obfuscator/Packer detection
* Version infos changer
* Dependency detection/merging
* Requested level execution detection/changer
* Icon Changer
* Obfuscator/Packer :

- Renamer scheme (Alphabetic, invisible, dots, chinese, japanese, greek)
- Obfuscation & Packer scheme (Namespaces, Types, Methods, Properties, Fields, Events, Parameters, Variables, CustomAttributes)
- Obfuscation settings (rename resources content, resources encryption & compression, strings encryption, integers & booleans encoding, public calls hidding, Pinvoke calls hidding, anti-debug/tamper/dumper/ildasm, stackflow)
- Packer : Lzma compression


[PREREQUIS]
- Système d'exploitation Windows Vista, 7 et 8
- Le DotNet Framework 4 minimum
- Ne nécessite pas d'installation


[REMERCIEMENTS]
--> jbevain pour sa librairie Mono.Cecil (https://github.com/jbevain/cecil)
--> Xertz pour son theme que j'ai agrémenté pour DNP.
--> aeonhack's pour son "ThemeBase"
--> Gluck pour son projet ILRepack que j'ai intégré dans DNP
--> Ploxy (The-One) pour ses quelques conseils.
--> Xenocode pour ses conseils et astuces.
--> nash pour la batterie de tests des versions Beta.


lundi 10 novembre 2014

DotNet Patcher v4 : 1ère Beta pour les phases de test.

Après 9 mois de labeur à étudier et remodeler le projet "DotNet Renamer", ce dernier fait aujourd'hui partie intégrante du projet "DotNet Patcher v4".

DotNet Patcher v4 n'est autre qu'une version revisitée de son prédécesseur avec quelques améliorations notables.
Cependant, notons également sur le point négatif qu'elle ne prends pas en charge les applications qui contiennent des appels aux méthodes de l'espace de noms "System.Reflection", en somme très complexe à mettre en place. Amis développeurs, il est donc recommandé de ne pas utiliser "la partie renommage" de cet outil si ces appels sont présents dans vos projets !

Merci à mes plus fidèles bêtas-testeurs : Nash, Guillaume et Neo.



lundi 27 octobre 2014

DotNet Renamer : MAJ vers 1.1.4.0

Modifié : Ajout de l'interface ICore20Reader afin de simplifier l'utilisation$
Ajouté : Classe Cls_Task afin d'améliorer et de simplifier l'utilisation de la librairie de renommage..

Comment utiliser simplement la librairie :

Dim _param = New Cls_Parameters(TxbSelectedFile.Text, TxbSelectedFile.Text & "-Renamed.exe")
    If _param.isValidFile Then
 
          Dim _paramArgs As New Cls_RenamerState() With { _
                                                         .Namespaces = True, _
                                                         .Types = True, _
                                                         .Methods = True, _
                                                         .Properties = True, _
                                                         .CustomAttributes = True, _
                                                         .Events = True, _
                                                         .Fields = True, _
                                                         .Parameters = True, _
                                                         .Variables = True, _
                                                         .RenameMainNamespaceSetting = Cls_RenamerState.RenameMainNamespace.NotOnly, _
                                                         .ReplaceNamespacesSetting = Cls_RenamerState.ReplaceNamespaces.Empty, _
                                                         .RenamingType = Cls_RandomizerType.RenameEnum.Chinese, _
                                                         .RenameRuleSetting = Cls_RenamerState.RenameRule.Personalize}
 
          Dim _Task = New Cls_Task(_param, _paramArgs)
          _Task.StartTask()
 
          MessageBox.Show("Renamed :" & vbNewLine & vbNewLine & _
                          "Namespace(s) : " & _Task.Result.Item("Namespace").ToString & vbNewLine & _
                          "Type(s) : " & _Task.Result.Item("Type").ToString & vbNewLine & _
                          "Method(s) : " & _Task.Result.Item("Method").ToString & vbNewLine & _
                          "Parameter(s) : " & _Task.Result.Item("Parameter").ToString & vbNewLine & _
                          "Generic Parameter(s) : " & _Task.Result.Item("Generic Parameter").ToString & vbNewLine & _
                          "Variable(s) : " & _Task.Result.Item("Variable").ToString & vbNewLine & _
                          "Property(s) : " & _Task.Result.Item("Property").ToString & vbNewLine & _
                          "Event(s) : " & _Task.Result.Item("Event").ToString & vbNewLine & _
                          "Field(s) : " & _Task.Result.Item("Field").ToString _
           , "Completed", MessageBoxButtons.OK, MessageBoxIcon.Information)
 
    End If

--> Projet accessible ici

lundi 20 octobre 2014

DotNet Renamer : MAJ vers 1.1.3.0

Modified : L'Assembly est chargé dans un AppDomain afin d'être déchargé correctement !
Added : Chargement des informations d'Assembly via Reflection.

--> Projet accessible ici

jeudi 9 octobre 2014

DotNet Patcher v4.0

Salut à tous,

Le développement de DotNet Renamer est arrivé à son terme depuis environ 2 mois et depuis j'ai remis le couvert avec la version 4 de DotNet Patcher.
En sommes voici les quelques ajouts (sans parler des améliorations apportées à la v3) :



Reste à savoir si cette mouture sera rendue publique. ;)

dimanche 14 septembre 2014

DotNet Renamer : MAJ vers 1.1.2.0


Modified : Toutes les méthodes Set et Get et les propriétés sont renommées
Modified : Mise à jour des Types et Propriétés dans la/les procédures InitializeComponent(s)
Added : Schéma de renommage : Greek
Added : Renommage des NestedTypes

--> Commit accessible ici
--> Projet accessible ici

mardi 26 août 2014

DotNet Renamer : MAJ vers 1.1.1.0


- BugFix : Erreur lors du chargement d'assembly depuis la classe Analyzer
- Added : Renommage du contenu des ressources (Screenshot)

--> Commit accessible ici
--> Projet accessible ici



lundi 11 août 2014

Imabox Uploader : MAJ vers 3.1.0.2

Imabox Uploader : MAJ vers 3.1.0.2


- BugFix : L'appli ne gère pas la visualisation des SWF depuis l'espace membre !

http://wallace87000.upd.fr/ImaboxUploader.exe


Un grands merci à Hornet51 pour le retour de ce Bug

lundi 21 juillet 2014

Imabox Uploader (Capture, modification et hébergement d'images)

[DESCRIPTION]

Cet utilitaire permet de capturer une zone de votre écran à l'aide de votre curseur de souris ou de raccourcis clavier.
Vos captures ainsi que vos images peuvent être éditées grâce à votre logiciel d'édition favoris, redimensionnées puis enfin hébergés chez l'hébergeur imabox.
Un historique de vos fichiers hébergés vous donnera accès aux liens http afin de les réutiliser plus tard (s'ils existent toujours selon le service de l'hébergeur).

Les points forts:
- Historique d'hébergement : récupérer vos images précédemment hébergées grâce à leurs Url.
- File d'attente d'hébergement : idéale pour rédiger des tutoriaux.
- Gestionnaire de compte Imabox : Gérer votre espace depuis l'application.
- Paramétrage de vos raccourcis clavier : capturer la fenêtre active ou l'écran.


[SCREENSHOTS]

Fenêtre principal : File d'attente d'hébergement


Historique : Récupération de vos images hébergées (membre ou anonyme)



Options : Hébergement, images, etc...







A propos : Informations, remerciements et support


 [FONCTIONNALITES]

- héberger des fichiers : bmp, jpg, gif, png au clic droit
- définir une zone puis la capturer
- ajouter des fichiers dans la liste par glissé-déposé
- capture d'écran depuis le raccourci clavier lorsque le logiciel est réduit dans la zone de notifications
- retrait de fichiers dans la file d'attente d'hébergement
- copie des liens dans le presse-papier
- visualisation de l'image en miniature
- redimensionnement des images de la liste avant hébergement
- affichage en temps réel de l'hébergement de chaque fichier
- possibilité de consulter les fichiers hébergés depuis l'historique
- filtre de l'historique depuis l'entête des colonnes
- possibilité de télécharger à nouveau les fichiers hébergés
- réduire l'application dans la zone de notifications
- menu dans la zone de notifications
- gestion de votre espace membre imabox (vos images hébergées)
- détection en temps réel de la connexion Internet.


[PREREQUIS]

- Système d'exploitation Windows Vista, Windows 7 et Windows 8
- Le DotNet Framework 4 minimum
- Ne nécessite pas d'installation

[REMERCIEMENTS]

mercredi 16 juillet 2014

Tuto : Créer un contrôle Textbox n'autorisant que certains caractères (Regex ou expressions régulières)

 Créer un contrôle TextBox n'autorisant que certains caractères (Regex ou expressions régulières)

Il devient parfois difficilement maintenable de toujours placer du code dans les gestionnaires d’événement du formulaire principal d'une application. 
Dans le cas particulier ou nous souhaiterions interdire la saisie de certains caractères dans une TextBox (dans notre exemple : LTextBox2) il nous faudrait alors utiliser les 2 gestionnaires d’événement suivants :

    Private Sub LTextBox2_KeyPress(sender As Object, e As KeyPressEventArgs) Handles LTextBox2.KeyPress
 
        If Not Char.IsControl(e.KeyChar) AndAlso Not IsNumeric(e.KeyChar) AndAlso e.KeyChar <> "." AndAlso e.KeyChar <> " " Then
            e.Handled = True
            MessageBox.Show("Valeur numérique uniquement !")
        End If
 
    End Sub
 
    Private Sub LTextBox2_TextChanged(sender As Object, e As EventArgs) Handles LTextBox2.TextChanged
 
        For Each c As Char In LTextBox2.Text.ToCharArray
            If Not IsNumeric(c) AndAlso c <> "." AndAlso c <> " " Then
                LTextBox2.Text = LTextBox2.Text.Replace(c, String.Empty)
                MessageBox.Show("Valeur numérique uniquement !")
            End If
        Next
 
    End Sub

Cet exemple extrait de ce billet autorise uniquement la saisie de caractères alphanumériques !
On se rends vite compte que l'implémentation de plusieurs TextBox deviendrait très difficilement maintenable !

En m'inspirant de cet exemple j'ai développé (en toute modestie) un petit contrôle hérité qui permet de vérifier lors de la saisie si les caractères entrés par l'utilisateur sont correctes selon le pattern Regex que le développeur aura placé dans la propriété adequate du contrôle "TextBoxEx".

Le contrôle TextBoxEx :

Imports System
Imports System.ComponentModel
Imports System.Data
Imports System.Drawing
Imports System.Text
Imports System.Windows.Forms
Imports System.Text.RegularExpressions
 
Partial Public Class TextBoxEx
    Inherits TextBox
 
#Region " Declarations "
    Private m_errorProvider As ErrorProvider = Nothing
    Private m_useRegularExpressionRegex As Regex = Nothing
#End Region
 
#Region " Properties "
    Private _UseRegularExpressionPattern As String
    Public Property UseRegularExpressionPattern() As String
        Get
            Return _UseRegularExpressionPattern
        End Get
        Set(ByVal value As String)
            If value IsNot Nothing Then m_useRegularExpressionRegex = New Regex(value, RegexOptions.Compiled)
            _UseRegularExpressionPattern = value
        End Set
    End Property
 
    Public Property UseRegularExpression As Boolean
    Public Property UseRegularExpressionErrorMessage As String
#End Region
 
#Region " Constructor "
    Public Sub New()
        m_errorProvider = New ErrorProvider
    End Sub
#End Region
 
#Region " Methods "
 
    Protected Overrides Sub OnValidating(e As CancelEventArgs)
        'OnValidating est déclenché lorsqu'on clique sur un autre contrôle dans la zone cliente du formulaire
        MyBase.OnValidating(e)
        SetErrorProvider()
    End Sub
 
    Protected Overrides Sub OnTextChanged(e As EventArgs)
        'OnTextChanged est déclenché lorsqu'un caractère est saisi dans la textbox.
        MyBase.OnTextChanged(e)
        SetErrorProvider()
    End Sub
 
    Private Sub SetErrorProvider()
        If UseRegularExpression And UseRegularExpressionPattern IsNot Nothing Then
            'On appelle la Fonction qui permet de vérifier l'exactitude des caractères saisis dans la textbox 
            If ValidateControl() = False Then
                'Me.Text = String.Empty
                If Not Me.Text.Length = 0 Then
                    Me.Text = Me.Text.Substring(0, Me.Text.Length - 1)
                    Me.Select(Me.Text.Length, 0)
                End If
                'ErrorProvider affiche une infobulle rouge à droite de la textbox.
                m_errorProvider.SetError(Me, UseRegularExpressionErrorMessage)
            Else
                'La saisie est valide donc rien n'est affiché dans ErrorProvider
                m_errorProvider.SetError(Me, String.Empty)
            End If
        End If
    End Sub
 
    Private Function ValidateControl() As Boolean
        ' Si le pattern est bon alors on vérifie que le texte tapé correspond au pattern 
        Return m_useRegularExpressionRegex.IsMatch(Me.Text)
    End Function
#End Region
 
End Class

Comment utiliser ce contrôle hérité :

  1. Ajouter une nouvelle classe dans votre projet nommée "TextboxEx"
  2. Sélectionnez le code plus haut et collez-le dans votre classe "TextBoxEx" (écrasez le contenu !)
  3. Régénérez votre projet
  4. Passez en mode "Concepteur de vues" 
  5. Dans votre boite à outils sélectionnez le contrôle "TextBoxEx" puis faites-le glisser sur votre formulaire : 

  6. Enfin sélectionnez votre TexBox puis paramétrez les propriétés :
    - "UseRegularExpressionPattern" avec le pattern : ^[0-9\b]+$ (ou le pattern RegEx que vous voulez)
    - "UseRegularExpression" à True
    - "UseRegularExpressionErrorMessage" avec la valeur Vous devez saisir uniquement des chiffres !
    ..... comme suit : 

    7. Voilà en image le résultat lorsque l'utilisateur tape un caractère alphabétique et non alphanumérique comme le préconise le pattern RegEx au dessus : 
                                                                                                                                                                               




mardi 1 juillet 2014

Tuto : Créer 1 Bitbucket et le gérer avec Source Tree Git Client

CREER UN BITBUCKET
ET  LE GERER AVEC
SOURCE TREE GIT CLIENT

Pdf disponible ici : http://wallace87000.upd.fr/CREER_UN_BITBUCKET_ET_LE_GERER_AVEC_SOURCE_TREE_GIT_CLIENT.pdf

1- Introduction

Ras le bol d’héberger vos projets un peu partout sur la toile (Mega, FTP perso, MediaFire, FileFactory…etc..) et de devoir mettre à jour les liens de téléchargements à chaque mise à jour ! Lorsqu’on se lance dans des projets de développement de grande envergure, il devient alors nécessaire de recourir à un gestionnaire de sources comme Bitbucket.
Après avoir mis en avant les avantages du gestionnaire de sources Bitbucket, je vais vous guider pour le mettre en place en quelques étapes qui viseront dans un premier temps à créer un compte Bitbucket puis le paramétrer, installer le client Git nommé « Source Tree » et enfin harmoniser le tout pour profiter pleinement de la gestion de vos projets.


2- Pourquoi le gestionnaire de sources Bitbucket

Voici en quelques lignes ce qui caractérise principalement ce gestionnaire de sources :

       - création/gestion des dépôts privés et publics (dépôt = projet)
       - partage de projets avec d’autres personnes (l’open source à l’état pur)
       - travail collaboratif avec d’autres développeurs
       - accepter ou rejeter des « Pull Requests » (soumissions d’ajouts de fonctionnalités, de correctifs, …etc…) d’autres développeurs ayant bifurqués (Forker) votre/vos projet(s)
       - modification en ligne ou depuis le client Git « Source Tree » de votre code source (complet ou indexé)
       - navigation dans vos projets grace à l’historique de commits (modifications)
       - gestion de versionning et des branches du projet
       - …….etc……

Il est surtout primordial d’avoir l’assurance qu’un projet est toujours disponible depuis Internet et de pouvoir revenir sur des versions antérieures à n’importe quel moment !
Le principal avantage a tirer de cet outil (Bitbucket) par rapport à son concurrent (GitHub) tient essentiellement dans la possibilité d’héberger autant de dépôts privées que vous voulez si le nombre de collaborateurs ne dépasse pas 5 !

Plus d’infos icihttps://www.atlassian.com/fr/software/bitbucket/overview


3- Mon compte Bitbucket

a. Création du compte

Ouvrez cette page et inscrivez-vous : https://bitbucket.org/account/signup

b. Paramétrer son compte

Accédez aux paramétrages du compte en cliquant en haut à droite sur votre avatar puis « Manage Account »  afin d’accéder à ceci :



- Le menu latéral de gauche vous permettra de paramétrer en profondeur votre compte
IMPORTANT : Vous pouvez passer le langage d’interface de votre compte en Français et remplacer votre avatar par défaut en cliquant sur « Change Avatar ».

- Le menu en haut à gauche donne accès principalement :
      o Dashboard : vue d’ensemble (projets privés et publics), demande d’ajouts, signalement de bugs
      o Repositories : Créer un dépôt, importer un dépôt
      o Create : créer directement un dépôt


4- Source Tree Git Client

a. Installer le client

      o Téléchargez l’application depuis le site : http://www.sourcetreeapp.com/
      o Installez-le puis lorsqu’il vous sera demandé, cliquez sur le 1er choix :

               • Lorsqu’il  vous sera demandé, cliquez sur le dernier choix :

               • L’installation est terminée et la fenêtre de configuration du client apparait.

b. Configurer le client

      o A la fin de l’installation du client vous arrivez sur cette fenêtre :


      o Configurez le client comme suit :
               Saisissez votre nom complet et votre adresse mail qui seront utilisés par défaut lorsque vous soumettrez une modification (commit)
               Cochez la case d’acceptation du CLUFF
               Cliquez sur « suivant »
                       • A la nouvelle fenêtre qui s’affiche laissez coché par défaut (Use Putty) puis cliquez sur « suivant »
                       • Une nouvelle fenêtre s’affiche « charger une clé SSH ? », cliquez sur « No »
                       • Enfin remplissez les champs à l’aide de vos identifiants de connexion de compte Bitbucket :


                       • Votre client est maintenant paramétré et il ressemble à cela:

c. Créer un nouveau dépôt

IMPORTANT : Il est important de savoir que la création d’un nouveau dépôt vise à créer une arborescence de votre futur projet sur votre compte Bitbucket.

Il est donc possible de créer un nouveau dépôt de 2 manières :

      o Nouveau dépôt depuis le logiciel Source Tree :

               • Créez un répertoire nommé BITBUCKET (dans mon exemple « D:\BITBUCKET »). Ce répertoire accueillera tous vos projets BitBucket. Dans le langage GIT on appelle ca « la copie de travail » ou « Working Copy » pour les puritains. C’est depuis ce répertoire que partiront toutes vos modifications ou « commits » de vos projets vers l’hébergeur Bitbucket (ou projets hébergés).
               • Créez un autre répertoire portant le nom de votre projet (dans mon exemple « D:\BITBUCKET\DotNetPatcher »)
               • Cliquez sur le bouton :

               • Dans la nouvelle fenêtre sui s’affiche, cliquez sur le bouton (projets hébergés) :
               • Cette nouvelle fenêtre contenant vos projets hébergés apparait, cliquez sur le bouton « Créer un nouveau dépôt … » :


               • Renseignez la nouvelle fenêtre comme suit  à l’aide de votre nom de projet puis cliquez sur le bouton « Create Repository » :


               • Cliquez sur le bouton « OK »

IMPORTANT : Par défaut la création d’un dépôt est marquée en tant que « Non visible publiquement » ou « Private Repository » ! A vous de prévoir ultérieurement la disponibilité publique de votre projet.

Vous constaterez que votre dépôt vide a été créé sur votre compte bitbucket et il est accessible et visible uniquement par vous depuis cette url : https://bitbucket.org/3dotdev/dotnetpatcher

      o Nouveau dépôt depuis votre compte Bitbucket
               Cliquez sur le bouton :
               Remplissez les champs puis validez en cliquant sur « Créer un dépôt » :


d. Clôner un dépôt

IMPORTANT : Il est important de savoir que le clonage d’un dépôt vise à créer une arborescence ou « copie de travail » de votre futur projet sur votre PC (en local).

Il est désormais possible de cloner votre dépôt de 2 façons :
      o Clôner depuis l’URL « https://bitbucket.org/3dotdev/dotnetpatcher », générée précédamment  lors de la création d’un nouveau dépôt :

               Cliquez sur le bouton « Clôner dans Source Tree » :


A NOTER : Pour permettre la création de l’arborecence de la copie de travail sur votre PC vous devrez autoriser le site Bitbucket à prendre la main sur votre ordinateur. Suivez les autres étapes pour clôner votre dépôt ou passez à la méthode décrite ci-après.

      o Clôner depuis Source Tree directement en procédant comme suit :
               Cliquez sur le bouton :
               Dans la nouvelle fenêtre qui s’affiche, cliquez sur le bouton (projets hébergés)
               Sélectionnez votre nouveau dépôt créé précédemment (dans mon exemple : DotNetPatcher) :


                       • Sélectionnez ensuite votre répertoire de travail créé précédemment, dans mon exemple« D:\BITBUCKET\DotNetPatcher ».
Votre fenêtre ressemble à ceci :


                       • Cliquez sur le bouton :
                       • Vous obtenez ce contenu dans Source Tree :



e. Ajouter un projet dans votre dépôt local

La notion de dépôt fait référence au projet hébergé (sur votre compte Bitbucket) et le clônage fait référence à la copie de travail (en local).
Avant de procéder à l’hébergement de votre projet sur Bitbucket, vous devez ajouter votre projet créé sous Visual Studio dans votre copie locale en procédant de cette manière :

      o copiez le contenu de votre projet depuis le répertoire par défaut  de Visual Studio « D:\Documents\Visual Studio 2012\Projects\DotNetPatcher » vers  le répertoire de travail : « D:\BITBUCKET\DotNetPatcher ».
Le contenu de la fenêtre Source Tree se mets automatiquement à jour car votre répertoire de travail a subit des modifications :


A NOTER : Dans la partie « Changements de la copie de travail » vous pouvez remarquer les fichiers qui ont été ajoutés.


f. Ajouter votre projet dans le dépôt hébergé

Cette étape nécessite obligatoirement d’avoir procéder à la création, le clonage, et la copie de votre projet en local

      o Au même niveau que le titre « Changements de la copie de travail », cliquez sur le bouton :
 afin d’ajouter tous les fichiers dans la partie « Changements indexés » juste au dessus.
Vous obtenez ceci :


      o Validez vos modifications en cliquant sur le bouton « Valider » (commit). Vous obtenez cette fenêtre, veillez à renseigner le champ « message de validation » permettant de décrire votre commit et à cocher la case « envoyer immédiatement les validations vers origin » comme ceci :


      o Cliquez sur le bouton « Valider » et attendez la fin de l’opération d’hébergement de votre projet
      o Observez vos commits en cliquant sur « Branches/master » dans le menu latéral de gauche :

 IMPORTANT : Pour committer votre projet sur votre espace hébergé :

      o Ouvrez votre projet situé dans le répertoire de la copie de travail (D:\BITBUCKET\DotNetPatcher) avec Visual Studio. Codez, déboggez…etc….  puis enregistrez
      o Revenez dans Source Tree et cliquez sur le bouton :
   afin d’ajouter les fichiers dans la catégorie des « changements indexés »
      o En somme répétez toute l’étape « f ».
      o Lorsque votre projet sera terminé, n’oubliez pas d’éditer le fichier « Readme » en ligne :


Plus d’infos ici https://bitbucket.org/tutorials/markdowndemo


g. Accéder aux paramètres de votre projet depuis votre compte Bitbucket

      o Accédez à l’url de votre projet : https://bitbucket.org/3dotdev/dotnetpatcher
      o Naviguez dans le menu latéral de gauche et cliquez sur l’icône :
  puis changer le logo de votre projet, le langage de programmation, …etc…et pensez à enregistrer les modifications :



IMPORTANT : Vous pouvez également supprimer votre dépôt depuis cette même fenêtre !


Si vous avez des questions quant à l’édition de votre code source en ligne et à la récupération des modifications depuis votre espace hébergé ou toutes autres choses…n’hésitez pas.

A+

dimanche 25 mai 2014

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 :

vendredi 23 mai 2014

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. ;)

jeudi 15 mai 2014

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 !

vendredi 2 mai 2014

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

samedi 26 avril 2014

Right-Clic Context Menu

[DESCRIPTION]

Right-Clic Context Menu (RCCM) est le successeur de My 7 Context menu et My 8 Context Menu.
Right-Clic Context Menu (RCCM) est un petit utilitaire qui facilite la gestion des menus contextuels sur Windows Vista, Windows 7, Windows 8, 8.1 et Windows 10 (NT 6). Il permet d'afficher, de créer, de modifier, de supprimer des items des différentes catégories des menus contextuels :

- de l'ordinateur
- des lecteurs
- du bureau
- des dossiers
- des fichiers


[SCREENSHOT]



[FONCTIONNALITES]

- afficher les items des différentes catégories des menus contextuels.
- éditer certains items modifiables.
- supprimer l'item sélectionné.
- créer un menu contextuel simple ou bien en cascade avec autant de commandes que vous le souhaitez.
- ajouter un programme et ou/un fichier de commande (.bat,.exe).
- ajouter une icône depuis un fichier exécutable ou bien en sélectionnant une icône directement.
- ajouter un lien URL depuis vos favoris ou bien en simple copier/coller.
- sélectionner l'endroit ou vous voulez voir apparaitre votre item dans votre menu contextuel (haut, centre, bas).
- possibilité d'étendre le menu contextuel avec la combinaison des touches "SHIFT+Clic-droit".
- restauration des clés de registre avant modification (état des clés de registre avant ouverture du soft).
- ajout de menus contextuels simples ou en cascade personnalisable avec des items prédéfinis au choix.
- possibilité d'exporter les menus contextuels créés en fichier ".reg".
- ne prends pas en charge les marques-pages de Mozilla FireFox


[PREREQUIS]

- Système d'exploitation Windows Vista, 7, 8, 8.1, 10
- Le DotNet Framework 4.0 minimum.
- Ne nécessite pas d'installation


[REMERCIEMENTS]

- La librairie SetACL pour la gestion des permissions du registre en 32 et 64 Bits.