Пример #1
0
        private static bool CheckSignature(BigInteger m, BigInteger s, BigInteger d, BigInteger N)
        {
            BigInteger h = CalculateHash(m);
            BigInteger w = CryptoTools.ModuloPower(s, d, N);

            return(w == h);
        }
Пример #2
0
        private static void SimulateShamirExchange(BigInteger p, BigInteger cA, BigInteger cB, BigInteger m)
        {
            BigInteger dA, dB;

            dA = ShamirTools.GenerateShamirPrivateKeyUsingAnother(p, cA);
            Console.WriteLine($"dA = {dA}");
            dB = ShamirTools.GenerateShamirPrivateKeyUsingAnother(p, cB);
            Console.WriteLine($"dB = {dB}");

            BigInteger x = m;


            Console.WriteLine($"Message is {x}");

            BigInteger y = CryptoTools.ModuloPower(x, cA, p);

            Console.WriteLine($"Alice calculated y = {y} and sent it to Bob");

            BigInteger z = CryptoTools.ModuloPower(y, cB, p);

            Console.WriteLine($"Bob calculated z = {z} and sent it to Alice");

            BigInteger u = CryptoTools.ModuloPower(z, dA, p);

            Console.WriteLine($"Alice calculated u = {u} and sent it to Bob");

            BigInteger w = CryptoTools.ModuloPower(u, dB, p);

            Console.WriteLine($"Bob calculated w = {w}");
        }
Пример #3
0
        private static void EncryptMessage(BigInteger g, BigInteger receiverPublicKey, BigInteger p, BigInteger message, out BigInteger y, out BigInteger k)
        {
            BigInteger r = CryptoTools.GenerateRandomBigInteger(1, p - 1);

            k = CryptoTools.ModuloPower(g, r, p);
            y = (message * CryptoTools.ModuloPower(receiverPublicKey, r, p)) % p;
        }
Пример #4
0
        private static void SimulateDiffieHellmanExchange(BigInteger p, BigInteger g)
        {
            Console.WriteLine("Alice starts exchange");

            BigInteger xA = CryptoTools.GenerateDiffieHellmanPrivateKey(g, p);

            Console.WriteLine("Alice generated private key xA = {0}", xA);
            BigInteger yA = CryptoTools.GenerateDiffieHellmanPublicKey(g, xA, p);

            Console.WriteLine("Alice generated public key yA = {0} and sent it to Bob", yA);

            BigInteger xB = CryptoTools.GenerateDiffieHellmanPrivateKey(g, p);

            Console.WriteLine("Bob generated private key xB = {0}", xB);
            BigInteger yB = CryptoTools.GenerateDiffieHellmanPublicKey(g, xB, p);

            Console.WriteLine("Bob generated public key yB = {0} and sent it to Alice", yB);

            BigInteger zAB = CryptoTools.ModuloPower(yB, xA, p);

            Console.WriteLine($"Alice calculated zAB = {zAB} - common private key");

            BigInteger zBA = CryptoTools.ModuloPower(yA, xB, p);

            Console.WriteLine($"Bob calculated zBA = {zBA} - common private key");
        }
Пример #5
0
        private static void SignMessage(BigInteger h, BigInteger g, BigInteger p, BigInteger x, out BigInteger r, out BigInteger s)
        {
            BigInteger k, kRev, ret;

            do
            {
                k   = CryptoTools.GenerateRandomBigInteger(2, p - 1);
                ret = CryptoTools.EuclidAlgorithm(p - 1, k, out _, out kRev);
            } while (ret != 1);

            if (kRev < 0)
            {
                kRev += (p - 1);
            }

            r = CryptoTools.ModuloPower(g, k, p);

            BigInteger u = (h - x * r) % (p - 1);

            if (u < 0)
            {
                u += (p - 1);
            }
            s = (kRev * u) % (p - 1);
        }
Пример #6
0
 private static bool CheckBanknoteSignature(BigInteger n, BigInteger s, BigInteger d, BigInteger N)
 {
     if (n == CryptoTools.ModuloPower(s, d, N))
     {
         return(true);
     }
     return(false);
 }
Пример #7
0
        //private static List<NumberIndex> babyList = new List<NumberIndex>(), giantList = new List<NumberIndex>();

        internal static BigInteger SolveEquation(BigInteger y, BigInteger a, BigInteger p)
        {
            List <NumberIndex> commonList = new List <NumberIndex>();

            BigInteger k, m;

            k = m = (BigInteger)Math.Ceiling(Math.Sqrt((double)p));
            for (BigInteger i = 0; i < m; i++)
            {
                commonList.Add(new NumberIndex((y * CryptoTools.ModuloPower(a, i, p)) % p, i, true));
            }

            for (BigInteger j = 1; j <= k; j++)
            {
                commonList.Add(new NumberIndex(CryptoTools.ModuloPower(a, j * m, p), j, false));
            }

            commonList.Sort();

            NumberIndex prev = null, cur = null;
            BigInteger  iX = 0, jX = 0;

            foreach (var element in commonList)
            {
                if (cur != null)
                {
                    prev = cur;
                }
                cur = element;

                if (prev != null)
                {
                    if (prev.Number == cur.Number)
                    {
                        if (prev.IsBaby != cur.IsBaby)
                        {
                            if (prev.IsBaby == false)
                            {
                                iX = prev.Index;
                                jX = cur.Index;
                            }
                            else
                            {
                                jX = prev.Index;
                                iX = cur.Index;
                            }
                            break;
                        }
                        else
                        {
                        }
                    }
                }
            }

            return(iX * m - jX);
        }
Пример #8
0
        public static BigInteger GenerateShamirPrivateKeyUsingAnother(BigInteger p, BigInteger c)
        {
            BigInteger temp, d, ret = CryptoTools.EuclidAlgorithm(p - 1, c, out temp, out d);

            if (d < 0)
            {
                d += (p - 1);
            }
            return(d);
        }
Пример #9
0
        internal static void SimulateRSASigning(BigInteger p, BigInteger q, BigInteger d, BigInteger m)
        {
            Console.WriteLine($"Alice gonna sign messsage m = {m} and send it to Bob");


            BigInteger N   = p * q;
            BigInteger phi = (p - 1) * (q - 1);

            BigInteger c, temp;

            BigInteger ret = CryptoTools.EuclidAlgorithm(phi, d, out temp, out c);

            if (ret != 1)
            {
                Console.WriteLine($"d = {d} isn't mutually prime with phi(N)! A new one will be generated");

                BigInteger cCandidate, dCandidate;
                do
                {
                    dCandidate = CryptoTools.GenerateRandomBigInteger(1, phi);
                    ret        = CryptoTools.EuclidAlgorithm(phi, dCandidate, out temp, out cCandidate);
                } while (ret != 1);
                c = cCandidate;
                d = dCandidate;
            }
            if (c < 0)
            {
                c += phi;
            }

            Console.WriteLine($"Alice's public keys are N = {N} and d = {d}");
            Console.WriteLine($"Alice's private key is c = {c}");


            BigInteger y = CalculateHash(m);

            Console.WriteLine($"Hash function of message {m} is {y} (h(m) = m)");

            BigInteger s = SignMessage(y, c, N);

            Console.WriteLine($"Alice sent message {m} and signature {s} to Bob");

            Console.WriteLine("Bob received them and checked if signature is correct");
            SimulateRSAChecking(m, s, d, N);
        }
Пример #10
0
        public static void GenerateShamirPrivateKeys(BigInteger p, out BigInteger c, out BigInteger d)
        {
            Random     r = new Random();
            BigInteger cCandidate, dCandidate, ret;

            do
            {
                BigInteger temp;
                cCandidate = r.Next(1, (int)p);
                ret        = CryptoTools.EuclidAlgorithm(p - 1, cCandidate, out temp, out dCandidate);
            } while (ret != 1); //крутимся пока не найдём такое cCandidate: (cCandidate, p - 1) = 1. тогда dCandidate обратное к cCandidate с точностью до модуля
            c = cCandidate;
            if (dCandidate < 0)
            {
                dCandidate += (p - 1);
            }
            d = dCandidate;
        }
Пример #11
0
        public static void SimulateMoneyExchange(BigInteger p, BigInteger q)
        {
            Console.WriteLine($"Bank's private p is {p}");
            Console.WriteLine($"Bank's private q is {q}");
            BigInteger N = p * q, phi = (p - 1) * (q - 1);

            Console.WriteLine($"Bank's public N is {N}, phi(N) = {phi}");

            BigInteger c, d;

            CryptoTools.GenerateInverseNumbers(phi, out c, out d);
            Console.WriteLine($"Bank's private c is {c} and public d is {d}");

            Console.WriteLine("START OF EXCHANGE");

            BigInteger n = CryptoTools.GenerateRandomBigInteger(2, N);
            BigInteger r, rInv;

            CryptoTools.GenerateInverseNumbers(N, out r, out rInv);
            BigInteger n_ = n * CryptoTools.ModuloPower(r, d, N) % N;

            Console.WriteLine("Client wants to purchase an item.");
            Console.WriteLine($"Client generated private n = {n}, random r = {r}: (r, N) = 1, then calculated n_ = (n * r^d) mod N = {n_} and sent it to bank");

            BigInteger s_ = CryptoTools.ModuloPower(n_, c, N);

            Console.WriteLine($"Bank calculated s_ = {s_}, withdrew money from client's account and sent s_ to client");

            BigInteger s = (s_ * rInv) % N;

            Console.WriteLine($"Client calculated s = {s} - this is bank's signature. Client's banknote is <n = {n}, s = {s}>");

            Console.WriteLine("Client sends banknote to shop");
            SimulateBanknoteChecking(n, s, d, N);

            Console.WriteLine("Do you want to try to use the same banknote again? y - yes, else - no");
            ConsoleKeyInfo cki = Console.ReadKey();

            Console.WriteLine();
            if (cki.KeyChar == 'y')
            {
                SimulateBanknoteChecking(n, s, d, N);
            }
        }
Пример #12
0
        private static void SimulateShamirExchange(BigInteger p)
        {
            BigInteger cA, dA, cB, dB;

            ShamirTools.GenerateShamirPrivateKeys(p, out cA, out dA);
            Console.WriteLine($"Alice generated private keys cA = {cA}, dA = {dA}");
            ShamirTools.GenerateShamirPrivateKeys(p, out cB, out dB);
            Console.WriteLine($"Bob generated private keys cB = {cB}, dB = {dB}");

            BigInteger x = -1;

            do
            {
                Console.WriteLine("Please enter message, x < p");
                string s = Console.ReadLine();
                try
                {
                    x = BigInteger.Parse(s);
                }
                catch (FormatException)
                {
                    x = -1;
                }
            }while (x < 0 || x >= p);

            Console.WriteLine($"Message is {x}");

            BigInteger y = CryptoTools.ModuloPower(x, cA, p);

            Console.WriteLine($"Alice calculated y = {y} and sent it to Bob");

            BigInteger z = CryptoTools.ModuloPower(y, cB, p);

            Console.WriteLine($"Bob calculated z = {z} and sent it to Alice");

            BigInteger u = CryptoTools.ModuloPower(z, dA, p);

            Console.WriteLine($"Alice calculated u = {u} and sent it to Bob");

            BigInteger w = CryptoTools.ModuloPower(u, dB, p);

            Console.WriteLine($"Bob calculated w = {w}");
        }
Пример #13
0
        public static void SimulateElGamalSigning(BigInteger p, BigInteger g, BigInteger m)
        {
            Console.WriteLine($"Alice gonna sign messsage m = {m} and send it to Bob");
            BigInteger x = CryptoTools.GenerateRandomBigInteger(2, p - 1);
            BigInteger y = CryptoTools.ModuloPower(g, x, p);

            Console.WriteLine($"Alice generated her private key x = {x} and calculated her public key y = {y}");


            BigInteger h = CalculateHash(m);

            Console.WriteLine($"Hash function of message {m} is {h} (h(m) = m)");

            BigInteger r, s;

            SignMessage(h, g, p, x, out r, out s);

            Console.WriteLine($"Alice signed her message and sent <m = {m}, r = {r}, s = {s}> to Bob");
            Console.WriteLine("Bob received them and checked if signature is correct:");
            SimulateElGamalChecking(m, r, s, p, y, g);
        }
Пример #14
0
        internal static void SimulateRSAExchange(BigInteger p, BigInteger q, BigInteger d, BigInteger x)
        {
            BigInteger N   = p * q;
            BigInteger phi = (p - 1) * (q - 1);

            BigInteger c, temp;

            BigInteger ret = CryptoTools.EuclidAlgorithm(phi, d, out temp, out c);

            if (ret != 1)
            {
                Console.WriteLine($"d = {d} isn't mutually prime with phi(N)! A new one will be generated");

                BigInteger cCandidate, dCandidate;
                do
                {
                    dCandidate = CryptoTools.GenerateRandomBigInteger(1, phi);
                    ret        = CryptoTools.EuclidAlgorithm(phi, dCandidate, out temp, out cCandidate);
                } while (ret != 1);
                c = cCandidate;
                d = dCandidate;
            }
            if (c < 0)
            {
                c += phi;
            }

            Console.WriteLine($"Receiver's public keys are N = {N} and d = {d}");
            Console.WriteLine($"Receiver's private key is c = {c}");

            BigInteger y = CryptoTools.ModuloPower(x, d, N);

            Console.WriteLine($"Sender encrypted message and sent y = {y} to receiver");

            BigInteger w = CryptoTools.ModuloPower(y, c, N);

            Console.WriteLine($"Receiver decrypted y and got w = {w}");
        }
Пример #15
0
 private static BigInteger GenerateElGamalPrivateKey(BigInteger g, BigInteger p)
 {
     return(CryptoTools.GenerateRandomBigInteger(2, p - 1));
 }
Пример #16
0
        private static bool CheckSignature(BigInteger m, BigInteger r, BigInteger s, BigInteger p, BigInteger y, BigInteger g)
        {
            BigInteger h = CalculateHash(m);

            return((CryptoTools.ModuloPower(y, r, p) * CryptoTools.ModuloPower(r, s, p)) % p == CryptoTools.ModuloPower(g, h, p));
        }
Пример #17
0
 private static BigInteger GenerateKey(int n)
 {
     return(CryptoTools.GenerateUnsignedRandomBigInteger(0, BigInteger.Pow(2, n)));
 }
Пример #18
0
        internal static void SimulatePokerExchange(BigInteger p)
        {
            BigInteger cA, dA, cB, dB;

            GeneratePokerPrivateKeys(p, out cA, out dA);
            Console.WriteLine($"Alice's private keys are cA = {cA} and dA = {dA}");
            GeneratePokerPrivateKeys(p, out cB, out dB);
            Console.WriteLine($"Bob's private keys are cB = {cB} and dB = {dB}");

            BigInteger alpha, beta, gamma; //карты

            GenerateCardNumbers(p, out alpha, out beta, out gamma);
            Console.WriteLine($"Alice generated numbers for cards and told Bob that alpha is {alpha}, beta is {beta}, gamma is {gamma}");

            Console.WriteLine("START OF THE EXCHANGE");
            Triplet cards = new Triplet(new Card(alpha, "ALPHA"), new Card(beta, "BETA"), new Card(gamma, "GAMMA"));
            Triplet encryptedCardsForBob = cards.ModuloPower(cA, p);

            Console.WriteLine($"Alice encrypted card numbers: alpha to {encryptedCardsForBob.X}, beta to {encryptedCardsForBob.Y}, gamma to {encryptedCardsForBob.Z}...");
            encryptedCardsForBob.Mix();
            Console.WriteLine($"...And then mixed them: {encryptedCardsForBob.X}, {encryptedCardsForBob.Y}, {encryptedCardsForBob.Z} and sent to Bob");

            BigInteger cardAEncryptedNumber = encryptedCardsForBob.ChooseRandom3();

            Console.WriteLine($"Bob chose {cardAEncryptedNumber} and sent to Alice");

            BigInteger cardANumber = CryptoTools.ModuloPower(cardAEncryptedNumber, dA, p);

            Console.WriteLine($"Alice decrypted it; her card number is {cardANumber} and it's {cards.FindName(cardANumber)}!");

            encryptedCardsForBob.RemoveUsedCard();
            Triplet encryptedCardsForAlice = encryptedCardsForBob.ModuloPower(cB, p);

            encryptedCardsForAlice.Mix();
            Console.Write($"Bob encrypted card numbers, mixed them and sent to Alice: ");
            for (int i = 0; i < 3; i++)
            {
                if (encryptedCardsForAlice[i].Number != 0)
                {
                    Console.Write($"{encryptedCardsForAlice[i].Name} to {encryptedCardsForAlice[i].Number} ");
                }
            }
            Console.WriteLine();

            BigInteger cardBEncryptedNumber          = encryptedCardsForAlice.ChooseRandom2();
            BigInteger cardBPartiallyDecryptedNumber = CryptoTools.ModuloPower(cardBEncryptedNumber, dA, p);

            Console.WriteLine($"Alice chose {cardBEncryptedNumber}, found its power {cardBPartiallyDecryptedNumber} and sent to Bob");

            BigInteger cardBNumber = CryptoTools.ModuloPower(cardBPartiallyDecryptedNumber, dB, p);

            Console.WriteLine($"Bob decrypted it; his card number is {cardBNumber} and it's {cards.FindName(cardBNumber)}!");

            encryptedCardsForBob.RemoveUsedCard();
            for (int i = 0; i < 3; i++)
            {
                if (cards[i].Number != cardANumber && cards[i].Number != cardBNumber)
                {
                    Console.WriteLine($"The third card has number {cards[i].Number} and is {cards[i].Name} ");
                }
            }
        }
Пример #19
0
 private static BigInteger GenerateElGamalPublicKey(BigInteger g, BigInteger privateKey, BigInteger p)
 {
     return(CryptoTools.ModuloPower(g, privateKey, p));
 }
Пример #20
0
 private static BigInteger DecryptMessage(BigInteger receiverPrivateKey, BigInteger p, BigInteger y, BigInteger k)
 {
     return(y * CryptoTools.ModuloPower(k, p - receiverPrivateKey - 1, p) % p);
 }
Пример #21
0
 private static BigInteger SignMessage(BigInteger y, BigInteger c, BigInteger N)
 {
     return(CryptoTools.ModuloPower(y, c, N));
 }