java加密解密工具_java实现aes加密或者解密不用工具包的怎么做

Ⅰ 有什么好的java 加密解密方法，求共享

下面是我的一个工具类，你看下：

packagecom.sojson.common.utils;

importjava.security.MessageDigest;
importjava.security.NoSuchAlgorithmException;
importjava.security.SecureRandom;

importjavax.crypto.Cipher;
importjavax.crypto.KeyGenerator;
importjavax.crypto.SecretKey;
importjavax.crypto.SecretKeyFactory;
importjavax.crypto.spec.DESKeySpec;
/**
*
*开发公司：SOJSON在线工具<p>
*版权所有：©www.sojson.com
*博客地址：http://www.sojson.com/blog/
*<p>
*
*注释写这里
*
*<p>
*
*区分责任人日期说明<br/>
*创建周柏成2017年3月13日<br/>
*
*@authorzhou-cheng
*@[email protected]
*@version1.0,2015年1月18日<br/>
*
*/
publicclassEncrypt{
publicstaticfinalStringgetMD5(Stringtext){
//returntext;
byte[]intext=text.getBytes();
MessageDigestmd5=null;
try{
md5=MessageDigest.getInstance("MD5");
}catch(NoSuchAlgorithmExceptione){
thrownewRuntimeException(e);
}
byte[]md5rslt=md5.digest(intext);
StringBufferverifyMsg=newStringBuffer();
for(inti=0;i<md5rslt.length;i++){
inthexChar=0xFF&md5rslt[i];
StringhexString=Integer.toHexString(hexChar);
hexString=(hexString.length()==1)?"0"+hexString:hexString;
verifyMsg.append(hexString);
}
returnverifyMsg.toString().toLowerCase();
}

publicstaticbyte[]key={-42,1,25,25,-57,84,67,32};

staticbyte[]encrypt(byte[]data,byte[]b)throwsException{
DESKeySpecdks=newDESKeySpec(b);
SecretKeyFactorykeyFactory=SecretKeyFactory.getInstance("DES");
SecretKeykey=keyFactory.generateSecret(dks);
SecureRandomsr=newSecureRandom();
Ciphercipher=Cipher.getInstance("DES");
cipher.init(Cipher.ENCRYPT_MODE,key,sr);
byte[]encryptedData=cipher.doFinal(data);
returnencryptedData;
}

staticbyte[]decrypt(byte[]data,byte[]b)throwsException{
DESKeySpecdks=newDESKeySpec(b);
SecretKeyFactorykeyFactory=SecretKeyFactory.getInstance("DES");
SecretKeykey=keyFactory.generateSecret(dks);
SecureRandomsr=newSecureRandom();
Ciphercipher=Cipher.getInstance("DES");
cipher.init(Cipher.DECRYPT_MODE,key,sr);
byte[]decryptedData=cipher.doFinal(data);
returndecryptedData;
}

staticbyte[]getKey()throwsException{
SecureRandomsr=newSecureRandom();
KeyGeneratorkg=KeyGenerator.getInstance("DES");
kg.init(sr);
SecretKeykey=kg.generateKey();
byte[]b=key.getEncoded();
returnb;
}

publicstaticStringshortUrl(Stringurl,intrandom){
//可以自定义生成MD5加密字符传前的混合KEY
Stringkey="gohome";
//要使用生成URL的字符
String[]chars=newString[]{"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","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"};

//对传入网址进行MD5加密
StringsMD5EncryptResult=getMD5(key+url);
Stringhex=sMD5EncryptResult;
String[]resUrl=newString[4];
for(inti=0;i<4;i++){
//把加密字符按照8位一组16进制与0x3FFFFFFF进行位与运算
StringsTempSubString=hex.substring(i*8,i*8+8);
//这里需要使用long型来转换，因为Inteper.parseInt()只能处理31位,首位为符号位,如果不用
//long，则会越界
longlHexLong=0x3FFFFFFF&Long.parseLong(sTempSubString,16);
StringoutChars="";
for(intj=0;j<6;j++){
//把得到的值与0x0000003D进行位与运算，取得字符数组chars索引
longindex=0x0000003D&lHexLong;
//把取得的字符相加
outChars+=chars[(int)index];
//每次循环按位右移5位
lHexLong=lHexLong>>5;
}
//把字符串存入对应索引的输出数组
resUrl[i]=outChars;
}
returnresUrl[random];
}

//6位短连接
publicstaticStringshortUrl(Stringurl){
//可以自定义生成MD5加密字符传前的混合KEY
Stringkey=String.valueOf(System.currentTimeMillis());
//要使用生成URL的字符
String[]chars=newString[]{"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","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"

};
//对传入网址进行MD5加密
StringsMD5EncryptResult=getMD5(key+url);
Stringhex=sMD5EncryptResult;
StringresUrl="";
//把加密字符按照8位一组16进制与0x3FFFFFFF进行位与运算
StringsTempSubString=hex.substring(0*8,0*8+8);
//这里需要使用long型来转换，因为Inteper.parseInt()只能处理31位,首位为符号位,如果不用
//long，则会越界
longlHexLong=0x3FFFFFFF&Long.parseLong(sTempSubString,16);
StringoutChars="";
for(intj=0;j<6;j++){
//把得到的值与0x0000003D进行位与运算，取得字符数组chars索引
longindex=0x0000003D&lHexLong;
//把取得的字符相加
outChars+=chars[(int)index];
//每次循环按位右移5位
lHexLong=lHexLong>>5;
}
//把字符串存入对应索引的输出数组
resUrl=outChars;
returnresUrl;
}

/**
*方法描述:md5签名
*
*@paramsrc
*@return
*@throwsException
*/
publicstaticStringmd5Digest(Stringsrc)throwsException{
MessageDigestmd=MessageDigest.getInstance("MD5");
byte[]b=md.digest(src.getBytes("UTF-8"));
returnbyte2HexStr(b);
}

/**
*字节数组转化为大写16进制字符串
*
*@paramb
*@return
*/
publicstaticStringbyte2HexStr(byte[]b){
StringBuildersb=newStringBuilder();
for(inti=0;i<b.length;i++){
Strings=Integer.toHexString(b[i]&0xFF);
if(s.length()==1){
sb.append("0");
}
sb.append(s.toUpperCase());
}
returnsb.toString();
}

}

Ⅱ 如何使用JAVA实现对字符串的DES加密和解密

java加密字符串可以使用des加密算法，实例如下：
package test;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.security.*;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
/**
* 加密解密
*
* @author shy.qiu
* @since http://blog.csdn.net/qiushyfm
*/
public class CryptTest {
/**
* 进行MD5加密
*
* @param info
* 要加密的信息
* @return String 加密后的字符串
*/
public String encryptToMD5(String info) {
byte[] digesta = null;
try {
// 得到一个md5的消息摘要
MessageDigest alga = MessageDigest.getInstance("MD5");
// 添加要进行计算摘要的信息
alga.update(info.getBytes());
// 得到该摘要
digesta = alga.digest();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
// 将摘要转为字符串
String rs = byte2hex(digesta);
return rs;
}
/**
* 进行SHA加密
*
* @param info
* 要加密的信息
* @return String 加密后的字符串
*/
public String encryptToSHA(String info) {
byte[] digesta = null;
try {
// 得到一个SHA-1的消息摘要
MessageDigest alga = MessageDigest.getInstance("SHA-1");
// 添加要进行计算摘要的信息
alga.update(info.getBytes());
// 得到该摘要
digesta = alga.digest();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
// 将摘要转为字符串
String rs = byte2hex(digesta);
return rs;
}
// //////////////////////////////////////////////////////////////////////////
/**
* 创建密匙
*
* @param algorithm
* 加密算法,可用 DES,DESede,Blowfish
* @return SecretKey 秘密（对称）密钥
*/
public SecretKey createSecretKey(String algorithm) {
// 声明KeyGenerator对象
KeyGenerator keygen;
// 声明密钥对象
SecretKey deskey = null;
try {
// 返回生成指定算法的秘密密钥的 KeyGenerator 对象
keygen = KeyGenerator.getInstance(algorithm);
// 生成一个密钥
deskey = keygen.generateKey();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
// 返回密匙
return deskey;
}
/**
* 根据密匙进行DES加密
*
* @param key
* 密匙
* @param info
* 要加密的信息
* @return String 加密后的信息
*/
public String encryptToDES(SecretKey key, String info) {
// 定义加密算法,可用 DES,DESede,Blowfish
String Algorithm = "DES";
// 加密随机数生成器 (RNG),(可以不写)
SecureRandom sr = new SecureRandom();
// 定义要生成的密文
byte[] cipherByte = null;
try {
// 得到加密/解密器
Cipher c1 = Cipher.getInstance(Algorithm);
// 用指定的密钥和模式初始化Cipher对象
// 参数:(ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE,UNWRAP_MODE)
c1.init(Cipher.ENCRYPT_MODE, key, sr);
// 对要加密的内容进行编码处理,
cipherByte = c1.doFinal(info.getBytes());
} catch (Exception e) {
e.printStackTrace();
}
// 返回密文的十六进制形式
return byte2hex(cipherByte);
}
/**
* 根据密匙进行DES解密
*
* @param key
* 密匙
* @param sInfo
* 要解密的密文
* @return String 返回解密后信息
*/
public String decryptByDES(SecretKey key, String sInfo) {
// 定义加密算法,
String Algorithm = "DES";
// 加密随机数生成器 (RNG)
SecureRandom sr = new SecureRandom();
byte[] cipherByte = null;
try {
// 得到加密/解密器
Cipher c1 = Cipher.getInstance(Algorithm);
// 用指定的密钥和模式初始化Cipher对象
c1.init(Cipher.DECRYPT_MODE, key, sr);
// 对要解密的内容进行编码处理
cipherByte = c1.doFinal(hex2byte(sInfo));
} catch (Exception e) {
e.printStackTrace();
}
// return byte2hex(cipherByte);
return new String(cipherByte);
}
// /////////////////////////////////////////////////////////////////////////////
/**
* 创建密匙组，并将公匙，私匙放入到指定文件中
*
* 默认放入mykeys.bat文件中
*/
public void createPairKey() {
try {
// 根据特定的算法一个密钥对生成器
KeyPairGenerator keygen = KeyPairGenerator.getInstance("DSA");
// 加密随机数生成器 (RNG)
SecureRandom random = new SecureRandom();
// 重新设置此随机对象的种子
random.setSeed(1000);
// 使用给定的随机源（和默认的参数集合）初始化确定密钥大小的密钥对生成器
keygen.initialize(512, random);// keygen.initialize(512);
// 生成密钥组
KeyPair keys = keygen.generateKeyPair();
// 得到公匙
PublicKey pubkey = keys.getPublic();
// 得到私匙
PrivateKey prikey = keys.getPrivate();
// 将公匙私匙写入到文件当中
doObjToFile("mykeys.bat", new Object[] { prikey, pubkey });
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
}
/**
* 利用私匙对信息进行签名把签名后的信息放入到指定的文件中
*
* @param info
* 要签名的信息
* @param signfile
* 存入的文件
*/
public void signToInfo(String info, String signfile) {
// 从文件当中读取私匙
PrivateKey myprikey = (PrivateKey) getObjFromFile("mykeys.bat", 1);
// 从文件中读取公匙
PublicKey mypubkey = (PublicKey) getObjFromFile("mykeys.bat", 2);
try {
// Signature 对象可用来生成和验证数字签名
Signature signet = Signature.getInstance("DSA");
// 初始化签署签名的私钥
signet.initSign(myprikey);
// 更新要由字节签名或验证的数据
signet.update(info.getBytes());
// 签署或验证所有更新字节的签名，返回签名
byte[] signed = signet.sign();
// 将数字签名,公匙,信息放入文件中
doObjToFile(signfile, new Object[] { signed, mypubkey, info });
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 读取数字签名文件根据公匙，签名，信息验证信息的合法性
*
* @return true 验证成功 false 验证失败
*/
public boolean validateSign(String signfile) {
// 读取公匙
PublicKey mypubkey = (PublicKey) getObjFromFile(signfile, 2);
// 读取签名
byte[] signed = (byte[]) getObjFromFile(signfile, 1);
// 读取信息
String info = (String) getObjFromFile(signfile, 3);
try {
// 初始一个Signature对象,并用公钥和签名进行验证
Signature signetcheck = Signature.getInstance("DSA");
// 初始化验证签名的公钥
signetcheck.initVerify(mypubkey);
// 使用指定的 byte 数组更新要签名或验证的数据
signetcheck.update(info.getBytes());
System.out.println(info);
// 验证传入的签名
return signetcheck.verify(signed);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将二进制转化为16进制字符串
*
* @param b
* 二进制字节数组
* @return String
*/
public 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();
}
/**
* 十六进制字符串转化为2进制
*
* @param hex
* @return
*/
public byte[] hex2byte(String hex) {
byte[] ret = new byte[8];
byte[] tmp = hex.getBytes();
for (int i = 0; i < 8; i++) {
ret[i] = uniteBytes(tmp[i * 2], tmp[i * 2 + 1]);
}
return ret;
}
/**
* 将两个ASCII字符合成一个字节；如："EF"--> 0xEF
*
* @param src0
* byte
* @param src1
* byte
* @return byte
*/
public static byte uniteBytes(byte src0, byte src1) {
byte _b0 = Byte.decode("0x" + new String(new byte[] { src0 }))
.byteValue();
_b0 = (byte) (_b0 << 4);
byte _b1 = Byte.decode("0x" + new String(new byte[] { src1 }))
.byteValue();
byte ret = (byte) (_b0 ^ _b1);
return ret;
}
/**
* 将指定的对象写入指定的文件
*
* @param file
* 指定写入的文件
* @param objs
* 要写入的对象
*/
public void doObjToFile(String file, Object[] objs) {
ObjectOutputStream oos = null;
try {
FileOutputStream fos = new FileOutputStream(file);
oos = new ObjectOutputStream(fos);
for (int i = 0; i < objs.length; i++) {
oos.writeObject(objs[i]);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 返回在文件中指定位置的对象
*
* @param file
* 指定的文件
* @param i
* 从1开始
* @return
*/
public Object getObjFromFile(String file, int i) {
ObjectInputStream ois = null;
Object obj = null;
try {
FileInputStream fis = new FileInputStream(file);
ois = new ObjectInputStream(fis);
for (int j = 0; j < i; j++) {
obj = ois.readObject();
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return obj;
}
/**
* 测试
*
* @param args
*/
public static void main(String[] args) {
CryptTest jiami = new CryptTest();
// 执行MD5加密"Hello world!"
System.out.println("Hello经过MD5:" + jiami.encryptToMD5("Hello"));
// 生成一个DES算法的密匙
SecretKey key = jiami.createSecretKey("DES");
// 用密匙加密信息"Hello world!"
String str1 = jiami.encryptToDES(key, "Hello");
System.out.println("使用des加密信息Hello为:" + str1);
// 使用这个密匙解密
String str2 = jiami.decryptByDES(key, str1);
System.out.println("解密后为：" + str2);
// 创建公匙和私匙
jiami.createPairKey();
// 对Hello world!使用私匙进行签名
jiami.signToInfo("Hello", "mysign.bat");
// 利用公匙对签名进行验证。
if (jiami.validateSign("mysign.bat")) {
System.out.println("Success!");
} else {
System.out.println("Fail!");
}
}
}

Ⅲ java实现aes加密或者解密，不用工具包的怎么做

importjava.security.InvalidKeyException;
importjava.security.Key;
importjava.security.NoSuchAlgorithmException;

importjavax.crypto.*;
importjavax.crypto.spec.*;

/**
*
*@authorwchun
*
*AES128算法，加密模式为ECB，填充模式为pkcs7（实际就是pkcs5）
*
*
*/
publicclassAES{
	
	staticfinalStringalgorithmStr="AES/ECB/PKCS5Padding";
	
	;
	
	staticprivateCiphercipher;
	
	staticbooleanisInited=false;
	
	//初始化
	staticprivatevoidinit()
	{
		
		//初始化keyGen
		try{
			keyGen=KeyGenerator.getInstance("AES");
		}catch(NoSuchAlgorithmExceptione){
			//TODOAuto-generatedcatchblock
			e.printStackTrace();
		}
		keyGen.init(128);
		
		//初始化cipher
		try{
			cipher=Cipher.getInstance(algorithmStr);
		}catch(NoSuchAlgorithmExceptione){
			//TODOAuto-generatedcatchblock
			e.printStackTrace();
		}catch(NoSuchPaddingExceptione){
			//TODOAuto-generatedcatchblock
			e.printStackTrace();
		}
		
		isInited=true;
	}
	
	publicstaticbyte[]GenKey()
	{
		if(!isInited)//如果没有初始化过,则初始化
		{
			init();
		}
		returnkeyGen.generateKey().getEncoded();
	}
	
	publicstaticbyte[]Encrypt(byte[]content,byte[]keyBytes)
	{
		byte[]encryptedText=null;
		
		if(!isInited)//为初始化
		{
			init();
		}
		
		Keykey=newSecretKeySpec(keyBytes,"AES");
		
		try{
			cipher.init(Cipher.ENCRYPT_MODE,key);
		}catch(InvalidKeyExceptione){
			//TODOAuto-generatedcatchblock
			e.printStackTrace();
		}
		
		try{
			encryptedText=cipher.doFinal(content);
		}catch(IllegalBlockSizeExceptione){
			//TODOAuto-generatedcatchblock
			e.printStackTrace();
		}catch(BadPaddingExceptione){
			//TODOAuto-generatedcatchblock
			e.printStackTrace();
		}
		
		returnencryptedText;
	}
	
	//解密为byte[]
	publicstaticbyte[]DecryptToBytes(byte[]content,byte[]keyBytes)
	{
		byte[]originBytes=null;
		if(!isInited)
		{
			init();
		}
		
		Keykey=newSecretKeySpec(keyBytes,"AES");
		
		try{
			cipher.init(Cipher.DECRYPT_MODE,key);
		}catch(InvalidKeyExceptione){
			//TODOAuto-generatedcatchblock
			e.printStackTrace();
		}
		
		//解密
		try{
			originBytes=cipher.doFinal(content);
		}catch(IllegalBlockSizeExceptione){
			//TODOAuto-generatedcatchblock
			e.printStackTrace();
		}catch(BadPaddingExceptione){
			//TODOAuto-generatedcatchblock
			e.printStackTrace();
		}
		
		returnoriginBytes;
	}
}

Ⅳ JAVA程序加密，怎么做才安全

程序加密？你说的是代码加密还是数据加密。我都说一下吧。

Java代码加密：

这点因为Java是开源的，想达到完全加密，基本是不可能的，因为在反编译的时候，虽然反编译回来的时候可能不是您原来的代码，但是意思是接近的，所以是不行的。

那么怎么增加反编译的难度（阅读难度），那么可以采用多层继承（实现）方式来解决，这样即使反编译出来的代码，可读性太差，复用性太差了。

Java数据加密：

我们一般用校验性加密，常用的是MD5，优点是速度快，数据占用空间小。缺点是不可逆，所以我们一般用来校验数据有没有被改动等。

需要可逆，可以选用base64，Unicode，缺点是没有密钥，安全性不高。

而我们需要可逆而且采用安全的方式是：对称加密和非堆成加密，我们常用的有AES、DES等单密钥和双密钥的方式。而且是各种语言通用的。

全部手动敲字，望采纳，下面是我用Javascript方式做的一系列在线加密/解密工具：

http://www.sojson.com/encrypt.html

Ⅳ java进行3des加密传过来的数据，php怎么解密

<?php
/**
* 3DES加解密类
* @Author: 黎志斌
* @version: v1.0
* 2016年7月21日
*/
class Encrypt
{
//加密秘钥，
private $_key;
private $_iv;
public function __construct($key, $iv)
{
$this->_key = $key;
$this->_iv = $iv;
}

/**
* 对字符串进行3DES加密
* @param string 要加密的字符串
* @return mixed 加密成功返回加密后的字符串，否则返回false
*/
public function encrypt3DES($str)
{
$td = mcrypt_mole_open(MCRYPT_3DES, "", MCRYPT_MODE_CBC, "");
if ($td === false) {
return false;
}
//检查加密key，iv的长度是否符合算法要求
$key = $this->fixLen($this->_key, mcrypt_enc_get_key_size($td));
$iv = $this->fixLen($this->_iv, mcrypt_enc_get_iv_size($td));

//加密数据长度处理
$str = $this->strPad($str, mcrypt_enc_get_block_size($td));

if (mcrypt_generic_init($td, $key, $iv) !== 0) {
return false;
}
$result = mcrypt_generic($td, $str);
mcrypt_generic_deinit($td);
mcrypt_mole_close($td);
return $result;
}

/**
* 对加密的字符串进行3DES解密
* @param string 要解密的字符串
* @return mixed 加密成功返回加密后的字符串，否则返回false
*/
public function decrypt3DES($str)
{
$td = mcrypt_mole_open(MCRYPT_3DES, "", MCRYPT_MODE_CBC, "");
if ($td === false) {
return false;
}

//检查加密key，iv的长度是否符合算法要求
$key = $this->fixLen($this->_key, mcrypt_enc_get_key_size($td));
$iv = $this->fixLen($this->_iv, mcrypt_enc_get_iv_size($td));

if (mcrypt_generic_init($td, $key, $iv) !== 0) {
return false;
}

$result = mdecrypt_generic($td, $str);
mcrypt_generic_deinit($td);
mcrypt_mole_close($td);

return $this->strUnPad($result);
}

/**
* 返回适合算法长度的key，iv字符串
* @param string $str key或iv的值
* @param int $td_len 符合条件的key或iv长度
* @return string 返回处理后的key或iv值
*/
private function fixLen($str, $td_len)
{
$str_len = strlen($str);
if ($str_len > $td_len) {
return substr($str, 0, $td_len);
} else if($str_len < $td_len) {
return str_pad($str, $td_len, '0');
}
return $str;
}

/**
* 返回适合算法的分组大小的字符串长度，末尾使用\0补齐
* @param string $str 要加密的字符串
* @param int $td_group_len 符合算法的分组长度
* @return string 返回处理后字符串
*/
private function strPad($str, $td_group_len)
{
$padding_len = $td_group_len - (strlen($str) % $td_group_len);
return str_pad($str, strlen($str) + $padding_len, "\0");
}

/**
* 返回适合算法的分组大小的字符串长度，末尾使用\0补齐
* @param string $str 要加密的字符串
* @return string 返回处理后字符串
*/
private function strUnPad($str)
{
return rtrim($str);
}
}
$key = 'ABCEDFGHIJKLMNOPQ';
$iv = '0123456789';
$des = new Encrypt($key, $iv);
$str = "abcdefghijklmnopq";
echo "source: {$str},len: ",strlen($str),"\r\n";
$e_str = $des->encrypt3DES($str);
echo "entrypt: ", $e_str, "\r\n";
$d_str = $des->decrypt3DES($e_str);
echo "dntrypt: {$d_str},len: ",strlen($d_str),"\r\n";

Ⅵ 如何用JAVA实现字符串简单加密解密

Ⅶ 如何用java实现文件（不只是txt文本）的整体加密解密

importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileOutputStream;
importjava.io.InputStream;
importjava.io.OutputStream;
importjava.security.KeyPair;
importjava.security.KeyPairGenerator;
importjava.security.NoSuchAlgorithmException;
importjava.security.interfaces.RSAPrivateKey;
importjava.security.interfaces.RSAPublicKey;
importjavax.crypto.Cipher;

/**
*文件加密解密
*加解密需要依靠以下四个属性，
	;
	staticKeyPairkeyPair;
	staticRSAPrivateKeyprivateKey;
	staticRSAPublicKeypublicKey;
*@authoryoung
*
*/
publicclassRSAEncrypt{

	;

	staticKeyPairkeyPair;

	staticRSAPrivateKeyprivateKey;

	staticRSAPublicKeypublicKey;

	static{
		try{
			//实例类型
			keyPairGen=KeyPairGenerator.getInstance("RSA");
			//初始化长度
			keyPairGen.initialize(512);
			//声场KeyPair
			keyPair=keyPairGen.generateKeyPair();
			//Generatekeys
			privateKey=(RSAPrivateKey)keyPair.getPrivate();
			publicKey=(RSAPublicKey)keyPair.getPublic();
		}catch(NoSuchAlgorithmExceptione){
			//TODOAuto-generatedcatchblock
			e.printStackTrace();
		}
	}

	publicstaticvoidmain(String[]args){
		RSAEncryptencrypt=newRSAEncrypt();
		Filefile=newFile(
				"C:\DocumentsandSettings\Administrator.DCB5E0D91E0D436\桌面\sdf.txt");
		FilenewFile=newFile(
				"C:\DocumentsandSettings\Administrator.DCB5E0D91E0D436\桌面\sdf1.txt");
		encrypt.encryptFile(encrypt,file,newFile);
		Filefile1=newFile(
				"C:\DocumentsandSettings\Administrator.DCB5E0D91E0D436\桌面\sdf1.txt");
		FilenewFile1=newFile(
				"C:\DocumentsandSettings\Administrator.DCB5E0D91E0D436\桌面\sdf2.txt");
		encrypt.decryptFile(encrypt,file1,newFile1);
	}

	/**
	*加密文件
	*@paramencryptRSAEncrypt对象
	*@paramfile源文件
	*@paramnewFile目标文件
	*/
	publicvoidencryptFile(RSAEncryptencrypt,Filefile,FilenewFile){
		try{
			InputStreamis=newFileInputStream(file);
			OutputStreamos=newFileOutputStream(newFile);

			byte[]bytes=newbyte[53];
			while(is.read(bytes)>0){
				byte[]e=encrypt.encrypt(RSAEncrypt.publicKey,bytes);
				bytes=newbyte[53];
				os.write(e,0,e.length);
			}
			os.close();
			is.close();
			System.out.println("writesuccess");
		}catch(Exceptione){
			e.printStackTrace();
		}
	}

	/**
	*解密文件
	*@paramencryptRSAEncrypt对象
	*@paramfile
	*@paramnewFile
	*/
	publicvoiddecryptFile(RSAEncryptencrypt,Filefile,FilenewFile){
		try{
			InputStreamis=newFileInputStream(file);
			OutputStreamos=newFileOutputStream(newFile);
			byte[]bytes1=newbyte[64];
			while(is.read(bytes1)>0){
				byte[]de=encrypt.decrypt(RSAEncrypt.privateKey,bytes1);
				bytes1=newbyte[64];
				os.write(de,0,de.length);
			}
			os.close();
			is.close();
			System.out.println("writesuccess");

		}catch(Exceptione){
			e.printStackTrace();
		}
	}

	/**
	*加密实现
	**EncryptString.*
	*
	*@returnbyte[]加密后的字节数组
	*/
	protectedbyte[]encrypt(RSAPublicKeypublicKey,byte[]obj){
		if(publicKey!=null){
			try{
				Ciphercipher=Cipher.getInstance("RSA");
				cipher.init(Cipher.ENCRYPT_MODE,publicKey);
				returncipher.doFinal(obj);
			}catch(Exceptione){
				e.printStackTrace();
			}
		}
		returnnull;
	}

	/**
	*解密实现
	**Basicdecryptmethod*
	*
	*@returnbyte[]解密后的字节数组
	*/
	protectedbyte[]decrypt(RSAPrivateKeyprivateKey,byte[]obj){
		if(privateKey!=null){
			try{
				Ciphercipher=Cipher.getInstance("RSA");
				cipher.init(Cipher.DECRYPT_MODE,privateKey);
				returncipher.doFinal(obj);
			}catch(Exceptione){
				e.printStackTrace();
			}
		}
		returnnull;
	}
}

Ⅷ 用Java实现IDEA数据加密解密

随着Internet的迅速发展,电子商务的浪潮势不可挡，日常工作和数据传输都放在Internet网上进行传输,大大提高了效率,降低了成本,创造了良好的效益。但是,由于Internet网络协议本身存在着重要的安全问题(IP包本身并不继承任何安全特性,很容易伪造出IP包的地址、修改其内容、重播以前的包以及在传输途中拦截并查看包的内容),使网上的信息传输存在巨大的安全风险电子商务的安全问题也越来越突出。加密是电子商务中最主要的安全技术,加密方法的选取直接影响电子商务活动中信息的安全程度，在电子商务系统中,主要的安全问题都可以通过加密来解决。数据的保密性可通过不同的加密算法对数据加密来实现。

对我国来讲，虽然可以引进很多的外国设备，但加密设备不能依靠引进，因为它涉及到网络安全、国家机密信息的安全，所以必须自己研制。当前国际上有许多加密算法，其中DES（Data Encryption Standard）是发明最早的用得最广泛的分组对称加密算法，DES用56位蜜钥加密64位明文，输出64位密文，DES的56位密钥共有256 种可能的密钥，但历史上曾利用穷举攻击破解过DES密钥，1998年电子边境基金会（EFF）用25万美元制造的专用计算机，用56小时破解了DES的密钥，1999年，EFF用22小时完成了破解工作，使DES算法受到了严重打击，使它的安全性受到严重威胁。因为JAVA语言的安全性和网络处理能力较强，本文主要介绍使用IDEA（Internation Data Encryption Algorithm ）数据加密算法在Java环境下实现数据的安全传输。

一、IDEA数据加密算法

IDEA数据加密算法是由中国学者来学嘉博士和着名的密码专家 James L. Massey 于1990年联合提出的。它的明文和密文都是64比特，但密钥长为128比特。IDEA 是作为迭代的分组密码实现的，使用 128 位的密钥和 8 个循环。这比 DES 提供了更多的安全性，但是在选择用于 IDEA 的密钥时，应该排除那些称为“弱密钥”的密钥。DES 只有四个弱密钥和 12 个次弱密钥，而 IDEA 中的弱密钥数相当可观，有 2 的 51 次方个。但是，如果密钥的总数非常大，达到 2 的 128 次方个，那么仍有 2 的 77 次方个密钥可供选择。IDEA 被认为是极为安全的。使用 128 位的密钥，蛮力攻击中需要进行的测试次数与 DES 相比会明显增大，甚至允许对弱密钥测试。而且，它本身也显示了它尤其能抵抗专业形式的分析性攻击。

二、Java密码体系和Java密码扩展

Java是Sun公司开发的一种面向对象的编程语言,并且由于它的平台无关性被大量应用于Internet的开发。Java密码体系(JCA)和Java密码扩展(JCE)的设计目的是为Java提供与实现无关的加密函数API。它们都用factory方法来创建类的例程,然后把实际的加密函数委托给提供者指定的底层引擎,引擎中为类提供了服务提供者接口在Java中实现数据的加密/解密,是使用其内置的JCE(Java加密扩展)来实现的。Java开发工具集1.1为实现包括数字签名和信息摘要在内的加密功能,推出了一种基于供应商的新型灵活应用编程接口。Java密码体系结构支持供应商的互操作,同时支持硬件和软件实现。Java密码学结构设计遵循两个原则:(1)算法的独立性和可靠性。(2)实现的独立性和相互作用性。算法的独立性是通过定义密码服务类来获得。用户只需了解密码算法的概念,而不用去关心如何实现这些概念。实现的独立性和相互作用性通过密码服务提供器来实现。密码服务提供器是实现一个或多个密码服务的一个或多个程序包。软件开发商根据一定接口,将各种算法实现后,打包成一个提供器,用户可以安装不同的提供器。安装和配置提供器,可将包含提供器的ZIP和JAR文件放在CLASSPATH下,再编辑Java安全属性文件来设置定义一个提供器。Java运行环境Sun版本时,提供一个缺省的提供器Sun。

三、Java环境下的实现

1．加密过程的实现

void idea_enc( int data11[], /*待加密的64位数据首地址*/ int key1[]){
int i ;
int tmp,x;
int zz[]=new int[6];
for ( i = 0 ; i < 48 ; i += 6) { /*进行8轮循环*/
for(int j=0,box=i;j<6;j++,box++){
zz[j]=key1[box];
}
x = handle_data(data11,zz);
tmp = data11[1]; /*交换中间两个*/
data11[1] = data11[2];
data11[2] = tmp;
}
tmp = data11[1]; /*最后一轮不交换*/
data11[1] = data11[2];
data11[2] = tmp;
data11[0] = MUL(data11[0],key1[48]);
data11[1] =(char)((data11[1] + key1[49])%0x10000);
data11[2] =(char)((data11[2] + key1[50])%0x10000);
data11[3] = MUL(data11[3],key1[51]);
}

2．解密过程的实现

void key_decryExp(int outkey[])/*解密密钥的变逆处理*/
{ int tmpkey[] = new int[52] ;
int i;
for ( i = 0 ; i < 52 ; i++) {
tmpkey[i] = outkey[ wz_spkey[i] ] ;/*换位*/
}
for ( i = 0 ; i < 52 ; i++) {
outkey[i] = tmpkey[i];
}
for ( i = 0 ; i < 18 ; i++) {
outkey[wz_spaddrever[i]] = (char)(65536-outkey[wz_spaddrever[i]]) ;/*替换成加法逆*/
}
for ( i = 0 ; i < 18 ; i++){
outkey[wz_spmulrevr[i]] =(char)(mulInv(outkey[wz_spmulrevr[i]] ));/*替换成乘法逆*/
}
}

四、总结

在实际应用中,我们可以使用Java开发工具包(JDK)中内置的对Socket通信的支持,通过JCE中的Java流和链表,加密基于Socket的网络通信.我们知道,加密/解密是数据传输中保证数据完整性的常用方法,Java语言因其平台无关性,在Internet上的应用非常之广泛.使用Java实现基于IDEA的数据加密传输可以在不同的平台上实现并具有实现简洁、安全性强等优点。

Ⅸ 使用eclipse做一个java工具类，来实现对文件和文字的加密解密怎么做呢使用什么加密算法，求解答！

http://blog.csdn.net/stpeace/article/details/8294980 可以看看这个

导航:首页 > 编程语言 > java加密解密工具

java加密解密工具

与java加密解密工具相关的资料