} } }

    MD5加密 Java源代码

    添加时间:2013-7-14 点击量:

    package lwp;
    

    /

    @author 梁WP
    /
    public class MD5_Encoding
    {
    // RFC1321中定义的标准44矩阵的常量定义。
    static final int S11 = 7, S12 = 12, S13 = 17, S14 = 22;
    static final int S21 = 5, S22 = 9, S23 = 14, S24 = 20;
    static final int S31 = 4, S32 = 11, S33 = 16, S34 = 23;
    static final int S41 = 6, S42 = 10, S43 = 15, S44 = 21;
    // 按RFC1321标准定义不成变byte型数组PADDING
    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
    };
    // MD5策画过程中的3组核心数据,采取数组情势存放
    private long[] state = new long[4]; // 策画状况(分别对应a b c d)
    private byte[] buffer = new byte[64]; // 分派64个字节私有缓冲区
    private long[] count = new long[2]; // 位个数
    // 新一次策画成果的16进制ASCII字符串默示,代表了16个字符串情势的MD5值
    public String resultStr;
    // 新一次策画成果的2进制数组默示,一共16个字节,代表了128bit情势的MD5值
    public byte[] digest = new byte[16];

    // MD5_Encoding类供给的首要的接口函数getMD5ofStr,用来进行数据加密变换。调用其可对随便率性字符串进行加密运算,并以字符串情势返回加密成果。
    public String getMD5ofStr(String in)
    {
    md5Init();
    // 初始化
    md5Update(in.getBytes(), in.length());// 调用MD5的主策画过程
    md5Final(); // 输出成果到digest数组中
    forint i = 0; i < 16; i++
    {
    resultStr
    += byteToHEX(digest[i]); // 将digest数组中的每个byte型数据转为16进制情势的字符串
    }
    return resultStr;
    }

    // 标准的机关函数,调用md5Init函数进行初始化工作
    public MD5_Encoding()
    {
    md5Init();
    }

    // md5初始化函数.初始化核心变量.
    private void md5Init()
    {
    state[
    0] = 0 x67452301L; // 定义state为RFC1321中定义的标准幻数
    state[1] = 0 xefcdab89L; // 定义state为RFC1321中定义的标准幻数
    state[2] = 0 x98badcfeL; // 定义state为RFC1321中定义的标准幻数
    state[3] = 0 x10325476L; // 定义state为RFC1321中定义的标准幻数
    count[0] = count[1] = 0L; // 初始化为0
    resultStr = ;// 初始化resultStr字符串为空
    forint i = 0; i < 16; i++
    {
    digest[i]
    = 0;//初始化digest数组元素为0
    }
    }

    //定义F G H I 为4个基数 ,即为4个根蒂根基的MD5函数,进行简单的位运算
    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函数进行进一步变换
    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 >>> (32 - s)); //这里long型数据右移时应用无符号右移运算符>>>
    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 >>> (32 - s)); //这里long型数据右移时应用无符号右移运算符>>>
    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 >>> (32 - s));//这里long型数据右移时应用无符号右移运算符>>>
    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 >>> (32 - s));//这里long型数据右移时应用无符号右移运算符>>>
    a += b;
    return a;
    }

    // MD5的主策画过程,input是须要变换的二进制字节串,inputlen是长度
    private void md5Update(byte[] input, int inputLen)
    {
    int i, index, partLen;
    byte[] block = new byte[64]; // 分派64个字节缓冲区
    //按照count策画index值。这里long型数据右移时应用无符号右移运算符>>>
    index = (int) (count[0] >>> 3) & 0 x3F;
    if ((count[0] += (inputLen << 3)) < (inputLen << 3))
    {
    count[
    1]++;
    }
    count[
    1] += (inputLen >>> 29); //这里int型数据右移时应用无符号右移运算符>>>
    partLen = 64 - index; //策画partLen值
    if (inputLen >= partLen)
    {
    md5Memcpy(buffer, input, index,
    0, partLen);
    md5Transform(buffer);
    for (i = partLen; i + 63 < inputLen; i += 64
    {
    md5Memcpy(block, input,
    0, i, 64);
    md5Transform(block);
    }
    index
    = 0;
    }
    else
    {
    i
    = 0;
    }
    md5Memcpy(buffer, input, index, i, inputLen
    - i);
    }

    // 收拾和填写输出成果,成果放到数组digest中。
    private void md5Final()
    {

    byte[] bits = new byte[8];
    int index, padLen;
    Encode(bits, count,
    8);
    index
    = (int) (count[0] >>> 3) & 0 x3f; //这里long型数据右移时应用无符号右移运算符>>>
    padLen = (index < 56) ? (56 - index) : (120 - index);
    md5Update(PADDING, padLen);
    md5Update(bits,
    8);
    Encode(digest, state,
    16);
    }

    // byte数组的块拷贝函数,将input数组中的肇端地位为inpos,长度len的数据拷贝到output数组肇端地位outpos处。
    private void md5Memcpy(byte[] output, byte[] input, int outpos, int inpos,
    int len)
    {
    int i;
    for (i = 0; i < len; i++
    {
    output[outpos
    + i] = input[inpos + i];
    }
    }

    // MD5核心变换策画法度,由md5Update函数调用,block是分块的原始字节数组
    private void md5Transform(byte block[])
    {
    long a = state[0], b = state[1], c = state[2], d = state[3];
    long[] x = new long[16];
    Decode(x, block,
    64);
    // 进行4级级联运算
    // 第1级
    a = FF(a, b, c, d, x[0], S11, 0 xd76aa478L); / 1 /
    d
    = FF(d, a, b, c, x[1], S12, 0 xe8c7b756L); / 2 /
    c
    = FF(c, d, a, b, x[2], S13, 0 x242070dbL); / 3 /
    b
    = FF(b, c, d, a, x[3], S14, 0 xc1bdceeeL); / 4 /
    a
    = FF(a, b, c, d, x[4], S11, 0 xf57c0fafL); / 5 /
    d
    = FF(d, a, b, c, x[5], S12, 0 x4787c62aL); / 6 /
    c
    = FF(c, d, a, b, x[6], S13, 0 xa8304613L); / 7 /
    b
    = FF(b, c, d, a, x[7], S14, 0 xfd469501L); / 8 /
    a
    = FF(a, b, c, d, x[8], S11, 0 x698098d8L); / 9 /
    d
    = FF(d, a, b, c, x[9], S12, 0 x8b44f7afL); / 10 /
    c
    = FF(c, d, a, b, x[10], S13, 0 xffff5bb1L); / 11 /
    b
    = FF(b, c, d, a, x[11], S14, 0 x895cd7beL); / 12 /
    a
    = FF(a, b, c, d, x[12], S11, 0 x6b901122L); / 13 /
    d
    = FF(d, a, b, c, x[13], S12, 0 xfd987193L); / 14 /
    c
    = FF(c, d, a, b, x[14], S13, 0 xa679438eL); / 15 /
    b
    = FF(b, c, d, a, x[15], S14, 0 x49b40821L); / 16 /

    // 第2级
    a = GG(a, b, c, d, x[1], S21, 0 xf61e2562L); / 17 /
    d
    = GG(d, a, b, c, x[6], S22, 0 xc040b340L); / 18 /
    c
    = GG(c, d, a, b, x[11], S23, 0 x265e5a51L); / 19 /
    b
    = GG(b, c, d, a, x[0], S24, 0 xe9b6c7aaL); / 20 /
    a
    = GG(a, b, c, d, x[5], S21, 0 xd62f105dL); / 21 /
    d
    = GG(d, a, b, c, x[10], S22, 0 x2441453L); / 22 /
    c
    = GG(c, d, a, b, x[15], S23, 0 xd8a1e681L); / 23 /
    b
    = GG(b, c, d, a, x[4], S24, 0 xe7d3fbc8L); / 24 /
    a
    = GG(a, b, c, d, x[9], S21, 0 x21e1cde6L); / 25 /
    d
    = GG(d, a, b, c, x[14], S22, 0 xc33707d6L); / 26 /
    c
    = GG(c, d, a, b, x[3], S23, 0 xf4d50d87L); / 27 /
    b
    = GG(b, c, d, a, x[8], S24, 0 x455a14edL); / 28 /
    a
    = GG(a, b, c, d, x[13], S21, 0 xa9e3e905L); / 29 /
    d
    = GG(d, a, b, c, x[2], S22, 0 xfcefa3f8L); / 30 /
    c
    = GG(c, d, a, b, x[7], S23, 0 x676f02d9L); / 31 /
    b
    = GG(b, c, d, a, x[12], S24, 0 x8d2a4c8aL); / 32 /

    // 第3级
    a = HH(a, b, c, d, x[5], S31, 0 xfffa3942L); / 33 /
    d
    = HH(d, a, b, c, x[8], S32, 0 x8771f681L); / 34 /
    c
    = HH(c, d, a, b, x[11], S33, 0 x6d9d6122L); / 35 /
    b
    = HH(b, c, d, a, x[14], S34, 0 xfde5380cL); / 36 /
    a
    = HH(a, b, c, d, x[1], S31, 0 xa4beea44L); / 37 /
    d
    = HH(d, a, b, c, x[4], S32, 0 x4bdecfa9L); / 38 /
    c
    = HH(c, d, a, b, x[7], S33, 0 xf6bb4b60L); / 39 /
    b
    = HH(b, c, d, a, x[10], S34, 0 xbebfbc70L); / 40 /
    a
    = HH(a, b, c, d, x[13], S31, 0 x289b7ec6L); / 41 /
    d
    = HH(d, a, b, c, x[0], S32, 0 xeaa127faL); / 42 /
    c
    = HH(c, d, a, b, x[3], S33, 0 xd4ef3085L); / 43 /
    b
    = HH(b, c, d, a, x[6], S34, 0 x4881d05L); / 44 /
    a
    = HH(a, b, c, d, x[9], S31, 0 xd9d4d039L); / 45 /
    d
    = HH(d, a, b, c, x[12], S32, 0 xe6db99e5L); / 46 /
    c
    = HH(c, d, a, b, x[15], S33, 0 x1fa27cf8L); / 47 /
    b
    = HH(b, c, d, a, x[2], S34, 0 xc4ac5665L); / 48 /

    // 第4级
    a = II(a, b, c, d, x[0], S41, 0 xf4292244L); / 49 /
    d
    = II(d, a, b, c, x[7], S42, 0 x432aff97L); / 50 /
    c
    = II(c, d, a, b, x[14], S43, 0 xab9423a7L); / 51 /
    b
    = II(b, c, d, a, x[5], S44, 0 xfc93a039L); / 52 /
    a
    = II(a, b, c, d, x[12], S41, 0 x655b59c3L); / 53 /
    d
    = II(d, a, b, c, x[3], S42, 0 x8f0ccc92L); / 54 /
    c
    = II(c, d, a, b, x[10], S43, 0 xffeff47dL); / 55 /
    b
    = II(b, c, d, a, x[1], S44, 0 x85845dd1L); / 56 /
    a
    = II(a, b, c, d, x[8], S41, 0 x6fa87e4fL); / 57 /
    d
    = II(d, a, b, c, x[15], S42, 0 xfe2ce6e0L); / 58 /
    c
    = II(c, d, a, b, x[6], S43, 0 xa3014314L); / 59 /
    b
    = II(b, c, d, a, x[13], S44, 0 x4e0811a1L); / 60 /
    a
    = II(a, b, c, d, x[4], S41, 0 xf7537e82L); / 61 /
    d
    = II(d, a, b, c, x[11], S42, 0 xbd3af235L); / 62 /
    c
    = II(c, d, a, b, x[2], S43, 0 x2ad7d2bbL); / 63 /
    b
    = II(b, c, d, a, x[9], S44, 0 xeb86d391L); / 64 /

    //分别累加到state[0],state[1],state[2],state[3]
    state[0] += a;
    state[
    1] += b;
    state[
    2] += c;
    state[
    3] += d;
    }

    // 把byte型数据转换为无符号long型数据
    private static long byteToul(byte b)
    {
    return b > 0 ? b : (b & 0 x7F + 128);
    }

    // 把byte类型的数据转换成十六进制ASCII字符默示
    private static String byteToHEX(byte in)
    {
    char[] DigitStr =
    {
    0, 1, 2, 3, 4, 5, 6, 7, 8, 9
    A, B, C, D, E, F
    };
    char[] out = new char[2];
    out[
    0] = DigitStr[(in >> 4) & 0 x0F]; //取高4位
    out[1] = DigitStr[in & 0 x0F]; //取低4位
    String s = new String(out);
    return s;
    }

    // 将long型数组按次序拆成byte型数组,长度为len
    private void Encode(byte[] output, long[] input, int len)
    {
    int i, j;
    for (i = 0, j = 0; j < len; i++, j += 4
    {
    output[j]
    = (byte) (input[i] & 0 xffL);
    output[j
    + 1] = (byte) ((input[i] >>> 8) & 0 xffL);
    output[j
    + 2] = (byte) ((input[i] >>> 16) & 0 xffL);
    output[j
    + 3] = (byte) ((input[i] >>> 24) & 0 xffL);
    }
    }

    // 将byte型数组按次序合成long型数组,长度为len
    private void Decode(long[] output, byte[] input, int len)
    {
    int i, j;
    for (i = 0, j = 0; j < len; i++, j += 4
    {
    output[i]
    = byteToul(input[j])
    | (byteToul(input[j + 1]) << 8
    | (byteToul(input[j + 2]) << 16
    | (byteToul(input[j + 3]) << 24);
    }
    }
    }


    真正的心灵世界会告诉你根本看不见的东西,这东西需要你付出思想和灵魂的劳动去获取,然后它会照亮你的生命,永远照亮你的生命。——王安忆《小说家的十三堂课》
    分享到: