public override TLObject FromBytes(byte[] bytes, ref int position)
        {
            bytes.ThrowExceptionIfIncorrect(ref position, Signature);

            Flags              = GetObject <TLInt>(bytes, ref position);
            _newAlgo           = GetObject <TLPasswordKdfAlgoBase>(Flags, (int)PasswordInputSettingsFlags.Password, null, bytes, ref position);
            _newPasswordHash   = GetObject <TLString>(Flags, (int)PasswordInputSettingsFlags.Password, null, bytes, ref position);
            _hint              = GetObject <TLString>(Flags, (int)PasswordInputSettingsFlags.Password, null, bytes, ref position);
            _email             = GetObject <TLString>(Flags, (int)PasswordInputSettingsFlags.Email, null, bytes, ref position);
            _newSecureSettings = GetObject <TLSecureSecretSettings>(Flags, (int)PasswordInputSettingsFlags.NewSecureSecret, null, bytes, ref position);

            return(this);
        }
Exemple #2
0
        public override TLObject FromBytes(byte[] bytes, ref int position)
        {
            bytes.ThrowExceptionIfIncorrect(ref position, Signature);

            _flags                   = GetObject <TLInt>(bytes, ref position);
            _currentAlgo             = GetObject <TLPasswordKdfAlgoBase>(Flags, (int)PasswordFlags.HasPassword, null, bytes, ref position);
            _hint                    = GetObject <TLString>(Flags, (int)PasswordFlags.Hint, null, bytes, ref position);
            _emailUnconfirmedPattern = GetObject <TLString>(Flags, (int)PasswordFlags.EmailUnconfirmedPattern, null, bytes, ref position);
            NewAlgo                  = GetObject <TLPasswordKdfAlgoBase>(bytes, ref position);
            NewSecureAlgo            = GetObject <TLSecurePasswordKdfAlgoBase>(bytes, ref position);
            SecretRandom             = GetObject <TLString>(bytes, ref position);

            return(this);
        }
Exemple #3
0
        public static TLString GetOldHash(TLPasswordKdfAlgoBase kdfAlgoBase, TLString password)
        {
            var algo = kdfAlgoBase as TLPasswordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow;

            if (algo != null)
            {
                var salt1 = algo.Salt1;

                var hash1 = GetHash(salt1, password);

                return(hash1);
            }

            return(null);
        }
Exemple #4
0
        public static void AddClientSalt(TLPasswordKdfAlgoBase algoBase)
        {
            var algo = algoBase as TLPasswordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow;

            if (algo == null)
            {
                return;
            }

            var secureRandom = new SecureRandom();
            var clientSalt1  = new byte[32];

            secureRandom.NextBytes(clientSalt1);

            var newSalt1Data = TLUtils.Combine(algo.Salt1.Data, clientSalt1);
            var newSalt1     = TLString.FromBigEndianData(newSalt1Data);

            algo.Salt1 = newSalt1;
        }
Exemple #5
0
        public static TLString GetNewHash(TLPasswordKdfAlgoBase kdfAlgoBase, TLString password)
        {
            var algo = kdfAlgoBase as TLPasswordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow;

            if (algo != null)
            {
                var salt1 = algo.Salt1;
                var salt2 = algo.Salt2;

                var hash1 = GetHash(salt1, password);
                var hash2 = GetHash(salt2, hash1);
                var hash3 = PBKDF2.GetHash(hash2.Data.AsBuffer(), salt1.Data.AsBuffer());
                var hash4 = GetHash(salt2, TLString.FromBigEndianData(hash3.ToArray()));

                return(hash4);
            }

            return(null);
        }
Exemple #6
0
        public static TLInputCheckPasswordBase GetCheck(TLString xStr, TLLong srpId, TLString srpB, TLPasswordKdfAlgoBase algoBase)
        {
            var algo = algoBase as TLPasswordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow;

            if (algo != null)
            {
                if (xStr == null || srpB == null || srpB.Data.Length == 0 || !TLUtils.CheckPrime(algo.P.Data, algo.G.Value))
                {
                    return(new TLInputCheckPasswordEmpty());
                }

                var g       = new BigInteger(1, algo.G.ToBytes().Reverse().ToArray()); // from big-endian to BI (ToBytes - little endian output)
                var g_bytes = GetBigIntegerBytes(g);

                var p       = new BigInteger(1, algo.P.Data);
                var p_bytes = GetBigIntegerBytes(p);

                var k_bytes = Telegram.Api.Helpers.Utils.ComputeSHA256(TLUtils.Combine(p_bytes, g_bytes));
                var k       = new BigInteger(1, k_bytes);

                var x = new BigInteger(1, xStr.Data);

                var a_bytes      = new byte[256];
                var secureRandom = new SecureRandom();
                secureRandom.NextBytes(a_bytes);
                var a = new BigInteger(1, a_bytes);

                var A       = g.ModPow(a, p);
                var A_bytes = GetBigIntegerBytes(A);

                var B = new BigInteger(1, srpB.Data);
                if (B.CompareTo(BigInteger.Zero) <= 0 || B.CompareTo(p) >= 0)
                {
                    return(null);
                }
                var B_bytes = GetBigIntegerBytes(B);

                var u_bytes = Telegram.Api.Helpers.Utils.ComputeSHA256(TLUtils.Combine(A_bytes, B_bytes));
                var u       = new BigInteger(1, u_bytes);
                if (u.CompareTo(BigInteger.Zero) == 0)
                {
                    return(null);
                }

                var B_kgx = B.Subtract(k.Multiply(g.ModPow(x, p)).Mod(p));
                if (B_kgx.CompareTo(BigInteger.Zero) < 0)
                {
                    B_kgx = B_kgx.Add(p);
                }
                if (!TLUtils.CheckGaAndGb(B_kgx, p))
                {
                    return(null);
                }
                var S       = B_kgx.ModPow(a.Add(u.Multiply(x)), p);
                var S_bytes = GetBigIntegerBytes(S);

                var K_bytes = Telegram.Api.Helpers.Utils.ComputeSHA256(S_bytes);

                var p_hash = Telegram.Api.Helpers.Utils.ComputeSHA256(algo.P.Data);
                var g_hash = Telegram.Api.Helpers.Utils.ComputeSHA256(g_bytes);
                for (var i = 0; i < p_hash.Length; i++)
                {
                    p_hash[i] = (byte)(g_hash[i] ^ p_hash[i]);
                }

                var M1 = Telegram.Api.Helpers.Utils.ComputeSHA256(TLUtils.Combine(
                                                                      p_hash,
                                                                      Telegram.Api.Helpers.Utils.ComputeSHA256(algo.Salt1.Data),
                                                                      Telegram.Api.Helpers.Utils.ComputeSHA256(algo.Salt2.Data),
                                                                      A_bytes,
                                                                      B_bytes,
                                                                      K_bytes));

                return(new TLInputCheckPasswordSRP
                {
                    SRPId = srpId,
                    A = TLString.FromBigEndianData(A_bytes),
                    M1 = TLString.FromBigEndianData(M1)
                });
            }

            return(new TLInputCheckPasswordEmpty());
        }