1  | 
     | 
     | 
    /* $OpenBSD: hash.c,v 1.3 2013/12/09 11:03:45 markus Exp $ */  | 
    
    
    2  | 
     | 
     | 
     | 
    
    
    3  | 
     | 
     | 
    /* Copied from nacl-20110221/crypto_hash/sha512/ref/hash.c */  | 
    
    
    4  | 
     | 
     | 
     | 
    
    
    5  | 
     | 
     | 
    /*  | 
    
    
    6  | 
     | 
     | 
    20080913  | 
    
    
    7  | 
     | 
     | 
    D. J. Bernstein  | 
    
    
    8  | 
     | 
     | 
    Public domain.  | 
    
    
    9  | 
     | 
     | 
    */  | 
    
    
    10  | 
     | 
     | 
     | 
    
    
    11  | 
     | 
     | 
    #include "crypto_api.h"  | 
    
    
    12  | 
     | 
     | 
     | 
    
    
    13  | 
     | 
     | 
    #define blocks crypto_hashblocks_sha512  | 
    
    
    14  | 
     | 
     | 
     | 
    
    
    15  | 
     | 
     | 
    static const unsigned char iv[64] = { | 
    
    
    16  | 
     | 
     | 
      0x6a,0x09,0xe6,0x67,0xf3,0xbc,0xc9,0x08,  | 
    
    
    17  | 
     | 
     | 
      0xbb,0x67,0xae,0x85,0x84,0xca,0xa7,0x3b,  | 
    
    
    18  | 
     | 
     | 
      0x3c,0x6e,0xf3,0x72,0xfe,0x94,0xf8,0x2b,  | 
    
    
    19  | 
     | 
     | 
      0xa5,0x4f,0xf5,0x3a,0x5f,0x1d,0x36,0xf1,  | 
    
    
    20  | 
     | 
     | 
      0x51,0x0e,0x52,0x7f,0xad,0xe6,0x82,0xd1,  | 
    
    
    21  | 
     | 
     | 
      0x9b,0x05,0x68,0x8c,0x2b,0x3e,0x6c,0x1f,  | 
    
    
    22  | 
     | 
     | 
      0x1f,0x83,0xd9,0xab,0xfb,0x41,0xbd,0x6b,  | 
    
    
    23  | 
     | 
     | 
      0x5b,0xe0,0xcd,0x19,0x13,0x7e,0x21,0x79  | 
    
    
    24  | 
     | 
     | 
    } ;  | 
    
    
    25  | 
     | 
     | 
     | 
    
    
    26  | 
     | 
     | 
    typedef unsigned long long uint64;  | 
    
    
    27  | 
     | 
     | 
     | 
    
    
    28  | 
     | 
     | 
    int crypto_hash_sha512(unsigned char *out,const unsigned char *in,unsigned long long inlen)  | 
    
    
    29  | 
     | 
     | 
    { | 
    
    
    30  | 
     | 
     | 
      unsigned char h[64];  | 
    
    
    31  | 
     | 
     | 
      unsigned char padded[256];  | 
    
    
    32  | 
     | 
     | 
      unsigned int i;  | 
    
    
    33  | 
     | 
     | 
      unsigned long long bytes = inlen;  | 
    
    
    34  | 
     | 
     | 
     | 
    
    
    35  | 
     | 
     | 
      for (i = 0;i < 64;++i) h[i] = iv[i];  | 
    
    
    36  | 
     | 
     | 
     | 
    
    
    37  | 
     | 
     | 
      blocks(h,in,inlen);  | 
    
    
    38  | 
     | 
     | 
      in += inlen;  | 
    
    
    39  | 
     | 
     | 
      inlen &= 127;  | 
    
    
    40  | 
     | 
     | 
      in -= inlen;  | 
    
    
    41  | 
     | 
     | 
     | 
    
    
    42  | 
     | 
     | 
      for (i = 0;i < inlen;++i) padded[i] = in[i];  | 
    
    
    43  | 
     | 
     | 
      padded[inlen] = 0x80;  | 
    
    
    44  | 
     | 
     | 
     | 
    
    
    45  | 
     | 
     | 
      if (inlen < 112) { | 
    
    
    46  | 
     | 
     | 
        for (i = inlen + 1;i < 119;++i) padded[i] = 0;  | 
    
    
    47  | 
     | 
     | 
        padded[119] = bytes >> 61;  | 
    
    
    48  | 
     | 
     | 
        padded[120] = bytes >> 53;  | 
    
    
    49  | 
     | 
     | 
        padded[121] = bytes >> 45;  | 
    
    
    50  | 
     | 
     | 
        padded[122] = bytes >> 37;  | 
    
    
    51  | 
     | 
     | 
        padded[123] = bytes >> 29;  | 
    
    
    52  | 
     | 
     | 
        padded[124] = bytes >> 21;  | 
    
    
    53  | 
     | 
     | 
        padded[125] = bytes >> 13;  | 
    
    
    54  | 
     | 
     | 
        padded[126] = bytes >> 5;  | 
    
    
    55  | 
     | 
     | 
        padded[127] = bytes << 3;  | 
    
    
    56  | 
     | 
     | 
        blocks(h,padded,128);  | 
    
    
    57  | 
     | 
     | 
      } else { | 
    
    
    58  | 
     | 
     | 
        for (i = inlen + 1;i < 247;++i) padded[i] = 0;  | 
    
    
    59  | 
     | 
     | 
        padded[247] = bytes >> 61;  | 
    
    
    60  | 
     | 
     | 
        padded[248] = bytes >> 53;  | 
    
    
    61  | 
     | 
     | 
        padded[249] = bytes >> 45;  | 
    
    
    62  | 
     | 
     | 
        padded[250] = bytes >> 37;  | 
    
    
    63  | 
     | 
     | 
        padded[251] = bytes >> 29;  | 
    
    
    64  | 
     | 
     | 
        padded[252] = bytes >> 21;  | 
    
    
    65  | 
     | 
     | 
        padded[253] = bytes >> 13;  | 
    
    
    66  | 
     | 
     | 
        padded[254] = bytes >> 5;  | 
    
    
    67  | 
     | 
     | 
        padded[255] = bytes << 3;  | 
    
    
    68  | 
     | 
     | 
        blocks(h,padded,256);  | 
    
    
    69  | 
     | 
     | 
      }  | 
    
    
    70  | 
     | 
     | 
     | 
    
    
    71  | 
     | 
     | 
      for (i = 0;i < 64;++i) out[i] = h[i];  | 
    
    
    72  | 
     | 
     | 
     | 
    
    
    73  | 
     | 
     | 
      return 0;  | 
    
    
    74  | 
     | 
     | 
    }  |