精华内容
参与话题
问答
  • RSA加解密&加验签

    万次阅读 2019-07-18 11:49:11
    简介 RSA加密算法是一种非对称加密算法。在公开密钥加密和电子商业中RSA被广泛使用。RSA是1977年由罗纳德·李维斯特(Ron Rivest)、*阿迪·萨莫尔(Adi Shamir)和伦纳德·阿德曼(Leonard Adleman)*一起提出的。...

    简介
    RSA加密算法是一种非对称加密算法。在公开密钥加密和电子商业中RSA被广泛使用。RSA是1977年由罗纳德·李维斯特(Ron Rivest)、*阿迪·萨莫尔(Adi Shamir)伦纳德·阿德曼(Leonard Adleman)*一起提出的。当时他们三人都在麻省理工学院工作。RSA就是他们三人姓氏开头字母拼在一起组成的。

    • RSA 加密或签名后的结果是不可读的二进制,使用时经常会转为 BASE64码再传输。
    • RSA 加密时,对要加密数据的大小有限制,最大不大于密钥长度。例如在使用 1024 bit 的密钥时,最大可以加1024/8=128 Bytes 的数据。数据大于 128 Bytes 时,需要对数据进行分组加密(如果数据超限,加解密时会失败,openssl 函数会返回false),分组加密后的加密串拼接成一个字符串后发送给客户端
    • 为了保证每次加密的结果都不同,RSA 加密时会在待加密数据后拼接一个随机字符串,再进行加密。不同的填充方式 Padding表示这个字符串的不同长度,在对超限数据进行分组后,会按照这个 Padding 指定的长度填入随机字符串。例如如果 Padding填充方式使用默认的 OPENSSL_PKCS1_PADDING(需要占用 11 个字节用于填充),那么明文长度最多只能就是128-11=117 Bytes。
    • 接收方解密时也需要分组。将加密后的原始二进制数据(对于经过 BASE64 的数据,需要解码),每 128 Bytes 分为一组,然后再进行解密。解密后,根据 Padding 的长度丢弃随机字符串,把得到的原字符串拼接起来,就得到原始报文。
    • 由于RSA算法的原理都是大数计算,使得RSA最快的情况也比对称加密算法慢上好几倍。速度一直是RSA的缺陷,一般来说RSA只用于小数据的加密.RSA的速度是对应同样安全级别的对称加密算法的1/1000左右。一般在实际数据传输时,用 RSA 来加密比较短的对称密码,双方交换密码后再使用 DES 等对称算法传输数据。
    • 秘钥长度用户应使用 1024 位密钥,证书认证机构应用 2048 位或以上

    加解密&加验签
    加解密:对请求参数加密,非明文方式传输。使用公钥加密,私钥解密
    加验签:主要是鉴别请求是否为理想请求方发出的,请求的参数是否有被篡改。使用私钥加密,公钥解密
    签名验签大概流程:对原文进行hash(生成摘要),用自己的私钥对hash值(摘要)加密得到一个签名值,将自己的原文,签名值,公钥证书发送给银行,银行用根证书验证对方的公钥是否有效,有效取出公钥证书中的公钥来,将发来的签名值进行解密,得到hash值,将原文进行hash值与解密得到的hash值对比。

    RSA工具类 RSAUtils

    public class RSAUtils {
    
        public static final String CHARSET = "UTF-8";
        public static final String RSA_ALGORITHM = "RSA";
    
        public static Map<String, String> createKeys(int keySize){
            //为RSA算法创建一个KeyPairGenerator对象
            KeyPairGenerator kpg;
            try{
                kpg = KeyPairGenerator.getInstance(RSA_ALGORITHM);
            }catch(NoSuchAlgorithmException e){
                throw new IllegalArgumentException("No such algorithm-->[" + RSA_ALGORITHM + "]");
            }
    
            //初始化KeyPairGenerator对象,密钥长度
            kpg.initialize(keySize);
            //生成密匙对
            KeyPair keyPair = kpg.generateKeyPair();
            //得到公钥
            Key publicKey = keyPair.getPublic();
            String publicKeyStr = Base64.encodeBase64URLSafeString(publicKey.getEncoded());
            //得到私钥
            Key privateKey = keyPair.getPrivate();
            String privateKeyStr = Base64.encodeBase64URLSafeString(privateKey.getEncoded());
            Map<String, String> keyPairMap = new HashMap<String, String>();
            keyPairMap.put("publicKey", publicKeyStr);
            keyPairMap.put("privateKey", privateKeyStr);
            return keyPairMap;
        }
    
        /**
         * 得到公钥
         * @param publicKey 密钥字符串(经过base64编码)
         * @throws Exception
         */
        public static RSAPublicKey getPublicKey(String publicKey) throws NoSuchAlgorithmException, InvalidKeySpecException {
            //通过X509编码的Key指令获得公钥对象
            KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(Base64.decodeBase64(publicKey));
            RSAPublicKey key = (RSAPublicKey) keyFactory.generatePublic(x509KeySpec);
            return key;
        }
    
        /**
         * 得到私钥
         * @param privateKey 密钥字符串(经过base64编码)
         * @throws Exception
         */
        public static RSAPrivateKey getPrivateKey(String privateKey) throws NoSuchAlgorithmException, InvalidKeySpecException {
            //通过PKCS#8编码的Key指令获得私钥对象
            KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(Base64.decodeBase64(privateKey));
            RSAPrivateKey key = (RSAPrivateKey) keyFactory.generatePrivate(pkcs8KeySpec);
            return key;
        }
    
        /**
         * 公钥加密
         * @param data
         * @param publicKey
         * @return
         */
        public static String publicEncrypt(String data, RSAPublicKey publicKey){
            try{
                Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
                cipher.init(Cipher.ENCRYPT_MODE, publicKey);
                return Base64.encodeBase64URLSafeString(rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(CHARSET), publicKey.getModulus().bitLength()));
            }catch(Exception e){
                throw new RuntimeException("加密字符串[" + data + "]时遇到异常", e);
            }
        }
    
        /**
         * 私钥解密
         * @param data
         * @param privateKey
         * @return
         */
    
        public static String privateDecrypt(String data, RSAPrivateKey privateKey){
            try{
                Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
                cipher.init(Cipher.DECRYPT_MODE, privateKey);
                return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.decodeBase64(data), privateKey.getModulus().bitLength()), CHARSET);
            }catch(Exception e){
                throw new RuntimeException("解密字符串[" + data + "]时遇到异常", e);
            }
        }
    
        /**
         * 私钥加密
         * @param data
         * @param privateKey
         * @return
         */
    
        public static String privateEncrypt(String data, RSAPrivateKey privateKey){
            try{
                Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
                cipher.init(Cipher.ENCRYPT_MODE, privateKey);
                return Base64.encodeBase64URLSafeString(rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(CHARSET), privateKey.getModulus().bitLength()));
            }catch(Exception e){
                throw new RuntimeException("加密字符串[" + data + "]时遇到异常", e);
            }
        }
    
        /**
         * 公钥解密
         * @param data
         * @param publicKey
         * @return
         */
    
        public static String publicDecrypt(String data, RSAPublicKey publicKey){
            try{
                Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
                cipher.init(Cipher.DECRYPT_MODE, publicKey);
                return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.decodeBase64(data), publicKey.getModulus().bitLength()), CHARSET);
            }catch(Exception e){
                throw new RuntimeException("解密字符串[" + data + "]时遇到异常", e);
            }
        }
    
        private static byte[] rsaSplitCodec(Cipher cipher, int opmode, byte[] datas, int keySize){
            int maxBlock = 0;
            if(opmode == Cipher.DECRYPT_MODE){
                maxBlock = keySize / 8;
            }else{
                maxBlock = keySize / 8 - 11;
            }
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int offSet = 0;
            byte[] buff;
            int i = 0;
            try{
                while(datas.length > offSet){
                    if(datas.length-offSet > maxBlock){
                        buff = cipher.doFinal(datas, offSet, maxBlock);
                    }else{
                        buff = cipher.doFinal(datas, offSet, datas.length-offSet);
                    }
                    out.write(buff, 0, buff.length);
                    i++;
                    offSet = i * maxBlock;
                }
            }catch(Exception e){
                throw new RuntimeException("加解密阀值为["+maxBlock+"]的数据时发生异常", e);
            }
            byte[] resultDatas = out.toByteArray();
            IOUtils.closeQuietly(out);
            return resultDatas;
        }
        public static void main (String[] args) throws Exception {
            /****生成密钥对****/
            Map<String, String> keyMap = createKeys(1024);
            String  publicKey = keyMap.get("publicKey");
            String  privateKey = keyMap.get("privateKey");
            System.out.println("公钥:" + publicKey);
            System.out.println("私钥:" + privateKey);
    
            System.out.println("公钥加密——私钥解密");
            String str = "人生自古谁无死?";
            System.out.println("明文:" + str);
            System.out.println("明文大小:" + str.getBytes().length);
            String encodedData = RSAUtils.publicEncrypt(str, RSAUtils.getPublicKey(publicKey));
            System.out.println("密文:" + encodedData);
            String decodedData = RSAUtils.privateDecrypt(encodedData, RSAUtils.getPrivateKey(privateKey));
            System.out.println("解密后文字:" + decodedData);
    
            System.out.println("私钥加密——公钥解密");
            String a1=RSAUtils.privateEncrypt("哈哈",RSAUtils.getPrivateKey(privateKey));
            System.out.println(a1);
            String a2=RSAUtils.publicDecrypt(a1,RSAUtils.getPublicKey(publicKey));
            System.out.println(a2);
        }
    }
    
    

    总结
    加密是为了防止信息被泄露,而签名是为了防止信息被篡改
    私钥和公钥是一对,谁都可以加解密,只是谁加密谁解密是看情景来用的:

    • 第一种情景是签名,使用私钥加密,公钥解密,用于让所有公钥所有者验证私钥所有者的身份并且用来防止私钥所有者发布的内容被篡改.但是不用来保证内容不被他人获得。
    • 第二种情景是加密,用公钥加密,私钥解密,用于向公钥所有者发布信息,这个信息可能被他人篡改,但是无法被他人获得。
    展开全文
  • 几种常用的加解密的方法

    千次阅读 2016-08-25 10:42:47
    和安一起解决视频加密的需求,了解了一些相关的视频加解密的方法,故把相关的知识贴在这里 1. 全部加密(Naive Algorithm) 也就是使用标准 加密方法(比如DES)加密整个视频流。将视频比特流同传统的文本数据同样...

    参考链接:http://www.drmsoft.cn/DRM_Encryption/How_to_encrypt_video.html


    和安一起解决视频加密的需求,了解了一些相关的视频加解密的方法,故把相关的知识贴在这里

    1. 全部加密(Naive Algorithm)

    也就是使用标准 加密方法(比如DES)加密整个视频流。将视频比特流同传统的文本数据同样对待,没有利用视频压缩后数据流的特殊结 构。这种方法显然计算量巨大,很难保证视频的实时传输。

    2. 选择性加密(Selective Algorithm)

    选择性 加密是基于信源特征的视频加密方法的主要方向,其中可分为以下几类:

    (1) 基本的选择性加密算法是基于视频 IPB帧结构的。这其 中最有代表性且最早提出的一种加密方法是仅仅加密I帧。然而, Agi and Gong 表明由于帧间的相关性和主要是由于P帧和B帧中的I-block没有加密,这种仅加密I帧的方法不能达 到一个令人满意的密级。这样,有人提出加密I帧的同时还应加 密PB帧中的 I块。但这样增大 了计算量,同时视频图像中的运动信息也没有被加密,保密性仍不够好。

    于是,有人提出 利用提高视频序列中I帧频率的方法来 增加加密的内容从而提高密级。但这样很明显会增大加密的数据量,大大增加计算量,同时减小视频压缩率。

    (2) 仅加密头信息的方法:MPEG、H26X序列都按一定结构组织图像数据。例如,图片组、图片(帧)、片组、片、宏块组、宏块等 ,都由一个头信息开始,后接图像数据。经编码后的视频数据,要按标准规定的特定结构排列组织,收方按相同 的标准结构解码,才能正确恢复原视频图像。

    该算法的原理是对这些头信息数据加密,将其变成随 机序列,再与其它数据混合,使接收方在不知道密钥的情况下难以区分结构信息数据和视频信息数据,更难以知 道数据结构和数据的具体内容,难以按原数据结构解码接收到的视频编码数据,无法获得原图像,达到加密目的 。

    该算法仅加密头信息,安全性较低。因为按照编码标 准,头信息具有固定的位置和内容,所以含信息量很小,加密的意义不大。只要能分辨出头信息和视频数据,就 可以恢复视频图像,并且一旦知道头信息,密钥和密码算法也很容易破译。事实上,基于MPEG、H26x等标准的视频数据结构比较固定,视频数据本身又有很强的特征,这种加密方式比较 容易破译。

    该算法不降低压缩率。增加计算量很小,适用于各种 标准视频或图像压缩编码数据。

    经过该算法加密的视频编码数据没有通用的数据结构 信息,全部为随机序列。为便于合法收方接收,需加入加密同步信息,或保留原来部分同步信息,只加密其它结 构信息。如果加密结构信息误码,合法收方恢复视频图像也很困难。

    (3) Meyer and Gadegast 设计了一种新的似MPEG比特流,称之为 SECMPEG。SECAM既能使用标准加密算法DES和RSA又能实现不同级别的密级。但SECMPEG与标准的MPEG不兼容,需要设计专门的编解码器。

    第一级:加密所 有的头信息(Headers)

    第二级:加密所 有的头信息(Headers)和I-Block中的DC和AC系数

    第三级:加密 I帧和 PB帧中的所有 I-Block

    第四级:加密所 有的数据

    (4) 选择性加密的另一个主要的方向是由Bharat Bhargava等提出的加密DCT符号,运动矢量MV符号。文献[5]中将仅加密I帧的DCT符号位的方法称为VEA算法。第二种方 法除了加密I帧,还要加密 PB帧的 DCT符号位和运动矢量MV的符号位称之为MVEA算法。相对保密性要好得多的第三种方法是使用 密钥加密(如DES或IDEA)的密码学算法来对DCT系数或运动矢量 MV符号位进行加密 ,作者称之为RVEA算法。

    选择性加密的保 密性根据具体使用什么方法而定,一般选择性加密的计算量不大,且通常不会增大码流大小(改变I帧频率的选择性 加密算法除外)。

    3. Zig-Zag置乱算法(Zig-Zag Permutation Algorithm)

    Zig-Zag置乱算法的基本思想:使用一个随机的置乱序列来代替 Zig-Zag扫描顺序,来将各个8×8块的DCT系数映射成一个1×64矢量。

    基本算法由三步组成,步骤如下:

    (1)产生一个基数为64的置乱序列表;

    (2)把DC系数分成两个较小值的数。假设 DC是二进制数d7d6d5d4d3d2d1d0,将它分成两个数d7d6d5d4和d3d2d1d0,它们的范围都在[0,15]。然后将DC系 数置为d7d6d5d4,将原最后一个AC系数置为d3d2d1d0。(这种分离处理是基于以下两点:(1)通常DC系数值 远大于AC系数值,因此乱序后很容易被识别。分离变小后就难于从AC系数中区分出来;(2)最末一个AC系数作 用很小,通常为0,可以用其存放d3d2d1d0,恢复时取0值,不影响图象质量,也不增加数据量。)

    (3)用随机置乱序列表将经分离处理的8× 8块映射成1×64序列(vector)。

    该算法设计者自己指出,上述基本 算法对已知明文攻击是脆弱的,因此提供了两种附加方法增强算法的安全性(security):

    方法1: 将每8个块分成一组,把8个DC系数组合在一起(每系 数8位,恰好64位),然后运用DES加密。加密的结果按字节映射回到8个块中,然后(按上面1~3步骤)用分离 过程和置乱对每块进行加密。

    方法2: 产生两张不同的置乱序列表(表1和表2),对每个8×8 块抛掷硬币,反面用表1,正面用表2。抛币产生的正反序列和两张表作为密码。

    Zig-Zag置乱算法有严重的安全性问题[1]。文献[1]提供两种可以成功破解该算法的方法。Zig-Zag置乱算法速度很 快,不影响视频的实时传输。但是经过加密的视频压缩后码流大小将显著增加。因为运用非zig-zag顺序将8×8块映射到1×64的矢量,将会极大减少连续零个数,从而减少压缩率。文献[1]表明 视频流大小经加密后增加可达46%(表中最大值)。考虑到MPEG视频流数据量的巨大,这种大小增量是很难容 忍的。

    4.改变 Huffman码表算法

    改变Huffman码表的视频加密算法原理是:对于熵 编码用Huffman编码的视频编码标准,将通用Huffman码表修改后使用,修改后的特殊 Huffman码表作为密钥。非法接收方无此特殊码表,不能正确解码视频(图像)信息。

    该算法的安全性取决于保持压缩率不变的前提下, Huffman码表的可变空间(密码空间)。文献[8]做了定量的分析。

    改变Huffman码表,一般会降低 压缩率。Huffman编码是对数据流中出现频率高的位组合模式对应短码字,出现频率低的位组合模式对应长码字, 达到缩短平均码字,压缩数据的目的。Huffman码表通过统计码流中各种位组合模式出现的概率制作。本算法在改 变各组合模式对应的Huffman码字时,保持对应码字长度不变,即保持了特定出现概率的组合模式对应的特定码字 长度不变,也就保持了原压缩率不变。

    该算法完全不增加计算量。适用于使用Huffman编码的各种视频和图像压缩编码标准和算法。其缺点是安全性较差(密钥空间小)。

    5. 基于统计规律的视频加密算法

    基于统计规律的 视频加密算法在文献[1]中称 之为VEA算法(Video Encryption Algorithm)。文献[1]认为,压缩和 加密之间具有共同点,即两者都致力于去除冗余信息(Redundant information)。经MPEG压缩编码的码流具有一定的随机性。文献[1]把码流分成以字节为单元的流,每字节单元的 值为整数0~255。按字节测试统计(Byte-by-Byte),编码后字节值在0~255上的分布接近均匀,最高的字节出现 频率低于0.0178, 方差为10-6。最高相邻字节对(digrams:pairs of two adjacent numbers)的出现频率低于10-4,因此提出以下设想:将I帧分为8或16(通常16)大块( chunk),在任何chunk中,没有重复的字节模式。依据这个设想提出下面的VEA算法。

    (1)设一I帧的某个chunk为如下形式:a1 ,a2,a3,a4,...,a2n-1,a2n。

    (2)选择奇数号的字节组成奇队列(Odd List),选择偶数号的字节组成偶队列(Even List)。

    (3)将两个新数据流异或 

     

    (4)选择一种加密函数(例如DES)来加 密偶队列a2,a4,...,a2n。得到的密文为:c1,c2,…,cn, E(a2,a4,…,a2n).

    容易看出:如果a2a4…a2n没有 重复模式(repeated pattern),VEA算法密级就决定于function E。 因为a2,a4,…,a2n对a1,a3,…,a2n-1虽是简单异或,却是一次一 密乱码本(one-time pad)加密密钥,这是公认非常保密的。

    该方法不加密头信息结构格式等数据,只加密图像数 据本身。将待加密数据分为两半,一半用密码方法(函数E)加密,另一半用简单异或,因 此总体减少了计算量,提高了计算速度。前一半的计算速度取决于E。

    该方法不影响压缩率。适用于压缩的视频(或图像) 编码数据,而且压缩效果越好,加密效果也越好。

    6. 纯置乱算法 (Pure Permutation Algorithm)

    基于上一节中的 统计结果,我们知MPEG视频的字节流有一个非常低的字节对出现频率。因此,通常的利用数据频率,字节对频率特性等密码 分析方法对此没有用(至少很难)。

    Pure Permutation Algorithm 应运而生:Pure Permutation Algorithm简单的置乱字节流。置乱密码序列的基数是根据密级和应用需求动态 可变的。比如我们可以用64个数的置乱序列 或 一个长的 I帧的 1/8的置乱序列。

    Pure Permutation Algorithm的问题在于它对已知明文攻击非常脆弱。

    一旦通过比较密文和已知原始帧数据,获取了随机置乱序列,所有的帧将很容易被破译。为了找出随机置乱序列 ,我们需要已知随机序列长度倍数大小的明文。然而注意到MPEG数据流的单一性(unicity)和帧 大小在同一个数量级上,因此基于Shannon’s Theorem,如果已知一个I帧数据足以破译整个随机序列。



    展开全文
  • 加密解密

    2020-07-07 10:41:09
    加密解密加解密概念常用算法对称加密非对称加密 加解密概念 加密算法分 对称加密 和 非对称加密,其中对称加密算法的加密与解密 密钥相同,非对称加密算法的加密密钥与解密 密钥不同,此外,还有一类 不需要密钥 的 ...

    加解密概念

    加密算法分 对称加密 和 非对称加密,其中对称加密算法的加密与解密 密钥相同,非对称加密算法的加密密钥与解密 密钥不同,此外,还有一类 不需要密钥 的 散列算法

    常用算法

    对称算法:主要有 DES、3DES、AES 等,加解密 的过程是 可逆的。
    非对称算法 主要有 RSA、DSA 等,
    RSA 加密算法是目前最有影响力的 公钥加密算法,并且被普遍认为是目前 最优秀的公钥方案 之一。RSA 是第一个能同时用于 加密 和 数字签名 的算法,它能够 抵抗 到目前为止已知的 所有密码攻击,已被 ISO 推荐为公钥数据加密标准。

    散列算法 主要有 SHA-1、MD5 等。

    对称加密

    对称加密算法 是应用较早的加密算法,又称为 共享密钥加密算法。在 对称加密算法 中,使用的密钥只有一个,发送 和 接收 双方都使用这个密钥对数据进行 加密 和 解密。这就要求加密和解密方事先都必须知道加密的密钥。

    数据加密过程:在对称加密算法中,数据发送方 将 明文 (原始数据) 和 加密密钥 一起经过特殊 加密处理,生成复杂的 加密密文 进行发送。

    数据解密过程:数据接收方 收到密文后,若想读取原数据,则需要使用 加密使用的密钥 及相同算法的 逆算法 对加密的密文进行解密,才能使其恢复成 可读明文。

    非对称加密

    非对称加密算法,又称为 公开密钥加密算法。它需要两个密钥,一个称为 公开密钥 (public key),即 公钥,另一个称为 私有密钥 (private key),即 私钥。
    因为 加密 和 解密 使用的是两个不同的密钥,所以这种算法称为 非对称加密算法。
    如果使用 公钥 对数据 进行加密,只有用对应的 私钥 才能 进行解密。
    如果使用 私钥 对数据 进行加密,只有用对应的 公钥 才能 进行解密。

    展开全文
  • 自定义AES加解密算法(采用对称加密算法) Base64格式使用RFC4648进行编码和解码 自定义加解密KEY Key:来源:使用秘钥生成器生成一个随机秘钥,然后使用base64的Encoder进行编码 在使用的时候为固定值,即为私钥,不...

    自定义AES加解密算法(采用对称加密算法)

    Base64格式使用RFC4648进行编码和解码

    1. 自定义加解密KEY

      Key:来源:使用秘钥生成器生成一个随机秘钥,然后使用base64的Encoder进行编码

      在使用的时候为固定值,即为私钥,不可丢失,不可泄露

    2. 开始加密:

      a) 解码key:使用base64进行解码获取字节数组,获取原始秘钥

      b) 获取需要进行加密的数据的字节数组

      c) AES加密,获取构造的秘钥,和需要进行加密的字节数组

      d) AES加密使用默认值,ECB,此时没有偏移量(当使用CBC时,存在偏移量)

      e) 得到字节数组,使用base64进行编码

    3. 解密:

      a) 解码key:使用base64进行解码获取字节数组,获取原始秘钥

      b) 对需要进行解密的数据进行base64解码

      c) 使用AES进行解码,得到字节数组

      d) 直接将字节数组转换为字符串

    创建AESUtil.java

    package com.decode;
    
    import java.util.Base64;
    
    import javax.crypto.Cipher;
    import javax.crypto.KeyGenerator;
    import javax.crypto.SecretKey;
    import javax.crypto.spec.SecretKeySpec;
    
    public class AESUtil {
    
    	/**
    	 * 生成AES秘钥,然后Base64编码 
    	 * @return Base64编码 
    	 * @throws Exception 
    	 */
    	public static String genKeyAES() throws Exception {
    		KeyGenerator keyGen = KeyGenerator.getInstance("AES");
    		keyGen.init(128);
    		SecretKey key = keyGen.generateKey();
    		return Base64.getEncoder().encodeToString(key.getEncoded());
    	}
    
    	/**
    	 * 将Base64编码后的AES秘钥转换成SecretKey对象
    	 * @param base64Key
    	 * @return SecretKey对象
    	 * @throws Exception
    	 */
    	public static SecretKey loadKeyAES(String base64Key) throws Exception {
    		byte[] bytes = Base64.getDecoder().decode(base64Key);
    		return new SecretKeySpec(bytes, "AES");
    	}
    
    	/**
    	 * AES加密
    	 * @param source 加密内容
    	 * @param key SecretKey对象
    	 * @return 加密后的字节数组
    	 * @throws Exception
    	 */
    	public static byte[] encryptAES(byte[] source, SecretKey key) throws Exception {
    		Cipher cipher = Cipher.getInstance("AES");
    		cipher.init(Cipher.ENCRYPT_MODE, key);
    		return cipher.doFinal(source);
    	}
    
    	/**
    	 * AES解密
    	 * @param source 解密内容
    	 * @param key SecretKey对象
    	 * @return 解密后的字节数组
    	 * @throws Exception
    	 */
    	public static byte[] decryptAES(byte[] source, SecretKey key) throws Exception {
    		Cipher cipher = Cipher.getInstance("AES");
    		cipher.init(Cipher.DECRYPT_MODE, key);
    		return cipher.doFinal(source);
    	}
    }
    
    

    创建EncryptUtil.java

    package com.decode;
    
    import java.util.Base64;
    
    import javax.crypto.SecretKey;
    
    /**
     * AES加密解密算法
     * @author xxyf55
     *
     */
    public class EncryptUtil {
    	//加密解密秘钥KEY
    	public static final String aesKey = "a3z4v/RxfgHTRZtlHlrw+5Q==";
    
    	public static void main(String[] args) {
    		try {
    			long start = System.currentTimeMillis();
    			String context = "123123";
    			String aesData = appEncrypt(context);
    			System.out.println(aesData);
    			context = appDecrypt(aesData);
    			System.out.println(context);
    			long end = System.currentTimeMillis();
    			System.out.println(end - start);
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    
    	/**
    	 * 加密内容
    	 * @param content 需要加密的内容
    	 * @return 返回String
    	 * @throws Exception
    	 */
    	public static String appEncrypt(String content) throws Exception {
    		SecretKey secretKey = AESUtil.loadKeyAES(aesKey);
    		// 用AES秘钥加密请求内容
    		byte[] encryptContentRequest = AESUtil.encryptAES(content.getBytes("utf-8"), secretKey);
    		String data = Base64.getEncoder().encodeToString(encryptContentRequest);
    		return data;
    	}
    
    	/**
    	 * 解密内容
    	 * @param content 内容
    	 * @return
    	 * @throws Exception
    	 */
    	public static String appDecrypt(String content) throws Exception {
    		// 用AES秘钥解密请求内容
    		SecretKey secretKey = AESUtil.loadKeyAES(aesKey);
    		byte[] response = AESUtil.decryptAES(Base64.getDecoder().decode(content), secretKey);
    		return new String(response);
    	}
    }
    
    

    运行main方法即可获得加密之后的数据,进行解密之后得到原始的数据

    展开全文
  • Java-数据加解密实现

    万次阅读 2018-08-30 14:20:11
    (1)对称加密:即加密与解密用的是同一把秘钥,常用的对称加密技术有DES、AES等。 (2)非对称加密:加密与解密用的是不同的秘钥,常用的非对称加密技术有RSA等。 为什么要有非对称加密、解密技术呢? 假设这样一...
  • 所以加解密、加签验签对于一个合格的程序员来说是必须要掌握的一个概念。那么加解密相关的密码学真的离我们很遥远吗?其实生活中有很多常见的场景其实都用到了密码学的相关知识,我们不要把它想得太难,例如在《睡在...
  • 几种常用加密手段的加密与解密

    万次阅读 2018-07-05 21:48:23
    网络中传输敏感信息的时候通常会对字符串做加密解密处理1.Base64位加密(可加密解密) 最简单的加密方式,没有密钥,这种方式只要让别人拿到你的密文,就可以直接解密,只能用来迷惑,一般情况下不单独使用,因为真...
  • 加解密方法简介

    2018-11-28 10:46:13
    采用单钥密码的加密方法,同一个密钥可以同时用来加密和解密,这种加密方法称为对称加密,也称为单密钥加密。常用的对称加密算法:  DES(Data Encryption Standard):数据加密标准,速度较快,适用于加密大量...
  •   最近的文章中多次出现了非对称加密,今天就来分析一下非对称加密的算法。 ...公钥和私钥是一对,如果用公钥对数据加密,那么只能用对应的私钥解密。如果用私钥对数据加密,只能用对应的...
  • JAVA实现PGP/GPG加解密加验签

    万次阅读 2020-03-13 11:05:24
    一、引言 上一篇博客中介绍了GPG的基本使用,在原来的项目中我们对接gpg加密的时候,采用的方式,利用java代码执行...所以小编也利用java生成一个加密文件,这样双方可以愉快的加解密了。 二、代码实现 2.1 mave...
  • 完整的RSA开发流程以及加解密Demo

    万次阅读 2018-06-14 21:36:54
    import java.security.KeyFactory; import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.PrivateKey; import java.security.PublicKey; import java.security.spec.PKCS8En...
  • 条理清晰的入门:使用Java实现RSA加密解密 需要导入的头文件 生成公钥、私钥 进行加密解密 密钥的存储 密文的存储、读取
  • Base64加解密简述

    万次阅读 多人点赞 2019-03-11 09:12:14
    打开激活窗口 选择 Activate new license with License server (用license server 激活) 在 License sever address 处填入 https://jetlicense.nss.im/(失效) 点击 Activate 进行认证 ... ...
  • RSA算法原理——(3)RSA加解密过程及公式论证

    万次阅读 多人点赞 2018-07-04 00:16:32
    上期(RSA简介及基础数论知识)为大家介绍了:互质、欧拉函数、欧拉...三、RSA加解密过程及公式论证 二、RSA加解密过程及公式论证 今天的内容主要分为三个部分: rsa密钥生成过程: 讲解如何生成公钥和私钥 rs...
  • 继上一篇 加密解密系列文章之 - ASCII 加密解密(最简单的加密解密) 上 的下篇。 我在 上 篇里 已经给大家说了最基本的ASCII 加密 解密的东西。然后再最后 我们说了ASCII加密解密的问题。那就是 当对一个ASCII的...
  • SpringBoot中接口加密解密统一处理

    万次阅读 多人点赞 2019-07-27 19:49:38
    我们与客户端的接口交互中,为了更高的安全性,我们可能需要对接口加密(请求参数加密,服务端解密)、返回信息加密(服务端加密,客户端解密),但是也不是所有的接口都这样,有些接口可能不需要,我们可以使用注解...
  • DES加密解密

    千次阅读 2017-09-20 17:03:49
    DES全称为Data Encryption Standard,即数据加密标准,是一种使用密钥加密的块算法,1977年被美国联邦政府的国家标准局确定为联邦资料处理标准(FIPS),并授权在非密级政府通信中使用,随后该算法在国际上广泛...
  • 本人没学过加密解密专业以及没有对加密解密做过任何的系统学习。文章用来记录我自己学到的加密解密的一些我理解的东西,有错误之处欢迎大家指出。谢谢。加密解密。在以前我的眼里。是灰常高大上、灰常屌的技术。正如...
  • Java字段加解密

    万次阅读 2020-07-27 21:15:39
    加解密:将明文转换成一串看不懂的东西,并且还能再转回来 引用jar包: <!-- 加解密包 --> <dependency> <groupId>org.jasypt</groupId> <artifactId>jasypt</artifactId>...
  • Java使用AES加解密

    万次阅读 2017-06-19 09:21:41
    Java使用AES加解密目录1.1生成密钥1.2密钥的存储1.3获取存储的密钥1.4加解密1.5使用存储的密钥进行加解密示例 AES是一种对称的加密算法,可基于相同的密钥进行加密和解密。Java采用AES算法进行加解密的逻辑大致如下...

空空如也

1 2 3 4 5 ... 20
收藏数 255,505
精华内容 102,202
关键字:

加解密