Exemple #1
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);
        }
Exemple #2
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);
        }
        public static RequestReqDHParams GetRequest(TResPQ resPq, string publicKey, out byte[] newNonce)
        {
            var pq = new BigInteger(resPq.PqAsBinary);
            var f1 = PollardRho.Factor(pq);
            var f2 = pq.Divide(f1);
            var p  = f1.Min(f2);
            var q  = f1.Max(f2);

            newNonce = new byte[32];
            Random.NextBytes(newNonce);

            var pqInnerData = new TPQInnerData
            {
                PqAsBinary  = pq.ToByteArrayUnsigned(),
                PAsBinary   = p.ToByteArrayUnsigned(),
                QAsBinary   = q.ToByteArrayUnsigned(),
                ServerNonce = resPq.ServerNonce,
                Nonce       = resPq.Nonce,
                NewNonce    = newNonce
            };

            var serializedData = Serializer.Serialize(pqInnerData);

            byte[] innerData;
            try
            {
                innerData = serializedData.ToArray();
            }
            finally
            {
                serializedData.SafeRelease();
            }

            var fingerprint = RSAHelper.GetFingerprint(publicKey);

            if (!resPq.ServerPublicKeyFingerprints.Contains(fingerprint))
            {
                throw new InvalidOperationException("The fingerprint is not found");
            }

            var hashsum = Sha1Helper.ComputeHashsum(innerData);

            var dataWithHash = PooledByteBufferAllocator.Default.Buffer();

            byte[] innerDataWithHash;
            try
            {
                dataWithHash.WriteBytes(hashsum);
                dataWithHash.WriteBytes(innerData);

                var paddingBytes = new byte[255 - dataWithHash.ReadableBytes];
                Random.NextBytes(paddingBytes);
                dataWithHash.WriteBytes(paddingBytes);
                innerDataWithHash = dataWithHash.ToArray();
            }
            finally
            {
                dataWithHash.SafeRelease();
            }

            var ciphertext = RSAHelper.RsaEncryptWithPublic(innerDataWithHash, publicKey);

            return(new RequestReqDHParams
            {
                Nonce = resPq.Nonce,
                PAsBinary = p.ToByteArrayUnsigned(),
                QAsBinary = q.ToByteArrayUnsigned(),
                ServerNonce = resPq.ServerNonce,
                PublicKeyFingerprint = fingerprint,
                EncryptedDataAsBinary = ciphertext
            });
        }