Esempio n. 1
0
        private async Task <Step3Response> DoAuthentication()
        {
            Log.Info("Try do authentication");

            var step1       = new Step1PqRequest();
            var step1Result = await MtProtoPlainSender.SendAndReceive(step1.ToBytes());

            var step1Response = step1.FromBytes(step1Result);

            Log.Debug("First step is done");

            var step2       = new Step2DhExchange();
            var step2Result = await MtProtoPlainSender.SendAndReceive(step2.ToBytes(
                                                                          step1Response.Nonce,
                                                                          step1Response.ServerNonce,
                                                                          step1Response.Fingerprints,
                                                                          step1Response.Pq));

            var step2Response = step2.FromBytes(step2Result);

            Log.Debug("Second step is done");

            var step3       = new Step3CompleteDhExchange();
            var step3Result = await MtProtoPlainSender.SendAndReceive(step3.ToBytes(
                                                                          step2Response.Nonce,
                                                                          step2Response.ServerNonce,
                                                                          step2Response.NewNonce,
                                                                          step2Response.EncryptedAnswer));

            var step3Response = step3.FromBytes(step3Result);

            Log.Debug("Third step is done");

            return(step3Response);
        }
Esempio n. 2
0
        public void DeserializatinTest()
        {
            var pq = new BigInteger("2821213750622862821", 10);

            var resPq = new TResPQ
            {
                Nonce       = new byte[16],
                ServerNonce = new byte[16],
                PqAsBinary  = pq.ToByteArrayUnsigned(),
                ServerPublicKeyFingerprints = new TVector <long>(5611009732197236050)
            };

            _random.NextBytes(resPq.Nonce);
            _random.NextBytes(resPq.ServerNonce);

            var response = Step2ClientHelper.GetRequest(resPq, PublicKey, out var newNonce);

            var buffer = Serializer.Serialize(response);

            var dataNew = new byte[buffer.ReadableBytes];

            buffer.ReadBytes(dataNew);

            var a       = new Step2DhExchange();
            var dataOld = a.ToBytes(resPq.Nonce, resPq.ServerNonce, newNonce, new List <byte[]>()
            {
                BitConverter.GetBytes(5611009732197236050)
            },
                                    new Old.MTProto.Crypto.BigInteger("2821213750622862821", 10));

            Assert.Equal(dataNew, dataOld);
        }
Esempio n. 3
0
        public void ValidationTest()
        {
            var pqData = new byte[] { 35, 85, 96, 197, 87, 11, 113, 253 };

            var resPq = new TResPQ
            {
                Nonce       = new byte[16],
                ServerNonce = new byte[16],
                PqAsBinary  = pqData,
                ServerPublicKeyFingerprints = new TVector <long>(5611009732197236050)
            };

            _random.NextBytes(resPq.Nonce);
            _random.NextBytes(resPq.ServerNonce);

            var response = Step2ClientHelper.GetRequest(resPq, PublicKey, out var newNonce);

            var a     = new Step2DhExchange();
            var bytes = a.ToBytes(resPq.Nonce, resPq.ServerNonce, newNonce, new List <byte[]>()
            {
                BitConverter.GetBytes(5611009732197236050)
            },
                                  new Old.MTProto.Crypto.BigInteger(1, pqData));

            var buffer = PooledByteBufferAllocator.Default.Buffer();

            buffer.WriteBytes(bytes);
            var responseOld = (RequestReqDHParams)Serializer.Deserialize(buffer);

            Assert.Equal(response.PAsBinary, responseOld.PAsBinary);
            Assert.Equal(response.QAsBinary, responseOld.QAsBinary);
            Assert.Equal(response.Nonce, responseOld.Nonce);
            Assert.Equal(response.ServerNonce, responseOld.ServerNonce);
            Assert.Equal(response.PublicKeyFingerprint, responseOld.PublicKeyFingerprint);

            var responseInnerData    = Decrypt(response, out var responseInnerDataChecksum);
            var responseOldInnerData = Decrypt(responseOld, out var responseOldInnerDataChecksum);

            Assert.Equal(responseInnerDataChecksum, responseOldInnerDataChecksum);
            Assert.Equal(responseInnerData.PqAsBinary, responseOldInnerData.PqAsBinary);
            Assert.Equal(responseInnerData.PAsBinary, responseOldInnerData.PAsBinary);
            Assert.Equal(responseInnerData.QAsBinary, responseOldInnerData.QAsBinary);
            Assert.Equal(responseInnerData.Nonce, responseOldInnerData.Nonce);
            Assert.Equal(responseInnerData.ServerNonce, responseOldInnerData.ServerNonce);
            Assert.Equal(responseInnerData.NewNonce, responseOldInnerData.NewNonce);
        }