src/xbt/xbt_sha.c

   1 /* $Id$ */
   2 /* xbt_sha.c - SHA1 hash function */
   3
   4 /* Initial version part of iksemel (XML parser for Jabber)
   5  *   Copyright (C) 2000-2003 Gurer Ozen <madcat@e-kolay.net>. All right reserved. */
   6
   7 /* Adapted to fit into SimGrid by Martin Quinson.
   8      Copyright (c) 2008 Martin Quinson. All rights reserved. */
   9
  10 /* This program is free software; you can redistribute it and/or modify it
  11  * under the terms of the license (GNU LGPL) which comes with this package. */
  12
  13 #include "xbt/sysdep.h"
  14 #include "xbt/hash.h"
  15
  16 struct s_xbt_sha_ {
  17         unsigned int hash[5];
  18         unsigned int buf[80];
  19         int blen;
  20         unsigned int lenhi, lenlo;
  21 };
  22 static void sha_calculate (xbt_sha_t sha);
  23
  24 /* ************** */
  25 /* User Interface */
  26 /* ************** */
  27
  28 /** @brief constructor */
  29 xbt_sha_t xbt_sha_new (void) {
  30         xbt_sha_t sha;
  31
  32         sha = xbt_new(s_xbt_sha_t,1);
  33         xbt_sha_reset (sha);
  34
  35         return sha;
  36 }
  37
  38 /** @brief destructor */
  39 void xbt_sha_free (xbt_sha_t sha) {
  40    free (sha);
  41 }
  42
  43 void xbt_sha_reset (xbt_sha_t sha) {
  44    memset (sha, 0, sizeof (s_xbt_sha_t));
  45    sha->hash[0] = 0x67452301;
  46    sha->hash[1] = 0xefcdab89;
  47    sha->hash[2] = 0x98badcfe;
  48    sha->hash[3] = 0x10325476;
  49    sha->hash[4] = 0xc3d2e1f0;
  50 }
  51
  52 /* @brief Add some more data to the buffer */
  53 void xbt_sha_feed (xbt_sha_t sha, const unsigned char *data, size_t len) {
  54    int i;
  55
  56    for (i=0; i<len; i++) {
  57       sha->buf[sha->blen / 4] <<= 8;
  58       sha->buf[sha->blen / 4] |= (unsigned int)data[i];
  59       if ((++sha->blen) % 64 == 0) {
  60          sha_calculate (sha);
  61          sha->blen = 0;
  62       }
  63       sha->lenlo += 8;
  64       sha->lenhi += (sha->lenlo < 8);
  65    }
  66 }
  67
  68 /* finalize computation before displaying the result */
  69 static void xbt_sha_finalize (xbt_sha_t sha) {
  70         unsigned char pad[8];
  71         unsigned char padc;
  72
  73         pad[0] = (unsigned char)((sha->lenhi >> 24) & 0xff);
  74         pad[1] = (unsigned char)((sha->lenhi >> 16) & 0xff);
  75         pad[2] = (unsigned char)((sha->lenhi >> 8) & 0xff);
  76         pad[3] = (unsigned char)(sha->lenhi & 0xff);
  77         pad[4] = (unsigned char)((sha->lenlo >> 24) & 0xff);
  78         pad[5] = (unsigned char)((sha->lenlo >> 16) & 0xff);
  79         pad[6] = (unsigned char)((sha->lenlo >> 8) & 0xff);
  80         pad[7] = (unsigned char)(sha->lenlo & 255);
  81
  82         padc = 0x80;
  83         xbt_sha_feed (sha, &padc, 1);
  84
  85         padc = 0x00;
  86         while (sha->blen != 56)
  87                 xbt_sha_feed (sha, &padc, 1);
  88
  89         xbt_sha_feed (sha, pad, 8);
  90 }
  91
  92 /** @brief returns the sha hash into a newly allocated buffer (+ reset sha object) */
  93 char *xbt_sha_read(xbt_sha_t sha) {
  94    char *res = xbt_malloc(40);
  95    xbt_sha_print(sha,res);
  96    return res;
  97 }
  98
  99 /** @brief copy the content sha hash into the @a hash pre-allocated string (and reset buffer) */
 100 void xbt_sha_print (xbt_sha_t sha, char *hash) {
 101    int i;
 102
 103    xbt_sha_finalize(sha);
 104    for (i=0; i<5; i++) {
 105       sprintf (hash, "%08x", sha->hash[i]);
 106       hash += 8;
 107    }
 108 }
 109
 110
 111 /** @brief simply compute a SHA1 hash and copy it to the provided buffer */
 112 void xbt_sha (const char *data, char *hash) {
 113   s_xbt_sha_t sha;
 114
 115   xbt_sha_reset (&sha);
 116   xbt_sha_feed (&sha, (const unsigned char*)data, strlen (data));
 117
 118   xbt_sha_print (&sha, hash);
 119 }
 120
 121 /* ********************* */
 122 /* Core of the algorithm */
 123 /* ********************* */
 124
 125 #define SRL(x,y) (((x) << (y)) | ((x) >> (32-(y))))
 126 #define SHA(a,b,f,c) \
 127         for (i= (a) ; i<= (b) ; i++) { \
 128                 TMP = SRL(A,5) + ( (f) ) + E + sha->buf[i] + (c) ; \
 129                 E = D; \
 130                 D = C; \
 131                 C = SRL(B,30); \
 132                 B = A; \
 133                 A = TMP; \
 134         }
 135
 136 static void sha_calculate (xbt_sha_t sha)
 137 {
 138         int i;
 139         unsigned int A, B, C, D, E, TMP;
 140
 141         for (i=16; i<80; i++)
 142                 sha->buf[i] = SRL (sha->buf[i-3] ^ sha->buf[i-8] ^ sha->buf[i-14] ^ sha->buf[i-16], 1);
 143
 144         A = sha->hash[0];
 145         B = sha->hash[1];
 146         C = sha->hash[2];
 147         D = sha->hash[3];
 148         E = sha->hash[4];
 149
 150         SHA (0,  19, ((C^D)&B)^D,     0x5a827999);
 151         SHA (20, 39, B^C^D,           0x6ed9eba1);
 152         SHA (40, 59, (B&C)|(D&(B|C)), 0x8f1bbcdc);
 153         SHA (60, 79, B^C^D,           0xca62c1d6);
 154
 155         sha->hash[0] += A;
 156         sha->hash[1] += B;
 157         sha->hash[2] += C;
 158         sha->hash[3] += D;
 159         sha->hash[4] += E;
 160 }
 161
 162 /* ************* */
 163 /* Testing stuff */
 164 /* ************* */
 165 #ifdef SIMGRID_TEST
 166 #include "xbt/hash.h"
 167 #include "portable.h" /* hexa_str */
 168
 169 static char* mycmp(const char *p1, const char *p2,size_t n) {
 170   int i;
 171
 172   for (i=0; i<n; i++) {
 173     if (p1[i] != p2[i]) {
 174       return bprintf("Differs on %d -- Ox%x",i,p1[i]);
 175     }
 176   }
 177   return xbt_strdup("");
 178 }
 179
 180 static void test_sha(const char *clear,const char *hashed) {
 181    char hash[41];
 182    xbt_sha(clear,hash);
 183
 184    xbt_test_add1("==== Test with '%s'",clear);
 185    xbt_test_assert3(!memcmp(hash, hashed, 40), "Wrong sha: %40s!=%40s (%s)",
 186                     hash,hashed,mycmp(hash,hashed,40));
 187 }
 188
 189 XBT_TEST_SUITE("hash","Various hash functions");
 190
 191 XBT_LOG_NEW_DEFAULT_CATEGORY(hash,"Tests of various hash functions ");
 192
 193
 194 XBT_TEST_UNIT("sha",test_crypto_sha,"Test of the sha algorithm") {
 195    /* Empty string as test vector */
 196    test_sha("",                                            "da39a3ee5e6b4b0d3255bfef95601890afd80709");
 197
 198    /* Some pangram as test vector */
 199    test_sha("The quick brown fox jumps over the lazy dog", "2fd4e1c67a2d28fced849ee1bb76e7391b93eb12");
 200    test_sha("Woven silk pyjamas exchanged for blue quartz","da3aff337c810c6470db4dbf0f205c8afc31c442");
 201    test_sha("Pack my box with five dozen liquor jugs",     "373ba8be29d4d95708bf7cd43038f4e409dcb439");
 202
 203 }
 204 #endif /* SIMGRID_TEST */