对称加密与非对称加密&JWT

心已赠人 2023-02-10 05:30 65阅读 0赞

# 1. 对称加密 #

对称加密指的就是加密和解密使用同一个秘钥，所以叫做对称加密。对称加密只有一个秘钥，作为私钥。

常见的对称加密算法：DES，AES，3DES等等。

# 2. 非对称加密 #

非对称加密指的是：加密和解密使用不同的秘钥，一把作为公开的公钥，另一把作为私钥。公钥加密的信息，只有私钥才能解密。私钥加密的信息，只有公钥才能解密。

常见的非对称加密算法：RSA，ECC

## 区别 ##

对称加密算法相比非对称加密算法来说，加解密的效率要高得多。但是缺陷在于对于秘钥的管理上，以及在非安全信道中通讯时，密钥交换的安全性不能保障。所以在实际的网络环境中，会将两者混合使用.

# 4. JWT #

JWT通常由三部分组成: 头信息（header）, 消息体（payload）和签名（signature）。  
头信息指定了该JWT使用的签名算法:

header = '{"alg":"HS256","typ":"JWT"}'

HS256 表示使用了 HMAC-SHA256 来生成签名。  
消息体包含了JWT的意图：

payload = '{"loggedInAs":"admin","iat":1422779638}'
    //iat表示令牌生成的时间

未签名的令牌由base64url编码的头信息和消息体拼接而成（使用"."分隔），签名则通过私有的key计算而成：

key = 'secretkey'  
    unsignedToken = encodeBase64(header) + '.' + encodeBase64(payload)  
    signature = HMAC-SHA256(key, unsignedToken)

最后在未签名的令牌尾部拼接上base64url编码的签名（同样使用"."分隔）就是JWT了：

token = encodeBase64(header) + '.' + encodeBase64(payload) + '.' + encodeBase64(signature) 
    
    # token看起来像这样: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJsb2dnZWRJbkFzIjoiYWRtaW4iLCJpYXQiOjE0MjI3Nzk2Mzh9.gzSraSYS8EXBxLN_oWnFSRgCzcmJmMjLiuyu5CSpyHI

JWT常常被用作保护服务端的资源（resource），客户端通常将JWT通过HTTP的Authorization header发送给服务端，服务端使用自己保存的key计算、验证签名以判断该JWT是否可信：

Authorization: Bearer eyJhbGci*...<snip>...*yu5CSpyHI

# 5. 简单验证 #

pom：

<dependency>
                <groupId>io.jsonwebtoken</groupId>
                <artifactId>jjwt</artifactId>
                <version>0.9.1</version>
            </dependency>
            <dependency>
                <groupId>com.auth0</groupId>
                <artifactId>java-jwt</artifactId>
                <version>3.4.0</version>
            </dependency>
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-lang3</artifactId>
            </dependency>

public class JWTUtils { 
        public static final String SUBJECT = "subject";
    
        public static final long EXPIRE = 1000 * 60 * 60 * 24 * 7;  //过期时间，毫秒，一周
    
        //秘钥
        public static final String APPSECRET = "onehee666";
    
        /** * 生成jwt * 有时候直接将 参数User User 换成json的String就行 * stinrg=Joso.parseObject(Object object) * @param user * @return */
        public static String geneJsonWebToken(User user) { 
    
            if (user == null || user.getUsername() == null || user.getPassword() == null
            ) { 
                return null;
            }
            String token = Jwts.builder().setSubject(SUBJECT)
                    .claim("username", user.getUsername())
                    .claim("password", user.getPassword())
                    .setIssuedAt(new Date())
                    .setExpiration(new Date(System.currentTimeMillis() + EXPIRE))
                    .signWith(SignatureAlgorithm.HS256, APPSECRET).compact();
    
            return token;
        }
    
    
        /** * 校验token * * @param token * @return */
        public static Claims checkJWT(String token) { 
    
            try { 
                final Claims claims = Jwts.parser().setSigningKey(APPSECRET).
                        parseClaimsJws(token).getBody();
                return claims;
    
            } catch (Exception e) { 
            }
            return null;
    
        }
    
        /** * 解析Claims * * @param token * @return */
        public static Claims getClaim(String token) { 
            Claims claims = null;
            try { 
                claims = Jwts.parser()
                        .setSigningKey(APPSECRET)
                        .parseClaimsJws(token)
                        .getBody();
            } catch (Exception e) { 
                e.printStackTrace();
            }
            return claims;
        }
    
        /** * 获取jwt发布时间 */
        public static Date getIssuedAt(String token) { 
            return getClaim(token).getIssuedAt();
        }
    
    // /**
    // * 获取UID
    // */
    // public static Integer getUid(String token) { 
    // return TypeUtils.castToInt(getClaim(token).get(UID));
    // }
    
        /** * 获取jwt失效时间 */
        public static Date getExpiration(String token) { 
            return getClaim(token).getExpiration();
        }
    
        /** * 验证token是否失效 * * @param token * @return true:过期 false:没过期 */
        public static boolean isExpired(String token) { 
            try { 
                final Date expiration = getExpiration(token);
                return expiration.before(new Date());
            } catch (ExpiredJwtException expiredJwtException) { 
                return true;
            }
        }

public static void main(String[] args) { 
            User user = new User();
            user.setPassword("123");
            user.setUsername("admin");
            String s = JWTUtils.geneJsonWebToken(user);
            System.out.println(s);
            Claims claims = JWTUtils.checkJWT(s);
            Object username = claims.get("username");
            System.out.println("username "+username);
            String id = claims.getId();
            System.out.println("id "+ id);
            String subject = claims.getSubject();
            System.out.println(subject);
            System.out.println(claims.getAudience());
            System.out.println(claims.getExpiration());
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70]

# 6. RSA #

利用java的keytool生成密钥对：

keytool -genkey -alias 你的证书别名 -keyalg 密钥算法 -keystore 证书库文件保存的位置和文件名 -keysize 密钥长度 -validity 证书有效期天数

会在当前文件夹下生成，也可指定文件夹  
![在这里插入图片描述][20200520200417620.png]

-alias：密钥的别名
     -keyalg：使用的hash算法 
     -keypass：密钥的访问密码 
     -keystore：密钥库文件名
     -storepass：密钥库的访问密码

查询证书信息：  
keytool -list -keystore xc.keystore  
删除别名  
keytool -delete -alias xckey -keystore xc.keystore  
导出证书：

keytool -export -alias 别名 -keystore 密钥库文件名 -file 生成整数名.cer

![在这里插入图片描述][20200520200605144.png]

keytool ‐list ‐rfc ‐‐keystore jwtdemo.keystore | openssl x509 ‐inform pem ‐pubkey

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 1]  
下面一段代码可以也生成密钥对：

public class RSAEncrypt { 
    	private static Map<Integer, String> keyMap = new HashMap<Integer, String>();  //用于封装随机产生的公钥与私钥
    	public static void main(String[] args) throws Exception { 
    		//生成公钥和私钥
    		genKeyPair();
    		//加密字符串
    		String message = "df723820";
    		System.out.println("随机生成的公钥为:" + keyMap.get(0));
    		System.out.println("随机生成的私钥为:" + keyMap.get(1));
    		String messageEn = encrypt(message,keyMap.get(0));
    		System.out.println();
    		System.out.println(message + "\t加密后的字符串为:" + messageEn);
    		String messageDe = decrypt(messageEn,keyMap.get(1));
    		System.out.println("还原后的字符串为:" + messageDe);
    	}
    
    	/** * 随机生成密钥对 * @throws NoSuchAlgorithmException */  
    	public static void genKeyPair() throws NoSuchAlgorithmException { 
    		// KeyPairGenerator类用于生成公钥和私钥对，基于RSA算法生成对象 
    		KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
    		// 初始化密钥对生成器，密钥大小为96-1024位 
    		keyPairGen.initialize(1024,new SecureRandom());
    		// 生成一个密钥对，保存在keyPair中 
    		KeyPair keyPair = keyPairGen.generateKeyPair();
    		RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();   // 得到私钥
    		RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();  // 得到公钥
    		String publicKeyString = new String(Base64.encodeBase64(publicKey.getEncoded()));
    		// 得到私钥字符串 
    		String privateKeyString = new String(Base64.encodeBase64((privateKey.getEncoded())));  
    		// 将公钥和私钥保存到Map
    		keyMap.put(0,publicKeyString);  //0表示公钥
    		keyMap.put(1,privateKeyString);  //1表示私钥
    	}  
    	/** * RSA公钥加密 * * @param str * 加密字符串 * @param publicKey * 公钥 * @return 密文 * @throws Exception * 加密过程中的异常信息 */  
    	public static String encrypt( String str, String publicKey ) throws Exception{ 
    		//base64编码的公钥
    		byte[] decoded = Base64.decodeBase64(publicKey);
    		RSAPublicKey pubKey = (RSAPublicKey) KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(decoded));
    		//RSA加密
    		Cipher cipher = Cipher.getInstance("RSA");
    		cipher.init(Cipher.ENCRYPT_MODE, pubKey);
    		String outStr = Base64.encodeBase64String(cipher.doFinal(str.getBytes("UTF-8")));
    		return outStr;
    	}
    
    	/** * RSA私钥解密 * * @param str * 加密字符串 * @param privateKey * 私钥 * @return 铭文 * @throws Exception * 解密过程中的异常信息 */  
    	public static String decrypt(String str, String privateKey) throws Exception{ 
    		//64位解码加密后的字符串
    		byte[] inputByte = Base64.decodeBase64(str.getBytes("UTF-8"));
    		//base64编码的私钥
    		byte[] decoded = Base64.decodeBase64(privateKey);  
            RSAPrivateKey priKey = (RSAPrivateKey) KeyFactory.getInstance("RSA").generatePrivate(new PKCS8EncodedKeySpec(decoded));
    		//RSA解密
    		Cipher cipher = Cipher.getInstance("RSA");
    		cipher.init(Cipher.DECRYPT_MODE, priKey);
    		String outStr = new String(cipher.doFinal(inputByte));
    		return outStr;
    	}
    }

RSA+JWT：

public class JwtUtils { 
        /** * 私钥加密token * * @param user 载荷中的数据 * @param privateKey 私钥 * @param expireMinutes 过期时间，单位秒 * @return * @throws Exception */
        public static String generateToken(User user, PrivateKey privateKey, int expireMinutes) throws Exception { 
            return Jwts.builder()
                    .claim("username", user.getUsername())
                    .claim("password", user.getPassword())
                    .setExpiration(DateTime.now().plusMinutes(expireMinutes).toDate())
                    .signWith(SignatureAlgorithm.RS256, privateKey)
                    .compact();
        }
        /** * 私钥加密token * * @param user 载荷中的数据 * @param privateKey 私钥字节数组 * @param expireMinutes 过期时间，单位秒 * @return * @throws Exception */
        public static String generateToken(User user, byte[] privateKey, int expireMinutes) throws Exception { 
            return Jwts.builder()
                    .claim("username", user.getUsername())
                    .claim("password", user.getPassword())
                    .setExpiration(DateTime.now().plusMinutes(expireMinutes).toDate())
                    .signWith(SignatureAlgorithm.RS256, RsaUtils.getPrivateKey(privateKey))
                    .compact();
        }
        /** * 公钥解析token * * @param token 用户请求中的token * @param publicKey 公钥 * @return * @throws Exception */
        private static Jws<Claims> parserToken(String token, PublicKey publicKey) { 
            return Jwts.parser().setSigningKey(publicKey).parseClaimsJws(token);
        }
        /** * 公钥解析token * * @param token 用户请求中的token * @param publicKey 公钥字节数组 * @return * @throws Exception */
        private static Jws<Claims> parserToken(String token, byte[] publicKey) throws Exception { 
            return Jwts.parser().setSigningKey(RsaUtils.getPublicKey(publicKey))
                    .parseClaimsJws(token);
        }
    
        /** * 获取token中的用户信息 * * @param token 用户请求中的令牌 * @param publicKey 公钥 * @return 用户信息 * @throws Exception */
        public static User getInfoFromToken(String token, PublicKey publicKey) throws Exception { 
            Jws<Claims> claimsJws = parserToken(token, publicKey);
            Claims body = claimsJws.getBody();
            return new User(
                    ObjectUtils.toString(body.get(JwtConstans.JWT_KEY_PASSWORD)),
                    ObjectUtils.toString(body.get(JwtConstans.JWT_KEY_USER_NAME))
            );
        }
        /** * 获取token中的用户信息 * * @param token 用户请求中的令牌 * @param publicKey 公钥 * @return 用户信息 * @throws Exception */
        public static User getInfoFromToken(String token, byte[] publicKey) throws Exception { 
            Jws<Claims> claimsJws = parserToken(token, publicKey);
            Claims body = claimsJws.getBody();
            return new User(
                    ObjectUtils.toString(body.get(JwtConstans.JWT_KEY_PASSWORD)),
                    ObjectUtils.toString(body.get(JwtConstans.JWT_KEY_USER_NAME))
            );
        }
    
    }

public class RsaUtils { 
        /** * 从文件中读取公钥 * * @param filename 公钥保存路径，相对于classpath * @return 公钥对象 * @throws Exception */
        public static PublicKey getPublicKey(String filename) throws Exception { 
            byte[] bytes = readFile(filename);
            return getPublicKey(bytes);
        }
    
        /** * 从文件中读取密钥 * @param filename 私钥保存路径，相对于classpath * @return 私钥对象 * @throws Exception */
        public static PrivateKey getPrivateKey(String filename) throws Exception { 
            byte[] bytes = readFile(filename);
            return getPrivateKey(bytes);
        }
    
        /** * 获取公钥 * * @param bytes 公钥的字节形式 * @return * @throws Exception */
        public static PublicKey getPublicKey(byte[] bytes) throws Exception { 
            X509EncodedKeySpec spec = new X509EncodedKeySpec(bytes);
            KeyFactory factory = KeyFactory.getInstance("RSA");
            return factory.generatePublic(spec);
        }
    
        /** * 获取密钥 * @param bytes 私钥的字节形式 * @return * @throws Exception */
        public static PrivateKey getPrivateKey(byte[] bytes) throws Exception { 
            PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(bytes);
            KeyFactory factory = KeyFactory.getInstance("RSA");
            return factory.generatePrivate(spec);
        }
    
        /** * 根据密文，生存rsa公钥和私钥,并写入指定文件 * * @param publicKeyFilename 公钥文件路径 * @param privateKeyFilename 私钥文件路径 * @param secret 生成密钥的密文 * @throws IOException * @throws NoSuchAlgorithmException */
        public static void generateKey(String publicKeyFilename, String privateKeyFilename, String secret) throws Exception { 
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
            SecureRandom secureRandom = new SecureRandom(secret.getBytes());
            keyPairGenerator.initialize(1024, secureRandom);
            KeyPair keyPair = keyPairGenerator.genKeyPair();
            // 获取公钥并写出
            byte[] publicKeyBytes = keyPair.getPublic().getEncoded();
            writeFile(publicKeyFilename, publicKeyBytes);
            // 获取私钥并写出
            byte[] privateKeyBytes = keyPair.getPrivate().getEncoded();
            writeFile(privateKeyFilename, privateKeyBytes);
        }
    
    
        private static byte[] readFile(String fileName) throws Exception { 
            return Files.readAllBytes(new File(fileName).toPath());
        }
    
    
        private static void writeFile(String destPath, byte[] bytes) throws IOException { 
            File dest = new File(destPath);
            if (!dest.exists()) { 
                dest.createNewFile();
            }
            Files.write(dest.toPath(), bytes);
        }
    
        /** * 测试RSAUtils工具类的使用 * * @param args */
        public static void main(String[] args) throws Exception { 
            // rsa.pub文件名随意，例如：rsa.pub、rsa.io、pub.opp、rsapub.tyrf、rsa.txt、、、、
            String pubKeyPath = "D:\\rsapu.txt";
            String priKeyPath = "D:\\rsase.txt";
            // 明文
            String secret = "sc@Login(Auth}*^31)&czxy%";
            RsaUtils.generateKey(pubKeyPath, priKeyPath, secret);
            System.out.println("ok");
    
    
            /**************解密**************/
            // PublicKey publicKey = RsaUtils.getPublicKey(pubKeyPath);
            // System.out.println("公钥:"+publicKey);
            //
            // PrivateKey = RsaUtils.getPrivateKey(priKeyPath);
            // System.out.prinprivateKeytln("私钥："+privateKey);
    
        }
    
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/2020052017115567.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc=,size_16,color_FFFFFF,t_70
[20200520200417620.png]: https://img-blog.csdnimg.cn/20200520200417620.png
[20200520200605144.png]: https://img-blog.csdnimg.cn/20200520200605144.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200520210351935.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc=,size_16,color_FFFFFF,t_70