13518219792
可变在这里含义很简单 就是最终的加密结果是可变的 而非必需按标准MD 加密实现 Java类库security中的MessageDigest类就提供了MD 加密的支持 实现起来非常方便 为了实现更多效果 我们可以如下设计MD 工具类
称多网站建设公司创新互联,称多网站设计制作，有大型网站制作公司丰富经验。已为称多成百上千提供企业网站建设服务。企业网站搭建\外贸网站制作要多少钱，请找那个售后服务好的称多做网站的公司定做！
Java代码
package ** ** util;
import java security MessageDigest;
/**
* 标准MD 加密方法 使用java类库的security包的MessageDigest类处理
* @author Sarin
*/
public class MD {
/**
* 获得MD 加密密码的方法
*/
public static String getMD ofStr(String origString) {
String origMD = null;
try {
MessageDigest md = MessageDigest getInstance( MD );
byte[] result = md digest(origString getBytes());
origMD = byteArray HexStr(result);
} catch (Exception e) {
e printStackTrace();
}
return origMD ;
}
/**
* 处理字节数组得到MD 密码的方法
*/
private static String byteArray HexStr(byte[] bs) {
StringBuffer *** = new StringBuffer();
for (byte b : bs) {
*** append(byte HexStr(b));
}
return *** toString();
}
/**
* 字节标准移位转十六进制方法
*/
private static String byte HexStr(byte b) {
String hexStr = null;
int n = b;
if (n ) {
//若需要自定义加密 请修改这个移位算法即可
n = b x F + ;
}
hexStr = Integer toHexString(n / ) + Integer toHexString(n % );
return hexStr toUpperCase();
}
/**
* 提供一个MD 多次加密方法
*/
public static String getMD ofStr(String origString int times) {
String md = getMD ofStr(origString);
for (int i = ; i times ; i++) {
md = getMD ofStr(md );
}
return getMD ofStr(md );
}
/**
* 密码验证方法
*/
public static boolean verifyPassword(String inputStr String MD Code) {
return getMD ofStr(inputStr) equals(MD Code);
}
/**
* 重载一个多次加密时的密码验证方法
*/
public static boolean verifyPassword(String inputStr String MD Code int times) {
return getMD ofStr(inputStr times) equals(MD Code);
}
/**
* 提供一个测试的主函数
*/
public static void main(String[] args) {
System out println( : + getMD ofStr( ));
System out println( : + getMD ofStr( ));
System out println( sarin: + getMD ofStr( sarin ));
System out println( : + getMD ofStr( ));
}
}
可以看出实现的过程非常简单 因为由java类库提供了处理支持 但是要清楚的是这种方式产生的密码不是标准的MD 码 它需要进行移位处理才能得到标准MD 码 这个程序的关键之处也在这了 怎么可变？调整移位算法不就可变了么！不进行移位 也能够得到 位的密码 这就不是标准加密了 只要加密和验证过程使用相同的算法就可以了
MD 加密还是很安全的 像CMD 那些穷举破解的只是针对标准MD 加密的结果进行的 如果自定义移位算法后 它还有效么？可以说是无解的了 所以MD 非常安全可靠
为了更可变 还提供了多次加密的方法 可以在MD 基础之上继续MD 就是对 位的第一次加密结果再MD 恩 这样去破解？没有任何意义
这样在MIS系统中使用 安全可靠 欢迎交流 希望对使用者有用
我们最后看看由MD 加密算法实现的类 那是非常庞大的
Java代码
import java lang reflect *;
/**
* **********************************************
* md 类实现了RSA Data Security Inc 在提交给IETF
* 的RFC 中的MD message digest 算法
* ***********************************************
*/
public class MD {
/* 下面这些S S 实际上是一个 * 的矩阵 在原始的C实现中是用#define 实现的
这里把它们实现成为static final是表示了只读 切能在同一个进程空间内的多个
Instance间共享*/
static final int S = ;
static final int S = ;
static final int S = ;
static final int S = ;
static final int S = ;
static final int S = ;
static final int S = ;
static final int S = ;
static final int S = ;
static final int S = ;
static final int S = ;
static final int S = ;
static final int S = ;
static final int S = ;
static final int S = ;
static final int S = ;
static final byte[] PADDING = {
};
/* 下面的三个成员是MD 计算过程中用到的 个核心数据 在原始的C实现中
被定义到MD _CTX结构中
*/
private long[] state = new long[ ]; // state (ABCD)
private long[] count = new long[ ]; // number of bits modulo ^ (l *** first)
private byte[] buffer = new byte[ ]; // input buffer
/* digestHexStr是MD 的唯一一个公共成员 是最新一次计算结果的
进制ASCII表示
*/
public String digestHexStr;
/* digest 是最新一次计算结果的 进制内部表示 表示 bit的MD 值
*/
private byte[] digest = new byte[ ];
/*
getMD ofStr是类MD 最主要的公共方法 入口参数是你想要进行MD 变换的字符串
返回的是变换完的结果 这个结果是从公共成员digestHexStr取得的．
*/
public String getMD ofStr(String inbuf) {
md Init();
md Update(inbuf getBytes() inbuf length());
md Final();
digestHexStr = ;
for (int i = ; i ; i++) {
digestHexStr += byteHEX(digest[i]);
}
return digestHexStr;
}
// 这是MD 这个类的标准构造函数 JavaBean要求有一个public的并且没有参数的构造函数
public MD () {
md Init();
return;
}
/* md Init是一个初始化函数 初始化核心变量 装入标准的幻数 */
private void md Init() {
count[ ] = L;
count[ ] = L;
///* Load magic initialization constants
state[ ] = x L;
state[ ] = xefcdab L;
state[ ] = x badcfeL;
state[ ] = x L;
return;
}
/* F G H I 是 个基本的MD 函数 在原始的MD 的C实现中 由于它们是
简单的位运算 可能出于效率的考虑把它们实现成了宏 在java中 我们把它们
实现成了private方法 名字保持了原来C中的 */
private long F(long x long y long z) {
return (x y) | ((~x) z);
}
private long G(long x long y long z) {
return (x z) | (y (~z));
}
private long H(long x long y long z) {
return x ^ y ^ z;
}
private long I(long x long y long z) {
return y ^ (x | (~z));
}
/*
FF GG HH和II将调用F G H I进行近一步变换
FF GG HH and II transformations for rounds and
Rotation is separate from addition to prevent reputation
*/
private long FF(long a long b long c long d long x long s long ac) {
a += F(b c d) + x + ac;
a = ((int) a s) | ((int) a ( s));
a += b;
return a;
}
private long GG(long a long b long c long d long x long s long ac) {
a += G(b c d) + x + ac;
a = ((int) a s) | ((int) a ( s));
a += b;
return a;
}
private long HH(long a long b long c long d long x long s long ac) {
a += H(b c d) + x + ac;
a = ((int) a s) | ((int) a ( s));
a += b;
return a;
}
private long II(long a long b long c long d long x long s long ac) {
a += I(b c d) + x + ac;
a = ((int) a s) | ((int) a ( s));
a += b;
return a;
}
/*
md Update是MD 的主计算过程 inbuf是要变换的字节串 inputlen是长度 这个
函数由getMD ofStr调用 调用之前需要调用md init 因此把它设计成private的
*/
private void md Update(byte[] inbuf int inputLen) {
int i index partLen;
byte[] block = new byte[ ];
index = (int) (count[ ] ) x F;
// /* Update number of bits */
if ((count[ ] += (inputLen )) (inputLen ))
count[ ]++;
count[ ] += (inputLen );
partLen = index;
// Transform as many times as possible
if (inputLen = partLen) {
md Memcpy(buffer inbuf index partLen);
md Transform(buffer);
for (i = partLen; i + inputLen; i += ) {
md Memcpy(block inbuf i );
md Transform(block);
}
index = ;
} else
i = ;
///* Buffer remaining input */
md Memcpy(buffer inbuf index i inputLen i);
}
/*
md Final整理和填写输出结果
*/
private void md Final() {
byte[] bits = new byte[ ];
int index padLen;
///* Save number of bits */
Encode(bits count );
///* Pad out to mod
index = (int) (count[ ] ) x f;
padLen = (index ) ? ( index) : ( index);
md Update(PADDING padLen);
///* Append length (before padding) */
md Update(bits );
///* Store state in digest */
Encode(digest state );
}
/* md Memcpy是一个内部使用的byte数组的块拷贝函数 从input的inpos开始把len长度的
字节拷贝到output的outpos位置开始
*/
private void md Memcpy(byte[] output byte[] input int outpos int inpos int len) {
int i;
for (i = ; i len; i++)
output[outpos + i] = input[inpos + i];
}
/*
md Transform是MD 核心变换程序 有md Update调用 block是分块的原始字节
*/
private void md Transform(byte block[]) {
long a = state[ ] b = state[ ] c = state[ ] d = state[ ];
long[] x = new long[ ];
Decode(x block );
/* Round */
a = FF(a b c d x[ ] S xd aa L); /* */
d = FF(d a b c x[ ] S xe c b L); /* */
c = FF(c d a b x[ ] S x dbL); /* */
b = FF(b c d a x[ ] S xc bdceeeL); /* */
a = FF(a b c d x[ ] S xf c fafL); /* */
d = FF(d a b c x[ ] S x c aL); /* */
c = FF(c d a b x[ ] S xa L); /* */
b = FF(b c d a x[ ] S xfd L); /* */
a = FF(a b c d x[ ] S x d L); /* */
d = FF(d a b c x[ ] S x b f afL); /* */
c = FF(c d a b x[ ] S xffff bb L); /* */
b = FF(b c d a x[ ] S x cd beL); /* */
a = FF(a b c d x[ ] S x b L); /* */
d = FF(d a b c x[ ] S xfd L); /* */
c = FF(c d a b x[ ] S xa eL); /* */
b = FF(b c d a x[ ] S x b L); /* */
/* Round */
a = GG(a b c d x[ ] S xf e L); /* */
d = GG(d a b c x[ ] S xc b L); /* */
c = GG(c d a b x[ ] S x e a L); /* */
b = GG(b c d a x[ ] S xe b c aaL); /* */
a = GG(a b c d x[ ] S xd f dL); /* */
d = GG(d a b c x[ ] S x L); /* */
c = GG(c d a b x[ ] S xd a e L); /* */
b = GG(b c d a x[ ] S xe d fbc L); /* */
a = GG(a b c d x[ ] S x e cde L); /* */
d = GG(d a b c x[ ] S xc d L); /* */
c = GG(c d a b x[ ] S xf d d L); /* */
b = GG(b c d a x[ ] S x a edL); /* */
a = GG(a b c d x[ ] S xa e e L); /* */
d = GG(d a b c x[ ] S xfcefa f L); /* */
c = GG(c d a b x[ ] S x f d L); /* */
b = GG(b c d a x[ ] S x d a c aL); /* */
/* Round */
a = HH(a b c d x[ ] S xfffa L); /* */
d = HH(d a b c x[ ] S x f L); /* */
c = HH(c d a b x[ ] S x d d L); /* */
b = HH(b c d a x[ ] S xfde cL); /* */
a = HH(a b c d x[ ] S xa beea L); /* */
d = HH(d a b c x[ ] S x bdecfa L); /* */
c = HH(c d a b x[ ] S xf bb b L); /* */
b = HH(b c d a x[ ] S xbebfbc L); /* */
a = HH(a b c d x[ ] S x b ec L); /* */
d = HH(d a b c x[ ] S xeaa faL); /* */
c = HH(c d a b x[ ] S xd ef L); /* */
b = HH(b c d a x[ ] S x d L); /* */
a = HH(a b c d x[ ] S xd d d L); /* */
d = HH(d a b c x[ ] S xe db e L); /* */
c = HH(c d a b x[ ] S x fa cf L); /* */
b = HH(b c d a x[ ] S xc ac L); /* */
/* Round */
a = II(a b c d x[ ] S xf L); /* */
d = II(d a b c x[ ] S x aff L); /* */
c = II(c d a b x[ ] S xab a L); /* */
b = II(b c d a x[ ] S xfc a L); /* */
a = II(a b c d x[ ] S x b c L); /* */
d = II(d a b c x[ ] S x f ccc L); /* */
c = II(c d a b x[ ] S xffeff dL); /* */
b = II(b c d a x[ ] S x dd L); /* */
a = II(a b c d x[ ] S x fa e fL); /* */
d = II(d a b c x[ ] S xfe ce e L); /* */
c = II(c d a b x[ ] S xa L); /* */
b = II(b c d a x[ ] S x e a L); /* */
a = II(a b c d x[ ] S xf e L); /* */
d = II(d a b c x[ ] S xbd af L); /* */
c = II(c d a b x[ ] S x ad d bbL); /* */
b = II(b c d a x[ ] S xeb d L); /* */
state[ ] += a;
state[ ] += b;
state[ ] += c;
state[ ] += d;
}
/*Encode把long数组按顺序拆成byte数组 因为java的long类型是 bit的
只拆低 bit 以适应原始C实现的用途
*/
private void Encode(byte[] output long[] input int len) {
int i j;
for (i = j = ; j len; i++ j += ) {
output[j] = (byte) (input[i] xffL);
output[j + ] = (byte) ((input[i] ) xffL);
output[j + ] = (byte) ((input[i] ) xffL);
output[j + ] = (byte) ((input[i] ) xffL);
}
}
/*Decode把byte数组按顺序合成成long数组 因为java的long类型是 bit的
只合成低 bit 高 bit清零 以适应原始C实现的用途
*/
private void Decode(long[] output byte[] input int len) {
int i j;
for (i = j = ; j len; i++ j += )
output[i] = b iu(input[j]) | (b iu(input[j + ]) ) | (b iu(input[j + ]) )
| (b iu(input[j + ]) );
return;
}
/*
b iu是我写的一个把byte按照不考虑正负号的原则的＂升位＂程序 因为java没有unsigned运算
*/
public static long b iu(byte b) {
return b ? b x F + : b;
}
/*byteHEX() 用来把一个byte类型的数转换成十六进制的ASCII表示
因为java中的byte的toString无法实现这一点 我们又没有C语言中的
sprintf(outbuf % X ib)
*/
public static String byteHEX(byte ib) {
char[] Digit = { A B C D E F };
char[] ob = new char[ ];
ob[ ] = Digit[(ib ) X F];
ob[ ] = Digit[ib X F];
String s = new String(ob);
return s;
}
public static void main(String args[]) {
MD m = new MD ();
if (Array getLength(args) == ) { //如果没有参数 执行标准的Test Suite
System out println( MD Test suite: );
System out println( MD (\ \ ): + m getMD ofStr( ));
System out println( MD (\ a\ ): + m getMD ofStr( a ));
System out println( MD (\ abc\ ): + m getMD ofStr( abc ));
System out println( MD (\ \ ): + m getMD ofStr( ));
System out println( MD (\ \ ): + m getMD ofStr( ));
System out println( MD (\ message digest\ ): + m getMD ofStr( message digest ));
System out println( MD (\ abcdefghijklmnopqrstuvwxyz\ ): + m getMD ofStr( abcdefghijklmnopqrstuvwxyz ));
System out println( MD (\ ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz \ ):
+ m getMD ofStr( ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz ));
} else
System out println( MD ( + args[ ] + )= + m getMD ofStr(args[ ]));
}
lishixinzhi/Article/program/Java/hx/201311/26604
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.io.*;
import java.security.*;
import javax.crypto.*;
import javax.crypto.spec.*;
/**
文件名：FileEncrypter.java
JDK：1.40以上
说明：文件加密
加密方法：三重DES加密
加密过程：对选中的文件加密后在同文件夹下生成一个增加了".tdes"
扩展名的加密文件
解密过程：对选中的加密文件（必须有".tdes"扩展名）进行解密
*/
public class FileEncrypter extends JFrame{
public static final int WIDTH = 550;
public static final int HEIGHT = 200;
public static void main(String args[]) {
FileEncrypter fe = new FileEncrypter();
fe.show();
}
FileEncrypter(){
this.setSize(WIDTH,HEIGHT);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setResizable(false);
Toolkit tk = Toolkit.getDefaultToolkit();
Dimension screenSize = tk.getScreenSize();
this.setLocation((screenSize.width - WIDTH)/2,
(screenSize.height - HEIGHT)/2);
this.setTitle("文件加密器(TriDES)");
Container c = this.getContentPane();
c.setLayout( new FlowLayout());
final FilePanel fp = new FilePanel("文件选择");
c.add(fp);
final KeyPanel pp = new KeyPanel("密码");
c.add(pp);
JButton jbE = new JButton("加密");
c.add(jbE);
jbE.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent event){
File file = new File(fp.getFileName());
if (file.exists())
encrypt(file.getAbsoluteFile(),pp.getKey());
else
JOptionPane.showMessageDialog(
null,"请选择文件！","提示",JOptionPane.OK_OPTION);
}
});
JButton jbD = new JButton("解密");
c.add(jbD);
jbD.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent event){
File file = new File(fp.getFileName());
if (file.exists())
decrypt(file.getAbsoluteFile(),pp.getKey());
else
JOptionPane.showMessageDialog(
null,"请选择文件！","提示",JOptionPane.OK_OPTION);
}
});
}
/**
加密函数
输入：
要加密的文件，密码（由0-F组成，共48个字符，表示3个8位的密码）如：
AD67EA2F3BE6E5ADD368DFE03120B5DF92A8FD8FEC2F0746
其中：
AD67EA2F3BE6E5AD DES密码一
D368DFE03120B5DF DES密码二
92A8FD8FEC2F0746 DES密码三
输出：
对输入的文件加密后，保存到同一文件夹下增加了".tdes"扩展名的文件中。
*/
private void encrypt(File fileIn,String sKey){
try{
if(sKey.length() == 48){
byte[] bytK1 = getKeyByStr(sKey.substring(0,16));
byte[] bytK2 = getKeyByStr(sKey.substring(16,32));
byte[] bytK3 = getKeyByStr(sKey.substring(32,48));
FileInputStream fis = new FileInputStream(fileIn);
byte[] bytIn = new byte[(int)fileIn.length()];
for(int i = 0;iFILEIN.LENGTH();I++){
bytIn[i] = (byte)fis.read();
}
//加密
byte[] bytOut = encryptByDES(encryptByDES(
encryptByDES(bytIn,bytK1),bytK2),bytK3);
String fileOut = fileIn.getPath() + ".tdes";
FileOutputStream fos = new FileOutputStream(fileOut);
for(int i = 0;iBYTOUT.LENGTH;I++){
fos.write((int)bytOut[i]);
}
fos.close();
JOptionPane.showMessageDialog(
this,"加密成功！","提示",JOptionPane.OK_OPTION);
}else
JOptionPane.showMessageDialog(
this,"密码长度必须等于48！","错误信息",JOptionPane.ERROR_MESSAGE);
}catch(Exception e){
e.printStackTrace();
}
}
/**
解密函数
输入：
要解密的文件，密码（由0-F组成，共48个字符，表示3个8位的密码）如：
AD67EA2F3BE6E5ADD368DFE03120B5DF92A8FD8FEC2F0746
其中：
AD67EA2F3BE6E5AD DES密码一
D368DFE03120B5DF DES密码二
92A8FD8FEC2F0746 DES密码三
输出：
对输入的文件解密后，保存到用户指定的文件中。
*/
private void decrypt(File fileIn,String sKey){
try{
if(sKey.length() == 48){
String strPath = fileIn.getPath();
if(strPath.substring(strPath.length()-5).toLowerCase().equals(".tdes"))
strPath = strPath.substring(0,strPath.length()-5);
else{
JOptionPane.showMessageDialog(
this,"不是合法的加密文件！","提示",JOptionPane.OK_OPTION);
return;
}
JFileChooser chooser = new JFileChooser();
chooser.setCurrentDirectory(new File("."));
chooser.setSelectedFile(new File(strPath));
//用户指定要保存的文件
int ret = chooser.showSaveDialog(this);
if(ret==JFileChooser.APPROVE_OPTION){
byte[] bytK1 = getKeyByStr(sKey.substring(0,16));
byte[] bytK2 = getKeyByStr(sKey.substring(16,32));
byte[] bytK3 = getKeyByStr(sKey.substring(32,48));
FileInputStream fis = new FileInputStream(fileIn);
byte[] bytIn = new byte[(int)fileIn.length()];
for(int i = 0;iFILEIN.LENGTH();I++){
bytIn[i] = (byte)fis.read();
}
//解密
byte[] bytOut = decryptByDES(decryptByDES(
decryptByDES(bytIn,bytK3),bytK2),bytK1);
File fileOut = chooser.getSelectedFile();
fileOut.createNewFile();
FileOutputStream fos = new FileOutputStream(fileOut);
for(int i = 0;iBYTOUT.LENGTH;I++){
fos.write((int)bytOut[i]);
}
fos.close();
JOptionPane.showMessageDialog(
this,"解密成功！","提示",JOptionPane.OK_OPTION);
}
}else
JOptionPane.showMessageDialog(
this,"密码长度必须等于48！","错误信息",JOptionPane.ERROR_MESSAGE);
}catch(Exception e){
JOptionPane.showMessageDialog(
this,"解密失败，请核对密码！","提示",JOptionPane.OK_OPTION);
}
}
/**
用DES方法加密输入的字节
bytKey需为8字节长，是加密的密码
*/
private byte[] encryptByDES(byte[] bytP,byte[] bytKey) throws Exception{
DESKeySpec desKS = new DESKeySpec(bytKey);
SecretKeyFactory skf = SecretKeyFactory.getInstance("DES");
SecretKey sk = skf.generateSecret(desKS);
Cipher cip = Cipher.getInstance("DES");
cip.init(Cipher.ENCRYPT_MODE,sk);
return cip.doFinal(bytP);
}
/**
用DES方法解密输入的字节
bytKey需为8字节长，是解密的密码
*/
private byte[] decryptByDES(byte[] bytE,byte[] bytKey) throws Exception{
DESKeySpec desKS = new DESKeySpec(bytKey);
SecretKeyFactory skf = SecretKeyFactory.getInstance("DES");
SecretKey sk = skf.generateSecret(desKS);
Cipher cip = Cipher.getInstance("DES");
cip.init(Cipher.DECRYPT_MODE,sk);
return cip.doFinal(bytE);
}
/**
输入密码的字符形式，返回字节数组形式。
如输入字符串：AD67EA2F3BE6E5AD
返回字节数组：{173,103,234,47,59,230,229,173}
*/
private byte[] getKeyByStr(String str){
byte[] bRet = new byte[str.length()/2];
for(int i=0;iSTR.LENGTH()
Integer itg =
new Integer(16*getChrInt(str.charAt(2*i)) + getChrInt(str.charAt(2*i+1)));
bRet[i] = itg.byteValue();
}
return bRet;
}
/**
计算一个16进制字符的10进制值
输入：0-F
*/
private int getChrInt(char chr){
int iRet=0;
if(chr=="0".charAt(0)) iRet = 0;
if(chr=="1".charAt(0)) iRet = 1;
if(chr=="2".charAt(0)) iRet = 2;
if(chr=="3".charAt(0)) iRet = 3;
if(chr=="4".charAt(0)) iRet = 4;
if(chr=="5".charAt(0)) iRet = 5;
if(chr=="6".charAt(0)) iRet = 6;
if(chr=="7".charAt(0)) iRet = 7;
if(chr=="8".charAt(0)) iRet = 8;
if(chr=="9".charAt(0)) iRet = 9;
if(chr=="A".charAt(0)) iRet = 10;
if(chr=="B".charAt(0)) iRet = 11;
if(chr=="C".charAt(0)) iRet = 12;
if(chr=="D".charAt(0)) iRet = 13;
if(chr=="E".charAt(0)) iRet = 14;
if(chr=="F".charAt(0)) iRet = 15;
return iRet;
}
}
/**
文件选择组件。
*/
class FilePanel extends JPanel{
FilePanel(String str){
JLabel label = new JLabel(str);
JTextField fileText = new JTextField(35);
JButton chooseButton = new JButton("浏览...");
this.add(label);
this.add(fileText);
this.add(chooseButton);
clickAction ca = new clickAction(this);
chooseButton.addActionListener(ca);
}
public String getFileName(){
JTextField jtf = (JTextField)this.getComponent(1);
return jtf.getText();
}
private class clickAction implements ActionListener{
clickAction(Component c){
cmpt = c;
}
public void actionPerformed(ActionEvent event){
JFileChooser chooser = new JFileChooser();
chooser.setCurrentDirectory(new File("."));
int ret = chooser.showOpenDialog(cmpt);
if(ret==JFileChooser.APPROVE_OPTION){
JPanel jp = (JPanel)cmpt;
JTextField jtf = (JTextField)jp.getComponent(1);
jtf.setText(chooser.getSelectedFile().getPath());
}
}
private Component cmpt;
}
}
/**
密码生成组件。
*/
class KeyPanel extends JPanel{
KeyPanel(String str){
JLabel label = new JLabel(str);
JTextField fileText = new JTextField(35);
JButton chooseButton = new JButton("随机产生");
this.add(label);
this.add(fileText);
this.add(chooseButton);
clickAction ca = new clickAction(this);
chooseButton.addActionListener(ca);
}
//返回生成的密码（48个字符长度）
public String getKey(){
JTextField jtf = (JTextField)this.getComponent(1);
return jtf.getText();
}
private class clickAction implements ActionListener{
clickAction(Component c){
cmpt = c;
}
public void actionPerformed(ActionEvent event){
try{
KeyGenerator kg = KeyGenerator.getInstance("DES");
kg.init(56);
Key ke = kg.generateKey();
byte[] bytK1 = ke.getEncoded();
ke = kg.generateKey();
byte[] bytK2 = ke.getEncoded();
ke = kg.generateKey();
byte[] bytK3 = ke.getEncoded();
JPanel jp = (JPanel)cmpt;
JTextField jtf = (JTextField)jp.getComponent(1);
jtf.setText(getByteStr(bytK1)+getByteStr(bytK2)+getByteStr(bytK3));
}catch(Exception e){
e.printStackTrace();
}
}
private String getByteStr(byte[] byt){
String strRet = "";
for(int i=0;iBYT.LENGTH;I++){
//System.out.println(byt[i]);
strRet += getHexValue((byt[i]240)/16);
strRet += getHexValue(byt[i]15);
}
return strRet;
}
private String getHexValue(int s){
String sRet=null;
switch (s){
case 0: sRet = "0";break;
case 1: sRet = "1";break;
case 2: sRet = "2";break;
case 3: sRet = "3";break;
case 4: sRet = "4";break;
case 5: sRet = "5";break;
case 6: sRet = "6";break;
case 7: sRet = "7";break;
case 8: sRet = "8";break;
case 9: sRet = "9";break;
case 10: sRet = "A";break;
case 11: sRet = "B";break;
case 12: sRet = "C";break;
case 13: sRet = "D";break;
case 14: sRet = "E";break;
case 15: sRet = "F";
}
return sRet;
}
private Component cmpt;
}
}
以下两个类可以很方便的完成字符串的加密和解密
加密 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= ;il;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= ;il;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））
}
lishixinzhi/Article/program/Java/hx/201311/26449
