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         620 : static void do_hexmap_init(uint8_t *hexmap, uint8_t shift)
      16             : {
      17             :         uint8_t i;
      18             :         uint8_t h;
      19         620 :         memset(hexmap, 0, HEXMAP_SIZE);
      20         620 :         for(i='0', h=0x00; i<='9'; i++, h++) hexmap[i]=h<<shift;
      21         620 :         for(i='a', h=0x0A; i<='f'; i++, h++) hexmap[i]=h<<shift;
      22         620 :         for(i='A', h=0x0A; i<='F'; i++, h++) hexmap[i]=h<<shift;
      23         620 : }
      24             : 
      25         310 : void hexmap_init(void)
      26             : {
      27         310 :         do_hexmap_init(hexmap1, 4);
      28         310 :         do_hexmap_init(hexmap2, 0);
      29             :         md5str_to_bytes("D41D8CD98F00B204E9800998ECF8427E",
      30         310 :                 md5sum_of_empty_string);
      31         310 : }
      32             : 
      33        8526 : 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      112488 :         for(bpos=0, spos=0; bpos<len && str[spos]; )
      39             :         {
      40       95436 :                 if(str[spos]=='/')
      41             :                 {
      42       24588 :                         spos++;
      43       24588 :                         continue;
      44             :                 }
      45       70848 :                 bytes[bpos++] = hexmap1[(uint8_t)str[spos]]
      46       70848 :                         | hexmap2[(uint8_t)str[spos+1]];
      47       70848 :                 spos+=2;
      48             :         }
      49        8526 : }
      50             : 
      51         330 : void md5str_to_bytes(const char *md5str, uint8_t *bytes)
      52             : {
      53         330 :         str_to_bytes(md5str, bytes, MD5_DIGEST_LENGTH);
      54         330 : }
      55             : 
      56        7302 : char *bytes_to_md5str(uint8_t *bytes)
      57             : {
      58             :         static char str[64];
      59             :         snprintf(str, sizeof(str), "%016"PRIx64"%016"PRIx64,
      60        7302 :                 htobe64(*(uint64_t *)bytes), htobe64(*(uint64_t *)(bytes+8)));
      61        7302 :         return str;
      62             : }
      63             : 
      64        8196 : uint64_t savepathstr_with_sig_to_uint64(const char *savepathstr)
      65             : {
      66             :         uint8_t b[sizeof(uint64_t)];
      67        8196 :         str_to_bytes(savepathstr, b, sizeof(b));
      68        8196 :         return htobe64(*(uint64_t *)&b);
      69             : }
      70             : 
      71        8238 : static char *savepathstr_make(uint64_t *be_bytes)
      72             : {
      73             :         static char str[15];
      74        8238 :         uint8_t *b=(uint8_t *)be_bytes;
      75             :         snprintf(str, sizeof(str), "%02X%02X/%02X%02X/%02X%02X",
      76        8238 :                 b[0], b[1], b[2], b[3], b[4], b[5]);
      77        8238 :         return str;
      78             : }
      79             : 
      80        8233 : char *uint64_to_savepathstr(uint64_t bytes)
      81             : {
      82        8233 :         uint64_t be_bytes=htobe64(bytes);
      83        8233 :         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           5 : char *uint64_to_savepathstr_with_sig_uint(uint64_t bytes, uint16_t *sig)
      97             : {
      98             :         char *str;
      99           5 :         uint64_t be_bytes=htobe64(bytes);
     100           5 :         uint8_t *b=(uint8_t *)&be_bytes;
     101           5 :         str=savepathstr_make(&be_bytes);
     102           5 :         *sig = b[6] << 8;
     103           5 :         *sig |= b[7];
     104           5 :         return str;
     105             : }