Ce site est optimisé pour être consulté depuis un navigateur moderne dans lequel JavaScript est activé.

Dofus 2 et le chiffrement RSA (youhou)

Hetarnam

Bonjour à tous, aujourd'hui, ON VA FABRIQUER UNE BOMBE. Non je déconne, je vais vous expliquer comment créer vos propre clefs RSA pour arrêter de charcuter votre client affin d'accéder au identifiants et la clef AES après lors de l'authentification. C'est mal, respectez votre Invoker.

Cette méthode à été testé sur 3 versions de Dofus 2, incluant la plus récente à ce jour, la 2.57.

Il vous faudra quelques outils, vos doigts en premier, mais également JPEXS qu'on ne présente plus, disponible sur Windows, Unix et probablement Mac j'ai la flemme de vérifier.

Comment ce merdier fonctionne donc ?

Déjà, il y a 5 clefs. Ouais je sais c'est déjà chiant.

Les deux plus importantes maintenant sont la SIGNATURE_KEY_DATA (qui s’appellera Brigitte dans la suite de ce tutoriel), et AuthentificationManager__verifyKey (qui sera donc Michel pour la suite), que vous pourrez trouver dans le dossier binaryData avec JPEXS une fois votre client ouvert.

Brigitte sert à signer des fichiers ou du texte, elle est utilisé dans la partie "host.signature" de votre config.xml, et également dans le fichier signature.xmls de votre thème Dofus (content/themes/darkTheme pour vous normalement).

Michel quant à lui, sert à chiffrer les identifiants en provenance votre client, c'est lui qui est casse couille, vous pouvez le taper allez-y.

Brigitte et Michel sont de type différent, Brigitte est une clef spéciale qui se construit à partir d'une clef RSA, mais qui ressort comme ça :

Michel est aussi construit à partir d'une clef RSA, mais ressort légèrement différent :

Commençons par le commencement, vous allez donc devoir utiliser votre langage de programmation préféré pour générer une paire de clef, publique et privée, de taille 2048 pour les besoins de ce tutoriel, mais vous pouvez faire plus gros si vous le voulez, mais pas plus petit.

Ces clefs doivent être de type PKCS1, fomat X.059 (normalement c'est par défaut). La clef privée elle doit être exporté en PEM dans l'idéal dans un fichier que vous devez garder.

La clef publique, convertissez là au format DER, encodez là en base64, et rajoutez les headers et footers: "-----BEGIN PUBLIC KEY-----" et "-----END PUBLIC KEY-----"

Vous pouvez tester le résultat ici :

https://8gwifi.org/PemParserFunctions.jsp

Vous devriez avoir en header :

On reste là, vous devez également la clef de signature. Vous devez donc récupérer le module et l'exposant de cette clef publique.

Vous prenez un BinaryWriter BIG ENDIAN classique utilisé pour le protocole Dofus, et vous faites donc (writeUTF implique un writeShort/writeUShort de la taille juste avant la string):


BinaryWriter.writeUTF('DofusPublicKey');
BinaryWriter.writeUTF(publicKey.module.toHex()); // Attention, le format hexa doit être appliqué
BinaryWriter.writeUTF(publicKey.exposant.toHex()); // Ici aussi

Une fois ceci fait, vous exportez le buffer de votre BinaryWriter dans un fichier, et vous aurez obtenu Michel. Gg.

Nous avons donc 3 clefs, une publique, une privée, et une de signature.

La clef publique et la clef de signature vous pouvez maintenant les remplacer dans le client avec JPEXS facilement.

Je ne vais pas expliquer comment signer des fichiers ou les hosts ici, vous êtes libre de le faire vous même grâce au fichier "com.ankamagames.jerakine.utils.crypto.Signature". Y'a environ 20 lignes à recopier, donc ça va.

Maintenant, utiliser la clef privée à la connexion en jeu.

A la connexion d'un nouveau client vous allez donc générer une nouvelle paire de clef, de taille inférieur à la paire générée précédemment, dans ce cas nous choisirons 1024. Les deux clefs doivent être même format évoqué précédemment.

Vous allez maintenant convertir la clef publique créée à l'instant au format DER, et vous encrypter ça avec la clef privée utilisée précédemment, celle que je vous ai dit de conserver. Et j'ai dit ENCRYPTER, pas SIGNER.

Une fois ceci fait, vous pouvez envoyer cette clef encrypté dans votre HelloConnectMessage. Si vous avez fait le boulot correctement, vous devriez recevoir un packet IdentificationMessage, vous pouvez vous applaudir.

Dans ce message vous aurez un champ "credentials" contenant un tableau de bytes. Nous allons donc le déchiffrer avec la clef privée associé à la clef publique qui a été envoyé dans le packet HelloConnect. Le décryptage doit s’effectuer au padding PKCS1.

Dans la propriété "credentials" vous aurez:

32 bytes - salt - UTF

32 bytes - clef AES - tableau de bytes

1 byte - taille de l'identifiant de l'utilisateur - nombre

? bytes - identifiant de l'utilisateur, vous devez lire n bytes en fonction du paramètre précédent - UTF

? bytes - mot de passe, vous pouvez lire le reste jusqu'à la fin du buffer - UTF

Voilà vous avez tout les cochons, have fun !

Si vous avez des questions j'essayerait d'y répondre au mieux sous ce sujet.

EDIT 23/05/2021 :

Lien de l'outil de génération de clef et de signature : https://www.mediafire.com/file/yo52nhafcjwzl0q/signature.rar/file

Lien du mini émulateur de test : https://www.mediafire.com/file/2cklras3k6gdyr7/emulator.rar/file

Lien de la rediffusion du live : https://www.youtube.com/watch?v=eMIjpyBPNnI

EDIT 09/12/2021 :

Pour ceux qui ont la nouvelle version de Node Forge il y aura une erreur sur index.ts dans l'outil de signature, remplacez ligne 29 et 30 :

const n: string = BigInt(publicKeyObject.n).toString(16);
const e: string = BigInt(publicKeyObject.e).toString(16);

Par

const n: string = publicKeyObject.n.toString(16);
const e: string = publicKeyObject.e.toString(16);

katanagaki

Salut !

Déjà merci pour tes topics qui sont des mines d'ors d'informations sur le jeu Dofus et qui m'ont permis par le biais du jeu d'accumuler énormément de connaissances en programmation.

Je code moi aussi un émulateur (personnel, qui ne verra jamais le jour et non complet), et je comptais justement m'attaquer au chiffrement RSA. J'ai peu de connaissances en cryptographie mais je vais essayer de faire mon mieux.

J'ai commencé par suivre ton tuto à la lettre, mais ça s'est soldé par un échec pour ce premier essai. Je code en C#, Ce que j'ai fait :

- Généré une paire de clefs donc clef publique et clef privée à l'aide la classe crypto de C#

- Formaté la clef privée au format PEM et formaté la clef publique au format DER

- Extraire le Modulus et l'Exponent de la clef publique, puis crée un fichier texte contenant ma nouvelle signature.

Le soucis c'est que le jeu ne se lance pas, surement que le client vérifie la taille mais j'ai pas encore la fonction dans les sources, ça prend du temps d'analyser tout ça, et j'ai d'autres projets à côté.

Enfin bref la longueur de la SIGNATURE_KEY original a une taille de 293, celle que je génère est de... 805

Il doit y avoir quelque chose qui va pas :(

Hetarnam

Ta question est tout à fait légitime haha, j’ai aidé quelqu’un récemment à l’intégrer en C# et c’était pas facile car les librairies dispo sont à chier. Première chose, vérifie que l’hexa de ta clef de signature est correct et ne contient pas de tirets dedans, la lib par default pour faire de l’hexa met des tirets partout, secondo tu devrais convertir ton modulus et ton exponent en long, puis les convertir en hexa, avec le format X et non X2, car sinon il va toujours vouloir faire des pairs, ta clef de sortie sera forcément plus longue que la clef originale mais elle sera valide quand même :)

Et ton client ne se lance pas très probablement à cause de ça, c’etait le cas pour la personne que j’ai aidé aussi.

Une fois lancé, ton client te diras sûrement qu’il arrive pas à lire la signature du theme, tu devras le repatcher toi même, conseil ouvre le fichier signature.xmls avec notepad ou autre en premier, tu verras la signature est flagrante. Tu la retire, tu signes le fichier, et tu seras tout bon

katanagaki

Merci de ta réponse !

Deuxième essai, toujours sur un échec. Voilà le code que j'utilise pour crée la signature.


// Importation de la public key
                RSA.FromXmlString(PublicKeyString);
                RSAParameters publicKey = RSA.ExportParameters(false);

                // Récupération des données du Modulus et de l'Exponent de la public key
                byte[] modBytes = publicKey.Modulus;
                byte[] expBytes = publicKey.Exponent;

                // Bytes -> Long
                long modLong = new BigInteger(modBytes).LongValue;
                long expLong = new BigInteger(expBytes).LongValue;

                // Long -> Hex
                string modString = modLong.ToString("X");
                string expString = expLong.ToString("X");

                // Generation de la clef de signature
                CustomDataOutput output = new CustomDataOutput();

                output.WriteUTF("DofusPublicKey");
                output.WriteUTF(modString);
                output.WriteUTF(expString);

Mon Output :


[ BLEN ] = Mod : 256
[ BLEN ] = Exp : 3
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[ LONG ] = Mod : -8459264767400590987
[ LONG ] = Exp : 65537
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[ HEX ] = Mod : 8A9AA7835E1C4175
[ HEX ] = Exp : 10001
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[ D2 ] = Generation de la signature.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[ D2 ] = Signature Len : 38
[ D2 ] = Signature Hex : DofusPublicKey8A9AA7835E1C417510001

Je vois aucun autre moyen de convertir mod et exp en long que d'utiliser BigInteger, mais je sais pas si c'est valide..

J'ai l'impression que cette fois ci le Modulus converti est trop court par rapport à celui de la clef de signature originale, ce qui me surprend c'est que l'exponent a lui bien été traduit, il me donne bien "65537" en long et "10001" en Hex ce qui est a priori bon

Hetarnam

katanagaki

Merci de ta réponse !

Deuxième essai, toujours sur un échec. Voilà le code que j'utilise pour crée la signature.


// Importation de la public key
                RSA.FromXmlString(PublicKeyString);
                RSAParameters publicKey = RSA.ExportParameters(false);

                // Récupération des données du Modulus et de l'Exponent de la public key
                byte[] modBytes = publicKey.Modulus;
                byte[] expBytes = publicKey.Exponent;

                // Bytes -> Long
                long modLong = new BigInteger(modBytes).LongValue;
                long expLong = new BigInteger(expBytes).LongValue;

                // Long -> Hex
                string modString = modLong.ToString("X");
                string expString = expLong.ToString("X");

                // Generation de la clef de signature
                CustomDataOutput output = new CustomDataOutput();

                output.WriteUTF("DofusPublicKey");
                output.WriteUTF(modString);
                output.WriteUTF(expString);

Mon Output :


[ BLEN ] = Mod : 256
[ BLEN ] = Exp : 3
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[ LONG ] = Mod : -8459264767400590987
[ LONG ] = Exp : 65537
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[ HEX ] = Mod : 8A9AA7835E1C4175
[ HEX ] = Exp : 10001
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[ D2 ] = Generation de la signature.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[ D2 ] = Signature Len : 38
[ D2 ] = Signature Hex : DofusPublicKey8A9AA7835E1C417510001

Je vois aucun autre moyen de convertir mod et exp en long que d'utiliser BigInteger, mais je sais pas si c'est valide..

Je crois que tu as raison et il faut convertir en biginteger en fait !

katanagaki

Yes, en plus on dirait que j'ai résolu mon problème, en fait j'écrivais la signature en Little-Endian, j'ai essayé de l'écrire en Big Endian cette fois et magie... le jeu s'ouvre et j'ai effectivement un message d'erreur concernant le thème, je pense que c'est la suite.

Voici mon nouveau code :


        private byte[] CreateSignature(RSAParameters publicKey)
        {
            BigInteger mod64 = new BigInteger(publicKey.Modulus);
            BigInteger exp64 = new BigInteger(publicKey.Exponent);

            if (File.Exists(@"./signature.bin"))
            {
                File.Delete(@"./signature.bin");
            }

            byte[] data = null;

            using (var fs = File.Create(@"./signature.bin"))
            {
                DataWriter writer = new DataWriter();

                writer.WriteUTF("DofusPublicKey");
                writer.WriteUTF(mod64.ToString("X"));
                writer.WriteUTF(exp64.ToString("X"));

                data = writer.Data;

                fs.Write(data, 0, data.Length);
            }

            Console.WriteLine("Output :");
            Console.WriteLine(Encoding.UTF8.GetString(data));

            return data;
        }

Si ça peut aider ^^

Au fait quand tu dis "Signer le fichier" tu parles bien de coder un outil qui permet de signer les fichiers et non pas un simple remplacement ?

Hetarnam

Parfait! Oui j'ai édit le sujet à propos de l'endian à prendre :)

Oui il faut que tu fasses ton propre outil mais comme dit dans le sujet c'est très claire dans les sources du jeu et j'ai indiqué le fichier "com.ankamagames.jerakine.utils.crypto.Signature" et son pote qui est dans le même dossier, y'en a pour 30 minutes max à recopier

katanagaki

Je viens de voir le fichier Signature.

J'arrive pas à comprendre le début de la fonction c'est bizarre.


         var adaptedData:* = null;
         if(!this._key.canSign)
         {
            throw new Error("La clef fournit ne permet pas de signer des données");
         }
         if(data is ByteArray)
         {
            adaptedData = data as ByteArray;
         }
         else
         {
            adaptedData = new ByteArray();
            data.readBytes(adaptedData);
            adaptedData.position = 0;
         }

D'ailleurs j'ai du mal à comprendre comment elle fonctionne, si c'est pas trop long et chiant tu pourrais m'expliquer comment la méthode fonctionne ? :/

Lukyrouge3

Bon je comprends pas, j'ai remplacé la signature dans les fichiers du jeu et j'ai signé mon signature.xmls avec cette fonction


function signFile(adaptedData, includeData = true) {
    let hash = new CustomDataWrapper();
    let random = Math.random() * 255;
    hash.writeInt16(random);
    hash.writeUInt32(adaptedData.length);
    hash.writeUTFBytes(createHash('md5').update(adaptedData.readUTFBytes(adaptedData.length)).digest().toString());
    for (let i = 2; i < hash.length; i++) {
        hash.byteBuf = hash.byteBuf ^ random;
    }
    hash.position = 0;
    let out = sign('RSA-SHA256', hash.byteBuf, privateKey);
    let result = new CustomDataWrapper();
    result.writeUTF(ANKAMA_SIGNED_FILE_HEADER);
    result.writeInt16(1);
    result.writeInt32(out.length);
    result.writeBytes(out);
    result.writeBytes(adaptedData.byteBuf);

    return result.byteBuf.toString();
}

Mais quand je lance le jeu ca reste bloqué sur "

Error with selected UI theme : Invalid signature for file://A:/Code/JS/DofusNodeJS/dofus/content/themes/darkStone/signature.xmls"

Ma clé publique

Ma clé privée

Mon fichier signature


 DofusPublicKey 09E37CD749B87E00C9916483BD842465DA8A97744D7BC29E9470B336EF3847B5F1AD91FE810CF69EEC87A965362E8BD11279E60FAEA5673D2654C522CCC9EDFD35C28AC65C38027319A35A748E5D26F3E7565B1AE89FE27493C34844D7F6C2C1BA50D4DAFE3106E270D2B4F7E14F4C3E402FE552F1DE276148DB2A1922B3C9A78103BA9F4DAE89F7CBD9F026AC3CEF18B4B71122E226945A2C384D29E767563BE913D6844FA492561F67C266453A3A2A8B3B09553FCFF4335E5D4692F414B3C6ACB1C6AE8514A670B53C29ADCED06ED66710B3714F0AAB5B3AF000DE9362632985556E7830391774FB0B261E2A2B2CFE9339F57C13086370AF410277FB21E3D0 10001

Et le début de signature.xmls


 AKSF    I��eF�*
���.%/Z ڨI�3Q�K^��d�pxs!�ˍ��wu1o,^ }�+��}����K8�}-�����,_���Q`�'���R�3�
*��a,VWt��e|yG�Mz��h�/���nm}s�}�+����(;�M�2�CrUm
.    �U<�{�ƕ����o�0���� �29�VRyS��e�(�UI��m���UI�P�l@\,�63�&�e8
j;�2b�s�ȥ��6VQ��!�    iM��_�a@��r���ˀA�'b<?xml version="1.0" encoding="UTF-8"?>
<meta>
    <filesVersions>

Si qqn peut me mettre sur la voie pour comprendre ou sont mes erreurs ca serait très sympa !

katanagaki

Même erreur que mon VDD, malgrès le fait d'avoir recopié et adapté le code source en C# parfaitement. J'ai testé de nombreuses choses, sans succès. Je vais essayer dans un autre langage on verra bien.

Pour ceux qui veulent mes codes sources :

Génération de clefs RSA

https://github.com/dicay/RsaKeysGenerator.NET - Génération de clefs RSA de taille 2048 et exporte dans des fichiers .XML, .PEM, .DER

Génération de la signature


 public static void GenerateSignatureKey(string output)
        {
            RSAParameters publicKey = RSA.GetPublicKey();

            BigInteger modulus = new BigInteger(publicKey.Modulus);
            BigInteger exponent = new BigInteger(publicKey.Exponent);

            using (var fs = File.Create(output + @"\signature.bin"))
            {
                BigEndianWriter writer = new BigEndianWriter();

                writer.WriteUTF("DofusPublicKey");
                writer.WriteUTF(modulus.ToString("X").ToLower());
                writer.WriteUTF(exponent.ToString("X").ToLower());

                fs.Write(writer.Data, 0, writer.Data.Length);
            }
        }

Fonction pour les signer les fichiers comme Dofus


        public static void Sign(string input, string output)
        {
            var inputBytes = File.ReadAllBytes(input);
            BigEndianReader inputReader = new BigEndianReader(inputBytes);
            BigEndianWriter hash = new BigEndianWriter();

            uint random = (uint)(new Random().Next() * 255);

            hash.WriteByte((byte)random);
            hash.WriteUInt((uint)inputReader.Data.Length);
            hash.WriteUTFBytes(XemuMD5.Hash(inputReader.ReadUTFBytes((ushort)inputReader.Data.Length)));

            var hashBuffer = hash.Data;
            byte[] mixedHashBuffer = new byte[hashBuffer.Length];

            for (int i = 2; i < hashBuffer.Length; i++)
            {
                mixedHashBuffer = (byte)(hashBuffer ^ random);
            }

            var signedData = XemuRSA.Encrypt(mixedHashBuffer);

            BigEndianWriter result = new BigEndianWriter();
            result.WriteUTF(ANKAMA_SIGNED_FILE_HEADER);
            result.WriteShort(1);
            result.WriteInt(signedData.Length);
            result.WriteBytes(signedData);
            result.WriteBytes(inputBytes);

            var outputData = result.Data;

            using (var fs = File.Create(output))
            {
                fs.Write(outputData, 0, outputData.Length);
            }
        }

Encryption de données avec la clef privée


 public static byte[] Encrypt(byte[] toEncrypt)
        {
            using (var RSA = new RSACryptoServiceProvider())
            {
                var publickey = File.ReadAllText(PRIVATEKEY_PATH);
                RSA.FromXmlString(publickey);

                var encrypted = RSA.Encrypt(toEncrypt, RSAEncryptionPadding.Pkcs1);

                return encrypted;
            }
        }

Hetarnam

Bon ça vous plairait qu'on le fasse en live? Comme ça on voit pas à pas et j'aiderais tout le monde à corriger?

Lukyrouge3

De ouf en vrai x) Donne moi le jour et l'heure et je suis là

chuckame

Plop! Je débute aussi dans un projet perso en Java, j'ai déjà fait :

- key gen

- remplacement des clés dans le DofusInvoker.swf (d'ailleurs je vous file le script, car c'est bien relou de passer par l'interface)

Voici le script qui, à l'aide de ffdec (à DL ici: Latest release, prenez le zip), va aller remplacer SIGNATURE_KEY_DATA et AuthentificationManager__verifyKey tout seul, tout en gardant le DofusInvoker.swf officiel :

#!/bin/bash

SIGNATURE_KEY_DATA_CHARACTER_ID=13
PUBLIC_KEY_CHARACTER_ID=115
INPUT=$1
NEW_SIGNATURE_KEY_DATA_FILE=$2
NEW_PUBLIC_KEY_FILE=$3

if [ -z "$INPUT" ] || [ -z "$NEW_SIGNATURE_KEY_DATA_FILE" ] || [ -z "$NEW_PUBLIC_KEY_FILE" ]; then
  echo "Missing parameters. Expected: $0 path/to/DofusInvoker.swf path/to/public/signature.bin path/to/public/key.pem"
  exit 1
fi

java -jar ../ffdec/ffdec.jar \
  -replace "${INPUT}" "${INPUT}.patched" \
  ${SIGNATURE_KEY_DATA_CHARACTER_ID} "${NEW_SIGNATURE_KEY_DATA_FILE}" \
  ${PUBLIC_KEY_CHARACTER_ID} "${NEW_PUBLIC_KEY_FILE}"

if [ ! -f "${INPUT}.official" ]; then
  mv "${INPUT}" "${INPUT}.official"
else
  rm "${INPUT}"
fi

mv "${INPUT}.patched" "${INPUT}"

Et voici le code permettant de faire la signature du xmls (dataBytes représente seulement la partie xml du fichier xmls, et cette méthode retourne le fichier final: signature + xml) :


    public static byte[] prefixDataWithSignature(byte[] dataBytes, RSAPrivateKey privateKey) {
        var hash = Unpooled.buffer();

        int random = new Random().nextInt(0xFF);

        hash.writeByte(random);
        hash.writeInt(inputBytes.length);
        hash.writeBytes(CryptoHelper.getMD5Hash(inputBytes));

        var hashBuffer = ByteBufUtil.getBytes(hash);

        for (int i = 2; i < hashBuffer.length; i++) {
            hashBuffer ^= random;
        }

        byte[] signature = CryptoHelper.getSignature(hashBuffer, privateKey);

        ByteBufWriter output = new ByteBufWriter(Unpooled.buffer());
        output.writeUTF(ANKAMA_SIGNED_FILE_HEADER);
        output.writeShort(MD5_HASH_TYPE);
        output.writeInt(signature.length);
        output.writeBytesWithoutSize(signature);
        output.writeBytesWithoutSize(inputBytes);
        return ByteBufUtil.getBytes(output.buffer());
    }

Mais je n'arrive pas à passer l'étape de validation du signature.xmls du thème... L'un d'entre vous peut m'indiquer la marche à suivre ? Je pense que j'ai mal géré la signature du xmls

chuckame

Après plusieurs jours de galère, j'ai trouvé.... Il fallait simplement pas prendre les octets bruts du hash md5, mais prendre l'hexa !!!

Hetarnam

Yop a tous, suite à l'annonce de Dofus qui va migrer sur Unity, ils vont probablement changer la sécurité de connexion, et donc j'ai décidé de faire le tuto live et de vous partager des sources opérationnelles en JS pour que vous puissiez comprendre plus facilement.

Ça aura lieu le 23 mai dans l'aprem, je vous donnerais les détails sur le calendrier Twitch de ma chaine !

chuckame

L'annonce de dof sur unity... C'est pas pour demain si tu parles de l'article publié en septembre ^^

Mais cool, ça peut être intéressant, merci !

Hetarnam

Update Twitch : le stream aura lieu a 18h UTC+2 - ici, pour environ 1 h/1 h 15 de diffusion qui sera sur YouTube après pour ceux qui ont loupé

Hetarnam

UP : lien de la rediffusion et du code fait durant le live ajouté !

MaSTeR

Hetarnam
UP : lien de la rediffusion et du code fait durant le live ajouté !

Merci pour ton temps et le partage de connaissance, c'est très gentil à toi !

Vvllaadd

Hetarnam
UP : lien de la rediffusion et du code fait durant le live ajouté !

Bravo pour ta dévotion envers la communauté. ;)

Page suivante »