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

Problème de ticket

Yoshino

Bonjour à tous, j'ai décider de me tourner vers vous car j'ai un soucis sur la réception du AuthenticationTicketMessage car mon ticket reste vide ce qui me deco automatiquement. Je suis en train de faire un bot en MITM, c'est mes débuts dans le monde du dev de bot, et je laisse le ticket passer tel quel, donc j'ai décider de vérifier ma classe du SelectedServerDataMessage mais je ne vois pas ce qui pourrais clocher dans le serialize et deserialize de ce packet comme le ticket ce génère par lui.

Code

Cliquez pour révéler Cliquez pour masquer

public override void Serialize(IDataWriter writer)
        {
            if (this.ServerId < 0)
            {
                throw new Exception("Forbidden value (" + this.ServerId + ") on element serverId.");
            }
            writer.WriteVarShort(this.ServerId);
            writer.WriteUTF(this.Address);
            if (this.Port < 0 || this.Port > 65535)
            {
                throw new Exception("Forbidden value (" + this.Port + ") on element port.");
            }
            writer.WriteShort((short)this.Port);
            writer.WriteBoolean(this.CanCreateNewCharacter);
            writer.WriteVarInt(this.Ticket.Length);
            uint _loc2_ = 0;
            while (_loc2_ < this.Ticket.Length)
            {
                writer.WriteSByte(this.Ticket[_loc2_]);
                _loc2_++;
            }
        }
     
        public override void Deserialize(IDataReader reader)
        {
            this.ServerId = (ushort)reader.ReadVarShort();
            bool flag = this.ServerId < 0;
            if (flag)
            {
                throw new Exception("Forbidden value on ServerId = " + this.ServerId + ", it doesn't respect the following condition : serverId < 0");
            }
            this.Address = reader.ReadUTF();
            this.Port = reader.ReadUShort();
            bool flag2 = this.Port < 0 || this.Port > 65535;
            if (flag2)
            {
                throw new Exception("Forbidden value on Port = " + this.Port + ", it doesn't respect the following condition : port < 0 || port > 65535");
            }
            this.CanCreateNewCharacter = reader.ReadBoolean();
            int num = reader.ReadVarInt();
            this.Ticket = new sbyte[num];
            for (int i = 0; i < num; i++)
            {
                this.Ticket = reader.ReadSByte();
            }
        }

Merci d'avance pour la moindre aide.

PS : Je sais que c'est mon premier poste et que pour certain ça doit mal passer de demander de l'aide.

Taykyue

Ton code compile ? Car il y a un problème.

Lors de la déserialisation :

for (int i = 0; i < num; i++)
{
    this.Ticket = reader.ReadSByte();
}

Devrait être :

for (int i = 0; i < num; i++)
{
    this.Ticket[num] = reader.ReadSByte();
}

Yoshino

Il n'apparait pas c'est bizarre mais c'est

Ticket = ...

que j'ai moi

Edit : Voilà, j'ai remis mon code à jour dans le premier poste

asyade

Ta vérifier tes IO ? sa viens peut-être de "num = readVarInt()" (je me rappelle avoir eu des soucis avec les io, des var qui passe d´autres non faut le faire proprement)

Yoshino

Je pense que c'est correct:


 public int ReadVarInt()
       {
            int _loc4_ = 0;
            int _loc1_ = 0;
            int _loc2_ = 0;
            bool _loc3_ = false;
            while (_loc2_ < INT_SIZE)
            {
                _loc4_ = this.ReadByte();
                _loc3_ = (_loc4_ & MASK_10000000) == MASK_10000000;
                if (_loc2_ > 0)
                {
                    _loc1_ = _loc1_ + ((_loc4_ & MASK_01111111) << _loc2_);
                }
                else
                {
                    _loc1_ = _loc1_ + (_loc4_ & MASK_01111111);
                }
                _loc2_ = _loc2_ + CHUNCK_BIT_SIZE;
                if (!_loc3_)
                {
                    return _loc1_;
                }
            }
                throw new Exception("Too much data");
       }

Yoshino

Petit up, personne n'a une idée ?

BlueDream

Ta fonction de lecture semble correcte, au niveau de l'écriture ?

Yoshino

Pour ecrire j'utilise celle là

public void WriteVarInt(int @int)
        {
            this.WriteVar((ulong)@int);
        }

private void WriteVar(ulong number)
        {
            while (number > 127)
            {
                this.WriteByte((byte)((number & 127) | 128));
                number >>= 7;
            }
            this.WriteByte((byte)number);
        }

C'est Apokah qui me l'a passé, il est incorrect ?

BlueDream

Cela ne ressemble pas du tout au code officiel.

CustomDataWrapper.as


private static const MASK_10000000:int = 128;
private static const MASK_01111111:int = 127;

public function writeVarInt(param1:int) : void
      {
         var _loc5_:* = 0;
         var _loc2_:ByteArray = new ByteArray();
         if(param1 >= 0 && param1 <= MASK_01111111)
         {
            _loc2_.writeByte(param1);
            this._data.writeBytes(_loc2_);
            return;
         }
         var _loc3_:int = param1;
         var _loc4_:ByteArray = new ByteArray();
         while(_loc3_ != 0)
         {
            _loc4_.writeByte(_loc3_ & MASK_01111111);
            _loc4_.position = _loc4_.length - 1;
            _loc5_ = _loc4_.readByte();
            _loc3_ = _loc3_ >>> CHUNCK_BIT_SIZE;
            if(_loc3_ > 0)
            {
               _loc5_ = _loc5_ | MASK_10000000;
            }
            _loc2_.writeByte(_loc5_);
         }
         this._data.writeBytes(_loc2_);
      }

BlueDream

A mon avis ton problème est ici:

BlueDream
_loc3_ = _loc3_ >>> CHUNCK_BIT_SIZE

Ce n'est pas un simple déplacement vers la droite, c'est du unsigned il me semble.

J'avais pas mal galéré à la traduire en VB .Net, ça donnait ça, tu peux essayer.

local_3 = CInt(Convert.ToUInt32(local_3.ToString("X"), 16) >> CHUNCK_BIT_SIZE)

Yoshino

Je viens de la traduire et j'ai toujours le ticket vide

private static int MASK_10000000 = 128;
        private static int MASK_01111111 = 127;
        private static int CHUNCK_BIT_SIZE = 7;
        public void WriteVarInt(int param1)
        {
            var _loc2_ = new BigEndianWriter();
            var _loc5_ = 0;
            if (param1 >= 0 && param1 <= MASK_01111111)
            {
                _loc2_.WriteByte((byte)param1);
                this.WriteBytes(this.Data);
                return;
            }
            int _loc3_ = param1;
            var _loc4_ = new BigEndianWriter();
            var _l4_ = new BigEndianReader(_loc4_.Data);
            while (_loc3_ != 0)
            {
                _loc4_.WriteByte((byte)(_loc3_ & MASK_01111111));
                _loc4_.Position = _loc4_.Data.Length - 1;
                _loc5_ = _l4_.ReadByte();
                _loc3_ = _loc3_ >> CHUNCK_BIT_SIZE;
                if (_loc3_ > 0)
                {
                    _loc5_ = _loc5_ | MASK_10000000;
                }
                _loc2_.WriteByte((byte)_loc5_);
            }
            this.WriteBytes(_loc2_.Data);
        }

Yoshino

Merci, mais le "X" représente quoi ? (j'ai tester avec ça ne change toujours rien)

Taykyue

Cast ton param1 en uint, ça sera plus simple.

Il y a aussi des incohérences dans ton code :

public void WriteVarInt(int param1)
        {
            var _loc2_ = new BigEndianWriter();
            var _loc5_ = 0;
            if (param1 >= 0 && param1 <= MASK_01111111)
            {
                this.WriteByte((byte)param1);
                return;
            }
            int _loc3_ = param1;
            var _loc4_ = new BigEndianWriter();
            var _l4_ = new BigEndianReader(_loc4_.Data);
            while (_loc3_ != 0)
            {
                _loc5_ = (byte)(_loc3_ & MASK_01111111);
                _loc3_ = _loc3_ >> CHUNCK_BIT_SIZE;
                if (_loc3_ > 0)
                {
                    _loc5_ = _loc5_ | MASK_10000000;
                }
                _loc2_.WriteByte((byte)_loc5_);
            }
            this.WriteBytes(_loc2_.Data);
        }

Yoshino

C'est fait

private static int MASK_10000000 = 128;
        private static int MASK_01111111 = 127;
        private static int CHUNCK_BIT_SIZE = 7;
        public void WriteVarInt(uint param1)
        {
            var _loc2_ = new BigEndianWriter();
            var _loc5_ = 0;
            if (param1 >= 0 && param1 <= MASK_01111111)
            {
                _loc2_.WriteByte((byte)param1);
                this.WriteBytes(this.Data);
                return;
            }
            uint _loc3_ = param1;
            var _loc4_ = new BigEndianWriter();
            var _l4_ = new BigEndianReader(_loc4_.Data);
            while (_loc3_ != 0)
            {
                _loc4_.WriteByte((byte)(_loc3_ & MASK_01111111));
                _loc4_.Position = _loc4_.Data.Length - 1;
                _loc5_ = _l4_.ReadByte();
                _loc3_ = Convert.ToUInt32(_loc3_.ToString("X"), 16) >> CHUNCK_BIT_SIZE;
                if (_loc3_ > 0)
                {
                    _loc5_ = _loc5_ | MASK_10000000;
                }
                _loc2_.WriteByte((byte)_loc5_);
            }
            this.WriteBytes(_loc2_.Data);
        }

Taykyue

Je n'ai malheureusement pas trop de temps pour t'aider à résoudre ton problème. J'ai néanmoins pris le temps de corriger ton code.

Essaye ceci :

private static int MASK_10000000 = 128;
private static int MASK_01111111 = 127;
private static int CHUNCK_BIT_SIZE = 7;

public void WriteVarInt(int param1)
{
    var value = (uint)param1;
    if (value >= 0 && value <= MASK_01111111)
    {
        this.WriteByte((byte)param1);
        return;
    }

    while (value != 0)
    {
        var temp = (byte)(_loc3_ & MASK_01111111);
        value >>= CHUNCK_BIT_SIZE;
        if (value > 0)
        {
            value |= MASK_10000000;
        }

        this.WriteByte(temp);
    }
}

Yoshino

Merci, Je viens de test et ça ne change toujours rien mon ticket reste vide :/

Taykyue

Au début du poste tu parlais d'un problème de réception (donc de lecture), et la on cherche à corriger un problème d'écriture.

Met un point d'arrêt dans le paquet SelectedServerDataMessage, voir si la taille du ticket s'est bien écrite (en regardant dans la mémoire).

dampenfr31

Bonjour

Je te laisse vérifier ta classe SelectedServerDataMessage -> http://pastebin.com/Bd1Muk3H

Et comme Taykyue te l'a dit, met un breakpoint dans ce packet.

Fallen

code coté serveur =>

Cliquez pour révéler Cliquez pour masquer

BigEndianWriter bigEndianWriter = new BigEndianWriter();

bigEndianWriter.WriteByte((byte)client.Account.Ticket.Length);

bigEndianWriter.WriteUTFBytes(client.Account.Ticket);

client.Send((Stump.DofusProtocol.Messages.Message)new SelectedServerDataMessage((ushort)world.Id, world.Address, world.Port, true, Cryptography.EncryptAES(bigEndianWriter.Data, client.AesKey)));

Le serveur crypte les données en AES grace à la clé que tu lui a envoyé si elle n'existe pas il envoi un ticket vide j'espere t'avoir aidé

Yoshino

Pour le ticket dans le SelectedServerDataMessage j'ai un sbyte avec 32 entrées et la key du HelloConnectMessage ainsi que le salt sont bien renseigné mais la key du packet AuthentificationTicketMessage reste vide c'est ça le soucis :/

Merci tout de même de vos réponses

Page suivante »