salted.c

   1 #include <stdio.h>
   2 #include <sys/types.h>
   3 #include <time.h>
   4 #include <string.h>
   5 #include <stdbool.h>
   6
   7 #include "md5-cl.h"
   8 #include "b64-cl.h"
   9
  10 #include "hmacmd5.h"
  11
  12 #define SALT_MAX (5)
  13 #define PASS_MAX (32)
  14
  15 //void mangle(char * password)
  16 u32x mangle_md5 (u32x w0[4], u32x w1[4], const u32x in_len)
  17 {
  18         u32x out_len = in_len;
  19         u32 i;
  20
  21         u32x digest[4];
  22         u32x w0_t[4];
  23         u32x w1_t[4];
  24         u32x w2_t[4];
  25         u32x w3_t[4];
  26
  27         append_0x80_2x4_VV (w0, w1, out_len);
  28
  29         w0_t[0] = w0[0];
  30         w0_t[1] = w0[1];
  31         w0_t[2] = w0[2];
  32         w0_t[3] = w0[3];
  33         w1_t[0] = w1[0];
  34         w1_t[1] = w1[1];
  35         w1_t[2] = w1[2];
  36         w1_t[3] = w1[3];
  37         w2_t[0] = 0;
  38         w2_t[1] = 0;
  39         w2_t[2] = 0;
  40         w2_t[3] = 0;
  41         w3_t[0] = 0;
  42         w3_t[1] = 0;
  43         w3_t[2] = (out_len) * 8;
  44         w3_t[3] = 0;
  45
  46         digest[0] = MD5M_A;
  47         digest[1] = MD5M_B;
  48         digest[2] = MD5M_C;
  49         digest[3] = MD5M_D;
  50
  51         md5_transform (w0_t, w1_t, w2_t, w3_t, digest);
  52
  53         u8 b64encoded[16];
  54
  55 /*
  56         ((u8 *)digest)[0] = 0x87;
  57         ((u8 *)digest)[1] = 0x43;
  58         ((u8 *)digest)[2] = 0xb5;
  59         ((u8 *)digest)[3] = 0x20;
  60         ((u8 *)digest)[4] = 0x63;
  61         ((u8 *)digest)[5] = 0xcd;
  62 */
  63         out_len = b64_encode (b64encoded, 6, (u8 *)digest);
  64
  65         for (i = out_len; i < 16; i++) {
  66                 b64encoded[i] = 0;
  67         }
  68
  69 /*
  70         b64encoded[0] = 'h';
  71         b64encoded[1] = '0';
  72         b64encoded[2] = 'O';
  73         b64encoded[3] = '1';
  74         b64encoded[4] = 'I';
  75         b64encoded[5] = 'G';
  76         b64encoded[6] = 'P';
  77         b64encoded[7] = 'N';
  78 */
  79
  80
  81         w0[0] = ((u32x *)b64encoded)[0];
  82         w0[1] = ((u32x *)b64encoded)[1];
  83         w0[2] = ((u32x *)b64encoded)[2];
  84         w0[3] = ((u32x *)b64encoded)[3];
  85         w1[0] = 0;
  86         w1[1] = 0;
  87         w1[2] = 0;
  88         w1[3] = 0;
  89
  90         return (out_len);
  91 }
  92
  93 u32x mangle_hmac (u32x w0[4], u32x w1[4], const u32x in_len)
  94 {
  95         u32x out_len = in_len;
  96                 u32 digest[4];
  97                 u32 data[8];
  98                 u32 i;
  99
 100                 data[0] = w0[0];
 101                 data[1] = w0[1];
 102                 data[2] = w0[2];
 103                 data[3] = w0[3];
 104                 data[4] = w1[0];
 105                 data[5] = w1[1];
 106                 data[6] = w1[2];
 107                 data[7] = w1[3];
 108
 109                 md5hmac_cl("flypig.co.uk", strlen("flypig.co.uk"), (u8 *)data, in_len, (u8 *)digest);
 110
 111                 printf("HMAC: ");
 112                 for (i = 0; i < 16; i++) {
 113                         printf("%x", ((u8 *)digest)[i]);
 114                 }
 115                 printf("\n");
 116
 117                 w0[0] = digest[0];
 118                 w0[1] = digest[1];
 119                 w0[2] = digest[2];
 120                 w0[3] = digest[3];
 121                 w1[0] = 0;
 122                 w1[1] = 0;
 123                 w1[2] = 0;
 124                 w1[3] = 0;
 125
 126         out_len = b64_encode ((u8 *)data, 16, (u8 *)w0);
 127
 128         for (i = out_len; i < 32; i++) {
 129                 ((u8 *)data)[i] = 0;
 130         }
 131
 132                 w0[0] = data[0];
 133                 w0[1] = data[1];
 134                 w0[2] = data[2];
 135                 w0[3] = data[3];
 136                 w1[0] = data[4];
 137                 w1[1] = data[5];
 138                 w1[2] = data[6];
 139                 w1[3] = data[7];
 140
 141         return (out_len);
 142 }
 143
 144 int main(int argc, char * argv[]) {
 145         unsigned char result[RESULT_MAX];
 146         unsigned char salt[SALT_MAX];
 147         unsigned char digest[DIGEST_SIZE];
 148         unsigned char hash[DIGEST_SIZE * 2 + 1];
 149         size_t size;
 150         int pos;
 151         char password[PASS_MAX];
 152
 153         for (pos = 0; pos < PASS_MAX; pos++) {
 154                 password[pos] = 0;
 155         }
 156
 157         if (argc > 1) {
 158                 strncpy(password, argv[1], PASS_MAX);
 159         }
 160         else {
 161                 strncpy(password, "hashcat", PASS_MAX);
 162         }
 163         password[PASS_MAX - 1] = '\0';
 164
 165         if (argc > 2) {
 166                 strncpy(salt, argv[2], SALT_MAX);
 167         }
 168         else {
 169                 strncpy(salt, "1234", SALT_MAX);
 170         }
 171         salt[SALT_MAX - 1] = '\0';
 172
 173         SPH_HashedPassowrd("hashcat", "flypig.co.uk", result);
 174
 175         //mangle(password);
 176
 177         mangle_hmac ((u32x *)password, (u32x *)(password + 16), strlen(password));
 178
 179         //md5hmac(salt, password, digest);
 180
 181         md5hmac_cl(salt, strlen(salt), password, strlen(password), digest);
 182
 183
 184         for (pos = 0; pos < DIGEST_SIZE; pos++) {
 185                 writeHexByte(digest[pos], hash + (pos * 2));
 186         }
 187         hash[DIGEST_SIZE * 2] = '\0';
 188
 189         printf("(password, salt) = (\"%s\", \"%s\")\n", password, salt);
 190         printf("Result: %s:%s\n", hash, salt);
 191
 192         return 0;
 193 }
 194