Changeset 391 for python/trunk/Modules/shamodule.c

Timestamp:

Mar 19, 2014, 11:31:01 PM (11 years ago)

Author:

dmik

Message:

python: Merge vendor 2.7.6 to trunk.

Location:

python/trunk

Files:

• . (modified) (1 prop)
• Modules/shamodule.c (modified) (17 diffs)

python/trunk/Modules/shamodule.c

@@ -22 +22 @@
 /* Endianness testing and definitions */
 #define TestEndianness(variable) {int i=1; variable=PCT_BIG_ENDIAN;\
-        if (*((char*)&i)==1) variable=PCT_LITTLE_ENDIAN;}
+        if (*((char*)&i)==1) variable=PCT_LITTLE_ENDIAN;}
 
 #define PCT_LITTLE_ENDIAN 1
@@ -32 +32 @@
 
 #if SIZEOF_INT == 4
-typedef unsigned int SHA_INT32; /* 32-bit integer */
+typedef unsigned int SHA_INT32; /* 32-bit integer */
 #else
 /* not defined. compilation will die. */
@@ -46 +46 @@
 typedef struct {
     PyObject_HEAD
-    SHA_INT32 digest[5];                /* Message digest */
-    SHA_INT32 count_lo, count_hi;       /* 64-bit bit count */
-    SHA_BYTE data[SHA_BLOCKSIZE];       /* SHA data buffer */
+    SHA_INT32 digest[5];                /* Message digest */
+    SHA_INT32 count_lo, count_hi;       /* 64-bit bit count */
+    SHA_BYTE data[SHA_BLOCKSIZE];       /* SHA data buffer */
     int Endianness;
-    int local;                          /* unprocessed amount in data */
+    int local;                          /* unprocessed amount in data */
 } SHAobject;
 
@@ -61 +61 @@
 
     if ( Endianness == PCT_BIG_ENDIAN )
-        return;
+        return;
 
     byteCount /= sizeof(*buffer);
@@ -112 +112 @@
    rcs@cs.arizona.edu for discovering this */
 
-/*#define f1(x,y,z)     ((x & y) | (~x & z))            // Rounds  0-19 */
-#define f1(x,y,z)       (z ^ (x & (y ^ z)))             /* Rounds  0-19 */
-#define f2(x,y,z)       (x ^ y ^ z)                     /* Rounds 20-39 */
-/*#define f3(x,y,z)     ((x & y) | (x & z) | (y & z))   // Rounds 40-59 */
-#define f3(x,y,z)       ((x & y) | (z & (x | y)))       /* Rounds 40-59 */
-#define f4(x,y,z)       (x ^ y ^ z)                     /* Rounds 60-79 */
+/*#define f1(x,y,z)     ((x & y) | (~x & z))            // Rounds  0-19 */
+#define f1(x,y,z)       (z ^ (x & (y ^ z)))             /* Rounds  0-19 */
+#define f2(x,y,z)       (x ^ y ^ z)                     /* Rounds 20-39 */
+/*#define f3(x,y,z)     ((x & y) | (x & z) | (y & z))   // Rounds 40-59 */
+#define f3(x,y,z)       ((x & y) | (z & (x | y)))       /* Rounds 40-59 */
+#define f4(x,y,z)       (x ^ y ^ z)                     /* Rounds 60-79 */
 
 /* SHA constants */
 
-#define CONST1          0x5a827999L                     /* Rounds  0-19 */
-#define CONST2          0x6ed9eba1L                     /* Rounds 20-39 */
-#define CONST3          0x8f1bbcdcL                     /* Rounds 40-59 */
-#define CONST4          0xca62c1d6L                     /* Rounds 60-79 */
+#define CONST1          0x5a827999L                     /* Rounds  0-19 */
+#define CONST2          0x6ed9eba1L                     /* Rounds 20-39 */
+#define CONST3          0x8f1bbcdcL                     /* Rounds 40-59 */
+#define CONST4          0xca62c1d6L                     /* Rounds 60-79 */
 
 /* 32-bit rotate */
 
-#define R32(x,n)        ((x << n) | (x >> (32 - n)))
+#define R32(x,n)        ((x << n) | (x >> (32 - n)))
 
 /* the generic case, for when the overall rotation is not unraveled */
 
-#define FG(n)   \
-    T = R32(A,5) + f##n(B,C,D) + E + *WP++ + CONST##n;  \
+#define FG(n)   \
+    T = R32(A,5) + f##n(B,C,D) + E + *WP++ + CONST##n;  \
     E = D; D = C; C = R32(B,30); B = A; A = T
 
 /* specific cases, for when the overall rotation is unraveled */
 
-#define FA(n)   \
+#define FA(n)   \
     T = R32(A,5) + f##n(B,C,D) + E + *WP++ + CONST##n; B = R32(B,30)
 
-#define FB(n)   \
+#define FB(n)   \
     E = R32(T,5) + f##n(A,B,C) + D + *WP++ + CONST##n; A = R32(A,30)
 
-#define FC(n)   \
+#define FC(n)   \
     D = R32(E,5) + f##n(T,A,B) + C + *WP++ + CONST##n; T = R32(T,30)
 
-#define FD(n)   \
+#define FD(n)   \
     C = R32(D,5) + f##n(E,T,A) + B + *WP++ + CONST##n; E = R32(E,30)
 
-#define FE(n)   \
+#define FE(n)   \
     B = R32(C,5) + f##n(D,E,T) + A + *WP++ + CONST##n; D = R32(D,30)
 
-#define FT(n)   \
+#define FT(n)   \
     A = R32(B,5) + f##n(C,D,E) + T + *WP++ + CONST##n; C = R32(C,30)
 
@@ -168 +168 @@
 
     for (i = 16; i < 80; ++i) {
-        W[i] = W[i-3] ^ W[i-8] ^ W[i-14] ^ W[i-16];
-
-        /* extra rotation fix */
-        W[i] = R32(W[i], 1);
+        W[i] = W[i-3] ^ W[i-8] ^ W[i-14] ^ W[i-16];
+
+        /* extra rotation fix */
+        W[i] = R32(W[i], 1);
     }
     A = sha_info->digest[0];
@@ -237 +237 @@
 
 static void
-sha_update(SHAobject *sha_info, SHA_BYTE *buffer, int count)
-{
-    int i;
+sha_update(SHAobject *sha_info, SHA_BYTE *buffer, unsigned int count)
+{
+    unsigned int i;
     SHA_INT32 clo;
 
@@ -287 +287 @@
     ((SHA_BYTE *) sha_info->data)[count++] = 0x80;
     if (count > SHA_BLOCKSIZE - 8) {
-        memset(((SHA_BYTE *) sha_info->data) + count, 0,
-               SHA_BLOCKSIZE - count);
-        sha_transform(sha_info);
-        memset((SHA_BYTE *) sha_info->data, 0, SHA_BLOCKSIZE - 8);
+        memset(((SHA_BYTE *) sha_info->data) + count, 0,
+               SHA_BLOCKSIZE - count);
+        sha_transform(sha_info);
+        memset((SHA_BYTE *) sha_info->data, 0, SHA_BLOCKSIZE - 8);
     }
     else {
-        memset(((SHA_BYTE *) sha_info->data) + count, 0,
-               SHA_BLOCKSIZE - 8 - count);
+        memset(((SHA_BYTE *) sha_info->data) + count, 0,
+               SHA_BLOCKSIZE - 8 - count);
     }
 
@@ -403 +403 @@
     retval = PyString_FromStringAndSize(NULL, sizeof(digest) * 2);
     if (!retval)
-            return NULL;
+            return NULL;
     hex_digest = PyString_AsString(retval);
     if (!hex_digest) {
-            Py_DECREF(retval);
-            return NULL;
+            Py_DECREF(retval);
+            return NULL;
     }
 
@@ -414 +414 @@
         char c;
         c = (digest[i] >> 4) & 0xf;
-        c = (c>9) ? c+'a'-10 : c + '0';
+        c = (c>9) ? c+'a'-10 : c + '0';
         hex_digest[j++] = c;
         c = (digest[i] & 0xf);
-        c = (c>9) ? c+'a'-10 : c + '0';
+        c = (c>9) ? c+'a'-10 : c + '0';
         hex_digest[j++] = c;
     }
@@ -429 +429 @@
 SHA_update(SHAobject *self, PyObject *args)
 {
-    unsigned char *cp;
-    int len;
-
-    if (!PyArg_ParseTuple(args, "s#:update", &cp, &len))
+    Py_buffer view;
+    Py_ssize_t n;
+    unsigned char *buf;
+
+    if (!PyArg_ParseTuple(args, "s*:update", &view))
         return NULL;
 
-    sha_update(self, cp, len);
-
-    Py_INCREF(Py_None);
-    return Py_None;
+    n = view.len;
+    buf = (unsigned char *) view.buf;
+    while (n > 0) {
+        Py_ssize_t nbytes;
+        if (n > INT_MAX)
+            nbytes = INT_MAX;
+        else
+            nbytes = n;
+        sha_update(self, buf,
+                   Py_SAFE_DOWNCAST(nbytes, Py_ssize_t, unsigned int));
+        buf += nbytes;
+        n -= nbytes;
+    }
+
+    PyBuffer_Release(&view);
+    Py_RETURN_NONE;
 }
 
 static PyMethodDef SHA_methods[] = {
-    {"copy",      (PyCFunction)SHA_copy,      METH_NOARGS,  SHA_copy__doc__},
-    {"digest",    (PyCFunction)SHA_digest,    METH_NOARGS,  SHA_digest__doc__},
+    {"copy",      (PyCFunction)SHA_copy,      METH_NOARGS,  SHA_copy__doc__},
+    {"digest",    (PyCFunction)SHA_digest,    METH_NOARGS,  SHA_digest__doc__},
     {"hexdigest", (PyCFunction)SHA_hexdigest, METH_NOARGS,  SHA_hexdigest__doc__},
-    {"update",    (PyCFunction)SHA_update,    METH_VARARGS, SHA_update__doc__},
-    {NULL,        NULL}         /* sentinel */
+    {"update",    (PyCFunction)SHA_update,    METH_VARARGS, SHA_update__doc__},
+    {NULL,        NULL}         /* sentinel */
 };
 
@@ -491 +504 @@
 static PyTypeObject SHAtype = {
     PyVarObject_HEAD_INIT(NULL, 0)
-    "_sha.sha",         /*tp_name*/
-    sizeof(SHAobject),  /*tp_size*/
-    0,                  /*tp_itemsize*/
+    "_sha.sha",         /*tp_name*/
+    sizeof(SHAobject),  /*tp_size*/
+    0,                  /*tp_itemsize*/
     /* methods */
-    SHA_dealloc,        /*tp_dealloc*/
-    0,                  /*tp_print*/
+    SHA_dealloc,        /*tp_dealloc*/
+    0,                  /*tp_print*/
     0,                  /*tp_getattr*/
     0,                  /*tp_setattr*/
@@ -513 +526 @@
     0,                  /*tp_doc*/
     0,                  /*tp_traverse*/
-    0,                  /*tp_clear*/
-    0,                  /*tp_richcompare*/
-    0,                  /*tp_weaklistoffset*/
-    0,                  /*tp_iter*/
-    0,                  /*tp_iternext*/
-    SHA_methods,        /* tp_methods */
+    0,                  /*tp_clear*/
+    0,                  /*tp_richcompare*/
+    0,                  /*tp_weaklistoffset*/
+    0,                  /*tp_iter*/
+    0,                  /*tp_iternext*/
+    SHA_methods,        /* tp_methods */
     0,                  /* tp_members */
     SHA_getseters,      /* tp_getset */
@@ -536 +549 @@
     static char *kwlist[] = {"string", NULL};
     SHAobject *new;
-    unsigned char *cp = NULL;
-    int len;
-
-    if (!PyArg_ParseTupleAndKeywords(args, kwdict, "|s#:new", kwlist,
-                                     &cp, &len)) {
+    Py_buffer view = { 0 };
+    Py_ssize_t n;
+    unsigned char *buf;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwdict, "|s*:new", kwlist,
+                                     &view)) {
         return NULL;
     }
 
-    if ((new = newSHAobject()) == NULL)
+    if ((new = newSHAobject()) == NULL) {
+        PyBuffer_Release(&view);
         return NULL;
+    }
 
     sha_init(new);
@@ -551 +567 @@
     if (PyErr_Occurred()) {
         Py_DECREF(new);
+        PyBuffer_Release(&view);
         return NULL;
     }
-    if (cp)
-        sha_update(new, cp, len);
+
+    n = view.len;
+    buf = (unsigned char *) view.buf;
+    while (n > 0) {
+        Py_ssize_t nbytes;
+        if (n > INT_MAX)
+            nbytes = INT_MAX;
+        else
+            nbytes = n;
+        sha_update(new, buf,
+                   Py_SAFE_DOWNCAST(nbytes, Py_ssize_t, unsigned int));
+        buf += nbytes;
+        n -= nbytes;
+    }
+
+    PyBuffer_Release(&view);
 
     return (PyObject *)new;
@@ -564 +595 @@
 static struct PyMethodDef SHA_functions[] = {
     {"new", (PyCFunction)SHA_new, METH_VARARGS|METH_KEYWORDS, SHA_new__doc__},
-    {NULL,      NULL}            /* Sentinel */
+    {NULL,      NULL}            /* Sentinel */
 };
 
@@ -582 +613 @@
     m = Py_InitModule("_sha", SHA_functions);
     if (m == NULL)
-        return;
+        return;
 
     /* Add some symbolic constants to the module */
     insint("blocksize", 1);  /* For future use, in case some hash
                                 functions require an integral number of
-                                blocks */ 
+                                blocks */
     insint("digestsize", 20);
     insint("digest_size", 20);