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

   1 /*\r
   2  * rcracki_mt is a multithreaded implementation and fork of the original \r
   3  * RainbowCrack\r
   4  *\r
   5  * Copyright 2009, 2010 Daniël Niggebrugge <niggebrugge@fox-it.com>\r
   6  * Copyright 2009, 2010 James Nobis <frt@quelrod.net>\r
   7  *\r
   8  * This file is part of rcracki_mt.\r
   9  *\r
  10  * rcracki_mt is free software: you can redistribute it and/or modify\r
  11  * it under the terms of the GNU General Public License as published by\r
  12  * the Free Software Foundation, either version 2 of the License, or\r
  13  * (at your option) any later version.\r
  14  *\r
  15  * rcracki_mt is distributed in the hope that it will be useful,\r
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  18  * GNU General Public License for more details.\r
  19  *\r
  20  * You should have received a copy of the GNU General Public License\r
  21  * along with rcracki_mt.  If not, see <http://www.gnu.org/licenses/>.\r
  22  */\r
  23 \r
  24 #if defined(_WIN32) && !defined(__GNUC__)\r
  25         #pragma warning(disable : 4786 4267 4018)\r
  26 #endif\r
  27 \r
  28 #include "rcrackiThread.h"\r
  29 \r
  30 // create job for pre-calculation\r
  31 rcrackiThread::rcrackiThread(unsigned char* TargetHash, int thread_id, int nRainbowChainLen, int thread_count, uint64* pStartPosIndexE)\r
  32 {\r
  33         t_TargetHash = TargetHash;\r
  34         t_nRainbowChainLen = nRainbowChainLen;\r
  35         t_ID = thread_id;\r
  36         t_count = thread_count;\r
  37         t_pStartPosIndexE = pStartPosIndexE;\r
  38         t_nChainWalkStep = 0;\r
  39         falseAlarmChecker = false;\r
  40         falseAlarmCheckerO = false;\r
  41 }\r
  42 \r
  43 // create job for false alarm checking\r
  44 rcrackiThread::rcrackiThread(unsigned char* pHash, bool oldFormat)\r
  45 {\r
  46         falseAlarmChecker = true;\r
  47         falseAlarmCheckerO = oldFormat;\r
  48         t_pChainsFound.clear();\r
  49         t_nGuessedPoss.clear();\r
  50         t_pHash = pHash;\r
  51         t_nChainWalkStepDueToFalseAlarm = 0;\r
  52         t_nFalseAlarm = 0;\r
  53         foundHash = false;\r
  54 }\r
  55 \r
  56 void rcrackiThread::AddAlarmCheck(RainbowChain* pChain, int nGuessedPos)\r
  57 {\r
  58         t_pChainsFound.push_back(pChain);\r
  59         t_nGuessedPoss.push_back(nGuessedPos);\r
  60 }\r
  61 \r
  62 void rcrackiThread::AddAlarmCheckO(RainbowChainO* pChain, int nGuessedPos)\r
  63 {\r
  64         t_pChainsFoundO.push_back(pChain);\r
  65         t_nGuessedPoss.push_back(nGuessedPos);\r
  66 }\r
  67 \r
  68 // Windows (beginthreadex) way of threads\r
  69 //unsigned __stdcall rcrackiThread::rcrackiThreadStaticEntryPoint(void * pThis)\r
  70 //{\r
  71 //      rcrackiThread* pTT = (rcrackiThread*)pThis;\r
  72 //      pTT->rcrackiThreadEntryPoint();\r
  73 //      _endthreadex( 2 );\r
  74 //      return 2;\r
  75 //}\r
  76 \r
  77 // entry point for the posix thread\r
  78 void * rcrackiThread::rcrackiThreadStaticEntryPointPthread(void * pThis)\r
  79 {\r
  80         rcrackiThread* pTT = (rcrackiThread*)pThis;\r
  81         pTT->rcrackiThreadEntryPoint();\r
  82         pthread_exit(NULL);\r
  83         return NULL;\r
  84 }\r
  85 \r
  86 // start processing of jobs\r
  87 void rcrackiThread::rcrackiThreadEntryPoint()\r
  88 {\r
  89         if (falseAlarmChecker) {\r
  90                 if (falseAlarmCheckerO) {\r
  91                         CheckAlarmO();\r
  92                 }\r
  93                 else {\r
  94                         CheckAlarm();\r
  95                 }\r
  96         }\r
  97         else {\r
  98                 PreCalculate();\r
  99         }\r
 100 }\r
 101 \r
 102 uint64 rcrackiThread::GetIndex(int nPos)\r
 103 {\r
 104         uint64 t_index = t_vStartPosIndexE[nPos - t_ID];\r
 105         return t_index;\r
 106 }\r
 107 \r
 108 int rcrackiThread::GetChainWalkStep()\r
 109 {\r
 110         return t_nChainWalkStep;\r
 111 }\r
 112 \r
 113 int rcrackiThread::GetIndexCount()\r
 114 {\r
 115         return t_vStartPosIndexE.size();\r
 116 }\r
 117 \r
 118 rcrackiThread::~rcrackiThread(void)\r
 119 {\r
 120 }\r
 121 \r
 122 void rcrackiThread::PreCalculate()\r
 123 {\r
 124         for (t_nPos = t_nRainbowChainLen - 2 - t_ID; t_nPos >= 0; t_nPos -= t_count)\r
 125         {\r
 126                 t_cwc.SetHash(t_TargetHash);\r
 127                 t_cwc.HashToIndex(t_nPos);\r
 128                 int i;\r
 129                 for (i = t_nPos + 1; i <= t_nRainbowChainLen - 2; i++)\r
 130                 {\r
 131                         t_cwc.IndexToPlain();\r
 132                         t_cwc.PlainToHash();\r
 133                         t_cwc.HashToIndex(i);\r
 134                 }\r
 135                 t_pStartPosIndexE[t_nPos] = t_cwc.GetIndex();\r
 136                 t_nChainWalkStep += t_nRainbowChainLen - 2 - t_nPos;\r
 137         }\r
 138 }\r
 139 \r
 140 void rcrackiThread::CheckAlarm()\r
 141 {\r
 142         uint32 i;\r
 143         for (i = 0; i < t_pChainsFound.size(); i++)\r
 144         {\r
 145                 RainbowChain* t_pChain = t_pChainsFound[i];\r
 146                 int t_nGuessedPos = t_nGuessedPoss[i];          \r
 147                 \r
 148                 CChainWalkContext cwc;\r
 149                 //uint64 nIndexS = t_pChain->nIndexS & 0x0000FFFFFFFFFFFF; // for first 6 bytes\r
 150                 //uint64 nIndexS = t_pChain->nIndexS >> 16;\r
 151                 uint64 nIndexS = t_pChain->nIndexS & 0x0000FFFFFFFFFFFFULL; // for first 6 bytes\r
 152                 cwc.SetIndex(nIndexS);\r
 153                 //cwc.SetIndex(t_pChain->nIndexS);      \r
 154                 int nPos;\r
 155                 for (nPos = 0; nPos < t_nGuessedPos; nPos++)\r
 156                 {\r
 157                         cwc.IndexToPlain();\r
 158                         cwc.PlainToHash();\r
 159                         cwc.HashToIndex(nPos);\r
 160                 }\r
 161                 cwc.IndexToPlain();\r
 162                 cwc.PlainToHash();\r
 163                 if (cwc.CheckHash(t_pHash))\r
 164                 {\r
 165                         t_Hash = cwc.GetHash();\r
 166                         t_Plain = cwc.GetPlain();\r
 167                         t_Binary = cwc.GetBinary();\r
 168 \r
 169                         foundHash = true;\r
 170                         break;\r
 171                 }\r
 172                 else {\r
 173                         foundHash = false;\r
 174                         t_nChainWalkStepDueToFalseAlarm += t_nGuessedPos + 1;\r
 175                         t_nFalseAlarm++;\r
 176                 }\r
 177         }\r
 178 }\r
 179 \r
 180 void rcrackiThread::CheckAlarmO()\r
 181 {\r
 182         uint32 i;\r
 183         for (i = 0; i < t_pChainsFoundO.size(); i++)\r
 184         {\r
 185                 RainbowChainO* t_pChain = t_pChainsFoundO[i];\r
 186                 int t_nGuessedPos = t_nGuessedPoss[i];          \r
 187                 \r
 188                 CChainWalkContext cwc;\r
 189 \r
 190                 uint64 nIndexS = t_pChain->nIndexS;\r
 191                 cwc.SetIndex(nIndexS);\r
 192 \r
 193                 int nPos;\r
 194                 for (nPos = 0; nPos < t_nGuessedPos; nPos++)\r
 195                 {\r
 196                         cwc.IndexToPlain();\r
 197                         cwc.PlainToHash();\r
 198                         cwc.HashToIndex(nPos);\r
 199                 }\r
 200                 cwc.IndexToPlain();\r
 201                 cwc.PlainToHash();\r
 202                 if (cwc.CheckHash(t_pHash))\r
 203                 {\r
 204                         t_Hash = cwc.GetHash();\r
 205                         t_Plain = cwc.GetPlain();\r
 206                         t_Binary = cwc.GetBinary();\r
 207 \r
 208                         foundHash = true;\r
 209                         break;\r
 210                 }\r
 211                 else {\r
 212                         foundHash = false;\r
 213                         t_nChainWalkStepDueToFalseAlarm += t_nGuessedPos + 1;\r
 214                         t_nFalseAlarm++;\r
 215                 }\r
 216         }\r
 217 }\r
 218 \r
 219 bool rcrackiThread::FoundHash()\r
 220 {\r
 221         return foundHash;\r
 222 }\r
 223 \r
 224 int rcrackiThread::GetChainWalkStepDueToFalseAlarm()\r
 225 {\r
 226         return t_nChainWalkStepDueToFalseAlarm;\r
 227 }\r
 228 \r
 229 int rcrackiThread::GetnFalseAlarm()\r
 230 {\r
 231         return t_nFalseAlarm;\r
 232 }\r
 233 \r
 234 string rcrackiThread::GetHash()\r
 235 {\r
 236         return t_Hash;\r
 237 }\r
 238 \r
 239 string rcrackiThread::GetPlain()\r
 240 {\r
 241         return t_Plain;\r
 242 }\r
 243 \r
 244 string rcrackiThread::GetBinary()\r
 245 {\r
 246         return t_Binary;\r
 247 }\r