2 * rcracki_mt is a multithreaded implementation and fork of the original
\r
5 * Copyright 2009, 2010 Daniƫl Niggebrugge <niggebrugge@fox-it.com>
\r
6 * Copyright 2009, 2010 James Nobis <frt@quelrod.net>
\r
8 * This file is part of rcracki_mt.
\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
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
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
24 #if defined(_WIN32) && !defined(__GNUC__)
\r
25 #pragma warning(disable : 4786 4267 4018)
\r
28 #include "rcrackiThread.h"
\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
33 t_TargetHash = TargetHash;
\r
34 t_nRainbowChainLen = nRainbowChainLen;
\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
43 // create job for false alarm checking
\r
44 rcrackiThread::rcrackiThread(unsigned char* pHash, bool oldFormat)
\r
46 falseAlarmChecker = true;
\r
47 falseAlarmCheckerO = oldFormat;
\r
48 t_pChainsFound.clear();
\r
49 t_nGuessedPoss.clear();
\r
51 t_nChainWalkStepDueToFalseAlarm = 0;
\r
56 void rcrackiThread::AddAlarmCheck(RainbowChain* pChain, int nGuessedPos)
\r
58 t_pChainsFound.push_back(pChain);
\r
59 t_nGuessedPoss.push_back(nGuessedPos);
\r
62 void rcrackiThread::AddAlarmCheckO(RainbowChainO* pChain, int nGuessedPos)
\r
64 t_pChainsFoundO.push_back(pChain);
\r
65 t_nGuessedPoss.push_back(nGuessedPos);
\r
68 // Windows (beginthreadex) way of threads
\r
69 //unsigned __stdcall rcrackiThread::rcrackiThreadStaticEntryPoint(void * pThis)
\r
71 // rcrackiThread* pTT = (rcrackiThread*)pThis;
\r
72 // pTT->rcrackiThreadEntryPoint();
\r
73 // _endthreadex( 2 );
\r
77 // entry point for the posix thread
\r
78 void * rcrackiThread::rcrackiThreadStaticEntryPointPthread(void * pThis)
\r
80 rcrackiThread* pTT = (rcrackiThread*)pThis;
\r
81 pTT->rcrackiThreadEntryPoint();
\r
86 // start processing of jobs
\r
87 void rcrackiThread::rcrackiThreadEntryPoint()
\r
89 if (falseAlarmChecker) {
\r
90 if (falseAlarmCheckerO) {
\r
102 uint64 rcrackiThread::GetIndex(int nPos)
\r
104 uint64 t_index = t_vStartPosIndexE[nPos - t_ID];
\r
108 int rcrackiThread::GetChainWalkStep()
\r
110 return t_nChainWalkStep;
\r
113 int rcrackiThread::GetIndexCount()
\r
115 return t_vStartPosIndexE.size();
\r
118 rcrackiThread::~rcrackiThread(void)
\r
122 void rcrackiThread::PreCalculate()
\r
124 //XXX is this correct for multiple threads?
\r
125 for (t_nPos = t_nRainbowChainLen - 2 - t_ID; t_nPos >= 0; t_nPos -= t_count)
\r
127 t_cwc.SetHash(t_TargetHash);
\r
128 t_cwc.HashToIndex(t_nPos);
\r
130 for (i = t_nPos + 1; i <= t_nRainbowChainLen - 2; i++)
\r
132 t_cwc.IndexToPlain();
\r
133 t_cwc.PlainToHash();
\r
134 t_cwc.HashToIndex(i);
\r
136 t_pStartPosIndexE[t_nPos] = t_cwc.GetIndex();
\r
137 t_nChainWalkStep += t_nRainbowChainLen - 2 - t_nPos;
\r
141 void rcrackiThread::CheckAlarm()
\r
144 for (i = 0; i < t_pChainsFound.size(); i++)
\r
146 RainbowChain* t_pChain = t_pChainsFound[i];
\r
147 int t_nGuessedPos = t_nGuessedPoss[i];
\r
149 CChainWalkContext cwc;
\r
150 //uint64 nIndexS = t_pChain->nIndexS & 0x0000FFFFFFFFFFFF; // for first 6 bytes
\r
151 //uint64 nIndexS = t_pChain->nIndexS >> 16;
\r
152 uint64 nIndexS = t_pChain->nIndexS & 0x0000FFFFFFFFFFFFULL; // for first 6 bytes
\r
153 cwc.SetIndex(nIndexS);
\r
154 //cwc.SetIndex(t_pChain->nIndexS);
\r
156 for (nPos = 0; nPos < t_nGuessedPos; nPos++)
\r
158 cwc.IndexToPlain();
\r
160 cwc.HashToIndex(nPos);
\r
162 cwc.IndexToPlain();
\r
164 if (cwc.CheckHash(t_pHash))
\r
166 t_Hash = cwc.GetHash();
\r
167 t_Plain = cwc.GetPlain();
\r
168 t_Binary = cwc.GetBinary();
\r
175 t_nChainWalkStepDueToFalseAlarm += t_nGuessedPos + 1;
\r
181 void rcrackiThread::CheckAlarmO()
\r
184 for (i = 0; i < t_pChainsFoundO.size(); i++)
\r
186 RainbowChainO* t_pChain = t_pChainsFoundO[i];
\r
187 int t_nGuessedPos = t_nGuessedPoss[i];
\r
189 CChainWalkContext cwc;
\r
191 uint64 nIndexS = t_pChain->nIndexS;
\r
192 cwc.SetIndex(nIndexS);
\r
195 for (nPos = 0; nPos < t_nGuessedPos; nPos++)
\r
197 cwc.IndexToPlain();
\r
199 cwc.HashToIndex(nPos);
\r
201 cwc.IndexToPlain();
\r
203 if (cwc.CheckHash(t_pHash))
\r
205 t_Hash = cwc.GetHash();
\r
206 t_Plain = cwc.GetPlain();
\r
207 t_Binary = cwc.GetBinary();
\r
214 t_nChainWalkStepDueToFalseAlarm += t_nGuessedPos + 1;
\r
220 bool rcrackiThread::FoundHash()
\r
225 int rcrackiThread::GetChainWalkStepDueToFalseAlarm()
\r
227 return t_nChainWalkStepDueToFalseAlarm;
\r
230 int rcrackiThread::GetnFalseAlarm()
\r
232 return t_nFalseAlarm;
\r
235 string rcrackiThread::GetHash()
\r
240 string rcrackiThread::GetPlain()
\r
245 string rcrackiThread::GetBinary()
\r