Line data    Source code

       1             : #include "burp.h"
       2             : #include "hexmap.h"
       3             : #include "protocol2/blk.h"
       4             : 
       5             : // FIX THIS: Should be set in configure somewhere.
       6             : #include <openssl/md5.h>
       7             : 
       8             : #define HEXMAP_SIZE     256
       9             : 
      10             : static uint8_t hexmap1[HEXMAP_SIZE];
      11             : static uint8_t hexmap2[HEXMAP_SIZE];
      12             : 
      13             : uint8_t md5sum_of_empty_string[MD5_DIGEST_LENGTH];
      14             : 
      15         762 : static void do_hexmap_init(uint8_t *hexmap, uint8_t shift)
      16             : {
      17             :         uint8_t i;
      18             :         uint8_t h;
      19             :         memset(hexmap, 0, HEXMAP_SIZE);
      20         762 :         for(i='0', h=0x00; i<='9'; i++, h++) hexmap[i]=h<<shift;
      21        4572 :         for(i='a', h=0x0A; i<='f'; i++, h++) hexmap[i]=h<<shift;
      22        4572 :         for(i='A', h=0x0A; i<='F'; i++, h++) hexmap[i]=h<<shift;
      23         762 : }
      24             : 
      25         381 : void hexmap_init(void)
      26             : {
      27         381 :         do_hexmap_init(hexmap1, 4);
      28         381 :         do_hexmap_init(hexmap2, 0);
      29             :         md5str_to_bytes("D41D8CD98F00B204E9800998ECF8427E",
      30             :                 md5sum_of_empty_string);
      31         381 : }
      32             : 
      33       17510 : static void str_to_bytes(const char *str, uint8_t *bytes, size_t len)
      34             : {
      35             :         static uint8_t bpos;
      36             :         static uint8_t spos;
      37             : 
      38      229745 :         for(bpos=0, spos=0; bpos<len && str[spos]; )
      39             :         {
      40      194725 :                 if(str[spos]=='/')
      41             :                 {
      42       51261 :                         spos++;
      43       51261 :                         continue;
      44             :                 }
      45             : #if BYTE_ORDER == LITTLE_ENDIAN
      46      286928 :                 bytes[bpos++] = hexmap1[(uint8_t)str[spos]]
      47      143464 :                         | hexmap2[(uint8_t)str[spos+1]];
      48             : #elif BYTE_ORDER == BIG_ENDIAN
      49             :                 bytes[bpos-bpos%4+3-bpos%4] = hexmap1[(uint8_t)str[spos]]
      50             :                         | hexmap2[(uint8_t)str[spos+1]];
      51             :                 bpos+=1;
      52             : #else
      53             :                 #error byte order not supported
      54             : #endif
      55      143464 :                 spos+=2;
      56             :         }
      57       17510 : }
      58             : 
      59          42 : void md5str_to_bytes(const char *md5str, uint8_t *bytes)
      60             : {
      61         423 :         str_to_bytes(md5str, bytes, MD5_DIGEST_LENGTH);
      62          42 : }
      63             : 
      64        7419 : char *bytes_to_md5str(uint8_t *bytes)
      65             : {
      66             :         static char str[64];
      67       22257 :         snprintf(str, sizeof(str), "%016" PRIx64 "%016" PRIx64,
      68             :                 htobe64(*(uint64_t *)bytes), htobe64(*(uint64_t *)(bytes+8)));
      69        7419 :         return str;
      70             : }
      71             : 
      72       17087 : uint64_t savepathstr_with_sig_to_uint64(const char *savepathstr)
      73             : {
      74             :         uint8_t b[sizeof(uint64_t)];
      75       17087 :         str_to_bytes(savepathstr, b, sizeof(b));
      76       34174 :         return htobe64(*(uint64_t *)&b);
      77             : }
      78             : 
      79       17689 : static char *savepathstr_make(uint64_t *be_bytes)
      80             : {
      81             :         static char str[15];
      82       17689 :         uint8_t *b=(uint8_t *)be_bytes;
      83      106134 :         snprintf(str, sizeof(str), "%02X%02X/%02X%02X/%02X%02X",
      84      106134 :                 b[0], b[1], b[2], b[3], b[4], b[5]);
      85       17689 :         return str;
      86             : }
      87             : 
      88       17336 : char *uint64_to_savepathstr(uint64_t bytes)
      89             : {
      90       17336 :         uint64_t be_bytes=htobe64(bytes);
      91       17336 :         return savepathstr_make(&be_bytes);
      92             : }
      93             : 
      94           5 : char *uint64_to_savepathstr_with_sig(uint64_t bytes)
      95             : {
      96             :         static char str[20];
      97           5 :         uint64_t be_bytes=htobe64(bytes);
      98           5 :         uint8_t *b=(uint8_t *)&be_bytes;
      99          40 :         snprintf(str, sizeof(str), "%02X%02X/%02X%02X/%02X%02X/%02X%02X",
     100          40 :                 b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7]);
     101           5 :         return str;
     102             : }
     103             : 
     104         353 : char *uint64_to_savepathstr_with_sig_uint(uint64_t bytes, uint16_t *sig)
     105             : {
     106             :         char *str;
     107         353 :         uint64_t be_bytes=htobe64(bytes);
     108         353 :         uint8_t *b=(uint8_t *)&be_bytes;
     109         353 :         str=savepathstr_make(&be_bytes);
     110         353 :         *sig = b[6] << 8;
     111         353 :         *sig |= b[7];
     112         353 :         return str;
     113             : }