perf/random_hashing.cpp

   1 #include <string.h>
   2 #include <stdio.h>
   3 #include <algorithm>
   4
   5 #include <iostream>
   6
   7 #include "sha1.h"
   8 #include "ubc_check.h"
   9
  10 #include "test_util_lib.h"
  11
  12 using namespace std;
  13
  14 int GenRandomBytes(
  15         unsigned char*  pb,
  16         size_t                  cb,
  17         br::mt19937             &rng)
  18 {
  19         size_t i;
  20
  21         for (i = 0; i < cb; i++)
  22         {
  23                 pb[i] = (unsigned char)rng();
  24         }
  25
  26         return i;
  27
  28 }
  29
  30 int HashRandomBytes(
  31         size_t                  cntBytesToHash,
  32         unsigned int    uiSeed)
  33 {
  34         unsigned char hash[20];
  35
  36         unsigned char buffer_to_hash[64];
  37
  38         SHA1_CTX ctx;
  39
  40         int i = cntBytesToHash;
  41
  42         br::mt19937 rng(uiSeed);
  43         cout << "Hashing...";
  44         SHA1DCInit(&ctx);
  45
  46         while (0 < i)
  47         {
  48                 unsigned int cb = min(64, i);
  49
  50                 cb = GenRandomBytes(buffer_to_hash, cb, rng);
  51
  52                 SHA1DCUpdate(&ctx, (char *)buffer_to_hash, cb);
  53
  54                 i -= cb;
  55         }
  56
  57         SHA1DCFinal(hash, &ctx);
  58
  59         cout << "Done." << endl;
  60
  61         if (ctx.found_collision)
  62         {
  63                 cout << "Collision found." << endl;
  64         }
  65
  66         return 0;
  67
  68 }
  69
  70 int UBCVerifyRandomBytes(
  71         size_t                  cntBytesToHash,
  72         unsigned int    uiSeed)
  73 {
  74         unsigned char buffer_to_hash[64];
  75
  76         uint32_t expanded_message[80];
  77
  78         uint32_t dvmask[1] = { 0 };
  79         uint32_t dvmask_verify[1] = { 0 };
  80
  81         int i = cntBytesToHash;
  82
  83         br::mt19937 rng(uiSeed);
  84         cout << "Unavoidable bit checking...";
  85
  86         while (0 < i)
  87         {
  88                 unsigned int cb = min(64, i);
  89
  90                 cb = GenRandomBytes(buffer_to_hash, cb, rng);
  91
  92                 memset(dvmask, 0, sizeof(dvmask));
  93                 memset(dvmask_verify, 0, sizeof(dvmask_verify));
  94
  95                 sha1_compression_W((uint32_t*)buffer_to_hash, expanded_message);
  96
  97                 ubc_check(expanded_message, dvmask);
  98                 //ubc_check_verify(expanded_message, dvmask_verify);
  99
 100                 if (0 != memcmp(dvmask, dvmask_verify, sizeof(dvmask)))
 101                 {
 102                         printf("Calculated dvmask does not equal dvmask verify output.\n");
 103                 }
 104
 105                 i -= cb;
 106         }
 107
 108         cout << "Done." << endl;
 109
 110         return 0;
 111 }