Пример #1
0
        public static BigInteger[] GenerateSignature(BigInteger privateKey, byte[] hash)
        {
            BigInteger?k = null;

            for (int i = 0; i < 100; i++)
            {
                byte[] kBytes = new byte[33];
                rngCsp.GetBytes(kBytes);
                kBytes[32] = 0;

                k = new BigInteger(kBytes);
                var z = Bytes32.ConvetToBigInteger(hash);

                if (k.Value.IsZero || k >= Secp256k1.q)
                {
                    continue;
                }

                var r = Calculate.getPublicByPrivate(k.Value)[0] % Secp256k1.q;

                if (r.IsZero)
                {
                    continue;
                }

                var ss = (z + r * privateKey);
                var s  = (ss * (k.Value.ModInverse(Secp256k1.q))) % Secp256k1.q;

                if (s.IsZero)
                {
                    continue;
                }

                return(new BigInteger[] { r, s });
            }

            throw new Exception("Unable to generate signature");
        }
Пример #2
0
        public static string GetAddressOfUncompressed(BigInteger[] publicKey)
        {
            var publicKeyArray1 = HexToByteArray.BigIntegerTo32ByteArray(publicKey[0]);

            HexToByteArray.ChangeDirection(ref publicKeyArray1);
            var publicKeyArray2 = HexToByteArray.BigIntegerTo32ByteArray(publicKey[1]);

            HexToByteArray.ChangeDirection(ref publicKeyArray2);
            //    var array = HexToByteArray.BigIntegerTo32ByteArray(privateKey);

            var resultAdd = Calculate.BiteSplitJoint(new byte[] { 0x04 }, publicKeyArray1);

            resultAdd = Calculate.BiteSplitJoint(resultAdd, publicKeyArray2);
            Console.WriteLine($"非压缩公钥为{ Hex.BytesToHex(resultAdd)}");


            var step3 = ripemd160.ComputeHash(sha256.ComputeHash(resultAdd));

            var step4 = Calculate.BiteSplitJoint(new byte[] { 0x00 }, step3);

            var step5 = sha256.ComputeHash(sha256.ComputeHash(step4));

            var step6 = Calculate.BiteSplitJoint(step4, new byte[] { step5[0], step5[1], step5[2], step5[3] });

            return(Calculate.Encode(step6));

            //SHA256 sha256 = new SHA256Managed();
            //byte[] hash1 = sha256.ComputeHash(resultAdd);

            //var pubKeyHash = Hash160.Hash(publicKey.EncodePoint(hash1));
            //byte[] hash2 = sha256.ComputeHash(hash1);

            //var result = new byte[CheckSumSizeInBytes];
            //Buffer.BlockCopy(hash2, 0, result, 0, result.Length);

            //byte[] chechHash = Calculate.GetCheckSum(resultAdd);
        }
Пример #3
0
        internal static bool Check(string inputSting, out System.Numerics.BigInteger privateBigInteger)
        {
            var privateByte = Base58.Decode(inputSting);

            // var privateByte = Hex.HexToBytes32(inputSting);
            //  var privateKey1 = Calculate.Encode(privateByte);
            if (privateByte.Length == 38)
            {
                if (privateByte[0] == 0x80 && privateByte[33] == 0x01)
                {
                    var m = new List <byte>();
                    for (var i = 0; i < 34; i++)
                    {
                        m.Add(privateByte[i]);
                    }
                    byte[] chechHash = Calculate.GetCheckSum(m.ToArray());
                    if (
                        chechHash[0] == privateByte[34] &&
                        chechHash[1] == privateByte[35] &&
                        chechHash[2] == privateByte[36] &&
                        chechHash[3] == privateByte[37])
                    {
                        privateBigInteger = 0;
                        for (var i = 1; i < 33; i++)
                        {
                            privateBigInteger = privateBigInteger * 256;
                            privateBigInteger = privateBigInteger + Convert.ToInt32(privateByte[i]);
                        }
                        privateBigInteger = privateBigInteger % Secp256k1.q;
                        return(true);
                    }
                    else
                    {
                        privateBigInteger = -1;
                        return(false);
                    }
                }
                else
                {
                    privateBigInteger = -1;
                    return(false);
                }
            }
            else if (privateByte.Length == 37)
            {
                if (privateByte[0] == 0x80)
                {
                    var m = new List <byte>();
                    for (var i = 0; i < 33; i++)
                    {
                        m.Add(privateByte[i]);
                    }
                    byte[] chechHash = Calculate.GetCheckSum(m.ToArray());
                    if (
                        chechHash[0] == privateByte[33] &&
                        chechHash[1] == privateByte[34] &&
                        chechHash[2] == privateByte[35] &&
                        chechHash[3] == privateByte[36])
                    {
                        privateBigInteger = 0;
                        for (var i = 1; i < 33; i++)
                        {
                            privateBigInteger = privateBigInteger * 256;
                            privateBigInteger = privateBigInteger + Convert.ToInt32(privateByte[i]);
                        }
                        privateBigInteger = privateBigInteger % Secp256k1.q;
                        return(true);
                    }
                    else
                    {
                        privateBigInteger = -1;
                        return(false);
                    }
                }
                else
                {
                    privateBigInteger = -1;
                    return(false);
                }
            }
            else
            {
                privateBigInteger = -1;
                return(false);
            }
        }
Пример #4
0
        public static void SecretFileF()
        {
            while (true)
            {
                Console.WriteLine($"输入助记词!");
                SHA256 sha256 = new SHA256Managed();
                byte[] hash   = sha256.ComputeHash(Encoding.UTF8.GetBytes(Console.ReadLine()));
                // var privateKey = HexToBigInteger.inputHex("e8d96a53e9c597e5a1e2ceaddd0b5ebe75588b26e71846b46a9b5f3666409355");

                //var inputSting = "e8d96a53e9c597e5a1e2ceaddd0b5ebe75588b26e71846b46a9b5f3666409355";
                //var inputSting = ;
                var privateKey = Bytes32.ConvetToBigInteger(hash);
                privateKey = privateKey % Secp256k1.q;
                var privateByte = hash;

                {
                    var resultAdd = Calculate.BiteSplitJoint(new byte[] { 0x80 }, privateByte);
                    resultAdd = Calculate.BiteSplitJoint(resultAdd, new byte[] { 0x01 });
                    byte[] chechHash = Calculate.GetCheckSum(resultAdd);
                    resultAdd = Calculate.BiteSplitJoint(resultAdd, chechHash);
                    var privateKey1 = Calculate.Encode(resultAdd);
                    Console.WriteLine($"您压缩后的私钥为{privateKey1}");
                }
                {
                    var    resultAdd = Calculate.BiteSplitJoint(new byte[] { 0x80 }, privateByte);
                    byte[] chechHash = Calculate.GetCheckSum(resultAdd);
                    resultAdd = Calculate.BiteSplitJoint(resultAdd, chechHash);
                    var privateKey1 = Calculate.Encode(resultAdd);
                    Console.WriteLine($"您压缩前的私钥为{privateKey1}");
                }
                var publicKey = Calculate.getPublicByPrivate(privateKey);
                if (publicKey != null)
                {
                    var walletOfcompressed = PublicKeyF.GetAddressOfcompressed(publicKey);
                    Console.WriteLine($"压缩钱包地址为:{walletOfcompressed}");
                    var walletOfUncompressed = PublicKeyF.GetAddressOfUncompressed(publicKey);
                    Console.WriteLine($"非压缩钱包地址为:{walletOfUncompressed}");
                }
                else
                {
                    Console.WriteLine($"您输入了零元!");
                }
                Console.WriteLine("E/Exit,退出当前");

                if (Console.ReadLine().ToUpper() == "E")
                {
                    break;
                }
            }


            //Console.WriteLine($"您的非私钥为80{HexToBigInteger.bigIntergetToHex(publicKey[0])}01");


            //var publicKeyName = getPublicKeyName(publicKey);
            //Console.WriteLine($"您的公钥16进制为{publicKeyName}");
            //if (publicKey != null)
            //    Console.WriteLine($"您的公钥10进制为:{publicKey[0]},{publicKey[1]}");


            //Random rm = new Random(DateTime.Now.GetHashCode());
            //for (var i = 1; i <= 256 * 256; i++)
            //{
            //    var M = getPublicByPrivate(new BigInteger(i));
            //}
            //   throw new NotImplementedException();
        }
Пример #5
0
        public static string SignMessage()
        {
            Console.WriteLine("请输入要签名的信息(utf-8)");
            var msg = Console.ReadLine();

            Console.WriteLine("请输入要私钥");
            //   output($"拖入您的Base58编码的37位或38位的私钥的路径,用此私钥进行验证.即校验.txt");

            var privateKey = Console.ReadLine();

            System.Numerics.BigInteger privateBigInteger;
            if (PrivateKeyF.Check(privateKey, out privateBigInteger))
            {
            }
            else
            {
                Console.WriteLine($"请输入正确的私钥!!!");
                return("");
            }
            bool   compressed;
            string address;

            if (privateKey.Length == 51)
            {
                compressed = false;
                address    = PublicKeyF.GetAddressOfUncompressed(Calculate.getPublicByPrivate(privateBigInteger));
            }
            else if (privateKey.Length == 52)
            {
                compressed = true;
                address    = PublicKeyF.GetAddressOfcompressed(Calculate.getPublicByPrivate(privateBigInteger));
            }
            else
            {
                throw new Exception("");
            }


            var msgHash = msg_digest(msg);
            var signal  = PrivateKeyF.Sign(privateBigInteger, msgHash);
            var r       = signal[0];
            var rByte   = HexToByteArray.BigIntegerTo32ByteArray(r);

            HexToByteArray.ChangeDirection(ref rByte);

            var s     = signal[1];
            var sByte = HexToByteArray.BigIntegerTo32ByteArray(s);

            HexToByteArray.ChangeDirection(ref sByte);

            // Console.WriteLine($"{Convert.ToBase64String(rByte)}{Convert.ToBase64String(sByte)}");

            var sequence = new byte[] { 0 }; //[0];

            sequence = sequence.Concat(rByte).ToArray();
            sequence = sequence.Concat(sByte).ToArray();

            for (var i = 0; i < 4; i++)
            {
                int nV = 27 + i;
                if (compressed)
                {
                    nV += 4;
                }
                sequence[0] = Convert.ToByte(nV);
                var sig = Convert.ToBase64String(sequence);
                Console.WriteLine(sig);
                var calAddredd = verify_message(sig, msg, compressed ? 1 : 0);
                // return sig;
                if (calAddredd == address)
                {
                    return(sig);
                }
                //if (verify_message(sig, msg, compressed ? 1 : 0) == address)
                //    return sig;
            }
            return("");
        }
Пример #6
0
        public static string verify_message(string signature, string message, int addrtype)
        {
            byte[] sig;
            //try
            {
                sig = Convert.FromBase64String(signature);
            }
            //catch (err)
            //{
            //    return false;
            //}

            if (sig.Length != 65)
            {
                return("Error e");
            }

            // extract r,s from signature
            var r = Bytes32.ConvetToBigInteger(sig.Skip(1).Take(32).ToArray());
            var s = Bytes32.ConvetToBigInteger(sig.Skip(33).Take(32).ToArray());
            // var s = BigInteger.fromByteArrayUnsigned(sig.slice(33, 33 + 32));

            // get recid
            //  var compressed = false;
            var nV = Convert.ToInt32(sig[0]);

            if (nV < 27 || nV >= 35)
            {
                return("Error e");
            }
            if (nV >= 31)
            {
                //    compressed = true;
                nV -= 4;
            }
            var recid = new BigInteger(nV - 27);


            {
                //var z = Bytes32.ConvetToBigInteger(hash); ;
                //var w = s.ModInverse(Secp256k1.q);
                //var u1 = (z * w) % Secp256k1.q;
                //var u2 = (r * w) % Secp256k1.q;
                //bool isZero;
                //var pt = Calculate.pointPlus(Calculate.getPublicByPrivate(u1), Calculate.getMulValue(u2, publicKey), out isZero);// (publicKey.Multiply(u2));

                //if (pt == null)
                //{
                //    return false;
                //}
                //else
                //{
                //    var pmod = pt[0] % Secp256k1.q;

                //    return pmod == r;
                //}
            }
            //var ecparams = getSECCurveByName("secp256k1");
            //var curve = ecparams.getCurve();
            //var a = curve.getA().toBigInteger();
            //var b = curve.getB().toBigInteger();
            //var p = curve.getQ();
            //var G = ecparams.getG();
            //var order = ecparams.getN();

            //var x = r.add(order.multiply(recid.divide(BigInteger.valueOf(2))));
            var x = recid / 2 * Secp256k1.q + r;

            //Calculate.getMulValue(,recid / 2);
            // var alpha = x.multiply(x).multiply(x).add(a.multiply(x)).add(b).mod(p);
            var alpha = (x * x * x + Secp256k1.a * x + Secp256k1.b) % Secp256k1.p;
            //var beta = alpha.modPow(p.add(BigInteger.ONE).divide(BigInteger.valueOf(4)), p);
            var beta = BigInteger.ModPow(alpha, (Secp256k1.p + 1) / 4, Secp256k1.p);//Calculate.Pow((Secp256k1.p + 1) / 4, alpha);
            var y    = (beta - recid).IsEven ? beta : (Secp256k1.p - beta);
            //var y = beta.subtract(recid).isEven() ? beta : p.subtract(beta);

            //   var R = new ECPointFp(curve, curve.fromBigInteger(x), curve.fromBigInteger(y));
            // var e = BigInteger.fromByteArrayUnsigned(msg_digest(message));
            var e = Bytes32.ConvetToBigInteger(msg_digest(message));
            //    var minus_e = BigInteger.Negate(e)+ % Secp256k1.q;
            var minus_e = ((Secp256k1.q - e) % Secp256k1.q + Secp256k1.q) % Secp256k1.q;
            var inv_r   = ECCMain.Inverse.ex_gcd(r, Secp256k1.q);////BigInteger.mo r.modInverse(order);
            //var Q = (R.multiply(s).add(G.multiply(minus_e))).multiply(inv_r);
            bool isZero;
            var  Q__ = Calculate.pointPlus(Calculate.getMulValue(s, new BigInteger[] { x, y }),
                                           Calculate.getPublicByPrivate(minus_e), out isZero);

            if (isZero)
            {
                return("Error e");
            }
            else
            {
                var Q          = Calculate.getMulValue(inv_r, Q__);
                var public_key = PublicKeyF.GetAddressOfcompressed(Q);
                if (addrtype == 0)
                {
                    return(PublicKeyF.GetAddressOfUncompressed(Q));
                }
                else if (addrtype == 1)
                {
                    return(PublicKeyF.GetAddressOfcompressed(Q));
                }
                else
                {
                    return("Error e");
                }
            }
        }