OpenSSL.Net使用随记（二）

前面已经把使用OpenSSL.Net环境准备好了，现在来调用几个常用算法的实现

• MD5，SHA1

　　在这只需要注意下OpenSSL.Crypto.MessageDiges后面签名算法会用到。

    class Program_Hash
    {
        static void Main(string[] args)
        {
            var ciphertext = MD5("Md5加密。", Encoding.UTF8);
            ciphertext = SHA1("SHA1加密。", Encoding.UTF8);
        }

        public static string MD5(string text, Encoding encoding)
        {
            return HashDigest(text, encoding, MessageDigest.MD5);
        }

        public static string SHA1(string text, Encoding encoding)
        {
            return HashDigest(text, encoding, MessageDigest.SHA1);
        }

        private static string HashDigest(string text, Encoding encoding, MessageDigest hashType)
        {
            using (MessageDigestContext hashDigest = new MessageDigestContext(hashType))
            {
                byte[] hashBytes = encoding.GetBytes(text);
                byte[] signByte = hashDigest.Digest(hashBytes);
                return BitConverter.ToString(signByte).Replace("-", "").ToLower();
            }
        }
    }

• AES

　　1、在这里SymmetricCrypt是之前项目封装的System.Security.Cryptography.RijndaelManaged

　　2、Key与IV是有其规律的因此IV是可以去掉

　　3、在string与byte[]之间转换时要注意编码，什么时候用Convert.FromBase64String，什么时候用Encoding

　　4、可以查看下Cipher封装，里面有不同的算法

    class Program_Symmetric
    {
        static void Main(string[] args)
        {
            SymmetricCrypt symmetric = new SymmetricCrypt(CryptType.Rijndael);
            string key = "PGKQBXNCiuwKmlIUThSy1h+ZHMAN+HytbZny/FepkvM=",
                iv = "aqauVvyO7qvAbaDsdOeFsA==",
                text = "AES256加解密。";

            var ctext = symmetric.Encrypt(text, key, iv);

            var ctext2 = symmetric.Decrypt(ctext, key, iv);

            var ctext3 = Encrypt(ctext2, key, iv);

            Decrypt(ctext3, key, iv);
        }

        public static string Decrypt(string text, string key, string iv)
        {
            byte[] keyBytes = Convert.FromBase64String(key);
            byte[] ivBytes = Convert.FromBase64String(iv);
            byte[] textBytes = Convert.FromBase64String(text);
            using (CipherContext cipher = new CipherContext(Cipher.AES_256_CBC))
            {
                byte[] output = cipher.Decrypt(textBytes, keyBytes, ivBytes);
                var result = Encoding.UTF8.GetString(output);
                return result;
            }
        }

        public static string Encrypt(string text, string key, string iv)
        {
            byte[] keyBytes = Convert.FromBase64String(key);
            byte[] ivBytes = Convert.FromBase64String(iv);
            byte[] textBytes = Encoding.UTF8.GetBytes(text);
            using (CipherContext cipher = new CipherContext(Cipher.AES_256_CBC))
            {
                byte[] output = cipher.Encrypt(textBytes, keyBytes, ivBytes);
                var result = Convert.ToBase64String(output);
                return result;
            }
        }
    }

• RSA

　　1、公钥与私钥可以用OpenSSL命令行随意生成

　　2、OpenSSL.Core.BIO简单理解是用于装载密钥的容器

　　3、注意OpenSSL.Crypto.RSA的静态方法

　　4、OpenSSL.Crypto.CryptoKey用于装载BIO能把密钥转换成具体的算法对象，这个类的作用很大，涉及到签名验签都会用到

class Program_RSA
    {
        static void Main(string[] args)
        {
            string privateKey = "", publicKey = "", text = "RSA-1024加解密。", ctext = "";
            int padding = 1;
            Encoding encoding = Encoding.UTF8;
            using (RSA rsa = new RSA())
            {
                rsa.GenerateKeys(1024, BigNumber.One, null, null);
                privateKey = rsa.PrivateKeyAsPEM;
                publicKey = rsa.PublicKeyAsPEM;
            }

            ctext = PrivateEncrypt(privateKey, text, encoding, padding);
            text = PublicDecrypt(publicKey, ctext, encoding, padding);

            ctext = PublicEncrypt(publicKey, text, encoding, padding);
            text = PrivateDecrypt(privateKey, ctext, encoding, padding);

            var signText = Sign(privateKey, text, encoding);
            var signTag = Verify(publicKey, text, signText, encoding);

        }

        /// <summary>
        /// 私钥解密
        /// </summary>
        public static string PrivateDecrypt(string privateKey, string text, Encoding encoding, int padding)
        {
            byte[] textBytes = Convert.FromBase64String(text);
            using (BIO bio = new BIO(privateKey))
            {
                using (RSA rsa = RSA.FromPrivateKey(bio))
                {
                    textBytes = rsa.PrivateDecrypt(textBytes, (RSA.Padding)padding);
                }
            }
            return encoding.GetString(textBytes);
        }

        /// <summary>
        /// 私钥加密
        /// </summary>
        public static string PrivateEncrypt(string privateKey, string text, Encoding encoding, int padding)
        {
            byte[] textBytes = encoding.GetBytes(text);
            using (BIO bio = new BIO(privateKey))
            {
                using (RSA rsa = RSA.FromPrivateKey(bio))
                {
                    textBytes = rsa.PrivateEncrypt(textBytes, (RSA.Padding)padding);
                }
            }
            return Convert.ToBase64String(textBytes);
        }

        /// <summary>
        /// 公钥解密
        /// </summary>
        public static string PublicDecrypt(string publicKey, string text, Encoding encoding, int padding)
        {
            byte[] textBytes = Convert.FromBase64String(text);
            using (BIO bio = new BIO(publicKey))
            {
                using (RSA rsa = RSA.FromPublicKey(bio))
                {
                    textBytes = rsa.PublicDecrypt(textBytes, (RSA.Padding)padding);
                }
            }
            return encoding.GetString(textBytes);
        }

        /// <summary>
        /// 公钥加密
        /// </summary>
        public static string PublicEncrypt(string publicKey, string text, Encoding encoding, int padding)
        {
            byte[] textBytes = encoding.GetBytes(text);
            using (BIO bio = new BIO(publicKey))
            {
                using (RSA rsa = RSA.FromPublicKey(bio))
                {
                    textBytes = rsa.PublicEncrypt(textBytes, (RSA.Padding)padding);
                    rsa.Dispose();
                }
                bio.Dispose();
            }
            return Convert.ToBase64String(textBytes);
        }

        /// <summary>
        /// 私钥签名
        /// </summary>
        public static string Sign(string privateKey, string text, Encoding encoding)
        {
            using (BIO bio = new BIO(privateKey))
            {
                using (CryptoKey cryptoKey = CryptoKey.FromPrivateKey(bio, null))
                {
                    using (MessageDigestContext sha256 = new MessageDigestContext(MessageDigest.SHA256))
                    {
                        byte[] msgByte = encoding.GetBytes(text);
                        byte[] signByte = sha256.Sign(msgByte, cryptoKey);
                        return Convert.ToBase64String(signByte);
                    }
                }
            }
        }

        /// <summary>
        /// 公钥验签
        /// </summary>
        public static bool Verify(string publicKey, string text, string sign, Encoding encoding)
        {
            using (BIO bio = new BIO(publicKey))
            {
                using (CryptoKey cryptoKey = CryptoKey.FromPublicKey(bio, null))
                {
                    using (MessageDigestContext sha256 = new MessageDigestContext(MessageDigest.SHA256))
                    {
                        byte[] msgByte = encoding.GetBytes(text);
                        byte[] signByte = Convert.FromBase64String(sign);
                        return sha256.Verify(msgByte, signByte, cryptoKey);
                    }
                }
            }
        }
    }