源码
/**
* แก้ไข: MD5Digest<br>
* 说明： 用来进行密码加密的md5公用参数<br>
* 编写日期： 2001/03/05<br>
* 修改者： <br>
* 修改信息： <br>
* @ผู้เขียน edgarlo [email protected]
* @เวอร์ชัน 1.0<br>
-
นำเข้า java.security.MessageDigest;
นำเข้า java.security.NoSuchAlgorithmException;
MD5Digest คลาสสาธารณะ
{
MessageDigest ส่วนตัว __md5 = null;
StringBuffer ส่วนตัว __digestBuffer = null;
MD5Digest สาธารณะ ()
พ่น NoSuchAlgorithmException
-
__md5 = MessageDigest.getInstance("MD5");
__digestBuffer = StringBuffer ใหม่();
}
สตริงสาธารณะ md5crypt(สตริง s)
-
__digestBuffer.setLength(0);
ไบต์ abyte0[] = __md5.digest(s.getBytes());
สำหรับ (int i = 0; i < abyte0.length; i++)
__digestBuffer.append(toHex(abyte0[i]));
กลับ __digestBuffer.toString();
-
สตริงสาธารณะ toHex (ไบต์หนึ่ง) {
สตริง HEX = "0123456789ABCDEF";
ถ่าน [] ผลลัพธ์ = ถ่านใหม่ [2];
ผลลัพธ์[0]=HEX.charAt((หนึ่ง & 0xf0) >> 4);
ผลลัพธ์[1]=HEX.charAt(หนึ่ง & 0x0f);
สตริง mm=สตริงใหม่ (ผลลัพธ์);
กลับมม.;
-
-
-
-
MD5 ของ Java Bean
@author:Topcat Tuppin
แก้ไขล่าสุด: 10 มี.ค. 2544
-
แพ็คเกจ Beartool;
นำเข้า java.lang.reflect.*;
-
md5 ผู้ดูแลระบบ RSA Data Security, Inc.ใน IETF
RFC1321中的MD5 message-digest 算法。
*************************************************/
MD5 คลาสสาธารณะ {
/* 下เลดี้这些S11-S44实际上是一个4*4的矩阵，在原始的C实现中是用#define 实现的，
这里把它们实现成为static สุดท้าย是表示了只读，切能在同一个进程空间内的多个
อินสแตนซ์间共享*/
int สุดท้ายคงที่ S11 = 7;
int สุดท้ายคงที่ S12 = 12;
int สุดท้ายคงที่ S13 = 17;
int สุดท้ายคงที่ S14 = 22;
int สุดท้ายคงที่ S21 = 5;
int สุดท้ายคงที่ S22 = 9;
int สุดท้ายคงที่ S23 = 14;
int สุดท้ายคงที่ S24 = 20;
int สุดท้ายคงที่ S31 = 4;
int สุดท้ายคงที่ S32 = 11;
int สุดท้ายคงที่ S33 = 16;
int สุดท้ายคงที่ S34 = 23;
int สุดท้ายคงที่ S41 = 6;
int สุดท้ายคงที่ S42 = 10;
int สุดท้ายคงที่ S43 = 15;
int สุดท้ายคงที่ S44 = 21;
ไบต์สุดท้ายแบบคงที่ [] 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 };
/* 下的的三个成员是MD5计算过程中用到的3个核heart数据，在原始的C实现中
被定义到MD5_CTX结构中
-
สถานะยาวส่วนตัว [] = ยาวใหม่ [4]; // รัฐ (ABCD)
ส่วนตัวยาว [] นับ = ยาวใหม่ [2]; // จำนวนบิต, โมดูโล 2^64 (lsb ก่อน)
ไบต์ส่วนตัว [] บัฟเฟอร์ = ไบต์ใหม่ [64]; //บัฟเฟอร์อินพุต
/* digestHexStr是MD5 ของ 16 进制ASCII表示.
-
สตริงสาธารณะ digestHexStr;
/* digest, 进制内部表示,表示128bit ของ MD5值.
-
ไบต์ส่วนตัว [] แยกย่อย = ไบต์ใหม่ [16];
-
getMD5ofStr是类MD5最主要的公共方法，入口参数是你想要进行MD5变换的字符串
返回的是变换完的结果，这个结果是从公共成员digestHexStr取得的.
-
สตริงสาธารณะ getMD5ofStr (สตริง inbuf) {
md5Init();
md5Update(inbuf.getBytes(), inbuf.length());
md5Final();
แยกย่อยHexStr = "";
สำหรับ (int i = 0; i <16; i++) {
digestHexStr += byteHEX (ย่อย [i]);
-
กลับย่อยHexStr;
-
// 这是MD5这个类的标准构造函数，JavaBean要求有一个public的并且没有参数的构造函数
MD5 สาธารณะ () {
md5Init();
กลับ;
-
/* md5Init是一个初始化函数，初始化核heart变量，装入标准的幻数 */
โมฆะส่วนตัว md5Init () {
นับ[0] = 0L;
นับ[1] = 0L;
///* โหลดค่าคงที่การเริ่มต้นเวทย์มนตร์
สถานะ[0] = 0x67452301L;
สถานะ [1] = 0xefcdab89L;
สถานะ [2] = 0x98badcfeL;
สถานะ [3] = 0x10325476L;
กลับ;
-
/* F, G, H ,I 是4个基本的MD5函数，在原始的MD5的C实现中，由于它们是
简单的位运算，可能出于效率的考虑把它们实现成了宏，在java中，我们把它们
实现成了private方法，名字保持了原来C中的。 */
private long F(long x, long y, long z) {
กลับ (x & y) | ((~x) & z);
-
ยาวส่วนตัว G(ยาว x, ยาว y, ยาว z) {
กลับ (x & z) | (ใช่ & (~z));
-
ยาวส่วนตัว H(ยาว x, ยาว y, ยาว z) {
กลับ x ^ y ^ z;
}
ยาวส่วนตัว I(ยาว x, ยาว y, ยาว z) {
กลับ y ^ (x | (~z));
-
-
FF,GG,HH和II将调用F,G,H,I进行近一步变换
การเปลี่ยนแปลง FF, GG, HH และ II สำหรับรอบ 1, 2, 3 และ 4
การหมุนจะแยกออกจากการเพิ่มเพื่อป้องกันการคำนวณใหม่
*/
FF ยาวส่วนตัว (ยาว a, ยาว b, ยาว c, ยาว d, ยาว x, ยาว s,
กระแสสลับยาว) {
ก += F (ข, ค, ง) + x + เอซี;
a = ((int) a << s) | ((int) a >>> (32 - วิ));
ก += ข;
กลับ;
}
GG แบบยาวส่วนตัว (long a, long b, long c, long d, long x, long s,
กระแสสลับยาว) {
ก += G (ข, ค, ง) + x + เอซี;
a = ((int) a << s) | ((int) a >>> (32 - วิ));
ก += ข;
กลับ;
-
HH ยาวส่วนตัว (ยาว a, ยาว b, ยาว c, ยาว d, ยาว x, ยาว s,
กระแสสลับยาว) {
ก += H (ข, ค, ง) + x + เอซี;
a = ((int) a << s) | ((int) a >>> (32 - วิ));
ก += ข;
กลับ;
-
ยาวส่วนตัว II (ยาว a, ยาว b, ยาว c, ยาว d, ยาว x, ยาว s,
กระแสสลับยาว) {
ก += ฉัน (ข, ค, ง) + x + เอซี;
a = ((int) a << s) | ((int) a >>> (32 - วิ));
ก += ข;
กลับ;
-
-
md5Update是MD5 主计算过程，inbuf是要变换的字节串，inputlen是长度，这个
函数由getMD5ofStr调用，调用之前需要调用md5init，因此把它设计成private的
-
โมฆะส่วนตัว md5Update (ไบต์ [] inbuf, int inputLen) {
int i, ดัชนี, partLen;
ไบต์ [] บล็อก = ไบต์ใหม่ [64];
ดัชนี = (int)(นับ[0] >>> 3) & 0x3F;
// /* อัพเดตจำนวนบิต */
ถ้า ((นับ [0] += (inputLen << 3)) < (inputLen << 3))
นับ[1]++;
นับ[1] += (อินพุตเลน >>> 29);
partLen = 64 - ดัชนี;
// แปลงร่างให้มากที่สุด
ถ้า (inputLen >= partLen) {
md5Memcpy (บัฟเฟอร์, inbuf, ดัชนี, 0, partLen);
md5Transform(บัฟเฟอร์);
สำหรับ (i = partLen; i + 63 < inputLen; i += 64) {
md5Memcpy (บล็อก, inbuf, 0, i, 64);
md5Transform (บล็อก);
-
ดัชนี = 0;
} อื่น ๆ
i = 0;
///* บัฟเฟอร์อินพุตที่เหลือ */
md5Memcpy (บัฟเฟอร์, inbuf, ดัชนี, i, inputLen - i);
-
-
md5Final整理和填写输出结果
-
โมฆะส่วนตัว md5Final () {
ไบต์ [] บิต = ไบต์ใหม่ [8];
ดัชนี int, padLen;
///* บันทึกจำนวนบิต */
เข้ารหัส (บิต, นับ, 8);
///* แพดออกไปเป็น 56 mod 64
ดัชนี = (int)(นับ[0] >>> 3) & 0x3f;
padLen = (ดัชนี < 56) ? (56 - ดัชนี) : (120 - ดัชนี);
md5Update (PADDING, padLen);
///* เพิ่มความยาว (ก่อนเติม) */
md5Update(บิต, 8);
///* สถานะการจัดเก็บอยู่ในสรุป */
เข้ารหัส (สรุป, สถานะ, 16);
-
/* md5Memcpy ไบต์ 数组的块拷贝函数，从input ของ inpos ขยาย 始把len长度的 字节拷贝到output ของ outpos 位置ขยาย
*/
โมฆะส่วนตัว md5Memcpy (เอาต์พุตไบต์ [], อินพุตไบต์ [],
int outpos, int inpos, int len)
-
ฉัน;
สำหรับ (i = 0; i <len; i++)
เอาท์พุท [outpos + i] = อินพุต [inpos + i];
-
-
md5Transform 是MD5 是分块的原始字节
-
โมฆะส่วนตัว md5Transform (บล็อกไบต์ []) {
ยาว = สถานะ [0], b = สถานะ [1], c = สถานะ [2], d = สถานะ [3];
ยาว[] x = ยาวใหม่[16];
ถอดรหัส (x, บล็อก, 64);
/* รอบที่ 1 */
ก = FF (ก, ข, ค, ง, x[0], S11, 0xd76aa478L); /* 1 */
ง = FF (ง, ก, ข, ค, x[1], S12, 0xe8c7b756L); /* 2 */
ค = FF (c, d, a, b, x[2], S13, 0x242070dbL); /* 3 */
ข = FF (b, c, d, a, x[3], S14, 0xc1bdceeeL); /* 4 */
ก = FF (ก, ข, ค, ง, x[4], S11, 0xf57c0fafL); /* 5 */
ง = FF (ง, ก, ข, ค, x[5], S12, 0x4787c62aL); /* 6 */
ค = FF (ค, ง, ก, ข, x[6], S13, 0xa8304613L); /* 7 */
ข = FF (b, c, d, a, x[7], S14, 0xfd469501L); /* 8 */
ก = FF (ก, ข, ค, ง, x[8], S11, 0x698098d8L); /* 9 */
ง = FF (ง, ก, ข, ค, x[9], S12, 0x8b44f7afL); /* 10 */
ค = FF (ค, ง, ก, ข, x[10], S13, 0xffff5bb1L); /* 11 */
ข = FF (b, c, d, a, x[11], S14, 0x895cd7beL); /* 12 */
ก = FF (ก, ข, ค, ง, x[12], S11, 0x6b901122L); /* 13 */
ง = FF (ง, ก, ข, ค, x[13], S12, 0xfd987193L); /* 14 */
ค = FF (ค, ง, ก, ข, x[14], S13, 0xa679438eL); /* 15 */
ข = FF (b, c, d, a, x[15], S14, 0x49b40821L); /* 16 */
/* รอบ 2 */
ก = GG (ก, ข, ค, ง, x[1], S21, 0xf61e2562L); /* 17 */
ง = GG (ง, ก, ข, ค, x[6], S22, 0xc040b340L); /* 18 */
ค = GG (ค, ดี, ก, ข, x[11], S23, 0x265e5a51L); /* 19 */
ข = GG (b, c, d, a, x[0], S24, 0xe9b6c7aaL); /* 20 */
ก = GG (ก, ข, ค, ง, x[5], S21, 0xd62f105dL); /* 21 */
d = GG (ง, ก, ข, ค, x[10], S22, 0x2441453L); /* 22 */
ค = GG (ค, ดี, ก, ข, x[15], S23, 0xd8a1e681L); /* 23 */
ข = GG (b, c, d, a, x[4], S24, 0xe7d3fbc8L); /* 24 */
ก = GG (ก, ข, ค, ง, x[9], S21, 0x21e1cde6L); /* 25 */
ง = GG (ง, ก, ข, ค, x[14], S22, 0xc33707d6L); /* 26 */
ค = GG (ค, ดี, ก, ข, x[3], S23, 0xf4d50d87L); /* 27 */
ข = GG (b, c, d, a, x[8], S24, 0x455a14edL); /* 28 */
ก = GG (ก, ข, ค, ง, x[13], S21, 0xa9e3e905L); /* 29 */
d = GG (d, a, b, c, x[2], S22, 0xfcefa3f8L); /* 30 */
ค = GG (ค, ดี, ก, ข, x[7], S23, 0x676f02d9L); /* 31 */
b = GG (b, c, d, a, x[12], S24, 0x8d2a4c8aL); /* 32 */
/* รอบที่ 3 */
ก = HH (ก, ข, ค, ง, x[5], S31, 0xfffa3942L); /* 33 */
ง = HH (ง, ก, ข, ค, x[8], S32, 0x8771f681L); /* 34 */
ค = HH (ค, ง, ก, ข, x[11], S33, 0x6d9d6122L); /* 35 */
b = HH (b, c, d, a, x[14], S34, 0xfde5380cL); /* 36 */
ก = HH (ก, ข, ค, ง, x[1], S31, 0xa4beea44L); /* 37 */
d = HH (d, a, b, c, x[4], S32, 0x4bdecfa9L); /* 38 */
ค = HH (ค, ง, ก, ข, x[7], S33, 0xf6bb4b60L); /* 39 */
ข = HH (b, c, d, a, x[10], S34, 0xbebfbc70L); /* 40 */
ก = HH (ก, ข, ค, ง, x[13], S31, 0x289b7ec6L); /* 41 */
d = HH (d, a, b, c, x[0], S32, 0xeaa127faL); /* 42 */
ค = HH (c, d, a, b, x[3], S33, 0xd4ef3085L); /* 43 */
ข = HH (b, c, d, a, x[6], S34, 0x4881d05L); /* 44 */
ก = HH (ก, ข, ค, ง, x[9], S31, 0xd9d4d039L); /* 45 */
ง = HH (ง, ก, ข, ค, x[12], S32, 0xe6db99e5L); /* 46 */
ค = HH (ค, ง, ก, ข, x[15], S33, 0x1fa27cf8L); /* 47 */
ข = HH (b, c, d, a, x[2], S34, 0xc4ac5665L); /* 48 */
/* รอบที่ 4 */
ก = II (ก, ข, ค, ง, x[0], S41, 0xf4292244L); /* 49 */
ง = II (ง, ก, ข, ค, x[7], S42, 0x432aff97L); /* 50 */
ค = II (ค, ดี, เอ, ข, x[14], S43, 0xab9423a7L); /* 51 */
ข = II (บี, ค, ดี, เอ, x[5], S44, 0xfc93a039L); /* 52 */
ก = II (ก, ข, ค, ง, x[12], S41, 0x655b59c3L); /* 53 */
ง = ครั้งที่สอง (ง, ก, ข, ค, x[3], S42, 0x8f0ccc92L); /* 54 */
ค = II (c, d, a, b, x[10], S43, 0xffeff47dL); /* 55 */
ข = II (b, c, d, a, x[1], S44, 0x85845dd1L); /* 56 */
ก = II (ก, ข, ค, ง, x[8], S41, 0x6fa87e4fL); /* 57 */
ง = ครั้งที่สอง (ง, ก, ข, ค, x[15], S42, 0xfe2ce6e0L); /* 58 */
ค = II (ค, ง, ก, ข, x[6], S43, 0xa3014314L); /* 59 */
ข = ครั้งที่สอง (b, c, d, a, x[13], S44, 0x4e0811a1L); /* 60 */
ก = II (ก, ข, ค, ง, x[4], S41, 0xf7537e82L); /* 61 */
ง = ครั้งที่สอง (ง, ก, ข, ค, x[11], S42, 0xbd3af235L); /* 62 */
ค = II (c, d, a, b, x[2], S43, 0x2ad7d2bbL); /* 63 */
ข = II (b, c, d, a, x[9], S44, 0xeb86d391L); /* 64 */
สถานะ[0] += ก;
สถานะ [1] += ข;
สถานะ [2] += ค;
สถานะ [3] += d;
-
/*เข้ารหัส把long数组按顺序拆成byte数组，因为java的long类型是64bit的，
只拆低32bit，以适应原始C实现的用途
-
การเข้ารหัสเป็นโมฆะส่วนตัว (เอาต์พุตไบต์ [], อินพุตยาว [], int len) {
อินท์ฉันเจ;
สำหรับ (i = 0, j = 0; j <len; i++, j += 4) {
เอาท์พุท [j] = (ไบต์) (อินพุต [i] & 0xffL);
เอาท์พุท [j + 1] = (ไบต์) ((อินพุต [i] >>> 8) & 0xffL);
เอาท์พุท [j + 2] = (ไบต์) ((อินพุต [i] >>> 16) & 0xffL);
เอาท์พุท [j + 3] = (ไบต์) ((อินพุต [i] >>> 24) & 0xffL);
-
}
/*Decode把byte数组按顺序合成成long数组，因为java的long类型是64bit的，
只合成低32bit，高32bit清零，以适应原始C实现的用途
-
ถอดรหัสโมฆะส่วนตัว (เอาต์พุตยาว [], อินพุตไบต์ [], int len) {
อินท์ฉันเจ;
สำหรับ (i = 0, j = 0; j <len; i++, j += 4)
เอาท์พุท [i] = b2iu (อินพุต [j]) |
(b2iu(อินพุต[เจ + 1]) << 8) |
(b2iu(อินพุต[เจ + 2]) << 16) |
(b2iu(อินพุต[เจ + 3]) << 24);
กลับ;
-
-
b2iu是我写的一个把byte按foto不考虑正负号的原则的＂升位＂程序，因为java没有unsigned运算
-
b2iu แบบคงที่สาธารณะ (ไบต์ b) {
กลับ b < 0 ? ข & 0x7F + 128 : ข;
-
/*byteHEX() , ไบต์ , ไบต์ , 数转换成十六进制 ของ ASCII 表示 ,
因为java中的byte的toString无法实现这一点，我们又没有C语言中的
sprintf(ส่งออก,"%02X",ib)
-
สาธารณะสตริงคงที่ byteHEX (ไบต์ ib) {
ถ่าน [] หลัก = { '0','1','2','3','4','5','6','7','8','9',
'A','B','C','D','E','F' };
ถ่าน [] ob = ถ่านใหม่ [2];
ob[0] = หลัก[(ib >>> 4) & 0X0F];
ob[1] = หลัก[ib & 0X0F];
สตริง s = สตริงใหม่ (ob);
กลับ;
}
โมฆะสาธารณะคงหลัก (สตริง args []) {
MD5 m = MD5 ใหม่();
if (Array.getLength(args) == 0) { //如果没有参数，执行标准的Test Suite
System.out.println("ชุดทดสอบ MD5:");
System.out.println("MD5(""):"+m.getMD5ofStr(""));
System.out.println("MD5("a"):"+m.getMD5ofStr("a"));
System.out.println("MD5("abc"):"+m.getMD5ofStr("abc"));
System.out.println("MD5("ข้อความสรุป"):"+m.getMD5ofStr("ข้อความสรุป"));
System.out.println("MD5("abcdefghijklmnopqrstuvwxyz"):"+
m.getMD5ofStr("abcdefghijklmnopqrstuvwxyz"));
System.out.println("MD5("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"):"+
m.getMD5ofStr("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"));
-
อื่น
System.out.println("MD5(" + args[0] + ")=" + m.getMD5ofStr(args[0]));
}
}
JSP中的使用方法
--------------------------------------------- ----------------------------------
<%@ ภาษาเพจ='java' %>
<jsp:useBean id='oMD5' scope='request' class='beartool.MD5'/>
<%@ เพจนำเข้า='java.util.*'%>
<%@ เพจนำเข้า='java.sql.*'%>
<html>
<ร่างกาย>
-
สตริง userid = request.getParameter("UserID"); //获取用户输入UserID
รหัสผ่านสตริง = request.getParameter("รหัสผ่าน"); //获取用户输入的รหัสผ่าน
สตริง pwdmd5 = oMD5.getMD5ofStr(รหัสผ่าน); //计算MD5的值
PrintWriter rp = การตอบสนอง getWriter();
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
การเชื่อมต่อ con = DriverManager.getConnection("jdbc:odbc:community", "", "");
คำสั่ง stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("select * from users when userID ='"+userid+"' and pwdmd5= '" + pwdmd5+"'" );
ถ้า (rs.next())
-
rp.print("เข้าสู่ระบบได้");
-
อื่น
-
rp.print("การเข้าสู่ระบบล้มเหลว");
}
stmt.ปิด();
แย้ง.ปิด();
%>
</ร่างกาย>
</html>