精华内容
下载资源
问答
  • aes rsa
    2021-12-09 11:21:35
    这是我自己写的方法 可以一步一步去试试 
    
    <?php
    
    namespace app\personnel\controller;
    
    use think\Controller;
    use think\Db;
    use think\Request;
    
    
    class Survey
    {
    
    
        private $gy = '-----BEGIN PUBLIC KEY-----
    MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCmkANmC849IOntYQQdSgLvMMGm
    8V/u838ATHaoZwvweoYyd+/7Wx+bx5bdktJb46YbqS1vz3VRdXsyJIWhpNcmtKhY
    inwcl83aLtzJeKsznppqMyAIseaKIeAm6tT8uttNkr2zOymL/PbMpByTQeEFlyy1
    poLBwrol0F4USc+owwIDAQAB
    -----END PUBLIC KEY-----';
    
        private $sy = '-----BEGIN PRIVATE KEY-----
    MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAKaQA2YLzj0g6e1h
    BB1KAu8wwabxX+7zfwBMdqhnC/B6hjJ37/tbH5vHlt2S0lvjphupLW/PdVF1ezIk
    haGk1ya0qFiKfByXzdou3Ml4qzOemmozIAix5ooh4Cbq1Py6202SvbM7KYv89syk
    HJNB4QWXLLWmgsHCuiXQXhRJz6jDAgMBAAECgYAIF5cSriAm+CJlVgFNKvtZg5Tk
    93UhttLEwPJC3D7IQCuk6A7Qt2yhtOCvgyKVNEotrdp3RCz++CY0GXIkmE2bj7i0
    fv5vT3kWvO9nImGhTBH6QlFDxc9+p3ukwsonnCshkSV9gmH5NB/yFoH1m8tck2Gm
    BXDj+bBGUoKGWtQ7gQJBANR/jd5ZKf6unLsgpFUS/kNBgUa+EhVg2tfr9OMioWDv
    MSqzG/sARQ2AbO00ytpkbAKxxKkObPYsn47MWsf5970CQQDIqRiGmCY5QDAaejW4
    HbOcsSovoxTqu1scGc3Qd6GYvLHujKDoubZdXCVOYQUMEnCD5j7kdNxPbVzdzXll
    9+p/AkEAu/34iXwCbgEWQWp4V5dNAD0kXGxs3SLpmNpztLn/YR1bNvZry5wKew5h
    z1zEFX+AGsYgQJu1g/goVJGvwnj/VQJAOe6f9xPsTTEb8jkAU2S323BG1rQFsPNg
    jY9hnWM8k2U/FbkiJ66eWPvmhWd7Vo3oUBxkYf7fMEtJuXu+JdNarwJAAwJK0YmO
    LxP4U+gTrj7y/j/feArDqBukSngcDFnAKu1hsc68FJ/vT5iOC6S7YpRJkp8egj5o
    pCcWaTO3GgC5Kg==
    -----END PRIVATE KEY-----';
    
        //AES加密
        public function encrypt($data, $key)
        {
            $data = openssl_encrypt($data, 'aes-128-ecb', base64_decode($key), OPENSSL_RAW_DATA);
            return base64_encode($data);
        }
    
    
        //AES解密
        public static function decrypt($data, $key)
        {
            $encrypted = base64_decode($data);
            return openssl_decrypt($encrypted, 'aes-128-ecb', base64_decode($key), OPENSSL_RAW_DATA);
        }
    
        //随机生成key
        public function GetRandStr($length)
        {
            //字符组合
            $str = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
            $len = strlen($str) - 1;
            $randstr = '';
            for ($i = 0; $i < $length; $i++) {
                $num = mt_rand(0, $len);
                $randstr .= $str[$num];
            }
            return $randstr;
        }
    
    
        //公钥加密
        public function gongencrypt($data)
        {
            $key = $this->gy;
            //公钥加密
            $public_key = openssl_pkey_get_public($key);
            if (!$public_key) {
                die('公钥不可用');
            }
    //第一个参数是待加密的数据只能是string,第二个参数是加密后的数据,第三个参数是openssl_pkey_get_public返回的资源类型,第四个参数是填充方式
            $return_en = openssl_public_encrypt($data, $crypted, $public_key);
            if (!$return_en) {
                return ('加密失败,请检查RSA秘钥');
            }
            $eb64_cry = base64_encode($crypted);
            return $eb64_cry;
        }
    
        //私钥加密
        public function jiedecrypt($data)
        {
    
            $key = $this->sy;
            //私钥解密
            $private_key = openssl_pkey_get_private($key);
            if (!$private_key) {
                die('私钥不可用');
            }
            $return_de = openssl_private_decrypt(base64_decode($data), $decrypted, $private_key);
            if (!$return_de) {
                return ('解密失败,请检查RSA秘钥');
            }
            return $decrypted;
        }
    
        /**
         * 获取待签名字符串
         * @param array $params 参数数组
         * @return   string
         */
        public function getSignString($params)
        {
            unset($params['sign']);
            ksort($params);
            reset($params);
            $pairs = array();
            foreach ($params as $k => $v) {
                if (!empty($v)) {
                    $pairs[] = "$k=$v";
                }
            }
            return implode('&', $pairs);
        }
    
        /**
         * 生成签名
         * @param string $signString 待签名字符串
         * @param    [type]     $priKey     私钥
         * @return   string     base64结果值
         */
        public function getSign($signString, $priKey)
        {
            $privKeyId = openssl_pkey_get_private($priKey);
            $signature = '';
            openssl_sign($signString, $signature, $privKeyId);
            openssl_free_key($privKeyId);
            return base64_encode($signature);
        }
    
        /**
         * 校验签名
         * @param string $pubKey 公钥
         * @param string $sign 签名
         * @param string $toSign 待签名字符串
         * @param string $signature_alg 签名方式 比如 sha1WithRSAEncryption 或者sha512
         * @return   bool
         */
        public function checkSign($pubKey, $sign, $toSign, $signature_alg = OPENSSL_ALGO_SHA1)
        {
            $publicKeyId = openssl_pkey_get_public($pubKey);
            $result = openssl_verify($toSign, base64_decode($sign), $publicKeyId, $signature_alg);
            openssl_free_key($publicKeyId);
            return $result === 1 ? true : false;
        }
    
    
        public function ceshi()
        {
            $data = input('');
            //生成随机aesKey
            $number = $this->GetRandStr(16);
            $aesKey = $number;
            $data = ["ss" => '测试啊大哥', "ww" => '真的',];
            //加密data数据
            $datas = json_encode($data);
            //加密AES数据
            $jiami = $this->encrypt($datas, $aesKey);
            $sel = [
                'aesKey' => $aesKey,
                'data' => $jiami,
            ];
            //解密AES数据
            //$jiemi =   $this->decrypt($jiami,$aesKey);
            //第一步加密走完 aeskey(明文) data(密文) 签名无
            //公钥加密
            $a = $this->gongencrypt($aesKey);
            $wel = [
                'aesKey' => $a,
                'data' => $jiami,
            ];
            //私钥解密
            //$b = $this->jiedecrypt($a);
            //第二步加密走完 aeskey(密文) data(密文) 签名无
            $signString = $this->getSignString($wel);
            $priKey = $this->sy;
            $sign = $this->getSign($signString, $priKey);
            $tel = [
                'aesKey' => $a,
                'data' => $jiami,
                'sign' => $sign,
            ];
            //第三部走完 aesKey(密文) data(密文) 签名有
            //解密第一步  验签  aesKey(密文) data(密文) 签名有
            $pubKeys = $this->gy;
            $res = $this->checkSign($pubKeys, $sign, $signString);
            //解密第二步 解密RSA aesKey(明文) data(密文) 签名有
            $tel['aesKey'] = $this->jiedecrypt($tel['aesKey']);
            //解密第三步 解密AES aesKey(明文) data(明文) 签名有
            $jiemi = $this->decrypt($tel['data'], $tel['aesKey']);
    
        }
    
    
    
    
    
    
    }
    
    更多相关内容
  • android AES rsa 混合加密

    2017-10-18 12:36:47
    android AES rsa 混合加密。
  • my test of AES and RSA, write in C#, wish you like
  • aes-rsa:AES RSA 加密工具

    2021-07-02 22:42:15
    使用 AESRSA 对数据进行加密和解密 实现方法 明文数据使用 AES 对称加密算法进行加密, AES 密钥使用 RSA 进行加密传输并对数据进行数据签名 加密结果密文数据结构: [数字签名(AES密钥密文+明文数据密文)][AES...
  • MD5 AES RSA 最全总结,本人亲自总结,欢迎学习
  • 易语言AES RSA加解密类

    2018-12-03 11:26:44
    易语言AES RSA加解密类,功能很全,基本够用了,RSA AES加解密,已经写成类了,只要调用
  • AES RSA加密

    2017-11-21 11:18:54
    AES RSA加密算法原理分析和应用,附有文档和demo,适合新手学习
  • 使用Crypto库,提供RSA,SM2,AES,SM3,SM4,SHA256的使用示例,可用于安全启动
  • js结合AES RSA进行加密

    千次阅读 2019-07-22 10:06:35
    想要了解两种加密算法查询其他资料,这里仅介绍加密流程及js代码 流程: 随机生成一个字符串(本文用32个字节的16进制字符),记为ramdomStr ...对ramdomStr进行AES(对称加密)加密,得到key记为c...

    想要了解两种加密算法查询其他资料,这里仅介绍加密流程及js代码

    流程:

    1. 随机生成一个字符串(本文用32个字节的16进制字符),记为ramdomStr
    2. 请求从后端获取一个公钥,此公钥用于RSA加密,记为publicRsaKey
    3. 用RSA加密算法对ramdomStr用publicRsaKey进行加密,得到新的key记为newKey
    4. 对ramdomStr进行AES(对称加密)加密,得到key记为cryptkey
    5. 用cryptkey对数据进行加密得到加密后的数据encryptedData
    6. 最后把encryptedData和newKey以商量好的格式传给后端,后端拿到这个字符串对newKey进行解密,拿到原始ramdomStr,再对数据encryptedData进行解密,拿到原始数据

    例:encryptData= ‘haha’, newKey=‘hehe’, 和后端商量好以##号进行连接。变成haha##hehe,后端以##进行分割,后端用RSA的私钥对hehe进行解密得到原始ramdomStr,用ramdomStr对haha进行数据解密,得到原始数据

    附流程图,附加防篡改流程

    在这里插入图片描述

    npm i crypto-js -S //AES加密算法
    npm i jsencrypt -S //RSA加密算法
    npm i axios -S //RSA加密算法
    // 正文开始
    import CryptoJS from 'crypto-js'
    import 'jsencrypt'
    
    export function generandomhexstr (length){
      let text = ''
      let possible = '0123456789abcdef'
      for( let i=0; i < length; i++ ){
        text += possible.charAt(Math. floor(Math. random() * possible.length))
      }
      return text
    } //获取随机字符串
    
    /* [用法: 执行encryption函数]
     * @param {String} getPubkeyUrl [请求公钥的接口]
     * @param {Object/String} data  [要加密的数据]
     * @param {function} fn         [拿到加密格式的回调函数]
     */
    export function encryption (getPubkeyUrl, data, fn) {
      axios.get(getPubkeyUrl, {prodName: 'pdm'}).then(res => { //flyio与axios同样功能,都是用于请求的,返回promise
    
      	if (!res.data) return //res.data 为请求到的公钥
      	let key= generandomhexstr(32)  //得到ramdomStr
      
      	/* AES加密 */
      	let cryptkey = CryptoJS.enc.Hex.parse(key) //得到cryptkey
      	if (typeof data === 'object'){
        	data = JSON.stringify(data)
      	}
      	let encryptedData = CryptoJS.AES.encrypt(data, cryptkey, {
        	mode: CryptoJS.mode.ECB,
        	padding: CryptoJS.pad.Pkcs7
      	})  
      	let encrypted = encryptedData.ciphertext.toString() //对数据进行加密得到encryptedData
      
        /* rsa加密 */
        let upperKey = key.toUpperCase()
        let encrypt = new window.JSEncrypt()
        encrypt.setPublicKey(res.data)
        let newKey = encrypt.encrypt(upperKey) //newKey
        
        typeof fn == 'function' && fn(`${newKey}##${encrypted}`)  //与后端商定用##号进行分割
      }). catch(err => {
        console. log(err)
      })
    }
    

    用法:执行

    展开全文
  • 如何进行AES RSA SHA1的加解密详细设计资料说明
  • RSA.rar,RSA,.vs,RSA,v14,.suo,RSA.sln,RSA,RSATools.cpp,test.cpp,RSA.vcxproj,RSATools.h,main.cpp,RSA.vcxproj.filters
  • 加密技术汇总
  • Hash MD5 DES AES RSA加解密实例
  • 前后端API交互使用RSAAES加密解密(js、Java).md
  • AES+RSA加解密

    2022-03-23 17:05:54
    在网上搜到一篇关于AES+RSA加密方案的文章,如下面链接所示,按照该方案成功解决了加密问题,在这里记录一下。 首先来看看未加密时,通过Fiddler抓包获取的明文信息如图所示: 图1 未加密时候,Fiddler抓包获取...

    最近维护公司APP应用的登录模块,由于测试人员用Fiddler抓包工具抓取到了公司关于登录时候的明文登录信息。虽然使用的是HTTPS的方式进行http请求的,但还是被Fiddler抓到了明文内容。因此,需要对之前未加密的登录信息进行加密。在网上搜到一篇关于AES+RSA加密方案的文章,如下面链接所示,按照该方案成功解决了加密问题,在这里记录一下。

    首先来看看未加密时,通过Fiddler抓包获取的明文信息如图所示:

    图1 未加密时候,Fiddler抓包获取的请求体。

     未加密时候,Fiddler抓包获取的请求头:

     可以明显地看到所有的http请求信息都是透明的。如果真的有有心人去盗窃用户的信息的话,会造成多大的损失。

    加密之后,Fiddler抓包获取的请求体:

    加密之后,Fiddler抓包获取的请求头:

    可以看到所有的请求体都通过AES加密后,再使用Base64进行编解码转换后的请求体,即使是被有心人去窃取了,也很难在有效的时间内进行破解。


    首先来看一张图,来看看实现该需求用到的几个常用的加解密名词

    加解密常用名词:

    基本需求及概念

    随着Internet网的广泛应用,信息安全问题日益突出,以数据加密技术为核心的信息安全技术也得到了极大的发展。目前的数据加密技术根据加密密钥类型可分私钥加密(对称加密)系统和公钥加密(非对称加密)系统。

    对称加密算法是较传统的加密体制,通信双方在加/解密过程中使用他们共享的单一密钥,鉴于其算法简单和加密速度快的优点,目前仍然是主流的密码体制之一。最常用的对称密码算法是数据加密标准(DES)算法,但是由于DES密钥长度较短,已经不适合当今分布式开放网络对数据加密安全性的要求。最后,一种新的基于Rijndael算法对称高级数据加密标准AES取代了数据加密标准DES。非对称加密由于加/解密钥不同(公钥加密,私钥解密),密钥管理简单,也得到广泛应用。RSA是非对称加密系统最著名的公钥密码算法。

    AES算法

    AES基本原理及算法流程

    美国国家标准和技术研究所(NIST)经过三轮候选算法筛选,从众多的分组密码中选中Rijndael算法作为高级加密标准(AES)。Rijndael密码是一个迭代型分组密码,分组长度和密码长度都是可变的,分组长度和密码长度可以独立的指定为128比特,192比特或者256比特。AES的加密算法的数据处理单位是字节,128位的比特信息被分成16个字节,按顺序复制到一个4*4的矩阵中,称为状态(state),AES的所有变换都是基于状态矩阵的变换。

    AES算法流程

    对于发送方,它首先创建一个AES私钥,并用口令对这个私钥进行加密。然后把用口令加密后的AES密钥通过Internet发送到接收方。发送方解密这个私钥,并用此私钥加密明文得到密文,密文和加密后的AES密钥一起通过Internet发送到接收方。接收方收到后再用口令对加密密钥进行解密得到AES密钥,最后用解密后的密钥把收到的密文解密成明文。图7中是这个过程的实现流程。

    AES算法流程:

    RSA算法

    RSA算法基本原理及流程

    RSA是在1977年发明RSA密码系统的三个人的名字的首字母的缩写,他们是:Ron Rivest、Adi Shamir和Leonard Adleman。它是第一个公钥加密算法,在很多密码协议中都有应用,如SSL和S/MIME。RSA算法是基于大质数的因数分解的公匙体系。简单的讲,就是两个很大的质数,一个作为公钥,另一个作为私钥,如用其中一个加密,则用另一个解密。密钥长度从40到2048位可变,密钥越长,加密效果越好,但加密解密的开销也大。

    RSA算法实现流程

    首先,接收方创建RSA密匙对,即一个公钥和一个私钥,公钥被发送到发送方,私钥则被保存在接收方。发送方在接收到这个公钥后,用该公钥对明文进行加密得到密文,然后把密文通过网络传输给接收方。接收方在收到它们后,用RSA私钥对收到的密文进行解密,最后得到明文。图8是整个过程的实现流程。

    AES与RSA相结合数据加密方案

    RSA算法是公开密钥系统的代表,其安全性建立在具有大素数因子的合数,其因子分解困难这一法则之上的。Rijndael算法作为新一代的高级加密标准,运行时不需要计算机有非常高的处理能力和大的内存,操作可以很容易的抵御时间和空间的攻击,在不同的运行环境下始终能保持良好的性能。这使AES将安全,高效,性能,方便,灵活性集于一体,理应成为网络数据加密的首选。相比较,因为AES密钥的长度最长只有256比特,可以利用软件和硬件实现高速处理,而RSA算法需要进行大整数的乘幂和求模等多倍字长处理,处理速度明显慢于AES[5];所以AES算法加解密处理效率明显高于RSA算法。在密钥管理方面,因为AES算法要求在通信前对密钥进行秘密分配,解密的私钥必须通过网络传送至加密数据接收方,而RSA采用公钥加密,私钥解密(或私钥加密,公钥解密),加解密过程中不必网络传输保密的密钥;所以RSA算法密钥管理要明显优于AES算法。

    从上面比较得知,由于RSA加解密速度慢,不适合大量数据文件加密,因此在网络中完全用公开密码体制传输机密信息是没有必要,也是不太现实的。AES加密速度很快,但是在网络传输过程中如何安全管理AES密钥是保证AES加密安全的重要环节。这样在传送机密信息的双方,如果使用AES对称密码体制对传输数据加密,同时使用RSA不对称密码体制来传送AES的密钥,就可以综合发挥AES和RSA的优点同时避免它们缺点来实现一种新的数据加密方案。加解密实现流程如图(9)。

    AES与RSA相结合数据加密方案流程:

     具体过程是先由接收方创建RSA密钥对,接收方通过Internet发送RSA公钥到发送方,同时保存RSA私钥。而发送方创建AES密钥,并用该AES密钥加密待传送的明文数据,同时用接受的RSA公钥加密AES密钥,最后把用RSA公钥加密后的AES密钥同密文一起通过Internet传输发送到接收方。当接收方收到这个被加密的AES密钥和密文后,首先调用接收方保存的RSA私钥,并用该私钥解密加密的AES密钥,得到AES密钥。最后用该AES密钥解密密文得到明文。

    客户端的具体的实现流程:

    1. 服务器端(server)分别生成自己的RSA密钥对,并提供接口给Android客户端获取RSA公钥(rsaPublicKey)
    2. client生成AES密钥(aesKey)
    3. client使用自己的AES密钥(aesKey)对转换为json格式的请求明文数据(data)进行加密,得到加密后的请求数据encryptData
    4. client提供server提供的接口获取RSA公钥(rsaPublicKey)
    5. client使用获取RSA公钥(rsaPublicKey)对AES密钥(aesKey)进行加密,得到encryptAesKey
    6. client将encryptAesKey作为http请求头参数,将加密后的请求数据encryptData作为请求体一起传输给服务器端

    服务端的具体实现流程:

    1. server 响应client的http请求,读取http请求头。获得client传过来的加密后的AES密钥(encryptAesKey),读取http请求体,获得client传过来的加密后的请求数据(encryptData)。
    2. server使用自己的RSA私钥(rsaPrivateKey)对加密后的AES密钥(encryptAesKey)进行RSA解密,得到AES密钥(aesKey)
    3. 使用解密后的AES密钥(aesKey)对加密后的请求数据(encryptData),进行AES解密操作,得到解密后的请求数据(data),该数据为json格式
    4.  对解密后的请求数据(data)进行json解析,然后做相关的响应操作。

    主要的流程图如下:

     crypto.js的内容如下:

    /*
     * @FilePath     : /OPPO-Support-WeApp/src/common/js/crypto.js
     * @Description  : 加密、解密 https://github.com/neohan666/wxmp-rsa
     * 
     * 如何使用
     * 
     * 引入
     * import RsaCrypto from "@/common/js/crypto.js";
     * 
     * 加密(默认添加前后缀)
     * RsaCrypto.encryptAES(875466680969966);
     * 加密(无须前后缀)
     * RsaCrypto.encryptAES(875466680969966, false);
     * 
     * 解密
     * let encrypt =
                "ZGfEzsTeBwLR85OX6l2tYEMveFFpFn66L8iudmOs0SqMazljJXMF9Qi4m/vG0MlSCDSp7VJJRkzPkLGFPi3CPdl6+feLzjDBahG89KBuRWfKS6SMYhcQJLevdKe+iwAvy3MtIQ5/FmYu5TtNWEhqTNmYsqg07W1pXEwCK6LLKaY=";
        RsaCrypto.decryptAES(encrypt)
     */
    
    import { JSEncrypt } from "wxmp-rsa";
    const CryptoJS = require("crypto-js");
    
    const START_STR = "START_CMS_RSA";
    const END_STR = "RSA_CMS_END";
    const RSA_PUBLIC_KEY = process.env.VUE_APP_RSA_PUBLIC_KEY || ""; // rsa的公钥
    const RSA_PRIVATE_KEY = process.env.VUE_APP_RSA_PRIVATE_KEY || ""; // rsa的私钥
    
    JSEncrypt.prototype.newRsaCrypt = function (param) {
        return START_STR + this.encrypt(param) + END_STR;
    };
    
    // 加密公钥
    const PUBLIC_KEY = `
      -----BEGIN PUBLIC KEY-----
      ${RSA_PUBLIC_KEY}
      -----END PUBLIC KEY-----
    `;
    // 解密私钥
    const PRIVATE_KEY = `
      -----BEGIN RSA PRIVATE KEY-----
      ${RSA_PRIVATE_KEY}
      -----END RSA PRIVATE KEY-----
    `;
    
    let aesKey = createAESKey(); // 随机获取AES密钥
    let key = createKey(aesKey); // 加密AES密钥
    
    /**
     随机生成密钥
     */
    function randomStr(len) {
        len = len || 32;
        let $chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnoprstuvwxyz1234567890";
        let maxPos = $chars.length;
        let pwd = "";
        for (let i = 0; i < len; i++) {
            pwd += $chars.charAt(Math.floor(Math.random() * maxPos));
        }
        return pwd;
    }
    
    /** 生成32位密钥 */
    function createAESKey() {
        return randomStr(16);
    }
    // 生成RSA加密AESkey
    function createKey(aesKey) {
        let rsaPublicKey = RSA_PUBLIC_KEY;
        let encrypt = new JSEncrypt();
        encrypt.setPublicKey(rsaPublicKey);
        let key = encrypt.encrypt(aesKey);
        return key;
    }
    
    export default {
        init() {
            const crypt = new JSEncrypt();
            return crypt;
        },
        encrypt(string, wrapper = true) {
            const myEncrypt = this.init();
            myEncrypt.setPublicKey(PUBLIC_KEY);
            return wrapper ? myEncrypt.newRsaCrypt(string) : myEncrypt.encrypt(string);
        },
        decrypt(encrypted, placeholder = "") {
            const myEncrypt = this.init();
            myEncrypt.setPrivateKey(PRIVATE_KEY);
            return myEncrypt.decrypt(encrypted) || placeholder;
        },
        /**
         * AES加密
         */
        encryptAES(str) {
            let srcs = CryptoJS.enc.Utf8.parse(str);
            let skeyString = aesKey;
            let ivString = "UTQMNP953UFXXKRG";
            skeyString = CryptoJS.enc.Utf8.parse(skeyString);
            ivString = CryptoJS.enc.Utf8.parse(ivString);
            let encrypted = CryptoJS.AES.encrypt(srcs, skeyString, {
                iv: ivString,
                mode: CryptoJS.mode.CBC,
                padding: CryptoJS.pad.Pkcs7,
            });
            return "START_CMS_RSA" + encrypted.ciphertext.toString(CryptoJS.enc.Base64) + "RSA_CMS_END";
        },
        /**
         * AES解密
         */
        decryptAES(str) {
            let encryptedHexStr = CryptoJS.enc.Base64.parse(str);
            let srcs = CryptoJS.enc.Base64.stringify(encryptedHexStr);
            let skeyString = aesKey;
            let ivString = "UTQMNP953UFXXKRG";
            skeyString = CryptoJS.enc.Utf8.parse(skeyString);
            ivString = CryptoJS.enc.Utf8.parse(ivString);
            let encrypted = CryptoJS.AES.decrypt(srcs, skeyString, {
                iv: ivString,
                mode: CryptoJS.mode.CBC,
                padding: CryptoJS.pad.Pkcs7,
            });
            let decryptedStr = encrypted.toString(CryptoJS.enc.Utf8);
            return decryptedStr.toString();
        },
    
        key,
    };
    

    接口请求中的使用:

    /**
    *
    *
    */
    let headers = {
        decryptKey: JSON.stringify([ // 告诉后端需要解密的接口返回的字段
           "applyUserName",
            "applyUserPhone",
            "applyAddress",
            "imei",
            "userName",
            "userPhone",
         ]),
         "aes-decryptkey": RsaCrypto.key, // 把加密后的AES密钥传过去
     };
    
      let params = {
           ssoid:RsaCrypto.encryptAES(this.ssoId), // 加密的使用
           pageIndex: 1,
           pageSize: 10,
      };
    
      this.$api.sendInRepair.getSirRepair(headers, params).then((res) => {})

    wxmp-rsa的使用链接GitHub - chenyu445/wxmp-rsa: 兼容微信小程序的rsa加解密库,支持超长文本和中文字符

    展开全文
  • 加密和解密使用两个不通的秘钥,(public key和private key)公钥可以给别人私钥总是字节保留。

    1 可逆加密/解密

    1.1 BASE64

      private static  final  String UTF8= StandardCharsets.UTF_8.name();
    
        //base64 加密 = 为补充字节,如果gbk 为3个字节编码, utf8 为4个字节编码
        @Test
         public  void  test1()throws  Exception{
    
            String  word = "刘必君1234";
    
            String encode = Base64.encodeBase64String(word.getBytes(UTF8));
            log.info("加密后的密串: "+ encode);
            // 5YiY5b+F5ZCbMTIzNA==
    
        }
    //     base64 解密
        @Test
        public  void  test2()throws  Exception{
    
            String  word = "5YiY5b+F5ZCbMTIzNA==";
    
            byte[] decode = Base64.decodeBase64(word);
    
            log.info("解密后的密串"+ new String(decode,UTF8));
            //刘必君1234
    
        }
    
    

    2 不可逆加密

    2.1 MD5

      @Test
         public  void  test1()throws  Exception{
          
           private static  final  String UTF8= StandardCharsets.UTF_8.name();
    
            String  word = "刘必君1234";
    //        String algorithm = "MD5";
            String result = DigestUtils.md5Hex(word.getBytes(UTF8));
    
            log.info("算法对象加密结果长度:"+ result.length());
            log.info("算法对象加密结果:"+ result);
    //        64d409fa15a3bc4678f073f9f847f2eb
        }
    

    2.2 SHA256

     private static  final  String UTF8= StandardCharsets.UTF_8.name();
    
    
        @Test
         public  void  test1()throws  Exception{
    
            String  word = "刘必君1234";
    
            String result = DigestUtils.sha256Hex(word.getBytes(UTF8));
    //96cb3e8514fc85ef78a1b0c0ebdb0cb852266c04709719cf18475b07c911f011   64
            log.info("算法对象加密结果长度:"+ result.length());
            log.info("算法对象加密结果:"+ result);
    //        64d409fa15a3bc4678f073f9f847f2eb
        }
    

    2.3 SHA512

     private static  final  String UTF8= StandardCharsets.UTF_8.name();
    
    
        @Test
         public  void  test1()throws  Exception{
    
            String  word = "刘必君1234";
    
            String result = DigestUtils.sha512Hex(word.getBytes(UTF8));
    //b79555568ce9b19a8e4565f0b19ff7f947587b7ca4d03c9df0a18c0b6919d060add6220db510ecbfc271a9db4e5b4bff561f0b7ea48ad0262fe2dab9fa5a27ed   128
            log.info("算法对象加密结果长度:"+ result.length());
            log.info("算法对象加密结果:"+ result);
    //        64d409fa15a3bc4678f073f9f847f2eb
        }
    

    2.4 MAC加密

    mac 加密中使用了盐 ,key

     @Test
         public  void  test1()throws  Exception{
    
            String  word = "刘必君1234";
           String  key = "1231";
            String hmacHex = new HmacUtils(HmacAlgorithms.HMAC_MD5, key).hmacHex(word);
    //        3475e3498e6813d825523cdeadd8e172
            System.out.println(hmacHex);
    
    
    
            String HMAC_SHA_256 = new HmacUtils(HmacAlgorithms.HMAC_SHA_256, key).hmacHex(word);
    //        29d732bdd062173e4bdb4f7d71d6ea6e44ad52d37e19c14cba2f4bf876ded48e
            System.out.println(HMAC_SHA_256);
    
    
            String HMAC_SHA_512 = new HmacUtils(HmacAlgorithms.HMAC_SHA_512, key).hmacHex(word);
    //        792b3be46ff34d878a1ea806d376f3a2e2af58b032e37f21d07421158aabda07ae72ef0b041ebe2e9eb78bb2d5a8b9a7d59d85f869ed4d2b0fca58f68d40aa72
            System.out.println(HMAC_SHA_512);
    
    
        }
    

    3 对称加密解密

    堆成加密解密,只有一个key

    3.1 des加密和解密

    DEC_KEY 长度必须是等于8

    package com.sxfz.word.util;
    
    import org.apache.commons.codec.binary.Base64;
    import org.junit.Test;
    
    import javax.crypto.*;
    import javax.crypto.spec.SecretKeySpec;
    import java.io.UnsupportedEncodingException;
    import java.nio.charset.StandardCharsets;
    import java.security.InvalidKeyException;
    import java.security.NoSuchAlgorithmException;
    
    public class DESUtils {
    
        private static final String ALGORITHM = "DES";
        //DEC_KEY 长度必须是等于8
        private static final String KEY = "12345678";
        private static final String UTF8 = StandardCharsets.UTF_8.name();
    
    
        private String encrypt(String text) throws Exception {
    //      获取实例
            Cipher cilper = Cipher.getInstance(ALGORITHM);
    //      创建 加密的规则
    
            SecretKey secretKey = new SecretKeySpec(KEY.getBytes(UTF8), ALGORITHM);
    //       初始化加解密对象,设置key,和加密规则/解密规则
            cilper.init(Cipher.ENCRYPT_MODE, secretKey);
    //        cilper.init(Cipher.DECRYPT_MODE,secretKey);
    
            byte[] doFinal = cilper.doFinal(text.getBytes(UTF8));
            System.out.println(Base64.encodeBase64String(doFinal));
            return Base64.encodeBase64String(doFinal);
        }
    
        private String dencrypt(String text) throws Exception {
    
    //      获取实例
            Cipher cilper = Cipher.getInstance(ALGORITHM);
    //      创建 加密的规则
    
            SecretKey secretKey = new SecretKeySpec(KEY.getBytes(UTF8), ALGORITHM);
    //       初始化加解密对象,设置key,和加密规则/解密规则
    //        cilper.init(Cipher.ENCRYPT_MODE, secretKey);
            cilper.init(Cipher.DECRYPT_MODE,secretKey);
    
            byte[] doFinal = cilper.doFinal( Base64.decodeBase64(text.getBytes(UTF8)));
            System.out.println(new String(doFinal,UTF8));
            return new String(doFinal,UTF8);
        }
    
    
        @Test
        public void  test() throws  Exception{
            String text = "张三丰的故事123";
            String encrypt = encrypt(text);
            System.out.println("base64加密"+encrypt);
            System.out.println("解密"+dencrypt(encrypt));
        }
    }
    结果:
    
    wtm82GVgSJmS7Rkp1HpiysQwRhamDJMS
    base64加密wtm82GVgSJmS7Rkp1HpiysQwRhamDJMS
    张三丰的故事123
    解密张三丰的故事123
    

    3.2 AES加密和解密

    aes_key 长度可以为:16 24 32;

    package com.sxfz.word.util;
    
    import org.apache.commons.codec.binary.Base64;
    import org.apache.commons.codec.binary.Hex;
    import org.junit.Test;
    
    import javax.crypto.Cipher;
    import javax.crypto.SecretKey;
    import javax.crypto.spec.SecretKeySpec;
    import java.nio.charset.StandardCharsets;
    
    public class AESUtils {
    
        private static final String ALGORITHM = "AES";
        //       int[] AES_KEYSIZES = new int[]{16, 24, 32};  aeskey 长度为16 24 32 三种情况
        private static final String KEY = "1234567121211212";
        private static final String UTF8 = StandardCharsets.UTF_8.name();
    
        /**
         *
         * @param text
         * @return 加密后返回16进制字符串对象
         * @throws Exception
         */
        private String encrypt(String text) throws Exception {
    //      获取实例
            Cipher cilper = Cipher.getInstance(ALGORITHM);
    //      创建 加密的规则
    
            SecretKey secretKey = new SecretKeySpec(KEY.getBytes(UTF8), ALGORITHM);
    //       初始化加解密对象,设置key,和加密规则/解密规则
            cilper.init(Cipher.ENCRYPT_MODE, secretKey);
    //        cilper.init(Cipher.DECRYPT_MODE,secretKey);
    
            byte[] doFinal = cilper.doFinal(text.getBytes(UTF8));
            System.out.println(Base64.encodeBase64String(doFinal));
            return Hex.encodeHexString(doFinal);
        }
    
        /**
         *
         * @param encodetext hex加密字符串
         * @return 返回明文字符串
         * @throws Exception
         */
        private String dencrypt(String encodetext) throws Exception {
    
    //      获取实例
            Cipher cilper = Cipher.getInstance(ALGORITHM);
    //      创建 加密的规则
    
            SecretKey secretKey = new SecretKeySpec(KEY.getBytes(UTF8), ALGORITHM);
    //       初始化加解密对象,设置key,和加密规则/解密规则
    //        cilper.init(Cipher.ENCRYPT_MODE, secretKey);
            cilper.init(Cipher.DECRYPT_MODE,secretKey);
    
            byte[] doFinal = cilper.doFinal( Hex.decodeHex(text));
            System.out.println(new String(doFinal,UTF8));
            return new String(doFinal,UTF8);
        }
    
    
        @Test
        public void  test() throws  Exception{
            String text = "张三丰的故事123";
            String encrypt = encrypt(text);
            System.out.println("HEX加密"+encrypt);
            System.out.println("解密"+dencrypt(encrypt));
        }
    }
    
    jieguo:
    LzcrgFJ6/Sb4poX0HMANb334Eowv6MptsiqAQW9SGxM= base64加密 长度44
    HEX加密2f372b80527afd26f8a685f41cc00d6f7df8128c2fe8ca6db22a80416f521b13 hexString 长度64
    张三丰的故事123
    解密张三丰的故事123
    
    
    

    3.3 优化秘钥

    通过key 生成指定长度的秘钥,通过秘钥然后再获取加密串,最后是用加密串来进行初始化 之前的秘钥

     /**
         *  通过key生成指定长度的可以
         * @param key
         * @return
         */
        private SecretKey generatorKey(String key)throws  Exception{
    //     创建keygenerator对象,可以根据传入的key生成一个指定长度的key
            KeyGenerator keyGenerator =KeyGenerator.getInstance(ALGORITHM);
    //      初始化 secureRandom,并指定生成指定长度key的算法
            SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
    
             secureRandom.setSeed(key.getBytes(UTF8));
             keyGenerator.init(128,secureRandom);
             SecretKey secretKey =keyGenerator.generateKey();
    //         这里是通过秘钥获取,加密串
            byte[] encoded = secretKey.getEncoded();
            System.out.println(Hex.encodeHexString(encoded));
    
            return  secretKey;
        }
    
    
    
        @Test
        public void  test() throws  Exception{
    //        String text = "张三丰的故事123";
    //        String encrypt = encrypt(text);
    //        System.out.println("HEX加密"+encrypt);
    //        System.out.println("解密"+dencrypt(encrypt));
    
    
            generatorKey("123");
        }
    

    3.4 加密分类

    3.4.1 块加密
    • ECB

      定义:electronic code book ,电码本模式,将整个明文分成若干段相同的小段,然后对每一段进行加密

      特点:每段之间互不依赖,可以并行处理;同样的明文总是成成同样的密文

    在这里插入图片描述

    • CBC

      定义:cipher block chanining ,密文分组链模式,所谓的链,即密文分组之间像联调一样相关链接在一起,先将明文切分若干小段,然后每一小段与上一段的密文段(第一个块因每一上一个密文段,使用的是IV)进行运算后,在与秘钥进行加密;

      特点: 串行处理;同样的明文每次生成的密文不一样

      IV:为初始化向量

    在这里插入图片描述

    3.4.2 序列加密

    3.5 块加密常用的填充模式

    为什么要有,对于固定的加密算法,每个块有固定的大小(blocksize),比如8个byte,明文分块后,加密前需要保证最后一个块的大小为8个byte,如果不够则使用特定的数据进行填充;

    • noPadding : 不自动填充

      desc时,要求明文必须是8个字节的整数倍,aes时,是16个字节的整数倍

    • PKCS5Padding(限制了块大小为8个byte的)PKCS7Padding

    • ECB 加密:

    package com.sxfz.word.util;
    
    import com.baomidou.mybatisplus.core.incrementer.IKeyGenerator;
    import org.apache.commons.codec.binary.Base64;
    import org.apache.commons.codec.binary.Hex;
    import org.junit.Test;
    
    import javax.crypto.Cipher;
    import javax.crypto.KeyGenerator;
    import javax.crypto.SecretKey;
    import javax.crypto.spec.SecretKeySpec;
    import java.nio.charset.StandardCharsets;
    import java.security.SecureRandom;
    
    public class AESUtils {
    
        private static final String ALGORITHM = "AES/ECB/PKCS5Padding";
        private static final String ALGORITHM_TYPE = "AES";
    //       int[] AES_KEYSIZES = new int[]{16, 24, 32};  aeskey 长度为16 24 32 三种情况
        private static final String KEY = "1234567121211211";
        private static final String UTF8 = StandardCharsets.UTF_8.name();
    
        /**
         *
         * @param text
         * @return 加密后返回16进制字符串对象
         * @throws Exception
         */
        private String encrypt(String text) throws Exception {
    //      获取实例
            Cipher cilper = Cipher.getInstance(ALGORITHM);
    //      创建 加密的规则
    
            SecretKey secretKey = new SecretKeySpec(KEY.getBytes(UTF8), ALGORITHM_TYPE);
    //       初始化加解密对象,设置key,和加密规则/解密规则
            cilper.init(Cipher.ENCRYPT_MODE, secretKey);
    //        cilper.init(Cipher.DECRYPT_MODE,secretKey);
    
            byte[] doFinal = cilper.doFinal(text.getBytes(UTF8));
            System.out.println(Base64.encodeBase64String(doFinal));
            return Hex.encodeHexString(doFinal);
        }
    
        /**
         *
         * @param encodetext hex加密字符串
         * @return 返回明文字符串
         * @throws Exception
         */
        private String dencrypt(String encodetext) throws Exception {
    
    //      获取实例
            Cipher cilper = Cipher.getInstance(ALGORITHM);
    //      创建 加密的规则
    
            SecretKey secretKey = new SecretKeySpec(KEY.getBytes(UTF8), ALGORITHM_TYPE);
    //       初始化加解密对象,设置key,和加密规则/解密规则
    //        cilper.init(Cipher.ENCRYPT_MODE, secretKey);
            cilper.init(Cipher.DECRYPT_MODE,secretKey);
    
            byte[] doFinal = cilper.doFinal( Hex.decodeHex(encodetext));
            System.out.println(new String(doFinal,UTF8));
            return new String(doFinal,UTF8);
        }
    
      
    
    
        @Test
        public void  test() throws  Exception{
            String text = "张三丰的故事123";
            String encrypt = encrypt(text);
            System.out.println("HEX加密"+encrypt);
            System.out.println("解密"+dencrypt(encrypt));
    
    
    
        }
    }
    
    
    • cbc 加密机制
    package com.sxfz.word.util;
    
    import com.baomidou.mybatisplus.core.incrementer.IKeyGenerator;
    import org.apache.commons.codec.binary.Base64;
    import org.apache.commons.codec.binary.Hex;
    import org.junit.Test;
    
    import javax.crypto.Cipher;
    import javax.crypto.KeyGenerator;
    import javax.crypto.SecretKey;
    import javax.crypto.spec.IvParameterSpec;
    import javax.crypto.spec.SecretKeySpec;
    import java.nio.charset.StandardCharsets;
    import java.security.SecureRandom;
    
    public class AESUtils {
    
        private static final String ALGORITHM = "AES/ECB/PKCS5Padding";
        private static final String ALGORITHM_CBC = "AES/CBC/PKCS5Padding";
        private static final String ALGORITHM_TYPE = "AES";
    //       int[] AES_KEYSIZES = new int[]{16, 24, 32};  aeskey 长度为16 24 32 三种情况
        private static final String KEY = "1234567121211211";
    //    IV 的默认长度为16个字节
        private static final String IV = "abcdefgh12345678";
        private static final String UTF8 = StandardCharsets.UTF_8.name();
    
        /**
         *
         * @param text
         * @return 加密后返回16进制字符串对象
         * @throws Exception
         */
        private String encrypt(String text) throws Exception {
    //      获取实例
            Cipher cilper = Cipher.getInstance(ALGORITHM_CBC);
    //      创建 加密的规则
    
            SecretKey secretKey = new SecretKeySpec(KEY.getBytes(UTF8), ALGORITHM_TYPE);
    //       初始化加解密对象,设置key,和加密规则/解密规则
            IvParameterSpec ivParameterSpec = new IvParameterSpec(IV.getBytes(UTF8));
    //        cilper.init(Cipher.DECRYPT_MODE,secretKey);
            cilper.init(Cipher.ENCRYPT_MODE,secretKey,ivParameterSpec);
    //        cilper.init(Cipher.DECRYPT_MODE,secretKey);
    
            byte[] doFinal = cilper.doFinal(text.getBytes(UTF8));
    
            return Hex.encodeHexString(doFinal);
        }
    
        /**
         *
         * @param encodetext hex加密字符串
         * @return 返回明文字符串
         * @throws Exception
         */
        private String dencrypt(String encodetext) throws Exception {
    
    //      获取实例
            Cipher cilper = Cipher.getInstance(ALGORITHM_CBC);
    //      创建 加密的规则
    
            SecretKey secretKey = new SecretKeySpec(KEY.getBytes(UTF8), ALGORITHM_TYPE);
    //       初始化加解密对象,设置key,和加密规则/解密规则
    //        cilper.init(Cipher.ENCRYPT_MODE, secretKey);
            IvParameterSpec ivParameterSpec = new IvParameterSpec(IV.getBytes(UTF8));
    //        cilper.init(Cipher.DECRYPT_MODE,secretKey);
            cilper.init(Cipher.DECRYPT_MODE,secretKey,ivParameterSpec);
    
            byte[] doFinal = cilper.doFinal( Hex.decodeHex(encodetext));
            System.out.println(new String(doFinal,UTF8));
            return new String(doFinal,UTF8);
        }
    
        /**
         *  通过key生成指定长度的可以
         * @param key
         * @return
         */
        private SecretKey generatorKey(String key)throws  Exception{
    //     创建keygenerator对象,可以根据传入的key生成一个指定长度的key
            KeyGenerator keyGenerator =KeyGenerator.getInstance(ALGORITHM);
    //      初始化 secureRandom,并指定生成指定长度key的算法
            SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
    
             secureRandom.setSeed(key.getBytes(UTF8));
             keyGenerator.init(128,secureRandom);
             SecretKey secretKey =keyGenerator.generateKey();
    //         这里是通过秘钥获取,加密串
            byte[] encoded = secretKey.getEncoded();
            System.out.println(Hex.encodeHexString(encoded));
    
            return  secretKey;
        }
    
    
    
        @Test
        public void  test() throws  Exception{
            String text = "我是超人我怕谁,212123";
            String encrypt = encrypt(text);
            System.out.println("HEX加密"+encrypt);
            System.out.println("解密"+dencrypt(encrypt));
    
    
    //        generatorKey("123");
        }
    }
    

    4 非对称加密

    4.1 定义

    加密和解密使用两个不通的秘钥,(public key和private key)公钥可以给别人私钥总是字节保留。

    4.2 为什么会出现

    对称加密使用相同的秘钥,但对不同的原始内容加密会采用不同的秘钥,导致秘钥数量巨大,难以维护。

    4.3 常见算法

    • RSA
    • 其他:ECC , Diffe-Hellman, EI Gamal ,DSA

    5.3 应用场景

    • 加解密

      可以使用公钥加密,对应的就是私钥解密;也可以使用私钥加密,对应的是公钥解密;

    package com.sxfz.word.util;
    
    import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.codec.binary.Base64;
    import org.apache.commons.io.FileUtils;
    import org.junit.Test;
    
    
    import javax.crypto.Cipher;
    import java.io.ByteArrayOutputStream;
    import java.io.File;
    import java.nio.charset.StandardCharsets;
    import java.security.*;
    import java.security.spec.PKCS8EncodedKeySpec;
    import java.security.spec.X509EncodedKeySpec;
    
    /**
     * RAS 加密解密工具类
     */
    @Slf4j
    public class RsaUtils {
    
        private static final String ALGORITHM = "RSA";
        private static final String UTF8 = StandardCharsets.UTF_8.name();
    //  单次加密长度最大为117
        private static final int MAX_ENCODE_LENGTH = 117;
        //  单次解密长度最大为128
        private static final int MAX_DECODE_LENGTH = 128;
    
    
        private static String publicKeyPath;
        private static String privateKeyPath;
    
    
        static {
            ClassLoader classLoader = RsaUtils.class.getClassLoader();
            publicKeyPath = classLoader.getResource("rsa.pub").getPath();
            privateKeyPath = classLoader.getResource("rsa.pri").getPath();
    
            log.info("publicKeyPath"+publicKeyPath);
            log.info("privateKeyPath"+privateKeyPath);
        }
    
        /**
         * 生成经过base64加密(公钥/私钥),并写入到文件中
         */
        private void writeRsaKey2File()throws  Exception{
    
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(ALGORITHM);
            keyPairGenerator.initialize(1024);
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
    
            PrivateKey privateKey = keyPair.getPrivate();
            PublicKey publicKey = keyPair.getPublic();
    
            FileUtils.writeStringToFile(new File(publicKeyPath),Base64.encodeBase64String(publicKey.getEncoded()),UTF8);
            FileUtils.writeStringToFile(new File(privateKeyPath),Base64.encodeBase64String(privateKey.getEncoded()),UTF8);
    
    
        }
    
    
    
        /**
         *  从生成好的文件中获取公钥
         *  公钥和私钥保存在文件中是使用base64的方式进行编码的,所以第一步需要进行base64解码
         *   公钥使用规则 X509EncodedKeySpec
         *   私钥使用规则  PKCS8EncodedKeySpec
         * @return
         */
        private PublicKey getPublicKey()throws  Exception{
            String endcodeBase64 = FileUtils.readFileToString(new File(publicKeyPath), UTF8);
            byte[] publicKeyBytes = Base64.decodeBase64(endcodeBase64);
            KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
    //      公钥使用规则x509
            X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(publicKeyBytes);
            return keyFactory.generatePublic(x509EncodedKeySpec);
    
        }
    
        /**
         *  从生成好的文件中获取私钥
         *  公钥和私钥保存在文件中是使用base64的方式进行编码的,所以第一步需要进行base64解码
         *   公钥使用规则x509
         *       私钥使用规则  PKCS8EncodedKeySpec
         * @return
         */
        private PrivateKey getPrivateKey()throws  Exception{
            String endcodeBase64 = FileUtils.readFileToString(new File(privateKeyPath), UTF8);
            byte[] privateKeyBytes = Base64.decodeBase64(endcodeBase64);
            KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
    //       私钥使用规则  PKCS8EncodedKeySpec
            PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(privateKeyBytes);
            return keyFactory.generatePrivate(pkcs8EncodedKeySpec);
        }
    
        @Test
        public void test1()throws  Exception{
    //        生成秘钥对  生成一次后保存下来,不要乱折腾
    //        writeRsaKey2File();
            String  text = "搜晚上我是超人,我怕谁12132l;搜晚上我是超人,我怕谁12132l;搜晚上我是超人,我怕谁12132l;搜晚上我是超人,我怕谁12132l;搜晚上我是超人,我怕谁12132l;搜晚上我是超人,我怕谁12132l;搜晚上我是超人,我怕谁12132l;搜晚上我是超人,我怕谁12132l;搜晚上我是超人,我怕谁12132l;搜晚上我是超人,我怕谁12132l;";
            System.out.println(" ------------------公钥加密,私钥解密-------------------------------");
            String encryptStr = encrypt(text, getPublicKey());
            System.out.println(encryptStr);
            String decryptStr = decrypt(encryptStr, getPrivateKey());
            System.out.println(decryptStr);
            System.out.println(" ------------------私钥加密,公钥解密-------------------------------");
    
             encryptStr = encrypt(text,getPrivateKey());
            System.out.println(encryptStr);
             decryptStr = decrypt(encryptStr,getPublicKey());
            System.out.println(decryptStr);
    
    
    
    
        }
    
    
        /**
         *  加密类
         * @param originalContent 要加密的明文
         * @param key 公钥或者私钥
         * @return Base64 加密后的字符串
         */
        private String encrypt(String originalContent, Key key) throws  Exception{
    
    
            Cipher cipher = Cipher.getInstance(ALGORITHM);
            cipher.init(Cipher.ENCRYPT_MODE,key);
    
            byte []  bytes = doCodec(cipher,originalContent.getBytes(UTF8),MAX_ENCODE_LENGTH);
    
            return Base64.encodeBase64String(bytes);
    
        }
    
    
    
        /**
         *  解密类
         * @param base64EncodeContent base64加密后的密文
         * @param key 公钥或者私钥
         * @return 原始内容
         */
        private String decrypt(String base64EncodeContent, Key key) throws  Exception{
    
            byte[] decodeBase64 = Base64.decodeBase64(base64EncodeContent);
    
            Cipher cipher = Cipher.getInstance(ALGORITHM);
            cipher.init(Cipher.DECRYPT_MODE,key);
    
            byte []  bytes = doCodec(cipher,decodeBase64,MAX_DECODE_LENGTH);
    
            return  new String(bytes,UTF8);
    
        }
    
        /**
         *   加密/解密的公共方法
         * @param cipher 加密或者解密
         * @param bytes 明文/密文
         * @param maxBlockSize 处理的最大长度
         * @return  返回密文或者明文
         * @throws Exception
         */
        private byte[] doCodec(Cipher cipher, byte[] bytes, int maxBlockSize) throws Exception{
    //       偏移量
            int offset = 0;
    
    //       循环成次数
            int count = 0 ;
    //      加密/解密后的结果
            byte []  temp;
    //      加密/解密的总结果
            ByteArrayOutputStream  bos = new ByteArrayOutputStream();
    
    //        输入的字符串长度
            int inputLength = bytes.length;
    
    
            while ((inputLength - offset)>0){
    
                if((inputLength - offset)>maxBlockSize){
                temp =  cipher.doFinal(bytes,offset,maxBlockSize);
                }else {
    
                  temp =  cipher.doFinal(bytes,offset,inputLength - offset);
                }
                bos.write(temp,0,temp.length);
                count ++;
                offset = maxBlockSize*count;
    
            }
    
    
            byte[] result = bos.toByteArray();
            bos.close();
    
            return  result;
        }
    
    }
    
    
    • 数字签名
    • 数字信封
    • 数字证书
    展开全文
  • AES+RSA加密

    2021-03-12 14:02:51
    AES+RSA加密 一、说明 加密算法分 对称加密、非对称加密、散列。其中对称加密算法的的密钥相同;非对称加密算法的加密密钥与解密的密钥不同;散列算法不需要密钥 常见的对称加密算法主要有DES、3DES、AES...,...
  • 一、AESRSA 1、对称加密和非对称加密简介 目前常见的加密方式是有两种,一种是对称加密(AES为代表),一种是非对称加密(RSA为代表)。 对称加密只有一个秘钥,加密和解密都是用同一个秘钥,所以叫做对称...
  • DES,AESRSA,MD5加密

    2018-12-07 18:11:34
    支持 DES,AESRSA,MD5加密,工具类,导入即用。欢迎下载
  • 这是我的密码学项目,比较简单,实现了DES,AES,RSA。拿java做了简单的可视化界面。代码也是拿java实现的。没有调用java的security包。注释不怎么样。但是可以直接运行。略微有点小bug。
  • 浅析AESRSA的区别

    2021-12-12 19:34:44
    信息数据传输的安全一直都是个很重要的话题,从刚开始当程序员时错以为MD5、SHA1这些哈希算法就是加密算法,到后来慢慢接触对称加密、非对称加密这些概念,再到对接各种大开发平台接口的时候看到他们通过 RSA 进行...
  • RSAAES的区别

    千次阅读 2021-12-07 14:48:30
    由于,RSA加解密速度慢,不适合大量数据文件加密,而AES加密速度很快,所有,中合起来就是:(AES+RSA)使用AES对称密码体制 对传输数据加密,同时使用RSA不对称密码体制 来传送AES的密钥–AES传递数据,RSA传递AES...
  • #资源达人分享计划#
  • AESRSA加密

    千次阅读 2019-07-03 18:52:13
    AES加密是一种对称式加密,即加密和解密所需秘钥是相同的,你可以生成一组秘钥,然后利用该秘钥加密...同时,相比RSA加密来说,好处是不会限制加密字符串的长度。 下面贴出AES加密代码 package dev.parking.u...
  • AES+RSA加密及解密

    千次阅读 2018-11-02 14:45:23
    RSA+AES
  • rsa+aes加密

    2021-11-30 10:42:55
    AES+RSA=数据加密方案: 流程: 接收方创建RSA秘钥对, 发送RSA公钥给发送方,自己保留RSA私钥 发送方创建AES密钥,加密待传送的明文,之后用RSA公钥加密该密钥, RSA公钥加密AES的密钥+AES密钥加密明文的密文----...
  • RSA+AES混合加密-JavaWeb

    千次阅读 2021-05-06 11:36:11
    RSA+AES的混合加密时,AES用于给传输的数据加密,然后通过RSAAES的秘钥加密,所以接收到数据后,就需要先解密得到AES的秘钥,然后通过AES秘钥再去解密得到数据。 下面简单说下demo中加密解密的
  • Java实现AESRSA算法

    2020-11-27 16:17:31
    说明: 本文是用 Java1.8 官方的工具类进行...AES:https://blog.csdn.net/gulang03/article/details/81175854 RSA:https://blog.csdn.net/gulang03/article/details/81176133 实现类: AESUtil: package com.fknight
  • AESRSA混合加密完整实例

    千次阅读 2020-09-05 20:20:16
    前段时间看到一篇文章讲如何保证API调用时数据的安全性(传送门:https://blog.csdn.net/ityouknow/article/details/80603617),文中讲到利用RSA来加密传输AES的秘钥,用AES来加密数据,并提供如下思路: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 44,772
精华内容 17,908
关键字:

aes rsa