Line data    Source code

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