Base64
public class Base64 {
private static char base64EncodeChars[] = {
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x',
'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', '+', '/'
};
private static byte base64DecodeChars[] = {
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, 62, -1, -1, -1, 63, 52, 53,
54, 55, 56, 57, 58, 59, 60, 61, -1, -1,
-1, -1, -1, -1, -1, 0, 1, 2, 3, 4,
5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
25, -1, -1, -1, -1, -1, -1, 26, 27, 28,
29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
49, 50, 51, -1, -1, -1, -1, -1
};
public Base64() {
}
public static String encode(byte data[]) {
StringBuffer sb = new StringBuffer();
int len = data.length;
for (int i = 0; i < len;) {
int b1 = data[i++] & 0xff;
if (i == len) {
sb.append(base64EncodeChars[b1 >>> 2]);
sb.append(base64EncodeChars[(b1 & 3) << 4]);
sb.append("==");
break;
}
int b2 = data[i++] & 0xff;
if (i == len) {
sb.append(base64EncodeChars[b1 >>> 2]);
sb.append(base64EncodeChars[(b1 & 3) << 4 | (b2 & 0xf0) >>> 4]);
sb.append(base64EncodeChars[(b2 & 0xf) << 2]);
sb.append("=");
break;
}
int b3 = data[i++] & 0xff;
sb.append(base64EncodeChars[b1 >>> 2]);
sb.append(base64EncodeChars[(b1 & 3) << 4 | (b2 & 0xf0) >>> 4]);
sb.append(base64EncodeChars[(b2 & 0xf) << 2 | (b3 & 0xc0) >>> 6]);
sb.append(base64EncodeChars[b3 & 0x3f]);
}
return sb.toString();
}
public static byte[] decode(String str) {
byte data[] = str.getBytes();
int len = data.length;
ByteArrayOutputStream buf = new ByteArrayOutputStream(len);
for (int i = 0; i < len;) {
int b1;
do {
b1 = base64DecodeChars[data[i++]];
} while (i < len && b1 == -1);
if (b1 == -1) {
break;
}
int b2;
do {
b2 = base64DecodeChars[data[i++]];
} while (i < len && b2 == -1);
if (b2 == -1) {
break;
}
buf.write(b1 << 2 | (b2 & 0x30) >>> 4);
int b3;
do {
b3 = data[i++];
if (b3 == 61) {
return buf.toByteArray();
}
b3 = base64DecodeChars[b3];
} while (i < len && b3 == -1);
if (b3 == -1) {
break;
}
buf.write((b2 & 0xf) << 4 | (b3 & 0x3c) >>> 2);
int b4;
do {
b4 = data[i++];
if (b4 == 61) {
return buf.toByteArray();
}
b4 = base64DecodeChars[b4];
} while (i < len && b4 == -1);
if (b4 == -1) {
break;
}
buf.write((b3 & 3) << 6 | b4);
}
return buf.toByteArray();
}
public static String getBase64Code(String src) {
String result = (new StringBuilder(String.valueOf((new String(src)).replace("=", "")))).append("==".substring(0, (src.length() % 8) / 3)).toString();
return result.substring(0, result.length() - result.length() % 4);
}
EncrypDES
public class EncrypDES {
//KeyGenerator 提供对称密钥生成器的功能，支持各种算法
private KeyGenerator keygen;
//SecretKey 负责保存对称密钥
private SecretKey deskey;
//Cipher负责完成加密或解密工作
private Cipher c;
//该字节数组负责保存加密的结果
private byte[] cipherByte;
public EncrypDES() throws NoSuchAlgorithmException, NoSuchPaddingException{
Security.addProvider(new com.sun.crypto.provider.SunJCE());
//实例化支持DES算法的密钥生成器(算法名称命名需按规定，否则抛出异常)
keygen = KeyGenerator.getInstance("DES");
//生成密钥
deskey = keygen.generateKey();
//生成Cipher对象,指定其支持的DES算法
c = Cipher.getInstance("DES");
}
/**
* 对字符串加密
*
* @param str
* @return
* @throws InvalidKeyException
* @throws IllegalBlockSizeException
* @throws BadPaddingException
*/
public byte[] Encrytor(String str) throws InvalidKeyException,
IllegalBlockSizeException, BadPaddingException {
// 根据密钥，对Cipher对象进行初始化，ENCRYPT_MODE表示加密模式
c.init(Cipher.ENCRYPT_MODE, deskey);
byte[] src = str.getBytes();
// 加密，结果保存进cipherByte
cipherByte = c.doFinal(src);
return cipherByte;
}
/**
* 对字符串解密
*
* @param buff
* @return
* @throws InvalidKeyException
* @throws IllegalBlockSizeException
* @throws BadPaddingException
*/
public byte[] Decryptor(byte[] buff) throws InvalidKeyException,
IllegalBlockSizeException, BadPaddingException {
// 根据密钥，对Cipher对象进行初始化，DECRYPT_MODE表示加密模式
c.init(Cipher.DECRYPT_MODE, deskey);
cipherByte = c.doFinal(buff);
return cipherByte;
}
EncrypMD5
public EncrypMD5() {
}
public String getMD5(String source) {
String result = null;
char hexDigits[] = {
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'a', 'b', 'c', 'd', 'e', 'f'
};
try {
MessageDigest md = MessageDigest.getInstance("MD5");
md.update(source.getBytes());
byte tmp[] = md.digest();
char str[] = new char[32];
int k = 0;
for (int i = 0; i < 16; i++) {
byte byte0 = tmp[i];
str[k++] = hexDigits[byte0 >>> 4 & 0xf];
str[k++] = hexDigits[byte0 & 0xf];
}
result = new String(str);
}
catch (Exception e) {
e.printStackTrace();
}
return result;
}
public void testGetMD5() {
String msg = "郭XX-精品相声技术";
EncrypMD5 md5 = new EncrypMD5();
System.out.println(md5.getMD5(msg));
}
public String getMD5(String source, int count) {
for (int i = 0; i < count; i++) {
source = getMD5(source);
}
return source;
}
public void testGetMD52() {
String msg = "郭XX-精品相声技";
EncrypMD5 md5 = new EncrypMD5();
System.out.println(md5.getMD5(msg, 10));
System.out.println(md5.getMD5("郭XX-精品相声技术", 10));
}
EncrypPBE
public static final String ALGORITHM = "PBEWITHMD5andDES";
public EncrypPBE() {
}
public static byte[] initSalt() throws Exception {
byte salt[] = new byte[8];
Random random = new Random();
random.nextBytes(salt);
return salt;
}
private static Key toKey(String password) throws Exception {
PBEKeySpec keySpec = new PBEKeySpec(password.toCharArray());
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("PBEWITHMD5andDES");
javax.crypto.SecretKey secretKey = keyFactory.generateSecret(keySpec);
return secretKey;
}
public static byte[] encrypt(byte data[], String password, byte salt[]) throws Exception {
Key key = toKey(password);
PBEParameterSpec paramSpec = new PBEParameterSpec(salt, 100);
Cipher cipher = Cipher.getInstance("PBEWITHMD5andDES");
cipher.init(1, key, paramSpec);
return cipher.doFinal(data);
}
public static byte[] decrypt(byte data[], String password, byte salt[]) throws Exception {
Key key = toKey(password);
PBEParameterSpec paramSpec = new PBEParameterSpec(salt, 100);
Cipher cipher = Cipher.getInstance("PBEWITHMD5andDES");
cipher.init(2, key, paramSpec);
return cipher.doFinal(data);
}
public static byte[] decryptBASE64(String key) throws Exception {
return (new BASE64Decoder()).decodeBuffer(key);
}
public static String encryptBASE64(byte key[]) throws Exception {
return (new BASE64Encoder()).encodeBuffer(key);
}
public static String encryptPBE(String src, String pwd, byte salt[]) throws Exception {
byte input[] = src.getBytes();
byte data[] = encrypt(input, pwd, salt);
return encryptBASE64(data);
}
public static String decryptPBE(String src, String pwd, byte salt[]) throws Exception {
byte output[] = decrypt(decryptBASE64(src), pwd, salt);
return new String(output);
}
EncrypRSA
public static final String KEY_ALGORITHM = "RSA";
public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
private static final String PUBLIC_KEY = "RSAPublicKey";
private static final String PRIVATE_KEY = "RSAPrivateKey";
public EncrypRSA() {
}
public static String sign(byte data[], String privateKey) throws Exception {
byte keyBytes[] = decryptBASE64(privateKey);
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
java.security.PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);
Signature signature = Signature.getInstance("MD5withRSA");
signature.initSign(priKey);
signature.update(data);
return encryptBASE64(signature.sign());
}
public static boolean verify(byte data[], String publicKey, String sign) throws Exception {
byte keyBytes[] = decryptBASE64(publicKey);
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
java.security.PublicKey pubKey = keyFactory.generatePublic(keySpec);
Signature signature = Signature.getInstance("MD5withRSA");
signature.initVerify(pubKey);
signature.update(data);
return signature.verify(decryptBASE64(sign));
}
public static byte[] decryptByPrivateKey(byte data[], String key) throws Exception {
byte keyBytes[] = decryptBASE64(key);
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(2, privateKey);
return cipher.doFinal(data);
}
public static byte[] decryptByPublicKey(byte data[], String key) throws Exception {
byte keyBytes[] = decryptBASE64(key);
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
Key publicKey = keyFactory.generatePublic(x509KeySpec);
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(2, publicKey);
return cipher.doFinal(data);
}
public static byte[] encryptByPublicKey(byte data[], String key) throws Exception {
byte keyBytes[] = decryptBASE64(key);
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
Key publicKey = keyFactory.generatePublic(x509KeySpec);
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(1, publicKey);
return cipher.doFinal(data);
}
public static byte[] encryptByPrivateKey(byte data[], String key) throws Exception {
byte keyBytes[] = decryptBASE64(key);
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(1, privateKey);
return cipher.doFinal(data);
}
public static String getPrivateKey(Map keyMap) throws Exception {
Key key = (Key)keyMap.get("RSAPrivateKey");
return encryptBASE64(key.getEncoded());
}
public static String getPublicKey(Map keyMap) throws Exception {
Key key = (Key)keyMap.get("RSAPublicKey");
return encryptBASE64(key.getEncoded());
}
public static Map initKey() throws Exception {
KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
keyPairGen.initialize(1024);
KeyPair keyPair = keyPairGen.generateKeyPair();
RSAPublicKey publicKey = (RSAPublicKey)keyPair.getPublic();
RSAPrivateKey privateKey = (RSAPrivateKey)keyPair.getPrivate();
Map keyMap = new HashMap(2);
keyMap.put("RSAPublicKey", publicKey);
keyMap.put("RSAPrivateKey", privateKey);
return keyMap;
}
public static byte[] decryptBASE64(String key) throws Exception {
return (new BASE64Decoder()).decodeBuffer(key);
}
public static String encryptBASE64(byte key[]) throws Exception {
return (new BASE64Encoder()).encodeBuffer(key);
}
EncrypSHA
public EncrypSHA() {
}
public byte[] eccrypt(String info) throws NoSuchAlgorithmException {
MessageDigest md5 = MessageDigest.getInstance("SHA");
byte srcBytes[] = info.getBytes();
md5.update(srcBytes);
byte resultBytes[] = md5.digest();
return resultBytes;
}
相关推荐
java中常用的工具类，用于MD5的加密，里面还有切割了MD5加密的长度，有DES加密与解密，并且配有main函数可测试，可以根据自己的实际情况使用main函数测试使用
这个压缩包对于学习和应用Java加密技术、排序算法以及日志管理提供了丰富的资源。开发者可以根据项目需求选择合适的工具类，也可以作为理解这些基本概念和实现方式的参考。在实际使用时，务必遵循相关的安全规范，...
例如，使用AES加密的Java代码通常会涉及到`javax.crypto.Cipher`类，以及`SecretKey`的生成。开发者需要先创建一个密钥，然后利用`Cipher`类的`init()`方法初始化加密或解密模式，最后调用`doFinal()`方法执行加密或...
基于java的开发源码-用Java加密类实现DES、RSA及SHA的加密算法.zip 基于java的开发源码-用Java加密类实现DES、RSA及SHA的加密算法.zip 基于java的开发源码-用Java加密类实现DES、RSA及SHA的加密算法.zip 基于java的...
Java加密算法是信息安全领域的重要组成部分，它用于保护数据的隐私性和完整性。在Java中，有多种加密算法可供选择，如AES、DES和RSA，每种都有其特定的应用场景和优势。下面将详细介绍这些算法以及相关的学习要点。 ...
Java加密解密工具包，通常用于保护敏感数据的安全，防止未经授权的访问或篡改。这个名为"JCT"的工具包提供了丰富的功能，使得开发者在Java应用中集成加密和解密操作变得更加简单。下面我们将详细探讨Java加密的相关...
在Java中，我们通常使用`java.security.MessageDigest`类来实现MD5加密。在提供的代码段中，`encrypt`方法获取MD5实例，更新输入数据并返回其摘要。MD5常用于存储密码的散列值，例如，当用户注册或登录时，用户的...
本文将详细介绍几种常用的Java加密算法及其应用实例，包括MD5、SHA及RSA。 #### 1. MD5加密 **简介**：MD5（Message-Digest Algorithm 5）是一种广泛使用的散列函数，能够将任意长度的数据转换成一个固定长度...
本文主要介绍了Java中常用加密/解密方法。具有很好的参考价值，下面跟着小编一起来看下吧
本篇文章将深入探讨Java加密解密的核心概念、常用算法以及如何使用它们。 一、加密的基本原理 加密是一种将明文数据转换为看似随机的密文的过程，目的是保护数据免受未经授权的访问。解密则是将密文还原为原始明文...
Java 中常用的加密算法 MD5,SHA,RSA Java 中常用的加密算法有多种，包括 MD5、SHA 和 RSA 等，这些算法在不同的应用场景中发挥着重要作用。下面将对这些算法进行详细的介绍和分析。 一、MD5 加密算法 MD5...
Java 常用的 4 种加密方式（MD5+Base64+SHA+BCrypt） Java 加密是指使用 Java 语言来实现数据加密、解密和数字签名等操作。数据加密是指将明文数据转换为难以理解的密文，以保护数据的机密性和完整性。Java 提供了...
### Java加密网址分享知识点概述 #### 一、Java加密技术概览 在互联网时代，数据安全变得尤为重要。Java作为一种广泛使用的编程语言，在处理敏感信息时提供了多种加密手段。本篇文章将探讨如何使用Java进行网址...
在这个主题中，我们将深入探讨三个关键知识点：Java中的类加载器（ClassLoader）在加密解密中的应用、常见的加密算法以及Java提供的加密技术。 首先，让我们来看看Java的类加载器如何在加密解密中发挥作用。类加载...
"Java常用工具类大全，工作5年精心整理.zip"这个压缩包文件很可能包含了一位有经验的Java开发者在五年工作中积累的各种实用工具类，这些工具类能够极大地提高开发效率，简化代码编写。以下是对可能包含的知识点进行...
在这个“RSA+AES加密工具类 Java”中，我们将深入探讨这两种加密技术以及如何在Java环境中，包括Android和Web应用，实现它们。 首先，RSA（Rivest-Shamir-Adleman）是一种非对称加密算法，基于大整数因子分解的困难...
4. **流操作与加密**：在Java中，可以使用BufferedInputStream和BufferedOutputStream来提高读写效率，并结合Cipher类（Java的加密/解密接口）进行数据加密和解密。通过CipherInputStream和CipherOutputStream，可以...
Java加密算法源码是开发人员在进行数据安全处理时常用的一种工具，涵盖了多种常见的加密算法，包括AES（高级加密标准）、DES（数据加密标准）、MD5（消息摘要算法5）、RSA（公钥加密技术）以及SHA（安全散列算法）。...
根据密钥类型不同将现代密码技术分为两类：对称加密算法（秘密钥匙加密）和非对称加密算法（公开密钥加密）。 对称钥匙加密系统是加密和解密均采用同一把秘密钥匙，而且通信双方都必须获得这把钥匙，并保持钥匙的...