java数字加密系统代码 java数字加密系统代码有哪些 _加密

java的md5的加密算法代码import java.lang.reflect.*;
/*******************************************************************************
* keyBean 类实现了RSA Data Security, Inc.在提交给IETF 的RFC1321中的keyBean message-digest
* 算法。
******************************************************************************/
public class keyBean {
/*
* 下面这些S11-S44实际上是一个4*4的矩阵，在原始的C实现中是用#define 实现的，这里把它们实现成为static
* final是表示了只读，切能在同一个进程空间内的多个 Instance间共享
*/
static final int S11 = 7;
static final int S12 = 12;
static final int S13 = 17;
static final int S14 = 22;
static final int S21 = 5;
static final int S22 = 9;
static final int S23 = 14;
static final int S24 = 20;
static final int S31 = 4;
static final int S32 = 11;
static final int S33 = 16;
static final int S34 = 23;
static final int S41 = 6;
static final int S42 = 10;
static final int S43 = 15;
static final int S44 = 21;
static final byte[] PADDING = { -128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0 };
/*
* 下面的三个成员是keyBean计算过程中用到的3个核心数据，在原始的C实现中被定义到keyBean_CTX结构中
*/
private long[] state = new long[4]; // state (ABCD)
private long[] count = new long[2]; // number of bits, modulo 2^64 (lsb
// first)
private byte[] buffer = new byte[64]; // input buffer
/*
* digestHexStr是keyBean的唯一一个公共成员，是最新一次计算结果的 16进制ASCII表示.
*/
public String digestHexStr;
/*
* digest,是最新一次计算结果的2进制内部表示，表示128bit的keyBean值.
*/
private byte[] digest = new byte[16];
/*
* getkeyBeanofStr是类keyBean最主要的公共方法，入口参数是你想要进行keyBean变换的字符串
* 返回的是变换完的结果，这个结果是从公共成员digestHexStr取得的．
*/
public String getkeyBeanofStr(String inbuf) {
keyBeanInit();
keyBeanUpdate(inbuf.getBytes(), inbuf.length());
keyBeanFinal();
digestHexStr = "";
for (int i = 0; i16; i) {
digestHexStr= byteHEX(digest[i]);
}
return digestHexStr;
}
// 这是keyBean这个类的标准构造函数， JavaBean要求有一个public的并且没有参数的构造函数
public keyBean() {
keyBeanInit();
return;
}
/* keyBeanInit是一个初始化函数，初始化核心变量，装入标准的幻数 */
private void keyBeanInit() {
count[0] = 0L;
count[1] = 0L;
// /* Load magic initialization constants.
state[0] = 0x67452301L;
state[1] = 0xefcdab89L;
state[2] = 0x98badcfeL;
state[3] = 0x10325476L;
return;
}
/*
* F, G, H ,I 是4个基本的keyBean函数，在原始的keyBean的C实现中，由于它们是
* 简单的位运算，可能出于效率的考虑把它们实现成了宏，在java中，我们把它们实现成了private方法，名字保持了原来C中的。
*/
private long F(long x, long y, long z) {
return (xy) | ((~x)z);
}
private long G(long x, long y, long z) {
return (xz) | (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 1, 2, 3, and 4. Rotation is separate from addition to prevent
* recomputation.
*/
private long FF(long a, long b, long c, long d, long x, long s, long ac) {
a= F(b, c, d)xac;
a = ((int) as) | ((int) a(32 - 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)xac;
a = ((int) as) | ((int) a(32 - 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)xac;
a = ((int) as) | ((int) a(32 - 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)xac;
a = ((int) as) | ((int) a(32 - s));
a= b;
return a;
}
/*
* keyBeanUpdate是keyBean的主计算过程， inbuf是要变换的字节串，inputlen是长度，这个
* 函数由getkeyBeanofStr调用，调用之前需要调用keyBeaninit，因此把它设计成private的
*/
private void keyBeanUpdate(byte[] inbuf, int inputLen) {
int i, index, partLen;
byte[] block = new byte[64];
index = (int) (count[0]3)0x3F;
// /* Update number of bits */
if ((count[0]= (inputLen3))(inputLen3))
count[1];
count[1]= (inputLen29);
partLen = 64 - index;
// Transform as many times as possible.
if (inputLen = partLen) {
keyBeanMemcpy(buffer, inbuf, index, 0, partLen);
keyBeanTransform(buffer);
for (i = partLen; i63inputLen; i= 64) {
keyBeanMemcpy(block, inbuf, 0, i, 64);
keyBeanTransform(block);
}
index = 0;
} else
i = 0;
// /* Buffer remaining input */
keyBeanMemcpy(buffer, inbuf, index, i, inputLen - i);
}
/*
* keyBeanFinal整理和填写输出结果
*/
private void keyBeanFinal() {
byte[] bits = new byte[8];
int index, padLen;
// /* Save number of bits */
Encode(bits, count, 8);
// /* Pad out to 56 mod 64.
index = (int) (count[0]3)0x3f;
padLen = (index56) ? (56 - index) : (120 - index);
keyBeanUpdate(PADDING, padLen);
// /* Append length (before padding) */
keyBeanUpdate(bits, 8);
// /* Store state in digest */
Encode(digest, state, 16);
}
/*
* keyBeanMemcpy是一个内部使用的byte数组的块拷贝函数，从input的inpos开始把len长度的
* 字节拷贝到output的outpos位置开始
*/
private void keyBeanMemcpy(byte[] output, byte[] input, int outpos,
int inpos, int len) {
int i;
for (i = 0; ilen; i)
output[outposi] = input[inposi];
}
/*
* keyBeanTransform是keyBean核心变换程序，有keyBeanUpdate调用，block是分块的原始字节
*/
private void keyBeanTransform(byte block[]) {
long a = state[0], b = state[1], c = state[2], d = state[3];
long[] x = new long[16];
Decode(x, block, 64);
/* Round 1 */
【java数字加密系统代码 java数字加密系统代码有哪些】a = FF(a, b, c, d, x[0], S11, 0xd76aa478L); /* 1 */
d = FF(d, a, b, c, x[1], S12, 0xe8c7b756L); /* 2 */
c = FF(c, d, a, b, x[2], S13, 0x242070dbL); /* 3 */
b = FF(b, c, d, a, x[3], S14, 0xc1bdceeeL); /* 4 */
a = FF(a, b, c, d, x[4], S11, 0xf57c0fafL); /* 5 */
d = FF(d, a, b, c, x[5], S12, 0x4787c62aL); /* 6 */
c = FF(c, d, a, b, x[6], S13, 0xa8304613L); /* 7 */
b = FF(b, c, d, a, x[7], S14, 0xfd469501L); /* 8 */
a = FF(a, b, c, d, x[8], S11, 0x698098d8L); /* 9 */
d = FF(d, a, b, c, x[9], S12, 0x8b44f7afL); /* 10 */
c = FF(c, d, a, b, x[10], S13, 0xffff5bb1L); /* 11 */
b = FF(b, c, d, a, x[11], S14, 0x895cd7beL); /* 12 */
a = FF(a, b, c, d, x[12], S11, 0x6b901122L); /* 13 */
d = FF(d, a, b, c, x[13], S12, 0xfd987193L); /* 14 */
c = FF(c, d, a, b, x[14], S13, 0xa679438eL); /* 15 */
b = FF(b, c, d, a, x[15], S14, 0x49b40821L); /* 16 */
/* Round 2 */
a = GG(a, b, c, d, x[1], S21, 0xf61e2562L); /* 17 */
d = GG(d, a, b, c, x[6], S22, 0xc040b340L); /* 18 */
c = GG(c, d, a, b, x[11], S23, 0x265e5a51L); /* 19 */
b = GG(b, c, d, a, x[0], S24, 0xe9b6c7aaL); /* 20 */
a = GG(a, b, c, d, x[5], S21, 0xd62f105dL); /* 21 */
d = GG(d, a, b, c, x[10], S22, 0x2441453L); /* 22 */
c = GG(c, d, a, b, x[15], S23, 0xd8a1e681L); /* 23 */
b = GG(b, c, d, a, x[4], S24, 0xe7d3fbc8L); /* 24 */
a = GG(a, b, c, d, x[9], S21, 0x21e1cde6L); /* 25 */
d = GG(d, a, b, c, x[14], S22, 0xc33707d6L); /* 26 */
c = GG(c, d, a, b, x[3], S23, 0xf4d50d87L); /* 27 */
b = GG(b, c, d, a, x[8], S24, 0x455a14edL); /* 28 */
a = GG(a, b, c, d, x[13], S21, 0xa9e3e905L); /* 29 */
d = GG(d, a, b, c, x[2], S22, 0xfcefa3f8L); /* 30 */
c = GG(c, d, a, b, x[7], S23, 0x676f02d9L); /* 31 */
b = GG(b, c, d, a, x[12], S24, 0x8d2a4c8aL); /* 32 */
/* Round 3 */
a = HH(a, b, c, d, x[5], S31, 0xfffa3942L); /* 33 */
d = HH(d, a, b, c, x[8], S32, 0x8771f681L); /* 34 */
c = HH(c, d, a, b, x[11], S33, 0x6d9d6122L); /* 35 */
b = HH(b, c, d, a, x[14], S34, 0xfde5380cL); /* 36 */
a = HH(a, b, c, d, x[1], S31, 0xa4beea44L); /* 37 */
d = HH(d, a, b, c, x[4], S32, 0x4bdecfa9L); /* 38 */
c = HH(c, d, a, b, x[7], S33, 0xf6bb4b60L); /* 39 */
b = HH(b, c, d, a, x[10], S34, 0xbebfbc70L); /* 40 */
a = HH(a, b, c, d, x[13], S31, 0x289b7ec6L); /* 41 */
d = HH(d, a, b, c, x[0], S32, 0xeaa127faL); /* 42 */
c = HH(c, d, a, b, x[3], S33, 0xd4ef3085L); /* 43 */
b = HH(b, c, d, a, x[6], S34, 0x4881d05L); /* 44 */
a = HH(a, b, c, d, x[9], S31, 0xd9d4d039L); /* 45 */
d = HH(d, a, b, c, x[12], S32, 0xe6db99e5L); /* 46 */
c = HH(c, d, a, b, x[15], S33, 0x1fa27cf8L); /* 47 */
b = HH(b, c, d, a, x[2], S34, 0xc4ac5665L); /* 48 */
/* Round 4 */
a = II(a, b, c, d, x[0], S41, 0xf4292244L); /* 49 */
d = II(d, a, b, c, x[7], S42, 0x432aff97L); /* 50 */
c = II(c, d, a, b, x[14], S43, 0xab9423a7L); /* 51 */
b = II(b, c, d, a, x[5], S44, 0xfc93a039L); /* 52 */
a = II(a, b, c, d, x[12], S41, 0x655b59c3L); /* 53 */
d = II(d, a, b, c, x[3], S42, 0x8f0ccc92L); /* 54 */
c = II(c, d, a, b, x[10], S43, 0xffeff47dL); /* 55 */
b = II(b, c, d, a, x[1], S44, 0x85845dd1L); /* 56 */
a = II(a, b, c, d, x[8], S41, 0x6fa87e4fL); /* 57 */
d = II(d, a, b, c, x[15], S42, 0xfe2ce6e0L); /* 58 */
c = II(c, d, a, b, x[6], S43, 0xa3014314L); /* 59 */
b = II(b, c, d, a, x[13], S44, 0x4e0811a1L); /* 60 */
a = II(a, b, c, d, x[4], S41, 0xf7537e82L); /* 61 */
d = II(d, a, b, c, x[11], S42, 0xbd3af235L); /* 62 */
c = II(c, d, a, b, x[2], S43, 0x2ad7d2bbL); /* 63 */
b = II(b, c, d, a, x[9], S44, 0xeb86d391L); /* 64 */
state[0]= a;
state[1]= b;
state[2]= c;
state[3]= d;
}
/*
* Encode把long数组按顺序拆成byte数组，因为java的long类型是64bit的，只拆低32bit ，以适应原始C实现的用途
*/
private void Encode(byte[] output, long[] input, int len) {
int i, j;
for (i = 0, j = 0; jlen; i, j= 4) {
output[j] = (byte) (input[i]0xffL);
output[j1] = (byte) ((input[i]8)0xffL);
output[j2] = (byte) ((input[i]16)0xffL);
output[j3] = (byte) ((input[i]24)0xffL);
}
}
/*
* Decode把byte数组按顺序合成成long数组，因为java的long类型是64bit的，
* 只合成低32bit，高32bit清零，以适应原始C实现的用途
*/
private void Decode(long[] output, byte[] input, int len) {
int i, j;
for (i = 0, j = 0; jlen; i, j= 4)
output[i] = b2iu(input[j]) | (b2iu(input[j1])8)
| (b2iu(input[j2])16) | (b2iu(input[j3])24);
return;
}
/*
* b2iu是我写的一个把byte按照不考虑正负号的原则的”升位”程序，因为java没有unsigned运算
*/
public static long b2iu(byte b) {
return b0 ? b0x7F128 : b;
}
/*
* byteHEX()，用来把一个byte类型的数转换成十六进制的ASCII表示，
* 因为java中的byte的toString无法实现这一点，我们又没有C语言中的 sprintf(outbuf,"X",ib)
*/
public static String byteHEX(byte ib) {
char[] Digit = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A',
'B', 'C', 'D', 'E', 'F' };
char[] ob = new char[2];
ob[0] = Digit[(ib4)0X0F];
ob[1] = Digit[ib0X0F];
String s = new String(ob);
return s;
}
public static void main(String args[]) {
keyBean m = new keyBean();
if (Array.getLength(args) == 0) { // 如果没有参数，执行标准的Test Suite
System.out.println("keyBean Test suite:");
System.out.println("keyBean(\"):"m.getkeyBeanofStr(""));
System.out.println("keyBean(\"a\"):"m.getkeyBeanofStr("a"));
System.out.println("keyBean(\"abc\"):"m.getkeyBeanofStr("abc"));
System.out.println("keyBean(\"message digest\"):"
m.getkeyBeanofStr("message digest"));
System.out.println("keyBean(\"abcdefghijklmnopqrstuvwxyz\"):"
m.getkeyBeanofStr("abcdefghijklmnopqrstuvwxyz"));
System.out
.println("keyBean(\"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789\"):"
m
.getkeyBeanofStr("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"));
} else
System.out.println("keyBean("args[0]")="
m.getkeyBeanofStr(args[0]));
}
}
java编写数字加密解密加多一个判断java数字加密系统代码，当输入的长度小于指定长度的时候java数字加密系统代码，出错java数字加密系统代码；
如果超出指定长度java数字加密系统代码，则取前几位，譬如指定6位，输入123 ，出错java数字加密系统代码；输入123456789，那就只处理123456，忽略后面的789
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class Test {
public static void main(String[] args) throws Exception {
System.out.print("请输入加密（解密）和要处理的数字个数：1为加密，2为解密； ");
Scanner scanner = new Scanner(System.in);
String[] input1 = scanner.nextLine().split("\\s ");
String choice = input1[0];
int count = Integer.parseInt(input1[1]);
System.out.print("请输入要处理的数字，用空格隔开：");
String input = scanner.nextLine().replaceAll("\\s ", "");
if(input.length()count){
throw new Exception("不足"count"位数字，请检查输入");
}else if(input.length()count){
System.out.println("太多数字，将处理前"count"个数字："
input.substring(0, 6));
input = input.substring(0, 6);
}
if(choice.equals("1")){
if(input.length()count){
}
String encode = EncodeUtil.encode(input);
System.out.println("加密后的数字是: "encode);
}else{
String decode = EncodeUtil.decode(input);
System.out.println("解密后的数字: "decode);
}
}
}
class EncodeUtil{
private static MapString, String encodeMap = null;
private static MapString, String decodeMap = null;
public final static String encode(String strToEncode){
if(encodeMap == null){
encodeMap = new HashMapString, String();
encodeMap.put("0", "7");
encodeMap.put("1", "5");
encodeMap.put("2", "9");
encodeMap.put("3", "1");
encodeMap.put("4", "3");
encodeMap.put("5", "6");
encodeMap.put("6", "8");
encodeMap.put("7", "0");
encodeMap.put("8", "2");
encodeMap.put("9", "4");
}
StringBuilder sb = new StringBuilder();
for(int i = 0; istrToEncode.length(); i){
sb.append(encodeMap.get(String.valueOf(strToEncode.charAt(i))));
}
return sb.toString();
}
public final static String decode(String strToDecode){
if(decodeMap == null){
decodeMap = new HashMapString, String();
decodeMap.put("7", "0");
decodeMap.put("5", "1");
decodeMap.put("9", "2");
decodeMap.put("1", "3");
decodeMap.put("3", "4");
decodeMap.put("6", "5");
decodeMap.put("8", "6");
decodeMap.put("0", "7");
decodeMap.put("2", "8");
decodeMap.put("4", "9");
}
StringBuilder sb = new StringBuilder();
for(int i = 0; istrToDecode.length(); i){
sb.append(decodeMap.get(String.valueOf(strToDecode.charAt(i))));
}
return sb.toString();
}
}
------------------测试
C:\Program Files\IBM\RAD 7\jdk\binjava Test
请输入加密（解密）和要处理的数字个数：1为加密， 2为解密； 1 6
请输入要处理的数字，用空格隔开：1 2 3
Exception in thread "main" java.lang.Exception: 不足6位数字，请检查输入
at Test.main(Test.java:19)
C:\Program Files\IBM\RAD 7\jdk\binjava Test
请输入加密（解密）和要处理的数字个数：1为加密，2为解密； 1 6
请输入要处理的数字，用空格隔开：1 2 3 4 5 6 7
太多数字，将处理前6个数字：123456
加密后的数字是: 591368
C:\Program Files\IBM\RAD 7\jdk\binjava Test
请输入加密（解密）和要处理的数字个数：1为加密，2为解密； 1 6
请输入要处理的数字，用空格隔开：1 9 9 7 7 1
加密后的数字是: 544005
C:\Program Files\IBM\RAD 7\jdk\binjava Test
请输入加密（解密）和要处理的数字个数：1为加密，2为解密； 2 6
请输入要处理的数字，用空格隔开：5 4 4 0 0 5
解密后的数字: 199771
求java加密源代码（MD5，base64）import java.security.*;
import javax.crypto.*;
/**
* 本例解释如何利用DES私钥加密算法加解密
*
* @author Devon
* @version 1.0 04/03/10
*/
public class SingleKeyExample {
public static void main(String[] args) {
try {
String algorithm = "DES"; //定义加密算法,可用 DES,DESede,Blowfish
String message = "Hello World. 这是待加密的信息";
// 生成个DES密钥
KeyGenerator keyGenerator = KeyGenerator.getInstance(algorithm);
keyGenerator.init(56); //选择DES算法,密钥长度必须为56位
Key key = keyGenerator.generateKey(); //生成密钥
// 生成Cipher对象
Cipher cipher = Cipher.getInstance("DES");
//用密钥加密明文(message),生成密文(cipherText)
cipher.init(Cipher.ENCRYPT_MODE, key);//操作模式为加密(Cipher.ENCRYPT_MODE),key为密钥
byte[] cipherText = cipher.doFinal(message.getBytes());//得到加密后的字节数组
System.out.println("加密后的信息: "new String(cipherText));
//用密钥加密明文(plainText),生成密文(cipherByte)
cipher.init(Cipher.DECRYPT_MODE, key);//操作模式为解密,key为密钥
byte[] sourceText = cipher.doFinal(cipherText); //获得解密后字节数组
System.out.println("解密后的信息: "new String(sourceText));
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
/**
* @author Devon
*/
import java.security.*;
import java.security.spec.*;
import javax.crypto.*;
public class PairKeyExample {
public static void main(String argv[]) {
try {
String algorithm = "RSA"; //定义加密算法,可用 DES,DESede,Blowfish
String message = "张三java数字加密系统代码，java数字加密系统代码你好java数字加密系统代码，我是李四";
//产生张三的密钥对(keyPairZhang)
KeyPairGenerator keyGeneratorZhang =
KeyPairGenerator.getInstance(algorithm);//指定采用的算法
keyGeneratorZhang.initialize(1024); //指定密钥长度为1024位
KeyPair keyPairZhang = keyGeneratorZhang.generateKeyPair(); //产生密钥对
System.out.println("生成张三的公钥对");
// 张三生成公钥(publicKeyZhang)并发送给李四,这里发送的是公钥的数组字节
byte[] publicKeyZhangEncode = keyPairZhang.getPublic().getEncoded();
//通过网络或磁盘等方式,把公钥编码传送给李四
//李四接收到张三编码后的公钥,将其解码
KeyFactory keyFacoryLi = KeyFactory.getInstance(algorithm);//得到KeyFactory对象
X509EncodedKeySpec x509KeySpec =
new X509EncodedKeySpec(publicKeyZhangEncode);//公钥采用X.509编码
PublicKey publicKeyZhang = keyFacoryLi.generatePublic(x509KeySpec); //将公钥的KeySpec对象转换为公钥
System.out.println("李四成功解码,得到张三的公钥");
//李四用张三的公钥加密信息java数字加密系统代码，并发送给李四
Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");//得到Cipher对象
cipher.init(Cipher.ENCRYPT_MODE, publicKeyZhang);//用张三的公钥初始化Cipher对象
byte[] cipherMessage = cipher.doFinal(message.getBytes());//得到加密信息
System.out.println("加密后信息："new String(cipherMessage));
System.out.println("加密完成，发送给李四...");
//张三用自己的私钥解密从李四处收到的信息
cipher.init(Cipher.DECRYPT_MODE, keyPairZhang.getPrivate()); //张三用其私钥初始化Cipher对象
byte[] originalMessage = cipher.doFinal(cipherMessage);//得到解密后信息
System.out.println("张三收到信息，解密后为："new String(originalMessage));
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
java加密解密代码package com.cube.limail.util;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;/**
* 加密解密类
*/
publicclassEryptogram
{
privatestaticStringAlgorithm ="DES";
private String key="CB7A92E3D3491964";
//定义加密算法,可用 DES,DESede,Blowfish
staticbooleandebug= false ;
/**
* 构造子注解.
*/
publicEryptogram ()
{
} /**
* 生成密钥
* @return byte[] 返回生成的密钥
* @throws exception 扔出异常.
*/
publicstaticbyte [] getSecretKey () throwsException
{
KeyGeneratorkeygen= KeyGenerator.getInstance (Algorithm );
SecretKeydeskey= keygen.generateKey ();
System.out.println ("生成密钥:" bytesToHexString (deskey.getEncoded ()));
if(debug ) System.out.println ("生成密钥:" bytesToHexString (deskey.getEncoded ()));
returndeskey.getEncoded ();
} /**
* 将指定的数据根据提供的密钥进行加密
* @param input 需要加密的数据
* @param key 密钥
* @return byte[] 加密后的数据
* @throws Exception
*/
publicstaticbyte [] encryptData (byte [] input ,byte [] key ) throwsException
{
SecretKeydeskey= newjavax.crypto.spec.SecretKeySpec (key ,Algorithm );
if(debug )
{
System.out.println ("加密前的二进串:" byte2hex (input ));
System.out.println ("加密前的字符串:" newString (input ));
} Cipherc1= Cipher.getInstance (Algorithm );
c1.init (Cipher.ENCRYPT_MODE ,deskey );
byte [] cipherByte =c1.doFinal (input );
if(debug ) System.out.println ("加密后的二进串:" byte2hex (cipherByte ));
returncipherByte ;
} /**
* 将给定的已加密的数据通过指定的密钥进行解密
* @param input 待解密的数据
* @param key 密钥
* @return byte[] 解密后的数据
* @throws Exception
*/
publicstaticbyte [] decryptData (byte [] input ,byte [] key ) throwsException
{
SecretKeydeskey= newjavax.crypto.spec.SecretKeySpec (key ,Algorithm );
if(debug ) System.out.println ("解密前的信息:" byte2hex (input ));
Cipherc1= Cipher.getInstance (Algorithm );
c1.init (Cipher.DECRYPT_MODE ,deskey );
byte [] clearByte =c1.doFinal (input );
if(debug )
{
System.out.println ("解密后的二进串:" byte2hex (clearByte ));
System.out.println ("解密后的字符串:" (newString (clearByte )));
} returnclearByte ;
} /**
* 字节码转换成16进制字符串
* @param byte[] b 输入要转换的字节码
* @return String 返回转换后的16进制字符串
*/
publicstaticStringbyte2hex (byte [] b )
{
Stringhs ="";
Stringstmp ="";
for(intn =0 ;n b.length ;n)
{
stmp =(java.lang.Integer.toHexString (b [n ]0XFF ));
if(stmp.length ()==1 ) hs =hs"0" stmp ;
elsehs =hsstmp ;
if(n b.length -1 ) hs =hs":";
} returnhs.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; ilen; i) {
int pos = i * 2;
result[i] = (byte) (toByte(achar[pos])4 | toByte(achar[pos1]));
}
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; ibArray.length; i) {
sTemp = Integer.toHexString(0xFFbArray[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=https://www.04ip.com/post/null;
//CommDao dao=new CommDao();
// List list=dao.getRecordList("from Key k where k.deptid=" deptid);
//if(list.size()0){
//value=https://www.04ip.com/post/((com.csc.sale.bean.Key)list.get(0)).getKey();
value = "https://www.04ip.com/post/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);//将字节数组转化为字符串，获得加密后的字符串密码解密与之差不多
java数字加密系统代码的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java数字加密系统代码有哪些、java数字加密系统代码的信息别忘了在本站进行查找喔。

java数字加密系统代码 java数字加密系统代码有哪些

推荐阅读

房子阳台朝哪个方向好房子阳台朝什么方向好

独在异乡的第二年

炒这些菜时千万不要放醋以免发生反应

尼康d850的基本设置是什么尼康d850的基本设置

滴滴与uber的竞争分析,uber被滴滴合并分析

中括号 [ ]在数学表示什么中括号 [ ]在数学里面表示什么

埋线改全切怎么抽线

鮟鱇鱼的特点

苏州林内燃气热水器不燃烧是什么原因,全面的对比下

青砖伴瓦漆白马踏新泥什么意思

自热火锅上层加热水会爆炸吗

摩托罗拉|泪目！华为商城上线“中国制造”个性手机壳全系9.9元

矩阵分析那本书好,矩阵在那本书里讲

python函数需要背吗 python需要背哪些东西英语

iphone|真不怕冷！零下三十度都能用，支持热成像和激光测距！AGM G1发布

劳动合同解除和终止的区别是什么

元日古诗解释元日古诗的翻译及原文

癌症|院士坦言癌症不可能被消灭？从头到脚的防癌重点，帮你总结全了

青州新办事中心地址在什么位置

煎饺和蒸饺的区别