1 /* SHA256 module */
2 
3 /* This module provides an interface to NIST's SHA-256 and SHA-224 Algorithms */
4 
5 /* See below for information about the original code this module was
6    based upon. Additional work performed by:
7 
8    Andrew Kuchling (amk@amk.ca)
9    Greg Stein (gstein@lyra.org)
10    Trevor Perrin (trevp@trevp.net)
11 
12    Copyright (C) 2005-2007   Gregory P. Smith (greg@krypto.org)
13    Licensed to PSF under a Contributor Agreement.
14 
15 */
16 
17 /* SHA objects */
18 
19 #include "Python.h"
20 #include "structmember.h"
21 #include "hashlib.h"
22 #include "pystrhex.h"
23 
24 /*[clinic input]
25 module _sha256
26 class SHA256Type "SHAobject *" "&PyType_Type"
27 [clinic start generated code]*/
28 /*[clinic end generated code: output=da39a3ee5e6b4b0d input=71a39174d4f0a744]*/
29 
30 /* Some useful types */
31 
32 typedef unsigned char SHA_BYTE;
33 
34 #if SIZEOF_INT == 4
35 typedef unsigned int SHA_INT32; /* 32-bit integer */
36 #else
37 /* not defined. compilation will die. */
38 #endif
39 
40 /* The SHA block size and message digest sizes, in bytes */
41 
42 #define SHA_BLOCKSIZE    64
43 #define SHA_DIGESTSIZE  32
44 
45 /* The structure for storing SHA info */
46 
47 typedef struct {
48     PyObject_HEAD
49     SHA_INT32 digest[8];                /* Message digest */
50     SHA_INT32 count_lo, count_hi;       /* 64-bit bit count */
51     SHA_BYTE data[SHA_BLOCKSIZE];       /* SHA data buffer */
52     int local;                          /* unprocessed amount in data */
53     int digestsize;
54 } SHAobject;
55 
56 #include "clinic/sha256module.c.h"
57 
58 /* When run on a little-endian CPU we need to perform byte reversal on an
59    array of longwords. */
60 
61 #if PY_LITTLE_ENDIAN
62 static void longReverse(SHA_INT32 *buffer, int byteCount)
63 {
64     SHA_INT32 value;
65 
66     byteCount /= sizeof(*buffer);
67     while (byteCount--) {
68         value = *buffer;
69         value = ( ( value & 0xFF00FF00L ) >> 8  ) | \
70                 ( ( value & 0x00FF00FFL ) << 8 );
71         *buffer++ = ( value << 16 ) | ( value >> 16 );
72     }
73 }
74 #endif
75 
76 static void SHAcopy(SHAobject *src, SHAobject *dest)
77 {
78     dest->local = src->local;
79     dest->digestsize = src->digestsize;
80     dest->count_lo = src->count_lo;
81     dest->count_hi = src->count_hi;
82     memcpy(dest->digest, src->digest, sizeof(src->digest));
83     memcpy(dest->data, src->data, sizeof(src->data));
84 }
85 
86 
87 /* ------------------------------------------------------------------------
88  *
89  * This code for the SHA-256 algorithm was noted as public domain. The
90  * original headers are pasted below.
91  *
92  * Several changes have been made to make it more compatible with the
93  * Python environment and desired interface.
94  *
95  */
96 
97 /* LibTomCrypt, modular cryptographic library -- Tom St Denis
98  *
99  * LibTomCrypt is a library that provides various cryptographic
100  * algorithms in a highly modular and flexible manner.
101  *
102  * The library is free for all purposes without any express
103  * guarantee it works.
104  *
105  * Tom St Denis, tomstdenis@iahu.ca, http://libtom.org
106  */
107 
108 
109 /* SHA256 by Tom St Denis */
110 
111 /* Various logical functions */
112 #define ROR(x, y)\
113 ( ((((unsigned long)(x)&0xFFFFFFFFUL)>>(unsigned long)((y)&31)) | \
114 ((unsigned long)(x)<<(unsigned long)(32-((y)&31)))) & 0xFFFFFFFFUL)
115 #define Ch(x,y,z)       (z ^ (x & (y ^ z)))
116 #define Maj(x,y,z)      (((x | y) & z) | (x & y))
117 #define S(x, n)         ROR((x),(n))
118 #define R(x, n)         (((x)&0xFFFFFFFFUL)>>(n))
119 #define Sigma0(x)       (S(x, 2) ^ S(x, 13) ^ S(x, 22))
120 #define Sigma1(x)       (S(x, 6) ^ S(x, 11) ^ S(x, 25))
121 #define Gamma0(x)       (S(x, 7) ^ S(x, 18) ^ R(x, 3))
122 #define Gamma1(x)       (S(x, 17) ^ S(x, 19) ^ R(x, 10))
123 
124 
125 static void
126 sha_transform(SHAobject *sha_info)
127 {
128     int i;
129         SHA_INT32 S[8], W[64], t0, t1;
130 
131     memcpy(W, sha_info->data, sizeof(sha_info->data));
132 #if PY_LITTLE_ENDIAN
133     longReverse(W, (int)sizeof(sha_info->data));
134 #endif
135 
136     for (i = 16; i < 64; ++i) {
137                 W[i] = Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) + W[i - 16];
138     }
139     for (i = 0; i < 8; ++i) {
140         S[i] = sha_info->digest[i];
141     }
142 
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;
149 
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);
214 
215 #undef RND
216 
217     /* feedback */
218     for (i = 0; i < 8; i++) {
219         sha_info->digest[i] = sha_info->digest[i] + S[i];
220     }
221 
222 }
223 
224 
225 
226 /* initialize the SHA digest */
227 
228 static void
229 sha_init(SHAobject *sha_info)
230 {
231     sha_info->digest[0] = 0x6A09E667L;
232     sha_info->digest[1] = 0xBB67AE85L;
233     sha_info->digest[2] = 0x3C6EF372L;
234     sha_info->digest[3] = 0xA54FF53AL;
235     sha_info->digest[4] = 0x510E527FL;
236     sha_info->digest[5] = 0x9B05688CL;
237     sha_info->digest[6] = 0x1F83D9ABL;
238     sha_info->digest[7] = 0x5BE0CD19L;
239     sha_info->count_lo = 0L;
240     sha_info->count_hi = 0L;
241     sha_info->local = 0;
242     sha_info->digestsize = 32;
243 }
244 
245 static void
246 sha224_init(SHAobject *sha_info)
247 {
248     sha_info->digest[0] = 0xc1059ed8L;
249     sha_info->digest[1] = 0x367cd507L;
250     sha_info->digest[2] = 0x3070dd17L;
251     sha_info->digest[3] = 0xf70e5939L;
252     sha_info->digest[4] = 0xffc00b31L;
253     sha_info->digest[5] = 0x68581511L;
254     sha_info->digest[6] = 0x64f98fa7L;
255     sha_info->digest[7] = 0xbefa4fa4L;
256     sha_info->count_lo = 0L;
257     sha_info->count_hi = 0L;
258     sha_info->local = 0;
259     sha_info->digestsize = 28;
260 }
261 
262 
263 /* update the SHA digest */
264 
265 static void
266 sha_update(SHAobject *sha_info, SHA_BYTE *buffer, Py_ssize_t count)
267 {
268     Py_ssize_t i;
269     SHA_INT32 clo;
270 
271     clo = sha_info->count_lo + ((SHA_INT32) count << 3);
272     if (clo < sha_info->count_lo) {
273         ++sha_info->count_hi;
274     }
275     sha_info->count_lo = clo;
276     sha_info->count_hi += (SHA_INT32) count >> 29;
277     if (sha_info->local) {
278         i = SHA_BLOCKSIZE - sha_info->local;
279         if (i > count) {
280             i = count;
281         }
282         memcpy(((SHA_BYTE *) sha_info->data) + sha_info->local, buffer, i);
283         count -= i;
284         buffer += i;
285         sha_info->local += (int)i;
286         if (sha_info->local == SHA_BLOCKSIZE) {
287             sha_transform(sha_info);
288         }
289         else {
290             return;
291         }
292     }
293     while (count >= SHA_BLOCKSIZE) {
294         memcpy(sha_info->data, buffer, SHA_BLOCKSIZE);
295         buffer += SHA_BLOCKSIZE;
296         count -= SHA_BLOCKSIZE;
297         sha_transform(sha_info);
298     }
299     memcpy(sha_info->data, buffer, count);
300     sha_info->local = (int)count;
301 }
302 
303 /* finish computing the SHA digest */
304 
305 static void
306 sha_final(unsigned char digest[SHA_DIGESTSIZE], SHAobject *sha_info)
307 {
308     int count;
309     SHA_INT32 lo_bit_count, hi_bit_count;
310 
311     lo_bit_count = sha_info->count_lo;
312     hi_bit_count = sha_info->count_hi;
313     count = (int) ((lo_bit_count >> 3) & 0x3f);
314     ((SHA_BYTE *) sha_info->data)[count++] = 0x80;
315     if (count > SHA_BLOCKSIZE - 8) {
316         memset(((SHA_BYTE *) sha_info->data) + count, 0,
317                SHA_BLOCKSIZE - count);
318         sha_transform(sha_info);
319         memset((SHA_BYTE *) sha_info->data, 0, SHA_BLOCKSIZE - 8);
320     }
321     else {
322         memset(((SHA_BYTE *) sha_info->data) + count, 0,
323                SHA_BLOCKSIZE - 8 - count);
324     }
325 
326     /* GJS: note that we add the hi/lo in big-endian. sha_transform will
327        swap these values into host-order. */
328     sha_info->data[56] = (hi_bit_count >> 24) & 0xff;
329     sha_info->data[57] = (hi_bit_count >> 16) & 0xff;
330     sha_info->data[58] = (hi_bit_count >>  8) & 0xff;
331     sha_info->data[59] = (hi_bit_count >>  0) & 0xff;
332     sha_info->data[60] = (lo_bit_count >> 24) & 0xff;
333     sha_info->data[61] = (lo_bit_count >> 16) & 0xff;
334     sha_info->data[62] = (lo_bit_count >>  8) & 0xff;
335     sha_info->data[63] = (lo_bit_count >>  0) & 0xff;
336     sha_transform(sha_info);
337     digest[ 0] = (unsigned char) ((sha_info->digest[0] >> 24) & 0xff);
338     digest[ 1] = (unsigned char) ((sha_info->digest[0] >> 16) & 0xff);
339     digest[ 2] = (unsigned char) ((sha_info->digest[0] >>  8) & 0xff);
340     digest[ 3] = (unsigned char) ((sha_info->digest[0]      ) & 0xff);
341     digest[ 4] = (unsigned char) ((sha_info->digest[1] >> 24) & 0xff);
342     digest[ 5] = (unsigned char) ((sha_info->digest[1] >> 16) & 0xff);
343     digest[ 6] = (unsigned char) ((sha_info->digest[1] >>  8) & 0xff);
344     digest[ 7] = (unsigned char) ((sha_info->digest[1]      ) & 0xff);
345     digest[ 8] = (unsigned char) ((sha_info->digest[2] >> 24) & 0xff);
346     digest[ 9] = (unsigned char) ((sha_info->digest[2] >> 16) & 0xff);
347     digest[10] = (unsigned char) ((sha_info->digest[2] >>  8) & 0xff);
348     digest[11] = (unsigned char) ((sha_info->digest[2]      ) & 0xff);
349     digest[12] = (unsigned char) ((sha_info->digest[3] >> 24) & 0xff);
350     digest[13] = (unsigned char) ((sha_info->digest[3] >> 16) & 0xff);
351     digest[14] = (unsigned char) ((sha_info->digest[3] >>  8) & 0xff);
352     digest[15] = (unsigned char) ((sha_info->digest[3]      ) & 0xff);
353     digest[16] = (unsigned char) ((sha_info->digest[4] >> 24) & 0xff);
354     digest[17] = (unsigned char) ((sha_info->digest[4] >> 16) & 0xff);
355     digest[18] = (unsigned char) ((sha_info->digest[4] >>  8) & 0xff);
356     digest[19] = (unsigned char) ((sha_info->digest[4]      ) & 0xff);
357     digest[20] = (unsigned char) ((sha_info->digest[5] >> 24) & 0xff);
358     digest[21] = (unsigned char) ((sha_info->digest[5] >> 16) & 0xff);
359     digest[22] = (unsigned char) ((sha_info->digest[5] >>  8) & 0xff);
360     digest[23] = (unsigned char) ((sha_info->digest[5]      ) & 0xff);
361     digest[24] = (unsigned char) ((sha_info->digest[6] >> 24) & 0xff);
362     digest[25] = (unsigned char) ((sha_info->digest[6] >> 16) & 0xff);
363     digest[26] = (unsigned char) ((sha_info->digest[6] >>  8) & 0xff);
364     digest[27] = (unsigned char) ((sha_info->digest[6]      ) & 0xff);
365     digest[28] = (unsigned char) ((sha_info->digest[7] >> 24) & 0xff);
366     digest[29] = (unsigned char) ((sha_info->digest[7] >> 16) & 0xff);
367     digest[30] = (unsigned char) ((sha_info->digest[7] >>  8) & 0xff);
368     digest[31] = (unsigned char) ((sha_info->digest[7]      ) & 0xff);
369 }
370 
371 /*
372  * End of copied SHA code.
373  *
374  * ------------------------------------------------------------------------
375  */
376 
377 static PyTypeObject SHA224type;
378 static PyTypeObject SHA256type;
379 
380 
381 static SHAobject *
382 newSHA224object(void)
383 {
384     return (SHAobject *)PyObject_New(SHAobject, &SHA224type);
385 }
386 
387 static SHAobject *
388 newSHA256object(void)
389 {
390     return (SHAobject *)PyObject_New(SHAobject, &SHA256type);
391 }
392 
393 /* Internal methods for a hash object */
394 
395 static void
396 SHA_dealloc(PyObject *ptr)
397 {
398     PyObject_Del(ptr);
399 }
400 
401 
402 /* External methods for a hash object */
403 
404 /*[clinic input]
405 SHA256Type.copy
406 
407 Return a copy of the hash object.
408 [clinic start generated code]*/
409 
410 static PyObject *
411 SHA256Type_copy_impl(SHAobject *self)
412 /*[clinic end generated code: output=1a8bbd66a0c9c168 input=f58840a618d4f2a7]*/
413 {
414     SHAobject *newobj;
415 
416     if (Py_TYPE(self) == &SHA256type) {
417         if ( (newobj = newSHA256object())==NULL)
418             return NULL;
419     } else {
420         if ( (newobj = newSHA224object())==NULL)
421             return NULL;
422     }
423 
424     SHAcopy(self, newobj);
425     return (PyObject *)newobj;
426 }
427 
428 /*[clinic input]
429 SHA256Type.digest
430 
431 Return the digest value as a string of binary data.
432 [clinic start generated code]*/
433 
434 static PyObject *
435 SHA256Type_digest_impl(SHAobject *self)
436 /*[clinic end generated code: output=46616a5e909fbc3d input=1fb752e58954157d]*/
437 {
438     unsigned char digest[SHA_DIGESTSIZE];
439     SHAobject temp;
440 
441     SHAcopy(self, &temp);
442     sha_final(digest, &temp);
443     return PyBytes_FromStringAndSize((const char *)digest, self->digestsize);
444 }
445 
446 /*[clinic input]
447 SHA256Type.hexdigest
448 
449 Return the digest value as a string of hexadecimal digits.
450 [clinic start generated code]*/
451 
452 static PyObject *
453 SHA256Type_hexdigest_impl(SHAobject *self)
454 /*[clinic end generated code: output=725f8a7041ae97f3 input=0cc4c714693010d1]*/
455 {
456     unsigned char digest[SHA_DIGESTSIZE];
457     SHAobject temp;
458 
459     /* Get the raw (binary) digest value */
460     SHAcopy(self, &temp);
461     sha_final(digest, &temp);
462 
463     return _Py_strhex((const char *)digest, self->digestsize);
464 }
465 
466 /*[clinic input]
467 SHA256Type.update
468 
469     obj: object
470     /
471 
472 Update this hash object's state with the provided string.
473 [clinic start generated code]*/
474 
475 static PyObject *
476 SHA256Type_update(SHAobject *self, PyObject *obj)
477 /*[clinic end generated code: output=0967fb2860c66af7 input=b2d449d5b30f0f5a]*/
478 {
479     Py_buffer buf;
480 
481     GET_BUFFER_VIEW_OR_ERROUT(obj, &buf);
482 
483     sha_update(self, buf.buf, buf.len);
484 
485     PyBuffer_Release(&buf);
486     Py_INCREF(Py_None);
487     return Py_None;
488 }
489 
490 static PyMethodDef SHA_methods[] = {
491     SHA256TYPE_COPY_METHODDEF
492     SHA256TYPE_DIGEST_METHODDEF
493     SHA256TYPE_HEXDIGEST_METHODDEF
494     SHA256TYPE_UPDATE_METHODDEF
495     {NULL,        NULL}         /* sentinel */
496 };
497 
498 static PyObject *
499 SHA256_get_block_size(PyObject *self, void *closure)
500 {
501     return PyLong_FromLong(SHA_BLOCKSIZE);
502 }
503 
504 static PyObject *
505 SHA256_get_name(PyObject *self, void *closure)
506 {
507     if (((SHAobject *)self)->digestsize == 32)
508         return PyUnicode_FromStringAndSize("sha256", 6);
509     else
510         return PyUnicode_FromStringAndSize("sha224", 6);
511 }
512 
513 static PyGetSetDef SHA_getseters[] = {
514     {"block_size",
515      (getter)SHA256_get_block_size, NULL,
516      NULL,
517      NULL},
518     {"name",
519      (getter)SHA256_get_name, NULL,
520      NULL,
521      NULL},
522     {NULL}  /* Sentinel */
523 };
524 
525 static PyMemberDef SHA_members[] = {
526     {"digest_size", T_INT, offsetof(SHAobject, digestsize), READONLY, NULL},
527     {NULL}  /* Sentinel */
528 };
529 
530 static PyTypeObject SHA224type = {
531     PyVarObject_HEAD_INIT(NULL, 0)
532     "_sha256.sha224",   /*tp_name*/
533     sizeof(SHAobject),  /*tp_size*/
534     0,                  /*tp_itemsize*/
535     /* methods */
536     SHA_dealloc,        /*tp_dealloc*/
537     0,                  /*tp_print*/
538     0,                  /*tp_getattr*/
539     0,                  /*tp_setattr*/
540     0,                  /*tp_reserved*/
541     0,                  /*tp_repr*/
542     0,                  /*tp_as_number*/
543     0,                  /*tp_as_sequence*/
544     0,                  /*tp_as_mapping*/
545     0,                  /*tp_hash*/
546     0,                  /*tp_call*/
547     0,                  /*tp_str*/
548     0,                  /*tp_getattro*/
549     0,                  /*tp_setattro*/
550     0,                  /*tp_as_buffer*/
551     Py_TPFLAGS_DEFAULT, /*tp_flags*/
552     0,                  /*tp_doc*/
553     0,                  /*tp_traverse*/
554     0,                  /*tp_clear*/
555     0,                  /*tp_richcompare*/
556     0,                  /*tp_weaklistoffset*/
557     0,                  /*tp_iter*/
558     0,                  /*tp_iternext*/
559     SHA_methods,        /* tp_methods */
560     SHA_members,        /* tp_members */
561     SHA_getseters,      /* tp_getset */
562 };
563 
564 static PyTypeObject SHA256type = {
565     PyVarObject_HEAD_INIT(NULL, 0)
566     "_sha256.sha256",   /*tp_name*/
567     sizeof(SHAobject),  /*tp_size*/
568     0,                  /*tp_itemsize*/
569     /* methods */
570     SHA_dealloc,        /*tp_dealloc*/
571     0,                  /*tp_print*/
572     0,                  /*tp_getattr*/
573     0,                  /*tp_setattr*/
574     0,                  /*tp_reserved*/
575     0,                  /*tp_repr*/
576     0,                  /*tp_as_number*/
577     0,                  /*tp_as_sequence*/
578     0,                  /*tp_as_mapping*/
579     0,                  /*tp_hash*/
580     0,                  /*tp_call*/
581     0,                  /*tp_str*/
582     0,                  /*tp_getattro*/
583     0,                  /*tp_setattro*/
584     0,                  /*tp_as_buffer*/
585     Py_TPFLAGS_DEFAULT, /*tp_flags*/
586     0,                  /*tp_doc*/
587     0,                  /*tp_traverse*/
588     0,                  /*tp_clear*/
589     0,                  /*tp_richcompare*/
590     0,                  /*tp_weaklistoffset*/
591     0,                  /*tp_iter*/
592     0,                  /*tp_iternext*/
593     SHA_methods,        /* tp_methods */
594     SHA_members,        /* tp_members */
595     SHA_getseters,      /* tp_getset */
596 };
597 
598 
599 /* The single module-level function: new() */
600 
601 /*[clinic input]
602 _sha256.sha256
603 
604     string: object(c_default="NULL") = b''
605 
606 Return a new SHA-256 hash object; optionally initialized with a string.
607 [clinic start generated code]*/
608 
609 static PyObject *
610 _sha256_sha256_impl(PyObject *module, PyObject *string)
611 /*[clinic end generated code: output=fa644436dcea5c31 input=09cce3fb855056b2]*/
612 {
613     SHAobject *new;
614     Py_buffer buf;
615 
616     if (string)
617         GET_BUFFER_VIEW_OR_ERROUT(string, &buf);
618 
619     if ((new = newSHA256object()) == NULL) {
620         if (string)
621             PyBuffer_Release(&buf);
622         return NULL;
623     }
624 
625     sha_init(new);
626 
627     if (PyErr_Occurred()) {
628         Py_DECREF(new);
629         if (string)
630             PyBuffer_Release(&buf);
631         return NULL;
632     }
633     if (string) {
634         sha_update(new, buf.buf, buf.len);
635         PyBuffer_Release(&buf);
636     }
637 
638     return (PyObject *)new;
639 }
640 
641 /*[clinic input]
642 _sha256.sha224
643 
644     string: object(c_default="NULL") = b''
645 
646 Return a new SHA-224 hash object; optionally initialized with a string.
647 [clinic start generated code]*/
648 
649 static PyObject *
650 _sha256_sha224_impl(PyObject *module, PyObject *string)
651 /*[clinic end generated code: output=21e3ba22c3404f93 input=27a04ba24c353a73]*/
652 {
653     SHAobject *new;
654     Py_buffer buf;
655 
656     if (string)
657         GET_BUFFER_VIEW_OR_ERROUT(string, &buf);
658 
659     if ((new = newSHA224object()) == NULL) {
660         if (string)
661             PyBuffer_Release(&buf);
662         return NULL;
663     }
664 
665     sha224_init(new);
666 
667     if (PyErr_Occurred()) {
668         Py_DECREF(new);
669         if (string)
670             PyBuffer_Release(&buf);
671         return NULL;
672     }
673     if (string) {
674         sha_update(new, buf.buf, buf.len);
675         PyBuffer_Release(&buf);
676     }
677 
678     return (PyObject *)new;
679 }
680 
681 
682 /* List of functions exported by this module */
683 
684 static struct PyMethodDef SHA_functions[] = {
685     _SHA256_SHA256_METHODDEF
686     _SHA256_SHA224_METHODDEF
687     {NULL,      NULL}            /* Sentinel */
688 };
689 
690 
691 /* Initialize this module. */
692 
693 #define insint(n,v) { PyModule_AddIntConstant(m,n,v); }
694 
695 
696 static struct PyModuleDef _sha256module = {
697         PyModuleDef_HEAD_INIT,
698         "_sha256",
699         NULL,
700         -1,
701         SHA_functions,
702         NULL,
703         NULL,
704         NULL,
705         NULL
706 };
707 
708 PyMODINIT_FUNC
709 PyInit__sha256(void)
710 {
711     PyObject *m;
712 
713     Py_TYPE(&SHA224type) = &PyType_Type;
714     if (PyType_Ready(&SHA224type) < 0)
715         return NULL;
716     Py_TYPE(&SHA256type) = &PyType_Type;
717     if (PyType_Ready(&SHA256type) < 0)
718         return NULL;
719 
720     m = PyModule_Create(&_sha256module);
721     if (m == NULL)
722         return NULL;
723 
724     Py_INCREF((PyObject *)&SHA224type);
725     PyModule_AddObject(m, "SHA224Type", (PyObject *)&SHA224type);
726     Py_INCREF((PyObject *)&SHA256type);
727     PyModule_AddObject(m, "SHA256Type", (PyObject *)&SHA256type);
728     return m;
729 
730 }
731