Manual py3k backport: [svn r74158] Issue #6218: Make io.BytesIO and io.StringIO pickl...
[python.git] / Modules / sha256module.c
blobf489f48893b47c65ca9e2f41a0672fdf72a1f5c3
1 /* SHA256 module */
3 /* This module provides an interface to NIST's SHA-256 and SHA-224 Algorithms */
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)
10 Trevor Perrin (trevp@trevp.net)
12 Copyright (C) 2005 Gregory P. Smith (greg@krypto.org)
13 Licensed to PSF under a Contributor Agreement.
17 /* SHA objects */
19 #include "Python.h"
20 #include "structmember.h"
21 #include "hashlib.h"
24 /* Endianness testing and definitions */
25 #define TestEndianness(variable) {int i=1; variable=PCT_BIG_ENDIAN;\
26 if (*((char*)&i)==1) variable=PCT_LITTLE_ENDIAN;}
28 #define PCT_LITTLE_ENDIAN 1
29 #define PCT_BIG_ENDIAN 0
31 /* Some useful types */
33 typedef unsigned char SHA_BYTE;
35 #if SIZEOF_INT == 4
36 typedef unsigned int SHA_INT32; /* 32-bit integer */
37 #else
38 /* not defined. compilation will die. */
39 #endif
41 /* The SHA block size and message digest sizes, in bytes */
43 #define SHA_BLOCKSIZE 64
44 #define SHA_DIGESTSIZE 32
46 /* The structure for storing SHA info */
48 typedef struct {
49 PyObject_HEAD
50 SHA_INT32 digest[8]; /* Message digest */
51 SHA_INT32 count_lo, count_hi; /* 64-bit bit count */
52 SHA_BYTE data[SHA_BLOCKSIZE]; /* SHA data buffer */
53 int Endianness;
54 int local; /* unprocessed amount in data */
55 int digestsize;
56 } SHAobject;
58 /* When run on a little-endian CPU we need to perform byte reversal on an
59 array of longwords. */
61 static void longReverse(SHA_INT32 *buffer, int byteCount, int Endianness)
63 SHA_INT32 value;
65 if ( Endianness == PCT_BIG_ENDIAN )
66 return;
68 byteCount /= sizeof(*buffer);
69 while (byteCount--) {
70 value = *buffer;
71 value = ( ( value & 0xFF00FF00L ) >> 8 ) | \
72 ( ( value & 0x00FF00FFL ) << 8 );
73 *buffer++ = ( value << 16 ) | ( value >> 16 );
77 static void SHAcopy(SHAobject *src, SHAobject *dest)
79 dest->Endianness = src->Endianness;
80 dest->local = src->local;
81 dest->digestsize = src->digestsize;
82 dest->count_lo = src->count_lo;
83 dest->count_hi = src->count_hi;
84 memcpy(dest->digest, src->digest, sizeof(src->digest));
85 memcpy(dest->data, src->data, sizeof(src->data));
89 /* ------------------------------------------------------------------------
91 * This code for the SHA-256 algorithm was noted as public domain. The
92 * original headers are pasted below.
94 * Several changes have been made to make it more compatible with the
95 * Python environment and desired interface.
99 /* LibTomCrypt, modular cryptographic library -- Tom St Denis
101 * LibTomCrypt is a library that provides various cryptographic
102 * algorithms in a highly modular and flexible manner.
104 * The library is free for all purposes without any express
105 * gurantee it works.
107 * Tom St Denis, tomstdenis@iahu.ca, http://libtomcrypt.org
111 /* SHA256 by Tom St Denis */
113 /* Various logical functions */
114 #define ROR(x, y)\
115 ( ((((unsigned long)(x)&0xFFFFFFFFUL)>>(unsigned long)((y)&31)) | \
116 ((unsigned long)(x)<<(unsigned long)(32-((y)&31)))) & 0xFFFFFFFFUL)
117 #define Ch(x,y,z) (z ^ (x & (y ^ z)))
118 #define Maj(x,y,z) (((x | y) & z) | (x & y))
119 #define S(x, n) ROR((x),(n))
120 #define R(x, n) (((x)&0xFFFFFFFFUL)>>(n))
121 #define Sigma0(x) (S(x, 2) ^ S(x, 13) ^ S(x, 22))
122 #define Sigma1(x) (S(x, 6) ^ S(x, 11) ^ S(x, 25))
123 #define Gamma0(x) (S(x, 7) ^ S(x, 18) ^ R(x, 3))
124 #define Gamma1(x) (S(x, 17) ^ S(x, 19) ^ R(x, 10))
127 static void
128 sha_transform(SHAobject *sha_info)
130 int i;
131 SHA_INT32 S[8], W[64], t0, t1;
133 memcpy(W, sha_info->data, sizeof(sha_info->data));
134 longReverse(W, (int)sizeof(sha_info->data), sha_info->Endianness);
136 for (i = 16; i < 64; ++i) {
137 W[i] = Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) + W[i - 16];
139 for (i = 0; i < 8; ++i) {
140 S[i] = sha_info->digest[i];
143 /* Compress */
144 #define RND(a,b,c,d,e,f,g,h,i,ki) \
145 t0 = h + Sigma1(e) + Ch(e, f, g) + ki + W[i]; \
146 t1 = Sigma0(a) + Maj(a, b, c); \
147 d += t0; \
148 h = t0 + t1;
150 RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],0,0x428a2f98);
151 RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],1,0x71374491);
152 RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],2,0xb5c0fbcf);
153 RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],3,0xe9b5dba5);
154 RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],4,0x3956c25b);
155 RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],5,0x59f111f1);
156 RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],6,0x923f82a4);
157 RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],7,0xab1c5ed5);
158 RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],8,0xd807aa98);
159 RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],9,0x12835b01);
160 RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],10,0x243185be);
161 RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],11,0x550c7dc3);
162 RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],12,0x72be5d74);
163 RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],13,0x80deb1fe);
164 RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],14,0x9bdc06a7);
165 RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],15,0xc19bf174);
166 RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],16,0xe49b69c1);
167 RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],17,0xefbe4786);
168 RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],18,0x0fc19dc6);
169 RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],19,0x240ca1cc);
170 RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],20,0x2de92c6f);
171 RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],21,0x4a7484aa);
172 RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],22,0x5cb0a9dc);
173 RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],23,0x76f988da);
174 RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],24,0x983e5152);
175 RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],25,0xa831c66d);
176 RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],26,0xb00327c8);
177 RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],27,0xbf597fc7);
178 RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],28,0xc6e00bf3);
179 RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],29,0xd5a79147);
180 RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],30,0x06ca6351);
181 RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],31,0x14292967);
182 RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],32,0x27b70a85);
183 RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],33,0x2e1b2138);
184 RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],34,0x4d2c6dfc);
185 RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],35,0x53380d13);
186 RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],36,0x650a7354);
187 RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],37,0x766a0abb);
188 RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],38,0x81c2c92e);
189 RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],39,0x92722c85);
190 RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],40,0xa2bfe8a1);
191 RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],41,0xa81a664b);
192 RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],42,0xc24b8b70);
193 RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],43,0xc76c51a3);
194 RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],44,0xd192e819);
195 RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],45,0xd6990624);
196 RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],46,0xf40e3585);
197 RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],47,0x106aa070);
198 RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],48,0x19a4c116);
199 RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],49,0x1e376c08);
200 RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],50,0x2748774c);
201 RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],51,0x34b0bcb5);
202 RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],52,0x391c0cb3);
203 RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],53,0x4ed8aa4a);
204 RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],54,0x5b9cca4f);
205 RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],55,0x682e6ff3);
206 RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],56,0x748f82ee);
207 RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],57,0x78a5636f);
208 RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],58,0x84c87814);
209 RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],59,0x8cc70208);
210 RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],60,0x90befffa);
211 RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],61,0xa4506ceb);
212 RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],62,0xbef9a3f7);
213 RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],63,0xc67178f2);
215 #undef RND
217 /* feedback */
218 for (i = 0; i < 8; i++) {
219 sha_info->digest[i] = sha_info->digest[i] + S[i];
226 /* initialize the SHA digest */
228 static void
229 sha_init(SHAobject *sha_info)
231 TestEndianness(sha_info->Endianness)
232 sha_info->digest[0] = 0x6A09E667L;
233 sha_info->digest[1] = 0xBB67AE85L;
234 sha_info->digest[2] = 0x3C6EF372L;
235 sha_info->digest[3] = 0xA54FF53AL;
236 sha_info->digest[4] = 0x510E527FL;
237 sha_info->digest[5] = 0x9B05688CL;
238 sha_info->digest[6] = 0x1F83D9ABL;
239 sha_info->digest[7] = 0x5BE0CD19L;
240 sha_info->count_lo = 0L;
241 sha_info->count_hi = 0L;
242 sha_info->local = 0;
243 sha_info->digestsize = 32;
246 static void
247 sha224_init(SHAobject *sha_info)
249 TestEndianness(sha_info->Endianness)
250 sha_info->digest[0] = 0xc1059ed8L;
251 sha_info->digest[1] = 0x367cd507L;
252 sha_info->digest[2] = 0x3070dd17L;
253 sha_info->digest[3] = 0xf70e5939L;
254 sha_info->digest[4] = 0xffc00b31L;
255 sha_info->digest[5] = 0x68581511L;
256 sha_info->digest[6] = 0x64f98fa7L;
257 sha_info->digest[7] = 0xbefa4fa4L;
258 sha_info->count_lo = 0L;
259 sha_info->count_hi = 0L;
260 sha_info->local = 0;
261 sha_info->digestsize = 28;
265 /* update the SHA digest */
267 static void
268 sha_update(SHAobject *sha_info, SHA_BYTE *buffer, int count)
270 int i;
271 SHA_INT32 clo;
273 clo = sha_info->count_lo + ((SHA_INT32) count << 3);
274 if (clo < sha_info->count_lo) {
275 ++sha_info->count_hi;
277 sha_info->count_lo = clo;
278 sha_info->count_hi += (SHA_INT32) count >> 29;
279 if (sha_info->local) {
280 i = SHA_BLOCKSIZE - sha_info->local;
281 if (i > count) {
282 i = count;
284 memcpy(((SHA_BYTE *) sha_info->data) + sha_info->local, buffer, i);
285 count -= i;
286 buffer += i;
287 sha_info->local += i;
288 if (sha_info->local == SHA_BLOCKSIZE) {
289 sha_transform(sha_info);
291 else {
292 return;
295 while (count >= SHA_BLOCKSIZE) {
296 memcpy(sha_info->data, buffer, SHA_BLOCKSIZE);
297 buffer += SHA_BLOCKSIZE;
298 count -= SHA_BLOCKSIZE;
299 sha_transform(sha_info);
301 memcpy(sha_info->data, buffer, count);
302 sha_info->local = count;
305 /* finish computing the SHA digest */
307 static void
308 sha_final(unsigned char digest[SHA_DIGESTSIZE], SHAobject *sha_info)
310 int count;
311 SHA_INT32 lo_bit_count, hi_bit_count;
313 lo_bit_count = sha_info->count_lo;
314 hi_bit_count = sha_info->count_hi;
315 count = (int) ((lo_bit_count >> 3) & 0x3f);
316 ((SHA_BYTE *) sha_info->data)[count++] = 0x80;
317 if (count > SHA_BLOCKSIZE - 8) {
318 memset(((SHA_BYTE *) sha_info->data) + count, 0,
319 SHA_BLOCKSIZE - count);
320 sha_transform(sha_info);
321 memset((SHA_BYTE *) sha_info->data, 0, SHA_BLOCKSIZE - 8);
323 else {
324 memset(((SHA_BYTE *) sha_info->data) + count, 0,
325 SHA_BLOCKSIZE - 8 - count);
328 /* GJS: note that we add the hi/lo in big-endian. sha_transform will
329 swap these values into host-order. */
330 sha_info->data[56] = (hi_bit_count >> 24) & 0xff;
331 sha_info->data[57] = (hi_bit_count >> 16) & 0xff;
332 sha_info->data[58] = (hi_bit_count >> 8) & 0xff;
333 sha_info->data[59] = (hi_bit_count >> 0) & 0xff;
334 sha_info->data[60] = (lo_bit_count >> 24) & 0xff;
335 sha_info->data[61] = (lo_bit_count >> 16) & 0xff;
336 sha_info->data[62] = (lo_bit_count >> 8) & 0xff;
337 sha_info->data[63] = (lo_bit_count >> 0) & 0xff;
338 sha_transform(sha_info);
339 digest[ 0] = (unsigned char) ((sha_info->digest[0] >> 24) & 0xff);
340 digest[ 1] = (unsigned char) ((sha_info->digest[0] >> 16) & 0xff);
341 digest[ 2] = (unsigned char) ((sha_info->digest[0] >> 8) & 0xff);
342 digest[ 3] = (unsigned char) ((sha_info->digest[0] ) & 0xff);
343 digest[ 4] = (unsigned char) ((sha_info->digest[1] >> 24) & 0xff);
344 digest[ 5] = (unsigned char) ((sha_info->digest[1] >> 16) & 0xff);
345 digest[ 6] = (unsigned char) ((sha_info->digest[1] >> 8) & 0xff);
346 digest[ 7] = (unsigned char) ((sha_info->digest[1] ) & 0xff);
347 digest[ 8] = (unsigned char) ((sha_info->digest[2] >> 24) & 0xff);
348 digest[ 9] = (unsigned char) ((sha_info->digest[2] >> 16) & 0xff);
349 digest[10] = (unsigned char) ((sha_info->digest[2] >> 8) & 0xff);
350 digest[11] = (unsigned char) ((sha_info->digest[2] ) & 0xff);
351 digest[12] = (unsigned char) ((sha_info->digest[3] >> 24) & 0xff);
352 digest[13] = (unsigned char) ((sha_info->digest[3] >> 16) & 0xff);
353 digest[14] = (unsigned char) ((sha_info->digest[3] >> 8) & 0xff);
354 digest[15] = (unsigned char) ((sha_info->digest[3] ) & 0xff);
355 digest[16] = (unsigned char) ((sha_info->digest[4] >> 24) & 0xff);
356 digest[17] = (unsigned char) ((sha_info->digest[4] >> 16) & 0xff);
357 digest[18] = (unsigned char) ((sha_info->digest[4] >> 8) & 0xff);
358 digest[19] = (unsigned char) ((sha_info->digest[4] ) & 0xff);
359 digest[20] = (unsigned char) ((sha_info->digest[5] >> 24) & 0xff);
360 digest[21] = (unsigned char) ((sha_info->digest[5] >> 16) & 0xff);
361 digest[22] = (unsigned char) ((sha_info->digest[5] >> 8) & 0xff);
362 digest[23] = (unsigned char) ((sha_info->digest[5] ) & 0xff);
363 digest[24] = (unsigned char) ((sha_info->digest[6] >> 24) & 0xff);
364 digest[25] = (unsigned char) ((sha_info->digest[6] >> 16) & 0xff);
365 digest[26] = (unsigned char) ((sha_info->digest[6] >> 8) & 0xff);
366 digest[27] = (unsigned char) ((sha_info->digest[6] ) & 0xff);
367 digest[28] = (unsigned char) ((sha_info->digest[7] >> 24) & 0xff);
368 digest[29] = (unsigned char) ((sha_info->digest[7] >> 16) & 0xff);
369 digest[30] = (unsigned char) ((sha_info->digest[7] >> 8) & 0xff);
370 digest[31] = (unsigned char) ((sha_info->digest[7] ) & 0xff);
374 * End of copied SHA code.
376 * ------------------------------------------------------------------------
379 static PyTypeObject SHA224type;
380 static PyTypeObject SHA256type;
383 static SHAobject *
384 newSHA224object(void)
386 return (SHAobject *)PyObject_New(SHAobject, &SHA224type);
389 static SHAobject *
390 newSHA256object(void)
392 return (SHAobject *)PyObject_New(SHAobject, &SHA256type);
395 /* Internal methods for a hash object */
397 static void
398 SHA_dealloc(PyObject *ptr)
400 PyObject_Del(ptr);
404 /* External methods for a hash object */
406 PyDoc_STRVAR(SHA256_copy__doc__, "Return a copy of the hash object.");
408 static PyObject *
409 SHA256_copy(SHAobject *self, PyObject *unused)
411 SHAobject *newobj;
413 if (Py_TYPE(self) == &SHA256type) {
414 if ( (newobj = newSHA256object())==NULL)
415 return NULL;
416 } else {
417 if ( (newobj = newSHA224object())==NULL)
418 return NULL;
421 SHAcopy(self, newobj);
422 return (PyObject *)newobj;
425 PyDoc_STRVAR(SHA256_digest__doc__,
426 "Return the digest value as a string of binary data.");
428 static PyObject *
429 SHA256_digest(SHAobject *self, PyObject *unused)
431 unsigned char digest[SHA_DIGESTSIZE];
432 SHAobject temp;
434 SHAcopy(self, &temp);
435 sha_final(digest, &temp);
436 return PyString_FromStringAndSize((const char *)digest, self->digestsize);
439 PyDoc_STRVAR(SHA256_hexdigest__doc__,
440 "Return the digest value as a string of hexadecimal digits.");
442 static PyObject *
443 SHA256_hexdigest(SHAobject *self, PyObject *unused)
445 unsigned char digest[SHA_DIGESTSIZE];
446 SHAobject temp;
447 PyObject *retval;
448 char *hex_digest;
449 int i, j;
451 /* Get the raw (binary) digest value */
452 SHAcopy(self, &temp);
453 sha_final(digest, &temp);
455 /* Create a new string */
456 retval = PyString_FromStringAndSize(NULL, self->digestsize * 2);
457 if (!retval)
458 return NULL;
459 hex_digest = PyString_AsString(retval);
460 if (!hex_digest) {
461 Py_DECREF(retval);
462 return NULL;
465 /* Make hex version of the digest */
466 for(i=j=0; i<self->digestsize; i++) {
467 char c;
468 c = (digest[i] >> 4) & 0xf;
469 c = (c>9) ? c+'a'-10 : c + '0';
470 hex_digest[j++] = c;
471 c = (digest[i] & 0xf);
472 c = (c>9) ? c+'a'-10 : c + '0';
473 hex_digest[j++] = c;
475 return retval;
478 PyDoc_STRVAR(SHA256_update__doc__,
479 "Update this hash object's state with the provided string.");
481 static PyObject *
482 SHA256_update(SHAobject *self, PyObject *args)
484 PyObject *obj;
485 Py_buffer buf;
487 if (!PyArg_ParseTuple(args, "O:update", &obj))
488 return NULL;
490 GET_BUFFER_VIEW_OR_ERROUT(obj, &buf, NULL);
492 sha_update(self, buf.buf, buf.len);
494 PyBuffer_Release(&buf);
495 Py_INCREF(Py_None);
496 return Py_None;
499 static PyMethodDef SHA_methods[] = {
500 {"copy", (PyCFunction)SHA256_copy, METH_NOARGS, SHA256_copy__doc__},
501 {"digest", (PyCFunction)SHA256_digest, METH_NOARGS, SHA256_digest__doc__},
502 {"hexdigest", (PyCFunction)SHA256_hexdigest, METH_NOARGS, SHA256_hexdigest__doc__},
503 {"update", (PyCFunction)SHA256_update, METH_VARARGS, SHA256_update__doc__},
504 {NULL, NULL} /* sentinel */
507 static PyObject *
508 SHA256_get_block_size(PyObject *self, void *closure)
510 return PyInt_FromLong(SHA_BLOCKSIZE);
513 static PyObject *
514 SHA256_get_name(PyObject *self, void *closure)
516 if (((SHAobject *)self)->digestsize == 32)
517 return PyString_FromStringAndSize("SHA256", 6);
518 else
519 return PyString_FromStringAndSize("SHA224", 6);
522 static PyGetSetDef SHA_getseters[] = {
523 {"block_size",
524 (getter)SHA256_get_block_size, NULL,
525 NULL,
526 NULL},
527 {"name",
528 (getter)SHA256_get_name, NULL,
529 NULL,
530 NULL},
531 {NULL} /* Sentinel */
534 static PyMemberDef SHA_members[] = {
535 {"digest_size", T_INT, offsetof(SHAobject, digestsize), READONLY, NULL},
536 /* the old md5 and sha modules support 'digest_size' as in PEP 247.
537 * the old sha module also supported 'digestsize'. ugh. */
538 {"digestsize", T_INT, offsetof(SHAobject, digestsize), READONLY, NULL},
539 {NULL} /* Sentinel */
542 static PyTypeObject SHA224type = {
543 PyVarObject_HEAD_INIT(NULL, 0)
544 "_sha256.sha224", /*tp_name*/
545 sizeof(SHAobject), /*tp_size*/
546 0, /*tp_itemsize*/
547 /* methods */
548 SHA_dealloc, /*tp_dealloc*/
549 0, /*tp_print*/
550 0, /*tp_getattr*/
551 0, /*tp_setattr*/
552 0, /*tp_compare*/
553 0, /*tp_repr*/
554 0, /*tp_as_number*/
555 0, /*tp_as_sequence*/
556 0, /*tp_as_mapping*/
557 0, /*tp_hash*/
558 0, /*tp_call*/
559 0, /*tp_str*/
560 0, /*tp_getattro*/
561 0, /*tp_setattro*/
562 0, /*tp_as_buffer*/
563 Py_TPFLAGS_DEFAULT, /*tp_flags*/
564 0, /*tp_doc*/
565 0, /*tp_traverse*/
566 0, /*tp_clear*/
567 0, /*tp_richcompare*/
568 0, /*tp_weaklistoffset*/
569 0, /*tp_iter*/
570 0, /*tp_iternext*/
571 SHA_methods, /* tp_methods */
572 SHA_members, /* tp_members */
573 SHA_getseters, /* tp_getset */
576 static PyTypeObject SHA256type = {
577 PyVarObject_HEAD_INIT(NULL, 0)
578 "_sha256.sha256", /*tp_name*/
579 sizeof(SHAobject), /*tp_size*/
580 0, /*tp_itemsize*/
581 /* methods */
582 SHA_dealloc, /*tp_dealloc*/
583 0, /*tp_print*/
584 0, /*tp_getattr*/
585 0, /*tp_setattr*/
586 0, /*tp_compare*/
587 0, /*tp_repr*/
588 0, /*tp_as_number*/
589 0, /*tp_as_sequence*/
590 0, /*tp_as_mapping*/
591 0, /*tp_hash*/
592 0, /*tp_call*/
593 0, /*tp_str*/
594 0, /*tp_getattro*/
595 0, /*tp_setattro*/
596 0, /*tp_as_buffer*/
597 Py_TPFLAGS_DEFAULT, /*tp_flags*/
598 0, /*tp_doc*/
599 0, /*tp_traverse*/
600 0, /*tp_clear*/
601 0, /*tp_richcompare*/
602 0, /*tp_weaklistoffset*/
603 0, /*tp_iter*/
604 0, /*tp_iternext*/
605 SHA_methods, /* tp_methods */
606 SHA_members, /* tp_members */
607 SHA_getseters, /* tp_getset */
611 /* The single module-level function: new() */
613 PyDoc_STRVAR(SHA256_new__doc__,
614 "Return a new SHA-256 hash object; optionally initialized with a string.");
616 static PyObject *
617 SHA256_new(PyObject *self, PyObject *args, PyObject *kwdict)
619 static char *kwlist[] = {"string", NULL};
620 SHAobject *new;
621 PyObject *data_obj = NULL;
622 Py_buffer buf;
624 if (!PyArg_ParseTupleAndKeywords(args, kwdict, "|O:new", kwlist,
625 &data_obj)) {
626 return NULL;
629 if (data_obj)
630 GET_BUFFER_VIEW_OR_ERROUT(data_obj, &buf, NULL);
632 if ((new = newSHA256object()) == NULL) {
633 if (data_obj)
634 PyBuffer_Release(&buf);
635 return NULL;
638 sha_init(new);
640 if (PyErr_Occurred()) {
641 Py_DECREF(new);
642 if (data_obj)
643 PyBuffer_Release(&buf);
644 return NULL;
646 if (data_obj) {
647 sha_update(new, buf.buf, buf.len);
648 PyBuffer_Release(&buf);
651 return (PyObject *)new;
654 PyDoc_STRVAR(SHA224_new__doc__,
655 "Return a new SHA-224 hash object; optionally initialized with a string.");
657 static PyObject *
658 SHA224_new(PyObject *self, PyObject *args, PyObject *kwdict)
660 static char *kwlist[] = {"string", NULL};
661 SHAobject *new;
662 PyObject *data_obj = NULL;
663 Py_buffer buf;
665 if (!PyArg_ParseTupleAndKeywords(args, kwdict, "|O:new", kwlist,
666 &data_obj)) {
667 return NULL;
670 if (data_obj)
671 GET_BUFFER_VIEW_OR_ERROUT(data_obj, &buf, NULL);
673 if ((new = newSHA224object()) == NULL) {
674 if (data_obj)
675 PyBuffer_Release(&buf);
676 return NULL;
679 sha224_init(new);
681 if (PyErr_Occurred()) {
682 Py_DECREF(new);
683 if (data_obj)
684 PyBuffer_Release(&buf);
685 return NULL;
687 if (data_obj) {
688 sha_update(new, buf.buf, buf.len);
689 PyBuffer_Release(&buf);
692 return (PyObject *)new;
696 /* List of functions exported by this module */
698 static struct PyMethodDef SHA_functions[] = {
699 {"sha256", (PyCFunction)SHA256_new, METH_VARARGS|METH_KEYWORDS, SHA256_new__doc__},
700 {"sha224", (PyCFunction)SHA224_new, METH_VARARGS|METH_KEYWORDS, SHA224_new__doc__},
701 {NULL, NULL} /* Sentinel */
705 /* Initialize this module. */
707 #define insint(n,v) { PyModule_AddIntConstant(m,n,v); }
709 PyMODINIT_FUNC
710 init_sha256(void)
712 PyObject *m;
714 Py_TYPE(&SHA224type) = &PyType_Type;
715 if (PyType_Ready(&SHA224type) < 0)
716 return;
717 Py_TYPE(&SHA256type) = &PyType_Type;
718 if (PyType_Ready(&SHA256type) < 0)
719 return;
720 m = Py_InitModule("_sha256", SHA_functions);
721 if (m == NULL)
722 return;