AppPkg/Applications/Python/Python-2.7.10/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
  22
  23 /* Endianness testing and definitions */
  24 #define TestEndianness(variable) {int i=1; variable=PCT_BIG_ENDIAN;\
  25         if (*((char*)&i)==1) variable=PCT_LITTLE_ENDIAN;}
  26
  27 #define PCT_LITTLE_ENDIAN 1
  28 #define PCT_BIG_ENDIAN 0
  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 Endianness;
  53     int local;                          /* unprocessed amount in data */
  54     int digestsize;
  55 } SHAobject;
  56
  57 /* When run on a little-endian CPU we need to perform byte reversal on an
  58    array of longwords. */
  59
  60 static void longReverse(SHA_INT32 *buffer, int byteCount, int Endianness)
  61 {
  62     SHA_INT32 value;
  63
  64     if ( Endianness == PCT_BIG_ENDIAN )
  65         return;
  66
  67     byteCount /= sizeof(*buffer);
  68     while (byteCount--) {
  69         value = *buffer;
  70         value = ( ( value & 0xFF00FF00L ) >> 8  ) | \
  71                 ( ( value & 0x00FF00FFL ) << 8 );
  72         *buffer++ = ( value << 16 ) | ( value >> 16 );
  73     }
  74 }
  75
  76 static void SHAcopy(SHAobject *src, SHAobject *dest)
  77 {
  78     dest->Endianness = src->Endianness;
  79     dest->local = src->local;
  80     dest->digestsize = src->digestsize;
  81     dest->count_lo = src->count_lo;
  82     dest->count_hi = src->count_hi;
  83     memcpy(dest->digest, src->digest, sizeof(src->digest));
  84     memcpy(dest->data, src->data, sizeof(src->data));
  85 }
  86
  87
  88 /* ------------------------------------------------------------------------
  89  *
  90  * This code for the SHA-256 algorithm was noted as public domain. The
  91  * original headers are pasted below.
  92  *
  93  * Several changes have been made to make it more compatible with the
  94  * Python environment and desired interface.
  95  *
  96  */
  97
  98 /* LibTomCrypt, modular cryptographic library -- Tom St Denis
  99  *
 100  * LibTomCrypt is a library that provides various cryptographic
 101  * algorithms in a highly modular and flexible manner.
 102  *
 103  * The library is free for all purposes without any express
 104  * gurantee it works.
 105  *
 106  * Tom St Denis, tomstdenis@iahu.ca, http://libtomcrypt.org
 107  */
 108
 109
 110 /* SHA256 by Tom St Denis */
 111
 112 /* Various logical functions */
 113 #define ROR(x, y)\
 114 ( ((((unsigned long)(x)&0xFFFFFFFFUL)>>(unsigned long)((y)&31)) | \
 115 ((unsigned long)(x)<<(unsigned long)(32-((y)&31)))) & 0xFFFFFFFFUL)
 116 #define Ch(x,y,z)       (z ^ (x & (y ^ z)))
 117 #define Maj(x,y,z)      (((x | y) & z) | (x & y))
 118 #define S(x, n)         ROR((x),(n))
 119 #define R(x, n)         (((x)&0xFFFFFFFFUL)>>(n))
 120 #define Sigma0(x)       (S(x, 2) ^ S(x, 13) ^ S(x, 22))
 121 #define Sigma1(x)       (S(x, 6) ^ S(x, 11) ^ S(x, 25))
 122 #define Gamma0(x)       (S(x, 7) ^ S(x, 18) ^ R(x, 3))
 123 #define Gamma1(x)       (S(x, 17) ^ S(x, 19) ^ R(x, 10))
 124
 125
 126 static void
 127 sha_transform(SHAobject *sha_info)
 128 {
 129     int i;
 130         SHA_INT32 S[8], W[64], t0, t1;
 131
 132     memcpy(W, sha_info->data, sizeof(sha_info->data));
 133     longReverse(W, (int)sizeof(sha_info->data), sha_info->Endianness);
 134
 135     for (i = 16; i < 64; ++i) {
 136                 W[i] = Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) + W[i - 16];
 137     }
 138     for (i = 0; i < 8; ++i) {
 139         S[i] = sha_info->digest[i];
 140     }
 141
 142     /* Compress */
 143 #define RND(a,b,c,d,e,f,g,h,i,ki)                    \
 144      t0 = h + Sigma1(e) + Ch(e, f, g) + ki + W[i];   \
 145      t1 = Sigma0(a) + Maj(a, b, c);                  \
 146      d += t0;                                        \
 147      h  = t0 + t1;
 148
 149     RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],0,0x428a2f98);
 150     RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],1,0x71374491);
 151     RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],2,0xb5c0fbcf);
 152     RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],3,0xe9b5dba5);
 153     RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],4,0x3956c25b);
 154     RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],5,0x59f111f1);
 155     RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],6,0x923f82a4);
 156     RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],7,0xab1c5ed5);
 157     RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],8,0xd807aa98);
 158     RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],9,0x12835b01);
 159     RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],10,0x243185be);
 160     RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],11,0x550c7dc3);
 161     RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],12,0x72be5d74);
 162     RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],13,0x80deb1fe);
 163     RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],14,0x9bdc06a7);
 164     RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],15,0xc19bf174);
 165     RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],16,0xe49b69c1);
 166     RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],17,0xefbe4786);
 167     RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],18,0x0fc19dc6);
 168     RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],19,0x240ca1cc);
 169     RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],20,0x2de92c6f);
 170     RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],21,0x4a7484aa);
 171     RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],22,0x5cb0a9dc);
 172     RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],23,0x76f988da);
 173     RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],24,0x983e5152);
 174     RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],25,0xa831c66d);
 175     RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],26,0xb00327c8);
 176     RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],27,0xbf597fc7);
 177     RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],28,0xc6e00bf3);
 178     RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],29,0xd5a79147);
 179     RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],30,0x06ca6351);
 180     RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],31,0x14292967);
 181     RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],32,0x27b70a85);
 182     RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],33,0x2e1b2138);
 183     RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],34,0x4d2c6dfc);
 184     RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],35,0x53380d13);
 185     RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],36,0x650a7354);
 186     RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],37,0x766a0abb);
 187     RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],38,0x81c2c92e);
 188     RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],39,0x92722c85);
 189     RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],40,0xa2bfe8a1);
 190     RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],41,0xa81a664b);
 191     RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],42,0xc24b8b70);
 192     RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],43,0xc76c51a3);
 193     RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],44,0xd192e819);
 194     RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],45,0xd6990624);
 195     RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],46,0xf40e3585);
 196     RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],47,0x106aa070);
 197     RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],48,0x19a4c116);
 198     RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],49,0x1e376c08);
 199     RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],50,0x2748774c);
 200     RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],51,0x34b0bcb5);
 201     RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],52,0x391c0cb3);
 202     RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],53,0x4ed8aa4a);
 203     RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],54,0x5b9cca4f);
 204     RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],55,0x682e6ff3);
 205     RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],56,0x748f82ee);
 206     RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],57,0x78a5636f);
 207     RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],58,0x84c87814);
 208     RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],59,0x8cc70208);
 209     RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],60,0x90befffa);
 210     RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],61,0xa4506ceb);
 211     RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],62,0xbef9a3f7);
 212     RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],63,0xc67178f2);
 213
 214 #undef RND
 215
 216     /* feedback */
 217     for (i = 0; i < 8; i++) {
 218         sha_info->digest[i] = sha_info->digest[i] + S[i];
 219     }
 220
 221 }
 222
 223
 224
 225 /* initialize the SHA digest */
 226
 227 static void
 228 sha_init(SHAobject *sha_info)
 229 {
 230     TestEndianness(sha_info->Endianness)
 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     TestEndianness(sha_info->Endianness)
 249     sha_info->digest[0] = 0xc1059ed8L;
 250     sha_info->digest[1] = 0x367cd507L;
 251     sha_info->digest[2] = 0x3070dd17L;
 252     sha_info->digest[3] = 0xf70e5939L;
 253     sha_info->digest[4] = 0xffc00b31L;
 254     sha_info->digest[5] = 0x68581511L;
 255     sha_info->digest[6] = 0x64f98fa7L;
 256     sha_info->digest[7] = 0xbefa4fa4L;
 257     sha_info->count_lo = 0L;
 258     sha_info->count_hi = 0L;
 259     sha_info->local = 0;
 260     sha_info->digestsize = 28;
 261 }
 262
 263
 264 /* update the SHA digest */
 265
 266 static void
 267 sha_update(SHAobject *sha_info, SHA_BYTE *buffer, int count)
 268 {
 269     int i;
 270     SHA_INT32 clo;
 271
 272     clo = sha_info->count_lo + ((SHA_INT32) count << 3);
 273     if (clo < sha_info->count_lo) {
 274         ++sha_info->count_hi;
 275     }
 276     sha_info->count_lo = clo;
 277     sha_info->count_hi += (SHA_INT32) count >> 29;
 278     if (sha_info->local) {
 279         i = SHA_BLOCKSIZE - sha_info->local;
 280         if (i > count) {
 281             i = count;
 282         }
 283         memcpy(((SHA_BYTE *) sha_info->data) + sha_info->local, buffer, i);
 284         count -= i;
 285         buffer += i;
 286         sha_info->local += i;
 287         if (sha_info->local == SHA_BLOCKSIZE) {
 288             sha_transform(sha_info);
 289         }
 290         else {
 291             return;
 292         }
 293     }
 294     while (count >= SHA_BLOCKSIZE) {
 295         memcpy(sha_info->data, buffer, SHA_BLOCKSIZE);
 296         buffer += SHA_BLOCKSIZE;
 297         count -= SHA_BLOCKSIZE;
 298         sha_transform(sha_info);
 299     }
 300     memcpy(sha_info->data, buffer, count);
 301     sha_info->local = count;
 302 }
 303
 304 /* finish computing the SHA digest */
 305
 306 static void
 307 sha_final(unsigned char digest[SHA_DIGESTSIZE], SHAobject *sha_info)
 308 {
 309     int count;
 310     SHA_INT32 lo_bit_count, hi_bit_count;
 311
 312     lo_bit_count = sha_info->count_lo;
 313     hi_bit_count = sha_info->count_hi;
 314     count = (int) ((lo_bit_count >> 3) & 0x3f);
 315     ((SHA_BYTE *) sha_info->data)[count++] = 0x80;
 316     if (count > SHA_BLOCKSIZE - 8) {
 317         memset(((SHA_BYTE *) sha_info->data) + count, 0,
 318                SHA_BLOCKSIZE - count);
 319         sha_transform(sha_info);
 320         memset((SHA_BYTE *) sha_info->data, 0, SHA_BLOCKSIZE - 8);
 321     }
 322     else {
 323         memset(((SHA_BYTE *) sha_info->data) + count, 0,
 324                SHA_BLOCKSIZE - 8 - count);
 325     }
 326
 327     /* GJS: note that we add the hi/lo in big-endian. sha_transform will
 328        swap these values into host-order. */
 329     sha_info->data[56] = (hi_bit_count >> 24) & 0xff;
 330     sha_info->data[57] = (hi_bit_count >> 16) & 0xff;
 331     sha_info->data[58] = (hi_bit_count >>  8) & 0xff;
 332     sha_info->data[59] = (hi_bit_count >>  0) & 0xff;
 333     sha_info->data[60] = (lo_bit_count >> 24) & 0xff;
 334     sha_info->data[61] = (lo_bit_count >> 16) & 0xff;
 335     sha_info->data[62] = (lo_bit_count >>  8) & 0xff;
 336     sha_info->data[63] = (lo_bit_count >>  0) & 0xff;
 337     sha_transform(sha_info);
 338     digest[ 0] = (unsigned char) ((sha_info->digest[0] >> 24) & 0xff);
 339     digest[ 1] = (unsigned char) ((sha_info->digest[0] >> 16) & 0xff);
 340     digest[ 2] = (unsigned char) ((sha_info->digest[0] >>  8) & 0xff);
 341     digest[ 3] = (unsigned char) ((sha_info->digest[0]      ) & 0xff);
 342     digest[ 4] = (unsigned char) ((sha_info->digest[1] >> 24) & 0xff);
 343     digest[ 5] = (unsigned char) ((sha_info->digest[1] >> 16) & 0xff);
 344     digest[ 6] = (unsigned char) ((sha_info->digest[1] >>  8) & 0xff);
 345     digest[ 7] = (unsigned char) ((sha_info->digest[1]      ) & 0xff);
 346     digest[ 8] = (unsigned char) ((sha_info->digest[2] >> 24) & 0xff);
 347     digest[ 9] = (unsigned char) ((sha_info->digest[2] >> 16) & 0xff);
 348     digest[10] = (unsigned char) ((sha_info->digest[2] >>  8) & 0xff);
 349     digest[11] = (unsigned char) ((sha_info->digest[2]      ) & 0xff);
 350     digest[12] = (unsigned char) ((sha_info->digest[3] >> 24) & 0xff);
 351     digest[13] = (unsigned char) ((sha_info->digest[3] >> 16) & 0xff);
 352     digest[14] = (unsigned char) ((sha_info->digest[3] >>  8) & 0xff);
 353     digest[15] = (unsigned char) ((sha_info->digest[3]      ) & 0xff);
 354     digest[16] = (unsigned char) ((sha_info->digest[4] >> 24) & 0xff);
 355     digest[17] = (unsigned char) ((sha_info->digest[4] >> 16) & 0xff);
 356     digest[18] = (unsigned char) ((sha_info->digest[4] >>  8) & 0xff);
 357     digest[19] = (unsigned char) ((sha_info->digest[4]      ) & 0xff);
 358     digest[20] = (unsigned char) ((sha_info->digest[5] >> 24) & 0xff);
 359     digest[21] = (unsigned char) ((sha_info->digest[5] >> 16) & 0xff);
 360     digest[22] = (unsigned char) ((sha_info->digest[5] >>  8) & 0xff);
 361     digest[23] = (unsigned char) ((sha_info->digest[5]      ) & 0xff);
 362     digest[24] = (unsigned char) ((sha_info->digest[6] >> 24) & 0xff);
 363     digest[25] = (unsigned char) ((sha_info->digest[6] >> 16) & 0xff);
 364     digest[26] = (unsigned char) ((sha_info->digest[6] >>  8) & 0xff);
 365     digest[27] = (unsigned char) ((sha_info->digest[6]      ) & 0xff);
 366     digest[28] = (unsigned char) ((sha_info->digest[7] >> 24) & 0xff);
 367     digest[29] = (unsigned char) ((sha_info->digest[7] >> 16) & 0xff);
 368     digest[30] = (unsigned char) ((sha_info->digest[7] >>  8) & 0xff);
 369     digest[31] = (unsigned char) ((sha_info->digest[7]      ) & 0xff);
 370 }
 371
 372 /*
 373  * End of copied SHA code.
 374  *
 375  * ------------------------------------------------------------------------
 376  */
 377
 378 static PyTypeObject SHA224type;
 379 static PyTypeObject SHA256type;
 380
 381
 382 static SHAobject *
 383 newSHA224object(void)
 384 {
 385     return (SHAobject *)PyObject_New(SHAobject, &SHA224type);
 386 }
 387
 388 static SHAobject *
 389 newSHA256object(void)
 390 {
 391     return (SHAobject *)PyObject_New(SHAobject, &SHA256type);
 392 }
 393
 394 /* Internal methods for a hash object */
 395
 396 static void
 397 SHA_dealloc(PyObject *ptr)
 398 {
 399     PyObject_Del(ptr);
 400 }
 401
 402
 403 /* External methods for a hash object */
 404
 405 PyDoc_STRVAR(SHA256_copy__doc__, "Return a copy of the hash object.");
 406
 407 static PyObject *
 408 SHA256_copy(SHAobject *self, PyObject *unused)
 409 {
 410     SHAobject *newobj;
 411
 412     if (Py_TYPE(self) == &SHA256type) {
 413         if ( (newobj = newSHA256object())==NULL)
 414             return NULL;
 415     } else {
 416         if ( (newobj = newSHA224object())==NULL)
 417             return NULL;
 418     }
 419
 420     SHAcopy(self, newobj);
 421     return (PyObject *)newobj;
 422 }
 423
 424 PyDoc_STRVAR(SHA256_digest__doc__,
 425 "Return the digest value as a string of binary data.");
 426
 427 static PyObject *
 428 SHA256_digest(SHAobject *self, PyObject *unused)
 429 {
 430     unsigned char digest[SHA_DIGESTSIZE];
 431     SHAobject temp;
 432
 433     SHAcopy(self, &temp);
 434     sha_final(digest, &temp);
 435     return PyString_FromStringAndSize((const char *)digest, self->digestsize);
 436 }
 437
 438 PyDoc_STRVAR(SHA256_hexdigest__doc__,
 439 "Return the digest value as a string of hexadecimal digits.");
 440
 441 static PyObject *
 442 SHA256_hexdigest(SHAobject *self, PyObject *unused)
 443 {
 444     unsigned char digest[SHA_DIGESTSIZE];
 445     SHAobject temp;
 446     PyObject *retval;
 447     char *hex_digest;
 448     int i, j;
 449
 450     /* Get the raw (binary) digest value */
 451     SHAcopy(self, &temp);
 452     sha_final(digest, &temp);
 453
 454     /* Create a new string */
 455     retval = PyString_FromStringAndSize(NULL, self->digestsize * 2);
 456     if (!retval)
 457             return NULL;
 458     hex_digest = PyString_AsString(retval);
 459     if (!hex_digest) {
 460             Py_DECREF(retval);
 461             return NULL;
 462     }
 463
 464     /* Make hex version of the digest */
 465     for(i=j=0; i<self->digestsize; i++) {
 466         char c;
 467         c = (digest[i] >> 4) & 0xf;
 468         c = (c>9) ? c+'a'-10 : c + '0';
 469         hex_digest[j++] = c;
 470         c = (digest[i] & 0xf);
 471         c = (c>9) ? c+'a'-10 : c + '0';
 472         hex_digest[j++] = c;
 473     }
 474     return retval;
 475 }
 476
 477 PyDoc_STRVAR(SHA256_update__doc__,
 478 "Update this hash object's state with the provided string.");
 479
 480 static PyObject *
 481 SHA256_update(SHAobject *self, PyObject *args)
 482 {
 483     Py_buffer buf;
 484
 485     if (!PyArg_ParseTuple(args, "s*:update", &buf))
 486         return NULL;
 487
 488     sha_update(self, buf.buf, buf.len);
 489
 490     PyBuffer_Release(&buf);
 491     Py_RETURN_NONE;
 492 }
 493
 494 static PyMethodDef SHA_methods[] = {
 495     {"copy",      (PyCFunction)SHA256_copy,      METH_NOARGS,  SHA256_copy__doc__},
 496     {"digest",    (PyCFunction)SHA256_digest,    METH_NOARGS,  SHA256_digest__doc__},
 497     {"hexdigest", (PyCFunction)SHA256_hexdigest, METH_NOARGS,  SHA256_hexdigest__doc__},
 498     {"update",    (PyCFunction)SHA256_update,    METH_VARARGS, SHA256_update__doc__},
 499     {NULL,        NULL}         /* sentinel */
 500 };
 501
 502 static PyObject *
 503 SHA256_get_block_size(PyObject *self, void *closure)
 504 {
 505     return PyInt_FromLong(SHA_BLOCKSIZE);
 506 }
 507
 508 static PyObject *
 509 SHA256_get_name(PyObject *self, void *closure)
 510 {
 511     if (((SHAobject *)self)->digestsize == 32)
 512         return PyString_FromStringAndSize("SHA256", 6);
 513     else
 514         return PyString_FromStringAndSize("SHA224", 6);
 515 }
 516
 517 static PyGetSetDef SHA_getseters[] = {
 518     {"block_size",
 519      (getter)SHA256_get_block_size, NULL,
 520      NULL,
 521      NULL},
 522     {"name",
 523      (getter)SHA256_get_name, NULL,
 524      NULL,
 525      NULL},
 526     {NULL}  /* Sentinel */
 527 };
 528
 529 static PyMemberDef SHA_members[] = {
 530     {"digest_size", T_INT, offsetof(SHAobject, digestsize), READONLY, NULL},
 531     /* the old md5 and sha modules support 'digest_size' as in PEP 247.
 532      * the old sha module also supported 'digestsize'.  ugh. */
 533     {"digestsize", T_INT, offsetof(SHAobject, digestsize), READONLY, NULL},
 534     {NULL}  /* Sentinel */
 535 };
 536
 537 static PyTypeObject SHA224type = {
 538     PyVarObject_HEAD_INIT(NULL, 0)
 539     "_sha256.sha224",   /*tp_name*/
 540     sizeof(SHAobject),  /*tp_size*/
 541     0,                  /*tp_itemsize*/
 542     /* methods */
 543     SHA_dealloc,        /*tp_dealloc*/
 544     0,                  /*tp_print*/
 545     0,                  /*tp_getattr*/
 546     0,                  /*tp_setattr*/
 547     0,                  /*tp_compare*/
 548     0,                  /*tp_repr*/
 549     0,                  /*tp_as_number*/
 550     0,                  /*tp_as_sequence*/
 551     0,                  /*tp_as_mapping*/
 552     0,                  /*tp_hash*/
 553     0,                  /*tp_call*/
 554     0,                  /*tp_str*/
 555     0,                  /*tp_getattro*/
 556     0,                  /*tp_setattro*/
 557     0,                  /*tp_as_buffer*/
 558     Py_TPFLAGS_DEFAULT, /*tp_flags*/
 559     0,                  /*tp_doc*/
 560     0,                  /*tp_traverse*/
 561     0,                  /*tp_clear*/
 562     0,                  /*tp_richcompare*/
 563     0,                  /*tp_weaklistoffset*/
 564     0,                  /*tp_iter*/
 565     0,                  /*tp_iternext*/
 566     SHA_methods,        /* tp_methods */
 567     SHA_members,        /* tp_members */
 568     SHA_getseters,      /* tp_getset */
 569 };
 570
 571 static PyTypeObject SHA256type = {
 572     PyVarObject_HEAD_INIT(NULL, 0)
 573     "_sha256.sha256",   /*tp_name*/
 574     sizeof(SHAobject),  /*tp_size*/
 575     0,                  /*tp_itemsize*/
 576     /* methods */
 577     SHA_dealloc,        /*tp_dealloc*/
 578     0,                  /*tp_print*/
 579     0,                  /*tp_getattr*/
 580     0,                  /*tp_setattr*/
 581     0,                  /*tp_compare*/
 582     0,                  /*tp_repr*/
 583     0,                  /*tp_as_number*/
 584     0,                  /*tp_as_sequence*/
 585     0,                  /*tp_as_mapping*/
 586     0,                  /*tp_hash*/
 587     0,                  /*tp_call*/
 588     0,                  /*tp_str*/
 589     0,                  /*tp_getattro*/
 590     0,                  /*tp_setattro*/
 591     0,                  /*tp_as_buffer*/
 592     Py_TPFLAGS_DEFAULT, /*tp_flags*/
 593     0,                  /*tp_doc*/
 594     0,                  /*tp_traverse*/
 595     0,                  /*tp_clear*/
 596     0,                  /*tp_richcompare*/
 597     0,                  /*tp_weaklistoffset*/
 598     0,                  /*tp_iter*/
 599     0,                  /*tp_iternext*/
 600     SHA_methods,        /* tp_methods */
 601     SHA_members,        /* tp_members */
 602     SHA_getseters,      /* tp_getset */
 603 };
 604
 605
 606 /* The single module-level function: new() */
 607
 608 PyDoc_STRVAR(SHA256_new__doc__,
 609 "Return a new SHA-256 hash object; optionally initialized with a string.");
 610
 611 static PyObject *
 612 SHA256_new(PyObject *self, PyObject *args, PyObject *kwdict)
 613 {
 614     static char *kwlist[] = {"string", NULL};
 615     SHAobject *new;
 616     Py_buffer buf = { 0 };
 617
 618     if (!PyArg_ParseTupleAndKeywords(args, kwdict, "|s*:new", kwlist,
 619                                      &buf)) {
 620         return NULL;
 621     }
 622
 623     if ((new = newSHA256object()) == NULL) {
 624         PyBuffer_Release(&buf);
 625         return NULL;
 626     }
 627
 628     sha_init(new);
 629
 630     if (PyErr_Occurred()) {
 631         Py_DECREF(new);
 632         PyBuffer_Release(&buf);
 633         return NULL;
 634     }
 635     if (buf.len > 0) {
 636         sha_update(new, buf.buf, buf.len);
 637     }
 638     PyBuffer_Release(&buf);
 639
 640     return (PyObject *)new;
 641 }
 642
 643 PyDoc_STRVAR(SHA224_new__doc__,
 644 "Return a new SHA-224 hash object; optionally initialized with a string.");
 645
 646 static PyObject *
 647 SHA224_new(PyObject *self, PyObject *args, PyObject *kwdict)
 648 {
 649     static char *kwlist[] = {"string", NULL};
 650     SHAobject *new;
 651     Py_buffer buf = { 0 };
 652
 653     if (!PyArg_ParseTupleAndKeywords(args, kwdict, "|s*:new", kwlist,
 654                                      &buf)) {
 655         return NULL;
 656     }
 657
 658     if ((new = newSHA224object()) == NULL) {
 659         PyBuffer_Release(&buf);
 660         return NULL;
 661     }
 662
 663     sha224_init(new);
 664
 665     if (PyErr_Occurred()) {
 666         Py_DECREF(new);
 667         PyBuffer_Release(&buf);
 668         return NULL;
 669     }
 670     if (buf.len > 0) {
 671         sha_update(new, buf.buf, buf.len);
 672     }
 673     PyBuffer_Release(&buf);
 674
 675     return (PyObject *)new;
 676 }
 677
 678
 679 /* List of functions exported by this module */
 680
 681 static struct PyMethodDef SHA_functions[] = {
 682     {"sha256", (PyCFunction)SHA256_new, METH_VARARGS|METH_KEYWORDS, SHA256_new__doc__},
 683     {"sha224", (PyCFunction)SHA224_new, METH_VARARGS|METH_KEYWORDS, SHA224_new__doc__},
 684     {NULL,      NULL}            /* Sentinel */
 685 };
 686
 687
 688 /* Initialize this module. */
 689
 690 #define insint(n,v) { PyModule_AddIntConstant(m,n,v); }
 691
 692 PyMODINIT_FUNC
 693 init_sha256(void)
 694 {
 695     PyObject *m;
 696
 697     Py_TYPE(&SHA224type) = &PyType_Type;
 698     if (PyType_Ready(&SHA224type) < 0)
 699         return;
 700     Py_TYPE(&SHA256type) = &PyType_Type;
 701     if (PyType_Ready(&SHA256type) < 0)
 702         return;
 703     m = Py_InitModule("_sha256", SHA_functions);
 704     if (m == NULL)
 705         return;
 706 }