Beispiel #1
0
        public async Task OnLogonChallenge(AuthLogonChallenge challenge)
        {
            Account = GrainFactory.GetGrain <IAccount>(challenge.account);

            if (!(await Account.IsValid()))
            {
                await SendAuthError(AuthError.NoAccount);

                return;
            }


            string password = await Account.GetPassword();

            Shared.BigInteger pass = new Shared.BigInteger(password, 16);

            //test

            string passwordPlain = await Account.GetPasswordPlain();

            string SRPHash      = challenge.account.ToUpper() + ":" + passwordPlain.ToUpper();
            var    SRPHashBytes = Encoding.UTF8.GetBytes(SRPHash);
            var    SRPCreds     = BigInt.Hash(SRPHashBytes); //The bytes were g

            BigInteger x = BigInt.Hash(s, SRPCreds);

            v = g.ModPow(x, N);

            b = new Shared.BigInteger(new Random(), 160);

            Shared.BigInteger gmod = g.ModPow(b, N);

            if (gmod < 0)
            {
                gmod += N;
            }

            B = ((v * 3) + gmod) % N;

            if (B < 0)
            {
                B += N;
            }

            Shared.BigInteger unk = new Shared.BigInteger(new Random(), 128);
            //I'm sure this is used for matrix proofing (2 factor auth)

            PacketOut rtn = new PacketOut(AuthOp.AUTH_LOGON_CHALLENGE);

            rtn.Write((byte)AuthError.Success);
            rtn.Write((byte)0);  //unknown
            rtn.WriteBigInt(B, 32);
            rtn.WriteBigIntLength(g, 1);
            rtn.WriteBigIntLength(N, 32);
            rtn.WriteBigInt(s, 32);
            rtn.WriteBigInt(unk, 16);
            rtn.Write((byte)0);    //security flag
            await SendPacket(rtn); //test
        }
Beispiel #2
0
        public static PacketProcessResult HandleLogonAuthChallenge(PacketProcessor p)
        {
            if (p.CurrentPacket.Length < 4)
            {
                p.DataNeeded = 4; //1 opcode, 1 version, 2 data_size
                return(PacketProcessResult.RequiresData);
            }

            byte   proto_version = p.CurrentPacket.ReadByte();
            UInt16 data_size     = p.CurrentPacket.ReadUInt16();

            if (p.CurrentPacket.Length < 4 + data_size)
            {
                p.DataNeeded = 4 + data_size; //1 opcode, 1 version, 2 data_size, data_size data
                return(PacketProcessResult.RequiresData);
            }

            AuthLogonChallenge challenge = new AuthLogonChallenge();

            challenge.client          = p.CurrentPacket.ReadFourCC();
            challenge.client_major    = p.CurrentPacket.ReadByte();
            challenge.client_minor    = p.CurrentPacket.ReadByte();
            challenge.client_revision = p.CurrentPacket.ReadByte();
            challenge.client_build    = p.CurrentPacket.ReadUInt16();
            challenge.processor       = p.CurrentPacket.ReadFourCC();
            challenge.os       = p.CurrentPacket.ReadFourCC();
            challenge.locale   = p.CurrentPacket.ReadFourCC();
            challenge.category = p.CurrentPacket.ReadInt32();
            challenge.ipaddr   = new IPAddress(p.CurrentPacket.ReadBytes(4));
            challenge.account  = p.CurrentPacket.ReadString();

            if (p.ClientConnection != null && p.ClientConnection.CurrentSession != null)
            {
                p.ClientConnection.CurrentSession.OnLogonChallenge(challenge);
            }

            return(PacketProcessResult.Processed);
        }