接口安全加密传输(对称加密与非对称加密)

ゝ一纸荒年。 2022-01-28 13:34 517阅读 0赞

# [接口安全加密传输(对称加密与非对称加密)][Link 1] #

URL特殊字符转码

对称加密与非对称加密

DES RSA加密原理

移动APP接口安全加密设计

基于令牌方式实现接口参数安全传输

验签 单向加密

**URL转码：**

不管是以何种方式传递url时，如果要传递的url中包含特殊字符，如想要传递一个+，但是这个+会被url会被编码成空格，想要传递&，被url处理成分隔符。

尤其是当传递的url是经过Base64加密或者RSA加密后的，存在特殊字符时，这里的特殊字符一旦被url处理，就不是原先你加密的结果了。

url特殊符号及对应的编码:

<table> 
 <thead> 
 <tr> 
 <td> 符号 </td> 
 <td> url中的含义 </td> 
 <td> 编码 </td> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td> + </td> 
 <td> URL 中+号表示空格 </td> 
 <td> %2B </td> 
 </tr> 
 <tr> 
 <td> 空格 </td> 
 <td> URL中的空格可以用+号或者编码 </td> 
 <td> %20 </td> 
 </tr> 
 <tr> 
 <td> / </td> 
 <td> 分隔目录和子目录 </td> 
 <td> %2F </td> 
 </tr> 
 <tr> 
 <td> ? &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; </td> 
 <td> 分隔实际的URL和参数 </td> 
 <td> %3F </td> 
 </tr> 
 <tr> 
 <td> % </td> 
 <td> 指定特殊字符 </td> 
 <td> %25 </td> 
 </tr> 
 <tr> 
 <td> # </td> 
 <td> 表示书签 </td> 
 <td> %23 </td> 
 </tr> 
 <tr> 
 <td> &amp; </td> 
 <td> URL中指定的参数间的分隔符 </td> 
 <td> %26 </td> 
 </tr> 
 <tr> 
 <td> = </td> 
 <td> URL中指定参数的值 </td> 
 <td> %3D </td> 
 </tr> 
 </tbody> 
</table>

rpc远程通讯 实现加密有一些特殊字符  正好和http协议特殊字符形同 导致转成空格

localhost:8080/userName=1+1  这样的就接收到的是 1 1  空格代替了！

Java中提供了HTTP特殊字符转码

String url = "http://127.0.0.1:8080/tranIndex?";
            // 参数转码
            String strParam = "name=" + URLEncoder.encode("1+1", "utf-8");
            String newUrl = url + strParam;
            String result = HttpClientUtils.httpGet(newUrl);
            System.out.println("result:" + result);

转码： URLEncoder.encode

解码： URLecoder.decoder

对称加密和非对称加密：

防止别人抓包分析HTTP请求 篡改数据

对称加密：

加密和解密都是同一个密钥。才加解密过程当中，使用同一个密钥。

![1179709-20190125161553721-1941447836.png][]

客户端加密  服务器端解密  使用的是同一个密钥

抓包抓到的是 加密后的名问数据

对称加密： 加密解密都是同一个密钥。加密过程中，使用同一个密钥。

对称加密速度快

服务器端与服务器端进行通信（后台与后台通讯）

比如： 构建网站与机构网站进行合作的情况可以使用对称加密（同一个网段里面 抓包分析抓不到包）

密钥是长度8的倍数

密码不可能使用对称加密 别人可以反向获取  密码使用单向加密  不可以被逆向破解   密码使用MD5加密 再加盐

## 信息加密与密钥管理 ##

### 单向散列加密 ###

散列是信息的提炼，通常其长度要比信息小得多，且为一个固定长度。加密性强的散列一定是不可逆的，这就意味着通过散列结果，无法推出任何部分的原始信息。任何输入信息的变化，哪怕仅一位，都将导致散列结果的明显变化，这称之为雪崩效应。散列还应该是防冲突的，即找不出具有相同散列结果的两条信息。具有这些特性的散列结果就可以用于验证信息是否被修改。  
单向散列函数一般用于产生消息摘要，密钥加密等，常见的有：  
1、MD5（Message Digest Algorithm 5）：是RSA数据安全公司开发的一种单向散列算法，非可逆，相同的明文产生相同的密文。  
2、SHA（Secure Hash Algorithm）：可以对任意长度的数据运算生成一个160位的数值；  
SHA-1与MD5的比较  
因为二者均由MD4导出，SHA-1和MD5彼此很相似。相应的，他们的强度和其他特性也是相似，但还有以下几点不同：  
1、对强行供给的安全性：最显著和最重要的区别是SHA-1摘要比MD5摘要长32 位。使用强行技术，产生任何一个报文使其摘要等于给定报摘要的难度对MD5是2128数量级的操作，而对SHA-1则是2160数量级的操作。这样，SHA-1对强行攻击有更大的强度。  
2、对密码分析的安全性：由于MD5的设计，易受密码分析的攻击，SHA-1显得不易受这样的攻击。  
3、速度：在相同的硬件上，SHA-1的运行速度比MD5慢。

1、特征：雪崩效应、定长输出和不可逆。  
2、作用是：确保数据的完整性。  
3、加密算法：md5（标准密钥长度128位）、sha1（标准密钥长度160位）、md4、CRC-32  
4、加密工具：md5sum、sha1sum、openssl dgst。  
5、计算某个文件的hash值，例如：md5sum/shalsum FileName,openssl dgst –md5/-sha

#### MD5加密 ####

##### 在线MD5解密与加密 #####

[http://www.cmd5.com/][http_www.cmd5.com]

##### Java操作MD5加密 #####

##### MD5加盐实现方式 #####

一般使用的加盐：

md5(Password+UserName)，即将用户名和密码字符串相加再MD5，这样的MD5摘要基本上不可反查。

但有时候用户名可能会发生变化，发生变化后密码即不可用了（验证密码实际上就是再次计算摘要的过程）。

\----------

因此我们做了一个非常简单的加盐算法，每次保存密码到数据库时，都生成一个随机16位数字，将这16位数字和密码相加再求MD5摘要，然后在摘要中再将这16位数字按规则掺入形成一个48位的字符串。

在验证密码时再从48位字符串中按规则提取16位数字，和用户输入的密码相加再MD5。按照这种方法形成的结果肯定是不可直接反查的，且同一个密码每次保存时形成的摘要也都是不同的。

### 信息加密技术 ###

#### 对称加密 ####

对称密码技术：发件人和收件人使用其共同拥有的单个密钥 ,这种密钥既用于加密，也用于解密，叫做机密密钥(也称为对称密钥或会话密钥)。

能够提供信息机密性（没有密钥信息不能被解密）、完整性（被改变的信息不能被解密）的服务。

对称式密码学又称：单钥密码学、秘密密钥密码学、会话密钥密码学、私钥密码学、共享秘钥密码学

##### 常见的对称式加密技术 #####

DES（数据加密标准）：分组式加密，算法源于Lucifer，作为NIST对称式加密标准；64位（有效位56位、校验8位），分组算法

3DES：128位，分组算法

IDEA（国际数据加密算法）：128位，比DES快，分组算法

Blowfish：32-448位，算法公开，分组算法

RC4：流密码，密钥长度可变

RC5：分组密码，密钥长度可变，最大2048位

Rijndael：128位/196位/256位

AES（高级加密标准）：DES升级版，算法出自Rinjindael

##### 对称密码的优点 #####

用户只需记忆一个密钥，就可用于加密、解密；

与非对称加密方法相比，加密解密的计算量小，速度快，简单易用，适合于对海量数据进行加密处理 。

##### 对称密码的缺点 #####

如果密钥交换不安全，密钥的安全性就会丧失。特别是在电子商务环境下，当客户是未知的、不可信的实体时，如何使客户安全地获得密钥就成为一大难题。

如果用户较多情况下的密钥管理问题。N\*(N-1)/2

如果密钥多个用户被共享，不能提供抗抵赖性

##### 对称密码案例 #####

假设Alice和Bob是认识的，两人为了保证通信消息不被其它人截取，预先约定了一个密码，用来加密在他们之间传送的消息，这样即使有人截取了消息没有密码也无法知道消息的内容。由此便实现了机密性

![1179709-20190125163213109-1997476568.png][]

##### 基于DES实现加密和解密 #####

###### DES加密工具类 ######

DES加密介绍 DES是一种对称加密算法，所谓对称加密算法即：加密和解密使用相同密钥的算法。DES加密算法出自IBM的研究，后来被美国政府正式采用，之后开始广泛流传，但是近些年使用越来越少，因为DES使用56位密钥，以现代计算能力，24小时内即可被破解。虽然如此，在某些简单应用中，我们还是可以使用DES加密算法，本文简单讲解DES的JAVA实现 。注意：DES加密和解密过程中，密钥长度都必须是8的倍数

保证密钥相同

public static void main(String args[]) {
            // 待加密内容
            String str = "cryptology";
            // 密码，长度要是8的倍数
            String password = "95880288";
    
            byte[] result = DES.encrypt(str.getBytes(), password);
            System.out.println("加密后：" + new String(result));
            // 直接将如上内容解密
            try {
                byte[] decryResult = DES.decrypt(result, password);
                System.out.println("解密后：" + new String(decryResult));
            } catch (Exception e1) {
                e1.printStackTrace();
            }
        }

对称加密优缺点：

反编译出密钥来 就完蛋了    同一个密钥

对称加密的使用场景 服务器端与服务器端进行加密 比较好一些  没法用抓包

#### 非对称加密 ####

使用一对密钥：一个用于加密信息，另一个则用于解密信息。

两个密钥之间存在着相互依存关系：即用其中任一个密钥加密的信息只能用另一个密钥进行解密。

其中加密密钥不同于解密密钥,公钥加密私钥解密，反之也可私钥加密公钥解密。

密钥依据性质划分，将其中的一个向外界公开，称为公钥；另一个则自己保留，称为私钥。公钥(Public key)常用于数据加密（用对方公钥加密）或签名验证（用对方公钥解密），私钥(Private key)常用于数据解密（发送方用接收方公钥加密）或数字签名（用自己私钥加密）。

机密性、完整性、抗抵赖性

![1179709-20190125182508372-346362562.png][]

1.使用过程：

乙方生成两把密钥（公钥和私钥）

甲方获取乙方的公钥，然后用它对信息加密。

乙方得到加密后的信息，用私钥解密，乙方也可用私钥加密字符串

甲方获取乙方私钥加密数据，用公钥解密

优点：难破解

缺点: 加密速度慢

常用算法：

RSA、Elgamal、背包算法、Rabin、D-H、ECC（椭圆曲线加密算法)

移动APP接口安全 （HTTPs传输，使用令牌，使用非对称加密）

对称加密的话 对称加密情况下 密钥都是相同的 反编译移动打包apk

既然移动app端不能用对称加密，用非对称加密

非对称加密。 私钥（不公开）和公钥（公开）

首先非对称加密，是一对密钥（必须组合公钥和密钥进行组合）

1，使用第三方工具生成非对称加密

2，如果使用公钥加密，必须使用私钥解密

如果使用私钥加密， 那么必须要使用公钥解密。

安全但是效率低，应用场景： 支付宝 第三方支付对接

![1179709-20190125183935589-1556572847.png][]

移动APP             服务器端

公钥加密 私钥解密！

移动App端使用公钥加密  移动app客户端保存公钥        app使用公钥加密        服务器端保存私钥  服务器端使用私钥进行保密   私钥在服务器端很给力的 黑客获取不到

app和服务器 有个约定   生成一堆非对称密钥对 服务器端保存私钥  客户端保存公钥

公钥A 私钥B

公钥1 公钥2

必须成对的才可以解密！

RSA加密：

实际过程中，开发人员先把公钥私钥生成好。服务器端保存私钥，公钥发给客户端。

生成公钥和私：

/**
         * 生成公钥和私钥
         */
        public static void generateKey() {
            // 1.初始化秘钥
            KeyPairGenerator keyPairGenerator;
            try {
                keyPairGenerator = KeyPairGenerator.getInstance("RSA");
                SecureRandom sr = new SecureRandom(); // 随机数生成器
                keyPairGenerator.initialize(512, sr); // 设置512位长的秘钥
                KeyPair keyPair = keyPairGenerator.generateKeyPair(); // 开始创建
                RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
                RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
                // 进行转码
                publicKey = Base64.encodeBase64String(rsaPublicKey.getEncoded());
                // 进行转码
                privateKey = Base64.encodeBase64String(rsaPrivateKey.getEncoded());
            } catch (NoSuchAlgorithmException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

测试：

import javax.crypto.Cipher;
    
    
    public class Test001 {
    
        public static void main(String[] args) {
    
            // 实现步骤：
            // 1.生成公钥和私钥密钥对
            RSAUtil.generateKey();
            System.out.println("私钥:" + RSAUtil.privateKey);
            System.out.println("公钥:" + RSAUtil.publicKey);
            String content = "toov5comeon";
            System.out.println("加密前:"+content);
            // 2.使用公钥进行加密
            String encryptByPublicKey = RSAUtil.encryptByPublicKey(content, RSAUtil.publicKey, Cipher.ENCRYPT_MODE); //最后一个参数表示进行加密     返回加密后的结果 
            System.out.println("加密后:" + encryptByPublicKey);
            String encryptByprivateKey = RSAUtil.encryptByprivateKey(encryptByPublicKey, RSAUtil.privateKey,
                    Cipher.DECRYPT_MODE);
            // 3.使用私钥进行解密
            System.out.println("解密后:" + encryptByprivateKey);
            // 正常在开发中的时候,后端开发人员生成好密钥对，服务器端保存私钥 客户端保存公钥
    
        }
    
    }

![1179709-20190125185938902-1093922011.png][]

注意了 这可是有加号的  在RPC远程调用时候 可能这种特殊字符会被转换了哦 特殊字符处理

防止抓包篡改数据：

基于令牌的方式实现参数安全传输：

A (主站)    B（支付）

在跳转支付系统之前生成参数令牌

A调用B 支付系统生成令牌参数，返回参数令牌。

A跳转到B使用令牌方式跳转

支付系统接收令牌参数获取对应的userId和全额参数

访问时候，携带moeny userId ，服务器获取到然后生成token，并存入到redis（实际是存在数据库中） 中 key为token  value为money  userId

调用支付时候 携带 token，服务器端通过token去查询出money userid 进行操作

核心代码：

import java.util.UUID;
    
    import org.apache.commons.lang.StringUtils;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import com.fasterxml.jackson.databind.deser.Deserializers.Base;
    import com.itmayiedu.base.BaseApiService;
    import com.itmayiedu.base.BaseRedisService;
    import com.itmayiedu.base.ResponseBase;
    
    @RestController
    public class PayController extends BaseApiService {
        @Autowired
        private BaseRedisService baseRedisService;
    
        private static final Long TOKENTIME = (long) (30 * 60);
    
        // 先获取参数接口,返回令牌
        // 使用令牌传递参数 (不是前端调用是服务器调用)
        @RequestMapping("/getPayToken")
        public String getPayToken(Long userId, Long money) {
            // 生成令牌  令牌是随便生成的
            String payToken = UUID.randomUUID().toString();
            // 存放在redis中
            baseRedisService.setString(payToken, userId + "---" + money, TOKENTIME);
            return payToken;
        }
    
        @RequestMapping("/pay")
        public ResponseBase pay(String payToken) {  //进行支付时候 就传递上次生成的token就好了 
            if (StringUtils.isEmpty(payToken)) {
                return setResultError("token 不能为空!");
            }
            String result = (String) baseRedisService.getString(payToken);
            if (StringUtils.isEmpty(result)) {
                return setResultError("参数不能为空!");
            }
            // 直接处理操作数据库
            return setResultSuccessData(result);
        }
    
    }

辅助代码：

Base:

import org.springframework.stereotype.Component;
    
    import com.itmayiedu.utils.Constants;
    
    @Component
    public class BaseApiService {
    
        public ResponseBase setResultError(Integer code, String msg) {
            return setResult(code, msg, null);
        }
    
        // 返回错误，可以传msg
        public ResponseBase setResultError(String msg) {
            return setResult(Constants.HTTP_RES_CODE_500, msg, null);
        }
    
        // 返回成功，可以传data值
        public ResponseBase setResultSuccessData(Object data) {
            return setResult(Constants.HTTP_RES_CODE_200, Constants.HTTP_RES_CODE_200_VALUE, data);
        }
    
        public ResponseBase setResultSuccessData(Integer code, Object data) {
            return setResult(code, Constants.HTTP_RES_CODE_200_VALUE, data);
        }
    
        // 返回成功，沒有data值
        public ResponseBase setResultSuccess() {
            return setResult(Constants.HTTP_RES_CODE_200, Constants.HTTP_RES_CODE_200_VALUE, null);
        }
    
        // 返回成功，沒有data值
        public ResponseBase setResultSuccess(String msg) {
            return setResult(Constants.HTTP_RES_CODE_200, msg, null);
        }
    
        // 通用封装
        public ResponseBase setResult(Integer code, String msg, Object data) {
            return new ResponseBase(code, msg, data);
        }
    
    }

redis:

import java.util.concurrent.TimeUnit;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.StringRedisTemplate;
    import org.springframework.stereotype.Component;
    
    @Component
    public class BaseRedisService {
    
        @Autowired
        private StringRedisTemplate stringRedisTemplate;
    
        public void setString(String key, Object data, Long timeout) {
            if (data instanceof String) {
                String value = (String) data;
                stringRedisTemplate.opsForValue().set(key, value);
            }
            if (timeout != null) {
                stringRedisTemplate.expire(key, timeout, TimeUnit.SECONDS);
            }
        }
    
        public Object getString(String key) {
            return stringRedisTemplate.opsForValue().get(key);
        }
    
        public void delKey(String key) {
            stringRedisTemplate.delete(key);
        }
    
    }

response:

import lombok.Getter;
    import lombok.Setter;
    import lombok.extern.slf4j.Slf4j;
    
    @Getter
    @Setter
    @Slf4j
    public class ResponseBase {
    
        private Integer rtnCode;
        private String msg;
        private Object data;
    
        public ResponseBase() {
    
        }
    
        public ResponseBase(Integer rtnCode, String msg, Object data) {
            super();
            this.rtnCode = rtnCode;
            this.msg = msg;
            this.data = data;
        }
    
        public static void main(String[] args) {
            ResponseBase responseBase = new ResponseBase();
            responseBase.setData("123456");
            responseBase.setMsg("success");
            responseBase.setRtnCode(200);
            System.out.println(responseBase.toString());
            log.info("itmayiedu...");
        }
    
        @Override
        public String toString() {
            return "ResponseBase [rtnCode=" + rtnCode + ", msg=" + msg + ", data=" + data + "]";
        }
    
    }

posted @ 2019-01-25 19:42 [toov5][] 阅读( ...) 评论( ...) [编辑][Link 2] 收藏

[Link 1]: https://www.cnblogs.com/toov5/p/10321364.html
[1179709-20190125161553721-1941447836.png]: /images/20220128/9630ccea76694d2b99108c66d8d2c6bf.png
[http_www.cmd5.com]: http://www.cmd5.com/
[1179709-20190125163213109-1997476568.png]: /images/20220128/745b9da4248943b6957516dbfdbcfb48.png
[1179709-20190125182508372-346362562.png]: /images/20220128/df3c79e2b3654cd885bb1f2efdfba696.png
[1179709-20190125183935589-1556572847.png]: /images/20220128/84c42677c9de4fc094884bb9078cb8b0.png
[1179709-20190125185938902-1093922011.png]: /images/20220128/c4d1ff91f096423bb32e6b527f087f4f.png
[toov5]: https://www.cnblogs.com/toov5/
[Link 2]: https://i.cnblogs.com/EditPosts.aspx?postid=10321364