+++ /dev/null
-/* SHA module */\r
-\r
-/* This module provides an interface to NIST's Secure Hash Algorithm */\r
-\r
-/* See below for information about the original code this module was\r
- based upon. Additional work performed by:\r
-\r
- Andrew Kuchling (amk@amk.ca)\r
- Greg Stein (gstein@lyra.org)\r
-\r
- Copyright (C) 2005 Gregory P. Smith (greg@krypto.org)\r
- Licensed to PSF under a Contributor Agreement.\r
-\r
-*/\r
-\r
-/* SHA objects */\r
-\r
-#include "Python.h"\r
-#include "structmember.h"\r
-\r
-\r
-/* Endianness testing and definitions */\r
-#define TestEndianness(variable) {int i=1; variable=PCT_BIG_ENDIAN;\\r
- if (*((char*)&i)==1) variable=PCT_LITTLE_ENDIAN;}\r
-\r
-#define PCT_LITTLE_ENDIAN 1\r
-#define PCT_BIG_ENDIAN 0\r
-\r
-/* Some useful types */\r
-\r
-typedef unsigned char SHA_BYTE;\r
-\r
-#if SIZEOF_INT == 4\r
-typedef unsigned int SHA_INT32; /* 32-bit integer */\r
-#else\r
-/* not defined. compilation will die. */\r
-#endif\r
-\r
-/* The SHA block size and message digest sizes, in bytes */\r
-\r
-#define SHA_BLOCKSIZE 64\r
-#define SHA_DIGESTSIZE 20\r
-\r
-/* The structure for storing SHS info */\r
-\r
-typedef struct {\r
- PyObject_HEAD\r
- SHA_INT32 digest[5]; /* Message digest */\r
- SHA_INT32 count_lo, count_hi; /* 64-bit bit count */\r
- SHA_BYTE data[SHA_BLOCKSIZE]; /* SHA data buffer */\r
- int Endianness;\r
- int local; /* unprocessed amount in data */\r
-} SHAobject;\r
-\r
-/* When run on a little-endian CPU we need to perform byte reversal on an\r
- array of longwords. */\r
-\r
-static void longReverse(SHA_INT32 *buffer, int byteCount, int Endianness)\r
-{\r
- SHA_INT32 value;\r
-\r
- if ( Endianness == PCT_BIG_ENDIAN )\r
- return;\r
-\r
- byteCount /= sizeof(*buffer);\r
- while (byteCount--) {\r
- value = *buffer;\r
- value = ( ( value & 0xFF00FF00L ) >> 8 ) | \\r
- ( ( value & 0x00FF00FFL ) << 8 );\r
- *buffer++ = ( value << 16 ) | ( value >> 16 );\r
- }\r
-}\r
-\r
-static void SHAcopy(SHAobject *src, SHAobject *dest)\r
-{\r
- dest->Endianness = src->Endianness;\r
- dest->local = src->local;\r
- dest->count_lo = src->count_lo;\r
- dest->count_hi = src->count_hi;\r
- memcpy(dest->digest, src->digest, sizeof(src->digest));\r
- memcpy(dest->data, src->data, sizeof(src->data));\r
-}\r
-\r
-\r
-/* ------------------------------------------------------------------------\r
- *\r
- * This code for the SHA algorithm was noted as public domain. The original\r
- * headers are pasted below.\r
- *\r
- * Several changes have been made to make it more compatible with the\r
- * Python environment and desired interface.\r
- *\r
- */\r
-\r
-/* NIST Secure Hash Algorithm */\r
-/* heavily modified by Uwe Hollerbach <uh@alumni.caltech edu> */\r
-/* from Peter C. Gutmann's implementation as found in */\r
-/* Applied Cryptography by Bruce Schneier */\r
-/* Further modifications to include the "UNRAVEL" stuff, below */\r
-\r
-/* This code is in the public domain */\r
-\r
-/* UNRAVEL should be fastest & biggest */\r
-/* UNROLL_LOOPS should be just as big, but slightly slower */\r
-/* both undefined should be smallest and slowest */\r
-\r
-#define UNRAVEL\r
-/* #define UNROLL_LOOPS */\r
-\r
-/* The SHA f()-functions. The f1 and f3 functions can be optimized to\r
- save one boolean operation each - thanks to Rich Schroeppel,\r
- rcs@cs.arizona.edu for discovering this */\r
-\r
-/*#define f1(x,y,z) ((x & y) | (~x & z)) // Rounds 0-19 */\r
-#define f1(x,y,z) (z ^ (x & (y ^ z))) /* Rounds 0-19 */\r
-#define f2(x,y,z) (x ^ y ^ z) /* Rounds 20-39 */\r
-/*#define f3(x,y,z) ((x & y) | (x & z) | (y & z)) // Rounds 40-59 */\r
-#define f3(x,y,z) ((x & y) | (z & (x | y))) /* Rounds 40-59 */\r
-#define f4(x,y,z) (x ^ y ^ z) /* Rounds 60-79 */\r
-\r
-/* SHA constants */\r
-\r
-#define CONST1 0x5a827999L /* Rounds 0-19 */\r
-#define CONST2 0x6ed9eba1L /* Rounds 20-39 */\r
-#define CONST3 0x8f1bbcdcL /* Rounds 40-59 */\r
-#define CONST4 0xca62c1d6L /* Rounds 60-79 */\r
-\r
-/* 32-bit rotate */\r
-\r
-#define R32(x,n) ((x << n) | (x >> (32 - n)))\r
-\r
-/* the generic case, for when the overall rotation is not unraveled */\r
-\r
-#define FG(n) \\r
- T = R32(A,5) + f##n(B,C,D) + E + *WP++ + CONST##n; \\r
- E = D; D = C; C = R32(B,30); B = A; A = T\r
-\r
-/* specific cases, for when the overall rotation is unraveled */\r
-\r
-#define FA(n) \\r
- T = R32(A,5) + f##n(B,C,D) + E + *WP++ + CONST##n; B = R32(B,30)\r
-\r
-#define FB(n) \\r
- E = R32(T,5) + f##n(A,B,C) + D + *WP++ + CONST##n; A = R32(A,30)\r
-\r
-#define FC(n) \\r
- D = R32(E,5) + f##n(T,A,B) + C + *WP++ + CONST##n; T = R32(T,30)\r
-\r
-#define FD(n) \\r
- C = R32(D,5) + f##n(E,T,A) + B + *WP++ + CONST##n; E = R32(E,30)\r
-\r
-#define FE(n) \\r
- B = R32(C,5) + f##n(D,E,T) + A + *WP++ + CONST##n; D = R32(D,30)\r
-\r
-#define FT(n) \\r
- A = R32(B,5) + f##n(C,D,E) + T + *WP++ + CONST##n; C = R32(C,30)\r
-\r
-/* do SHA transformation */\r
-\r
-static void\r
-sha_transform(SHAobject *sha_info)\r
-{\r
- int i;\r
- SHA_INT32 T, A, B, C, D, E, W[80], *WP;\r
-\r
- memcpy(W, sha_info->data, sizeof(sha_info->data));\r
- longReverse(W, (int)sizeof(sha_info->data), sha_info->Endianness);\r
-\r
- for (i = 16; i < 80; ++i) {\r
- W[i] = W[i-3] ^ W[i-8] ^ W[i-14] ^ W[i-16];\r
-\r
- /* extra rotation fix */\r
- W[i] = R32(W[i], 1);\r
- }\r
- A = sha_info->digest[0];\r
- B = sha_info->digest[1];\r
- C = sha_info->digest[2];\r
- D = sha_info->digest[3];\r
- E = sha_info->digest[4];\r
- WP = W;\r
-#ifdef UNRAVEL\r
- FA(1); FB(1); FC(1); FD(1); FE(1); FT(1); FA(1); FB(1); FC(1); FD(1);\r
- FE(1); FT(1); FA(1); FB(1); FC(1); FD(1); FE(1); FT(1); FA(1); FB(1);\r
- FC(2); FD(2); FE(2); FT(2); FA(2); FB(2); FC(2); FD(2); FE(2); FT(2);\r
- FA(2); FB(2); FC(2); FD(2); FE(2); FT(2); FA(2); FB(2); FC(2); FD(2);\r
- FE(3); FT(3); FA(3); FB(3); FC(3); FD(3); FE(3); FT(3); FA(3); FB(3);\r
- FC(3); FD(3); FE(3); FT(3); FA(3); FB(3); FC(3); FD(3); FE(3); FT(3);\r
- FA(4); FB(4); FC(4); FD(4); FE(4); FT(4); FA(4); FB(4); FC(4); FD(4);\r
- FE(4); FT(4); FA(4); FB(4); FC(4); FD(4); FE(4); FT(4); FA(4); FB(4);\r
- sha_info->digest[0] += E;\r
- sha_info->digest[1] += T;\r
- sha_info->digest[2] += A;\r
- sha_info->digest[3] += B;\r
- sha_info->digest[4] += C;\r
-#else /* !UNRAVEL */\r
-#ifdef UNROLL_LOOPS\r
- FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1);\r
- FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1);\r
- FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2);\r
- FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2);\r
- FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3);\r
- FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3);\r
- FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4);\r
- FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4);\r
-#else /* !UNROLL_LOOPS */\r
- for (i = 0; i < 20; ++i) { FG(1); }\r
- for (i = 20; i < 40; ++i) { FG(2); }\r
- for (i = 40; i < 60; ++i) { FG(3); }\r
- for (i = 60; i < 80; ++i) { FG(4); }\r
-#endif /* !UNROLL_LOOPS */\r
- sha_info->digest[0] += A;\r
- sha_info->digest[1] += B;\r
- sha_info->digest[2] += C;\r
- sha_info->digest[3] += D;\r
- sha_info->digest[4] += E;\r
-#endif /* !UNRAVEL */\r
-}\r
-\r
-/* initialize the SHA digest */\r
-\r
-static void\r
-sha_init(SHAobject *sha_info)\r
-{\r
- TestEndianness(sha_info->Endianness)\r
-\r
- sha_info->digest[0] = 0x67452301L;\r
- sha_info->digest[1] = 0xefcdab89L;\r
- sha_info->digest[2] = 0x98badcfeL;\r
- sha_info->digest[3] = 0x10325476L;\r
- sha_info->digest[4] = 0xc3d2e1f0L;\r
- sha_info->count_lo = 0L;\r
- sha_info->count_hi = 0L;\r
- sha_info->local = 0;\r
-}\r
-\r
-/* update the SHA digest */\r
-\r
-static void\r
-sha_update(SHAobject *sha_info, SHA_BYTE *buffer, unsigned int count)\r
-{\r
- unsigned int i;\r
- SHA_INT32 clo;\r
-\r
- clo = sha_info->count_lo + ((SHA_INT32) count << 3);\r
- if (clo < sha_info->count_lo) {\r
- ++sha_info->count_hi;\r
- }\r
- sha_info->count_lo = clo;\r
- sha_info->count_hi += (SHA_INT32) count >> 29;\r
- if (sha_info->local) {\r
- i = SHA_BLOCKSIZE - sha_info->local;\r
- if (i > count) {\r
- i = count;\r
- }\r
- memcpy(((SHA_BYTE *) sha_info->data) + sha_info->local, buffer, i);\r
- count -= i;\r
- buffer += i;\r
- sha_info->local += i;\r
- if (sha_info->local == SHA_BLOCKSIZE) {\r
- sha_transform(sha_info);\r
- }\r
- else {\r
- return;\r
- }\r
- }\r
- while (count >= SHA_BLOCKSIZE) {\r
- memcpy(sha_info->data, buffer, SHA_BLOCKSIZE);\r
- buffer += SHA_BLOCKSIZE;\r
- count -= SHA_BLOCKSIZE;\r
- sha_transform(sha_info);\r
- }\r
- memcpy(sha_info->data, buffer, count);\r
- sha_info->local = count;\r
-}\r
-\r
-/* finish computing the SHA digest */\r
-\r
-static void\r
-sha_final(unsigned char digest[20], SHAobject *sha_info)\r
-{\r
- int count;\r
- SHA_INT32 lo_bit_count, hi_bit_count;\r
-\r
- lo_bit_count = sha_info->count_lo;\r
- hi_bit_count = sha_info->count_hi;\r
- count = (int) ((lo_bit_count >> 3) & 0x3f);\r
- ((SHA_BYTE *) sha_info->data)[count++] = 0x80;\r
- if (count > SHA_BLOCKSIZE - 8) {\r
- memset(((SHA_BYTE *) sha_info->data) + count, 0,\r
- SHA_BLOCKSIZE - count);\r
- sha_transform(sha_info);\r
- memset((SHA_BYTE *) sha_info->data, 0, SHA_BLOCKSIZE - 8);\r
- }\r
- else {\r
- memset(((SHA_BYTE *) sha_info->data) + count, 0,\r
- SHA_BLOCKSIZE - 8 - count);\r
- }\r
-\r
- /* GJS: note that we add the hi/lo in big-endian. sha_transform will\r
- swap these values into host-order. */\r
- sha_info->data[56] = (hi_bit_count >> 24) & 0xff;\r
- sha_info->data[57] = (hi_bit_count >> 16) & 0xff;\r
- sha_info->data[58] = (hi_bit_count >> 8) & 0xff;\r
- sha_info->data[59] = (hi_bit_count >> 0) & 0xff;\r
- sha_info->data[60] = (lo_bit_count >> 24) & 0xff;\r
- sha_info->data[61] = (lo_bit_count >> 16) & 0xff;\r
- sha_info->data[62] = (lo_bit_count >> 8) & 0xff;\r
- sha_info->data[63] = (lo_bit_count >> 0) & 0xff;\r
- sha_transform(sha_info);\r
- digest[ 0] = (unsigned char) ((sha_info->digest[0] >> 24) & 0xff);\r
- digest[ 1] = (unsigned char) ((sha_info->digest[0] >> 16) & 0xff);\r
- digest[ 2] = (unsigned char) ((sha_info->digest[0] >> 8) & 0xff);\r
- digest[ 3] = (unsigned char) ((sha_info->digest[0] ) & 0xff);\r
- digest[ 4] = (unsigned char) ((sha_info->digest[1] >> 24) & 0xff);\r
- digest[ 5] = (unsigned char) ((sha_info->digest[1] >> 16) & 0xff);\r
- digest[ 6] = (unsigned char) ((sha_info->digest[1] >> 8) & 0xff);\r
- digest[ 7] = (unsigned char) ((sha_info->digest[1] ) & 0xff);\r
- digest[ 8] = (unsigned char) ((sha_info->digest[2] >> 24) & 0xff);\r
- digest[ 9] = (unsigned char) ((sha_info->digest[2] >> 16) & 0xff);\r
- digest[10] = (unsigned char) ((sha_info->digest[2] >> 8) & 0xff);\r
- digest[11] = (unsigned char) ((sha_info->digest[2] ) & 0xff);\r
- digest[12] = (unsigned char) ((sha_info->digest[3] >> 24) & 0xff);\r
- digest[13] = (unsigned char) ((sha_info->digest[3] >> 16) & 0xff);\r
- digest[14] = (unsigned char) ((sha_info->digest[3] >> 8) & 0xff);\r
- digest[15] = (unsigned char) ((sha_info->digest[3] ) & 0xff);\r
- digest[16] = (unsigned char) ((sha_info->digest[4] >> 24) & 0xff);\r
- digest[17] = (unsigned char) ((sha_info->digest[4] >> 16) & 0xff);\r
- digest[18] = (unsigned char) ((sha_info->digest[4] >> 8) & 0xff);\r
- digest[19] = (unsigned char) ((sha_info->digest[4] ) & 0xff);\r
-}\r
-\r
-/*\r
- * End of copied SHA code.\r
- *\r
- * ------------------------------------------------------------------------\r
- */\r
-\r
-static PyTypeObject SHAtype;\r
-\r
-\r
-static SHAobject *\r
-newSHAobject(void)\r
-{\r
- return (SHAobject *)PyObject_New(SHAobject, &SHAtype);\r
-}\r
-\r
-/* Internal methods for a hashing object */\r
-\r
-static void\r
-SHA_dealloc(PyObject *ptr)\r
-{\r
- PyObject_Del(ptr);\r
-}\r
-\r
-\r
-/* External methods for a hashing object */\r
-\r
-PyDoc_STRVAR(SHA_copy__doc__, "Return a copy of the hashing object.");\r
-\r
-static PyObject *\r
-SHA_copy(SHAobject *self, PyObject *unused)\r
-{\r
- SHAobject *newobj;\r
-\r
- if ( (newobj = newSHAobject())==NULL)\r
- return NULL;\r
-\r
- SHAcopy(self, newobj);\r
- return (PyObject *)newobj;\r
-}\r
-\r
-PyDoc_STRVAR(SHA_digest__doc__,\r
-"Return the digest value as a string of binary data.");\r
-\r
-static PyObject *\r
-SHA_digest(SHAobject *self, PyObject *unused)\r
-{\r
- unsigned char digest[SHA_DIGESTSIZE];\r
- SHAobject temp;\r
-\r
- SHAcopy(self, &temp);\r
- sha_final(digest, &temp);\r
- return PyString_FromStringAndSize((const char *)digest, sizeof(digest));\r
-}\r
-\r
-PyDoc_STRVAR(SHA_hexdigest__doc__,\r
-"Return the digest value as a string of hexadecimal digits.");\r
-\r
-static PyObject *\r
-SHA_hexdigest(SHAobject *self, PyObject *unused)\r
-{\r
- unsigned char digest[SHA_DIGESTSIZE];\r
- SHAobject temp;\r
- PyObject *retval;\r
- char *hex_digest;\r
- int i, j;\r
-\r
- /* Get the raw (binary) digest value */\r
- SHAcopy(self, &temp);\r
- sha_final(digest, &temp);\r
-\r
- /* Create a new string */\r
- retval = PyString_FromStringAndSize(NULL, sizeof(digest) * 2);\r
- if (!retval)\r
- return NULL;\r
- hex_digest = PyString_AsString(retval);\r
- if (!hex_digest) {\r
- Py_DECREF(retval);\r
- return NULL;\r
- }\r
-\r
- /* Make hex version of the digest */\r
- for(i=j=0; i<sizeof(digest); i++) {\r
- char c;\r
- c = (digest[i] >> 4) & 0xf;\r
- c = (c>9) ? c+'a'-10 : c + '0';\r
- hex_digest[j++] = c;\r
- c = (digest[i] & 0xf);\r
- c = (c>9) ? c+'a'-10 : c + '0';\r
- hex_digest[j++] = c;\r
- }\r
- return retval;\r
-}\r
-\r
-PyDoc_STRVAR(SHA_update__doc__,\r
-"Update this hashing object's state with the provided string.");\r
-\r
-static PyObject *\r
-SHA_update(SHAobject *self, PyObject *args)\r
-{\r
- Py_buffer view;\r
- Py_ssize_t n;\r
- unsigned char *buf;\r
-\r
- if (!PyArg_ParseTuple(args, "s*:update", &view))\r
- return NULL;\r
-\r
- n = view.len;\r
- buf = (unsigned char *) view.buf;\r
- while (n > 0) {\r
- Py_ssize_t nbytes;\r
- if (n > INT_MAX)\r
- nbytes = INT_MAX;\r
- else\r
- nbytes = n;\r
- sha_update(self, buf,\r
- Py_SAFE_DOWNCAST(nbytes, Py_ssize_t, unsigned int));\r
- buf += nbytes;\r
- n -= nbytes;\r
- }\r
-\r
- PyBuffer_Release(&view);\r
- Py_RETURN_NONE;\r
-}\r
-\r
-static PyMethodDef SHA_methods[] = {\r
- {"copy", (PyCFunction)SHA_copy, METH_NOARGS, SHA_copy__doc__},\r
- {"digest", (PyCFunction)SHA_digest, METH_NOARGS, SHA_digest__doc__},\r
- {"hexdigest", (PyCFunction)SHA_hexdigest, METH_NOARGS, SHA_hexdigest__doc__},\r
- {"update", (PyCFunction)SHA_update, METH_VARARGS, SHA_update__doc__},\r
- {NULL, NULL} /* sentinel */\r
-};\r
-\r
-static PyObject *\r
-SHA_get_block_size(PyObject *self, void *closure)\r
-{\r
- return PyInt_FromLong(SHA_BLOCKSIZE);\r
-}\r
-\r
-static PyObject *\r
-SHA_get_digest_size(PyObject *self, void *closure)\r
-{\r
- return PyInt_FromLong(SHA_DIGESTSIZE);\r
-}\r
-\r
-static PyObject *\r
-SHA_get_name(PyObject *self, void *closure)\r
-{\r
- return PyString_FromStringAndSize("SHA1", 4);\r
-}\r
-\r
-static PyGetSetDef SHA_getseters[] = {\r
- {"digest_size",\r
- (getter)SHA_get_digest_size, NULL,\r
- NULL,\r
- NULL},\r
- {"block_size",\r
- (getter)SHA_get_block_size, NULL,\r
- NULL,\r
- NULL},\r
- {"name",\r
- (getter)SHA_get_name, NULL,\r
- NULL,\r
- NULL},\r
- /* the old md5 and sha modules support 'digest_size' as in PEP 247.\r
- * the old sha module also supported 'digestsize'. ugh. */\r
- {"digestsize",\r
- (getter)SHA_get_digest_size, NULL,\r
- NULL,\r
- NULL},\r
- {NULL} /* Sentinel */\r
-};\r
-\r
-static PyTypeObject SHAtype = {\r
- PyVarObject_HEAD_INIT(NULL, 0)\r
- "_sha.sha", /*tp_name*/\r
- sizeof(SHAobject), /*tp_size*/\r
- 0, /*tp_itemsize*/\r
- /* methods */\r
- SHA_dealloc, /*tp_dealloc*/\r
- 0, /*tp_print*/\r
- 0, /*tp_getattr*/\r
- 0, /*tp_setattr*/\r
- 0, /*tp_compare*/\r
- 0, /*tp_repr*/\r
- 0, /*tp_as_number*/\r
- 0, /*tp_as_sequence*/\r
- 0, /*tp_as_mapping*/\r
- 0, /*tp_hash*/\r
- 0, /*tp_call*/\r
- 0, /*tp_str*/\r
- 0, /*tp_getattro*/\r
- 0, /*tp_setattro*/\r
- 0, /*tp_as_buffer*/\r
- Py_TPFLAGS_DEFAULT, /*tp_flags*/\r
- 0, /*tp_doc*/\r
- 0, /*tp_traverse*/\r
- 0, /*tp_clear*/\r
- 0, /*tp_richcompare*/\r
- 0, /*tp_weaklistoffset*/\r
- 0, /*tp_iter*/\r
- 0, /*tp_iternext*/\r
- SHA_methods, /* tp_methods */\r
- 0, /* tp_members */\r
- SHA_getseters, /* tp_getset */\r
-};\r
-\r
-\r
-/* The single module-level function: new() */\r
-\r
-PyDoc_STRVAR(SHA_new__doc__,\r
-"Return a new SHA hashing object. An optional string argument\n\\r
-may be provided; if present, this string will be automatically\n\\r
-hashed.");\r
-\r
-static PyObject *\r
-SHA_new(PyObject *self, PyObject *args, PyObject *kwdict)\r
-{\r
- static char *kwlist[] = {"string", NULL};\r
- SHAobject *new;\r
- Py_buffer view = { 0 };\r
- Py_ssize_t n;\r
- unsigned char *buf;\r
-\r
- if (!PyArg_ParseTupleAndKeywords(args, kwdict, "|s*:new", kwlist,\r
- &view)) {\r
- return NULL;\r
- }\r
-\r
- if ((new = newSHAobject()) == NULL) {\r
- PyBuffer_Release(&view);\r
- return NULL;\r
- }\r
-\r
- sha_init(new);\r
-\r
- if (PyErr_Occurred()) {\r
- Py_DECREF(new);\r
- PyBuffer_Release(&view);\r
- return NULL;\r
- }\r
-\r
- n = view.len;\r
- buf = (unsigned char *) view.buf;\r
- while (n > 0) {\r
- Py_ssize_t nbytes;\r
- if (n > INT_MAX)\r
- nbytes = INT_MAX;\r
- else\r
- nbytes = n;\r
- sha_update(new, buf,\r
- Py_SAFE_DOWNCAST(nbytes, Py_ssize_t, unsigned int));\r
- buf += nbytes;\r
- n -= nbytes;\r
- }\r
-\r
- PyBuffer_Release(&view);\r
-\r
- return (PyObject *)new;\r
-}\r
-\r
-\r
-/* List of functions exported by this module */\r
-\r
-static struct PyMethodDef SHA_functions[] = {\r
- {"new", (PyCFunction)SHA_new, METH_VARARGS|METH_KEYWORDS, SHA_new__doc__},\r
- {NULL, NULL} /* Sentinel */\r
-};\r
-\r
-\r
-/* Initialize this module. */\r
-\r
-#define insint(n,v) { PyModule_AddIntConstant(m,n,v); }\r
-\r
-PyMODINIT_FUNC\r
-init_sha(void)\r
-{\r
- PyObject *m;\r
-\r
- Py_TYPE(&SHAtype) = &PyType_Type;\r
- if (PyType_Ready(&SHAtype) < 0)\r
- return;\r
- m = Py_InitModule("_sha", SHA_functions);\r
- if (m == NULL)\r
- return;\r
-\r
- /* Add some symbolic constants to the module */\r
- insint("blocksize", 1); /* For future use, in case some hash\r
- functions require an integral number of\r
- blocks */\r
- insint("digestsize", 20);\r
- insint("digest_size", 20);\r
-}\r
projects / mirror_edk2.git / blobdiff