浅谈数据加密策略

最新推荐文章于 2023-05-17 18:49:15 发布
最新推荐文章于 2023-05-17 18:49:15 发布
阅读量863 收藏 1
点赞数
分类专栏： 随记 文章标签： 加密解密 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45860998/article/details/114071798
版权

目录


浅谈之前，我们不妨先了解几个知识点：加密技术、哈希摘要。

加密技术 分为 对称加密 与 非对称加密 两类。
对称加密即加密密钥与解密密钥相同，形象的描述为，你有你家房门的钥匙，你既可以用它锁住房门，也可以用它打开房门。常见的算法有DES、AES。
而非对称加密则采用两把钥匙，公钥和私钥。使用公钥加密的信息只能通过私钥解密，反之，使用私钥加密的信息也只能通过公钥解密。这分别对应两个过程：数据加密传输与数字签名。本文仅谈论数据的加密传输。常见的算法有RSA。

哈希摘要 即指通过散列函数为一段数据生成固定长度的摘要，而不论数据的大小。生成的摘要一般难以推导出原数据。常见的散列函数有MD5、SHA-1、SHA-2、SHA-3(Keccak)。

一、数据加密传输策略的设计

从加密技术中，我们可以得到两种简单的加密传输的方式：使用对称加密或使用非对称加密。其各有优劣。

对称加密非对称加密
加密效率计算量小，加密效率高计算复杂，加密效率低
密钥传输不宜明文传输，以免泄漏密钥造成数据泄漏可传输公钥，使用私钥解密以获得数据

因此，结合使用对称加密与非对称加密，接收方先用发送方的非对称加密的公钥加密自己的对称加密的密钥，发送方再用其私钥解密出对称加密的密钥，双方通过对称加密的密钥传输数据，才是更好的选择。这里我们以客户端（数据接收方）和服务端（数据发送方）为例：

  1. 服务端使用非对称加密生成公钥(publicKey)和私钥(privateKey)，客户端使用对称加密生成密钥(key)
  2. 客户端获取publicKey，使用其加密key，得到key的密文(keyCiphertext)
  3. 服务端使用privateKey解密keyCiphertext得到key
  4. 服务端使用key加密数据(data)得到数据的密文(dataCiphertext)
  5. 客户端获取dataCiphertext，使用key解密得到data

至此，就完成了数据发送方（服务端）向数据接收方（客户端）的加密数据传输

二、密码的加密存储策略

不论是应用程序亦或是网页，都可能涉及到用户的登录，其背后也必然牵扯到数据库对用户密码的存储与验证。直接存储密码确实简单易行，但若发生数据泄漏则将可能产生严重后果，因此用户密码的存储也应当加密。
结合哈希摘要，我们不难想到一种方法：

  1. 将用户密码通过哈希函数加密生成摘要，并存储
  2. 用户登录时，对输入的密码使用相同的哈希函数加密生成摘要
  3. 对比两次摘要，即可验证密码

但实际上，若用户密码设计的简单（如个人生日等），很容易通过反查询（即先对多个数据一 一对应的生成摘要，再依次对比摘要以确定原数据）的方式破解用户密码。因此，加盐值（salt值）的概念应运而生。所谓加盐值，指的是一串随机生成的数据，将其以任意方式添加到原来的数据中，以提升数据复杂度的一种方法，就像是往一杯干净的水加粗盐而变得浑浊一样。因此，新的密码加密存储方式我们可以这样设计：

  1. 随机生成一串字符串（即盐值），将其以任意方式添加到用户密码中，生成摘要，同时存储摘要和盐值
  2. 用户登录时，取出盐值，将其以相同的方式添加到输入的密码中，生成摘要
  3. 对比两次摘要，即可验证密码

三、示例代码

代码中所采用的对称加密算法为AES，采用的非对称加密算法为RSA。数据的发送方为服务器端Java程序，数据的接收方为Android应用，所采用的字节数据编码方式为Base64。

数据发送方

    //-----------------AES------------------
    private byte[] aesKeyBytes = null;// AES密钥字节数组形式
    private Key aesKey = null;// AES密钥

    /**
     * 获得使用Base64编码的未加密AES密钥字符串.
     *
     * @return AES密钥字符串形式
     */
    public String getAESKeyNoEncrypt() {
        return new String(Base64.getEncoder().encode(aesKeyBytes), StandardCharsets.UTF_8);
    }

    /**
     * 使用AES密钥加密数据.
     *
     * @param data 待加密的数据
     * @return 加密后的密文，使用Base64编码
     */
    public String aesEncryptData(String data) {
        try {
            if (aesKey == null) {
                throw new NullPointerException("AES密钥为空");
            }
            if (data == null) {
                throw new NullPointerException("待加密数据为空");
            }
            Cipher cipher = Cipher.getInstance("AES");
            cipher.init(Cipher.ENCRYPT_MODE, aesKey);
            return new String(Base64.getEncoder().encode(cipher.doFinal(data.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8);
        } catch (Exception e) {
            myLog.e("AES加密数据失败", e);
            return null;
        }
    }

    /**
     * 使用AES密钥解密数据.
     *
     * @param ciphertext 待解密的使用Base64编码的密文
     * @return 解密后的数据
     */
    public String aesDecryptData(String ciphertext) {
        try {
            if (aesKey == null) {
                throw new NullPointerException("AES密钥为空");
            }
            if (ciphertext == null) {
                throw new NullPointerException("待解密密文为空");
            }
            byte[] decodeCiphertextBytes = Base64.getDecoder().decode(ciphertext.getBytes(StandardCharsets.UTF_8));
            Cipher cipher = Cipher.getInstance("AES");
            cipher.init(Cipher.DECRYPT_MODE, aesKey);
            return new String(cipher.doFinal(decodeCiphertextBytes), StandardCharsets.UTF_8);
        } catch (Exception e) {
            myLog.e("AES解密数据失败", e);
            return null;
        }
    }

    //-----------------RSA------------------
    // RSA允许你选择公钥的大小。512位的密钥被视为不安全的；768位的密钥
    // 不用担心受到除了国家安全管理（NSA）外的其他事物的危害；1024位的
    // 密钥几乎是安全的。
    //                                 ————来源于百度百科（RSA算法）
    private static final int rsaKeySize = 1024;// RSA密钥长度
    private static PrivateKey privateKey = null;// RSA私钥
    private static String publicKeyStr = null;// RSA公钥字符串形式

    /**
     * 生成RSA密钥对.
     */
    public static void generateRSAKeyPair() {
        try {
            KeyPairGenerator rsa = KeyPairGenerator.getInstance("RSA");
            rsa.initialize(rsaKeySize);
            KeyPair keyPair = rsa.generateKeyPair();
            privateKey = keyPair.getPrivate();
            byte[] publicKeyBytes = keyPair.getPublic().getEncoded();
            publicKeyStr = new String(Base64.getEncoder().encode(publicKeyBytes), StandardCharsets.UTF_8);
        } catch (Exception e) {
            myLog.e("生成RSA密钥对失败", e);
        }
    }

    /**
     * 获得RSA公钥的字符串形式，使用Base64编码.
     *
     * @return RSA公钥字符串
     */
    public static String getRSAPublicKeyStr() {
        return publicKeyStr;
    }

    /**
     * RSA私钥解密含密钥字符串以构造AES密钥.
     *
     * @param aesKeyStr 以Base64编码的RSA公钥加密后的AES密钥字符串
     */
    private void decryptAESKey(String aesKeyStr) {
        try {
            byte[] decodeAESKeyBytes = Base64.getDecoder().decode(aesKeyStr);
            int maxLength = rsaKeySize / 8;
            int mod = decodeAESKeyBytes.length % maxLength;
            int groupNum = decodeAESKeyBytes.length / maxLength;
            if (mod != 0) {
                groupNum++;
            }
            byte[][] dataSrc = new byte[groupNum][0];
            for (int i = 0, start = 0; i < groupNum; i++, start += maxLength) {
                if (i != groupNum - 1 || mod == 0) {
                    dataSrc[i] = Arrays.copyOfRange(decodeAESKeyBytes, start, start + maxLength);
                } else {
                    dataSrc[i] = Arrays.copyOfRange(decodeAESKeyBytes, start, start + mod);
                }
            }
            Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            byte[][] cache = new byte[dataSrc.length][0];
            aesKeyBytes = new byte[0];
            for (int i = 0, start = 0; i < dataSrc.length; i++) {
                cache[i] = cipher.doFinal(dataSrc[i]);
                aesKeyBytes = Arrays.copyOf(aesKeyBytes, aesKeyBytes.length + cache[i].length);
                System.arraycopy(cache[i], 0, aesKeyBytes, start, cache[i].length);
                start = cache[i].length;
            }
            aesKey = new SecretKeySpec(aesKeyBytes, "AES");
        } catch (Exception e) {
            myLog.e("解密数据获取AES密钥失败", e);
        }
    }

数据接收方

    //******************加密传输*******************
    private static String encryptAESKey = null;// 使用服务器端RSA公钥加密的AES密钥
    //====================AES=====================
    private static Key aesKey = null;// AES密钥
    private static byte[] aesKeyBytes = null;// AES密钥字节数组

    /**
     * 生成AES密钥.
     */
    public static void generateAESKey() {
        try {
            KeyGenerator aes = KeyGenerator.getInstance("AES");
            aes.init(256);
            aesKeyBytes = aes.generateKey().getEncoded();
            aesKey = new SecretKeySpec(aesKeyBytes, "AES");
        } catch (Exception e) {
            myLog.e("生成AES密钥失败", e);
        }
    }

    /**
     * 使用AES密钥加密数据.
     *
     * @param data 待加密的数据
     * @return 加密后的密文，使用Base64编码
     */
    @SuppressLint("GetInstance")
    private static String aesEncryptData(String data) {
        try {
            if (aesKey == null) {
                throw new NullPointerException("AES密钥为空");
            }
            Cipher cipher = Cipher.getInstance("AES");
            cipher.init(Cipher.ENCRYPT_MODE, aesKey);
            return new String(Base64.encode(cipher.doFinal(data.getBytes(StandardCharsets.UTF_8)), Base64.NO_WRAP), StandardCharsets.UTF_8);
        } catch (Exception e) {
            myLog.e( "AES加密数据失败", e);
            return null;
        }
    }

    /**
     * 使用AES密钥解密数据.
     *
     * @param ciphertext 待解密的使用Base64编码的密文
     * @return 解密后的数据
     */
    @SuppressLint("GetInstance")
    public static String aesDecryptData(String ciphertext) {
        try {
            if (aesKey == null) {
                throw new NullPointerException("AES密钥为空");
            }
            if (ciphertext == null) {
                throw new NullPointerException("密文为空");
            }
            byte[] decodeCiphertextBytes = Base64.decode(ciphertext.getBytes(StandardCharsets.UTF_8), Base64.NO_WRAP);
            Cipher cipher = Cipher.getInstance("AES");
            cipher.init(Cipher.DECRYPT_MODE, aesKey);
            return new String(cipher.doFinal(decodeCiphertextBytes), StandardCharsets.UTF_8);
        } catch (Exception e) {
            myLog.e("AES解密数据失败", e);
            return null;
        }
    }

    //====================RSA=====================
    private static PublicKey publicKey = null;// RSA公钥

    /**
     * 解码RSA公钥字符串以构造RSA公钥.
     */
    private static void revertRSAPublicKey(String rsaPublicKeyStr) {
        try {
            byte[] rsaPublicKeyBytes = Base64.decode(rsaPublicKeyStr.getBytes(StandardCharsets.UTF_8), Base64.NO_WRAP);
            publicKey = KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(rsaPublicKeyBytes));
            encryptAESKey = getEncryptAESKey();
        } catch (Exception e) {
            myLog.e("还原RSA公钥失败", e);
        }
    }

    /**
     * 使用RSA公钥加密AES密钥.
     *
     * @return 以Base64编码的加密后的AES密钥字符串
     */
    private static String getEncryptAESKey() {
        try {
            if (publicKey == null) {
                throw new NullPointerException("RSA公钥为空");
            }
            if (aesKeyBytes == null) {
                throw new NullPointerException("AES密钥为空");
            }
            int rsaKeySize = 1024;// RSA密钥长度
            int maxLength = rsaKeySize / 8 - 11;
            int mod = aesKeyBytes.length % maxLength;
            int groupNum = aesKeyBytes.length / maxLength;
            if (mod != 0) {
                groupNum++;
            }
            byte[][] dataSrc = new byte[groupNum][0];
            for (int i = 0, start = 0; i < groupNum; i++, start += maxLength) {
                if (i != groupNum - 1 || mod == 0) {
                    dataSrc[i] = Arrays.copyOfRange(aesKeyBytes, start, start + maxLength);
                } else {
                    dataSrc[i] = Arrays.copyOfRange(aesKeyBytes, start, start + mod);
                }
            }
            byte[][] cache = new byte[dataSrc.length][0];
            byte[] result = new byte[0];
            Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            for (int i = 0, start = 0; i < dataSrc.length; i++) {
                cache[i] = cipher.doFinal(dataSrc[i]);
                result = Arrays.copyOf(result, result.length + cache[i].length);
                System.arraycopy(cache[i], 0, result, start, cache[i].length);
                start = cache[i].length;
            }
            return new String(Base64.encode(result, Base64.NO_WRAP), StandardCharsets.UTF_8);
        } catch (Exception e) {
            myLog.e("使用RSA公钥加密AES密钥失败", e);
            return null;
        }
    }

能力所限，不足之处烦请多多指教！

鸣筝
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
加密策略
aipiannian6725的博客
03-02 331
一、前言 　　这两天研究了一下项目中的密码加密，可以说得上是学到了很多。下面来大致说一下。 二、常用加密 　 1.单向加密算法 　 单向加密算法主要用来验证数据传输的过程中，是否被篡改过。 BASE64 严格地说，属于编码格式，而非加密算法 MD5(Message Digest algorithm 5，信息摘要算法) ...
数据加密存储常见的加密方式
最新发布
m0_71744044的博客
05-18 1278
数据加密存储五种常见的加密方式先总结下
浅谈保护数据的加密策略
TrustAsia的博客
02-10 1630
数据加密策略
安卓个人信息加密策略
chenhuakang的博客
05-07 636
原文地址: http://www.jiamisoft.com/blog/21306-deses.html安卓root后可以查看app文件目录为了降低个人信息泄露的风险，需要采用加密，采用对称加密，针对信息量的大小和安全性，在不同的方案中筛选DES与AES的比较自DES 算法公诸于世以来，学术界围绕它的安全性等方面进行了研究并展开了激烈的争论。在技术上，对DES的批评主要集中在以下几个方面：1、作为...
浅谈数据加密技术应用在计算机网络信息安全中的应用.pdf
09-26
为提升数据加密技术在实际应用中的效果，我们需要制定有效的措施，包括定期更新和修补系统漏洞，加强用户安全意识教育，以及采用多重加密策略等。同时，随着技术的不断发展，如量子加密等新型加密方法也将对网络安全...
浅谈Oracle数据库安全策略.pdf
10-10
本文将探讨Oracle数据库的安全策略，包括用户管理和数据保护，旨在确保数据库系统的稳定和安全。 一、用户管理 用户管理是保障数据库安全的基础。在Oracle数据库中，通过创建不同的用户组和设置口令验证，可以有效...
浅谈计算机网络信息安全中的数据加密技术 (2).pdf
09-26
数据加密技术是保障计算机网络信息安全的重要手段，通过不断发展的加密算法和策略，可以有效地抵御黑客攻击和病毒威胁，保护用户的隐私和数据安全。未来，随着云计算、物联网等新技术的发展，数据加密技术将继续扮演...
浅谈数据中心智能化系统设计.rar
09-20
数据中心智能化系统设计是现代信息技术发展的重要方向，它涵盖了多个领域，包括硬件基础设施、软件系统、自动化...通过阅读“浅谈数据中心智能化系统设计.pdf”这份文档，我们可以更深入地理解这个复杂而重要的领域。
浅谈计算机大数据分析与云计算网络技术研究.pdf
07-16
【摘要】中提到的“浅谈计算机大数据分析与云计算网络技术研究”主要关注的是当前经济和技术发展背景下，计算机技术和云计算网络技术的应用和发展问题。本文将深入探讨这两个领域存在的挑战，并提出提升技术水平的...
常见的几种数据加密算法
qq_53663858的博客
06-15 1万+
常见的几种数据加密算法
常用的密码加密方法
m0_73875507的博客
05-17 354
对称加密算法中常用的算法有：DES、3DES、TDEA、Blowfish、RC2、RC4、对称加密的优缺点：优点是算法公开、计算量小、加密速度快、加密效率高，安全、可认证；采用单钥密码系统的加密方法，同一个密钥可以同时用作信息的加密和解密，这种加密方法。非对称加密算法是一种密钥的保密方法，它需要两个密钥来进行加密和解密，这两个密钥是。非对称加密的优缺点：优点是安全性更高，公钥是公开的，秘钥是自己保存的，不需要将私。上的普通的物理签名，但是在使用了公钥加密领域的技术来实现的，用于鉴别数字信息的方。
某站webpack打包JS逆向，keyCipher、keySM2Cipher参数分析
tiebanggg的博客
09-12 1721
文章目录前言一、抓包分析二、参数解析1.加密定位2.参数分析总结 前言 今天来水一篇文章，某站webpack打包类型，登录、数据解密参数keyCipher、keySM2Cipher。本文章仅供学习研究，如若侵犯到贵公司权益请联系229456906@qq.com第一时间进行删除；各位朋友切忌用于一切非法途径，否则后果自行承担！ 地址：gov地址就不放了，主要讲思路。。。 一、抓包分析 老规矩，打开登录框输入138****8888，1111111点击登录按钮进行抓包。 当点击登录后，看第一条请求： 看
Java数据加密Cipher介绍
03-07
数字加密是安全体系中最重要的安全组件，数据加密可以保证数据的私密性。Cipher类为加密和解密提供密码功能，是Java Cryptographic Extension（JCE）框架的核心。在本系列中，讲解了数据加密的常见的相关概念，对Cipher引擎类进行了简明扼要的介绍， 对Cipher 加解密Key对象做了介绍。通过本系列的学习，可以了解数据加密的原理及过程，了解Cipher引擎类，本课程给出来最基本的数据加密的引擎类示例，便于用户学习和使用Java数据加密解密编程
电子商务网站互联网安全防御攻略
热门推荐
Defonds 的专栏
12-09 1万+
电子商务网站，互联网的安全防御相当重要，尤其是牵扯到支付这一块的。本文总结了一些比较通用的 web 安全防御常识，供大家参考一下，也希望可以和关心这一块的同行一起讨论一下这方面的话题。
JAVA开发必须掌握的5中加密策略
huang_yx的博客
03-30 1221
本文是阅读Hollis的文章之后的总结。加密策略主要分为：1.数字摘要；2.对称加密；3.非对称加密；4.数字签名；5.数字证书，这5种策略一、数字摘要数字摘要也称为消息摘要，它是一个唯一对应一个消息或文本的固定长度的值，它由一个单向Hash函数对消息进行计算而产生。如果消息在传递的途中改变了，接收者通过对收到消息采用相同的Hash重新计算，新产生的摘要与原摘要进行比较，就可知道消息是否被篡改了。...
任务二个人数据安全(共17张PPT).pptx
12-02
任务二个人数据安全(共17张PPT).pptx

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值