Ein kleiner Artikel für den heutigen Abend. Es geht um das fixxen einer “String-Encryption” (eigentlich ein simples Encoding) mit Hilfe von Mono.Cecil. Dabei werden wir alle Methoden zu dieser String-Encryption-Klasse mit einem ldstr-Opcode ersetzen und dabei natürlich nebenher den String decodieren.

Die String-Encryption-Klasse besteht aus einem großen Byte-Array (XORed). Alle 59 statischen Methoden dieser Klasse beinhalten in etwa folgendes:

public static string smethod_16()
{
    return (string_0[15] ?? smethod_0(15, 313, 8));
}

Alle dieser Methoden liefern also string_0[X] zurück ODER wenn dieses NULL ist smethod_0(X,Y,Y). X ist in diesem Fall die “ID” des Strings, Y wird später besprochen.

Nehmen wir also an wir finden einen Call zu einer solchen Funktion, dann speichern wir die MethodDefinition (quasi die Methoden-Klasse unter Mono.Cecil) ab und übergeben diese unserer Funktion:

if (Globals.lstTypes[i].lstMethods[j].Object.Body.Instructions[k].OpCode.Code == Mono.Cecil.Cil.Code.Call)
{
String sTemp = Globals.lstTypes[i].lstMethods[j].Object.Body.Instructions[k].GetInstructionString();
 
if (sTemp.Contains("PrivateImplementationDetails"))
{                                
MethodDefinition MD = (MethodDefinition)Globals.lstTypes[i].lstMethods[j].Object.Body.Instructions[k].Operand;
 
String sTempDecoded = Utils.GetDecodedStringFromMD(MD, byte_0);
Globals.lstTypes[i].lstMethods[j].Object.Body.Instructions[k] = new Mono.Cecil.Cil.Instruction(Mono.Cecil.Cil.OpCodes.Ldstr, sTempDecoded);
}
}

Wenig übersichtlich, ich weis Auf jeden Fall gehen wir alle Methoden durch und prüfen ob diese einen “Call” Opcode enthalten. Wenn ja, so wird geprüft ob eine Funktion aus dem <PrivateImplementationDetails>-Namespace gecalled wird, wenn ja haben wir eine Funktion smethod_X(). Diese erhalten wir über den Operand des Call-OpCodes.

Unsere gefundene MethodDefinition (smethod_X) wird nun an die Utils-Funktion übergeben, zusammen mit dem großen byte-Array mit wohl all den Strings drin. Diese im nächsten Absatz besprochene Funktion liefert uns den decodierten String. Der eigentliche Methodenaufruf (call smethod-X) wird nun durch ein “Ldstr DekodierterString” ersetzt, also wird der dekodierte String direkt geladen, nicht durch die decoding-Funktion.

Zum eigentlichen Decoding. Diese Funktion ist schnell erklärt, es geht mehr um die Mono.Cecil-Funktionsweise:

public static String GetDecodedStringFromMD(MethodDefinition MD, byte[] Array)
        {
            int[] iParams = new int[3];
            for (int i = 0; i < MD.Body.Instructions.Count; i++)
            {
                if (MD.Body.Instructions[i].GetInstructionString().Contains("call"))
                {
                    iParams[0] = (int)MD.Body.Instructions[i - 3].Operand;
                    iParams[1] = (int)MD.Body.Instructions[i - 2].Operand;
                    iParams[2] = (int)MD.Body.Instructions[i - 1].Operand;
                }
            }
 
            return  Encoding.Default.GetString(Array, iParams[1],iParams[2]);
        }

Vor dem eigentlichen Decode-Call werden 3 Argumente der Funktion übergeben (X, Y, Y) Diese werden ausgelesen, danach folgt die GetString-Funktion mit den ausgelesenen Parametern (Y) als Anfangsoffset und Länge. In Falle von smethod_16() wäre das ein Startoffset von 313 und eine Länge von 8 Zeichen. Und mehr macht die Utils-Funktion auch nicht. Und so leicht ist Mono.Cecil zu bedienen

Greez Easy

2 people like this post.

Like

Unlike