コード例 #1
0
        private static bool VerifySignature(string message, byte[] public_key_bytes, string signature)
        {
            var curve  = SecNamedCurves.GetByName("secp256r1");
            var domain = new ECDomainParameters(curve.Curve, curve.G, curve.N, curve.H);

            //var publicKeyBytes = Base58Encoding.Decode(publicKey);
            //var publicKeyBytes = Base58Encoding.DecodeWithCheckSum(publicKey);
            //var publicKeyBytes = Base58Encoding.DecodePublicKey(publicKey);

            var byte0 = new byte[public_key_bytes.Length + 1];

            byte0[0] = 4;
            Array.Copy(public_key_bytes, 0, byte0, 1, public_key_bytes.Length);
            var q = curve.Curve.DecodePoint(byte0);

            var keyParameters = new
                                Org.BouncyCastle.Crypto.Parameters.ECPublicKeyParameters(q,
                                                                                         domain);

            ISigner signer = SignerUtilities.GetSigner("SHA-256withECDSA");

            signer.Init(false, keyParameters);
            signer.BlockUpdate(Encoding.UTF8.GetBytes(message), 0, message.Length);

            var signatureBytes = Base58Encoding.Decode(signature);
            var derSign        = SignatureHelper.derSign(signatureBytes);

            return(signer.VerifySignature(derSign));
        }
コード例 #2
0
        public string Decrypt(string LocalPrivateKey, string RemoteAccountId, string Salt, string CipherText)
        {
            var secret          = GetSharedSecret(LocalPrivateKey, RemoteAccountId);
            var cipherTextBytes = Base58Encoding.Decode(CipherText);
            var saltBytes       = Encoding.Unicode.GetBytes(Salt.ToCharArray(), 0, 8);

            using (var rijndael = new RijndaelManaged())
            {
                //rijndael.Key = secret;
                //rijndael.IV = saltBytes;
                var decryptor = rijndael.CreateDecryptor(secret, saltBytes);
                using (var memoryStream = new MemoryStream(cipherTextBytes))
                {
                    using (var cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read))
                    {
                        using (StreamReader srDecrypt = new StreamReader(cryptoStream))
                        {
                            // Read the decrypted bytes from the decrypting stream
                            // and place them in a string.
                            var plainText = srDecrypt.ReadToEnd();

                            //var plainTextBytes = new byte[cipherTextBytes.Length];
                            //int plainTextByteActualSize = cryptoStream.Read(plainTextBytes, 0, plainTextBytes.Length);
                            //var plainText = Base58Encoding.Encode(plainTextBytes);
                            return(plainText);
                        }
                    }
                }
            }
        }
コード例 #3
0
            public SignatureHolder(string signature)
            {
                var buff = Base58Encoding.Decode(signature);
                var b1   = new byte[buff[0]];
                var b2   = new byte[buff[1]];

                Buffer.BlockCopy(buff, 2, b1, 0, b1.Length);
                Buffer.BlockCopy(buff, 2 + b1.Length, b2, 0, b2.Length);

                R = new BigInteger(b1);
                S = new BigInteger(b2);
            }
コード例 #4
0
        private static bool VerifySignature(string message, string AccountId, string signature)
        {
            try
            {
                var signatureBytes = Base58Encoding.Decode(signature);
                var publicKeyBytes = Base58Encoding.DecodeAccountId(AccountId);

                var result = Neo.Cryptography.Crypto.Default.VerifySignature(Encoding.UTF8.GetBytes(message), signatureBytes, publicKeyBytes);

                return(result);
            }
            catch
            {
                //_log?.LogError("VerifySignature failed: " + ex.Message);
                return(false);
            }
        }