开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
md5.c
资源名称：net-snmp-5.2.2.rar　[点击查看]
上传用户：wxp200602
上传日期：2007-10-30
资源大小：4028k
文件大小：16k
源码类别：

SNMP编程

开发平台：

Unix_Linux

md5.c：源码内容
  1. /*
  2.  * ** **************************************************************************
  3.  * ** md5.c -- Implementation of MD5 Message Digest Algorithm                 **
  4.  * ** Updated: 2/16/90 by Ronald L. Rivest                                    **
  5.  * ** (C) 1990 RSA Data Security, Inc.                                        **
  6.  * ** **************************************************************************
  7.  */
  9. /*
  10.  * ** To use MD5:
  11.  * **   -- Include md5.h in your program
  12.  * **   -- Declare an MDstruct MD to hold the state of the digest computation.
  13.  * **   -- Initialize MD using MDbegin(&MD)
  14.  * **   -- For each full block (64 bytes) X you wish to process, call
  15.  * **          MDupdate(&MD,X,512)
  16.  * **      (512 is the number of bits in a full block.)
  17.  * **   -- For the last block (less than 64 bytes) you wish to process,
  18.  * **          MDupdate(&MD,X,n)
  19.  * **      where n is the number of bits in the partial block. A partial
  20.  * **      block terminates the computation, so every MD computation should
  21.  * **      terminate by processing a partial block, even if it has n = 0.
  22.  * **   -- The message digest is available in MD.buffer[0] ... MD.buffer[3].
  23.  * **      (Least-significant byte of each word should be output first.)
  24.  * **   -- You can print out the digest using MDprint(&MD)
  25.  */
  27. /*
  28.  * Implementation notes:
  29.  * ** This implementation assumes that ints are 32-bit quantities.
  30.  * ** If the machine stores the least-significant byte of an int in the
  31.  * ** least-addressed byte (eg., VAX and 8086), then LOWBYTEFIRST should be
  32.  * ** set to TRUE.  Otherwise (eg., SUNS), LOWBYTEFIRST should be set to
  33.  * ** FALSE.  Note that on machines with LOWBYTEFIRST FALSE the routine
  34.  * ** MDupdate modifies has a side-effect on its input array (the order of bytes
  35.  * ** in each word are reversed).  If this is undesired a call to MDreverse(X) can
  36.  * ** reverse the bytes of X back into order after each call to MDupdate.
  37.  */
  39. /*
  40.  * code uses WORDS_BIGENDIAN defined by configure now  -- WH 9/27/95 
  41.  */
  43. /*
  44.  * Compile-time includes 
  45.  */
  47. #include <net-snmp/net-snmp-config.h>
  49. #ifndef DISABLE_MD5
  51. #include <stdio.h>
  52. #include <sys/types.h>
  53. #if HAVE_STRING_H
  54. #include <string.h>
  55. #else
  56. #include <strings.h>
  57. #endif
  58. #if HAVE_WINSOCK_H
  59. #include <winsock.h>
  60. #endif
  62. #if HAVE_STDLIB_H
  63. #include <stdlib.h>
  64. #endif
  66. #include <net-snmp/utilities.h>
  67. #include <net-snmp/library/md5.h>
  69. /*
  70.  * Compile-time declarations of MD5 ``magic constants''.
  71.  */
  72. #define I0  0x67452301          /* Initial values for MD buffer */
  73. #define I1  0xefcdab89
  74. #define I2  0x98badcfe
  75. #define I3  0x10325476
  76. #define fs1  7                  /* round 1 shift amounts */
  77. #define fs2 12
  78. #define fs3 17
  79. #define fs4 22
  80. #define gs1  5                  /* round 2 shift amounts */
  81. #define gs2  9
  82. #define gs3 14
  83. #define gs4 20
  84. #define hs1  4                  /* round 3 shift amounts */
  85. #define hs2 11
  86. #define hs3 16
  87. #define hs4 23
  88. #define is1  6                  /* round 4 shift amounts */
  89. #define is2 10
  90. #define is3 15
  91. #define is4 21
  94. /*
  95.  * Compile-time macro declarations for MD5.
  96.  * ** Note: The ``rot'' operator uses the variable ``tmp''.
  97.  * ** It assumes tmp is declared as unsigned int, so that the >>
  98.  * ** operator will shift in zeros rather than extending the sign bit.
  99.  */
  100. #define f(X,Y,Z)             ((X&Y) | ((~X)&Z))
  101. #define g(X,Y,Z)             ((X&Z) | (Y&(~Z)))
  102. #define h(X,Y,Z)             (X^Y^Z)
  103. #define i_(X,Y,Z)            (Y ^ ((X) | (~Z)))
  104. #define rot(X,S)             (tmp=X,(tmp<<S) | (tmp>>(32-S)))
  105. #define ff(A,B,C,D,i,s,lp)   A = rot((A + f(B,C,D) + X[i] + lp),s) + B
  106. #define gg(A,B,C,D,i,s,lp)   A = rot((A + g(B,C,D) + X[i] + lp),s) + B
  107. #define hh(A,B,C,D,i,s,lp)   A = rot((A + h(B,C,D) + X[i] + lp),s) + B
  108. #define ii(A,B,C,D,i,s,lp)   A = rot((A + i_(B,C,D) + X[i] + lp),s) + B
  110. #ifdef STDC_HEADERS
  111. #define Uns(num) num##U
  112. #else
  113. #define Uns(num) num
  114. #endif                          /* STDC_HEADERS */
  116. void            MDreverse(unsigned int *);
  117. static void     MDblock(MDptr, unsigned int *);
  119. #ifdef SNMP_TESTING_CODE
  120. /*
  121.  * MDprint(MDp)
  122.  * ** Print message digest buffer MDp as 32 hexadecimal digits.
  123.  * ** Order is from low-order byte of buffer[0] to high-order byte of buffer[3].
  124.  * ** Each byte is printed with high-order hexadecimal digit first.
  125.  * ** This is a user-callable routine.
  126.  */
  127. void
  128. MDprint(MDptr MDp)
  129. {
  130.     int             i, j;
  131.     for (i = 0; i < 4; i++)
  132.         for (j = 0; j < 32; j = j + 8)
  133.             printf("%02x", (MDp->buffer[i] >> j) & 0xFF);
  134.     printf("n");
  135.     fflush(stdout);
  136. }
  137. #endif                          /* SNMP_TESTING_CODE */
  139. /*
  140.  * MDbegin(MDp)
  141.  * ** Initialize message digest buffer MDp. 
  142.  * ** This is a user-callable routine.
  143.  */
  144. void
  145. MDbegin(MDptr MDp)
  146. {
  147.     int             i;
  148.     MDp->buffer[0] = I0;
  149.     MDp->buffer[1] = I1;
  150.     MDp->buffer[2] = I2;
  151.     MDp->buffer[3] = I3;
  152.     for (i = 0; i < 8; i++)
  153.         MDp->count[i] = 0;
  154.     MDp->done = 0;
  155. }
  157. /*
  158.  * MDreverse(X)
  159.  * ** Reverse the byte-ordering of every int in X.
  160.  * ** Assumes X is an array of 16 ints.
  161.  * ** The macro revx reverses the byte-ordering of the next word of X.
  162.  */
  163. #define revx { t = (*X << 16) | (*X >> 16); 
  164.        *X++ = ((t & 0xFF00FF00) >> 8) | ((t & 0x00FF00FF) << 8); }
  166. void
  167. MDreverse(unsigned int *X)
  168. {
  169.     register unsigned int t;
  170.     revx;
  171.     revx;
  172.     revx;
  173.     revx;
  174.     revx;
  175.     revx;
  176.     revx;
  177.     revx;
  178.     revx;
  179.     revx;
  180.     revx;
  181.     revx;
  182.     revx;
  183.     revx;
  184.     revx;
  185.     revx;
  186. }
  188. /*
  189.  * MDblock(MDp,X)
  190.  * ** Update message digest buffer MDp->buffer using 16-word data block X.
  191.  * ** Assumes all 16 words of X are full of data.
  192.  * ** Does not update MDp->count.
  193.  * ** This routine is not user-callable. 
  194.  */
  195. static void
  196. MDblock(MDptr MDp, unsigned int *X)
  197. {
  198.     register unsigned int tmp, A, B, C, D;      /* hpux sysv sun */
  199. #ifdef WORDS_BIGENDIAN
  200.     MDreverse(X);
  201. #endif
  202.     A = MDp->buffer[0];
  203.     B = MDp->buffer[1];
  204.     C = MDp->buffer[2];
  205.     D = MDp->buffer[3];
  207.     /*
  208.      * Update the message digest buffer 
  209.      */
  210.     ff(A, B, C, D, 0, fs1, Uns(3614090360));    /* Round 1 */
  211.     ff(D, A, B, C, 1, fs2, Uns(3905402710));
  212.     ff(C, D, A, B, 2, fs3, Uns(606105819));
  213.     ff(B, C, D, A, 3, fs4, Uns(3250441966));
  214.     ff(A, B, C, D, 4, fs1, Uns(4118548399));
  215.     ff(D, A, B, C, 5, fs2, Uns(1200080426));
  216.     ff(C, D, A, B, 6, fs3, Uns(2821735955));
  217.     ff(B, C, D, A, 7, fs4, Uns(4249261313));
  218.     ff(A, B, C, D, 8, fs1, Uns(1770035416));
  219.     ff(D, A, B, C, 9, fs2, Uns(2336552879));
  220.     ff(C, D, A, B, 10, fs3, Uns(4294925233));
  221.     ff(B, C, D, A, 11, fs4, Uns(2304563134));
  222.     ff(A, B, C, D, 12, fs1, Uns(1804603682));
  223.     ff(D, A, B, C, 13, fs2, Uns(4254626195));
  224.     ff(C, D, A, B, 14, fs3, Uns(2792965006));
  225.     ff(B, C, D, A, 15, fs4, Uns(1236535329));
  226.     gg(A, B, C, D, 1, gs1, Uns(4129170786));    /* Round 2 */
  227.     gg(D, A, B, C, 6, gs2, Uns(3225465664));
  228.     gg(C, D, A, B, 11, gs3, Uns(643717713));
  229.     gg(B, C, D, A, 0, gs4, Uns(3921069994));
  230.     gg(A, B, C, D, 5, gs1, Uns(3593408605));
  231.     gg(D, A, B, C, 10, gs2, Uns(38016083));
  232.     gg(C, D, A, B, 15, gs3, Uns(3634488961));
  233.     gg(B, C, D, A, 4, gs4, Uns(3889429448));
  234.     gg(A, B, C, D, 9, gs1, Uns(568446438));
  235.     gg(D, A, B, C, 14, gs2, Uns(3275163606));
  236.     gg(C, D, A, B, 3, gs3, Uns(4107603335));
  237.     gg(B, C, D, A, 8, gs4, Uns(1163531501));
  238.     gg(A, B, C, D, 13, gs1, Uns(2850285829));
  239.     gg(D, A, B, C, 2, gs2, Uns(4243563512));
  240.     gg(C, D, A, B, 7, gs3, Uns(1735328473));
  241.     gg(B, C, D, A, 12, gs4, Uns(2368359562));
  242.     hh(A, B, C, D, 5, hs1, Uns(4294588738));    /* Round 3 */
  243.     hh(D, A, B, C, 8, hs2, Uns(2272392833));
  244.     hh(C, D, A, B, 11, hs3, Uns(1839030562));
  245.     hh(B, C, D, A, 14, hs4, Uns(4259657740));
  246.     hh(A, B, C, D, 1, hs1, Uns(2763975236));
  247.     hh(D, A, B, C, 4, hs2, Uns(1272893353));
  248.     hh(C, D, A, B, 7, hs3, Uns(4139469664));
  249.     hh(B, C, D, A, 10, hs4, Uns(3200236656));
  250.     hh(A, B, C, D, 13, hs1, Uns(681279174));
  251.     hh(D, A, B, C, 0, hs2, Uns(3936430074));
  252.     hh(C, D, A, B, 3, hs3, Uns(3572445317));
  253.     hh(B, C, D, A, 6, hs4, Uns(76029189));
  254.     hh(A, B, C, D, 9, hs1, Uns(3654602809));
  255.     hh(D, A, B, C, 12, hs2, Uns(3873151461));
  256.     hh(C, D, A, B, 15, hs3, Uns(530742520));
  257.     hh(B, C, D, A, 2, hs4, Uns(3299628645));
  258.     ii(A, B, C, D, 0, is1, Uns(4096336452));    /* Round 4 */
  259.     ii(D, A, B, C, 7, is2, Uns(1126891415));
  260.     ii(C, D, A, B, 14, is3, Uns(2878612391));
  261.     ii(B, C, D, A, 5, is4, Uns(4237533241));
  262.     ii(A, B, C, D, 12, is1, Uns(1700485571));
  263.     ii(D, A, B, C, 3, is2, Uns(2399980690));
  264.     ii(C, D, A, B, 10, is3, Uns(4293915773));
  265.     ii(B, C, D, A, 1, is4, Uns(2240044497));
  266.     ii(A, B, C, D, 8, is1, Uns(1873313359));
  267.     ii(D, A, B, C, 15, is2, Uns(4264355552));
  268.     ii(C, D, A, B, 6, is3, Uns(2734768916));
  269.     ii(B, C, D, A, 13, is4, Uns(1309151649));
  270.     ii(A, B, C, D, 4, is1, Uns(4149444226));
  271.     ii(D, A, B, C, 11, is2, Uns(3174756917));
  272.     ii(C, D, A, B, 2, is3, Uns(718787259));
  273.     ii(B, C, D, A, 9, is4, Uns(3951481745));
  275.     MDp->buffer[0] += A;
  276.     MDp->buffer[1] += B;
  277.     MDp->buffer[2] += C;
  278.     MDp->buffer[3] += D;
  279. #ifdef WORDS_BIGENDIAN
  280.     MDreverse(X);
  281. #endif
  282. }
  284. /*
  285.  * MDupdate(MDp,X,count)
  286.  * ** Input: MDp -- an MDptr
  287.  * **        X -- a pointer to an array of unsigned characters.
  288.  * **        count -- the number of bits of X to use.
  289.  * **                 (if not a multiple of 8, uses high bits of last byte.)
  290.  * ** Update MDp using the number of bits of X given by count.
  291.  * ** This is the basic input routine for an MD5 user.
  292.  * ** The routine completes the MD computation when count < 512, so
  293.  * ** every MD computation should end with one call to MDupdate with a
  294.  * ** count less than 512.  A call with count 0 will be ignored if the
  295.  * ** MD has already been terminated (done != 0), so an extra call with count
  296.  * ** 0 can be given as a ``courtesy close'' to force termination if desired.
  297.  * ** Returns : 0 if processing succeeds or was already done;
  298.  * **          -1 if processing was already done
  299.  * **          -2 if count was too large
  300.  */
  301. int
  302. MDupdate(MDptr MDp, unsigned char *X, unsigned int count)
  303. {
  304.     unsigned int    i, tmp, bit, byte, mask;
  305.     unsigned char   XX[64];
  306.     unsigned char  *p;
  307.     /*
  308.      * return with no error if this is a courtesy close with count
  309.      * ** zero and MDp->done is true.
  310.      */
  311.     if (count == 0 && MDp->done)
  312.         return 0;
  313.     /*
  314.      * check to see if MD is already done and report error 
  315.      */
  316.     if (MDp->done) {
  317.         return -1;
  318.     }
  319.     /*
  320.      * if (MDp->done) { fprintf(stderr,"nError: MDupdate MD already done."); return; }
  321.      */
  322.     /*
  323.      * Add count to MDp->count 
  324.      */
  325.     tmp = count;
  326.     p = MDp->count;
  327.     while (tmp) {
  328.         tmp += *p;
  329.         *p++ = tmp;
  330.         tmp = tmp >> 8;
  331.     }
  332.     /*
  333.      * Process data 
  334.      */
  335.     if (count == 512) {         /* Full block of data to handle */
  336.         MDblock(MDp, (unsigned int *) X);
  337.     } else if (count > 512)     /* Check for count too large */
  338.         return -2;
  339.     /*
  340.      * { fprintf(stderr,"nError: MDupdate called with illegal count value %d.",count);
  341.      * return;
  342.      * }
  343.      */
  344.     else {                      /* partial block -- must be last block so finish up */
  345.         /*
  346.          * Find out how many bytes and residual bits there are 
  347.          */
  348.         int             copycount;
  349.         byte = count >> 3;
  350.         bit = count & 7;
  351.         copycount = byte;
  352.         if (bit)
  353.             copycount++;
  354.         /*
  355.          * Copy X into XX since we need to modify it 
  356.          */
  357.         memset(XX, 0, sizeof(XX));
  358.         memcpy(XX, X, copycount);
  360.         /*
  361.          * Add padding '1' bit and low-order zeros in last byte 
  362.          */
  363.         mask = ((unsigned long) 1) << (7 - bit);
  364.         XX[byte] = (XX[byte] | mask) & ~(mask - 1);
  365.         /*
  366.          * If room for bit count, finish up with this block 
  367.          */
  368.         if (byte <= 55) {
  369.             for (i = 0; i < 8; i++)
  370.                 XX[56 + i] = MDp->count[i];
  371.             MDblock(MDp, (unsigned int *) XX);
  372.         } else {                /* need to do two blocks to finish up */
  373.             MDblock(MDp, (unsigned int *) XX);
  374.             for (i = 0; i < 56; i++)
  375.                 XX[i] = 0;
  376.             for (i = 0; i < 8; i++)
  377.                 XX[56 + i] = MDp->count[i];
  378.             MDblock(MDp, (unsigned int *) XX);
  379.         }
  380.         /*
  381.          * Set flag saying we're done with MD computation 
  382.          */
  383.         MDp->done = 1;
  384.     }
  385.     return 0;
  386. }
  388. /*
  389.  * MDchecksum(data, len, MD5): do a checksum on an arbirtrary amount of data 
  390.  */
  391. int
  392. MDchecksum(u_char * data, size_t len, u_char * mac, size_t maclen)
  393. {
  394.     MDstruct        md;
  395.     MDstruct       *MD = &md;
  396.     int             rc = 0;
  398.     MDbegin(MD);
  399.     while (len >= 64) {
  400.         rc = MDupdate(MD, data, 64 * 8);
  401.         if (rc)
  402.             goto check_end;
  403.         data += 64;
  404.         len -= 64;
  405.     }
  406.     rc = MDupdate(MD, data, len * 8);
  407.     if (rc)
  408.         goto check_end;
  410.     /*
  411.      * copy the checksum to the outgoing data (all of it that is requested). 
  412.      */
  413.     MDget(MD, mac, maclen);
  415.   check_end:
  416.     memset(&md, 0, sizeof(md));
  417.     return rc;
  418. }
  421. /*
  422.  * MDsign(data, len, MD5): do a checksum on an arbirtrary amount
  423.  * of data, and prepended with a secret in the standard fashion 
  424.  */
  425. int
  426. MDsign(u_char * data, size_t len, u_char * mac, size_t maclen,
  427.        u_char * secret, size_t secretlen)
  428. {
  429. #define HASHKEYLEN 64
  431.     MDstruct        MD;
  432.     u_char          K1[HASHKEYLEN];
  433.     u_char          K2[HASHKEYLEN];
  434.     u_char          extendedAuthKey[HASHKEYLEN];
  435.     u_char          buf[HASHKEYLEN];
  436.     size_t          i;
  437.     u_char         *cp, *newdata = 0;
  438.     int             rc = 0;
  440.     /*
  441.      * memset(K1,0,HASHKEYLEN);
  442.      * memset(K2,0,HASHKEYLEN);
  443.      * memset(buf,0,HASHKEYLEN);
  444.      * memset(extendedAuthKey,0,HASHKEYLEN);
  445.      */
  447.     if (secretlen != 16 || secret == NULL || mac == NULL || data == NULL ||
  448.         len <= 0 || maclen <= 0) {
  449.         /*
  450.          * DEBUGMSGTL(("md5","MD5 signing not properly initialized")); 
  451.          */
  452.         return -1;
  453.     }
  455.     memset(extendedAuthKey, 0, HASHKEYLEN);
  456.     memcpy(extendedAuthKey, secret, secretlen);
  457.     for (i = 0; i < HASHKEYLEN; i++) {
  458.         K1[i] = extendedAuthKey[i] ^ 0x36;
  459.         K2[i] = extendedAuthKey[i] ^ 0x5c;
  460.     }
  462.     MDbegin(&MD);
  463.     rc = MDupdate(&MD, K1, HASHKEYLEN * 8);
  464.     if (rc)
  465.         goto update_end;
  467.     i = len;
  468.     if (((unsigned int) data) % sizeof(long) != 0) {
  469.         /*
  470.          * this relies on the ability to use integer math and thus we
  471.          * must rely on data that aligns on 32-bit-word-boundries 
  472.          */
  473.         memdup(&newdata, data, len);
  474.         cp = newdata;
  475.     } else {
  476.         cp = data;
  477.     }
  479.     while (i >= 64) {
  480.         rc = MDupdate(&MD, cp, 64 * 8);
  481.         if (rc)
  482.             goto update_end;
  483.         cp += 64;
  484.         i -= 64;
  485.     }
  487.     rc = MDupdate(&MD, cp, i * 8);
  488.     if (rc)
  489.         goto update_end;
  491.     memset(buf, 0, HASHKEYLEN);
  492.     MDget(&MD, buf, HASHKEYLEN);
  494.     MDbegin(&MD);
  495.     rc = MDupdate(&MD, K2, HASHKEYLEN * 8);
  496.     if (rc)
  497.         goto update_end;
  498.     rc = MDupdate(&MD, buf, 16 * 8);
  499.     if (rc)
  500.         goto update_end;
  502.     /*
  503.      * copy the sign checksum to the outgoing pointer 
  504.      */
  505.     MDget(&MD, mac, maclen);
  507.   update_end:
  508.     memset(buf, 0, HASHKEYLEN);
  509.     memset(K1, 0, HASHKEYLEN);
  510.     memset(K2, 0, HASHKEYLEN);
  511.     memset(extendedAuthKey, 0, HASHKEYLEN);
  512.     memset(&MD, 0, sizeof(MD));
  514.     if (newdata)
  515.         free(newdata);
  516.     return rc;
  517. }
  519. void
  520. MDget(MDstruct * MD, u_char * buf, size_t buflen)
  521. {
  522.     int             i, j;
  524.     /*
  525.      * copy the checksum to the outgoing data (all of it that is requested). 
  526.      */
  527.     for (i = 0; i < 4 && i * 4 < (int) buflen; i++)
  528.         for (j = 0; j < 4 && i * 4 + j < (int) buflen; j++)
  529.             buf[i * 4 + j] = (MD->buffer[i] >> j * 8) & 0xff;
  530. }
  532. /*
  533.  * ** End of md5.c
  534.  * ****************************(cut)****************************************
  535.  */
  537. #endif /* DISABLE_MD5 */