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         686 : 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         686 :         for(i='0', h=0x00; i<='9'; i++, h++) hexmap[i]=h<<shift;
      21        4116 :         for(i='a', h=0x0A; i<='f'; i++, h++) hexmap[i]=h<<shift;
      22        4116 :         for(i='A', h=0x0A; i<='F'; i++, h++) hexmap[i]=h<<shift;
      23         686 : }
      24             : 
      25         343 : void hexmap_init(void)
      26             : {
      27         343 :         do_hexmap_init(hexmap1, 4);
      28         343 :         do_hexmap_init(hexmap2, 0);
      29             :         md5str_to_bytes("D41D8CD98F00B204E9800998ECF8427E",
      30             :                 md5sum_of_empty_string);
      31         343 : }
      32             : 
      33       17386 : 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      227928 :         for(bpos=0, spos=0; bpos<len && str[spos]; )
      39             :         {
      40      193156 :                 if(str[spos]=='/')
      41             :                 {
      42       51012 :                         spos++;
      43       51012 :                         continue;
      44             :                 }
      45      142144 :                 bytes[bpos++] = hexmap1[(uint8_t)str[spos]]
      46      142144 :                         | hexmap2[(uint8_t)str[spos+1]];
      47      142144 :                 spos+=2;
      48             :         }
      49       17386 : }
      50             : 
      51          39 : void md5str_to_bytes(const char *md5str, uint8_t *bytes)
      52             : {
      53         382 :         str_to_bytes(md5str, bytes, MD5_DIGEST_LENGTH);
      54          39 : }
      55             : 
      56        7326 : char *bytes_to_md5str(uint8_t *bytes)
      57             : {
      58             :         static char str[64];
      59             :         snprintf(str, sizeof(str), "%016"PRIx64"%016"PRIx64,
      60       21978 :                 htobe64(*(uint64_t *)bytes), htobe64(*(uint64_t *)(bytes+8)));
      61        7326 :         return str;
      62             : }
      63             : 
      64       17004 : uint64_t savepathstr_with_sig_to_uint64(const char *savepathstr)
      65             : {
      66             :         uint8_t b[sizeof(uint64_t)];
      67       17004 :         str_to_bytes(savepathstr, b, sizeof(b));
      68       34008 :         return htobe64(*(uint64_t *)&b);
      69             : }
      70             : 
      71       17396 : static char *savepathstr_make(uint64_t *be_bytes)
      72             : {
      73             :         static char str[15];
      74       17396 :         uint8_t *b=(uint8_t *)be_bytes;
      75             :         snprintf(str, sizeof(str), "%02X%02X/%02X%02X/%02X%02X",
      76       17396 :                 b[0], b[1], b[2], b[3], b[4], b[5]);
      77       17396 :         return str;
      78             : }
      79             : 
      80       17043 : char *uint64_to_savepathstr(uint64_t bytes)
      81             : {
      82       17043 :         uint64_t be_bytes=htobe64(bytes);
      83       17043 :         return savepathstr_make(&be_bytes);
      84             : }
      85             : 
      86           5 : char *uint64_to_savepathstr_with_sig(uint64_t bytes)
      87             : {
      88             :         static char str[20];
      89           5 :         uint64_t be_bytes=htobe64(bytes);
      90           5 :         uint8_t *b=(uint8_t *)&be_bytes;
      91             :         snprintf(str, sizeof(str), "%02X%02X/%02X%02X/%02X%02X/%02X%02X",
      92           5 :                 b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7]);
      93           5 :         return str;
      94             : }
      95             : 
      96         353 : char *uint64_to_savepathstr_with_sig_uint(uint64_t bytes, uint16_t *sig)
      97             : {
      98             :         char *str;
      99         353 :         uint64_t be_bytes=htobe64(bytes);
     100         353 :         uint8_t *b=(uint8_t *)&be_bytes;
     101         353 :         str=savepathstr_make(&be_bytes);
     102         353 :         *sig = b[6] << 8;
     103         353 :         *sig |= b[7];
     104         353 :         return str;
     105             : }