3 /* This module provides an interface to NIST's Secure Hash Algorithm */
5 /* See below for information about the original code this module was
6 based upon. Additional work performed by:
8 Andrew Kuchling (amk@amk.ca)
9 Greg Stein (gstein@lyra.org)
11 Copyright (C) 2005 Gregory P. Smith (greg@krypto.org)
12 Licensed to PSF under a Contributor Agreement.
19 #include "structmember.h"
23 /* Endianness testing and definitions */
24 #define TestEndianness(variable) {int i=1; variable=PCT_BIG_ENDIAN;\
25 if (*((char*)&i)==1) variable=PCT_LITTLE_ENDIAN;}
27 #define PCT_LITTLE_ENDIAN 1
28 #define PCT_BIG_ENDIAN 0
30 /* Some useful types */
32 typedef unsigned char SHA_BYTE
;
35 typedef unsigned int SHA_INT32
; /* 32-bit integer */
37 /* not defined. compilation will die. */
40 /* The SHA block size and message digest sizes, in bytes */
42 #define SHA_BLOCKSIZE 64
43 #define SHA_DIGESTSIZE 20
45 /* The structure for storing SHS info */
49 SHA_INT32 digest
[5]; /* Message digest */
50 SHA_INT32 count_lo
, count_hi
; /* 64-bit bit count */
51 SHA_BYTE data
[SHA_BLOCKSIZE
]; /* SHA data buffer */
53 int local
; /* unprocessed amount in data */
56 /* When run on a little-endian CPU we need to perform byte reversal on an
57 array of longwords. */
59 static void longReverse(SHA_INT32
*buffer
, int byteCount
, int Endianness
)
63 if ( Endianness
== PCT_BIG_ENDIAN
)
66 byteCount
/= sizeof(*buffer
);
69 value
= ( ( value
& 0xFF00FF00L
) >> 8 ) | \
70 ( ( value
& 0x00FF00FFL
) << 8 );
71 *buffer
++ = ( value
<< 16 ) | ( value
>> 16 );
75 static void SHAcopy(SHAobject
*src
, SHAobject
*dest
)
77 dest
->Endianness
= src
->Endianness
;
78 dest
->local
= src
->local
;
79 dest
->count_lo
= src
->count_lo
;
80 dest
->count_hi
= src
->count_hi
;
81 memcpy(dest
->digest
, src
->digest
, sizeof(src
->digest
));
82 memcpy(dest
->data
, src
->data
, sizeof(src
->data
));
86 /* ------------------------------------------------------------------------
88 * This code for the SHA algorithm was noted as public domain. The original
89 * headers are pasted below.
91 * Several changes have been made to make it more compatible with the
92 * Python environment and desired interface.
96 /* NIST Secure Hash Algorithm */
97 /* heavily modified by Uwe Hollerbach <uh@alumni.caltech edu> */
98 /* from Peter C. Gutmann's implementation as found in */
99 /* Applied Cryptography by Bruce Schneier */
100 /* Further modifications to include the "UNRAVEL" stuff, below */
102 /* This code is in the public domain */
104 /* UNRAVEL should be fastest & biggest */
105 /* UNROLL_LOOPS should be just as big, but slightly slower */
106 /* both undefined should be smallest and slowest */
109 /* #define UNROLL_LOOPS */
111 /* The SHA f()-functions. The f1 and f3 functions can be optimized to
112 save one boolean operation each - thanks to Rich Schroeppel,
113 rcs@cs.arizona.edu for discovering this */
115 /*#define f1(x,y,z) ((x & y) | (~x & z)) // Rounds 0-19 */
116 #define f1(x,y,z) (z ^ (x & (y ^ z))) /* Rounds 0-19 */
117 #define f2(x,y,z) (x ^ y ^ z) /* Rounds 20-39 */
118 /*#define f3(x,y,z) ((x & y) | (x & z) | (y & z)) // Rounds 40-59 */
119 #define f3(x,y,z) ((x & y) | (z & (x | y))) /* Rounds 40-59 */
120 #define f4(x,y,z) (x ^ y ^ z) /* Rounds 60-79 */
124 #define CONST1 0x5a827999L /* Rounds 0-19 */
125 #define CONST2 0x6ed9eba1L /* Rounds 20-39 */
126 #define CONST3 0x8f1bbcdcL /* Rounds 40-59 */
127 #define CONST4 0xca62c1d6L /* Rounds 60-79 */
131 #define R32(x,n) ((x << n) | (x >> (32 - n)))
133 /* the generic case, for when the overall rotation is not unraveled */
136 T = R32(A,5) + f##n(B,C,D) + E + *WP++ + CONST##n; \
137 E = D; D = C; C = R32(B,30); B = A; A = T
139 /* specific cases, for when the overall rotation is unraveled */
142 T = R32(A,5) + f##n(B,C,D) + E + *WP++ + CONST##n; B = R32(B,30)
145 E = R32(T,5) + f##n(A,B,C) + D + *WP++ + CONST##n; A = R32(A,30)
148 D = R32(E,5) + f##n(T,A,B) + C + *WP++ + CONST##n; T = R32(T,30)
151 C = R32(D,5) + f##n(E,T,A) + B + *WP++ + CONST##n; E = R32(E,30)
154 B = R32(C,5) + f##n(D,E,T) + A + *WP++ + CONST##n; D = R32(D,30)
157 A = R32(B,5) + f##n(C,D,E) + T + *WP++ + CONST##n; C = R32(C,30)
159 /* do SHA transformation */
162 sha_transform(SHAobject
*sha_info
)
165 SHA_INT32 T
, A
, B
, C
, D
, E
, W
[80], *WP
;
167 memcpy(W
, sha_info
->data
, sizeof(sha_info
->data
));
168 longReverse(W
, (int)sizeof(sha_info
->data
), sha_info
->Endianness
);
170 for (i
= 16; i
< 80; ++i
) {
171 W
[i
] = W
[i
-3] ^ W
[i
-8] ^ W
[i
-14] ^ W
[i
-16];
173 /* extra rotation fix */
176 A
= sha_info
->digest
[0];
177 B
= sha_info
->digest
[1];
178 C
= sha_info
->digest
[2];
179 D
= sha_info
->digest
[3];
180 E
= sha_info
->digest
[4];
183 FA(1); FB(1); FC(1); FD(1); FE(1); FT(1); FA(1); FB(1); FC(1); FD(1);
184 FE(1); FT(1); FA(1); FB(1); FC(1); FD(1); FE(1); FT(1); FA(1); FB(1);
185 FC(2); FD(2); FE(2); FT(2); FA(2); FB(2); FC(2); FD(2); FE(2); FT(2);
186 FA(2); FB(2); FC(2); FD(2); FE(2); FT(2); FA(2); FB(2); FC(2); FD(2);
187 FE(3); FT(3); FA(3); FB(3); FC(3); FD(3); FE(3); FT(3); FA(3); FB(3);
188 FC(3); FD(3); FE(3); FT(3); FA(3); FB(3); FC(3); FD(3); FE(3); FT(3);
189 FA(4); FB(4); FC(4); FD(4); FE(4); FT(4); FA(4); FB(4); FC(4); FD(4);
190 FE(4); FT(4); FA(4); FB(4); FC(4); FD(4); FE(4); FT(4); FA(4); FB(4);
191 sha_info
->digest
[0] += E
;
192 sha_info
->digest
[1] += T
;
193 sha_info
->digest
[2] += A
;
194 sha_info
->digest
[3] += B
;
195 sha_info
->digest
[4] += C
;
198 FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1);
199 FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1);
200 FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2);
201 FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2);
202 FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3);
203 FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3);
204 FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4);
205 FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4);
206 #else /* !UNROLL_LOOPS */
207 for (i
= 0; i
< 20; ++i
) { FG(1); }
208 for (i
= 20; i
< 40; ++i
) { FG(2); }
209 for (i
= 40; i
< 60; ++i
) { FG(3); }
210 for (i
= 60; i
< 80; ++i
) { FG(4); }
211 #endif /* !UNROLL_LOOPS */
212 sha_info
->digest
[0] += A
;
213 sha_info
->digest
[1] += B
;
214 sha_info
->digest
[2] += C
;
215 sha_info
->digest
[3] += D
;
216 sha_info
->digest
[4] += E
;
217 #endif /* !UNRAVEL */
220 /* initialize the SHA digest */
223 sha_init(SHAobject
*sha_info
)
225 TestEndianness(sha_info
->Endianness
)
227 sha_info
->digest
[0] = 0x67452301L
;
228 sha_info
->digest
[1] = 0xefcdab89L
;
229 sha_info
->digest
[2] = 0x98badcfeL
;
230 sha_info
->digest
[3] = 0x10325476L
;
231 sha_info
->digest
[4] = 0xc3d2e1f0L
;
232 sha_info
->count_lo
= 0L;
233 sha_info
->count_hi
= 0L;
237 /* update the SHA digest */
240 sha_update(SHAobject
*sha_info
, SHA_BYTE
*buffer
, unsigned int count
)
245 clo
= sha_info
->count_lo
+ ((SHA_INT32
) count
<< 3);
246 if (clo
< sha_info
->count_lo
) {
247 ++sha_info
->count_hi
;
249 sha_info
->count_lo
= clo
;
250 sha_info
->count_hi
+= (SHA_INT32
) count
>> 29;
251 if (sha_info
->local
) {
252 i
= SHA_BLOCKSIZE
- sha_info
->local
;
256 memcpy(((SHA_BYTE
*) sha_info
->data
) + sha_info
->local
, buffer
, i
);
259 sha_info
->local
+= i
;
260 if (sha_info
->local
== SHA_BLOCKSIZE
) {
261 sha_transform(sha_info
);
267 while (count
>= SHA_BLOCKSIZE
) {
268 memcpy(sha_info
->data
, buffer
, SHA_BLOCKSIZE
);
269 buffer
+= SHA_BLOCKSIZE
;
270 count
-= SHA_BLOCKSIZE
;
271 sha_transform(sha_info
);
273 memcpy(sha_info
->data
, buffer
, count
);
274 sha_info
->local
= count
;
277 /* finish computing the SHA digest */
280 sha_final(unsigned char digest
[20], SHAobject
*sha_info
)
283 SHA_INT32 lo_bit_count
, hi_bit_count
;
285 lo_bit_count
= sha_info
->count_lo
;
286 hi_bit_count
= sha_info
->count_hi
;
287 count
= (int) ((lo_bit_count
>> 3) & 0x3f);
288 ((SHA_BYTE
*) sha_info
->data
)[count
++] = 0x80;
289 if (count
> SHA_BLOCKSIZE
- 8) {
290 memset(((SHA_BYTE
*) sha_info
->data
) + count
, 0,
291 SHA_BLOCKSIZE
- count
);
292 sha_transform(sha_info
);
293 memset((SHA_BYTE
*) sha_info
->data
, 0, SHA_BLOCKSIZE
- 8);
296 memset(((SHA_BYTE
*) sha_info
->data
) + count
, 0,
297 SHA_BLOCKSIZE
- 8 - count
);
300 /* GJS: note that we add the hi/lo in big-endian. sha_transform will
301 swap these values into host-order. */
302 sha_info
->data
[56] = (hi_bit_count
>> 24) & 0xff;
303 sha_info
->data
[57] = (hi_bit_count
>> 16) & 0xff;
304 sha_info
->data
[58] = (hi_bit_count
>> 8) & 0xff;
305 sha_info
->data
[59] = (hi_bit_count
>> 0) & 0xff;
306 sha_info
->data
[60] = (lo_bit_count
>> 24) & 0xff;
307 sha_info
->data
[61] = (lo_bit_count
>> 16) & 0xff;
308 sha_info
->data
[62] = (lo_bit_count
>> 8) & 0xff;
309 sha_info
->data
[63] = (lo_bit_count
>> 0) & 0xff;
310 sha_transform(sha_info
);
311 digest
[ 0] = (unsigned char) ((sha_info
->digest
[0] >> 24) & 0xff);
312 digest
[ 1] = (unsigned char) ((sha_info
->digest
[0] >> 16) & 0xff);
313 digest
[ 2] = (unsigned char) ((sha_info
->digest
[0] >> 8) & 0xff);
314 digest
[ 3] = (unsigned char) ((sha_info
->digest
[0] ) & 0xff);
315 digest
[ 4] = (unsigned char) ((sha_info
->digest
[1] >> 24) & 0xff);
316 digest
[ 5] = (unsigned char) ((sha_info
->digest
[1] >> 16) & 0xff);
317 digest
[ 6] = (unsigned char) ((sha_info
->digest
[1] >> 8) & 0xff);
318 digest
[ 7] = (unsigned char) ((sha_info
->digest
[1] ) & 0xff);
319 digest
[ 8] = (unsigned char) ((sha_info
->digest
[2] >> 24) & 0xff);
320 digest
[ 9] = (unsigned char) ((sha_info
->digest
[2] >> 16) & 0xff);
321 digest
[10] = (unsigned char) ((sha_info
->digest
[2] >> 8) & 0xff);
322 digest
[11] = (unsigned char) ((sha_info
->digest
[2] ) & 0xff);
323 digest
[12] = (unsigned char) ((sha_info
->digest
[3] >> 24) & 0xff);
324 digest
[13] = (unsigned char) ((sha_info
->digest
[3] >> 16) & 0xff);
325 digest
[14] = (unsigned char) ((sha_info
->digest
[3] >> 8) & 0xff);
326 digest
[15] = (unsigned char) ((sha_info
->digest
[3] ) & 0xff);
327 digest
[16] = (unsigned char) ((sha_info
->digest
[4] >> 24) & 0xff);
328 digest
[17] = (unsigned char) ((sha_info
->digest
[4] >> 16) & 0xff);
329 digest
[18] = (unsigned char) ((sha_info
->digest
[4] >> 8) & 0xff);
330 digest
[19] = (unsigned char) ((sha_info
->digest
[4] ) & 0xff);
334 * End of copied SHA code.
336 * ------------------------------------------------------------------------
339 static PyTypeObject SHAtype
;
345 return (SHAobject
*)PyObject_New(SHAobject
, &SHAtype
);
348 /* Internal methods for a hashing object */
351 SHA_dealloc(PyObject
*ptr
)
357 /* External methods for a hashing object */
359 PyDoc_STRVAR(SHA_copy__doc__
, "Return a copy of the hashing object.");
362 SHA_copy(SHAobject
*self
, PyObject
*unused
)
366 if ( (newobj
= newSHAobject())==NULL
)
369 SHAcopy(self
, newobj
);
370 return (PyObject
*)newobj
;
373 PyDoc_STRVAR(SHA_digest__doc__
,
374 "Return the digest value as a string of binary data.");
377 SHA_digest(SHAobject
*self
, PyObject
*unused
)
379 unsigned char digest
[SHA_DIGESTSIZE
];
382 SHAcopy(self
, &temp
);
383 sha_final(digest
, &temp
);
384 return PyString_FromStringAndSize((const char *)digest
, sizeof(digest
));
387 PyDoc_STRVAR(SHA_hexdigest__doc__
,
388 "Return the digest value as a string of hexadecimal digits.");
391 SHA_hexdigest(SHAobject
*self
, PyObject
*unused
)
393 unsigned char digest
[SHA_DIGESTSIZE
];
399 /* Get the raw (binary) digest value */
400 SHAcopy(self
, &temp
);
401 sha_final(digest
, &temp
);
403 /* Create a new string */
404 retval
= PyString_FromStringAndSize(NULL
, sizeof(digest
) * 2);
407 hex_digest
= PyString_AsString(retval
);
413 /* Make hex version of the digest */
414 for(i
=j
=0; i
<sizeof(digest
); i
++) {
416 c
= (digest
[i
] >> 4) & 0xf;
417 c
= (c
>9) ? c
+'a'-10 : c
+ '0';
419 c
= (digest
[i
] & 0xf);
420 c
= (c
>9) ? c
+'a'-10 : c
+ '0';
426 PyDoc_STRVAR(SHA_update__doc__
,
427 "Update this hashing object's state with the provided string.");
430 SHA_update(SHAobject
*self
, PyObject
*args
)
435 if (!PyArg_ParseTuple(args
, "O:update", &data_obj
))
438 GET_BUFFER_VIEW_OR_ERROUT(data_obj
, &view
, NULL
);
440 sha_update(self
, (unsigned char*)view
.buf
,
441 Py_SAFE_DOWNCAST(view
.len
, Py_ssize_t
, unsigned int));
443 PyBuffer_Release(&view
);
448 static PyMethodDef SHA_methods
[] = {
449 {"copy", (PyCFunction
)SHA_copy
, METH_NOARGS
, SHA_copy__doc__
},
450 {"digest", (PyCFunction
)SHA_digest
, METH_NOARGS
, SHA_digest__doc__
},
451 {"hexdigest", (PyCFunction
)SHA_hexdigest
, METH_NOARGS
, SHA_hexdigest__doc__
},
452 {"update", (PyCFunction
)SHA_update
, METH_VARARGS
, SHA_update__doc__
},
453 {NULL
, NULL
} /* sentinel */
457 SHA_get_block_size(PyObject
*self
, void *closure
)
459 return PyInt_FromLong(SHA_BLOCKSIZE
);
463 SHA_get_digest_size(PyObject
*self
, void *closure
)
465 return PyInt_FromLong(SHA_DIGESTSIZE
);
469 SHA_get_name(PyObject
*self
, void *closure
)
471 return PyString_FromStringAndSize("SHA1", 4);
474 static PyGetSetDef SHA_getseters
[] = {
476 (getter
)SHA_get_digest_size
, NULL
,
480 (getter
)SHA_get_block_size
, NULL
,
484 (getter
)SHA_get_name
, NULL
,
487 /* the old md5 and sha modules support 'digest_size' as in PEP 247.
488 * the old sha module also supported 'digestsize'. ugh. */
490 (getter
)SHA_get_digest_size
, NULL
,
493 {NULL
} /* Sentinel */
496 static PyTypeObject SHAtype
= {
497 PyVarObject_HEAD_INIT(NULL
, 0)
498 "_sha.sha", /*tp_name*/
499 sizeof(SHAobject
), /*tp_size*/
502 SHA_dealloc
, /*tp_dealloc*/
509 0, /*tp_as_sequence*/
517 Py_TPFLAGS_DEFAULT
, /*tp_flags*/
521 0, /*tp_richcompare*/
522 0, /*tp_weaklistoffset*/
525 SHA_methods
, /* tp_methods */
527 SHA_getseters
, /* tp_getset */
531 /* The single module-level function: new() */
533 PyDoc_STRVAR(SHA_new__doc__
,
534 "Return a new SHA hashing object. An optional string argument\n\
535 may be provided; if present, this string will be automatically\n\
539 SHA_new(PyObject
*self
, PyObject
*args
, PyObject
*kwdict
)
541 static char *kwlist
[] = {"string", NULL
};
543 PyObject
*data_obj
= NULL
;
546 if (!PyArg_ParseTupleAndKeywords(args
, kwdict
, "|O:new", kwlist
,
552 GET_BUFFER_VIEW_OR_ERROUT(data_obj
, &view
, NULL
);
554 if ((new = newSHAobject()) == NULL
) {
556 PyBuffer_Release(&view
);
562 if (PyErr_Occurred()) {
565 PyBuffer_Release(&view
);
569 sha_update(new, (unsigned char*)view
.buf
,
570 Py_SAFE_DOWNCAST(view
.len
, Py_ssize_t
, unsigned int));
571 PyBuffer_Release(&view
);
574 return (PyObject
*)new;
578 /* List of functions exported by this module */
580 static struct PyMethodDef SHA_functions
[] = {
581 {"new", (PyCFunction
)SHA_new
, METH_VARARGS
|METH_KEYWORDS
, SHA_new__doc__
},
582 {NULL
, NULL
} /* Sentinel */
586 /* Initialize this module. */
588 #define insint(n,v) { PyModule_AddIntConstant(m,n,v); }
595 Py_TYPE(&SHAtype
) = &PyType_Type
;
596 if (PyType_Ready(&SHAtype
) < 0)
598 m
= Py_InitModule("_sha", SHA_functions
);
602 /* Add some symbolic constants to the module */
603 insint("blocksize", 1); /* For future use, in case some hash
604 functions require an integral number of
606 insint("digestsize", 20);
607 insint("digest_size", 20);