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
longReverse(SHA_INT32 * buffer,int byteCount)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
SHAcopy(SHAobject * src,SHAobject * dest)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, https://www.libtom.net
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
sha_transform(SHAobject * sha_info)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
sha_init(SHAobject * sha_info)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
sha224_init(SHAobject * sha_info)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
sha_update(SHAobject * sha_info,SHA_BYTE * buffer,Py_ssize_t count)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
sha_final(unsigned char digest[SHA_DIGESTSIZE],SHAobject * sha_info)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 *
newSHA224object(void)382 newSHA224object(void)
383 {
384 return (SHAobject *)PyObject_New(SHAobject, &SHA224type);
385 }
386
387 static SHAobject *
newSHA256object(void)388 newSHA256object(void)
389 {
390 return (SHAobject *)PyObject_New(SHAobject, &SHA256type);
391 }
392
393 /* Internal methods for a hash object */
394
395 static void
SHA_dealloc(PyObject * ptr)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 *
SHA256Type_copy_impl(SHAobject * self)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 bytes object.
432 [clinic start generated code]*/
433
434 static PyObject *
SHA256Type_digest_impl(SHAobject * self)435 SHA256Type_digest_impl(SHAobject *self)
436 /*[clinic end generated code: output=46616a5e909fbc3d input=f1f4cfea5cbde35c]*/
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 *
SHA256Type_hexdigest_impl(SHAobject * self)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 *
SHA256Type_update(SHAobject * self,PyObject * obj)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_RETURN_NONE;
487 }
488
489 static PyMethodDef SHA_methods[] = {
490 SHA256TYPE_COPY_METHODDEF
491 SHA256TYPE_DIGEST_METHODDEF
492 SHA256TYPE_HEXDIGEST_METHODDEF
493 SHA256TYPE_UPDATE_METHODDEF
494 {NULL, NULL} /* sentinel */
495 };
496
497 static PyObject *
SHA256_get_block_size(PyObject * self,void * closure)498 SHA256_get_block_size(PyObject *self, void *closure)
499 {
500 return PyLong_FromLong(SHA_BLOCKSIZE);
501 }
502
503 static PyObject *
SHA256_get_name(PyObject * self,void * closure)504 SHA256_get_name(PyObject *self, void *closure)
505 {
506 if (((SHAobject *)self)->digestsize == 32)
507 return PyUnicode_FromStringAndSize("sha256", 6);
508 else
509 return PyUnicode_FromStringAndSize("sha224", 6);
510 }
511
512 static PyGetSetDef SHA_getseters[] = {
513 {"block_size",
514 (getter)SHA256_get_block_size, NULL,
515 NULL,
516 NULL},
517 {"name",
518 (getter)SHA256_get_name, NULL,
519 NULL,
520 NULL},
521 {NULL} /* Sentinel */
522 };
523
524 static PyMemberDef SHA_members[] = {
525 {"digest_size", T_INT, offsetof(SHAobject, digestsize), READONLY, NULL},
526 {NULL} /* Sentinel */
527 };
528
529 static PyTypeObject SHA224type = {
530 PyVarObject_HEAD_INIT(NULL, 0)
531 "_sha256.sha224", /*tp_name*/
532 sizeof(SHAobject), /*tp_basicsize*/
533 0, /*tp_itemsize*/
534 /* methods */
535 SHA_dealloc, /*tp_dealloc*/
536 0, /*tp_vectorcall_offset*/
537 0, /*tp_getattr*/
538 0, /*tp_setattr*/
539 0, /*tp_as_async*/
540 0, /*tp_repr*/
541 0, /*tp_as_number*/
542 0, /*tp_as_sequence*/
543 0, /*tp_as_mapping*/
544 0, /*tp_hash*/
545 0, /*tp_call*/
546 0, /*tp_str*/
547 0, /*tp_getattro*/
548 0, /*tp_setattro*/
549 0, /*tp_as_buffer*/
550 Py_TPFLAGS_DEFAULT, /*tp_flags*/
551 0, /*tp_doc*/
552 0, /*tp_traverse*/
553 0, /*tp_clear*/
554 0, /*tp_richcompare*/
555 0, /*tp_weaklistoffset*/
556 0, /*tp_iter*/
557 0, /*tp_iternext*/
558 SHA_methods, /* tp_methods */
559 SHA_members, /* tp_members */
560 SHA_getseters, /* tp_getset */
561 };
562
563 static PyTypeObject SHA256type = {
564 PyVarObject_HEAD_INIT(NULL, 0)
565 "_sha256.sha256", /*tp_name*/
566 sizeof(SHAobject), /*tp_basicsize*/
567 0, /*tp_itemsize*/
568 /* methods */
569 SHA_dealloc, /*tp_dealloc*/
570 0, /*tp_vectorcall_offset*/
571 0, /*tp_getattr*/
572 0, /*tp_setattr*/
573 0, /*tp_as_async*/
574 0, /*tp_repr*/
575 0, /*tp_as_number*/
576 0, /*tp_as_sequence*/
577 0, /*tp_as_mapping*/
578 0, /*tp_hash*/
579 0, /*tp_call*/
580 0, /*tp_str*/
581 0, /*tp_getattro*/
582 0, /*tp_setattro*/
583 0, /*tp_as_buffer*/
584 Py_TPFLAGS_DEFAULT, /*tp_flags*/
585 0, /*tp_doc*/
586 0, /*tp_traverse*/
587 0, /*tp_clear*/
588 0, /*tp_richcompare*/
589 0, /*tp_weaklistoffset*/
590 0, /*tp_iter*/
591 0, /*tp_iternext*/
592 SHA_methods, /* tp_methods */
593 SHA_members, /* tp_members */
594 SHA_getseters, /* tp_getset */
595 };
596
597
598 /* The single module-level function: new() */
599
600 /*[clinic input]
601 _sha256.sha256
602
603 string: object(c_default="NULL") = b''
604
605 Return a new SHA-256 hash object; optionally initialized with a string.
606 [clinic start generated code]*/
607
608 static PyObject *
_sha256_sha256_impl(PyObject * module,PyObject * string)609 _sha256_sha256_impl(PyObject *module, PyObject *string)
610 /*[clinic end generated code: output=fa644436dcea5c31 input=09cce3fb855056b2]*/
611 {
612 SHAobject *new;
613 Py_buffer buf;
614
615 if (string)
616 GET_BUFFER_VIEW_OR_ERROUT(string, &buf);
617
618 if ((new = newSHA256object()) == NULL) {
619 if (string)
620 PyBuffer_Release(&buf);
621 return NULL;
622 }
623
624 sha_init(new);
625
626 if (PyErr_Occurred()) {
627 Py_DECREF(new);
628 if (string)
629 PyBuffer_Release(&buf);
630 return NULL;
631 }
632 if (string) {
633 sha_update(new, buf.buf, buf.len);
634 PyBuffer_Release(&buf);
635 }
636
637 return (PyObject *)new;
638 }
639
640 /*[clinic input]
641 _sha256.sha224
642
643 string: object(c_default="NULL") = b''
644
645 Return a new SHA-224 hash object; optionally initialized with a string.
646 [clinic start generated code]*/
647
648 static PyObject *
_sha256_sha224_impl(PyObject * module,PyObject * string)649 _sha256_sha224_impl(PyObject *module, PyObject *string)
650 /*[clinic end generated code: output=21e3ba22c3404f93 input=27a04ba24c353a73]*/
651 {
652 SHAobject *new;
653 Py_buffer buf;
654
655 if (string)
656 GET_BUFFER_VIEW_OR_ERROUT(string, &buf);
657
658 if ((new = newSHA224object()) == NULL) {
659 if (string)
660 PyBuffer_Release(&buf);
661 return NULL;
662 }
663
664 sha224_init(new);
665
666 if (PyErr_Occurred()) {
667 Py_DECREF(new);
668 if (string)
669 PyBuffer_Release(&buf);
670 return NULL;
671 }
672 if (string) {
673 sha_update(new, buf.buf, buf.len);
674 PyBuffer_Release(&buf);
675 }
676
677 return (PyObject *)new;
678 }
679
680
681 /* List of functions exported by this module */
682
683 static struct PyMethodDef SHA_functions[] = {
684 _SHA256_SHA256_METHODDEF
685 _SHA256_SHA224_METHODDEF
686 {NULL, NULL} /* Sentinel */
687 };
688
689
690 /* Initialize this module. */
691
692 #define insint(n,v) { PyModule_AddIntConstant(m,n,v); }
693
694
695 static struct PyModuleDef _sha256module = {
696 PyModuleDef_HEAD_INIT,
697 "_sha256",
698 NULL,
699 -1,
700 SHA_functions,
701 NULL,
702 NULL,
703 NULL,
704 NULL
705 };
706
707 PyMODINIT_FUNC
PyInit__sha256(void)708 PyInit__sha256(void)
709 {
710 PyObject *m;
711
712 Py_TYPE(&SHA224type) = &PyType_Type;
713 if (PyType_Ready(&SHA224type) < 0)
714 return NULL;
715 Py_TYPE(&SHA256type) = &PyType_Type;
716 if (PyType_Ready(&SHA256type) < 0)
717 return NULL;
718
719 m = PyModule_Create(&_sha256module);
720 if (m == NULL)
721 return NULL;
722
723 Py_INCREF((PyObject *)&SHA224type);
724 PyModule_AddObject(m, "SHA224Type", (PyObject *)&SHA224type);
725 Py_INCREF((PyObject *)&SHA256type);
726 PyModule_AddObject(m, "SHA256Type", (PyObject *)&SHA256type);
727 return m;
728
729 }
730