欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Java与C++实现相同的MD5加密算法简单实例

程序员文章站 2024-03-13 13:49:33
1、java版 package com.lyz.utils.common; import java.io.unsupportedencodingexce...

1、java版

package com.lyz.utils.common; 
 
import java.io.unsupportedencodingexception; 
import java.security.messagedigest; 
import java.security.nosuchalgorithmexception; 
/** 
 * md5加密 
 * @author liuyazhuang 
 */ 
public class md5hash { 
 
  public static string md5java(string message) { 
    string digest = null; 
    try { 
      messagedigest md = messagedigest.getinstance("md5"); 
      byte[] hash = md.digest(message.getbytes("utf-8")); 
 
      //converting byte array to hexadecimal string 
      stringbuilder sb = new stringbuilder(2 * hash.length); 
      for (byte b : hash) { 
        sb.append(string.format("%02x", b & 0xff)); 
      } 
 
      digest = sb.tostring(); 
 
    } catch (unsupportedencodingexception ex) { 
      //logger.getlogger(stringreplace.class.getname()).log(level.severe, null, ex); 
    } catch (nosuchalgorithmexception ex) { 
      //logger.getlogger(stringreplace.class.getname()).log(level.severe, null, ex); 
    } 
    return digest; 
  } 
  public static void main(string[] args) { 
    system.out.println(md5java("admin").touppercase()); 
  } 
}

2、c++代码

(1)md5.h

#include  <stdio.h> 
#include  <stdlib.h>
#include  <time.h> 
#include  <string.h> 
void  md5digest(char  *pszinput,  unsigned  long  ninputsize,  char  *pszoutput);

(2)md5.cpp

#include  <stdio.h> 
#include  <stdlib.h>
#include  <time.h> 
#include  <string.h> 
#include  "md5.h"

typedef  unsigned  char  *pointer; 
typedef  unsigned  short  int  uint2; 
typedef  unsigned  long  int  uint4; 

typedef  struct  
{ 
 uint4  state[4]; 
 uint4  count[2]; 
 unsigned  char  buffer[64]; 
}  md5_ctx; 

void  md5init(md5_ctx  *); 
void  md5update(md5_ctx  *,  unsigned  char  *,  unsigned  int); 
void  md5final(unsigned  char  [16],  md5_ctx  *); 

#define  s11  7 
#define  s12  12 
#define  s13  17 
#define  s14  22 
#define  s21  5 
#define  s22  9 
#define  s23  14 
#define  s24  20 
#define  s31  4 
#define  s32  11 
#define  s33  16 
#define  s34  23 
#define  s41  6 
#define  s42  10 
#define  s43  15 
#define  s44  21 

static  unsigned  char  padding[64]  =  { 
 0x80,  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 
}; 

#define  f(x,  y,  z)  (((x)  &  (y))  |  ((~x)  &  (z))) 
#define  g(x,  y,  z)  (((x)  &  (z))  |  ((y)  &  (~z))) 
#define  h(x,  y,  z)  ((x)  ^  (y)  ^  (z)) 
#define  i(x,  y,  z)  ((y)  ^  ((x)  |  (~z))) 

#define  rotate_left(x,  n)  (((x)  <<  (n))  |  ((x)  >>  (32-(n)))) 

#define  ff(a,  b,  c,  d,  x,  s,  ac)  {   (a)  +=  f  ((b),  (c),  (d))  +  (x)  +  (uint4)(ac);   (a)  =  rotate_left  ((a),  (s));   (a)  +=  (b);    } 
#define  gg(a,  b,  c,  d,  x,  s,  ac)  {   (a)  +=  g  ((b),  (c),  (d))  +  (x)  +  (uint4)(ac);   (a)  =  rotate_left  ((a),  (s));   (a)  +=  (b);    } 
#define  hh(a,  b,  c,  d,  x,  s,  ac)  {   (a)  +=  h  ((b),  (c),  (d))  +  (x)  +  (uint4)(ac);   (a)  =  rotate_left  ((a),  (s));   (a)  +=  (b);    } 
#define  ii(a,  b,  c,  d,  x,  s,  ac)  {   (a)  +=  i  ((b),  (c),  (d))  +  (x)  +  (uint4)(ac);   (a)  =  rotate_left  ((a),  (s));   (a)  +=  (b);  } 


inline  void  encode(unsigned  char  *output,  uint4  *input,  unsigned  int  len) 
{ 
 unsigned  int  i,  j; 
 
 for  (i  =  0,  j  =  0;  j  <  len;  i++,  j  +=  4)  { 
  output[j]  =  (unsigned  char)(input[i]  &  0xff); 
  output[j+1]  =  (unsigned  char)((input[i]  >>  8)  &  0xff); 
  output[j+2]  =  (unsigned  char)((input[i]  >>  16)  &  0xff); 
  output[j+3]  =  (unsigned  char)((input[i]  >>  24)  &  0xff); 
 } 
} 

inline  void  decode(uint4  *output,  unsigned  char  *input,  unsigned  int  len) 
{ 
 unsigned  int  i,  j; 
 
 for  (i  =  0,  j  =  0;  j  <  len;  i++,  j  +=  4) 
  output[i]  =  ((uint4)input[j])  |  (((uint4)input[j+1])  <<  8)  | 
 (((uint4)input[j+2])  <<  16)  |  (((uint4)input[j+3])  <<  24); 
} 

inline  void  md5transform  (uint4  state[4],  unsigned  char  block[64]) 
{ 
 uint4  a  =  state[0],  b  =  state[1],  c  =  state[2],  d  =  state[3],  x[16]; 
 decode  (x,  block,  64); 
 ff  (a,  b,  c,  d,  x[  0],  s11,  0xd76aa478);  
 ff  (d,  a,  b,  c,  x[  1],  s12,  0xe8c7b756);  
 ff  (c,  d,  a,  b,  x[  2],  s13,  0x242070db);  
 ff  (b,  c,  d,  a,  x[  3],  s14,  0xc1bdceee);  
 ff  (a,  b,  c,  d,  x[  4],  s11,  0xf57c0faf);  
 ff  (d,  a,  b,  c,  x[  5],  s12,  0x4787c62a);  
 ff  (c,  d,  a,  b,  x[  6],  s13,  0xa8304613);  
 ff  (b,  c,  d,  a,  x[  7],  s14,  0xfd469501);  
 ff  (a,  b,  c,  d,  x[  8],  s11,  0x698098d8); 
 ff  (d,  a,  b,  c,  x[  9],  s12,  0x8b44f7af);  
 ff  (c,  d,  a,  b,  x[10],  s13,  0xffff5bb1);  
 ff  (b,  c,  d,  a,  x[11],  s14,  0x895cd7be); 
 ff  (a,  b,  c,  d,  x[12],  s11,  0x6b901122);  
 ff  (d,  a,  b,  c,  x[13],  s12,  0xfd987193); 
 ff  (c,  d,  a,  b,  x[14],  s13,  0xa679438e); 
 ff  (b,  c,  d,  a,  x[15],  s14,  0x49b40821); 
 gg  (a,  b,  c,  d,  x[  1],  s21,  0xf61e2562); 
 gg  (d,  a,  b,  c,  x[  6],  s22,  0xc040b340);  
 gg  (c,  d,  a,  b,  x[11],  s23,  0x265e5a51);  
 gg  (b,  c,  d,  a,  x[  0],  s24,  0xe9b6c7aa);  
 gg  (a,  b,  c,  d,  x[  5],  s21,  0xd62f105d);  
 gg  (d,  a,  b,  c,  x[10],  s22,   0x2441453); 
 gg  (c,  d,  a,  b,  x[15],  s23,  0xd8a1e681);  
 gg  (b,  c,  d,  a,  x[  4],  s24,  0xe7d3fbc8); 
 gg  (a,  b,  c,  d,  x[  9],  s21,  0x21e1cde6);  
 gg  (d,  a,  b,  c,  x[14],  s22,  0xc33707d6); 
 gg  (c,  d,  a,  b,  x[  3],  s23,  0xf4d50d87); 
 gg  (b,  c,  d,  a,  x[  8],  s24,  0x455a14ed); 
 gg  (a,  b,  c,  d,  x[13],  s21,  0xa9e3e905);  
 gg  (d,  a,  b,  c,  x[  2],  s22,  0xfcefa3f8); 
 gg  (c,  d,  a,  b,  x[  7],  s23,  0x676f02d9); 
 gg  (b,  c,  d,  a,  x[12],  s24,  0x8d2a4c8a);  
 hh  (a,  b,  c,  d,  x[  5],  s31,  0xfffa3942); 
 hh  (d,  a,  b,  c,  x[  8],  s32,  0x8771f681); 
 hh  (c,  d,  a,  b,  x[11],  s33,  0x6d9d6122); 
 hh  (b,  c,  d,  a,  x[14],  s34,  0xfde5380c);  
 hh  (a,  b,  c,  d,  x[  1],  s31,  0xa4beea44);  
 hh  (d,  a,  b,  c,  x[  4],  s32,  0x4bdecfa9);  
 hh  (c,  d,  a,  b,  x[  7],  s33,  0xf6bb4b60);  
 hh  (b,  c,  d,  a,  x[10],  s34,  0xbebfbc70);  
 hh  (a,  b,  c,  d,  x[13],  s31,  0x289b7ec6);  
 hh  (d,  a,  b,  c,  x[  0],  s32,  0xeaa127fa); 
 hh  (c,  d,  a,  b,  x[  3],  s33,  0xd4ef3085); 
 hh  (b,  c,  d,  a,  x[  6],  s34,   0x4881d05); 
 hh  (a,  b,  c,  d,  x[  9],  s31,  0xd9d4d039);  
 hh  (d,  a,  b,  c,  x[12],  s32,  0xe6db99e5); 
 hh  (c,  d,  a,  b,  x[15],  s33,  0x1fa27cf8);  
 hh  (b,  c,  d,  a,  x[  2],  s34,  0xc4ac5665); 
 ii  (a,  b,  c,  d,  x[  0],  s41,  0xf4292244); 
 ii  (d,  a,  b,  c,  x[  7],  s42,  0x432aff97); 
 ii  (c,  d,  a,  b,  x[14],  s43,  0xab9423a7);  
 ii  (b,  c,  d,  a,  x[  5],  s44,  0xfc93a039);  
 ii  (a,  b,  c,  d,  x[12],  s41,  0x655b59c3); 
 ii  (d,  a,  b,  c,  x[  3],  s42,  0x8f0ccc92);  
 ii  (c,  d,  a,  b,  x[10],  s43,  0xffeff47d);  
 ii  (b,  c,  d,  a,  x[  1],  s44,  0x85845dd1);  
 ii  (a,  b,  c,  d,  x[  8],  s41,  0x6fa87e4f);  
 ii  (d,  a,  b,  c,  x[15],  s42,  0xfe2ce6e0); 
 ii  (c,  d,  a,  b,  x[  6],  s43,  0xa3014314); 
 ii  (b,  c,  d,  a,  x[13],  s44,  0x4e0811a1); 
 ii  (a,  b,  c,  d,  x[  4],  s41,  0xf7537e82); 
 ii  (d,  a,  b,  c,  x[11],  s42,  0xbd3af235); 
 ii  (c,  d,  a,  b,  x[  2],  s43,  0x2ad7d2bb);  
 ii  (b,  c,  d,  a,  x[  9],  s44,  0xeb86d391); 
 state[0]  +=  a; 
 state[1]  +=  b; 
 state[2]  +=  c; 
 state[3]  +=  d; 
 memset  ((pointer)x,  0,  sizeof  (x)); 
 } 
  
inline  void  md5init(md5_ctx  *context) 
{ 
 context->count[0]  =  context->count[1]  =  0; 
 context->state[0]  =  0x67452301; 
 context->state[1]  =  0xefcdab89; 
 context->state[2]  =  0x98badcfe; 
 context->state[3]  =  0x10325476; 
} 

inline  void  md5update(md5_ctx  *context,  unsigned  char  *input,  unsigned  int  inputlen) 
{ 
 unsigned  int  i,  index,  partlen; 
 
 index  =  (unsigned  int)((context->count[0]  >>  3)  &  0x3f); 
 if  ((context->count[0]  +=  ((uint4)inputlen  <<  3)) 
  <  ((uint4)inputlen  <<  3)) 
  context->count[1]++; 
 context->count[1]  +=  ((uint4)inputlen  >>  29); 
 
 partlen  =  64  -  index; 
 
 if  (inputlen  >=  partlen)  { 
  memcpy((pointer)&context->buffer[index],  (pointer)input,  partlen); 
  md5transform(context->state,  context->buffer); 
  
  for  (i  =  partlen;  i  +  63  <  inputlen;  i  +=  64) 
   md5transform  (context->state,  &input[i]); 
  index  =  0; 
 } 
 else 
  i  =  0; 
 
 memcpy((pointer)&context->buffer[index],  (pointer)&input[i],  inputlen-i); 
} 

inline  void  md5final(unsigned  char  digest[16],  md5_ctx  *context) 
{ 
 unsigned  char  bits[8]; 
 unsigned  int  index,  padlen; 
 
 encode  (bits,  context->count,  8); 
 index  =  (unsigned  int)((context->count[0]  >>  3)  &  0x3f); 
 padlen  =  (index  <  56)  ?  (56  -  index)  :  (120  -  index); 
 md5update  (context,  padding,  padlen); 
 md5update  (context,  bits,  8); 
 encode  (digest,  context->state,  16); 
 memset  ((pointer)context,  0,  sizeof  (*context)); 
 } 

void  md5digest(char  *pszinput,  unsigned  long  ninputsize,  char  *pszoutput) 
{ 
 md5_ctx  context; 
 unsigned  int  len  =  strlen  (pszinput); 
 
 md5init  (&context); 
 md5update  (&context,  (unsigned  char  *)pszinput,  len); 
 md5final  ((unsigned  char  *)pszoutput,  &context); 
} 

main() 
{ char szdigest[16]; 
 char encrypt[200]; 
 printf("请输入要计算md5值的字符串:");
 gets(encrypt);
 printf("\n加密结果:");
 md5digest(encrypt,strlen(encrypt),szdigest); 
 int i;
 for (i=0;i<16;i++) printf ("%02x",(unsigned char)szdigest[i]);
 getchar();

}

3、运行效果

这里我们都以输入123456为例

(1)java输出结果如下:

Java与C++实现相同的MD5加密算法简单实例

(2)c++输出结果如下:

Java与C++实现相同的MD5加密算法简单实例

以上就是小编为大家带来的java与c++实现相同的md5加密算法简单实例的全部内容了,希望对大家有所帮助,多多支持~