Modules/sha256module.c

   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
  23
  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;}
  27
  28 #define PCT_LITTLE_ENDIAN 1
  29 #define PCT_BIG_ENDIAN 0
  30
  31 /* Some useful types */
  32
  33 typedef unsigned char SHA_BYTE;
  34
  35 #if SIZEOF_INT == 4
  36 typedef unsigned int SHA_INT32; /* 32-bit integer */
  37 #else
  38 /* not defined. compilation will die. */
  39 #endif
  40
  41 /* The SHA block size and message digest sizes, in bytes */
  42
  43 #define SHA_BLOCKSIZE    64
  44 #define SHA_DIGESTSIZE  32
  45
  46 /* The structure for storing SHA info */
  47
  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;
  57
  58 /* When run on a little-endian CPU we need to perform byte reversal on an
  59    array of longwords. */
  60
  61 static void longReverse(SHA_INT32 *buffer, int byteCount, int Endianness)
  62 {
  63     SHA_INT32 value;
  64
  65     if ( Endianness == PCT_BIG_ENDIAN )
  66         return;
  67
  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 );
  74     }
  75 }
  76
  77 static void SHAcopy(SHAobject *src, SHAobject *dest)
  78 {
  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));
  86 }
  87
  88
  89 /* ------------------------------------------------------------------------
  90  *
  91  * This code for the SHA-256 algorithm was noted as public domain. The
  92  * original headers are pasted below.
  93  *
  94  * Several changes have been made to make it more compatible with the
  95  * Python environment and desired interface.
  96  *
  97  */
  98
  99 /* LibTomCrypt, modular cryptographic library -- Tom St Denis
 100  *
 101  * LibTomCrypt is a library that provides various cryptographic
 102  * algorithms in a highly modular and flexible manner.
 103  *
 104  * The library is free for all purposes without any express
 105  * gurantee it works.
 106  *
 107  * Tom St Denis, tomstdenis@iahu.ca, http://libtom.org
 108  */
 109
 110
 111 /* SHA256 by Tom St Denis */
 112
 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))
 125
 126
 127 static void
 128 sha_transform(SHAobject *sha_info)
 129 {
 130     int i;
 131         SHA_INT32 S[8], W[64], t0, t1;
 132
 133     memcpy(W, sha_info->data, sizeof(sha_info->data));
 134     longReverse(W, (int)sizeof(sha_info->data), sha_info->Endianness);
 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     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;
 244 }
 245
 246 static void
 247 sha224_init(SHAobject *sha_info)
 248 {
 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;
 262 }
 263
 264
 265 /* update the SHA digest */
 266
 267 static void
 268 sha_update(SHAobject *sha_info, SHA_BYTE *buffer, int count)
 269 {
 270     int i;
 271     SHA_INT32 clo;
 272
 273     clo = sha_info->count_lo + ((SHA_INT32) count << 3);
 274     if (clo < sha_info->count_lo) {
 275         ++sha_info->count_hi;
 276     }
 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;
 283         }
 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);
 290         }
 291         else {
 292             return;
 293         }
 294     }
 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);
 300     }
 301     memcpy(sha_info->data, buffer, count);
 302     sha_info->local = count;
 303 }
 304
 305 /* finish computing the SHA digest */
 306
 307 static void
 308 sha_final(unsigned char digest[SHA_DIGESTSIZE], SHAobject *sha_info)
 309 {
 310     int count;
 311     SHA_INT32 lo_bit_count, hi_bit_count;
 312
 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);
 322     }
 323     else {
 324         memset(((SHA_BYTE *) sha_info->data) + count, 0,
 325                SHA_BLOCKSIZE - 8 - count);
 326     }
 327
 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);
 371 }
 372
 373 /*
 374  * End of copied SHA code.
 375  *
 376  * ------------------------------------------------------------------------
 377  */
 378
 379 static PyTypeObject SHA224type;
 380 static PyTypeObject SHA256type;
 381
 382
 383 static SHAobject *
 384 newSHA224object(void)
 385 {
 386     return (SHAobject *)PyObject_New(SHAobject, &SHA224type);
 387 }
 388
 389 static SHAobject *
 390 newSHA256object(void)
 391 {
 392     return (SHAobject *)PyObject_New(SHAobject, &SHA256type);
 393 }
 394
 395 /* Internal methods for a hash object */
 396
 397 static void
 398 SHA_dealloc(PyObject *ptr)
 399 {
 400     PyObject_Del(ptr);
 401 }
 402
 403
 404 /* External methods for a hash object */
 405
 406 PyDoc_STRVAR(SHA256_copy__doc__, "Return a copy of the hash object.");
 407
 408 static PyObject *
 409 SHA256_copy(SHAobject *self, PyObject *unused)
 410 {
 411     SHAobject *newobj;
 412
 413     if (Py_TYPE(self) == &SHA256type) {
 414         if ( (newobj = newSHA256object())==NULL)
 415             return NULL;
 416     } else {
 417         if ( (newobj = newSHA224object())==NULL)
 418             return NULL;
 419     }
 420
 421     SHAcopy(self, newobj);
 422     return (PyObject *)newobj;
 423 }
 424
 425 PyDoc_STRVAR(SHA256_digest__doc__,
 426 "Return the digest value as a string of binary data.");
 427
 428 static PyObject *
 429 SHA256_digest(SHAobject *self, PyObject *unused)
 430 {
 431     unsigned char digest[SHA_DIGESTSIZE];
 432     SHAobject temp;
 433
 434     SHAcopy(self, &temp);
 435     sha_final(digest, &temp);
 436     return PyBytes_FromStringAndSize((const char *)digest, self->digestsize);
 437 }
 438
 439 PyDoc_STRVAR(SHA256_hexdigest__doc__,
 440 "Return the digest value as a string of hexadecimal digits.");
 441
 442 static PyObject *
 443 SHA256_hexdigest(SHAobject *self, PyObject *unused)
 444 {
 445     unsigned char digest[SHA_DIGESTSIZE];
 446     SHAobject temp;
 447     PyObject *retval;
 448     Py_UNICODE *hex_digest;
 449     int i, j;
 450
 451     /* Get the raw (binary) digest value */
 452     SHAcopy(self, &temp);
 453     sha_final(digest, &temp);
 454
 455     /* Create a new string */
 456     retval = PyUnicode_FromStringAndSize(NULL, self->digestsize * 2);
 457     if (!retval)
 458             return NULL;
 459     hex_digest = PyUnicode_AS_UNICODE(retval);
 460     if (!hex_digest) {
 461             Py_DECREF(retval);
 462             return NULL;
 463     }
 464
 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;
 474     }
 475     return retval;
 476 }
 477
 478 PyDoc_STRVAR(SHA256_update__doc__,
 479 "Update this hash object's state with the provided string.");
 480
 481 static PyObject *
 482 SHA256_update(SHAobject *self, PyObject *args)
 483 {
 484     PyObject *obj;
 485     Py_buffer buf;
 486
 487     if (!PyArg_ParseTuple(args, "O:update", &obj))
 488         return NULL;
 489
 490     GET_BUFFER_VIEW_OR_ERROUT(obj, &buf);
 491
 492     sha_update(self, buf.buf, buf.len);
 493
 494     PyBuffer_Release(&buf);
 495     Py_INCREF(Py_None);
 496     return Py_None;
 497 }
 498
 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 */
 505 };
 506
 507 static PyObject *
 508 SHA256_get_block_size(PyObject *self, void *closure)
 509 {
 510     return PyLong_FromLong(SHA_BLOCKSIZE);
 511 }
 512
 513 static PyObject *
 514 SHA256_get_name(PyObject *self, void *closure)
 515 {
 516     if (((SHAobject *)self)->digestsize == 32)
 517         return PyUnicode_FromStringAndSize("SHA256", 6);
 518     else
 519         return PyUnicode_FromStringAndSize("SHA224", 6);
 520 }
 521
 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 */
 532 };
 533
 534 static PyMemberDef SHA_members[] = {
 535     {"digest_size", T_INT, offsetof(SHAobject, digestsize), READONLY, NULL},
 536     {NULL}  /* Sentinel */
 537 };
 538
 539 static PyTypeObject SHA224type = {
 540     PyVarObject_HEAD_INIT(NULL, 0)
 541     "_sha256.sha224",   /*tp_name*/
 542     sizeof(SHAobject),  /*tp_size*/
 543     0,                  /*tp_itemsize*/
 544     /* methods */
 545     SHA_dealloc,        /*tp_dealloc*/
 546     0,                  /*tp_print*/
 547     0,                  /*tp_getattr*/
 548     0,                  /*tp_setattr*/
 549     0,                  /*tp_reserved*/
 550     0,                  /*tp_repr*/
 551     0,                  /*tp_as_number*/
 552     0,                  /*tp_as_sequence*/
 553     0,                  /*tp_as_mapping*/
 554     0,                  /*tp_hash*/
 555     0,                  /*tp_call*/
 556     0,                  /*tp_str*/
 557     0,                  /*tp_getattro*/
 558     0,                  /*tp_setattro*/
 559     0,                  /*tp_as_buffer*/
 560     Py_TPFLAGS_DEFAULT, /*tp_flags*/
 561     0,                  /*tp_doc*/
 562     0,                  /*tp_traverse*/
 563     0,                  /*tp_clear*/
 564     0,                  /*tp_richcompare*/
 565     0,                  /*tp_weaklistoffset*/
 566     0,                  /*tp_iter*/
 567     0,                  /*tp_iternext*/
 568     SHA_methods,        /* tp_methods */
 569     SHA_members,        /* tp_members */
 570     SHA_getseters,      /* tp_getset */
 571 };
 572
 573 static PyTypeObject SHA256type = {
 574     PyVarObject_HEAD_INIT(NULL, 0)
 575     "_sha256.sha256",   /*tp_name*/
 576     sizeof(SHAobject),  /*tp_size*/
 577     0,                  /*tp_itemsize*/
 578     /* methods */
 579     SHA_dealloc,        /*tp_dealloc*/
 580     0,                  /*tp_print*/
 581     0,                  /*tp_getattr*/
 582     0,                  /*tp_setattr*/
 583     0,                  /*tp_reserved*/
 584     0,                  /*tp_repr*/
 585     0,                  /*tp_as_number*/
 586     0,                  /*tp_as_sequence*/
 587     0,                  /*tp_as_mapping*/
 588     0,                  /*tp_hash*/
 589     0,                  /*tp_call*/
 590     0,                  /*tp_str*/
 591     0,                  /*tp_getattro*/
 592     0,                  /*tp_setattro*/
 593     0,                  /*tp_as_buffer*/
 594     Py_TPFLAGS_DEFAULT, /*tp_flags*/
 595     0,                  /*tp_doc*/
 596     0,                  /*tp_traverse*/
 597     0,                  /*tp_clear*/
 598     0,                  /*tp_richcompare*/
 599     0,                  /*tp_weaklistoffset*/
 600     0,                  /*tp_iter*/
 601     0,                  /*tp_iternext*/
 602     SHA_methods,        /* tp_methods */
 603     SHA_members,        /* tp_members */
 604     SHA_getseters,      /* tp_getset */
 605 };
 606
 607
 608 /* The single module-level function: new() */
 609
 610 PyDoc_STRVAR(SHA256_new__doc__,
 611 "Return a new SHA-256 hash object; optionally initialized with a string.");
 612
 613 static PyObject *
 614 SHA256_new(PyObject *self, PyObject *args, PyObject *kwdict)
 615 {
 616     static char *kwlist[] = {"string", NULL};
 617     SHAobject *new;
 618     PyObject *data_obj = NULL;
 619     Py_buffer buf;
 620
 621     if (!PyArg_ParseTupleAndKeywords(args, kwdict, "|O:new", kwlist,
 622                                      &data_obj)) {
 623         return NULL;
 624     }
 625
 626     if (data_obj)
 627         GET_BUFFER_VIEW_OR_ERROUT(data_obj, &buf);
 628
 629     if ((new = newSHA256object()) == NULL) {
 630         if (data_obj)
 631             PyBuffer_Release(&buf);
 632         return NULL;
 633     }
 634
 635     sha_init(new);
 636
 637     if (PyErr_Occurred()) {
 638         Py_DECREF(new);
 639         if (data_obj)
 640             PyBuffer_Release(&buf);
 641         return NULL;
 642     }
 643     if (data_obj) {
 644         sha_update(new, buf.buf, buf.len);
 645         PyBuffer_Release(&buf);
 646     }
 647
 648     return (PyObject *)new;
 649 }
 650
 651 PyDoc_STRVAR(SHA224_new__doc__,
 652 "Return a new SHA-224 hash object; optionally initialized with a string.");
 653
 654 static PyObject *
 655 SHA224_new(PyObject *self, PyObject *args, PyObject *kwdict)
 656 {
 657     static char *kwlist[] = {"string", NULL};
 658     SHAobject *new;
 659     PyObject *data_obj = NULL;
 660     Py_buffer buf;
 661
 662     if (!PyArg_ParseTupleAndKeywords(args, kwdict, "|O:new", kwlist,
 663                                      &data_obj)) {
 664         return NULL;
 665     }
 666
 667     if (data_obj)
 668         GET_BUFFER_VIEW_OR_ERROUT(data_obj, &buf);
 669
 670     if ((new = newSHA224object()) == NULL) {
 671         if (data_obj)
 672             PyBuffer_Release(&buf);
 673         return NULL;
 674     }
 675
 676     sha224_init(new);
 677
 678     if (PyErr_Occurred()) {
 679         Py_DECREF(new);
 680         if (data_obj)
 681             PyBuffer_Release(&buf);
 682         return NULL;
 683     }
 684     if (data_obj) {
 685         sha_update(new, buf.buf, buf.len);
 686         PyBuffer_Release(&buf);
 687     }
 688
 689     return (PyObject *)new;
 690 }
 691
 692
 693 /* List of functions exported by this module */
 694
 695 static struct PyMethodDef SHA_functions[] = {
 696     {"sha256", (PyCFunction)SHA256_new, METH_VARARGS|METH_KEYWORDS, SHA256_new__doc__},
 697     {"sha224", (PyCFunction)SHA224_new, METH_VARARGS|METH_KEYWORDS, SHA224_new__doc__},
 698     {NULL,      NULL}            /* Sentinel */
 699 };
 700
 701
 702 /* Initialize this module. */
 703
 704 #define insint(n,v) { PyModule_AddIntConstant(m,n,v); }
 705
 706
 707 static struct PyModuleDef _sha256module = {
 708         PyModuleDef_HEAD_INIT,
 709         "_sha256",
 710         NULL,
 711         -1,
 712         SHA_functions,
 713         NULL,
 714         NULL,
 715         NULL,
 716         NULL
 717 };
 718
 719 PyMODINIT_FUNC
 720 PyInit__sha256(void)
 721 {
 722     Py_TYPE(&SHA224type) = &PyType_Type;
 723     if (PyType_Ready(&SHA224type) < 0)
 724         return NULL;
 725     Py_TYPE(&SHA256type) = &PyType_Type;
 726     if (PyType_Ready(&SHA256type) < 0)
 727         return NULL;
 728     return PyModule_Create(&_sha256module);
 729 }