git.sesse.net Git - freerainbowtables/blob - Client Applications/rcracki_mt/rcrackiThread.cpp

   1 #ifdef _WIN32
   2         #pragma warning(disable : 4786 4267 4018)
   3 #endif
   4
   5 #include "rcrackiThread.h"
   6
   7 // create job for pre-calculation
   8 rcrackiThread::rcrackiThread(unsigned char* TargetHash, int thread_id, int nRainbowChainLen, int thread_count, uint64* pStartPosIndexE)
   9 {
  10         t_TargetHash = TargetHash;
  11         t_nRainbowChainLen = nRainbowChainLen;
  12         t_ID = thread_id;
  13         t_count = thread_count;
  14         t_pStartPosIndexE = pStartPosIndexE;
  15         t_nChainWalkStep = 0;
  16         falseAlarmChecker = false;
  17         falseAlarmCheckerO = false;
  18 }
  19
  20 // create job for false alarm checking
  21 rcrackiThread::rcrackiThread(unsigned char* pHash)
  22 {
  23         falseAlarmChecker = true;
  24         falseAlarmCheckerO = false;
  25         t_pChainsFound.clear();
  26         t_nGuessedPoss.clear();
  27         t_pHash = pHash;
  28         t_nChainWalkStepDueToFalseAlarm = 0;
  29         t_nFalseAlarm = 0;
  30         foundHash = false;
  31 }
  32
  33 // create job for false alarm checking OLD format
  34 rcrackiThread::rcrackiThread(unsigned char* pHash, bool oldFormat)
  35 {
  36         falseAlarmChecker = true;
  37         falseAlarmCheckerO = true;
  38         t_pChainsFoundO.clear();
  39         t_nGuessedPoss.clear();
  40         t_pHash = pHash;
  41         t_nChainWalkStepDueToFalseAlarm = 0;
  42         t_nFalseAlarm = 0;
  43         foundHash = false;
  44 }
  45
  46
  47 void rcrackiThread::AddAlarmCheck(RainbowChain* pChain, int nGuessedPos)
  48 {
  49         t_pChainsFound.push_back(pChain);
  50         t_nGuessedPoss.push_back(nGuessedPos);
  51 }
  52
  53 void rcrackiThread::AddAlarmCheckO(RainbowChainO* pChain, int nGuessedPos)
  54 {
  55         t_pChainsFoundO.push_back(pChain);
  56         t_nGuessedPoss.push_back(nGuessedPos);
  57 }
  58
  59 // Windows (beginthreadex) way of threads
  60 //unsigned __stdcall rcrackiThread::rcrackiThreadStaticEntryPoint(void * pThis)
  61 //{
  62 //      rcrackiThread* pTT = (rcrackiThread*)pThis;
  63 //      pTT->rcrackiThreadEntryPoint();
  64 //      _endthreadex( 2 );
  65 //      return 2;
  66 //}
  67
  68 // entry point for the posix thread
  69 void * rcrackiThread::rcrackiThreadStaticEntryPointPthread(void * pThis)
  70 {
  71         rcrackiThread* pTT = (rcrackiThread*)pThis;
  72         pTT->rcrackiThreadEntryPoint();
  73         pthread_exit(NULL);
  74         return NULL;
  75 }
  76
  77 // start processing of jobs
  78 void rcrackiThread::rcrackiThreadEntryPoint()
  79 {
  80         if (falseAlarmChecker) {
  81                 if (falseAlarmCheckerO) {
  82                         CheckAlarmO();
  83                 }
  84                 else {
  85                         CheckAlarm();
  86                 }
  87         }
  88         else {
  89                 PreCalculate();
  90         }
  91 }
  92
  93 uint64 rcrackiThread::GetIndex(int nPos)
  94 {
  95         uint64 t_index = t_vStartPosIndexE[nPos - t_ID];
  96         return t_index;
  97 }
  98
  99 int rcrackiThread::GetChainWalkStep()
 100 {
 101         return t_nChainWalkStep;
 102 }
 103
 104 int rcrackiThread::GetIndexCount()
 105 {
 106         return t_vStartPosIndexE.size();
 107 }
 108
 109 rcrackiThread::~rcrackiThread(void)
 110 {
 111 }
 112
 113 void rcrackiThread::PreCalculate()
 114 {
 115         for (t_nPos = t_nRainbowChainLen - 2 - t_ID; t_nPos >= 0; t_nPos -= t_count)
 116         {
 117                 t_cwc.SetHash(t_TargetHash);
 118                 t_cwc.HashToIndex(t_nPos);
 119                 int i;
 120                 for (i = t_nPos + 1; i <= t_nRainbowChainLen - 2; i++)
 121                 //for (i = t_nPos + 1; i <= 10; i++)
 122                 {
 123                         t_cwc.IndexToPlain();
 124                         t_cwc.PlainToHash();
 125                         t_cwc.HashToIndex(i);
 126                 }
 127                 t_pStartPosIndexE[t_nPos] = t_cwc.GetIndex();
 128                 t_nChainWalkStep += t_nRainbowChainLen - 2 - t_nPos;
 129         }
 130 }
 131
 132 void rcrackiThread::CheckAlarm()
 133 {
 134         int i;
 135         for (i = 0; i < t_pChainsFound.size(); i++)
 136         {
 137                 RainbowChain* t_pChain = t_pChainsFound[i];
 138                 int t_nGuessedPos = t_nGuessedPoss[i];
 139
 140                 CChainWalkContext cwc;
 141                 //uint64 nIndexS = t_pChain->nIndexS & 0x0000FFFFFFFFFFFF; // for first 6 bytes
 142                 //uint64 nIndexS = t_pChain->nIndexS >> 16;
 143                 uint64 nIndexS = t_pChain->nIndexS & 0x0000FFFFFFFFFFFFULL; // for first 6 bytes
 144                 cwc.SetIndex(nIndexS);
 145                 //cwc.SetIndex(t_pChain->nIndexS);
 146                 int nPos;
 147                 for (nPos = 0; nPos < t_nGuessedPos; nPos++)
 148                 {
 149                         cwc.IndexToPlain();
 150                         cwc.PlainToHash();
 151                         cwc.HashToIndex(nPos);
 152                 }
 153                 cwc.IndexToPlain();
 154                 cwc.PlainToHash();
 155                 if (cwc.CheckHash(t_pHash))
 156                 {
 157                         t_Hash = cwc.GetHash();
 158                         t_Plain = cwc.GetPlain();
 159                         t_Binary = cwc.GetBinary();
 160
 161                         foundHash = true;
 162                         break;
 163                 }
 164                 else {
 165                         foundHash = false;
 166                         t_nChainWalkStepDueToFalseAlarm += t_nGuessedPos + 1;
 167                         t_nFalseAlarm++;
 168                 }
 169         }
 170 }
 171
 172 void rcrackiThread::CheckAlarmO()
 173 {
 174         int i;
 175         for (i = 0; i < t_pChainsFoundO.size(); i++)
 176         {
 177                 RainbowChainO* t_pChain = t_pChainsFoundO[i];
 178                 int t_nGuessedPos = t_nGuessedPoss[i];
 179
 180                 CChainWalkContext cwc;
 181
 182                 uint64 nIndexS = t_pChain->nIndexS;
 183                 cwc.SetIndex(nIndexS);
 184
 185                 int nPos;
 186                 for (nPos = 0; nPos < t_nGuessedPos; nPos++)
 187                 {
 188                         cwc.IndexToPlain();
 189                         cwc.PlainToHash();
 190                         cwc.HashToIndex(nPos);
 191                 }
 192                 cwc.IndexToPlain();
 193                 cwc.PlainToHash();
 194                 if (cwc.CheckHash(t_pHash))
 195                 {
 196                         t_Hash = cwc.GetHash();
 197                         t_Plain = cwc.GetPlain();
 198                         t_Binary = cwc.GetBinary();
 199
 200                         foundHash = true;
 201                         break;
 202                 }
 203                 else {
 204                         foundHash = false;
 205                         t_nChainWalkStepDueToFalseAlarm += t_nGuessedPos + 1;
 206                         t_nFalseAlarm++;
 207                 }
 208         }
 209 }
 210
 211 bool rcrackiThread::FoundHash()
 212 {
 213         return foundHash;
 214 }
 215
 216 int rcrackiThread::GetChainWalkStepDueToFalseAlarm()
 217 {
 218         return t_nChainWalkStepDueToFalseAlarm;
 219 }
 220
 221 int rcrackiThread::GetnFalseAlarm()
 222 {
 223         return t_nFalseAlarm;
 224 }
 225
 226 string rcrackiThread::GetHash()
 227 {
 228         return t_Hash;
 229 }
 230
 231 string rcrackiThread::GetPlain()
 232 {
 233         return t_Plain;
 234 }
 235
 236 string rcrackiThread::GetBinary()
 237 {
 238         return t_Binary;
 239 }