home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / py2s152.zip / Modules / shamodule.c < prev    next >
C/C++ Source or Header  |  1999-06-27  |  18KB  |  605 lines
  1. /***********************************************************
  2. Copyright 1999 by Stichting Mathematisch Centrum, Amsterdam,
  3. The Netherlands.
  4.  
  5.                         All Rights Reserved
  6.  
  7. Permission to use, copy, modify, and distribute this software and its
  8. documentation for any purpose and without fee is hereby granted,
  9. provided that the above copyright notice appear in all copies and that
  10. both that copyright notice and this permission notice appear in
  11. supporting documentation, and that the names of Stichting Mathematisch
  12. Centrum or CWI or Corporation for National Research Initiatives or
  13. CNRI not be used in advertising or publicity pertaining to
  14. distribution of the software without specific, written prior
  15. permission.
  16.  
  17. While CWI is the initial source for this software, a modified version
  18. is made available by the Corporation for National Research Initiatives
  19. (CNRI) at the Internet address ftp://ftp.python.org.
  20.  
  21. STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
  22. REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
  23. MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
  24. CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
  25. DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  26. PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  27. TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  28. PERFORMANCE OF THIS SOFTWARE.
  29.  
  30. ******************************************************************/
  31.  
  32. /* SHA module */
  33.  
  34. /* This module provides an interface to NIST's Secure Hash Algorithm */
  35.  
  36. /* See below for information about the original code this module was
  37.    based upon. Additional work performed by:
  38.  
  39.    Andrew Kuchling (amk1@erols.com)
  40.    Greg Stein (gstein@lyra.org)
  41. */
  42.  
  43. /* SHA objects */
  44.  
  45. #include "Python.h"
  46.  
  47.  
  48. /* Endianness testing and definitions */
  49. #define TestEndianness(variable) {int i=1; variable=PCT_BIG_ENDIAN;\
  50.     if (*((char*)&i)==1) variable=PCT_LITTLE_ENDIAN;}
  51.  
  52. #define PCT_LITTLE_ENDIAN 1
  53. #define PCT_BIG_ENDIAN 0
  54.  
  55. /* Some useful types */
  56.  
  57. typedef unsigned char SHA_BYTE;
  58.  
  59. #if SIZEOF_INT == 4
  60. typedef unsigned int SHA_INT32;    /* 32-bit integer */
  61. #else
  62. /* not defined. compilation will die. */
  63. #endif
  64.  
  65. /* The SHA block size and message digest sizes, in bytes */
  66.  
  67. #define SHA_BLOCKSIZE    64
  68. #define SHA_DIGESTSIZE  20
  69.  
  70. /* The structure for storing SHS info */
  71.  
  72. typedef struct {
  73.     PyObject_HEAD
  74.     SHA_INT32 digest[5];        /* Message digest */
  75.     SHA_INT32 count_lo, count_hi;    /* 64-bit bit count */
  76.     SHA_BYTE data[SHA_BLOCKSIZE];    /* SHA data buffer */
  77.     int Endianness;
  78.     int local;            /* unprocessed amount in data */
  79. } SHAobject;
  80.  
  81. /* When run on a little-endian CPU we need to perform byte reversal on an
  82.    array of longwords. */
  83.  
  84. static void longReverse(buffer, byteCount, Endianness)
  85.     SHA_INT32 *buffer; 
  86.     int byteCount, Endianness;
  87. {
  88.     SHA_INT32 value;
  89.  
  90.     if ( Endianness == PCT_BIG_ENDIAN )
  91.     return;
  92.  
  93.     byteCount /= sizeof(*buffer);
  94.     while( byteCount-- )
  95.     {
  96.         value = *buffer;
  97.         value = ( ( value & 0xFF00FF00L ) >> 8  ) | \
  98.                 ( ( value & 0x00FF00FFL ) << 8 );
  99.         *buffer++ = ( value << 16 ) | ( value >> 16 );
  100.     }
  101. }
  102.  
  103. static void SHAcopy(src, dest)
  104.      SHAobject *src, *dest;
  105. {
  106.     dest->Endianness = src->Endianness;
  107.     dest->local = src->local;
  108.     dest->count_lo = src->count_lo;
  109.     dest->count_hi = src->count_hi;
  110.     memcpy(dest->digest, src->digest, sizeof(src->digest));
  111.     memcpy(dest->data, src->data, sizeof(src->data));
  112. }
  113.  
  114.  
  115. /* ------------------------------------------------------------------------
  116.  *
  117.  * This code for the SHA algorithm was noted as public domain. The original
  118.  * headers are pasted below.
  119.  *
  120.  * Several changes have been made to make it more compatible with the
  121.  * Python environment and desired interface.
  122.  *
  123.  */
  124.  
  125. /* NIST Secure Hash Algorithm */
  126. /* heavily modified by Uwe Hollerbach <uh@alumni.caltech edu> */
  127. /* from Peter C. Gutmann's implementation as found in */
  128. /* Applied Cryptography by Bruce Schneier */
  129. /* Further modifications to include the "UNRAVEL" stuff, below */
  130.  
  131. /* This code is in the public domain */
  132.  
  133. /* UNRAVEL should be fastest & biggest */
  134. /* UNROLL_LOOPS should be just as big, but slightly slower */
  135. /* both undefined should be smallest and slowest */
  136.  
  137. #define UNRAVEL
  138. /* #define UNROLL_LOOPS */
  139.  
  140. /* The SHA f()-functions.  The f1 and f3 functions can be optimized to
  141.    save one boolean operation each - thanks to Rich Schroeppel,
  142.    rcs@cs.arizona.edu for discovering this */
  143.  
  144. /*#define f1(x,y,z)    ((x & y) | (~x & z))        // Rounds  0-19 */
  145. #define f1(x,y,z)    (z ^ (x & (y ^ z)))        /* Rounds  0-19 */
  146. #define f2(x,y,z)    (x ^ y ^ z)            /* Rounds 20-39 */
  147. /*#define f3(x,y,z)    ((x & y) | (x & z) | (y & z))    // Rounds 40-59 */
  148. #define f3(x,y,z)    ((x & y) | (z & (x | y)))    /* Rounds 40-59 */
  149. #define f4(x,y,z)    (x ^ y ^ z)            /* Rounds 60-79 */
  150.  
  151. /* SHA constants */
  152.  
  153. #define CONST1        0x5a827999L            /* Rounds  0-19 */
  154. #define CONST2        0x6ed9eba1L            /* Rounds 20-39 */
  155. #define CONST3        0x8f1bbcdcL            /* Rounds 40-59 */
  156. #define CONST4        0xca62c1d6L            /* Rounds 60-79 */
  157.  
  158. /* 32-bit rotate */
  159.  
  160. #define R32(x,n)    ((x << n) | (x >> (32 - n)))
  161.  
  162. /* the generic case, for when the overall rotation is not unraveled */
  163.  
  164. #define FG(n)    \
  165.     T = R32(A,5) + f##n(B,C,D) + E + *WP++ + CONST##n;    \
  166.     E = D; D = C; C = R32(B,30); B = A; A = T
  167.  
  168. /* specific cases, for when the overall rotation is unraveled */
  169.  
  170. #define FA(n)    \
  171.     T = R32(A,5) + f##n(B,C,D) + E + *WP++ + CONST##n; B = R32(B,30)
  172.  
  173. #define FB(n)    \
  174.     E = R32(T,5) + f##n(A,B,C) + D + *WP++ + CONST##n; A = R32(A,30)
  175.  
  176. #define FC(n)    \
  177.     D = R32(E,5) + f##n(T,A,B) + C + *WP++ + CONST##n; T = R32(T,30)
  178.  
  179. #define FD(n)    \
  180.     C = R32(D,5) + f##n(E,T,A) + B + *WP++ + CONST##n; E = R32(E,30)
  181.  
  182. #define FE(n)    \
  183.     B = R32(C,5) + f##n(D,E,T) + A + *WP++ + CONST##n; D = R32(D,30)
  184.  
  185. #define FT(n)    \
  186.     A = R32(B,5) + f##n(C,D,E) + T + *WP++ + CONST##n; C = R32(C,30)
  187.  
  188. /* do SHA transformation */
  189.  
  190. static void
  191. sha_transform(sha_info)
  192.     SHAobject *sha_info;
  193. {
  194.     int i;
  195.     SHA_INT32 T, A, B, C, D, E, W[80], *WP;
  196.  
  197.     memcpy(W, sha_info->data, sizeof(sha_info->data));
  198.     longReverse(W, (int)sizeof(sha_info->data), sha_info->Endianness);
  199.  
  200.     for (i = 16; i < 80; ++i) {
  201.     W[i] = W[i-3] ^ W[i-8] ^ W[i-14] ^ W[i-16];
  202.  
  203.     /* extra rotation fix */
  204.     W[i] = R32(W[i], 1);
  205.     }
  206.     A = sha_info->digest[0];
  207.     B = sha_info->digest[1];
  208.     C = sha_info->digest[2];
  209.     D = sha_info->digest[3];
  210.     E = sha_info->digest[4];
  211.     WP = W;
  212. #ifdef UNRAVEL
  213.     FA(1); FB(1); FC(1); FD(1); FE(1); FT(1); FA(1); FB(1); FC(1); FD(1);
  214.     FE(1); FT(1); FA(1); FB(1); FC(1); FD(1); FE(1); FT(1); FA(1); FB(1);
  215.     FC(2); FD(2); FE(2); FT(2); FA(2); FB(2); FC(2); FD(2); FE(2); FT(2);
  216.     FA(2); FB(2); FC(2); FD(2); FE(2); FT(2); FA(2); FB(2); FC(2); FD(2);
  217.     FE(3); FT(3); FA(3); FB(3); FC(3); FD(3); FE(3); FT(3); FA(3); FB(3);
  218.     FC(3); FD(3); FE(3); FT(3); FA(3); FB(3); FC(3); FD(3); FE(3); FT(3);
  219.     FA(4); FB(4); FC(4); FD(4); FE(4); FT(4); FA(4); FB(4); FC(4); FD(4);
  220.     FE(4); FT(4); FA(4); FB(4); FC(4); FD(4); FE(4); FT(4); FA(4); FB(4);
  221.     sha_info->digest[0] += E;
  222.     sha_info->digest[1] += T;
  223.     sha_info->digest[2] += A;
  224.     sha_info->digest[3] += B;
  225.     sha_info->digest[4] += C;
  226. #else /* !UNRAVEL */
  227. #ifdef UNROLL_LOOPS
  228.     FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1);
  229.     FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1);
  230.     FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2);
  231.     FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2);
  232.     FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3);
  233.     FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3);
  234.     FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4);
  235.     FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4);
  236. #else /* !UNROLL_LOOPS */
  237.     for (i =  0; i < 20; ++i) { FG(1); }
  238.     for (i = 20; i < 40; ++i) { FG(2); }
  239.     for (i = 40; i < 60; ++i) { FG(3); }
  240.     for (i = 60; i < 80; ++i) { FG(4); }
  241. #endif /* !UNROLL_LOOPS */
  242.     sha_info->digest[0] += A;
  243.     sha_info->digest[1] += B;
  244.     sha_info->digest[2] += C;
  245.     sha_info->digest[3] += D;
  246.     sha_info->digest[4] += E;
  247. #endif /* !UNRAVEL */
  248. }
  249.  
  250. /* initialize the SHA digest */
  251.  
  252. static void
  253. sha_init(sha_info)
  254.     SHAobject *sha_info;
  255. {
  256.     TestEndianness(sha_info->Endianness)
  257.  
  258.     sha_info->digest[0] = 0x67452301L;
  259.     sha_info->digest[1] = 0xefcdab89L;
  260.     sha_info->digest[2] = 0x98badcfeL;
  261.     sha_info->digest[3] = 0x10325476L;
  262.     sha_info->digest[4] = 0xc3d2e1f0L;
  263.     sha_info->count_lo = 0L;
  264.     sha_info->count_hi = 0L;
  265.     sha_info->local = 0;
  266. }
  267.  
  268. /* update the SHA digest */
  269.  
  270. static void
  271. sha_update(sha_info, buffer, count)
  272.     SHAobject *sha_info;
  273.     SHA_BYTE *buffer;
  274.     int count;
  275. {
  276.     int i;
  277.     SHA_INT32 clo;
  278.  
  279.     clo = sha_info->count_lo + ((SHA_INT32) count << 3);
  280.     if (clo < sha_info->count_lo) {
  281.         ++sha_info->count_hi;
  282.     }
  283.     sha_info->count_lo = clo;
  284.     sha_info->count_hi += (SHA_INT32) count >> 29;
  285.     if (sha_info->local) {
  286.         i = SHA_BLOCKSIZE - sha_info->local;
  287.         if (i > count) {
  288.             i = count;
  289.         }
  290.         memcpy(((SHA_BYTE *) sha_info->data) + sha_info->local,
  291.                buffer, i);
  292.         count -= i;
  293.         buffer += i;
  294.         sha_info->local += i;
  295.         if (sha_info->local == SHA_BLOCKSIZE) {
  296.             sha_transform(sha_info);
  297.         } else {
  298.             return;
  299.         }
  300.     }
  301.     while (count >= SHA_BLOCKSIZE) {
  302.         memcpy(sha_info->data, buffer, SHA_BLOCKSIZE);
  303.         buffer += SHA_BLOCKSIZE;
  304.         count -= SHA_BLOCKSIZE;
  305.         sha_transform(sha_info);
  306.     }
  307.     memcpy(sha_info->data, buffer, count);
  308.     sha_info->local = count;
  309. }
  310.  
  311. /* finish computing the SHA digest */
  312.  
  313. static void
  314. sha_final(digest, sha_info)
  315.     unsigned char digest[20];
  316.     SHAobject *sha_info;
  317. {
  318.     int count;
  319.     SHA_INT32 lo_bit_count, hi_bit_count;
  320.  
  321.     lo_bit_count = sha_info->count_lo;
  322.     hi_bit_count = sha_info->count_hi;
  323.     count = (int) ((lo_bit_count >> 3) & 0x3f);
  324.     ((SHA_BYTE *) sha_info->data)[count++] = 0x80;
  325.     if (count > SHA_BLOCKSIZE - 8)
  326.     {
  327.     memset(((SHA_BYTE *) sha_info->data) + count, 0,
  328.            SHA_BLOCKSIZE - count);
  329.     sha_transform(sha_info);
  330.     memset((SHA_BYTE *) sha_info->data, 0, SHA_BLOCKSIZE - 8);
  331.     }
  332.     else
  333.     {
  334.     memset(((SHA_BYTE *) sha_info->data) + count, 0,
  335.            SHA_BLOCKSIZE - 8 - count);
  336.     }
  337.  
  338.     /* GJS: note that we add the hi/lo in big-endian. sha_transform will
  339.        swap these values into host-order. */
  340.     sha_info->data[56] = (hi_bit_count >> 24) & 0xff;
  341.     sha_info->data[57] = (hi_bit_count >> 16) & 0xff;
  342.     sha_info->data[58] = (hi_bit_count >>  8) & 0xff;
  343.     sha_info->data[59] = (hi_bit_count >>  0) & 0xff;
  344.     sha_info->data[60] = (lo_bit_count >> 24) & 0xff;
  345.     sha_info->data[61] = (lo_bit_count >> 16) & 0xff;
  346.     sha_info->data[62] = (lo_bit_count >>  8) & 0xff;
  347.     sha_info->data[63] = (lo_bit_count >>  0) & 0xff;
  348.     sha_transform(sha_info);
  349.     digest[ 0] = (unsigned char) ((sha_info->digest[0] >> 24) & 0xff);
  350.     digest[ 1] = (unsigned char) ((sha_info->digest[0] >> 16) & 0xff);
  351.     digest[ 2] = (unsigned char) ((sha_info->digest[0] >>  8) & 0xff);
  352.     digest[ 3] = (unsigned char) ((sha_info->digest[0]      ) & 0xff);
  353.     digest[ 4] = (unsigned char) ((sha_info->digest[1] >> 24) & 0xff);
  354.     digest[ 5] = (unsigned char) ((sha_info->digest[1] >> 16) & 0xff);
  355.     digest[ 6] = (unsigned char) ((sha_info->digest[1] >>  8) & 0xff);
  356.     digest[ 7] = (unsigned char) ((sha_info->digest[1]      ) & 0xff);
  357.     digest[ 8] = (unsigned char) ((sha_info->digest[2] >> 24) & 0xff);
  358.     digest[ 9] = (unsigned char) ((sha_info->digest[2] >> 16) & 0xff);
  359.     digest[10] = (unsigned char) ((sha_info->digest[2] >>  8) & 0xff);
  360.     digest[11] = (unsigned char) ((sha_info->digest[2]      ) & 0xff);
  361.     digest[12] = (unsigned char) ((sha_info->digest[3] >> 24) & 0xff);
  362.     digest[13] = (unsigned char) ((sha_info->digest[3] >> 16) & 0xff);
  363.     digest[14] = (unsigned char) ((sha_info->digest[3] >>  8) & 0xff);
  364.     digest[15] = (unsigned char) ((sha_info->digest[3]      ) & 0xff);
  365.     digest[16] = (unsigned char) ((sha_info->digest[4] >> 24) & 0xff);
  366.     digest[17] = (unsigned char) ((sha_info->digest[4] >> 16) & 0xff);
  367.     digest[18] = (unsigned char) ((sha_info->digest[4] >>  8) & 0xff);
  368.     digest[19] = (unsigned char) ((sha_info->digest[4]      ) & 0xff);
  369. }
  370.  
  371. /*
  372.  * End of copied SHA code.
  373.  *
  374.  * ------------------------------------------------------------------------
  375.  */
  376.  
  377. staticforward PyTypeObject SHAtype;
  378.  
  379.  
  380. static SHAobject *
  381. newSHAobject()
  382. {
  383.     return (SHAobject *)PyObject_NEW(SHAobject, &SHAtype);
  384. }
  385.  
  386. /* Internal methods for a hashing object */
  387.  
  388. static void
  389. SHA_dealloc(ptr)
  390.     PyObject *ptr;
  391. {
  392.     PyMem_DEL(ptr);
  393. }
  394.  
  395.  
  396. /* External methods for a hashing object */
  397.  
  398. static char SHA_copy__doc__[] = 
  399. "Return a copy of the hashing object.";
  400.  
  401. static PyObject *
  402. SHA_copy(self, args)
  403.     SHAobject *self;
  404.     PyObject *args;
  405. {
  406.     SHAobject *newobj;
  407.  
  408.     if (!PyArg_NoArgs(args)) {
  409.         return NULL;
  410.     }
  411.  
  412.     if ( (newobj = newSHAobject())==NULL)
  413.         return NULL;
  414.     
  415.     SHAcopy(self, newobj);
  416.     return (PyObject *)newobj;
  417. }
  418.  
  419. static char SHA_digest__doc__[] = 
  420. "Return the digest value as a string of binary data.";
  421.  
  422. static PyObject *
  423. SHA_digest(self, args)
  424.     SHAobject *self;
  425.     PyObject *args;
  426. {
  427.     unsigned char digest[SHA_DIGESTSIZE];
  428.     SHAobject temp;
  429.  
  430.     if (!PyArg_NoArgs(args))
  431.         return NULL;
  432.  
  433.     SHAcopy(self, &temp);
  434.     sha_final(digest, &temp);
  435.     return PyString_FromStringAndSize((const char *)digest, sizeof(digest));
  436. }
  437.  
  438. static char SHA_hexdigest__doc__[] = 
  439. "Return the digest value as a string of hexadecimal digits.";
  440.  
  441. static PyObject *
  442. SHA_hexdigest(self, args)
  443.     SHAobject *self;
  444.     PyObject *args;
  445. {
  446.     unsigned char digest[SHA_DIGESTSIZE];
  447.     SHAobject temp;
  448.     PyObject *retval;
  449.     char *hex_digest;
  450.     int i, j;
  451.  
  452.     if (!PyArg_NoArgs(args))
  453.         return NULL;
  454.  
  455.     /* Get the raw (binary) digest value */
  456.     SHAcopy(self, &temp);
  457.     sha_final(digest, &temp);
  458.  
  459.     /* Create a new string */
  460.     retval = PyString_FromStringAndSize(NULL, sizeof(digest) * 2);
  461.     hex_digest = PyString_AsString(retval);
  462.  
  463.     /* Make hex version of the digest */
  464.     for(i=j=0; i<sizeof(digest); i++)    
  465.     {
  466.         char c;
  467.         c = digest[i] / 16; c = (c>9) ? c+'a'-10 : c + '0';
  468.         hex_digest[j++] = c;
  469.         c = digest[i] % 16; c = (c>9) ? c+'a'-10 : c + '0';
  470.         hex_digest[j++] = c;
  471.     }
  472.  
  473.     return retval;
  474. }
  475.  
  476. static char SHA_update__doc__[] = 
  477. "Update this hashing object's state with the provided string.";
  478.  
  479. static PyObject *
  480. SHA_update(self, args)
  481.     SHAobject *self;
  482.     PyObject *args;
  483. {
  484.     unsigned char *cp;
  485.     int len;
  486.  
  487.     if (!PyArg_Parse(args, "s#", &cp, &len))
  488.         return NULL;
  489.  
  490.     sha_update(self, cp, len);
  491.  
  492.     Py_INCREF(Py_None);
  493.     return Py_None;
  494. }
  495.  
  496. static PyMethodDef SHA_methods[] = {
  497.     {"copy",    (PyCFunction)SHA_copy, 0, SHA_copy__doc__},
  498.     {"digest",    (PyCFunction)SHA_digest, 0, SHA_digest__doc__},
  499.     {"hexdigest",    (PyCFunction)SHA_hexdigest, 0, SHA_hexdigest__doc__},
  500.     {"update",    (PyCFunction)SHA_update, 0, SHA_update__doc__},
  501.     {NULL,        NULL}        /* sentinel */
  502. };
  503.  
  504. static PyObject *
  505. SHA_getattr(self, name)
  506.     PyObject *self;
  507.     char *name;
  508. {
  509.     if (strcmp(name, "blocksize")==0)
  510.         return PyInt_FromLong(1);
  511.     if (strcmp(name, "digestsize")==0)
  512.         return PyInt_FromLong(20);
  513.     
  514.     return Py_FindMethod(SHA_methods, self, name);
  515. }
  516.  
  517. static PyTypeObject SHAtype = {
  518.     PyObject_HEAD_INIT(NULL)
  519.     0,            /*ob_size*/
  520.     "SHA",            /*tp_name*/
  521.     sizeof(SHAobject),    /*tp_size*/
  522.     0,            /*tp_itemsize*/
  523.     /* methods */
  524.     SHA_dealloc,        /*tp_dealloc*/
  525.     0,            /*tp_print*/
  526.     SHA_getattr,        /*tp_getattr*/
  527. };
  528.  
  529.  
  530. /* The single module-level function: new() */
  531.  
  532. static char SHA_new__doc__[] =
  533.  "Return a new SHA hashing object.  An optional string "
  534.  "argument may be provided; if present, this string will be "
  535.  " automatically hashed."; 
  536.  
  537. static PyObject *
  538. SHA_new(self, args, kwdict)
  539.     PyObject *self;
  540.     PyObject *args;
  541.     PyObject *kwdict;
  542. {
  543.     static char *kwlist[] = {"string", NULL};
  544.     SHAobject *new;
  545.     unsigned char *cp = NULL;
  546.     int len;
  547.     
  548.     if ((new = newSHAobject()) == NULL)
  549.         return NULL;
  550.  
  551.     if (!PyArg_ParseTupleAndKeywords(args, kwdict, "|s#", kwlist,
  552.                      &cp, &len)) {
  553.             Py_DECREF(new);
  554.         return NULL;
  555.     }
  556.  
  557.         sha_init(new);
  558.  
  559.     if (PyErr_Occurred()) {
  560.         Py_DECREF(new);
  561.         return NULL;
  562.     }
  563.     if (cp)
  564.         sha_update(new, cp, len);
  565.  
  566.     return (PyObject *)new;
  567. }
  568.  
  569.  
  570. /* List of functions exported by this module */
  571.  
  572. static struct PyMethodDef SHA_functions[] = {
  573.     {"new", (PyCFunction)SHA_new, METH_VARARGS|METH_KEYWORDS, SHA_new__doc__},
  574.     {"sha",    (PyCFunction)SHA_new, METH_VARARGS|METH_KEYWORDS, SHA_new__doc__},
  575.     {NULL,    NULL}         /* Sentinel */
  576. };
  577.  
  578.  
  579. /* Initialize this module. */
  580.  
  581. #define insint(n,v) { PyObject *o=PyInt_FromLong(v); \
  582.     if (o!=NULL) PyDict_SetItemString(d,n,o); \
  583.     Py_XDECREF(o); }
  584.  
  585. void
  586. initsha()
  587. {
  588.     PyObject *d, *m;
  589.  
  590.     SHAtype.ob_type = &PyType_Type;
  591.     m = Py_InitModule("sha", SHA_functions);
  592.  
  593.     /* Add some symbolic constants to the module */
  594.     d = PyModule_GetDict(m);
  595.     insint("blocksize", 1);  /* For future use, in case some hash
  596.                     functions require an integral number of
  597.                     blocks */ 
  598.     insint("digestsize", 20);
  599.  
  600.     /* Check for errors */
  601.     if (PyErr_Occurred())
  602.         Py_FatalError("can't initialize module SHA");
  603. }
  604.  
  605.