EmbeddedPkg: Extend NvVarStoreFormattedLib LIBRARY_CLASS

[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.2 / Modules / shamodule.c

/* 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
\r
    if (!PyArg_ParseTuple(args, "s*:update", &view))\r
        return NULL;\r
\r
    sha_update(self, (unsigned char*)view.buf,\r
               Py_SAFE_DOWNCAST(view.len, Py_ssize_t, unsigned int));\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
\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
    if (view.len > 0) {\r
        sha_update(new, (unsigned char*)view.buf,\r
                   Py_SAFE_DOWNCAST(view.len, Py_ssize_t, unsigned int));\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