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   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://libtomcrypt.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 PyString_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     char *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 = 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;
 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, NULL);
 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 PyInt_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 PyString_FromStringAndSize("SHA256", 6);
 518     else
 519         return PyString_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     /* 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 */
 540 };
 541
 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 */
 574 };
 575
 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 */
 608 };
 609
 610
 611 /* The single module-level function: new() */
 612
 613 PyDoc_STRVAR(SHA256_new__doc__,
 614 "Return a new SHA-256 hash object; optionally initialized with a string.");
 615
 616 static PyObject *
 617 SHA256_new(PyObject *self, PyObject *args, PyObject *kwdict)
 618 {
 619     static char *kwlist[] = {"string", NULL};
 620     SHAobject *new;
 621     PyObject *data_obj = NULL;
 622     Py_buffer buf;
 623
 624     if (!PyArg_ParseTupleAndKeywords(args, kwdict, "|O:new", kwlist,
 625                                      &data_obj)) {
 626         return NULL;
 627     }
 628
 629     if (data_obj)
 630         GET_BUFFER_VIEW_OR_ERROUT(data_obj, &buf, NULL);
 631
 632     if ((new = newSHA256object()) == NULL) {
 633         if (data_obj)
 634             PyBuffer_Release(&buf);
 635         return NULL;
 636     }
 637
 638     sha_init(new);
 639
 640     if (PyErr_Occurred()) {
 641         Py_DECREF(new);
 642         if (data_obj)
 643             PyBuffer_Release(&buf);
 644         return NULL;
 645     }
 646     if (data_obj) {
 647         sha_update(new, buf.buf, buf.len);
 648         PyBuffer_Release(&buf);
 649     }
 650
 651     return (PyObject *)new;
 652 }
 653
 654 PyDoc_STRVAR(SHA224_new__doc__,
 655 "Return a new SHA-224 hash object; optionally initialized with a string.");
 656
 657 static PyObject *
 658 SHA224_new(PyObject *self, PyObject *args, PyObject *kwdict)
 659 {
 660     static char *kwlist[] = {"string", NULL};
 661     SHAobject *new;
 662     PyObject *data_obj = NULL;
 663     Py_buffer buf;
 664
 665     if (!PyArg_ParseTupleAndKeywords(args, kwdict, "|O:new", kwlist,
 666                                      &data_obj)) {
 667         return NULL;
 668     }
 669
 670     if (data_obj)
 671         GET_BUFFER_VIEW_OR_ERROUT(data_obj, &buf, NULL);
 672
 673     if ((new = newSHA224object()) == NULL) {
 674         if (data_obj)
 675             PyBuffer_Release(&buf);
 676         return NULL;
 677     }
 678
 679     sha224_init(new);
 680
 681     if (PyErr_Occurred()) {
 682         Py_DECREF(new);
 683         if (data_obj)
 684             PyBuffer_Release(&buf);
 685         return NULL;
 686     }
 687     if (data_obj) {
 688         sha_update(new, buf.buf, buf.len);
 689         PyBuffer_Release(&buf);
 690     }
 691
 692     return (PyObject *)new;
 693 }
 694
 695
 696 /* List of functions exported by this module */
 697
 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 */
 702 };
 703
 704
 705 /* Initialize this module. */
 706
 707 #define insint(n,v) { PyModule_AddIntConstant(m,n,v); }
 708
 709 PyMODINIT_FUNC
 710 init_sha256(void)
 711 {
 712     PyObject *m;
 713
 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;
 723 }