java密码的代码 java密码生成器

java密码加密与解密

以下两个类可以很方便的完成字符串的加密和解密

创新互联公司专注于企业成都全网营销推广、网站重做改版、郾城网站定制设计、自适应品牌网站建设、H5响应式网站、商城网站建设、集团公司官网建设、外贸网站制作、高端网站制作、响应式网页设计等建站业务，价格优惠性价比高，为郾城等各大城市提供网站开发制作服务。

加密 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

java密码:密码为0-9、a-z的字符组合,密码中的字符区分大小写

java密码:密码为0-9、a-z的字符组合,密码中的字符区分大小写就如下。

密码的业务规则密码位数为6-16个字符，区分大小写，支持字母（a-z，A-Z）、数字（0-9）及“_~@#$^”符号 代码如下（示例）：^[A-Za-z0-9_~@#$^]{6,16}+$

java加密解密代码

package com.cube.limail.util;

import javax.crypto.Cipher;

import javax.crypto.KeyGenerator;

import javax.crypto.SecretKey;/**

* 加密解密类

*/

public class Eryptogram

{

private static String Algorithm ="DES";

private String key="CB7A92E3D3491964";

//定义 加密算法,可用 DES,DESede,Blowfish

static boolean debug = false ;

/**

* 构造子注解.

*/

public Eryptogram ()

{

} /**

* 生成密钥

* @return byte[] 返回生成的密钥

* @throws exception 扔出异常.

*/

public static byte [] getSecretKey () throws Exception

{

KeyGenerator keygen = KeyGenerator.getInstance (Algorithm );

SecretKey deskey = keygen.generateKey ();

System.out.println ("生成密钥:"+bytesToHexString (deskey.getEncoded ()));

if (debug ) System.out.println ("生成密钥:"+bytesToHexString (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 ("加密前的二进串:"+byte2hex (input ));

System.out.println ("加密前的字符串:"+new String (input ));

} Cipher c1 = Cipher.getInstance (Algorithm );

c1.init (Cipher.ENCRYPT_MODE ,deskey );

byte [] cipherByte =c1.doFinal (input );

if (debug ) System.out.println ("加密后的二进串:"+byte2hex (cipherByte ));

return cipherByte ;

} /**

* 将给定的已加密的数据通过指定的密钥进行解密

* @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 ("解密前的信息:"+byte2hex (input ));

Cipher c1 = Cipher.getInstance (Algorithm );

c1.init (Cipher.DECRYPT_MODE ,deskey );

byte [] clearByte =c1.doFinal (input );

if (debug )

{

System.out.println ("解密后的二进串:"+byte2hex (clearByte ));

System.out.println ("解密后的字符串:"+(new String (clearByte )));

} return clearByte ;

} /**

* 字节码转换成16进制字符串

* @param byte[] b 输入要转换的字节码

* @return String 返回转换后的16进制字符串

*/

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 ;

if (n b.length -1 ) hs =hs +":";

} return hs.toUpperCase ();

}

/**

* 字符串转成字节数组.

* @param hex 要转化的字符串.

* @return byte[] 返回转化后的字符串.

*/

public static byte[] hexStringToByte(String hex) {

int len = (hex.length() / 2);

byte[] result = new byte[len];

char[] achar = hex.toCharArray();

for (int i = 0; i len; i++) {

int pos = i * 2;

result[i] = (byte) (toByte(achar[pos]) 4 | toByte(achar[pos + 1]));

}

return result;

}

private static byte toByte(char c) {

byte b = (byte) "0123456789ABCDEF".indexOf(c);

return b;

}

/**

* 字节数组转成字符串.

* @param String 要转化的字符串.

* @return 返回转化后的字节数组.

*/

public static final String bytesToHexString(byte[] bArray) {

StringBuffer sb = new StringBuffer(bArray.length);

String sTemp;

for (int i = 0; i bArray.length; i++) {

sTemp = Integer.toHexString(0xFF bArray[i]);

if (sTemp.length() 2)

sb.append(0);

sb.append(sTemp.toUpperCase());

}

return sb.toString();

}

/**

* 从数据库中获取密钥.

* @param deptid 企业id.

* @return 要返回的字节数组.

* @throws Exception 可能抛出的异常.

*/

public static byte[] getSecretKey(long deptid) throws Exception {

byte[] key=null;

String value=null;

//CommDao dao=new CommDao();

// List list=dao.getRecordList("from Key k where k.deptid="+deptid);

//if(list.size()0){

//value=((com.csc.sale.bean.Key)list.get(0)).getKey();

value = "CB7A92E3D3491964";

key=hexStringToByte(value);

//}

if (debug)

System.out.println("密钥:" + value);

return key;

}

public String encryptData2(String data) {

String en = null;

try {

byte[] key=hexStringToByte(this.key);

en = bytesToHexString(encryptData(data.getBytes(),key));

} catch (Exception e) {

e.printStackTrace();

}

return en;

}

public String decryptData2(String data) {

String de = null;

try {

byte[] key=hexStringToByte(this.key);

de = new String(decryptData(hexStringToByte(data),key));

} catch (Exception e) {

e.printStackTrace();

}

return de;

}

} 加密使用： byte[] key=Eryptogram.getSecretKey(deptid); //获得钥匙（字节数组）

byte[] tmp=Eryptogram.encryptData(password.getBytes(), key); //传入密码和钥匙，获得加密后的字节数组的密码

password=Eryptogram.bytesToHexString(tmp); //将字节数组转化为字符串，获得加密后的字符串密码解密与之差不多