java加密与解密的艺术pdf
importjavax.crypto.Cipher;
importjavax.crypto.spec.SecretKeySpec;
importjavax.xml.bind.DatatypeConverter;
publicclassTest{
publicstaticvoidmain(String[]args)throwsException{
Ciphercipher=Cipher.getInstance("RC4");
Stringpwd="123456";
Stringptext="HelloWorld你好";
SecretKeySpeckey=newSecretKeySpec(pwd.getBytes("UTF-8"),"RC4");
cipher.init(Cipher.ENCRYPT_MODE,key);
byte[]cdata=cipher.update(ptext.getBytes("UTF-8"));
//解密
cipher.init(Cipher.DECRYPT_MODE,key);
byte[]ddata=cipher.update(cdata);
System.out.println("密码:"+pwd);
System.out.println("明文:"晌隐+ptext);
System.out.println("密文:"+DatatypeConverter.printHexBinary(cdata));
System.out.println("解密文:"+newString(ddata,"UTF-8"));
}
}
密码:123456
明文:HelloWorld你镇戚好
密文:
解密文御谨陵:HelloWorld你好
RC4已经不太安全，只能用于一般加密，不能用于金融等紧要场合。
㈡ Java中用Base64编程的文件批量加密解密工具程序代码
/** * BASE64解密 * * @param key * @return * @throws Exception */
public static byte[] decryptBASE64(String key) throws Exception { return (new BASE64Decoder()).decodeBuffer(key); } /** * BASE64加密 * * @param key * @return * @throws Exception */ public static String encryptBASE64(byte[] key) throws Exception { return (new BASE64Encoder()).encodeBuffer(key); }
㈢ 求Java的MD5加密解密实现类。 要实现对用户的密码进行加密！ 然后验证用户的密码！
我简单说下吧，加密就是存进数据库的时候变成MD5存进去，解密，就是对比的时候，将用户输入的密码转换成MD5和数据库里面的对比。
㈣ 请问用java如何对文件进行加密解密
packagecom.palic.pss.afcs.worldthrough.common.util;
importjavax.crypto.Cipher;
importjavax.crypto.spec.SecretKeySpec;
importrepack.com.thoughtworks.xstream.core.util.Base64Encoder;
/**
*AES加密解密
*@authorEX-CHENQI004
*
*/
publicclassAesUtils{
publicstaticfinalStringcKey="assistant7654321";
/**
*加密--把加密后的byte数组先进行二进制转16进制在进行base64编码
*@paramsSrc
*@paramsKey
*@return
*@throwsException
*/
publicstaticStringencrypt(StringsSrc,StringsKey)throwsException{
if(sKey==null){
("ArgumentsKeyisnull.");
}
if(sKey.length()!=16){
(
"ArgumentsKey'lengthisnot16.");
}
byte[]raw=sKey.getBytes("ASCII");
SecretKeySpecskeySpec=newSecretKeySpec(raw,"AES");
Ciphercipher=Cipher.getInstance("AES");
cipher.init(Cipher.ENCRYPT_MODE,skeySpec);
byte[]encrypted=cipher.doFinal(sSrc.getBytes("UTF-8"));
StringtempStr=parseByte2HexStr(encrypted);
Base64Encoderencoder=newBase64Encoder();
returnencoder.encode(tempStr.getBytes("UTF-8"));
}
/**
*解密--先进行base64解码，在进行16进制转为2进制然后再解码
*@paramsSrc
*@paramsKey
*@return
*@throwsException
*/
publicstaticStringdecrypt(StringsSrc,StringsKey)throwsException{
if(sKey==null){
("499");
}
if(sKey.length()!=16){
("498");
}
byte[]raw=sKey.getBytes("ASCII");
SecretKeySpecskeySpec=newSecretKeySpec(raw,"AES");
Ciphercipher=Cipher.getInstance("AES");
cipher.init(Cipher.DECRYPT_MODE,skeySpec);
Base64Encoderencoder=newBase64Encoder();
byte[]encrypted1=encoder.decode(sSrc);
StringtempStr=newString(encrypted1,"utf-8");
encrypted1=parseHexStr2Byte(tempStr);
byte[]original=cipher.doFinal(encrypted1);
StringoriginalString=newString(original,"utf-8");
returnoriginalString;
}
/**
*将二进制转换成16进制
*
*@parambuf
*@return
*/
(bytebuf[]){
StringBuffersb=newStringBuffer();
for(inti=0;i<buf.length;i++){
Stringhex=Integer.toHexString(buf[i]&0xFF);
if(hex.length()==1){
hex='0'+hex;
}
sb.append(hex.toUpperCase());
}
returnsb.toString();
}
/**
*将16进制转换为二进制
*
*@paramhexStr
*@return
*/
publicstaticbyte[]parseHexStr2Byte(StringhexStr){
if(hexStr.length()<1)
returnnull;
byte[]result=newbyte[hexStr.length()/2];
for(inti=0;i<hexStr.length()/2;i++){
inthigh=Integer.parseInt(hexStr.substring(i*2,i*2+1),16);
intlow=Integer.parseInt(hexStr.substring(i*2+1,i*2+2),
16);
result[i]=(byte)(high*16+low);
}
returnresult;
}
publicstaticvoidmain(String[]args)throwsException{
/*
*加密用的Key可以用26个字母和数字组成，最好不要用保留字符，虽然不会错，至于怎么裁决，个人看情况而定
*/
StringcKey="assistant7654321";
//需要加密的字串
StringcSrc="123456";
//加密
longlStart=System.currentTimeMillis();
StringenString=encrypt(cSrc,cKey);
System.out.println("加密后的字串是："+enString);
longlUseTime=System.currentTimeMillis()-lStart;
System.out.println("加密耗时："+lUseTime+"毫秒");
//解密
lStart=System.currentTimeMillis();
StringDeString=decrypt(enString,cKey);
System.out.println("解密后的字串是："+DeString);
lUseTime=System.currentTimeMillis()-lStart;
System.out.println("解密耗时："+lUseTime+"毫秒");
}
}
㈤ java密码加密与解密
以下两个类可以很方便的完成字符串的加密和解密
加密 CryptHelper encrypt（password）
解密 CrypHelper decrypt（password）
代码如下
CryptUtils java
[java]
package gdie lab crypt;
import java io IOException;
import javax crypto Cipher;
import javax crypto KeyGenerator;
import javax crypto SecretKey;
import apache xerces internal impl dv util Base ;
public class CryptUtils {
private static String Algorithm = DES ;
private static byte[] DEFAULT_KEY=new byte[] { };
private static String VALUE_ENCODING= UTF ;
/**
* 生成密钥
*
* @return byte[] 返回生成的密钥
* @throws exception
* 扔出异常
*/
public static byte[] getSecretKey（） throws Exception {
KeyGenerator keygen = KeyGenerator getInstance（Algorithm）
SecretKey deskey = keygen generateKey（）
// if （debug ） System out println （ 生成密钥 +byte hex （deskey getEncoded
// （）））
return deskey getEncoded（）
}
/**
* 将指定的数据根据提供的密钥进行加密
*
* @param input
* 需要加密的数据
* @param key
* 密钥
* @return byte[] 加密后的数据
* @throws Exception
*/
public static byte[] encryptData（byte[] input byte[] key） throws Exception {
SecretKey deskey = new javax crypto spec SecretKeySpec（key Algorithm）
// if （debug ）
// {
// System out println （ 加密前的二进串 +byte hex （input ））
// System out println （ 加密前的字符串 +new String （input ））
//
// }
Cipher c = Cipher getInstance（Algorithm）
c init（Cipher ENCRYPT_MODE deskey）
byte[] cipherByte = c doFinal（input）
// if （debug ） System out println （ 加密后的二进串 +byte hex （cipherByte ））
return cipherByte;
}
public static byte[] encryptData（byte[] input） throws Exception {
return encryptData（input DEFAULT_KEY）
}
/**
* 将给定的已加密的数据通过指定的密钥进行解密
*
* @param input
* 待解密的数据
* @param key
* 密钥
* @return byte[] 解密后的数据
* @throws Exception
*/
public static byte[] decryptData（byte[] input byte[] key） throws Exception {
SecretKey deskey = new javax crypto spec SecretKeySpec（key Algorithm）
// if （debug ） System out println （ 解密前的信息 +byte hex （input ））
Cipher c = Cipher getInstance（Algorithm）
c init（Cipher DECRYPT_MODE deskey）
byte[] clearByte = c doFinal（input）
// if （debug ）
// {
// System out println （ 解密后的二进串 +byte hex （clearByte ））
// System out println （ 解密后的字符串 +（new String （clearByte ）））
//
// }
return clearByte;
}
public static byte[] decryptData（byte[] input） throws Exception {
return decryptData（input DEFAULT_KEY）
}
/**
* 字节码转换成 进制字符串
*
* @param byte[] b 输入要转换的字节码
* @return String 返回转换后的 进制字符串
*/
public static String byte hex（byte[] bytes） {
StringBuilder hs = new StringBuilder（）
for（byte b : bytes）
hs append（String format（ % $ X b））
return hs toString（）
}
public static byte[] hex byte（String content） {
int l=content length（）》 ;
byte[] result=new byte[l];
for（int i= ;i<l;i++） {
int j=i《 ;
String s=content substring（j j+ ）
result[i]=Integer valueOf（s ） byteValue（）
}
return result;
}
/**
* 将字节数组转换为base 编码字符串
* @param buffer
* @return
*/
public static String bytesToBase （byte[] buffer） {
//BASE Encoder en=new BASE Encoder（）
return Base encode（buffer）
// return encoder encode（buffer）
}
/**
* 将base 编码的字符串解码为字节数组
* @param value
* @return
* @throws IOException
*/
public static byte[] base ToBytes（String value） throws IOException {
//return Base decodeToByteArray（value）
// System out println（decoder decodeBuffer（value））
// return decoder decodeBuffer（value）
return Base decode（value）
}
/**
* 加密给定的字符串
* @param value
* @return 加密后的base 字符串
*/
public static String encryptString（String value） {
return encryptString（value DEFAULT_KEY）
}
/**
* 根据给定的密钥加密字符串
* @param value 待加密的字符串
* @param key 以BASE 形式存在的密钥
* @return 加密后的base 字符串
* @throws IOException
*/
public static String encryptString（String value String key） throws IOException {
return encryptString（value base ToBytes（key））
}
/**
* 根据给定的密钥加密字符串
* @param value 待加密的字符串
* @param key 字节数组形式的密钥
* @return 加密后的base 字符串
*/
public static String encryptString（String value byte[] key） {
try {
byte[] data=value getBytes（VALUE_ENCODING）
data=CryptUtils encryptData（data key）
return bytesToBase （data）
} catch （Exception e） {
// TODO Auto generated catch block
e printStackTrace（）
return null;
}
}
/**
* 解密字符串
* @param value base 形式存在的密文
* @return 明文
*/
public static String decryptString（String value） {
return decryptString（value DEFAULT_KEY）
}
/**
* 解密字符串
* @param value base 形式存在的密文
* @param key base 形式存在的密钥
* @return 明文
* @throws IOException
*/
public static String decryptString（String value String key） throws IOException {
String s=decryptString（value base ToBytes（key））
return s;
}
/**
* 解密字符串
* @param value base 形式存在的密文
* @param key 字节数据形式存在的密钥
* @return 明文
*/
public static String decryptString（String value byte[] key） {
try {
byte[] data=base ToBytes（value）
data=CryptUtils decryptData（data key）
return new String（data VALUE_ENCODING）
}catch（Exception e） {
e printStackTrace（）
return null;
}
}
}
package gdie lab crypt;
import java io IOException;
import javax crypto Cipher;
import javax crypto KeyGenerator;
import javax crypto SecretKey;
import apache xerces internal impl dv util Base ;
public class CryptUtils {
private static String Algorithm = DES ;
private static byte[] DEFAULT_KEY=new byte[] { };
private static String VALUE_ENCODING= UTF ;
/**
* 生成密钥
*
* @return byte[] 返回生成的密钥
* @throws exception
* 扔出异常
*/
public static byte[] getSecretKey（） throws Exception {
KeyGenerator keygen = KeyGenerator getInstance（Algorithm）
SecretKey deskey = keygen generateKey（）
// if （debug ） System out println （ 生成密钥 +byte hex （deskey getEncoded
// （）））
return deskey getEncoded（）
}
/**
* 将指定的数据根据提供的密钥进行加密
*
* @param input
* 需要加密的数据
* @param key
* 密钥
* @return byte[] 加密后的数据
* @throws Exception
*/
public static byte[] encryptData（byte[] input byte[] key） throws Exception {
SecretKey deskey = new javax crypto spec SecretKeySpec（key Algorithm）
// if （debug ）
// {
// System out println （ 加密前的二进串 +byte hex （input ））
// System out println （ 加密前的字符串 +new String （input ））
//
// }
Cipher c = Cipher getInstance（Algorithm）
c init（Cipher ENCRYPT_MODE deskey）
byte[] cipherByte = c doFinal（input）
// if （debug ） System out println （ 加密后的二进串 +byte hex （cipherByte ））
return cipherByte;
}
public static byte[] encryptData（byte[] input） throws Exception {
return encryptData（input DEFAULT_KEY）
}
/**
* 将给定的已加密的数据通过指定的密钥进行解密
*
* @param input
* 待解密的数据
* @param key
* 密钥
* @return byte[] 解密后的数据
* @throws Exception
*/
public static byte[] decryptData（byte[] input byte[] key） throws Exception {
SecretKey deskey = new javax crypto spec SecretKeySpec（key Algorithm）
// if （debug ） System out println （ 解密前的信息 +byte hex （input ））
Cipher c = Cipher getInstance（Algorithm）
c init（Cipher DECRYPT_MODE deskey）
byte[] clearByte = c doFinal（input）
// if （debug ）
// {
// System out println （ 解密后的二进串 +byte hex （clearByte ））
// System out println （ 解密后的字符串 +（new String （clearByte ）））
//
// }
return clearByte;
}
public static byte[] decryptData（byte[] input） throws Exception {
return decryptData（input DEFAULT_KEY）
}
/**
* 字节码转换成 进制字符串
*
* @param byte[] b 输入要转换的字节码
* @return String 返回转换后的 进制字符串
*/
public static String byte hex（byte[] bytes） {
StringBuilder hs = new StringBuilder（）
for（byte b : bytes）
hs append（String format（ % $ X b））
return hs toString（）
}
public static byte[] hex byte（String content） {
int l=content length（）》 ;
byte[] result=new byte[l];
for（int i= ;i<l;i++） {
int j=i《 ;
String s=content substring（j j+ ）
result[i]=Integer valueOf（s ） byteValue（）
}
return result;
}
/**
* 将字节数组转换为base 编码字符串
* @param buffer
* @return
*/
public static String bytesToBase （byte[] buffer） {
//BASE Encoder en=new BASE Encoder（）
return Base encode（buffer）
// return encoder encode（buffer）
}
/**
* 将base 编码的字符串解码为字节数组
* @param value
* @return
* @throws IOException
*/
public static byte[] base ToBytes（String value） throws IOException {
//return Base decodeToByteArray（value）
// System out println（decoder decodeBuffer（value））
// return decoder decodeBuffer（value）
return Base decode（value）
}
/**
* 加密给定的字符串
* @param value
* @return 加密后的base 字符串
*/
public static String encryptString（String value） {
return encryptString（value DEFAULT_KEY）
}
/**
* 根据给定的密钥加密字符串
* @param value 待加密的字符串
* @param key 以BASE 形式存在的密钥
* @return 加密后的base 字符串
* @throws IOException
*/
public static String encryptString（String value String key） throws IOException {
return encryptString（value base ToBytes（key））
}
/**
* 根据给定的密钥加密字符串
* @param value 待加密的字符串
* @param key 字节数组形式的密钥
* @return 加密后的base 字符串
*/
public static String encryptString（String value byte[] key） {
try {
byte[] data=value getBytes（VALUE_ENCODING）
data=CryptUtils encryptData（data key）
return bytesToBase （data）
} catch （Exception e） {
// TODO Auto generated catch block
e printStackTrace（）
return null;
}
}
/**
* 解密字符串
* @param value base 形式存在的密文
* @return 明文
*/
public static String decryptString（String value） {
return decryptString（value DEFAULT_KEY）
}
/**
* 解密字符串
* @param value base 形式存在的密文
* @param key base 形式存在的密钥
* @return 明文
* @throws IOException
*/
public static String decryptString（String value String key） throws IOException {
String s=decryptString（value base ToBytes（key））
return s;
}
/**
* 解密字符串
* @param value base 形式存在的密文
* @param key 字节数据形式存在的密钥
* @return 明文
*/
public static String decryptString（String value byte[] key） {
try {
byte[] data=base ToBytes（value）
data=CryptUtils decryptData（data key）
return new String（data VALUE_ENCODING）
}catch（Exception e） {
e printStackTrace（）
return null;
}
}
}
CryptHelper java
[java]
package gdie lab crypt;
import javax crypto Cipher;
import javax crypto SecretKey;
import javax crypto SecretKeyFactory;
import javax crypto spec DESKeySpec;
import javax crypto spec IvParameterSpec;
import springframework util DigestUtils;
public class CryptHelper{
private static String CRYPT_KEY = zhongqian ;
//加密
private static Cipher ecip;
//解密
private static Cipher dcip;
static {
try {
String KEY = DigestUtils md DigestAsHex（CRYPT_KEY getBytes（）） toUpperCase（）
KEY = KEY substring（ ）
byte[] bytes = KEY getBytes（）
DESKeySpec ks = new DESKeySpec（bytes）
SecretKeyFactory skf = SecretKeyFactory getInstance（ DES ）
SecretKey sk = skf generateSecret（ks）
IvParameterSpec iv = new IvParameterSpec（bytes）
ecip = Cipher getInstance（ DES/CBC/PKCS Padding ）
ecip init（Cipher ENCRYPT_MODE sk iv ）
dcip = Cipher getInstance（ DES/CBC/PKCS Padding ）
dcip init（Cipher DECRYPT_MODE sk iv ）
}catch（Exception ex） {
ex printStackTrace（）
}
}
public static String encrypt（String content） throws Exception {
byte[] bytes = ecip doFinal（content getBytes（ ascii ））
return CryptUtils byte hex（bytes）
}
public static String decrypt（String content） throws Exception {
byte[] bytes = CryptUtils hex byte（content）
bytes = dcip doFinal（bytes）
return new String（bytes ascii ）
}
//test
public static void main（String[] args） throws Exception {
String password = gly ;
String en = encrypt（password）
System out println（en）
System out println（decrypt（en））
}
}
package gdie lab crypt;
import javax crypto Cipher;
import javax crypto SecretKey;
import javax crypto SecretKeyFactory;
import javax crypto spec DESKeySpec;
import javax crypto spec IvParameterSpec;
import springframework util DigestUtils;
public class CryptHelper{
private static String CRYPT_KEY = zhongqian ;
//加密
private static Cipher ecip;
//解密
private static Cipher dcip;
static {
try {
String KEY = DigestUtils md DigestAsHex（CRYPT_KEY getBytes（）） toUpperCase（）
KEY = KEY substring（ ）
byte[] bytes = KEY getBytes（）
DESKeySpec ks = new DESKeySpec（bytes）
SecretKeyFactory skf = SecretKeyFactory getInstance（ DES ）
SecretKey sk = skf generateSecret（ks）
IvParameterSpec iv = new IvParameterSpec（bytes）
ecip = Cipher getInstance（ DES/CBC/PKCS Padding ）
ecip init（Cipher ENCRYPT_MODE sk iv ）
dcip = Cipher getInstance（ DES/CBC/PKCS Padding ）
dcip init（Cipher DECRYPT_MODE sk iv ）
}catch（Exception ex） {
ex printStackTrace（）
}
}
public static String encrypt（String content） throws Exception {
byte[] bytes = ecip doFinal（content getBytes（ ascii ））
return CryptUtils byte hex（bytes）
}
public static String decrypt（String content） throws Exception {
byte[] bytes = CryptUtils hex byte（content）
bytes = dcip doFinal（bytes）
return new String（bytes ascii ）
}
//test
public static void main（String[] args） throws Exception {
String password = gly ;
String en = encrypt（password）
System out println（en）
System out println（decrypt（en））
}
lishixin/Article/program/Java/hx/201311/26449
㈥ java 密码加密后为什么不能解密
首先确认你的加密算法是可逆的，比如DES/RSA，如果是MD5/SHA这类的哈希算法是没有对应算法解密的。
其次确认你的解密算法与加密时是匹配的，算法和参数都要匹配。
㈦ Java加密与解密的艺术创作背景
JavaEE技术在企业应用领域中占据了主导地位，无论是金融、医疗、教育等，都能看到其身影。加密与解密技术的不断发展，为JavaEE技术提供了强大的安全保障。在数据安全成为企业核心竞争力的今天，Java加密与解密技术已成关键。
企业架构师对于加密与解密算法在应用中的使用尤为关注，例如用户密码加密、网络协议加密等。然而，面对众多的Java加密与解密技术，如何选择合适的算法进行企业级应用开发，如何在开发过程中解决各种问题，成为开发者特别是架构师的难题。在国内，尚无一本书能全面解决这些问题。
本书作者在工作中运用Java加密与解密技术成功搭建了企业级应用网银系统，深刻体会到了技术的精妙。他希望通过本书，将自己在企业应用开发领域的经验和心得分享给广大读者，以提升企业应用的安全性。
Java加密与解密技术，如同艺术创作，需要精细的构思、巧妙的布局和严谨的执行。本书不仅介绍了各种加密与解密算法的基本原理和应用场景，还详细阐述了在实际开发中如何选择和应用这些技术，以及在开发过程中可能遇到的问题和解决策略。
对于开发者而言，本书不仅提供了一套完整的Java加密与解密技术解决方案，更是一次深入理解技术内涵、提升实战能力的宝贵机会。通过阅读本书，读者能够系统地掌握Java加密与解密技术的核心知识，提升在企业级应用开发中的安全防护能力，为构建安全、高效、稳定的系统提供坚实的技术支持。
在数字化时代，数据安全成为了企业生存和发展的命脉。Java加密与解密技术作为保护数据安全的关键手段，其重要性不言而喻。本书旨在通过详实的案例分析、深入的技术解析，以及实用的开发指导，帮助读者掌握Java加密与解密技术的核心精髓，从而在企业级应用开发中发挥出关键作用，为企业数据安全保驾护航。
㈧ JAVA加密解密要用到的JAR包
一般java加密解密都需要jar包的，不同的加解密方式对应
不同的加解密包，一般加解密方式有这么几种。
资料链接：http://www.doc88.com/p-19252566394.html