[.Net]Présentation LM-Obfuscator béta

[Neeizh]

gg nooby

 

[deleted584586]

C# est basé sur une logique de se style int test = mafonction(maf2(maf3(2)));
elle va toujour effectuée cette opération:

int test = <- mafonction <- maf2 <- maf3 <- 2

Pour moi, une simplification sa serait de pouvoir voir:
int test = mafonction(maf2(maf3(2)));
int test = mafonction(maf2(10));
int test = mafonction(20);
int test = 40;

Exemple (tréééééés simpliste) :

class yolocrypt
{
  public string c(String c)
  {
      return superdecrypt(c);
  }
  public string d(String d)
  {
     return this.c(d)
  }
}

class lol
{
   string c;
   public lol (String l)
   {
      this.c = l;
   }

   public int l ()
   {
      return superdecryptint(this.c);
   }
}

String mon_string = yolocrypt.d("ijdoiajozqd");
lol mon_cryin("zdzqqzdqdz");
int resultat = 1 + mon_cryin.l();

Si ont demandé à un programme de découpé est d'interprété les classe, puis de "Simplifier" (ou d'interpretée comme vous voulez) la ligne suivante en demandant un retour constant de la simplification.

Exemple de l'output:
String mon_string = yolocrypt.d("ijdoiajozqd");
->
String mon_string = "yo";

Ou (pour le int)

lol mon_cryin("zdzqqzdqdz");
int resultat = 1 + mon_cryin.l();
->
int resultat = 1 + 2;
->
int resultat = 3;

Sa reste du théorique, ont ne peut surement pas déobfusqué un programme mais sa peut surement extrêmement simplifier la vie pour la déobfuscation

@.NETGuard tu en pense quoi ?

 

[.NETGuard]

C# est basé sur une logique de se style int test = mafonction(maf2(maf3(2)));
elle va toujour effectuée cette opération:

int test = <- mafonction <- maf2 <- maf3 <- 2

Pour moi, une simplification sa serait de pouvoir voir:
int test = mafonction(maf2(maf3(2)));
int test = mafonction(maf2(10));
int test = mafonction(20);
int test = 40;

Exemple (tréééééés simpliste) :

class yolocrypt
{
  public string c(String c)
  {
      return superdecrypt(c);
  }
  public string d(String d)
  {
     return this.c(d)
  }
}

class lol
{
   string c;
   public lol (String l)
   {
      this.c = l;
   }

   public int l ()
   {
      return superdecryptint(this.c);
   }
}

String mon_string = yolocrypt.d("ijdoiajozqd");
lol mon_cryin("zdzqqzdqdz");
int resultat = 1 + mon_cryin.l();

Si ont demandé à un programme de découpé est d'interprété les classe, puis de "Simplifier" (ou d'interpretée comme vous voulez) la ligne suivante en demandant un retour constant de la simplification.

Exemple de l'output:
String mon_string = yolocrypt.d("ijdoiajozqd");
->
String mon_string = "yo";

Ou (pour le int)

lol mon_cryin("zdzqqzdqdz");
int resultat = 1 + mon_cryin.l();
->
int resultat = 1 + 2;
->
int resultat = 3;

Sa reste du théorique, ont ne peut surement pas déobfusqué un programme mais sa peut surement extrêmement simplifier la vie pour la déobfuscation

@.NETGuard tu en pense quoi ?

T'as compris la logique. Après en pratique faut analyser la protection et voir si la "compléxité" pour obtenir une variable est due à l'utilisateur ou à un programme tiers, c'est à dire un obfuscator.
Pour cela il suffit de voir si cette même méthode, ici yolocrypt.d(), est appelé plus d'une fois. Généralement on regarde si les string sont également chiffrer dans le constructeur de la forme, ou alors dans la méthode
InitializeComponment, puisque les string ne sont jamais "retouchée" ici.
Autre chose, mais tout aussi notable, une string doit forcément être déchiffrée une fois qu'elle est appelé en temps que tel. Il 'suffit" donc de récupérer l'adresse RVA de l'OpCode CALL à la fonction yolocrypt.d(),
puis pour chaque adresse on continue à tracer l'OpCode jusqu'à ce qu'il soit decrypt puis on le remplace :

String mon_string = yolocrypt.d("ijdoiajozqd"); // RVA 0x2788
/* ici on continue à tracer l'OpCode CALL de l'adresse RVA */
Une fois la string decryté, on la vois en claire dans le Stack :

suffit donc maintenant de la remplacer :
OpCode.Code = OpCodes.Ldstr("yo");

Et voilà

 

[MindSystem]

C# est basé sur une logique de se style int test = mafonction(maf2(maf3(2)));
elle va toujour effectuée cette opération:

int test = <- mafonction <- maf2 <- maf3 <- 2

Pour moi, une simplification sa serait de pouvoir voir:
int test = mafonction(maf2(maf3(2)));
int test = mafonction(maf2(10));
int test = mafonction(20);
int test = 40;

Exemple (tréééééés simpliste) :

class yolocrypt
{
  public string c(String c)
  {
      return superdecrypt(c);
  }
  public string d(String d)
  {
     return this.c(d)
  }
}

class lol
{
   string c;
   public lol (String l)
   {
      this.c = l;
   }

   public int l ()
   {
      return superdecryptint(this.c);
   }
}

String mon_string = yolocrypt.d("ijdoiajozqd");
lol mon_cryin("zdzqqzdqdz");
int resultat = 1 + mon_cryin.l();

Si ont demandé à un programme de découpé est d'interprété les classe, puis de "Simplifier" (ou d'interpretée comme vous voulez) la ligne suivante en demandant un retour constant de la simplification.

Exemple de l'output:
String mon_string = yolocrypt.d("ijdoiajozqd");
->
String mon_string = "yo";

Ou (pour le int)

lol mon_cryin("zdzqqzdqdz");
int resultat = 1 + mon_cryin.l();
->
int resultat = 1 + 2;
->
int resultat = 3;

Sa reste du théorique, ont ne peut surement pas déobfusqué un programme mais sa peut surement extrêmement simplifier la vie pour la déobfuscation

@.NETGuard tu en pense quoi ?

Le but de l'obfuscation est d'essayer de rendre le logiciel "illisible" par les yeux humains mais la machine doit toujours les traité de la même façon.

Exemple :

string str = "Bonjour";

Console.WriteLine(str);

En obfusqué, cela pourrai donné :

class allint
{
int AC_16541 = 0:
string fff = "Bonjour";
string mlkqmldkfmlksdfmlkqdf = ffff;
}
bool uselessbool = true;
int uselessint = 165416541;
Console.WriteLine(allint.mlkqmldkfmlksdfmlkqdf);

Voilà donc peut-importe la manière dont est faites le code, le but ici est de le compliqué pour qu'une personne qui voudrait récupérer le source code de l'application ait du mal

 

[Azzaro]

Pas mal

 

[MindSystem]

Mise à jour [0.8]

---- Nouveautés? ----

- Nouveau GUI :

- Ajout de l'anti dumper

- Ajout du packer

- Amélioration mineure de la constant protection

- Amélioration de la ressource encryption

- Numeric Encoding ajouté

- Invalid OpCode développé