基于apache common-codec 实现MD5、RSA、AES等加密方式

最新推荐文章于 2024-08-07 09:24:04 发布
最新推荐文章于 2024-08-07 09:24:04 发布
阅读量1.5w 收藏 14
点赞数 2
分类专栏： jsp和Servlet(功能篇)
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhouzhiwengang/article/details/90037556
版权

第一步：添加依赖jar 文件：

<!-- https://mvnrepository.com/artifact/commons-codec/commons-codec -->
<dependency>
    <groupId>commons-codec</groupId>
    <artifactId>commons-codec</artifactId>
    <version>1.10</version>
</dependency>

MD5加密：

import org.apache.commons.codec.digest.DigestUtils;

/**
 * MD5加密组件
 * 
 * @author wbw
 * @version 1.0
 * @since 1.0
 */
public abstract class MD5Util {

	/**
	 * MD5加密
	 * 
	 * @param data
	 *            待加密数据
	 * @return byte[] 消息摘要
	 * 
	 * @throws Exception
	 */
	public static byte[] encodeMD5(String data) throws Exception {

		// 执行消息摘要
		return DigestUtils.md5(data);
	}

	/**
	 * MD5加密
	 * 
	 * @param data
	 *            待加密数据
	 * @return byte[] 消息摘要
	 * 
	 * @throws Exception
	 */
	public static String encodeMD5Hex(String data) {
		// 执行消息摘要
		return DigestUtils.md5Hex(data);
	}
}

AES加密：

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;

public class AESUtil {

	private static final String KEY_AES = "AES";

	public static String encrypt(String src, String key) throws Exception {
		if (key == null || key.length() != 16) {
			throw new Exception("key不满足条件");
		} 
		byte[] raw = key.getBytes();
		SecretKeySpec skeySpec = new SecretKeySpec(raw, KEY_AES);
		Cipher cipher = Cipher.getInstance(KEY_AES);
		cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
		byte[] encrypted = cipher.doFinal(src.getBytes());
		return byte2hex(encrypted);
	}

	public static String decrypt(String src, String key) throws Exception {
		if (key == null || key.length() != 16) {
			throw new Exception("key不满足条件");
		}
		byte[] raw = key.getBytes();
		SecretKeySpec skeySpec = new SecretKeySpec(raw, KEY_AES);
		Cipher cipher = Cipher.getInstance(KEY_AES);
		cipher.init(Cipher.DECRYPT_MODE, skeySpec);
		byte[] encrypted1 = hex2byte(src);
		byte[] original = cipher.doFinal(encrypted1);
		String originalString = new String(original);
		return originalString;
	}

	public static byte[] hex2byte(String strhex) {
		if (strhex == null) {
			return null;
		}
		int l = strhex.length();
		if (l % 2 == 1) {
			return null;
		}
		byte[] b = new byte[l / 2];
		for (int i = 0; i != l / 2; i++) {
			b[i] = (byte) Integer.parseInt(strhex.substring(i * 2, i * 2 + 2),
					16);
		}
		return b;
	}

	public static String byte2hex(byte[] b) {
		String hs = "";
		String stmp = "";
		for (int n = 0; n < b.length; n++) {
			stmp = (java.lang.Integer.toHexString(b[n] & 0XFF));
			if (stmp.length() == 1) {
				hs = hs + "0" + stmp;
			} else {
				hs = hs + stmp;
			}
		}
		return hs.toUpperCase();
	}

}

Base64 加密：

import org.apache.commons.codec.binary.Base64;

/**
 * Base64组件
 * 
 * @author wbw
 * @version 1.0
 * @since 1.0
 */
public abstract class Base64Util {

	/**
	 * 字符编码
	 */
	public final static String ENCODING = "UTF-8";

	/**
	 * Base64编码
	 * 
	 * @param data 待编码数据
	 * @return String 编码数据
	 * @throws Exception
	 */
	public static String encode(String data) throws Exception {

		// 执行编码
		byte[] b = Base64.encodeBase64(data.getBytes(ENCODING));

		return new String(b, ENCODING);
	}

	/**
	 * Base64安全编码<br>
	 * 遵循RFC 2045实现
	 * 
	 * @param data
	 *            待编码数据
	 * @return String 编码数据
	 * 
	 * @throws Exception
	 */
	public static String encodeSafe(String data) throws Exception {

		// 执行编码
		byte[] b = Base64.encodeBase64(data.getBytes(ENCODING), true);

		return new String(b, ENCODING);
	}

	/**
	 * Base64解码
	 * 
	 * @param data 待解码数据
	 * @return String 解码数据
	 * @throws Exception
	 */
	public static String decode(String data) throws Exception {

		// 执行解码
		byte[] b = Base64.decodeBase64(data.getBytes(ENCODING));

		return new String(b, ENCODING);
	}

}

DES 加密：

import java.security.Key;
import java.security.SecureRandom;
import java.security.Security;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;

import org.apache.commons.codec.binary.Base64;
import org.bouncycastle.jce.provider.BouncyCastleProvider;

/**
 * DES安全编码组件
 * 
 * @author wbw
 * @version 1.0
 */
public abstract class DESUtil {
	static{
		Security.insertProviderAt(new BouncyCastleProvider(), 1);
	}
	/**
	 * 密钥算法 <br>
	 * Java 6 只支持56bit密钥 <br>
	 * Bouncy Castle 支持64bit密钥
	 */
	public static final String KEY_ALGORITHM = "DES";

	/**
	 * 加密/解密算法 / 工作模式 / 填充方式
	 */
	public static final String CIPHER_ALGORITHM = "DES/ECB/PKCS5PADDING";

	/**
	 * 转换密钥
	 * 
	 * @param key
	 *            二进制密钥
	 * @return Key 密钥
	 * @throws Exception
	 */
	private static Key toKey(byte[] key) throws Exception {

		// 实例化DES密钥材料
		DESKeySpec dks = new DESKeySpec(key);

		// 实例化秘密密钥工厂
		SecretKeyFactory keyFactory = SecretKeyFactory
				.getInstance(KEY_ALGORITHM);

		// 生成秘密密钥
		SecretKey secretKey = keyFactory.generateSecret(dks);

		return secretKey;
	}

	/**
	 * 解密
	 * 
	 * @param data
	 *            待解密数据
	 * @param key
	 *            密钥
	 * @return byte[] 解密数据
	 * @throws Exception
	 */
	public static byte[] decrypt(byte[] data, byte[] key) throws Exception {

		// 还原密钥
		Key k = toKey(key);

		// 实例化
		Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);

		// 初始化，设置为解密模式
		cipher.init(Cipher.DECRYPT_MODE, k);

		// 执行操作
		return cipher.doFinal(data);
	}

	/**
	 * 加密
	 * 
	 * @param data
	 *            待加密数据
	 * @param key
	 *            密钥
	 * @return byte[] 加密数据
	 * @throws Exception
	 */
	public static byte[] encrypt(byte[] data, byte[] key) throws Exception {

		// 还原密钥
		Key k = toKey(key);

		// 实例化
		Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);

		// 初始化，设置为加密模式
		cipher.init(Cipher.ENCRYPT_MODE, k);

		// 执行操作
		return cipher.doFinal(data);
	}

	/**
	 * 生成密钥 <br>
	 * Java 6 只支持56bit密钥 <br>
	 * Bouncy Castle 支持64bit密钥 <br>
	 * 
	 * @return byte[] 二进制密钥
	 * @throws Exception
	 */
	public static byte[] initKey() throws Exception {

		/*
		 * 实例化密钥生成器
		 * 
		 * 若要使用64bit密钥注意替换 将下述代码中的KeyGenerator.getInstance(CIPHER_ALGORITHM);
		 * 替换为KeyGenerator.getInstance(CIPHER_ALGORITHM, "BC");
		 */
		KeyGenerator kg = KeyGenerator.getInstance(KEY_ALGORITHM);

		/*
		 * 初始化密钥生成器 若要使用64bit密钥注意替换 将下述代码kg.init(56); 替换为kg.init(64);
		 */
		kg.init(56, new SecureRandom());

		// 生成秘密密钥
		SecretKey secretKey = kg.generateKey();

		// 获得密钥的二进制编码形式
		return secretKey.getEncoded();
	}
	
	public static byte[] initKey(String seed) throws Exception {
		KeyGenerator kg = KeyGenerator.getInstance(KEY_ALGORITHM);
		SecureRandom secureRandom = new SecureRandom(new Base64().decode(seed));  
		kg.init(secureRandom);
		SecretKey secretKey = kg.generateKey();
		return secretKey.getEncoded();
	}
}

RSA加密：

import java.io.ByteArrayOutputStream;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.Security;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

import javax.crypto.Cipher;

import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.util.encoders.Base64;


/**
 * RSA安全编码组件
 * 
 * @author wbw
 * @version 1.0
 */
public class RSAUtil {
	/**
	 * 非对称加密密钥算法
	 */
	public static final String KEY_ALGORITHM_RSA = "RSA";

	/**
	 * 公钥
	 */
	private static final String RSA_PUBLIC_KEY = "RSAPublicKey";

	/**
	 * 私钥
	 */
	private static final String RSA_PRIVATE_KEY = "RSAPrivateKey";
	
	/**
	 * RSA密钥长度 
	 * 默认1024位，
	 * 密钥长度必须是64的倍数， 
	 * 范围在512至65536位之间。
	 */
	private static final int KEY_SIZE = 1024;
	
	static{
		Security.insertProviderAt(new BouncyCastleProvider(), 1);
	}
	/**
	 * 私钥解密
	 * 
	 * @param data
	 *            待解密数据
	 * @param key
	 *            私钥
	 * @return byte[] 解密数据
	 * @throws Exception
	 */
	public static byte[] decryptByPrivateKey(byte[] data, byte[] key)
			throws Exception {

		// 取得私钥
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);

		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM_RSA);

		// 生成私钥
		PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);

		// 对数据解密
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());

		cipher.init(Cipher.DECRYPT_MODE, privateKey);

		int blockSize = cipher.getBlockSize();
		if(blockSize>0){
			ByteArrayOutputStream bout = new ByteArrayOutputStream(64);
			int j = 0;
			while (data.length - j * blockSize > 0) {
				bout.write(cipher.doFinal(data, j * blockSize, blockSize));
				j++;
			}
			return bout.toByteArray();
		}
		return cipher.doFinal(data);
	}

	/**
	 * 公钥解密
	 * 
	 * @param data
	 *            待解密数据
	 * @param key
	 *            公钥
	 * @return byte[] 解密数据
	 * @throws Exception
	 */
	public static byte[] decryptByPublicKey(byte[] data, byte[] key)
			throws Exception {

		// 取得公钥
		X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);

		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM_RSA);

		// 生成公钥
		PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);

		// 对数据解密
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());

		cipher.init(Cipher.DECRYPT_MODE, publicKey);

		return cipher.doFinal(data);
	}

	/**
	 * 公钥加密
	 * 
	 * @param data
	 *            待加密数据
	 * @param key
	 *            公钥
	 * @return byte[] 加密数据
	 * @throws Exception
	 */
	public static byte[] encryptByPublicKey(byte[] data, byte[] key)
			throws Exception {

		// 取得公钥
		X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);

		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM_RSA);
		
		PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);

		// 对数据加密
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());

		cipher.init(Cipher.ENCRYPT_MODE, publicKey);
		
		int blockSize = cipher.getBlockSize();
		if(blockSize>0){
			int outputSize = cipher.getOutputSize(data.length);
			int leavedSize = data.length % blockSize;
			int blocksSize = leavedSize != 0 ? data.length / blockSize + 1
					: data.length / blockSize;
			byte[] raw = new byte[outputSize * blocksSize];
			int i = 0,remainSize=0;
			while ((remainSize = data.length - i * blockSize) > 0) {
				int inputLen = remainSize > blockSize?blockSize:remainSize;
				cipher.doFinal(data, i * blockSize, inputLen, raw, i * outputSize);
				i++;
			}
			return raw;
		}
		return cipher.doFinal(data);
	}

	/**
	 * 私钥加密
	 * 
	 * @param data
	 *            待加密数据
	 * @param key
	 *            私钥
	 * @return byte[] 加密数据
	 * @throws Exception
	 */
	public static byte[] encryptByPrivateKey(byte[] data, byte[] key)
			throws Exception {

		// 取得私钥
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);

		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM_RSA);

		// 生成私钥
		PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);

		// 对数据加密
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());

		cipher.init(Cipher.ENCRYPT_MODE, privateKey);

		int blockSize = cipher.getBlockSize();
		if(blockSize>0){
			int outputSize = cipher.getOutputSize(data.length);
			int leavedSize = data.length % blockSize;
			int blocksSize = leavedSize != 0 ? data.length / blockSize + 1
					: data.length / blockSize;
			byte[] raw = new byte[outputSize * blocksSize];
			int i = 0,remainSize=0;
			while ((remainSize = data.length - i * blockSize) > 0) {
				int inputLen = remainSize > blockSize?blockSize:remainSize;
				cipher.doFinal(data, i * blockSize, inputLen, raw, i * outputSize);
				i++;
			}
			return raw;
		}
		return cipher.doFinal(data);
	}

	/**
	 * 取得私钥
	 * 
	 * @param keyMap
	 *            密钥Map
	 * @return key 私钥
	 * @throws Exception
	 */
	public static Key getPrivateKey(Map<String, Key> keyMap)
			throws Exception {
		return keyMap.get(RSA_PRIVATE_KEY);
	}

	/**
	 * 取得私钥
	 * 
	 * @param keyMap
	 *            密钥Map
	 * @return byte[] 私钥
	 * @throws Exception
	 */
	public static byte[] getPrivateKeyByte(Map<String, Key> keyMap)
			throws Exception {
		return keyMap.get(RSA_PRIVATE_KEY).getEncoded();
	}
	
	/**
	 * 取得公钥
	 * 
	 * @param keyMap
	 *            密钥Map
	 * @return key 公钥
	 * @throws Exception
	 */
	public static Key getPublicKey(Map<String, Key> keyMap)
			throws Exception {
		return keyMap.get(RSA_PUBLIC_KEY);
	}
	
	/**
	 * 取得公钥
	 * 
	 * @param keyMap
	 *            密钥Map
	 * @return byte[] 公钥
	 * @throws Exception
	 */
	public static byte[] getPublicKeyByte(Map<String, Key> keyMap)
			throws Exception {
		return keyMap.get(RSA_PUBLIC_KEY).getEncoded();
	}
	
	/**
	 * 初始化密钥
	 * @param byte[] seed 种子
	 * @return Map 密钥Map
	 * @throws Exception
	 */
	public static Map<String,Key> initKey(byte[] seed)throws Exception{
		// 实例化密钥对生成器
		KeyPairGenerator keyPairGen = KeyPairGenerator
				.getInstance(KEY_ALGORITHM_RSA);

		// 初始化密钥对生成器
		keyPairGen.initialize(KEY_SIZE,	new SecureRandom(seed) );

		// 生成密钥对
		KeyPair keyPair = keyPairGen.generateKeyPair();

		// 公钥
		RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();

		// 私钥
		RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();

		// 封装密钥
		Map<String, Key> keyMap = new HashMap<String, Key>(2);

		keyMap.put(RSA_PUBLIC_KEY, publicKey);
		keyMap.put(RSA_PRIVATE_KEY, privateKey);

		return keyMap;
	}
	
	/**
	 * 初始化密钥
	 * @param seed 种子
	 * @return Map 密钥Map
	 * @throws Exception
	 */
	public static Map<String,Key> initKey(String seed)throws Exception{
		return initKey(seed.getBytes());
	}

	/**
	 * 初始化密钥
	 * 
	 * @return Map 密钥Map
	 * @throws Exception
	 */
	public static Map<String, Key> initKey() throws Exception {
		return initKey(UUID.randomUUID().toString().getBytes());
	}
	
	public static PublicKey getPublicRSAKey(String key) throws Exception {
		X509EncodedKeySpec x509 = new X509EncodedKeySpec(Base64.decode(key));
		KeyFactory kf = KeyFactory.getInstance(KEY_ALGORITHM_RSA);
		return kf.generatePublic(x509);
	}

	public static PrivateKey getPrivateRSAKey(String key) throws Exception {
		PKCS8EncodedKeySpec pkgs8 = new PKCS8EncodedKeySpec(Base64.decode(key));
		KeyFactory kf = KeyFactory.getInstance(KEY_ALGORITHM_RSA);
		return kf.generatePrivate(pkgs8);
	}

}

 

在奋斗的大道
关注
专栏目录
Java加密组件实现DES、RSA和SHA加密算法
01-15
Java加密组件实现DES、RSA和SHA加密算法 - Java源码 - JAVA & XML - 源码
commons-crypto:Apache Commons Crypto的镜像
05-08
Apache Commons加密 Apache Commons Crypto是使用AES-NI（高级加密标准新指令）进行了优化的加密库。 它提供用于密码级别和Java流级别的Java API。 开发人员可以使用它以最少的代码和精力来实现高性能AES加密/解密。 请注意，Crypto不会直接实现诸如AES之类的加密算法。 它包装到实现算法的Openssl或JCE。 特征 用于低级加密操作的密码API。 Java流API（CryptoInputStream / CryptoOutputStream）用于高级流加密/解密。 两者均通过高性能AES加密/解密进行了优化。 （现代Xeon处理器中的1400 MB / s-1700 MB / s吞吐量）。 基于JNI的实现可实现与基于OpenSsl的本机C / C ++版本相当的性能。 可跨各种操作系统移植（目前仅可用于Linux / Mac
Apache Commons Codec 使用指南
最新发布
gitblog_00010的博客
08-07 1097
Apache Commons Codec 使用指南 commons-codecApache Commons Codec项目地址:https://gitcode.com/gh_mirrors/com/commons-codec 一、项目介绍 Apache Commons Codec是Apache Commons系列的一部分，专注于提供编码器和解码器实现，如Base64, HEX, 音译(Phone...
java 加密工具类（MD5、RSA、AES等加密方式）
乐于学习、乐于分享、乐于总结
02-03 1万+
1.加密工具类encryption MD5加密 import org.apache.commons.codec.digest.DigestUtils; /** * MD5加密组件 * * @author wbw * @version 1.0 * @since 1.0 */ public abstract class MD5Util { /** * MD5加密 *
commons-codec使用简介
热门推荐
OceanSky的专栏
06-11 4万+
commons-codec是Apache开源组织提供的用于摘要运算、编码解码的包。常见的编码解码工具Base64、MD5、Hex、SHA1、DES等。 Base64编码 System.out.println(&amp;amp;quot;===============base64======================&amp;amp;quot;); Base64 base64 = new Base64...
java apache md5加密_Java中MD5加密的几种方式
weixin_39597399的博客
02-23 950
一、MD5加密概述：MD5信息摘要算法(英语：MD5 Message-Digest Algorithm)，一种被广泛使用的密码散列函数，可以产生出一个128位(16字节)的散列值(hash value)，用于确保信息传输完整一致。MD5为不可逆散列算法，可用于存储用户密码，存储后永远不需要知道明文。密码比较时只需将用户输入的密码再次转成MD5码与存储的相比较即可得知用户输入密码是否正确。linux...
commons-codec使用介绍
z69183787的专栏
08-03 1万+
https://blog.csdn.net/jianggujin/article/details/51149133   commons-codec是Apache开源组织提供的用于摘要运算、编码的包。在该包中主要分为四类加密：BinaryEncoders、DigestEncoders、LanguageEncoders、NetworkEncoders。 今天就为大家介绍一下如何用commons-...
报文响应+获取会话公钥（SessionKey）+RAS加密+AES加密+MD5加密
04-23
1、接入申请：在接入单位应先向税务局申请，经过审批备案后，将生成的唯一的接入方编号(appCode)和通过使用OpenSSL生成的一对私钥和公钥。...再对（requestData密文+会话公钥明文）进行MD5加密作为sign值。
MD5 AES RSA加密最全总结
11-30
MD5、AES和RSA是当前信息安全领域使用非常广泛的加密算法，它们在不同的场景下承担着不同的安全使命。 MD5（Message-Digest Algorithm 5）是一种广泛使用的哈希函数，它可以将任意长度的数据转换为固定长度（128位...
rsa与aes混合加密java实现
08-12
这种方式称为RSA-AES混合加密。 具体步骤如下： 1. **生成密钥对**：使用RSA生成一对公钥和私钥。 2. **生成AES密钥**：创建一个随机的AES密钥。 3. **AES加密**：使用AES密钥加密原始数据。 4. **RSA加密AES密钥**...
rsa-aes-md5-crypt.zip
05-04
综上，"rsa-aes-md5-crypt.zip"这个压缩包可能包含了一个示例或工具，用于演示如何在JavaScript环境中利用jsrsasign库进行RSA公私钥生成、RSA加解密签名验签、AES加解密以及MD5哈希计算。开发者可以通过解压文件并...
MD5和RSA加密算法Java完成实现
09-16
MD5和RSA是两种在计算机安全领域广泛应用的加密算法，主要用在数据的完整性校验和保密通信上。本文将详细介绍这两种算法以及如何在Java环境中实现它们。 首先，MD5（Message-Digest Algorithm 5）是一种广泛使用的...
Apache Commons Codec 工具使用
ubuntulinuxjava的专栏
10-29 519
Apache Commons Codec(TM)框架提供常用编码器和解码器的实现，如：Base64、十六进制、语音和 URL。它由一组实用程序和一个用于编码和解码文本和二进制数据的简单框架组成。
apache的MD5算法
goflyfreely的专栏
07-04 5252
018 package org.apache.commons.codec.digest; 019   020 import java.io.ByteArrayInputStream; 021 import java.io.IOException;
java apache md5加密_java利用Apache commons codec进行MD5加密,BASE64加密解密,执行系统命令...
weixin_32121569的博客
02-13 404
编写代码之前先来介绍一下我们要用到的两个包;commons-codec-1.10.jarCommons项目中用来处理常用的编码方法的工具类包，例如DES、SHA1、MD5、Base64，URL，Soundx等等。commons-exec-1.3.jarApache Commons Exec 是 Apache 上的一个 Java 项目，提供一些常用的方法用来执行外部进程下面看一下代码结构：impor...
使用commons-codec进行MD5签名
Dima3773的博客
06-22 2608
一、maven依耐： &lt;dependency&gt; &lt;groupId&gt;commons-codec&lt;/groupId&gt; &lt;artifactId&gt;commons-codec&lt;/artifactId&gt; &lt;version&gt;1.10&lt;/version&gt; &lt;/dependency&
Apache Commons：Commons-codec介绍
走马观花
08-30 2232
http://www.zihou.me/html/2011/03/23/2983.html   在实际的应用中，我们经常需要对字符串进行编解码，Apache Commons家族中的Commons Codec就提供了一些公共的编解码实现，比如Base64, Hex, MD5,Phonetic and URLs等等。 一、官方网址： http://commons.apache.org/code
Apache Commons Codec 也就那样吧！！！
独泪了无痕
08-04 2110
一、简介   commons-codec是Apache开源组织提供的用于摘要运算、编码解码的包，常见的编码解码工具Base64、MD5、Hex、SHA1、DES等。常规加密解密算法它由一组实用程序和一个用于编码和解码文本和二进制数据的简单框架组成。   Apache Commons Codec 编解码器的形成是为了将开发工作集中在一种确定的 Base64 编码器实现上。在该编解码器开发之时，大约有 34 种不同的 Java 类用于处理遍布 Apache 软件基金会 CVS 存储库的 Base64 编码。虽.
c#实现非对称加密双向RSA + AES加密
06-02
双向 RSA + AES 加密是一种常见的加密方式，其中使用 RSA 算法加密 AES 密钥，然后使用 AES 算法加密数据。在 C# 中，可以使用 `RSACryptoServiceProvider` 类和 `AesCryptoServiceProvider` 类来实现此加密方式。以下是一个简单的示例： ```csharp using System; using System.IO; using System.Security.Cryptography; using System.Text; class Program { static void Main(string[] args) { string plainText = "Hello, world!"; byte[] encryptedData = Encrypt(plainText); string decryptedText = Decrypt(encryptedData); Console.WriteLine("Original text: {0}", plainText); Console.WriteLine("Encrypted data: {0}", Convert.ToBase64String(encryptedData)); Console.WriteLine("Decrypted text: {0}", decryptedText); } static byte[] Encrypt(string plainText) { byte[] aesKey = GenerateAesKey(); using (var rsa = new RSACryptoServiceProvider()) { rsa.PersistKeyInCsp = false; byte[] encryptedAesKey = rsa.Encrypt(aesKey, true); // 使用 RSA 加密 AES 密钥 using (var aes = new AesCryptoServiceProvider()) { aes.Key = aesKey; aes.GenerateIV(); using (var memoryStream = new MemoryStream()) { memoryStream.Write(aes.IV, 0, aes.IV.Length); using (var cryptoStream = new CryptoStream(memoryStream, aes.CreateEncryptor(), CryptoStreamMode.Write)) { byte[] plainData = Encoding.UTF8.GetBytes(plainText); cryptoStream.Write(plainData, 0, plainData.Length); cryptoStream.FlushFinalBlock(); } byte[] encryptedData = memoryStream.ToArray(); byte[] result = new byte[encryptedAesKey.Length + encryptedData.Length]; Buffer.BlockCopy(encryptedAesKey, 0, result, 0, encryptedAesKey.Length); Buffer.BlockCopy(encryptedData, 0, result, encryptedAesKey.Length, encryptedData.Length); return result; } } } } static string Decrypt(byte[] encryptedData) { byte[] encryptedAesKey = new byte[128]; // RSA 加密 AES 密钥得到的密文长度为 128 字节 byte[] encryptedDataOnly = new byte[encryptedData.Length - encryptedAesKey.Length]; Buffer.BlockCopy(encryptedData, 0, encryptedAesKey, 0, encryptedAesKey.Length); Buffer.BlockCopy(encryptedData, encryptedAesKey.Length, encryptedDataOnly, 0, encryptedDataOnly.Length); using (var rsa = new RSACryptoServiceProvider()) { rsa.PersistKeyInCsp = false; byte[] aesKey = rsa.Decrypt(encryptedAesKey, true); // 使用 RSA 解密 AES 密钥 using (var aes = new AesCryptoServiceProvider()) { aes.Key = aesKey; aes.IV = encryptedDataOnly.Take(aes.IV.Length).ToArray(); using (var memoryStream = new MemoryStream()) { using (var cryptoStream = new CryptoStream(memoryStream, aes.CreateDecryptor(), CryptoStreamMode.Write)) { cryptoStream.Write(encryptedDataOnly, aes.IV.Length, encryptedDataOnly.Length - aes.IV.Length); cryptoStream.FlushFinalBlock(); } byte[] decryptedData = memoryStream.ToArray(); return Encoding.UTF8.GetString(decryptedData); } } } } static byte[] GenerateAesKey() { using (var aes = new AesCryptoServiceProvider()) { aes.GenerateKey(); return aes.Key; } } } ``` 上面的代码中，首先调用 `GenerateAesKey` 方法生成 AES 密钥，然后使用 RSA 算法加密 AES 密钥。加密时，先将 AES 密钥使用 RSA 加密，然后使用 AES 算法加密数据。具体来说，将 AES 密钥和 IV 都写入 `MemoryStream` 对象中，然后使用 `CryptoStream` 对象将数据写入 `MemoryStream` 对象中。最后将密文和 RSA 加密的 AES 密钥一起返回。 解密时，先从密文中取出 RSA 加密的 AES 密钥，然后使用 RSA 算法解密 AES 密钥。解密时，先从密文中取出 AES 的 IV 值，然后使用 `CryptoStream` 对象将数据解密。最后将解密后的文本返回。 注意，上面的示例仅用于演示 RSA + AES 加密的基本原理，实际使用中还需要考虑安全性等因素。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值