精华内容
下载资源
问答
  • 文件加密解密
    2021-03-10 10:57:20

    文章目录

    1. 保护隐私数据不被未授权访问;
      什么是加密
    2. 保护隐私数据不被未授权访问;
    3. 用于隐藏真实数据,进行安全的数据传递;
    4. 避免数据被第三方截获;
    5. 用于隐藏真实数据,进行安全的数据传递;
    6. 避免数据被第三方截获;
      古代加密方式:置换(反序,替换)
      加密算法的历史
      古代加密方式:置换(反序,替换)
      现代加密算法:带密码的加密、两套密码的加密、动态密码加密。
      现代加密:对称加密、非对称加密
      现代加密算法:带密码的加密、两套密码的加密、动态密码加密。
      现代加密:对称加密、非对称加密
    7. 能否通过一个密码进行加密和解密的操作,如果能就是对称加密。
      对称加密
    8. 能否通过一个密码进行加密和解密的操作,如果能就是对称加密。
    9. 对称加密都有密码。
    10. 常用的加密方式DES, AES
    11. 对称加密都有密码。
    12. 常用的加密方式DES, AES
      DES 加密算法
      说明
      DES 通过密码,对数据进行大量循环方式的异或
      操作,从而生成加密后的数据。
      DES对数据依次进行加密,一次加密是8个字节一起
      因此,DES密码,必须是64bit,也就是8个字节
      DES加密实现
    13. DES加密之后的数据,不能够直接生成字符串的;
    14. 加密: M 明文, K 12345678, D 加密后数据
      D = DES(M, K) 用K密码对M进行加密生成D
    15. 解密:M = DES(D, K)
    16. 这种可以通过相同的密码进行加密和解密的叫做对称加密。
      DES API
    17. Cipher 加密/解密引擎,用于实际的处理
    18. cipher.init(int mode, Key key) 设置加密还是解密
    19. Key 对于DES需要使用 SecretKeyFactory 进行密码创建
      创建密码对象用的是 DESKeySpec
    20. Cipher update(byte[]) 每次调用都会返回一部分处理的数据,DES API doFinal 就只能返回最后一次的数据,不是完整的,
    21. DES 加密推荐使用 doFinal 来完成。
      DESede 加密方式
      对于DES 或者 DESede 而言,如果实现DESede的话,那么:Cipher 算法调整为 DESede,SecretKeyFactory制定的算法,同样调整为 DESede, 其中需要使用 DESedeKeySpec 生成密码,而且密码的长度 24个字节。
      AES 加密算法
      特点
    22. 速度快
    23. 强度高
    24. Java中默认支持 AES 128bit 加密
      AES 256bit 美国军方的标准;
      AES 256bit 需要美国出口许可证才可以用。
      DES, AES 特性 - 分块加密
      Padding: 加密的时候,分块是数据按照固定长度一块一块处理,可以通过 Cipher 参数进行分块的控制
      NoPadding:如果数据不是块长度的倍数,那么不会填充
      一般情况下,填充会自动向数据后面添加 字节0 补齐
      AES 常用的Cipher算法
    25. AES 默认可以使用,有时也会出现BadPaddingException,不建议使用
    26. AES/ECB/PKCS5Padding 另外一种AES 加密形式,建议使用
    27. AES/CBC/PKCS5Padding 内部的算法模式不同。
      4.算法及密码长度限制
      算法/模式/填充 16字节加密后数据长度 不满16字节加密后长度
      AES/CBC/NoPadding 16 不支持
      AES/CBC/PKCS5Padding 32 16
      AES/CBC/ISO10126Padding 32 16
      AES/CFB/NoPadding 16 原始数据长度
      AES/CFB/PKCS5Padding 32 16
      AES/CFB/ISO10126Padding 32 16
      AES/ECB/NoPadding 16 不支持
      AES/ECB/PKCS5Padding 32 16
      AES/ECB/ISO10126Padding 32 16
      AES/OFB/NoPadding 16 原始数据长度
      AES/OFB/PKCS5Padding 32 16
      AES/OFB/ISO10126Padding 32 16
      AES/PCBC/NoPadding 16 不支持
      AES/PCBC/PKCS5Padding 32 16
      AES/PCBC/ISO10126Padding 32 16
      AES API
    28. Cipher 加密/解密引擎
    29. 创建密码生成器 KeyGenerator,设置密码生成的密码长度 128 bit和设备安全随机数 ,
      如keyGenerator.init(128, new SecureRandom(password.getBytes()));
      3.生成 SecretKey keyGenerator.generateKey()
    30. 初始化 引擎 cipher.init(Cipher.ENCRYPT_MODE, secretKey)
    31. 加密处理 cipher.doFinal(byte[] origData)
      非对称加密算法
      加密实现
    32. M 明文 D 公钥 E 密钥 C 密文 n 公共模数 0x10001
    33. C = M ^ E mod n
    34. M = C ^ D mod n
    35. 通常 E + n 作为 私钥隐秘保存
    36. 通常 D + n 作为公钥,可以给任何人。
    37. 通过 C ^ D mon => M
    38. E 通过计算两个 1024bit 以上的整数(并且是素数),
      公钥 D = (素数1 - 1) * (素数2 - 1) E 包含两个素数
      D 安全性足够高
      非对称加密的API
    39. Cipher 可以进行加密,用的是 “RSA”, “DSA”
    40. KeyPairGenerator 生成 公钥和私钥
    41. cipher init 加密用 私钥, init 解密 用的是公钥初始化。
      加密实现
    42. M 明文 D 公钥 E 密钥 C 密文 n 公共模数 0x10001
    43. C = M ^ E mod n
    44. M = C ^ D mod n
    45. 通常 E + n 作为 私钥隐秘保存
    46. 通常 D + n 作为公钥,可以给任何人。
    47. 通过 C ^ D mon => M
    48. E 通过计算两个 1024bit 以上的整数(并且是素数),
      公钥 D = (素数1 - 1) * (素数2 - 1) E 包含两个素数
      D 安全性足够高
      非对称加密的API
    49. Cipher 可以进行加密,用的是 “RSA”, “DSA”
    50. KeyPairGenerator 生成 公钥和私钥
    51. cipher init 加密用 私钥, init 解密 用的是公钥初始化。
      Base64、MD5编码
       android.util.Base64类
        encode(byte[],flag)
        encodeToString(byte[],flag) 编码并转换成字符串
        decode(byte[],flag) 解码
        flags标识
         Base64.DEFAULT 默认,如果字符串过长(超过76)时自动在中间加一个换行符,字符串最后也会加一个换行符。可能会导致和其他模块对接时结果不一致,建议使用Base64.NO_WRAP
         Base64.NO_WRAP 不换行处理
         Base64.NO_PADDING 结束位置省略“==”
       it.sauronsoftware.base64.Base64类
        第三方Base64编码、解码工具类
        Base64.decode(byte[]);
        Base64.encode(byte[])
       MD5
        java.security.MessageDigest
        MD5加密:
    更多相关内容
  • 一、常用加密/解密算法 1.Base64  严格来说Base64并不是一种加密/解密算法,而是一种编码方式。Base64不生成密钥,通过Base64编码后的密文就可以直接“翻译”为明文,但是可以通过向明文中添加混淆字符来达到...
  • 常见的加密方式分为可逆不可逆两种方式  可逆:RSA,AES,DES等  不可逆:常见的MD5,SHAD等 一、MD5消息摘要算法 我想这是大家都常听过的算法,可能也用的比较多。那么什么是MD5算法呢?MD5全称是message-digest ...
  • 解密方法封装: public class Encrypt { /// <summary> /// md5加密后返回密文 /// </summary> /// <param name="source">要加密的明文</param> /// <returns></...

    MD5加密:(不可逆加密)

    加解方法封装: 

     public class Encrypt
        {
            /// <summary>
            /// md5加密后返回密文
            /// </summary>
            /// <param name="source">要加密的明文</param>
            /// <returns></returns>
            public static string MD5Encrypt(string source)
            {
                try
                {
                    MD5 md5 = MD5.Create();
                    byte[] data = md5.ComputeHash(Encoding.Default.GetBytes(source));
                    StringBuilder sBuilder = new StringBuilder();
                    for (int i = 0; i < data.Length; i++)
                    {
                        sBuilder.Append(data[i].ToString("x2"));
                    }
                    return sBuilder.ToString();
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
    
            /// <summary>
            /// 获取文件的md5摘要
            /// </summary>
            /// <param name="fileName">文件名称</param>
            /// <returns>文件摘要</returns>
            public static string AbstractFile(string fileName)
            {
                using (FileStream stream = new FileStream(fileName, FileMode.Open))
                {
                    MD5 md5 = new MD5CryptoServiceProvider();
                    byte[] retVal = md5.ComputeHash(stream);
    
                    StringBuilder sb = new StringBuilder();
                    for (int i = 0; i < retVal.Length; i++)
                    {
                        sb.Append(retVal[i].ToString("x2"));
                    }
    
                    return sb.ToString();
                }
            }
    
        }

    实例:

    Console.WriteLine(Encrypt.MD5Encrypt("123456"));     
    Console.WriteLine(Encrypt.AbstractFile(@"C:\Users\Administrator\Desktop\test\jquery.js"));

    结果:

     

    md5加密特点:

    1.相同原文加密后的结果是一样的

    2.不同长度的内容加密后长度是一样的

    3.加密不可逆,不能通过密文解密出原文

    4.原文差别很小,但加密后的结果差别很大

    5.文件也可以经过加密产生摘要

     

    md5加密应用:

    1.系统登录的密码,经md5加密后将密文存在数据库中,用户登录时对用户输入的密码用md5加密后和数据库比较。(密码保存,防止看到明文)

    2.源代码管理器,比如svn,文件有改动时,文件就会出现被改动的标记。(防篡改)

    3.极速秒传,扫描文件的md5,跟已有的文件md5比对,吻合表示文件已存在则不再上传。

    4.数字签名,把一些内容摘要一下,由权威的第三方去保障,将来这个文件就是由你做的,不能抵赖。

     

     

     

    DES加密:(对称可逆加密)

    app.config添加一个配置型,用于存储加密的key

     <appSettings>
        <add key="DesKey" value="hello666"/>
     </appSettings>

    加解密方法封装:  

    public class Encrypt
        {
            public static string DesKey = ConfigurationManager.AppSettings["DesKey"];
            private static byte[] _rgbKey = ASCIIEncoding.ASCII.GetBytes(DesKey.Substring(0, 8));
            private static byte[] _rgbIV = ASCIIEncoding.ASCII.GetBytes(DesKey.Insert(0, "w").Substring(0, 8));
    
            /// <summary>
            /// DES加密
            /// </summary>
            /// <param name="text">需要加密的值</param>
            /// <returns>加密后的结果</returns>
            public static string DesEncrypt(string text)
            {
                DESCryptoServiceProvider dsp = new DESCryptoServiceProvider();
                using (MemoryStream memStream = new MemoryStream())
                {
                    CryptoStream crypStream = new CryptoStream(memStream, dsp.CreateEncryptor(_rgbKey, _rgbIV), CryptoStreamMode.Write);
                    StreamWriter sWriter = new StreamWriter(crypStream);
                    sWriter.Write(text);
                    sWriter.Flush();
                    crypStream.FlushFinalBlock();
                    memStream.Flush();
                    return Convert.ToBase64String(memStream.GetBuffer(), 0, (int)memStream.Length);
                }
            }
    
    
            /// <summary>
            /// DES解密
            /// </summary>
            /// <param name="encryptText">需要解密的值</param>
            /// <returns>解密后的结果</returns>
            public static string DesDecrypt(string encryptText)
            {
                DESCryptoServiceProvider dsp = new DESCryptoServiceProvider();
                byte[] buffer = Convert.FromBase64String(encryptText);
    
                using (MemoryStream memStream = new MemoryStream())
                {
                    CryptoStream crypStream = new CryptoStream(memStream, dsp.CreateDecryptor(_rgbKey, _rgbIV), CryptoStreamMode.Write);
                    crypStream.Write(buffer, 0, buffer.Length);
                    crypStream.FlushFinalBlock();
                    memStream.Flush();
                    return ASCIIEncoding.UTF8.GetString(memStream.ToArray());
                }
            }
        }

    实例:

    string strDes = Encrypt.DesEncrypt("张三");
    Console.WriteLine(strDes);
    Console.WriteLine(Encrypt.DesDecrypt(strDes));

    结果:

     

    DES加密特点:

    1.加密后能解密回原文,加密key和解密key是同一个。

    2.加密解密的速度快,问题是密钥的安全性。

     

     

    RSA加密:(不对称可逆加密)

    加解密方法封装:  

     public class Encrypt
        {
            /// <summary>
            /// RSA随机生成一对密钥
            /// </summary>
            /// <returns>一对密钥值</returns>
            public static KeyValuePair<string, string> GetKeyPair()
            {
                RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();
                string publicKey = RSA.ToXmlString(false);
                string privateKey = RSA.ToXmlString(true);
                return new KeyValuePair<string, string>(publicKey, privateKey);
            }
    
    
            /// <summary>
            /// RSA加密(内容+加密key)
            /// </summary>
            /// <param name="content">内容</param>
            /// <param name="encryptKey">加密key</param>
            /// <returns>加密后的信息</returns>
            public static string RSAEncrypt(string content, string encryptKey)
            {
                RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
                rsa.FromXmlString(encryptKey);
                UnicodeEncoding ByteConverter = new UnicodeEncoding();
                byte[] DataToEncrypt = ByteConverter.GetBytes(content);
                byte[] resultBytes = rsa.Encrypt(DataToEncrypt, false);
                return Convert.ToBase64String(resultBytes);
            }
    
    
            /// <summary>
            /// RSA解密(内容+解密key)
            /// </summary>
            /// <param name="content">内容</param>
            /// <param name="descryptKey">解密key</param>
            /// <returns></returns>
            public static string RSADecrypt(string content, string descryptKey)
            {
                byte[] dataToDecrypt = Convert.FromBase64String(content);
                RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();
                RSA.FromXmlString(descryptKey);
                byte[] resultBytes = RSA.Decrypt(dataToDecrypt, false);
                UnicodeEncoding ByteConverter = new UnicodeEncoding();
                return ByteConverter.GetString(resultBytes);
            }
    
        }

    实例:

    KeyValuePair<string, string> encryptDescypt = Encrypt.GetKeyPair();
    string rsaEn = Encrypt.RSAEncrypt("123456",encryptDescypt.Key);
    string rsaDe = Encrypt.RSADecrypt(rsaEn, encryptDescypt.Value);
    Console.WriteLine(rsaEn);
    Console.WriteLine(rsaDe);

    结果:

     

    RSA加密特点:

    1.加密后能解密回原文,加密key和解密key不是同一个。

    2.加密解密速度不快,但安全性好。

    3.公开加密key,保证数据的安全传递。

    4.公开解密key,保证数据的不可抵赖。

    展开全文
  • 加密解密,前端加密,后端解密,CryptoJS,AESEncryptUtil.java DESEncryptUtil.java Base64EncodeUtil.java MD5Util.java
  • Java中常用加密解密

    千次阅读 2021-12-23 10:28:36
    一、对称加密与非对称加密 1、对称加密 2、非对称加密 3、对称加密与非对称加密的区别

    一、对称加密与非对称加密

    在这里插入图片描述

    1、对称加密

    对称加密采用了对称密码编码技术,它的特点是文件加密和解密使用相同的密钥加密,这种方法在密码学中叫做对称加密算法,对称加密算法使用起来简单快捷,密钥较短,且破译困难,除了数据加密标准(DES),另一个对称密钥加密系统是国际数据加密算法(IDEA),它比DES的加密性好,而且对计算机功能要求也没有那么高。

    常见的对称加密算法有DES、3DES、Blowfish、IDEA、RC4、RC5、RC6和AES

    2、非对称加密

    非对称加密算法需要两个密钥:公开密钥(publickey)和私有密钥(privatekey)。
    公开密钥与私有密钥是一对,如果用公开密钥对数据进行加密,只有用对应的私有密钥才能解密;如果用私有密钥对数据进行加密,那么只有用对应的公开密钥才能解密。因为加密和解密使用的是两个不同的密钥,所以这种算法叫作非对称加密算法。

    3、对称加密与非对称加密的区别

    • 1、加密和解密过程不同
      对称加密的加密过程和解密过程使用的同一个密钥,加密过程相当于用原文+密钥可以传输出密文,同时解密过程用密文-密钥可以推导出原文。
      但非对称加密采用了两个密钥,一般使用公钥进行加密,使用私钥进行解密。

    • 2、加密解密速度不同
      对称加密解密的速度比较快,适合数据比较长时的使用。
      非对称加密和解密花费的时间长、速度相对较慢,只适合对少量数据的使用。

    • 3、传输的安全性不同
      对称加密的过程中无法确保密钥被安全传递,密文在传输过程中是可能被第三方截获的,如果密码本也被第三方截获,则传输的密码信息将被第三方破获,安全性相对较低。
      非对称加密算法中私钥是基于不同的算法生成不同的随机数,私钥通过一定的加密算法推导出公钥,但私钥到公钥的推导过程是单向的,也就是说公钥无法反推导出私钥。所以安全性较高。

    二、加密算法实例

    1、MD5加密单向加密

    • MD5是一种单向加密算法,只能加密不能解密
    • MD5 主要用做数据一致性验证、数字签名和安全访问认证,而不是用作加密。
    package com.example.demo.password;
    
    import org.springframework.util.DigestUtils;
    
    import java.math.BigInteger;
    import java.security.MessageDigest;
    import java.security.NoSuchAlgorithmException;
    
    public class MD5Util {
        /**
         * java自带jar工具 java.security.MessageDigest 实现
         *
         * @param text  要加密的字符串
         * @param rad   进制:比如 16、32
         * @param isUpp 是否转换为大写
         * @return
         */
        public static String strToMD5(String text, int rad, boolean isUpp) {
            MessageDigest messageDigest = null;
            try {
                //通过MessageDigest类来的静态方法getInstance获取MessageDigest对象
                messageDigest = MessageDigest.getInstance("MD5");
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            }
            // 4、获取明文字符串对应的字节数组
            byte[] input = text.getBytes();
            // 5、执行加密
            messageDigest.update(input);
            //这里也可以直接使用byte[] output = messageDigest.digest(input)方法来进行加密,就省略了上面的update方法了
            byte[] output = messageDigest.digest();
            // 6、创建BigInteger对象
            // signum为1表示正数、-1表示负数、0表示0。不写默认表示正数
            int signum = 1;
            BigInteger bigInteger = new BigInteger(signum, output);
            // 7、按照16进制(或32进制)将bigInteger转为字符串
            return isUpp ? bigInteger.toString(rad).toUpperCase() : bigInteger.toString(rad);
        }
    
        /**
         * spring自带的工具 org.springframework.util.DigestUtils 实现
         *
         * @param text
         * @return 16进制
         */
        public static String _strToMD5(String text) {
            return DigestUtils.md5DigestAsHex(text.getBytes());
        }
    
        public static void main(String[] args) {
            String str = "hello";
            System.out.println(strToMD5(str, 16, true));
            System.out.println(_strToMD5(str));
            System.out.println(strToMD5(str, 16, false).equals(_strToMD5(str)));
        }
    }
    

    2、Base64加密解密

    Java 8 内置了 Base64 编码的编码器和解码器。
    Base64工具类提供了一套静态方法获取下面三种BASE64编解码器:

    • 基本:输出被映射到一组字符A-Za-z0-9+/,编码不添加任何行标,输出的解码仅支持A-Za-z0-9+/。
    • URL:输出映射到一组字符A-Za-z0-9+_,输出是URL和文件。
    • MIME:输出隐射到MIME友好格式。输出每行不超过76字符,并且使用’\r’并跟随’\n’作为分割。编码输出最后没有行分割。

    static class Base64.Decoder:该类实现一个解码器用于,使用 Base64 编码来解码字节数据。
    static class Base64.Encoder:该类实现一个编码器,使用 Base64 编码来编码字节数据。

    package com.example.demo.password;
    
    import java.io.UnsupportedEncodingException;
    import java.util.Base64;
    import java.util.UUID;
    
    public class Base64Util {
        public static void main(String[] args) throws Exception {
            String text = "hello";
            try {
                /**
                 * static Base64.Encoder getEncoder()
                 * 返回一个 Base64.Encoder ,编码使用基本型 base64 编码方案。
                 */
                String base64encodedString = Base64.getEncoder().encodeToString(text.getBytes("utf-8"));
                System.out.println("Base64 编码字符串 (基本) :" + base64encodedString);
    
                /**
                 * static Base64.Decoder getDecoder()
                 * 返回一个 Base64.Decoder ,解码使用基本型 base64 编码方案。
                 */
                byte[] base64decodedBytes = Base64.getDecoder().decode(base64encodedString);
                System.out.println("原始字符串: " + new String(base64decodedBytes, "utf-8"));
    
                /**
                 * static Base64.Encoder getUrlEncoder()
                 * 返回一个 Base64.Encoder ,编码使用 URL 和文件名安全型 base64 编码方案。
                 */
                base64encodedString = Base64.getUrlEncoder().encodeToString(text.getBytes("utf-8"));
                System.out.println("Base64 编码字符串 (URL) :" + base64encodedString);
    
                /**
                 * static Base64.Decoder getUrlDecoder()
                 * 返回一个 Base64.Decoder ,解码使用 URL 和文件名安全型 base64 编码方案。
                 */
                byte[] base64decodedBytes2 = Base64.getUrlDecoder().decode(base64encodedString);
                System.out.println("原始字符串: " + new String(base64decodedBytes2, "utf-8"));
    
                StringBuilder stringBuilder = new StringBuilder();
    
                for (int i = 0; i < 10; ++i) {
                    stringBuilder.append(UUID.randomUUID().toString());
                }
    
                byte[] mimeBytes = stringBuilder.toString().getBytes("utf-8");
                String mimeEncodedString = Base64.getMimeEncoder().encodeToString(mimeBytes);
                System.out.println("Base64 编码字符串 (MIME) :" + mimeEncodedString);
    
            }catch(UnsupportedEncodingException e){
                System.out.println("Error :" + e.getMessage());
            }
        }
    }
    

    Base 64主要用途不是加密,而是把一些二进制数转成普通字符,方便在网络上传输。 由于一些二进制字符在传输协议中属于控制字符,不能直接传送,所以需要转换一下才可以。由于某些系统中只能使用ASCII字符,Base64就是用来将非ASCII字符的数据转换成ASCII字符的一种方法,Base64特别适合在http,mime协议下快速传输数据。比如网络中图片的传输。

    package com.example.demo.password;
    
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.util.Base64;
    
    public class ImgToBase64String {
        /**
         * 图片转base64
         * @param filePath 图片文件路径
         * @return
         */
        public static String toBase64String(String filePath){
            if (null == filePath || 0 == filePath.length()){
                throw new RuntimeException("图片路径不能为空!!");
            }
            InputStream in = null;
            byte[] data = null;
            try {
                //读取图片字节数组
                in = new FileInputStream(filePath);
                data = new byte[in.available()];
                in.read(data);
                in.close();
            }catch (IOException e){
                e.printStackTrace();
            }
            StringBuilder sb = new StringBuilder();
            sb.append("data:image/jpg;base64,");
            sb.append(Base64.getEncoder().encodeToString(data));
            
            //对字节数组Base64编码,返回Base64编码过的字节数组字符串
            return sb.toString();
        }
    
        public static void main(String[] args) {
            System.out.println(toBase64String("D:\\下载\\desktop.png"));
        }
    }
    

    3、DES对称加密解密

    因jdk1.8自带的base64有所不同,使用jdk其他版本是可适当自行修改。

    package com.example.demo.password;
    
    import java.security.Key;
    import java.security.SecureRandom;
    import java.util.Base64;
    import javax.crypto.Cipher;
    import javax.crypto.KeyGenerator;
    
    public class DESUtil {
        public static Key setKey(String strKey) {
            Key key = null;
            try {
                KeyGenerator generator = KeyGenerator.getInstance("DES");
                generator.init(new SecureRandom(strKey.getBytes())); // 根据参数生成key
                key = generator.generateKey();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return key;
        }
    
        /**
         * @param source 编码内容
         * @param key 密钥
         * @param charSet 编码格式
         * @return
         */
        public static String encrypt(String source, String key, String charSet) {
            String encrypt = null;
            try {
                byte[] ret = encrypt(source.getBytes(charSet), key);
                encrypt = new String(Base64.getEncoder().encode(ret));
            } catch (Exception e) {
                e.printStackTrace();
                encrypt = null;
            }
            return encrypt;
        }
    
        /**
         * @param encryptedData 解码内容
         * @param key 密钥
         * @param charSet 编码格式
         * @return
         */
        public static String decrypt(String encryptedData, String key, String charSet) {
            String descryptedData = null;
            try {
                byte[] ret = descrypt(Base64.getDecoder().decode(encryptedData.getBytes()), key);
                descryptedData = new String(ret, charSet);
            } catch (Exception e) {
                e.printStackTrace();
                descryptedData = null;
            }
            return descryptedData;
        }
    
        private static byte[] encrypt(byte[] primaryData, String key) {
            Key desKey = setKey(key);
            try {
                Cipher cipher = Cipher.getInstance("DES"); // Cipher对象实际完成加密操作
                cipher.init(Cipher.ENCRYPT_MODE, desKey); // 用密钥初始化Cipher对象(加密)
                return cipher.doFinal(primaryData);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
    
        private static byte[] descrypt(byte[] encryptedData, String key) {
            Key desKey = setKey(key);
            try {
                Cipher cipher = Cipher.getInstance("DES"); // Cipher对象实际完成解密操作
                cipher.init(Cipher.DECRYPT_MODE, desKey); // 用密钥初始化Cipher对象(解密)
                return cipher.doFinal(encryptedData);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
    
        public static void main(String[] args) {
            String code = "hello world";
            String key = "thisisakey";
            String unicode = "utf-8";
            String encrypt = encrypt(code, key, unicode);
            String decrypt = decrypt(encrypt, key, unicode);
            System.out.println("原内容:" + code);
            System.out.println("加密:" + encrypt);
            System.out.println("解密:" + decrypt);
        }
    }
    

    4、AES对称加密解密

    AES 与 DES 一样,一共有四种加密模式:电子密码本模式(ECB)、加密分组链接模式(CBC)、加密反馈模式(CFB)和输出反馈模式(OFB)。

    package com.example.demo.password;
    
    import java.io.IOException;
    import java.io.UnsupportedEncodingException;
    import java.security.InvalidKeyException;
    import java.security.NoSuchAlgorithmException;
    import java.security.SecureRandom;
    import java.util.Base64;
    
    import javax.crypto.BadPaddingException;
    import javax.crypto.Cipher;
    import javax.crypto.IllegalBlockSizeException;
    import javax.crypto.KeyGenerator;
    import javax.crypto.NoSuchPaddingException;
    import javax.crypto.SecretKey;
    import javax.crypto.spec.SecretKeySpec;
    
    public class AESUtil {
        //指定为AES算法,不区分大小写
        private static final String KEY_ALGORITHM = "AES";
        private static final String CHARSET_NAME = "utf-8";
    
        /*
         * 加密 1.构造密钥生成器 2.根据ecnodeRules规则初始化密钥生成器 3.产生密钥 4.创建和初始化密码器 5.内容加密 6.返回字符串
         */
        public static String AESEncode(String encodeRules, String content) {
            try {
                // 1.构造密钥生成器,指定为AES算法,不区分大小写
                KeyGenerator keygen = KeyGenerator.getInstance(KEY_ALGORITHM);
                // 2.根据ecnodeRules规则初始化密钥生成器
                // 生成一个128位的随机源,根据传入的字节数组
                //keygen.init(128, new SecureRandom(encodeRules.getBytes()));
                SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
                secureRandom.setSeed(encodeRules.getBytes());
                keygen.init(128, secureRandom);
                // 3.产生原始对称密钥
                SecretKey original_key = keygen.generateKey();
                // 4.获得原始对称密钥的字节数组
                byte[] raw = original_key.getEncoded();
                // 5.根据字节数组生成AES密钥
                SecretKey key = new SecretKeySpec(raw, KEY_ALGORITHM);
                // 6.根据指定算法AES自成密码器
                Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
                // 7.初始化密码器,第一个参数为加密(Encrypt_mode)或者解密解密(Decrypt_mode)操作,第二个参数为使用的KEY
                cipher.init(Cipher.ENCRYPT_MODE, key);
                // 8.获取加密内容的字节数组(这里要设置为utf-8)不然内容中如果有中文和英文混合中文就会解密为乱码
                byte[] byte_encode = content.getBytes(CHARSET_NAME);
                // 9.根据密码器的初始化方式--加密:将数据加密
                byte[] byte_AES = cipher.doFinal(byte_encode);
                // 10.将加密后的数据转换为字符串
                // 这里用Base64Encoder中会找不到包
                // 解决办法:
                // 在项目的Build path中先移除JRE System Library,再添加库JRE System Library,重新编译后就一切正常了。
                String AES_encode = new String(Base64.getEncoder().encodeToString(byte_AES));
                // 11.将字符串返回
                return AES_encode;
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            } catch (NoSuchPaddingException e) {
                e.printStackTrace();
            } catch (InvalidKeyException e) {
                e.printStackTrace();
            } catch (IllegalBlockSizeException e) {
                e.printStackTrace();
            } catch (BadPaddingException e) {
                e.printStackTrace();
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
    
            // 如果有错就返加nulll
            return null;
        }
    
        /*
         * 解密 解密过程: 1.同加密1-4步 2.将加密后的字符串反纺成byte[]数组 3.将加密内容解密
         */
        public static String AESDncode(String encodeRules, String content) {
            try {
                // 1.构造密钥生成器,指定为AES算法,不区分大小写
                KeyGenerator keygen = KeyGenerator.getInstance(KEY_ALGORITHM);
                // 2.根据ecnodeRules规则初始化密钥生成器
                // 生成一个128位的随机源,根据传入的字节数组
                //keygen.init(128, new SecureRandom(encodeRules.getBytes()));
                SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
                secureRandom.setSeed(encodeRules.getBytes());
                keygen.init(128, secureRandom);
                // 3.产生原始对称密钥
                SecretKey original_key = keygen.generateKey();
                // 4.获得原始对称密钥的字节数组
                byte[] raw = original_key.getEncoded();
                // 5.根据字节数组生成AES密钥
                SecretKey key = new SecretKeySpec(raw, KEY_ALGORITHM);
                // 6.根据指定算法AES自成密码器
                Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
                // 7.初始化密码器,第一个参数为加密(Encrypt_mode)或者解密(Decrypt_mode)操作,第二个参数为使用的KEY
                cipher.init(Cipher.DECRYPT_MODE, key);
                // 8.将加密并编码后的内容解码成字节数组
                byte[] byte_content = Base64.getDecoder().decode(content);
                /*
                 * 解密
                 */
                byte[] byte_decode = cipher.doFinal(byte_content);
                String AES_decode = new String(byte_decode, CHARSET_NAME);
                return AES_decode;
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            } catch (NoSuchPaddingException e) {
                e.printStackTrace();
            } catch (InvalidKeyException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (IllegalBlockSizeException e) {
                e.printStackTrace();
            } catch (BadPaddingException e) {
                e.printStackTrace();
            }
    
            // 如果有错就返加nulll
            return null;
        }
    
        public static void main(String[] args) {
            String encodeRules = "thisisrule";
            String text = "hello word";
            String encodeText = AESEncode(encodeRules, text);
            System.out.println("加密后的密文是:" + encodeText);
            System.out.println("解密后的内容是:" + AESDncode(encodeRules, encodeText));
        }
    }
    

    5、非对称加密——RSA

    RSA密钥对生成:http://web.chacuo.net/netrsakeypair
    在线加密解密:http://encode.chahuo.com/
    RSA算法是一种非对称加密算法,RSA 加密主要有这么几步:生成密钥对、公开公钥、公钥加密私钥解密、私钥加密公钥解密。

    package com.example.demo.password;
    
    import org.apache.commons.codec.binary.Base64;
    
    import javax.crypto.Cipher;
    import java.security.KeyFactory;
    import java.security.interfaces.RSAPrivateKey;
    import java.security.interfaces.RSAPublicKey;
    import java.security.spec.PKCS8EncodedKeySpec;
    import java.security.spec.X509EncodedKeySpec;
    
    public class RSAUtil {
        private static final String CHARSET_NAME = "utf-8";
        private static final String TYPE = "RSA";
    
        /**
         * RSA公钥加密
         *
         * @param str       加密字符串
         * @param publicKey 公钥
         * @return 密文
         * @throws Exception 加密过程中的异常信息
         */
        public static String encrypt(String str, String publicKey) throws Exception {
            //base64编码的公钥
            byte[] decoded = Base64.decodeBase64(publicKey);
            RSAPublicKey pubKey = (RSAPublicKey) KeyFactory.getInstance(TYPE).generatePublic(new X509EncodedKeySpec(decoded));
            //RSA加密
            Cipher cipher = Cipher.getInstance(TYPE);
            cipher.init(Cipher.ENCRYPT_MODE, pubKey);
            String outStr = Base64.encodeBase64String(cipher.doFinal(str.getBytes(CHARSET_NAME)));
            return outStr;
        }
    
        /**
         * RSA私钥解密
         *
         * @param str        加密字符串
         * @param privateKey 私钥
         * @return 铭文
         * @throws Exception 解密过程中的异常信息
         */
        public static String decrypt(String str, String privateKey) throws Exception {
            //64位解码加密后的字符串
            byte[] inputByte = Base64.decodeBase64(str.getBytes(CHARSET_NAME));
            //base64编码的私钥
            byte[] decoded = Base64.decodeBase64(privateKey);
            RSAPrivateKey priKey = (RSAPrivateKey) KeyFactory.getInstance(TYPE).generatePrivate(new PKCS8EncodedKeySpec(decoded));
            //RSA解密
            Cipher cipher = Cipher.getInstance(TYPE);
            cipher.init(Cipher.DECRYPT_MODE, priKey);
            String outStr = new String(cipher.doFinal(inputByte));
            return outStr;
        }
    
        public static void main(String[] args) throws Exception {
            String publicKey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDKalqxfHXrZ0JZdLd2+BLhNS6bZxVyCOXvzFd0xCyX4oX/IbglKp9BGxQYaNl7stlHkQmMYBTAkIj0mAQzOVkqisYDevxKA5Yeitnim8R+N+a1SYaoQCfHLbCmMg4ZP0xaC30rA3DSMbEWQTD7p/g6v3sZevQUDVUcge9oaif9AQIDAQAB";
            String privateKey = "MIICeAIBADANBgkqhkiG9w0BAQEFAASCAmIwggJeAgEAAoGBAMpqWrF8detnQll0t3b4EuE1LptnFXII5e/MV3TELJfihf8huCUqn0EbFBho2Xuy2UeRCYxgFMCQiPSYBDM5WSqKxgN6/EoDlh6K2eKbxH435rVJhqhAJ8ctsKYyDhk/TFoLfSsDcNIxsRZBMPun+Dq/exl69BQNVRyB72hqJ/0BAgMBAAECgYEAwOZKOArcddKaMJZCoWYY1/bOy9qZXWuNddHPJsAtnzGJcXK5AvJzgqBDrl99o5z15HYcG2MVY85aNn8IwahNh8CpFF8At7O2hVz1sTER2MPeiV5324BGOCPUkT4lY2iT2Dq6hXraZDI9sovit4FnfFlWH9nMOV5ckBvm5ypcCoECQQD/YLgSqXEERuu5qjU+PBCBKqbtOq5+EBNwLb9isxTPjRPoQ98sEzWsbyeLrc73Cjql5vU1io9rsG3IiYdEvFn9AkEAyuiaK95pbILOqK096d3Gt9oz0fqc5K4c9V44anaFzkEOysZlO3o1iZxqjfHdBlJiE4j0fq52+s+L9riqFbNMVQJATL3V0tXUPoLJZ3u8kD0ggJA+pV9S/FL8ZGN69b/26v/sEYoD0IzdPjoQ2iqa3SXXxe8HlNVUj/nuo6qgWYl4SQJBAJsXsYfoh7JeRXHegV15m8O5sDRGl5efkhjmfL67e0kMpy7M+GG+5p8ZhMScYzHK1JZT73XJCr5o13Ws7qyJkMUCQQD2EaVPOG+5M0VbzGGG820NRk9omSwO3GdSf4HZ6JWmeGk0FJN4NfAHnD8nA5L/HP+muqCdYQtYD068oZrNSabP";
            String text = "hello world";
            String encodeText = encrypt(text, publicKey);
            System.out.println("加密后:" + encodeText);
            System.out.println("解密后:" + decrypt(encodeText, privateKey));
        }
    }
    
    展开全文
  • Linux rhmask命令用于对文件进行加密和解密操作。执行rhmask指令可制作加密过的文件,方便用户在公开的网络上传输该文件,而不至于被任意盗用。 语法格式:rhmask [参数] [加密文件] [输出文件] 常用参数: -d ...
  • .NET(C#)常用数据加密和解密方法汇总

    千次阅读 2020-01-13 14:17:21
    欢迎加入Unity业内qq交流群:956187480 qq扫描二维码加群 ...2、 文件加密:文本加密、pdf、word 3、 数据加密:ASP.NET(C#)中的数据加密 4、 硬件加密:加密狗 三、 数据加密的发展趋势 四、 网络...

    欢迎加入Unity业内qq交流群:956187480

    qq扫描二维码加群


    一、数据加密的概念

    1、  基本概念

    2、  基本功能

    3、  加密形式 

    二、 数据加密的项目应用和学习

    1、  媒体加密:DRM

    2、  文件加密:文本加密、pdf、word

    3、  数据加密:ASP.NET(C#)中的数据加密

    4、  硬件加密:加密狗

    三、 数据加密的发展趋势 

    四、 网络数据加密算法分类

    1、  根本不考虑解密问题:MD5、

    2、  私用密钥加密:DES、AES

    3、  公用密钥加密:RSA

    4、  数字证书: 

    五、对称加密之DES加密和解密的讲解 

    六、 非对称加密之RSA加密和解密的讲解 

    七、 ASP.NET(C#) 常用加密类实例调用讲解

    ASP.NET(C#)常用数据加密和解密方法汇总 

      

    数据加密技术是网络中最基本的安全技术,主要是通过对网络中传输的信息进行数据加密来保障其安全性,这是一种主动安全防御策略,用很小的代价即可为信息提供相当大的安全保护。

    一、加密的基本概念 

    "加密",是一种限制对网络上传输数据的访问权的技术。原始数据(也称为明文,plaintext)被加密设备(硬件或软件)和密钥加密而产生的经过编码的数据称为密文(ciphertext)。将密文还原为原始明文的过程称为解密,它是加密的反向处理,但解密者必须利用相同类型的加密设备和密钥对密文进行解密。

    加密的基本功能包括:

    1. 防止不速之客查看机密的数据文件;

    2. 防止机密数据被泄露或篡改;

    3. 防止特权用户(如系统管理员)查看私人数据文件;

    4. 使入侵者不能轻易地查找一个系统的文件。

    数据加密是确保计算机网络安全的一种重要机制,虽然由于成本、技术和管理上的复杂性等原因,目前尚未在网络中普及,但数据加密的确是实现分布式系统和网络环境下数据安全的重要手段之一。

    数据加密可在网络OSI七层协议(OSIOpen System Interconnect的缩写,意为开放式系统互联。国际标准组织(国际标准化组织)制定了OSI模型。这个模型把网络通信的工作分为7层,分别是物理层、数据链路层、网络层、传输层、会话层、表示层和应用层。)的多层上实现、所以从加密技术应用的逻辑位置看,有三种方式:

    链路加密:通常把网络层以下的加密叫链路加密,主要用于保护通信节点间传输的数据,加解密由置于线路上的密码设备实现。根据传递的数据的同步方式又可分为同步通信加密和异步通信加密两种,同步通信加密又包含字节同步通信加密和位同步通信加密。

    节点加密:是对链路加密的改进。在协议传输层上进行加密,主要是对源节点和目标节点之间传输数据进行加密保护,与链路加密类似.只是加密算法要结合在依附于节点的加密模件中,克服了链路加密在节点处易遭非法存取的缺点。

    端对端加密:网络层以上的加密称为端对端加密。是面向网络层主体。对应用层的数据信息进行加密,易于用软件实现,且成本低,但密钥管理问题困难,主要适合大型网络系统中信息在多个发方和收方之间传输的情况。

    二、数据加密的应用 

    1、  媒体加密:DRM

    2、  文件加密:文本加密、pdf、word

    3、  数据加密:ASP.NET(C#)中的数据加密

    4、  硬件加密:加密狗

     

    三.加密技术发展趋势 

    私用密钥加密技术与公开密钥加密技术相结合:鉴于两种密码体制加密的特点,在实际应用中可以采用折衷方案,即结合使用DES/IDEA和RSA,以DES为"内核",RSA为"外壳",对于网络中传输的数据可用DES或IDEA加密,而加密用的密钥则用RSA加密传送,此种方法既保证了数据安全又提高了加密和解密的速度,这也是目前加密技术发展的新方向之一。

    寻求新算法:跳出以常见的迭代为基础的构造思路,脱离基于某些数学问题复杂性的构造方法。如刘尊全先生提出的刘氏算法,是一种基于密钥的公开密钥体制,它采用了随机性原理构造加解密变换,并将其全部运算控制隐匿于密钥中,密钥长度可变。它是采用选取一定长度的分割来构造大的搜索空间,从而实现一次非线性变换。此种加密算法加密强度高、速度快、计算开销低。

    加密最终将被集成到系统和网络中,例如IPV6协议就已有了内置加密的支持,在硬件方面,Intel公司正研制一种加密协处理器。它可以集成到微机的主极上。

    四、加密技术的分类 

    加密类型可以简单地分为四种:

    1. 根本不考虑解密问题; 

    2. 私用密钥加密技术:对称式加密(Symmetric Key Encryption):对称式加密方式对加密和解密使用相同的密钥。通常,这种加密方式在应用中难以实施,因为用同一种安全方式共享密钥很难。如:RC4、RC2、DES 和 AES 系列加密算法。

    3. 公开密钥加密技术:非对称密钥加密(Asymmetric Key Encryption):非对称密钥加密使用一组公共/私人密钥系统,加密时使用一种密钥,解密时使用另一种密钥。公共密钥可以广泛的共享和透露。当需要用加密方式向服务器外部传送数据时,这种加密方式更方便。如: RSA

    4. 数字证书。(Certificate):数字证书是一种非对称密钥加密,但是,一个组织可以使用证书并通过数字签名将一组公钥和私钥与其拥有者相关联。 

    五、对称加密之DES加密与解密 

    一、  对称加密 

    对称加密,是一种比较传统的加密方式,其加密运算、解密运算使用的是同样的密钥,信息的发送者和信息的接收者在进行信息的传输与处理时,必须共同持有该密码(称为对称密码)。因此,通信双方都必须获得这把钥匙,并保持钥匙的秘密。

    单钥密码系统的安全性依赖于以下两个因素:

    第一、加密算法必须是足够强的,仅仅基于密文本身去解密信息在实践上是不可能的。

    第二、加密方法的安全性依赖于密钥的秘密性,而不是算法的秘密性,因此,我们没有必要确保算法的秘密性(事实上,现实中使用的很多单钥密码系统的算法都是公开的),但是我们一定要保证密钥的秘密性。

    DES(Data Encryption Standard)和TripleDES是对称加密的两种实现。

    DES和TripleDES基本算法一致,只是TripleDES算法提供的key位数更多,加密可靠性更高。

    DES使用的密钥key为8字节,初始向量IV也是8字节。

    TripleDES使用24字节的key,初始向量IV也是8字节。

    两种算法都是以8字节为一个块进行加密,一个数据块一个数据块的加密,一个8字节的明文加密后的密文也是8字节。如果明文长度不为8字节的整数倍,添加值为0的字节凑满8字节整数倍。所以加密后的密文长度一定为8字节的整数倍。

    二、  加密解密过程 

     

    Figure 1. DES加密解密过程

    上图是整个DES和TripleDES算法的加密解密过程,下面以TripleDES为例,结合dotnet分析加密解密的各个步骤,并给出相关实现代码。

    1 生成keyIV

    System.Security.Cryptography. TripleDESCryptoServiceProvider类是dotnet中实现TripleDES算法的主要的类。

    TripleDESCryptoServiceProvider类只有一个构造方法TripleDESCryptoServiceProvider(),这个方法把一些属性初始化:

    KeySize(加密密钥长度,以位为单位)= 192(24字节)

    BlockSize(加密处理的数据块大小,以位为单位)= 64(8字节)

    FeedbackSize(加密数据块后返回的数据大小,以位为单位)= 64(8字节)

    TripleDESCryptoServiceProvider构造方法同时会初始化一组随机的key和IV。

    默认的TripleDESCryptoServiceProvider的key为24字节,IV为8字节,加密数据块为8字节。

    生成key和IV的代码很简单:

    TripleDESCryptoServiceProvider tDESalg = new TripleDESCryptoServiceProvider();
    byte[] keyArray = tDESalg.Key;
    byte[] IVArray = tDESalg.IV;

    生成的key和IV在加密过程和解密过程都要使用。

    2 字符串明文转成某一代码页对应的编码字节流 

    待加密的数据可能有两种形式,一种是二进制的数据,本身就是一组字节流,这样的数据可以跳过这一步,直接进入加密步骤。还有一种情况是字符串数据,字符串中同样的字符使用不同的代码页会生成不同的字节码,所以从字符串到字节流的转换是需要指定使用何种编码的。在解密之后,要从字节流转换到字符串就要使用相同的代码页解码,否则就会出现乱码。

    // 待加密的字符串

    string plainTextString = "Here is some data to encrypt. 这里是一些要加密的数据。";

    // 使用utf-8编码(也可以使用其它的编码)

    Encoding sEncoding = Encoding.GetEncoding("utf-8");

    // 把字符串明文转换成utf-8编码的字节流

    byte[] plainTextArray = sEncoding.GetBytes(plainTextString);

    3 加密操作 

    加密的原料是明文字节流,TripleDES算法对字节流进行加密,返回的是加密后的字节流。同时要给定加密使用的key和IV。

    // 把字符串明文转换成utf-8编码的字节流

    byte[] plainTextArray = sEncoding.GetBytes(plainTextString);
    public static byte[] EncryptString(byte[] plainTextArray, byte[] Key, byte[] IV)
    {
        // 建立一个MemoryStream,这里面存放加密后的数据流
        MemoryStream mStream = new MemoryStream();
        // 使用MemoryStream 和key、IV新建一个CryptoStream 对象
        CryptoStream cStream = new CryptoStream(mStream,
            new TripleDESCryptoServiceProvider().CreateEncryptor(Key, IV),
            CryptoStreamMode.Write);
        // 将加密后的字节流写入到MemoryStream
        cStream.Write(plainTextArray, 0, plainTextArray.Length);
        //把缓冲区中的最后状态更新到MemoryStream,并清除cStream的缓存区
        cStream.FlushFinalBlock();
        // 把解密后的数据流转成字节流
        byte[] ret = mStream.ToArray();
        // 关闭两个streams.
        cStream.Close();
        mStream.Close();
        return ret;
    }

    4 解密操作 

    解密操作解密上面步骤生成的密文byte[],需要使用到加密步骤使用的同一组Key和IV。

    // 调用解密方法,返回已解密数据的byte[]

    byte[] finalPlainTextArray = DecryptTextFromMemory(Data, keyArray, IVArray);
    public static byte[] DecryptTextFromMemory(byte[] EncryptedDataArray, byte[] Key, byte[] IV)
    {
        // 建立一个MemoryStream,这里面存放加密后的数据流
        MemoryStream msDecrypt = new MemoryStream(EncryptedDataArray);
        // 使用MemoryStream 和key、IV新建一个CryptoStream 对象
        CryptoStream csDecrypt = new CryptoStream(msDecrypt,
            new TripleDESCryptoServiceProvider().CreateDecryptor(Key, IV),
            CryptoStreamMode.Read);
        // 根据密文byte[]的长度(可能比加密前的明文长),新建一个存放解密后明文的byte[]
        byte[] DecryptDataArray = new byte[EncryptedDataArray.Length];
        // 把解密后的数据读入到DecryptDataArray
        csDecrypt.Read(DecryptDataArray, 0, DecryptDataArray.Length);
        msDecrypt.Close();
        csDecrypt.Close();
        return DecryptDataArray;
    }

    有一点需要注意,DES加密是以数据块为单位加密的,8个字节一个数据块,如果待加密明byte[]的长度不是8字节的整数倍,算法先用值为“0”的byte补足8个字节,然后进行加密。所以加密后的密文长度一定是8的整数倍。这样的密文解密后如果补了0值的byte,则解密后这些0值的byte依然存在。比如上例中要加密的明文是:

    “Here is some data to encrypt. 这里是一些要加密的数据。”

    转成明文byte[]后是66个字节,DES算法就会补上6个0值的byte,补到72个字节。这样加密后再解密回来的密文byte[]解码后的字符串就是这样的:

    "Here is some data to encrypt. 这里是一些要加密的数据。\0\0\0\0\0\0"

    5 从编码字节流转成字符串明文 

    // 使用前面定义的Encoding,utf-8的编码把byte[]转成字符串

    plainTextString = sEncoding.GetString(finalPlainTextArray);

    六、非对称加密之RSA加密和解密的讲解 

          RSA公钥加密算法是1977年由Ron Rivest、Adi Shamirh和LenAdleman在(美国麻省理工学院)开发的。RSA取名来自开发他们三者的名字。RSA是目前最有影响力的公钥加密算法,它能够抵抗到目前为止已知的所有密码攻击,已被ISO推荐为公钥数据加密标准。RSA算法基于一个十分简单的数论事实:将两个大素数相乘十分容易,但那时想要对其乘积进行因式分解却极其困难,因此可以将乘积公开作为加密密钥。RSA算法是第一个能同时用于加密和数字签名的算法,也易于理解和操作。

      RSA是被研究得最广泛的公钥算法,从提出到现在已近二十年,经历了各种攻击的考验,逐渐为人们接受,普遍认为是目前最优秀的公钥方案之一。RSA的安全性依赖于大数的因子分解,但并没有从理论上证明破译RSA的难度与大数分解难度等价。即RSA的重大缺陷是无法从理论上把握它的保密性能如何,而且密码学界多数人士倾向于因子分解不是NPC问题。

      RSA的缺点主要有:

    A)产生密钥很麻烦,受到素数产生技术的限制,因而难以做到一次一密。

    B)分组长度太大,为保证安全性,n 至少也要 600bits以上,使运算代价很高,尤其是速度较慢,较对称密码算法慢几个数量级;且随着大数分解技术的发展,这个

    长度还在增加,不利于数据格式的标准化。目前,SET(Secure Electronic Transaction)协议中要求CA采用2048bits长的密钥,其他实体使用1024比特的密钥。C)RSA密钥长度随着保密级别提高,增加很快。下表列出了对同一安全级别所对应的密钥长度。

    保密级别

    对称密钥长度(bit)

    RSA密钥长度(bit)

    ECC密钥长度(bit)

    保密年限

    80

    80

    1024

    160

    2010

    112

    112

    2048

    224

    2030

    128

    128

    3072

    256

    2040

    192

    192

    7680

    384

    2080

    256

    256

    15360

    512

    2120

     这种算法1978年就出现了,它是第一个既能用于数据加密也能用于数字签名的算法。它易于理解和操作,也很流行。算法的名字以发明者的名字命名:Ron Rivest, AdiShamir 和Leonard Adleman。早在1973年,英国国家通信总局的数学家Clifford Cocks就发现了类似的算法。但是他的发现被列为绝密,直到1998年才公诸于世。

      RSA算法是一种非对称密码算法,所谓非对称,就是指该算法需要一对密钥,使用其中一个加密,则需要用另一个才能解密。

      RSA的算法涉及三个参数,n、e1、e2。

      其中,n是两个大质数p、q的积,n的二进制表示时所占用的位数,就是所谓的密钥长度。

      e1和e2是一对相关的值,e1可以任意取,但要求e1与(p-1)*(q-1)互质;再选择e2,要求(e2*e1)mod((p-1)*(q-1))=1。

      (n及e1),(n及e2)就是密钥对。

      RSA加解密的算法完全相同,设A为明文,B为密文,则:A=B^e1 mod n;B=A^e2 mod n;

      e1和e2可以互换使用,即:

      A=B^e2 mod n;B=A^e1 mod n;

     

    C#代码实现

    需引用using System.Security.Cryptography;

    /// <summary>
            /// RSA加密
            /// </summary>
            /// <param name="publickey"></param>
            /// <param name="content"></param>
            /// <returns></returns>
            public static string RSAEncrypt(string publickey, string content)
            {
                publickey = @"<RSAKeyValue><Modulus>5m9m14XH3oqLJ8bNGw9e4rGpXpcktv9MSkHSVFVMjHbfv+SJ5v0ubqQxa5YjLN4vc49z7SVju8s0X4gZ6AzZTn06jzWOgyPRV54Q4I0DCYadWW4Ze3e+BOtwgVU1Og3qHKn8vygoj40J6U85Z/PTJu3hN1m75Zr195ju7g9v4Hk=</Modulus><Exponent>AQAB</Exponent></RSAKeyValue>";
                RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
                byte[] cipherbytes;
                rsa.FromXmlString(publickey);
                cipherbytes = rsa.Encrypt(Encoding.UTF8.GetBytes(content), false);
    
                return Convert.ToBase64String(cipherbytes);
            }
    
            /// <summary>
            /// RSA解密
            /// </summary>
            /// <param name="privatekey"></param>
            /// <param name="content"></param>
            /// <returns></returns>
            public static string RSADecrypt(string privatekey, string content)
            {
                privatekey = @"<RSAKeyValue><Modulus>5m9m14XH3oqLJ8bNGw9e4rGpXpcktv9MSkHSVFVMjHbfv+SJ5v0ubqQxa5YjLN4vc49z7SVju8s0X4gZ6AzZTn06jzWOgyPRV54Q4I0DCYadWW4Ze3e+BOtwgVU1Og3qHKn8vygoj40J6U85Z/PTJu3hN1m75Zr195ju7g9v4Hk=</Modulus><Exponent>AQAB</Exponent><P>/hf2dnK7rNfl3lbqghWcpFdu778hUpIEBixCDL5WiBtpkZdpSw90aERmHJYaW2RGvGRi6zSftLh00KHsPcNUMw==</P><Q>6Cn/jOLrPapDTEp1Fkq+uz++1Do0eeX7HYqi9rY29CqShzCeI7LEYOoSwYuAJ3xA/DuCdQENPSoJ9KFbO4Wsow==</Q><DP>ga1rHIJro8e/yhxjrKYo/nqc5ICQGhrpMNlPkD9n3CjZVPOISkWF7FzUHEzDANeJfkZhcZa21z24aG3rKo5Qnw==</DP><DQ>MNGsCB8rYlMsRZ2ek2pyQwO7h/sZT8y5ilO9wu08Dwnot/7UMiOEQfDWstY3w5XQQHnvC9WFyCfP4h4QBissyw==</DQ><InverseQ>EG02S7SADhH1EVT9DD0Z62Y0uY7gIYvxX/uq+IzKSCwB8M2G7Qv9xgZQaQlLpCaeKbux3Y59hHM+KpamGL19Kg==</InverseQ><D>vmaYHEbPAgOJvaEXQl+t8DQKFT1fudEysTy31LTyXjGu6XiltXXHUuZaa2IPyHgBz0Nd7znwsW/S44iql0Fen1kzKioEL3svANui63O3o5xdDeExVM6zOf1wUUh/oldovPweChyoAdMtUzgvCbJk1sYDJf++Nr0FeNW1RB1XG30=</D></RSAKeyValue>";
                RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
                byte[] cipherbytes;
                rsa.FromXmlString(privatekey);
                cipherbytes = rsa.Decrypt(Convert.FromBase64String(content), false);
    
                return Encoding.UTF8.GetString(cipherbytes);
            }

    七、ASP.NET(C#)常用加密类调用的讲解

    1C#常用加密解密类库代码如下: 

    /// <summary>
          /// MD5 加密静态方法
          /// </summary>
          /// <param name="EncryptString">待加密的密文</param>
          /// <returns>returns</returns>
          public static string MD5Encrypt(string EncryptString)
          {
              if (string.IsNullOrEmpty(EncryptString)) { throw (new Exception("密文不得为空")); }
              MD5 m_ClassMD5 = new MD5CryptoServiceProvider();
              string m_strEncrypt = "";
              try
              {
                  m_strEncrypt = BitConverter.ToString(m_ClassMD5.ComputeHash(Encoding.Default.GetBytes(EncryptString))).Replace("-", "");
              }
             catch (ArgumentException ex) { throw ex; }
             catch (CryptographicException ex) { throw ex; }
             catch (Exception ex) { throw ex; }
              finally { m_ClassMD5.Clear(); }
              return m_strEncrypt;
          }
    
          /// <summary>
          /// DES 加密(数据加密标准,速度较快,适用于加密大量数据的场合)
          /// </summary>
          /// <param name="EncryptString">待加密的密文</param>
          /// <param name="EncryptKey">加密的密钥</param>
          /// <returns>returns</returns>
          public static string DESEncrypt(string EncryptString, string EncryptKey)
          {
              if (string.IsNullOrEmpty(EncryptString)) { throw (new Exception("密文不得为空")); }
              if (string.IsNullOrEmpty(EncryptKey)) { throw (new Exception("密钥不得为空")); }
              if (EncryptKey.Length != 8) { throw (new Exception("密钥必须为8位")); }
              byte[] m_btIV = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF };
              string m_strEncrypt = "";
             DESCryptoServiceProvider m_DESProvider = new DESCryptoServiceProvider();
              try
              {
                  byte[] m_btEncryptString = Encoding.Default.GetBytes(EncryptString);
                  MemoryStream m_stream = new MemoryStream();
                  CryptoStream m_cstream = new CryptoStream(m_stream, m_DESProvider.CreateEncryptor(Encoding.Default.GetBytes(EncryptKey), m_btIV), CryptoStreamMode.Write);
                  m_cstream.Write(m_btEncryptString, 0, m_btEncryptString.Length);
                  m_cstream.FlushFinalBlock();
                  m_strEncrypt = Convert.ToBase64String(m_stream.ToArray());
                  m_stream.Close(); m_stream.Dispose();
                  m_cstream.Close(); m_cstream.Dispose();
              }
              catch (IOException ex) { throw ex; }
              catch (CryptographicException ex) { throw ex; }
              catch (ArgumentException ex) { throw ex; }
              catch (Exception ex) { throw ex; }
              finally { m_DESProvider.Clear(); }
              return m_strEncrypt;
          }
    
          /// <summary>
          /// DES 解密(数据加密标准,速度较快,适用于加密大量数据的场合)
          /// </summary>
          /// <param name="DecryptString">待解密的密文</param>
          /// <param name="DecryptKey">解密的密钥</param>
          /// <returns>returns</returns>
          public static string DESDecrypt(string DecryptString, string DecryptKey)
          {
             if (string.IsNullOrEmpty(DecryptString)) { throw (new Exception("密文不得为空")); }
              if (string.IsNullOrEmpty(DecryptKey)) { throw (new Exception("密钥不得为空")); }
              if (DecryptKey.Length != 8) { throw (new Exception("密钥必须为8位")); }
              byte[] m_btIV = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF };
             string m_strDecrypt = "";
             DESCryptoServiceProvider m_DESProvider = new DESCryptoServiceProvider();
             try
            {
                 byte[] m_btDecryptString = Convert.FromBase64String(DecryptString);
                 MemoryStream m_stream = new MemoryStream();
                 CryptoStream m_cstream = new CryptoStream(m_stream, m_DESProvider.CreateDecryptor(Encoding.Default.GetBytes(DecryptKey), m_btIV), CryptoStreamMode.Write);
                 m_cstream.Write(m_btDecryptString, 0, m_btDecryptString.Length);
                 m_cstream.FlushFinalBlock();
                 m_strDecrypt = Encoding.Default.GetString(m_stream.ToArray());
                 m_stream.Close(); m_stream.Dispose();
                 m_cstream.Close(); m_cstream.Dispose();
             }
             catch (IOException ex) { throw ex; }
             catch (CryptographicException ex) { throw ex; }
             catch (ArgumentException ex) { throw ex; }
             catch (Exception ex) { throw ex; }
             finally { m_DESProvider.Clear(); }
             return m_strDecrypt;
         }
         /// <summary>
         /// RC2 加密(用变长密钥对大量数据进行加密)
         /// </summary>
         /// <param name="EncryptString">待加密密文</param>
         /// <param name="EncryptKey">加密密钥</param>
         /// <returns>returns</returns>
         public static string RC2Encrypt(string EncryptString, string EncryptKey)
         {
             if (string.IsNullOrEmpty(EncryptString)) { throw (new Exception("密文不得为空")); }
             if (string.IsNullOrEmpty(EncryptKey)) { throw (new Exception("密钥不得为空")); }
             if (EncryptKey.Length < 5 || EncryptKey.Length > 16) { throw (new Exception("密钥必须为5-16位")); }
             string m_strEncrypt = "";
             byte[] m_btIV = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF };
             RC2CryptoServiceProvider m_RC2Provider = new RC2CryptoServiceProvider();
             try
            {
                 byte[] m_btEncryptString = Encoding.Default.GetBytes(EncryptString);
                 MemoryStream m_stream = new MemoryStream();
                 CryptoStream m_cstream = new CryptoStream(m_stream, m_RC2Provider.CreateEncryptor(Encoding.Default.GetBytes(EncryptKey), m_btIV), CryptoStreamMode.Write);
                 m_cstream.Write(m_btEncryptString, 0, m_btEncryptString.Length);
                 m_cstream.FlushFinalBlock();
                 m_strEncrypt = Convert.ToBase64String(m_stream.ToArray());
                 m_stream.Close(); m_stream.Dispose();
                m_cstream.Close(); m_cstream.Dispose();
             }
             catch (IOException ex) { throw ex; }
             catch (CryptographicException ex) { throw ex; }
             catch (ArgumentException ex) { throw ex; }
             catch (Exception ex) { throw ex; }
             finally { m_RC2Provider.Clear(); }
             return m_strEncrypt;
         }
    
         /// <summary>
         /// RC2 解密(用变长密钥对大量数据进行加密)
         /// </summary>
         /// <param name="DecryptString">待解密密文</param>
         /// <param name="DecryptKey">解密密钥</param>
         /// <returns>returns</returns>
         public static string RC2Decrypt(string DecryptString, string DecryptKey)
         {
             if (string.IsNullOrEmpty(DecryptString)) { throw (new Exception("密文不得为空")); }
             if (string.IsNullOrEmpty(DecryptKey)) { throw (new Exception("密钥不得为空")); }
            if (DecryptKey.Length < 5 || DecryptKey.Length > 16) { throw (new Exception("密钥必须为5-16位")); }
             byte[] m_btIV = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF };
             string m_strDecrypt = "";
             RC2CryptoServiceProvider m_RC2Provider = new RC2CryptoServiceProvider();
            try
            {
                byte[] m_btDecryptString = Convert.FromBase64String(DecryptString);
                 MemoryStream m_stream = new MemoryStream();
                 CryptoStream m_cstream = new CryptoStream(m_stream, m_RC2Provider.CreateDecryptor(Encoding.Default.GetBytes(DecryptKey), m_btIV), CryptoStreamMode.Write);
                 m_cstream.Write(m_btDecryptString, 0, m_btDecryptString.Length);
                 m_cstream.FlushFinalBlock();
                 m_strDecrypt = Encoding.Default.GetString(m_stream.ToArray());
                 m_stream.Close(); m_stream.Dispose();
                 m_cstream.Close(); m_cstream.Dispose();
             }
             catch (IOException ex) { throw ex; }
            catch (CryptographicException ex) { throw ex; }
             catch (ArgumentException ex) { throw ex; }
             catch (Exception ex) { throw ex; }
            finally { m_RC2Provider.Clear(); }
             return m_strDecrypt;
         }
    
         /// <summary>
         /// 3DES 加密(基于DES,对一块数据用三个不同的密钥进行三次加密,强度更高)
         /// </summary>
         /// <param name="EncryptString">待加密密文</param>
         /// <param name="EncryptKey1">密钥一</param>
         /// <param name="EncryptKey2">密钥二</param>
        /// <param name="EncryptKey3">密钥三</param>
         /// <returns>returns</returns>
         public static string DES3Encrypt(string EncryptString, string EncryptKey1, string EncryptKey2, string EncryptKey3)
         {
             string m_strEncrypt = "";
             try
             {
                 m_strEncrypt = DESEncrypt(EncryptString, EncryptKey3);
                 m_strEncrypt = DESEncrypt(m_strEncrypt, EncryptKey2);
                m_strEncrypt = DESEncrypt(m_strEncrypt, EncryptKey1);
             }
             catch (Exception ex) { throw ex; }
             return m_strEncrypt;
         }
    
         /// <summary>
         /// 3DES 解密(基于DES,对一块数据用三个不同的密钥进行三次加密,强度更高)
         /// </summary>
         /// <param name="DecryptString">待解密密文</param>
         /// <param name="DecryptKey1">密钥一</param>
         /// <param name="DecryptKey2">密钥二</param>
         /// <param name="DecryptKey3">密钥三</param>
         /// <returns>returns</returns>
         public static string DES3Decrypt(string DecryptString, string DecryptKey1, string DecryptKey2, string DecryptKey3)
         {
             string m_strDecrypt = "";
             try
             {
                m_strDecrypt = DESDecrypt(DecryptString, DecryptKey1);
                 m_strDecrypt = DESDecrypt(m_strDecrypt, DecryptKey2);
                 m_strDecrypt = DESDecrypt(m_strDecrypt, DecryptKey3);
             }
             catch (Exception ex) { throw ex; }
             return m_strDecrypt;
         }
    
         /// <summary>
         /// AES 加密(高级加密标准,是下一代的加密算法标准,速度快,安全级别高,目前 AES 标准的一个实现是 Rijndael 算法)
         /// </summary>
         /// <param name="EncryptString">待加密密文</param>
         /// <param name="EncryptKey">加密密钥</param>
        /// <returns></returns>
        public static string AESEncrypt(string EncryptString, string EncryptKey)
         {
            if (string.IsNullOrEmpty(EncryptString)) { throw (new Exception("密文不得为空")); }
             if (string.IsNullOrEmpty(EncryptKey)) { throw (new Exception("密钥不得为空")); }
             string m_strEncrypt = "";
             byte[] m_btIV = Convert.FromBase64String("Rkb4jvUy/ye7Cd7k89QQgQ==");
             Rijndael m_AESProvider = Rijndael.Create();
             try
             {
                 byte[] m_btEncryptString = Encoding.Default.GetBytes(EncryptString);
                 MemoryStream m_stream = new MemoryStream();
                 CryptoStream m_csstream = new CryptoStream(m_stream, m_AESProvider.CreateEncryptor(Encoding.Default.GetBytes(EncryptKey), m_btIV), CryptoStreamMode.Write);
                 m_csstream.Write(m_btEncryptString, 0, m_btEncryptString.Length); m_csstream.FlushFinalBlock();
                 m_strEncrypt = Convert.ToBase64String(m_stream.ToArray());
                 m_stream.Close(); m_stream.Dispose();
                 m_csstream.Close(); m_csstream.Dispose();
             }
             catch (IOException ex) { throw ex; }
             catch (CryptographicException ex) { throw ex; }
             catch (ArgumentException ex) { throw ex; }
             catch (Exception ex) { throw ex; }
             finally { m_AESProvider.Clear(); }
             return m_strEncrypt;
         }
    
         /// <summary>
         /// AES 解密(高级加密标准,是下一代的加密算法标准,速度快,安全级别高,目前 AES 标准的一个实现是 Rijndael 算法)
         /// </summary>
         /// <param name="DecryptString">待解密密文</param>
         /// <param name="DecryptKey">解密密钥</param>
         /// <returns></returns>
         public static string AESDecrypt(string DecryptString, string DecryptKey)
         {
             if (string.IsNullOrEmpty(DecryptString)) { throw (new Exception("密文不得为空")); }
             if (string.IsNullOrEmpty(DecryptKey)) { throw (new Exception("密钥不得为空")); }
             string m_strDecrypt = "";
             byte[] m_btIV = Convert.FromBase64String("Rkb4jvUy/ye7Cd7k89QQgQ==");
             Rijndael m_AESProvider = Rijndael.Create();
             try
             {
                 byte[] m_btDecryptString = Convert.FromBase64String(DecryptString);
                 MemoryStream m_stream = new MemoryStream();
                 CryptoStream m_csstream = new CryptoStream(m_stream, m_AESProvider.CreateDecryptor(Encoding.Default.GetBytes(DecryptKey), m_btIV), CryptoStreamMode.Write);
                 m_csstream.Write(m_btDecryptString, 0, m_btDecryptString.Length); m_csstream.FlushFinalBlock();
                 m_strDecrypt = Encoding.Default.GetString(m_stream.ToArray());
                 m_stream.Close(); m_stream.Dispose();
                 m_csstream.Close(); m_csstream.Dispose();
             }
             catch (IOException ex) { throw ex; }
             catch (CryptographicException ex) { throw ex; }
             catch (ArgumentException ex) { throw ex; }
             catch (Exception ex) { throw ex; }
             finally { m_AESProvider.Clear(); }
             return m_strDecrypt;
         }

    2、数据加密和解密简单代码调用如下: 

    Response.Write("<br>-----------MD5加密---------------<br>");        

    Response.Write(SDKSecurity.MD5Encrypt("仰天一笑"));
    Response.Write("<br>-----------DES加密---------------<br>");        

    Response.Write(SDKSecurity.DESEncrypt("仰天一笑", "anson-xu"));        

    Response.Write("<br>-----------DES解密---------------<br>");        

    Response.Write(SDKSecurity.DESDecrypt("l06JvJ45r/lb9iKzSXl47Q==", "anson-xu"));
    Response.Write("<br>-----------AES加密---------------<br>");    

    Response.Write(SDKSecurity.AESEncrypt("仰天一笑", "ansonxuyu"));        

    Response.Write("<br>-----------AES解密---------------<br>");        

    Response.Write(SDKSecurity.AESDecrypt("avwKL+MO8+zoLHvzk0+TBA==", "ansonxuyu"));

    3、数据加密和解密调用后运行效果图如下: 


    欢迎加入Unity业内qq交流群:956187480

    qq扫描二维码加群

    展开全文
  • 数据加密技术是网络中最基本的安全技术,主要是通过对网络中传输的信息进行数据加密来保障其安全性,这是一...原始数据(也称为明文,plaintext)被加密设备(硬件或软件)密钥加密而产生的经过编码的数据称为密文(...
  • 常用数据加密和解密方法

    万次阅读 2018-07-17 13:54:07
    ASP.NET(C#)常用数据加密和解密方法汇总  一、数据加密的概念 1、 基本概念 2、 基本功能 3、 加密形式  二、 数据加密的项目应用学习 1、 媒体加密:DRM 2、 文件加密:文本加密、pdf、word 3、 ...
  • 数据加密和解密总结

    2020-11-30 17:52:44
    对称加密是最快速、最简单的一种加密方式,加密(encryption与解密(decryption)用的是同样的密钥(secret key), 这种方法在密码学中叫做对称加密算法。 对称加密有很多种算法,由于它效率很高,所以被.
  • xml文件加密和解密

    千次阅读 2020-01-05 14:01:03
    XML介绍 Extensible Markup Language(XML),可扩展标记语言,是一种用于标记电子文件使其具有结构性的标记语言。 XML文件特征如下: ...b)XML必须有根元素: 一个文件只能有一个根元素, 含开始...
  • 最近在做一个项目,需要将资源文件(包括图片、动画等类型)进行简单的加密后再上传至云上的服务器,而在应用程序中对该资源使用前先将读取到的文件数据进行解密以得到真正的文件信息。此策略的原因与好处是将准备好的...
  • 加密和解密方法

    千次阅读 2021-03-01 03:36:57
    ASP.NET(C#)常用数据加密和解密方法汇总 一、数据加密的概念 1、 基本概念 2、 基本功能 3、 加密形式 二、 数据加密的项目应用学习 1、 媒体加密:DRM 2、 文件加密:文本加密、pdf、word 3、 数据加密:ASP.NET...
  • PDF常用的三种加密方式:口令加密证书加密Adobe LiveCycle Rights Management口令加密: 作为第一代PDF安全加密方式,到现在也一直广泛应用。口令加密分为:用户密码(user password)、所有者密码(owner password)。...
  • Java中常用加密解密方法

    千次阅读 2019-06-14 15:37:50
    大体上分为双向加密和单向加密,而双向加密又分为对称加密和非对称加密(有些资料将加密直接分为对称加密和非对称加密)。 双向加密大体意思就是明文加密后形成密文,可以通过算法还原成明文。而单向加密只是对信息...
  • Java 加密解密之对称加密算法DES 本文转自网络 数据加密算法Data Encryption AlgorithmDEA是一种对称加密算法很可能是使用最广泛的密钥系统特别是在保护金融数据的安全中最初开发的DEA是嵌入硬件中的通常自动取款机...
  • 加密解密

    2022-04-22 16:19:01
    DES是对称性加密里常见的一种,所谓对称性加密加密和解密秘钥相同。对称性加密一般会按照固定长度,把待加密字符串分成块。不足一整块则最后特殊填充字符 2、特点 ​ DES算法具有极高安全性,除了用穷举搜索法对...
  • 常见数据加密解密方式

    千次阅读 2019-08-18 22:13:42
    目录 一、对称加密 1、凯撒加密算法:位偏移 2、byte bit 3、常见的对称加密算法 ...9、RSA非对称加密/解密保存秘钥对 10、非对称加密RSA特点 三、消息摘要 11、消息摘要算法介绍 12、消息摘要MD5的...
  • 几种常用加密手段的加密解密

    千次阅读 2019-01-31 15:36:32
    网络中传输敏感信息的时候通常会对字符串做加密解密处理 转自: https://blog.csdn.net/qq_36571506/article/details/80933640 1.Base64位加密(可加密解密) 最简单的加密方式,没有密钥,这种方式只要让别人拿到你...
  • 如果需要运用该代码直接clone项目,然后打包到本地或者私服,在通过注解就可以实现RSAAES加密解密,无需您写任何的代码。 采用的技术springboot2.3.1 spring-boot-starter-freemarker mybatis-pl
  • 这里写自定义目录标题前端常用的几种加密与解密第一种就是base64格式的加密与解密第二种MD5加密第三种加密RSA用公钥私钥加密解密第四种加密sha1 前端常用的几种加密与解密 第一种就是base64格式的加密与解密 window....
  • 应同事所邀把ASP.NET(C#)常用数据加密和解密方法列出供大家参考,特此发布出来,希望对大家有点帮助。数据虽来源于网络,系仰天一笑悉心整理。 ASP.NET(C#)常用数据加密和解密方法汇总 一
  • java常用加密解密方法

    千次阅读 2018-12-19 23:13:20
    加密是指对原来为明文的文件或数据按某种算法进行处理,使其成为不可读的一段代码,通常称为“密文”,通过这样的途径来达到保护数据不被非法人窃取、阅读的目的。 该过程的逆过程为解密,即将该编码信息转化为其...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 53,968
精华内容 21,587
关键字:

常用文件的加密和解密