LCOV - code coverage report
Current view: top level - Modules - sha512module.c (source / functions) Hit Total Coverage
Test: CPython lcov report Lines: 342 364 94.0 %
Date: 2022-07-07 18:19:46 Functions: 25 25 100.0 %

          Line data    Source code
       1             : /* SHA512 module */
       2             : 
       3             : /* This module provides an interface to NIST's SHA-512 and SHA-384 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             : #ifndef Py_BUILD_CORE_BUILTIN
      19             : #  define Py_BUILD_CORE_MODULE 1
      20             : #endif
      21             : 
      22             : #include "Python.h"
      23             : #include "pycore_bitutils.h"      // _Py_bswap64()
      24             : #include "pycore_strhex.h"        // _Py_strhex()
      25             : #include "structmember.h"         // PyMemberDef
      26             : #include "hashlib.h"
      27             : 
      28             : /*[clinic input]
      29             : module _sha512
      30             : class SHA512Type "SHAobject *" "&PyType_Type"
      31             : [clinic start generated code]*/
      32             : /*[clinic end generated code: output=da39a3ee5e6b4b0d input=81a3ccde92bcfe8d]*/
      33             : 
      34             : /* Some useful types */
      35             : 
      36             : typedef unsigned char SHA_BYTE;
      37             : typedef uint32_t SHA_INT32;  /* 32-bit integer */
      38             : typedef uint64_t SHA_INT64;  /* 64-bit integer */
      39             : 
      40             : /* The SHA block size and message digest sizes, in bytes */
      41             : 
      42             : #define SHA_BLOCKSIZE   128
      43             : #define SHA_DIGESTSIZE  64
      44             : 
      45             : /* The structure for storing SHA info */
      46             : 
      47             : typedef struct {
      48             :     PyObject_HEAD
      49             :     SHA_INT64 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/sha512module.c.h"
      57             : 
      58             : /* When run on a little-endian CPU we need to perform byte reversal on an
      59             :    array of longwords. */
      60             : 
      61             : #if PY_LITTLE_ENDIAN
      62       47176 : static void longReverse(SHA_INT64 *buffer, int byteCount)
      63             : {
      64       47176 :     byteCount /= sizeof(*buffer);
      65      801992 :     for (; byteCount--; buffer++) {
      66      754816 :         *buffer = _Py_bswap64(*buffer);
      67             :     }
      68       47176 : }
      69             : #endif
      70             : 
      71          74 : static void SHAcopy(SHAobject *src, SHAobject *dest)
      72             : {
      73          74 :     dest->local = src->local;
      74          74 :     dest->digestsize = src->digestsize;
      75          74 :     dest->count_lo = src->count_lo;
      76          74 :     dest->count_hi = src->count_hi;
      77          74 :     memcpy(dest->digest, src->digest, sizeof(src->digest));
      78          74 :     memcpy(dest->data, src->data, sizeof(src->data));
      79          74 : }
      80             : 
      81             : 
      82             : /* ------------------------------------------------------------------------
      83             :  *
      84             :  * This code for the SHA-512 algorithm was noted as public domain. The
      85             :  * original headers are pasted below.
      86             :  *
      87             :  * Several changes have been made to make it more compatible with the
      88             :  * Python environment and desired interface.
      89             :  *
      90             :  */
      91             : 
      92             : /* LibTomCrypt, modular cryptographic library -- Tom St Denis
      93             :  *
      94             :  * LibTomCrypt is a library that provides various cryptographic
      95             :  * algorithms in a highly modular and flexible manner.
      96             :  *
      97             :  * The library is free for all purposes without any express
      98             :  * guarantee it works.
      99             :  *
     100             :  * Tom St Denis, tomstdenis@iahu.ca, https://www.libtom.net
     101             :  */
     102             : 
     103             : 
     104             : /* SHA512 by Tom St Denis */
     105             : 
     106             : /* Various logical functions */
     107             : #define ROR64(x, y) \
     108             :     ( ((((x) & 0xFFFFFFFFFFFFFFFFULL)>>((unsigned long long)(y) & 63)) | \
     109             :       ((x)<<((unsigned long long)(64-((y) & 63))))) & 0xFFFFFFFFFFFFFFFFULL)
     110             : #define Ch(x,y,z)       (z ^ (x & (y ^ z)))
     111             : #define Maj(x,y,z)      (((x | y) & z) | (x & y))
     112             : #define S(x, n)         ROR64((x),(n))
     113             : #define R(x, n)         (((x) & 0xFFFFFFFFFFFFFFFFULL) >> ((unsigned long long)n))
     114             : #define Sigma0(x)       (S(x, 28) ^ S(x, 34) ^ S(x, 39))
     115             : #define Sigma1(x)       (S(x, 14) ^ S(x, 18) ^ S(x, 41))
     116             : #define Gamma0(x)       (S(x, 1) ^ S(x, 8) ^ R(x, 7))
     117             : #define Gamma1(x)       (S(x, 19) ^ S(x, 61) ^ R(x, 6))
     118             : 
     119             : 
     120             : static void
     121       47176 : sha512_transform(SHAobject *sha_info)
     122             : {
     123             :     int i;
     124             :     SHA_INT64 S[8], W[80], t0, t1;
     125             : 
     126       47176 :     memcpy(W, sha_info->data, sizeof(sha_info->data));
     127             : #if PY_LITTLE_ENDIAN
     128       47176 :     longReverse(W, (int)sizeof(sha_info->data));
     129             : #endif
     130             : 
     131     3066440 :     for (i = 16; i < 80; ++i) {
     132     3019260 :                 W[i] = Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) + W[i - 16];
     133             :     }
     134      424584 :     for (i = 0; i < 8; ++i) {
     135      377408 :         S[i] = sha_info->digest[i];
     136             :     }
     137             : 
     138             :     /* Compress */
     139             : #define RND(a,b,c,d,e,f,g,h,i,ki)                    \
     140             :      t0 = h + Sigma1(e) + Ch(e, f, g) + ki + W[i];   \
     141             :      t1 = Sigma0(a) + Maj(a, b, c);                  \
     142             :      d += t0;                                        \
     143             :      h  = t0 + t1;
     144             : 
     145       47176 :     RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],0,0x428a2f98d728ae22ULL);
     146       47176 :     RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],1,0x7137449123ef65cdULL);
     147       47176 :     RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],2,0xb5c0fbcfec4d3b2fULL);
     148       47176 :     RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],3,0xe9b5dba58189dbbcULL);
     149       47176 :     RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],4,0x3956c25bf348b538ULL);
     150       47176 :     RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],5,0x59f111f1b605d019ULL);
     151       47176 :     RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],6,0x923f82a4af194f9bULL);
     152       47176 :     RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],7,0xab1c5ed5da6d8118ULL);
     153       47176 :     RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],8,0xd807aa98a3030242ULL);
     154       47176 :     RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],9,0x12835b0145706fbeULL);
     155       47176 :     RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],10,0x243185be4ee4b28cULL);
     156       47176 :     RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],11,0x550c7dc3d5ffb4e2ULL);
     157       47176 :     RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],12,0x72be5d74f27b896fULL);
     158       47176 :     RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],13,0x80deb1fe3b1696b1ULL);
     159       47176 :     RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],14,0x9bdc06a725c71235ULL);
     160       47176 :     RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],15,0xc19bf174cf692694ULL);
     161       47176 :     RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],16,0xe49b69c19ef14ad2ULL);
     162       47176 :     RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],17,0xefbe4786384f25e3ULL);
     163       47176 :     RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],18,0x0fc19dc68b8cd5b5ULL);
     164       47176 :     RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],19,0x240ca1cc77ac9c65ULL);
     165       47176 :     RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],20,0x2de92c6f592b0275ULL);
     166       47176 :     RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],21,0x4a7484aa6ea6e483ULL);
     167       47176 :     RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],22,0x5cb0a9dcbd41fbd4ULL);
     168       47176 :     RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],23,0x76f988da831153b5ULL);
     169       47176 :     RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],24,0x983e5152ee66dfabULL);
     170       47176 :     RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],25,0xa831c66d2db43210ULL);
     171       47176 :     RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],26,0xb00327c898fb213fULL);
     172       47176 :     RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],27,0xbf597fc7beef0ee4ULL);
     173       47176 :     RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],28,0xc6e00bf33da88fc2ULL);
     174       47176 :     RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],29,0xd5a79147930aa725ULL);
     175       47176 :     RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],30,0x06ca6351e003826fULL);
     176       47176 :     RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],31,0x142929670a0e6e70ULL);
     177       47176 :     RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],32,0x27b70a8546d22ffcULL);
     178       47176 :     RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],33,0x2e1b21385c26c926ULL);
     179       47176 :     RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],34,0x4d2c6dfc5ac42aedULL);
     180       47176 :     RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],35,0x53380d139d95b3dfULL);
     181       47176 :     RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],36,0x650a73548baf63deULL);
     182       47176 :     RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],37,0x766a0abb3c77b2a8ULL);
     183       47176 :     RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],38,0x81c2c92e47edaee6ULL);
     184       47176 :     RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],39,0x92722c851482353bULL);
     185       47176 :     RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],40,0xa2bfe8a14cf10364ULL);
     186       47176 :     RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],41,0xa81a664bbc423001ULL);
     187       47176 :     RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],42,0xc24b8b70d0f89791ULL);
     188       47176 :     RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],43,0xc76c51a30654be30ULL);
     189       47176 :     RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],44,0xd192e819d6ef5218ULL);
     190       47176 :     RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],45,0xd69906245565a910ULL);
     191       47176 :     RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],46,0xf40e35855771202aULL);
     192       47176 :     RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],47,0x106aa07032bbd1b8ULL);
     193       47176 :     RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],48,0x19a4c116b8d2d0c8ULL);
     194       47176 :     RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],49,0x1e376c085141ab53ULL);
     195       47176 :     RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],50,0x2748774cdf8eeb99ULL);
     196       47176 :     RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],51,0x34b0bcb5e19b48a8ULL);
     197       47176 :     RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],52,0x391c0cb3c5c95a63ULL);
     198       47176 :     RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],53,0x4ed8aa4ae3418acbULL);
     199       47176 :     RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],54,0x5b9cca4f7763e373ULL);
     200       47176 :     RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],55,0x682e6ff3d6b2b8a3ULL);
     201       47176 :     RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],56,0x748f82ee5defb2fcULL);
     202       47176 :     RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],57,0x78a5636f43172f60ULL);
     203       47176 :     RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],58,0x84c87814a1f0ab72ULL);
     204       47176 :     RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],59,0x8cc702081a6439ecULL);
     205       47176 :     RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],60,0x90befffa23631e28ULL);
     206       47176 :     RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],61,0xa4506cebde82bde9ULL);
     207       47176 :     RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],62,0xbef9a3f7b2c67915ULL);
     208       47176 :     RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],63,0xc67178f2e372532bULL);
     209       47176 :     RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],64,0xca273eceea26619cULL);
     210       47176 :     RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],65,0xd186b8c721c0c207ULL);
     211       47176 :     RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],66,0xeada7dd6cde0eb1eULL);
     212       47176 :     RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],67,0xf57d4f7fee6ed178ULL);
     213       47176 :     RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],68,0x06f067aa72176fbaULL);
     214       47176 :     RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],69,0x0a637dc5a2c898a6ULL);
     215       47176 :     RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],70,0x113f9804bef90daeULL);
     216       47176 :     RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],71,0x1b710b35131c471bULL);
     217       47176 :     RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],72,0x28db77f523047d84ULL);
     218       47176 :     RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],73,0x32caab7b40c72493ULL);
     219       47176 :     RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],74,0x3c9ebe0a15c9bebcULL);
     220       47176 :     RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],75,0x431d67c49c100d4cULL);
     221       47176 :     RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],76,0x4cc5d4becb3e42b6ULL);
     222       47176 :     RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],77,0x597f299cfc657e2aULL);
     223       47176 :     RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],78,0x5fcb6fab3ad6faecULL);
     224       47176 :     RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],79,0x6c44198c4a475817ULL);
     225             : 
     226             : #undef RND
     227             : 
     228             :     /* feedback */
     229      424584 :     for (i = 0; i < 8; i++) {
     230      377408 :         sha_info->digest[i] = sha_info->digest[i] + S[i];
     231             :     }
     232             : 
     233       47176 : }
     234             : 
     235             : 
     236             : 
     237             : /* initialize the SHA digest */
     238             : 
     239             : static void
     240          41 : sha512_init(SHAobject *sha_info)
     241             : {
     242          41 :     sha_info->digest[0] = Py_ULL(0x6a09e667f3bcc908);
     243          41 :     sha_info->digest[1] = Py_ULL(0xbb67ae8584caa73b);
     244          41 :     sha_info->digest[2] = Py_ULL(0x3c6ef372fe94f82b);
     245          41 :     sha_info->digest[3] = Py_ULL(0xa54ff53a5f1d36f1);
     246          41 :     sha_info->digest[4] = Py_ULL(0x510e527fade682d1);
     247          41 :     sha_info->digest[5] = Py_ULL(0x9b05688c2b3e6c1f);
     248          41 :     sha_info->digest[6] = Py_ULL(0x1f83d9abfb41bd6b);
     249          41 :     sha_info->digest[7] = Py_ULL(0x5be0cd19137e2179);
     250          41 :     sha_info->count_lo = 0L;
     251          41 :     sha_info->count_hi = 0L;
     252          41 :     sha_info->local = 0;
     253          41 :     sha_info->digestsize = 64;
     254          41 : }
     255             : 
     256             : static void
     257          29 : sha384_init(SHAobject *sha_info)
     258             : {
     259          29 :     sha_info->digest[0] = Py_ULL(0xcbbb9d5dc1059ed8);
     260          29 :     sha_info->digest[1] = Py_ULL(0x629a292a367cd507);
     261          29 :     sha_info->digest[2] = Py_ULL(0x9159015a3070dd17);
     262          29 :     sha_info->digest[3] = Py_ULL(0x152fecd8f70e5939);
     263          29 :     sha_info->digest[4] = Py_ULL(0x67332667ffc00b31);
     264          29 :     sha_info->digest[5] = Py_ULL(0x8eb44a8768581511);
     265          29 :     sha_info->digest[6] = Py_ULL(0xdb0c2e0d64f98fa7);
     266          29 :     sha_info->digest[7] = Py_ULL(0x47b5481dbefa4fa4);
     267          29 :     sha_info->count_lo = 0L;
     268          29 :     sha_info->count_hi = 0L;
     269          29 :     sha_info->local = 0;
     270          29 :     sha_info->digestsize = 48;
     271          29 : }
     272             : 
     273             : 
     274             : /* update the SHA digest */
     275             : 
     276             : static void
     277          72 : sha512_update(SHAobject *sha_info, SHA_BYTE *buffer, Py_ssize_t count)
     278             : {
     279             :     Py_ssize_t i;
     280             :     SHA_INT32 clo;
     281             : 
     282          72 :     clo = sha_info->count_lo + ((SHA_INT32) count << 3);
     283          72 :     if (clo < sha_info->count_lo) {
     284           0 :         ++sha_info->count_hi;
     285             :     }
     286          72 :     sha_info->count_lo = clo;
     287          72 :     sha_info->count_hi += (SHA_INT32) count >> 29;
     288          72 :     if (sha_info->local) {
     289          10 :         i = SHA_BLOCKSIZE - sha_info->local;
     290          10 :         if (i > count) {
     291           2 :             i = count;
     292             :         }
     293          10 :         memcpy(((SHA_BYTE *) sha_info->data) + sha_info->local, buffer, i);
     294          10 :         count -= i;
     295          10 :         buffer += i;
     296          10 :         sha_info->local += (int)i;
     297          10 :         if (sha_info->local == SHA_BLOCKSIZE) {
     298           8 :             sha512_transform(sha_info);
     299             :         }
     300             :         else {
     301           2 :             return;
     302             :         }
     303             :     }
     304       47142 :     while (count >= SHA_BLOCKSIZE) {
     305       47072 :         memcpy(sha_info->data, buffer, SHA_BLOCKSIZE);
     306       47072 :         buffer += SHA_BLOCKSIZE;
     307       47072 :         count -= SHA_BLOCKSIZE;
     308       47072 :         sha512_transform(sha_info);
     309             :     }
     310          70 :     memcpy(sha_info->data, buffer, count);
     311          70 :     sha_info->local = (int)count;
     312             : }
     313             : 
     314             : /* finish computing the SHA digest */
     315             : 
     316             : static void
     317          72 : sha512_final(unsigned char digest[SHA_DIGESTSIZE], SHAobject *sha_info)
     318             : {
     319             :     int count;
     320             :     SHA_INT32 lo_bit_count, hi_bit_count;
     321             : 
     322          72 :     lo_bit_count = sha_info->count_lo;
     323          72 :     hi_bit_count = sha_info->count_hi;
     324          72 :     count = (int) ((lo_bit_count >> 3) & 0x7f);
     325          72 :     ((SHA_BYTE *) sha_info->data)[count++] = 0x80;
     326          72 :     if (count > SHA_BLOCKSIZE - 16) {
     327          24 :         memset(((SHA_BYTE *) sha_info->data) + count, 0,
     328          24 :                SHA_BLOCKSIZE - count);
     329          24 :         sha512_transform(sha_info);
     330          24 :         memset((SHA_BYTE *) sha_info->data, 0, SHA_BLOCKSIZE - 16);
     331             :     }
     332             :     else {
     333          48 :         memset(((SHA_BYTE *) sha_info->data) + count, 0,
     334          48 :                SHA_BLOCKSIZE - 16 - count);
     335             :     }
     336             : 
     337             :     /* GJS: note that we add the hi/lo in big-endian. sha512_transform will
     338             :        swap these values into host-order. */
     339          72 :     sha_info->data[112] = 0;
     340          72 :     sha_info->data[113] = 0;
     341          72 :     sha_info->data[114] = 0;
     342          72 :     sha_info->data[115] = 0;
     343          72 :     sha_info->data[116] = 0;
     344          72 :     sha_info->data[117] = 0;
     345          72 :     sha_info->data[118] = 0;
     346          72 :     sha_info->data[119] = 0;
     347          72 :     sha_info->data[120] = (hi_bit_count >> 24) & 0xff;
     348          72 :     sha_info->data[121] = (hi_bit_count >> 16) & 0xff;
     349          72 :     sha_info->data[122] = (hi_bit_count >>  8) & 0xff;
     350          72 :     sha_info->data[123] = (hi_bit_count >>  0) & 0xff;
     351          72 :     sha_info->data[124] = (lo_bit_count >> 24) & 0xff;
     352          72 :     sha_info->data[125] = (lo_bit_count >> 16) & 0xff;
     353          72 :     sha_info->data[126] = (lo_bit_count >>  8) & 0xff;
     354          72 :     sha_info->data[127] = (lo_bit_count >>  0) & 0xff;
     355          72 :     sha512_transform(sha_info);
     356          72 :     digest[ 0] = (unsigned char) ((sha_info->digest[0] >> 56) & 0xff);
     357          72 :     digest[ 1] = (unsigned char) ((sha_info->digest[0] >> 48) & 0xff);
     358          72 :     digest[ 2] = (unsigned char) ((sha_info->digest[0] >> 40) & 0xff);
     359          72 :     digest[ 3] = (unsigned char) ((sha_info->digest[0] >> 32) & 0xff);
     360          72 :     digest[ 4] = (unsigned char) ((sha_info->digest[0] >> 24) & 0xff);
     361          72 :     digest[ 5] = (unsigned char) ((sha_info->digest[0] >> 16) & 0xff);
     362          72 :     digest[ 6] = (unsigned char) ((sha_info->digest[0] >>  8) & 0xff);
     363          72 :     digest[ 7] = (unsigned char) ((sha_info->digest[0]      ) & 0xff);
     364          72 :     digest[ 8] = (unsigned char) ((sha_info->digest[1] >> 56) & 0xff);
     365          72 :     digest[ 9] = (unsigned char) ((sha_info->digest[1] >> 48) & 0xff);
     366          72 :     digest[10] = (unsigned char) ((sha_info->digest[1] >> 40) & 0xff);
     367          72 :     digest[11] = (unsigned char) ((sha_info->digest[1] >> 32) & 0xff);
     368          72 :     digest[12] = (unsigned char) ((sha_info->digest[1] >> 24) & 0xff);
     369          72 :     digest[13] = (unsigned char) ((sha_info->digest[1] >> 16) & 0xff);
     370          72 :     digest[14] = (unsigned char) ((sha_info->digest[1] >>  8) & 0xff);
     371          72 :     digest[15] = (unsigned char) ((sha_info->digest[1]      ) & 0xff);
     372          72 :     digest[16] = (unsigned char) ((sha_info->digest[2] >> 56) & 0xff);
     373          72 :     digest[17] = (unsigned char) ((sha_info->digest[2] >> 48) & 0xff);
     374          72 :     digest[18] = (unsigned char) ((sha_info->digest[2] >> 40) & 0xff);
     375          72 :     digest[19] = (unsigned char) ((sha_info->digest[2] >> 32) & 0xff);
     376          72 :     digest[20] = (unsigned char) ((sha_info->digest[2] >> 24) & 0xff);
     377          72 :     digest[21] = (unsigned char) ((sha_info->digest[2] >> 16) & 0xff);
     378          72 :     digest[22] = (unsigned char) ((sha_info->digest[2] >>  8) & 0xff);
     379          72 :     digest[23] = (unsigned char) ((sha_info->digest[2]      ) & 0xff);
     380          72 :     digest[24] = (unsigned char) ((sha_info->digest[3] >> 56) & 0xff);
     381          72 :     digest[25] = (unsigned char) ((sha_info->digest[3] >> 48) & 0xff);
     382          72 :     digest[26] = (unsigned char) ((sha_info->digest[3] >> 40) & 0xff);
     383          72 :     digest[27] = (unsigned char) ((sha_info->digest[3] >> 32) & 0xff);
     384          72 :     digest[28] = (unsigned char) ((sha_info->digest[3] >> 24) & 0xff);
     385          72 :     digest[29] = (unsigned char) ((sha_info->digest[3] >> 16) & 0xff);
     386          72 :     digest[30] = (unsigned char) ((sha_info->digest[3] >>  8) & 0xff);
     387          72 :     digest[31] = (unsigned char) ((sha_info->digest[3]      ) & 0xff);
     388          72 :     digest[32] = (unsigned char) ((sha_info->digest[4] >> 56) & 0xff);
     389          72 :     digest[33] = (unsigned char) ((sha_info->digest[4] >> 48) & 0xff);
     390          72 :     digest[34] = (unsigned char) ((sha_info->digest[4] >> 40) & 0xff);
     391          72 :     digest[35] = (unsigned char) ((sha_info->digest[4] >> 32) & 0xff);
     392          72 :     digest[36] = (unsigned char) ((sha_info->digest[4] >> 24) & 0xff);
     393          72 :     digest[37] = (unsigned char) ((sha_info->digest[4] >> 16) & 0xff);
     394          72 :     digest[38] = (unsigned char) ((sha_info->digest[4] >>  8) & 0xff);
     395          72 :     digest[39] = (unsigned char) ((sha_info->digest[4]      ) & 0xff);
     396          72 :     digest[40] = (unsigned char) ((sha_info->digest[5] >> 56) & 0xff);
     397          72 :     digest[41] = (unsigned char) ((sha_info->digest[5] >> 48) & 0xff);
     398          72 :     digest[42] = (unsigned char) ((sha_info->digest[5] >> 40) & 0xff);
     399          72 :     digest[43] = (unsigned char) ((sha_info->digest[5] >> 32) & 0xff);
     400          72 :     digest[44] = (unsigned char) ((sha_info->digest[5] >> 24) & 0xff);
     401          72 :     digest[45] = (unsigned char) ((sha_info->digest[5] >> 16) & 0xff);
     402          72 :     digest[46] = (unsigned char) ((sha_info->digest[5] >>  8) & 0xff);
     403          72 :     digest[47] = (unsigned char) ((sha_info->digest[5]      ) & 0xff);
     404          72 :     digest[48] = (unsigned char) ((sha_info->digest[6] >> 56) & 0xff);
     405          72 :     digest[49] = (unsigned char) ((sha_info->digest[6] >> 48) & 0xff);
     406          72 :     digest[50] = (unsigned char) ((sha_info->digest[6] >> 40) & 0xff);
     407          72 :     digest[51] = (unsigned char) ((sha_info->digest[6] >> 32) & 0xff);
     408          72 :     digest[52] = (unsigned char) ((sha_info->digest[6] >> 24) & 0xff);
     409          72 :     digest[53] = (unsigned char) ((sha_info->digest[6] >> 16) & 0xff);
     410          72 :     digest[54] = (unsigned char) ((sha_info->digest[6] >>  8) & 0xff);
     411          72 :     digest[55] = (unsigned char) ((sha_info->digest[6]      ) & 0xff);
     412          72 :     digest[56] = (unsigned char) ((sha_info->digest[7] >> 56) & 0xff);
     413          72 :     digest[57] = (unsigned char) ((sha_info->digest[7] >> 48) & 0xff);
     414          72 :     digest[58] = (unsigned char) ((sha_info->digest[7] >> 40) & 0xff);
     415          72 :     digest[59] = (unsigned char) ((sha_info->digest[7] >> 32) & 0xff);
     416          72 :     digest[60] = (unsigned char) ((sha_info->digest[7] >> 24) & 0xff);
     417          72 :     digest[61] = (unsigned char) ((sha_info->digest[7] >> 16) & 0xff);
     418          72 :     digest[62] = (unsigned char) ((sha_info->digest[7] >>  8) & 0xff);
     419          72 :     digest[63] = (unsigned char) ((sha_info->digest[7]      ) & 0xff);
     420          72 : }
     421             : 
     422             : /*
     423             :  * End of copied SHA code.
     424             :  *
     425             :  * ------------------------------------------------------------------------
     426             :  */
     427             : 
     428             : typedef struct {
     429             :     PyTypeObject* sha384_type;
     430             :     PyTypeObject* sha512_type;
     431             : } SHA512State;
     432             : 
     433             : static inline SHA512State*
     434       46177 : sha512_get_state(PyObject *module)
     435             : {
     436       46177 :     void *state = PyModule_GetState(module);
     437       46177 :     assert(state != NULL);
     438       46177 :     return (SHA512State *)state;
     439             : }
     440             : 
     441             : static SHAobject *
     442          30 : newSHA384object(SHA512State *st)
     443             : {
     444          30 :     SHAobject *sha = (SHAobject *)PyObject_GC_New(SHAobject, st->sha384_type);
     445          30 :     PyObject_GC_Track(sha);
     446          30 :     return sha;
     447             : }
     448             : 
     449             : static SHAobject *
     450          42 : newSHA512object(SHA512State *st)
     451             : {
     452          42 :     SHAobject *sha = (SHAobject *)PyObject_GC_New(SHAobject, st->sha512_type);
     453          42 :     PyObject_GC_Track(sha);
     454          42 :     return sha;
     455             : }
     456             : 
     457             : /* Internal methods for a hash object */
     458             : static int
     459          72 : SHA_traverse(PyObject *ptr, visitproc visit, void *arg)
     460             : {
     461          72 :     Py_VISIT(Py_TYPE(ptr));
     462          72 :     return 0;
     463             : }
     464             : 
     465             : static void
     466          72 : SHA512_dealloc(PyObject *ptr)
     467             : {
     468          72 :     PyTypeObject *tp = Py_TYPE(ptr);
     469          72 :     PyObject_GC_UnTrack(ptr);
     470          72 :     PyObject_GC_Del(ptr);
     471          72 :     Py_DECREF(tp);
     472          72 : }
     473             : 
     474             : 
     475             : /* External methods for a hash object */
     476             : 
     477             : /*[clinic input]
     478             : SHA512Type.copy
     479             : 
     480             :     cls: defining_class
     481             : 
     482             : Return a copy of the hash object.
     483             : [clinic start generated code]*/
     484             : 
     485             : static PyObject *
     486           2 : SHA512Type_copy_impl(SHAobject *self, PyTypeObject *cls)
     487             : /*[clinic end generated code: output=85ea5b47837a08e6 input=f673a18f66527c90]*/
     488             : {
     489             :     SHAobject *newobj;
     490           2 :     SHA512State *st = PyType_GetModuleState(cls);
     491             : 
     492           2 :     if (Py_IS_TYPE((PyObject*)self, st->sha512_type)) {
     493           1 :         if ( (newobj = newSHA512object(st))==NULL) {
     494           0 :             return NULL;
     495             :         }
     496             :     }
     497             :     else {
     498           1 :         if ( (newobj = newSHA384object(st))==NULL) {
     499           0 :             return NULL;
     500             :         }
     501             :     }
     502             : 
     503           2 :     SHAcopy(self, newobj);
     504           2 :     return (PyObject *)newobj;
     505             : }
     506             : 
     507             : /*[clinic input]
     508             : SHA512Type.digest
     509             : 
     510             : Return the digest value as a bytes object.
     511             : [clinic start generated code]*/
     512             : 
     513             : static PyObject *
     514          42 : SHA512Type_digest_impl(SHAobject *self)
     515             : /*[clinic end generated code: output=1080bbeeef7dde1b input=f6470dd359071f4b]*/
     516             : {
     517             :     unsigned char digest[SHA_DIGESTSIZE];
     518             :     SHAobject temp;
     519             : 
     520          42 :     SHAcopy(self, &temp);
     521          42 :     sha512_final(digest, &temp);
     522          42 :     return PyBytes_FromStringAndSize((const char *)digest, self->digestsize);
     523             : }
     524             : 
     525             : /*[clinic input]
     526             : SHA512Type.hexdigest
     527             : 
     528             : Return the digest value as a string of hexadecimal digits.
     529             : [clinic start generated code]*/
     530             : 
     531             : static PyObject *
     532          30 : SHA512Type_hexdigest_impl(SHAobject *self)
     533             : /*[clinic end generated code: output=7373305b8601e18b input=498b877b25cbe0a2]*/
     534             : {
     535             :     unsigned char digest[SHA_DIGESTSIZE];
     536             :     SHAobject temp;
     537             : 
     538             :     /* Get the raw (binary) digest value */
     539          30 :     SHAcopy(self, &temp);
     540          30 :     sha512_final(digest, &temp);
     541             : 
     542          30 :     return _Py_strhex((const char *)digest, self->digestsize);
     543             : }
     544             : 
     545             : /*[clinic input]
     546             : SHA512Type.update
     547             : 
     548             :     obj: object
     549             :     /
     550             : 
     551             : Update this hash object's state with the provided string.
     552             : [clinic start generated code]*/
     553             : 
     554             : static PyObject *
     555          40 : SHA512Type_update(SHAobject *self, PyObject *obj)
     556             : /*[clinic end generated code: output=1cf333e73995a79e input=ded2b46656566283]*/
     557             : {
     558             :     Py_buffer buf;
     559             : 
     560          40 :     GET_BUFFER_VIEW_OR_ERROUT(obj, &buf);
     561             : 
     562          40 :     sha512_update(self, buf.buf, buf.len);
     563             : 
     564          40 :     PyBuffer_Release(&buf);
     565          40 :     Py_RETURN_NONE;
     566             : }
     567             : 
     568             : static PyMethodDef SHA_methods[] = {
     569             :     SHA512TYPE_COPY_METHODDEF
     570             :     SHA512TYPE_DIGEST_METHODDEF
     571             :     SHA512TYPE_HEXDIGEST_METHODDEF
     572             :     SHA512TYPE_UPDATE_METHODDEF
     573             :     {NULL,        NULL}         /* sentinel */
     574             : };
     575             : 
     576             : static PyObject *
     577           2 : SHA512_get_block_size(PyObject *self, void *closure)
     578             : {
     579           2 :     return PyLong_FromLong(SHA_BLOCKSIZE);
     580             : }
     581             : 
     582             : static PyObject *
     583          20 : SHA512_get_name(PyObject *self, void *closure)
     584             : {
     585          20 :     if (((SHAobject *)self)->digestsize == 64)
     586          10 :         return PyUnicode_FromStringAndSize("sha512", 6);
     587             :     else
     588          10 :         return PyUnicode_FromStringAndSize("sha384", 6);
     589             : }
     590             : 
     591             : static PyGetSetDef SHA_getseters[] = {
     592             :     {"block_size",
     593             :      (getter)SHA512_get_block_size, NULL,
     594             :      NULL,
     595             :      NULL},
     596             :     {"name",
     597             :      (getter)SHA512_get_name, NULL,
     598             :      NULL,
     599             :      NULL},
     600             :     {NULL}  /* Sentinel */
     601             : };
     602             : 
     603             : static PyMemberDef SHA_members[] = {
     604             :     {"digest_size", T_INT, offsetof(SHAobject, digestsize), READONLY, NULL},
     605             :     {NULL}  /* Sentinel */
     606             : };
     607             : 
     608             : static PyType_Slot sha512_sha384_type_slots[] = {
     609             :     {Py_tp_dealloc, SHA512_dealloc},
     610             :     {Py_tp_methods, SHA_methods},
     611             :     {Py_tp_members, SHA_members},
     612             :     {Py_tp_getset, SHA_getseters},
     613             :     {Py_tp_traverse, SHA_traverse},
     614             :     {0,0}
     615             : };
     616             : 
     617             : static PyType_Spec sha512_sha384_type_spec = {
     618             :     .name = "_sha512.sha384",
     619             :     .basicsize =  sizeof(SHAobject),
     620             :     .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION |
     621             :               Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_HAVE_GC),
     622             :     .slots = sha512_sha384_type_slots
     623             : };
     624             : 
     625             : static PyType_Slot sha512_sha512_type_slots[] = {
     626             :     {Py_tp_dealloc, SHA512_dealloc},
     627             :     {Py_tp_methods, SHA_methods},
     628             :     {Py_tp_members, SHA_members},
     629             :     {Py_tp_getset, SHA_getseters},
     630             :     {Py_tp_traverse, SHA_traverse},
     631             :     {0,0}
     632             : };
     633             : 
     634             : // Using PyType_GetModuleState() on this type is safe since
     635             : // it cannot be subclassed: it does not have the Py_TPFLAGS_BASETYPE flag.
     636             : static PyType_Spec sha512_sha512_type_spec = {
     637             :     .name = "_sha512.sha512",
     638             :     .basicsize =  sizeof(SHAobject),
     639             :     .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION |
     640             :               Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_HAVE_GC),
     641             :     .slots = sha512_sha512_type_slots
     642             : };
     643             : 
     644             : /* The single module-level function: new() */
     645             : 
     646             : /*[clinic input]
     647             : _sha512.sha512
     648             : 
     649             :     string: object(c_default="NULL") = b''
     650             :     *
     651             :     usedforsecurity: bool = True
     652             : 
     653             : Return a new SHA-512 hash object; optionally initialized with a string.
     654             : [clinic start generated code]*/
     655             : 
     656             : static PyObject *
     657          42 : _sha512_sha512_impl(PyObject *module, PyObject *string, int usedforsecurity)
     658             : /*[clinic end generated code: output=a8d9e5f9e6a0831c input=23b4daebc2ebb9c9]*/
     659             : {
     660             :     SHAobject *new;
     661             :     Py_buffer buf;
     662             : 
     663          42 :     SHA512State *st = sha512_get_state(module);
     664             : 
     665          42 :     if (string)
     666          23 :         GET_BUFFER_VIEW_OR_ERROUT(string, &buf);
     667             : 
     668          41 :     if ((new = newSHA512object(st)) == NULL) {
     669           0 :         if (string)
     670           0 :             PyBuffer_Release(&buf);
     671           0 :         return NULL;
     672             :     }
     673             : 
     674          41 :     sha512_init(new);
     675             : 
     676          41 :     if (PyErr_Occurred()) {
     677           0 :         Py_DECREF(new);
     678           0 :         if (string)
     679           0 :             PyBuffer_Release(&buf);
     680           0 :         return NULL;
     681             :     }
     682          41 :     if (string) {
     683          22 :         sha512_update(new, buf.buf, buf.len);
     684          22 :         PyBuffer_Release(&buf);
     685             :     }
     686             : 
     687          41 :     return (PyObject *)new;
     688             : }
     689             : 
     690             : /*[clinic input]
     691             : _sha512.sha384
     692             : 
     693             :     string: object(c_default="NULL") = b''
     694             :     *
     695             :     usedforsecurity: bool = True
     696             : 
     697             : Return a new SHA-384 hash object; optionally initialized with a string.
     698             : [clinic start generated code]*/
     699             : 
     700             : static PyObject *
     701          30 : _sha512_sha384_impl(PyObject *module, PyObject *string, int usedforsecurity)
     702             : /*[clinic end generated code: output=da7d594a08027ac3 input=59ef72f039a6b431]*/
     703             : {
     704             :     SHAobject *new;
     705             :     Py_buffer buf;
     706             : 
     707          30 :     SHA512State *st = sha512_get_state(module);
     708             : 
     709          30 :     if (string)
     710          11 :         GET_BUFFER_VIEW_OR_ERROUT(string, &buf);
     711             : 
     712          29 :     if ((new = newSHA384object(st)) == NULL) {
     713           0 :         if (string)
     714           0 :             PyBuffer_Release(&buf);
     715           0 :         return NULL;
     716             :     }
     717             : 
     718          29 :     sha384_init(new);
     719             : 
     720          29 :     if (PyErr_Occurred()) {
     721           0 :         Py_DECREF(new);
     722           0 :         if (string)
     723           0 :             PyBuffer_Release(&buf);
     724           0 :         return NULL;
     725             :     }
     726          29 :     if (string) {
     727          10 :         sha512_update(new, buf.buf, buf.len);
     728          10 :         PyBuffer_Release(&buf);
     729             :     }
     730             : 
     731          29 :     return (PyObject *)new;
     732             : }
     733             : 
     734             : 
     735             : /* List of functions exported by this module */
     736             : 
     737             : static struct PyMethodDef SHA_functions[] = {
     738             :     _SHA512_SHA512_METHODDEF
     739             :     _SHA512_SHA384_METHODDEF
     740             :     {NULL,      NULL}            /* Sentinel */
     741             : };
     742             : 
     743             : static int
     744       42784 : _sha512_traverse(PyObject *module, visitproc visit, void *arg)
     745             : {
     746       42784 :     SHA512State *state = sha512_get_state(module);
     747       42784 :     Py_VISIT(state->sha384_type);
     748       42784 :     Py_VISIT(state->sha512_type);
     749       42784 :     return 0;
     750             : }
     751             : 
     752             : static int
     753        2214 : _sha512_clear(PyObject *module)
     754             : {
     755        2214 :     SHA512State *state = sha512_get_state(module);
     756        2214 :     Py_CLEAR(state->sha384_type);
     757        2214 :     Py_CLEAR(state->sha512_type);
     758        2214 :     return 0;
     759             : }
     760             : 
     761             : static void
     762        1107 : _sha512_free(void *module)
     763             : {
     764        1107 :     _sha512_clear((PyObject *)module);
     765        1107 : }
     766             : 
     767             : 
     768             : /* Initialize this module. */
     769             : static int
     770        1107 : _sha512_exec(PyObject *m)
     771             : {
     772        1107 :     SHA512State* st = sha512_get_state(m);
     773             : 
     774        1107 :     st->sha384_type = (PyTypeObject *)PyType_FromModuleAndSpec(
     775             :         m, &sha512_sha384_type_spec, NULL);
     776             : 
     777        1107 :     st->sha512_type = (PyTypeObject *)PyType_FromModuleAndSpec(
     778             :         m, &sha512_sha512_type_spec, NULL);
     779             : 
     780        1107 :     if (st->sha384_type == NULL || st->sha512_type == NULL) {
     781           0 :         return -1;
     782             :     }
     783             : 
     784        1107 :     Py_INCREF(st->sha384_type);
     785        1107 :     if (PyModule_AddObject(m, "SHA384Type", (PyObject *)st->sha384_type) < 0) {
     786           0 :         Py_DECREF(st->sha384_type);
     787           0 :         return -1;
     788             :     }
     789             : 
     790        1107 :     Py_INCREF(st->sha512_type);
     791        1107 :     if (PyModule_AddObject(m, "SHA384Type", (PyObject *)st->sha512_type) < 0) {
     792           0 :         Py_DECREF(st->sha512_type);
     793           0 :         return -1;
     794             :     }
     795             : 
     796        1107 :     return 0;
     797             : }
     798             : 
     799             : static PyModuleDef_Slot _sha512_slots[] = {
     800             :     {Py_mod_exec, _sha512_exec},
     801             :     {0, NULL}
     802             : };
     803             : 
     804             : static struct PyModuleDef _sha512module = {
     805             :         PyModuleDef_HEAD_INIT,
     806             :         .m_name = "_sha512",
     807             :         .m_size = sizeof(SHA512State),
     808             :         .m_methods = SHA_functions,
     809             :         .m_slots = _sha512_slots,
     810             :         .m_traverse = _sha512_traverse,
     811             :         .m_clear = _sha512_clear,
     812             :         .m_free = _sha512_free
     813             : };
     814             : 
     815             : PyMODINIT_FUNC
     816        1107 : PyInit__sha512(void)
     817             : {
     818        1107 :     return PyModuleDef_Init(&_sha512module);
     819             : }

Generated by: LCOV version 1.14