コード例 #1
0
        /// <summary>
        /// Sinh PublicKey và PrivateKey
        /// </summary>
        public bool GeneralKeys()
        {
            try
            {
                _publicKey  = null;
                _privateKey = null;
                var rnd = new Random();
                //2 p,q là những số nguyên tố ngâu nhiên không trùng nhau
                Int64 q = PrimeNumbers[rnd.Next(0, PrimeNumbers.Count)];
                Int64 p = PrimeNumbers[rnd.Next(0, PrimeNumbers.Count)];
                while (!IsPrimeNumber(q) && q > 0)
                {
                    q = PrimeNumbers[rnd.Next(0, PrimeNumbers.Count)];
                }

                while ((!IsPrimeNumber(p) || p == q) && p > 0)
                {
                    p = PrimeNumbers[rnd.Next(0, PrimeNumbers.Count)];
                }
                Int64 n = p * q;                 // module được công khai được tính theo công thức n = p*q
                Int64 euler = (p - 1) * (q - 1); // giá trị euler của n được tính theo công thức euler(n) =  (p - 1) * (q - 1)
                Int64 e = 0, d = 0;              //e : số mũ công khai ; d : số mũ bí mật;
                bool  flag   = false;
                var   minVal = MinValue >= euler? MinValue :2;
                while (!flag)
                {
                    e = rnd.Next(minVal, (int)euler);
                    while (e < 1 || e > euler || Euclid(e, euler) != 1)
                    {
                        e = rnd.Next(minVal, (int)euler);
                    }
                    var euclidExtended = EuclidExtended(e, euler);
                    if (euclidExtended != null)
                    {
                        d = Math.Abs((long)euclidExtended);
                        if (e != d && (e * d) % euler == 1)
                        {
                            _publicKey = new RsaKey {
                                Exponent = e, Modulus = n
                            };
                            _privateKey = new RsaKey {
                                Exponent = d, Modulus = n
                            };
                            _p               = p;
                            _q               = q;
                            _modulus         = n;
                            _euler           = euler;
                            _privateExponent = d;
                            _publicExponent  = e;
                            flag             = true;
                        }
                    }
                }
                return(true);
            }
            catch (Exception ex)
            {
                return(false);
            }
        }
コード例 #2
0
        /// <summary>
        /// Sinh PublicKey và PrivateKey với tham số truyền vào là 2 số nguyên tố (ngẫu nhiên) không trùng nhau
        /// </summary>
        /// <param name="firstPrime"></param>
        /// <param name="secondPrime"></param>
        /// <returns></returns>
        public bool GeneralKeys(Int64 firstPrime, Int64 secondPrime)
        {// Sinh PublicKey và PrivateKey với tham số truyền vào là 2 số nguyên tố (ngẫu nhiên) không trùng nhau
            try
            {
                _publicKey  = null;
                _privateKey = null;
                //2 số firstPrime và secondPrime là những số nguyên tố không trùng nhau
                if (firstPrime <= 0 || !IsPrimeNumber(firstPrime) || firstPrime <= 0 || !IsPrimeNumber(firstPrime) || firstPrime == secondPrime)
                {
                    return(false);
                }
                Int64 p     = secondPrime;
                Int64 q     = firstPrime;
                Int64 n     = CalculatePublicModule(p, q); // module được công khai được tính theo công thức n = p*q
                Int64 euler = CalculateEuler(p, q);
                // giá trị euler của n được tính theo công thức euler(n) =  (p - 1) * (q - 1)
                Int64 e = 0, d = 0; //e : số mũ công khai ; d : số mũ bí mật;
                bool  flag = false;
                while (!flag)
                {
                    e = GeneralPublicExponent(euler, MinValue);
                    var euclidExtended = EuclidExtended(e, euler);
                    if (euclidExtended != null)
                    {
                        d = Math.Abs((long)euclidExtended);

                        if (e != d && (e * d) % euler == 1)
                        {
                            _publicKey = new RsaKey {
                                Exponent = e, Modulus = n
                            };
                            _privateKey = new RsaKey {
                                Exponent = d, Modulus = n
                            };
                            _p               = p;
                            _q               = q;
                            _modulus         = n;
                            _euler           = euler;
                            _privateExponent = d;
                            _publicExponent  = e;
                            flag             = true;
                        }
                    }
                }
                return(true);
            }
            catch (Exception ex)
            {
                return(false);
            }
        }
コード例 #3
0
 /// <summary>
 /// encrypt(m) = m^e mod n
 /// </summary>
 /// <param name="msg"></param>
 /// <param name="publicKey"></param>
 /// <returns></returns>
 public static string Encrypt(string msg, RsaKey publicKey)
 {
     // Exponent : e ; Modulus : n
     if (publicKey.Exponent > 0 && publicKey.Modulus > 0)
     {
         var encMassage = ConvertStringLongs(msg);
         var longs      = new long[encMassage.Length];
         for (var i = 0; i < encMassage.Length; i++)
         {
             longs[i] = PowerModulo(encMassage[i], publicKey.Exponent, publicKey.Modulus);  //kết quả trả về của function PowerModulo là c hay là encrypt(m)
         }
         return(ConvertLongsToString64(longs));
     }
     return(string.Empty);
 }
コード例 #4
0
        public static byte[] Encrypt(byte[] data, RsaKey publicKey)
        {
            string result = string.Empty;

            if (publicKey.Exponent > 0 && publicKey.Modulus > 0)
            {
                var encData = ConvertBytesToLongs(data);
                var longs   = new long[encData.Length];
                for (var i = 0; i < encData.Length; i++)
                {
                    var output = PowerModulo(encData[i], publicKey.Exponent, publicKey.Modulus);
                    longs[i] = output;
                }
                result = ConvertLongsToString64(longs);
            }
            return(Encoding.UTF8.GetBytes(result));
        }
コード例 #5
0
        public static byte[] Decrypt(byte[] data, RsaKey privateKey)
        {
            var result = "";

            // Exponent : d ; Modulus : n
            if (privateKey.Exponent > 0 && privateKey.Modulus > 0)
            {
                var decMassage = ConvertString64ToLongs(Encoding.UTF8.GetString(data));
                var longs      = new Int64[decMassage.Length];
                for (var i = 0; i < decMassage.Length; i++)
                {
                    var output = PowerModulo(decMassage[i], privateKey.Exponent, privateKey.Modulus); // kết quả trả về của function PowerModulo là m hay decrypt(c)
                    longs[i] = Convert.ToInt64(output);
                }

                result = ConvertLongsToString(longs);
            }
            return(Encoding.UTF8.GetBytes(result));
        }
コード例 #6
0
        /// <summary>
        /// decrypt(c)= c^d * mod n
        /// </summary>
        /// <param name="cipherText"></param>
        /// <param name="privateKey"></param>
        /// <returns></returns>
        public static string Decrypt(string cipherText, RsaKey privateKey)
        {
            var result = "";

            // Exponent : d ; Modulus : n
            if (privateKey.Exponent > 0 && privateKey.Modulus > 0)
            {
                //var decMassage = ConvertStringLongs(cipherText);
                var decMassage = ConvertString64ToLongs(cipherText);
                var longs      = new Int64[decMassage.Length];
                for (var i = 0; i < decMassage.Length; i++)
                {
                    var output = PowerModulo(decMassage[i], privateKey.Exponent, privateKey.Modulus); // kết quả trả về của function PowerModulo là m hay decrypt(c)
                    longs[i] = Convert.ToInt64(output);
                }

                result = ConvertLongsToString(longs);
            }
            return(result);
        }