rcracki-mt-0.7.0/0000755000175000017500000000000012070347617013067 5ustar dookiedookiercracki-mt-0.7.0/rcracki_mt/0000750000175000017500000000000012070347540015173 5ustar dookiedookiercracki-mt-0.7.0/rcracki_mt/keyspace.cpp0000640000175000017500000005557212043323152017513 0ustar dookiedookie/* * This file is part of Advanced RTGen. * Copyright (C) 2011 Steve Thomas * Copyright 2011, 2012 James Nobis * * Advanced RTGen is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Advanced RTGen is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Advanced RTGen. If not, see . */ #include "Public.h" #include "keyspace.h" #include #include #include #include #include #include #include #include #ifndef UINT64_C #ifdef _WIN32 #define UINT64_C(c) (c) #else #define UINT64_C(c) c##ull #endif #endif KeySpace::KeySpace(const KeySpace &ks) { copyObject(ks); } KeySpace *KeySpace::init(std::list > subKeySpaces, uint32_t charaterEncoding) { uint64_t keySpace, keySpaceBoundary = 0; KeySpace *ks = new KeySpace(); std::list uniqueCharSets; std::list::iterator uniqueCharSetsIt; std::list::reverse_iterator charSetItRev; std::list::iterator charSetIt; std::list >::iterator subKeySpaceIt; uint32_t a, b, charSetLen = 0, maxPwLen = 1, minPwLen = 0xffffffff; int charSetDiffLen; ks->m_curSubKeySpace = 0; ks->m_numSubKeySpaces = subKeySpaces.size(); ks->m_charaterEncoding = charaterEncoding; ks->m_offset = 0; if ((charaterEncoding & CE_UTF16_BE) != 0) { ks->m_offset = 1; } else if ((charaterEncoding & CE_UTF32_BE) != 0) { ks->m_offset = 3; } ks->m_keySpaceBoundaries = new uint64_t [ks->m_numSubKeySpaces + 1]; ks->m_passwordLengths = new uint32_t [ks->m_numSubKeySpaces]; ks->m_divShortCut = new uint32_t [ks->m_numSubKeySpaces]; ks->m_numShortCutChars = new int [ks->m_numSubKeySpaces]; ks->m_charSetLengths = new uint32_t*[ks->m_numSubKeySpaces]; ks->m_subKeySpaces = new char** [ks->m_numSubKeySpaces]; ks->m_keySpaceBoundaries[0] = 0; for (a = 0, subKeySpaceIt = subKeySpaces.begin(); subKeySpaceIt != subKeySpaces.end(); ++subKeySpaceIt, a++) { if (maxPwLen < subKeySpaceIt->size()) { maxPwLen = subKeySpaceIt->size(); } if (minPwLen > subKeySpaceIt->size()) { minPwLen = subKeySpaceIt->size(); } keySpace = 1; ks->m_passwordLengths[a] = subKeySpaceIt->size(); ks->m_charSetLengths[a] = new uint32_t[subKeySpaceIt->size()]; for (b = subKeySpaceIt->size() - 1, charSetItRev = subKeySpaceIt->rbegin(); charSetItRev != subKeySpaceIt->rend(); ++charSetItRev, b--) { // Calculate key space keySpace *= charSetItRev->length(); if (keySpace < UINT64_C(0x100000000)) { ks->m_divShortCut[a] = (uint32_t) keySpace; ks->m_numShortCutChars[a] = subKeySpaceIt->size() - b; } // Find unique character sets ks->m_charSetLengths[a][b] = charSetItRev->length(); for (uniqueCharSetsIt = uniqueCharSets.begin(); uniqueCharSetsIt != uniqueCharSets.end(); ++uniqueCharSetsIt) { charSetDiffLen = ks->m_charSetLengths[a][b] - uniqueCharSetsIt->length(); if (charSetDiffLen > 0) { if (charSetItRev->find(*uniqueCharSetsIt) != std::string::npos) { *uniqueCharSetsIt = *charSetItRev; charSetLen += charSetDiffLen; break; } } else if (charSetDiffLen < 0) { if (uniqueCharSetsIt->find(*charSetItRev) != std::string::npos) { break; } } else if (*uniqueCharSetsIt == *charSetItRev) { break; } } if (uniqueCharSetsIt == uniqueCharSets.end()) { uniqueCharSets.push_back(charSetItRev->c_str()); charSetLen += charSetItRev->length(); } } if (keySpace == ks->m_divShortCut[a]) { ks->m_numShortCutChars[a] = 0; } else if (keySpace / ks->m_divShortCut[a] >= UINT64_C(0x100000000)) { ks->m_numShortCutChars[a] = -ks->m_numShortCutChars[a]; } keySpaceBoundary += keySpace; ks->m_keySpaceBoundaries[a + 1] = keySpaceBoundary; } ks->m_keySpace = keySpaceBoundary; ks->m_maxPwLen = maxPwLen; ks->m_minPwLen = minPwLen; ks->m_charSetPoses = new uint32_t[maxPwLen]; ks->m_charSetPosesTemp = new uint32_t[maxPwLen]; for (a = 0; a < maxPwLen; a++) { ks->m_charSetPoses[0] = 0; } if ((ks->m_charaterEncoding & CE_80_NULL_PADDED) != 0) { maxPwLen++; } if ((ks->m_charaterEncoding & (CE_UTF16_LE | CE_UTF16_BE)) != 0) { maxPwLen *= 2; } else if ((ks->m_charaterEncoding & (CE_UTF32_LE | CE_UTF32_BE)) != 0) { maxPwLen *= 4; } else if ((ks->m_charaterEncoding & CE_ASCII_BIN8) == 0) { fprintf(stderr, "Charater encoding not supported\n"); delete ks; return NULL; } maxPwLen = (maxPwLen + 3) / 4; ks->m_pwBlocks = maxPwLen; ks->m_pw = new uint32_t[maxPwLen + 1]; ks->m_pwTemp = new uint32_t[maxPwLen + 1]; ks->m_charSet = new char[charSetLen + 1]; ks->m_charSet[charSetLen] = 0; a = 0; for (uniqueCharSetsIt = uniqueCharSets.begin(); uniqueCharSetsIt != uniqueCharSets.end(); ++uniqueCharSetsIt) { charSetLen = uniqueCharSetsIt->length(); memcpy(ks->m_charSet + a, uniqueCharSetsIt->c_str(), charSetLen); a += charSetLen; } uniqueCharSets.clear(); for (a = 0, subKeySpaceIt = subKeySpaces.begin(); subKeySpaceIt != subKeySpaces.end(); ++subKeySpaceIt, a++) { ks->m_subKeySpaces[a] = new char*[subKeySpaceIt->size()]; for (b = 0, charSetIt = subKeySpaceIt->begin(); charSetIt != subKeySpaceIt->end(); ++charSetIt, b++) { ks->m_subKeySpaces[a][b] = strstr(ks->m_charSet, charSetIt->c_str()); } } ks->m_name = "inline"; ks->reset(0); return ks; } KeySpace::~KeySpace() { cleanUp(); } KeySpace *KeySpace::load(const char *fileName, uint32_t charaterEncoding) { std::vector lines; std::ifstream fin(fileName, std::ifstream::in); std::string line, name, charSet; std::map charSets; std::map::iterator charSetMapIt; std::list subKeySpace; std::list > subKeySpaces; std::list::iterator charSetIt; std::list >::iterator subKeySpaceIt; size_t pos, pos2; uint32_t len, lineNumber = 0; bool multiCharNames = false; char ch[2] = {0, 0}; #ifdef BOINC if (!boinc_ReadLinesFromFile(fileName, lines)) #else if (!ReadLinesFromFile(fileName, lines)) #endif { fprintf(stderr, "ERROR: Can't open key space file '%s'\n", fileName); return NULL; } // Read character sets while (1) { // Read line if (lineNumber >= lines.size()) { // eof fprintf(stderr, "ERROR: '%s' is not a valid key space file\n", fileName); return NULL; } line = lines[lineNumber]; lineNumber++; if (line.length() == 0 || line[0] == '#') { continue; } if (line[line.length() - 1] != ']') { break; } // Get character set name pos = line.find_first_of(" \t", 0, 2); if (pos == std::string::npos) { break; } name = line.substr(0, pos); // Get character set pos = line.find_first_not_of(" \t", pos, 2); if (pos == std::string::npos) { break; // this is not even possible... meh } if (line[pos] == '[') { charSet = line.substr(pos + 1, line.length() - pos - 2); } else if (line[pos] == 'h' && line[pos + 1] == '[') { charSet = HexToStr((unsigned char*)line.substr(pos + 2, line.length() - pos - 3).c_str(), line.length() - pos - 3); if (charSet.length() == 0 && line.length() - pos - 3 != 0) { fprintf(stderr, "ERROR: '%s' has an invalid character set on line #%u\n", fileName, lineNumber); return NULL; } } else { break; } if (charSet.length() == 0) { fprintf(stderr, "ERROR: '%s' has an empty character set on line #%u\n", fileName, lineNumber); return NULL; } // Insert into map if (charSets.find(name) == charSets.end()) { if (name.length() != 1) { multiCharNames = true; } charSets[name] = charSet; } else { fprintf(stderr, "ERROR: '%s' has a duplicate character set name on line #%u\n", fileName, lineNumber); return NULL; } } if (line[line.length() - 1] == ']') { fprintf(stderr, "ERROR line #%u: '%s' is not a valid key space file\n", lineNumber, fileName); return NULL; } // Read sub key spaces do { if (multiCharNames) { pos = 0; while (pos != std::string::npos) { // Get character set name pos2 = line.find_first_of(" \t", pos, 2); if (pos2 == std::string::npos) { pos2 = line.length(); } name = line.substr(pos, pos2 - pos); // Get character set charSetMapIt = charSets.find(name); if (charSetMapIt == charSets.end()) { fprintf(stderr, "ERROR: Character set name '%s' not found on line #%u from key space file '%s'\n", name.c_str(), lineNumber, fileName); return NULL; } subKeySpace.push_back(charSetMapIt->second); if (pos2 == line.length()) { break; } pos = line.find_first_not_of(" \t", pos2, 2); } } else { len = line.length(); for (pos = 0; pos < len; pos++) { *ch = line[pos]; if (*ch != ' ' && *ch != '\t') { charSetMapIt = charSets.find(ch); if (charSetMapIt == charSets.end()) { fprintf(stderr, "ERROR: Character set name '%c' not found on line #%u from key space file '%s'\n", *ch, lineNumber, fileName); return NULL; } subKeySpace.push_back(charSetMapIt->second); } } } subKeySpaces.push_back(subKeySpace); subKeySpace.clear(); // Read line do { if (lineNumber >= lines.size()) { line = ""; break; // eof } line = lines[lineNumber]; lineNumber++; } while ((line.length() == 0 || line[0] == '#')); } while (line.length() != 0); KeySpace *ks = KeySpace::init(subKeySpaces, charaterEncoding); if (ks != NULL) { ks->m_name = fileName; } return ks; } KeySpace *KeySpace::load(std::list > subKeySpaces, uint32_t charaterEncoding) { return KeySpace::init(subKeySpaces, charaterEncoding); } KeySpace& KeySpace::operator=(const KeySpace &ks) { if (this != &ks) { cleanUp(); copyObject(ks); } return *this; } void KeySpace::cleanUp() { uint32_t a; for (a = 0; a < m_numSubKeySpaces; a++) { delete [] m_subKeySpaces[a]; delete [] m_charSetLengths[a]; } delete [] m_keySpaceBoundaries; delete [] m_passwordLengths; delete [] m_divShortCut; delete [] m_numShortCutChars; delete [] m_charSetPoses; delete [] m_charSetPosesTemp; delete [] m_charSetLengths; delete [] m_charSet; delete [] m_subKeySpaces; delete [] m_pw; delete [] m_pwTemp; } void KeySpace::copyObject(const KeySpace &ks) { uint32_t a, b, tmp, charSetLen = 1; m_keySpace = ks.m_keySpace; m_numSubKeySpaces = ks.m_numSubKeySpaces; m_curSubKeySpace = ks.m_curSubKeySpace; m_maxPwLen = ks.m_maxPwLen; m_minPwLen = ks.m_minPwLen; m_charaterEncoding = ks.m_charaterEncoding; m_offset = ks.m_offset; m_pwBlocks = ks.m_pwBlocks; m_name = ks.m_name; m_keySpaceBoundaries = new uint64_t [m_numSubKeySpaces + 1]; m_passwordLengths = new uint32_t [m_numSubKeySpaces]; m_divShortCut = new uint32_t [m_numSubKeySpaces]; m_numShortCutChars = new int [m_numSubKeySpaces]; m_charSetLengths = new uint32_t*[m_numSubKeySpaces]; m_subKeySpaces = new char** [m_numSubKeySpaces]; m_charSetPoses = new uint32_t [m_maxPwLen]; m_charSetPosesTemp = new uint32_t [m_maxPwLen]; m_pw = new uint32_t [m_pwBlocks + 1]; m_pwTemp = new uint32_t [m_pwBlocks + 1]; memcpy(m_keySpaceBoundaries, ks.m_keySpaceBoundaries, sizeof(uint64_t) * (m_numSubKeySpaces + 1)); memcpy(m_passwordLengths, ks.m_passwordLengths, sizeof(uint32_t) * m_numSubKeySpaces); memcpy(m_divShortCut, ks.m_divShortCut, sizeof(uint32_t) * m_numSubKeySpaces); memcpy(m_numShortCutChars, ks.m_numShortCutChars, sizeof(uint32_t) * m_numSubKeySpaces); memcpy(m_charSetPoses, ks.m_charSetPoses, sizeof(uint32_t) * m_maxPwLen); memcpy(m_pw, ks.m_pw, sizeof(uint32_t) * (m_pwBlocks + 1)); for (a = 0; a < m_numSubKeySpaces; a++) { m_charSetLengths[a] = new uint32_t[m_passwordLengths[a]]; memcpy(m_charSetLengths[a], ks.m_charSetLengths[a], sizeof(uint32_t) * m_passwordLengths[a]); for (b = 0; b < m_passwordLengths[a]; b++) { tmp = m_charSetLengths[a][b] + (ks.m_subKeySpaces[a][b] - ks.m_charSet); if (charSetLen < tmp) { charSetLen = tmp; } } } m_charSet = new char[charSetLen]; memcpy(m_charSet, ks.m_charSet, sizeof(char) * charSetLen); for (a = 0; a < m_numSubKeySpaces; a++) { m_subKeySpaces[a] = new char*[m_passwordLengths[a]]; for (b = 0; b < m_passwordLengths[a]; b++) { m_subKeySpaces[a][b] = m_charSet + (ks.m_subKeySpaces[a][b] - ks.m_charSet); } } } bool KeySpace::reset(uint64_t pwNum) { return reset(pwNum, m_pw, m_charSetPoses, m_curSubKeySpace); } const bool KeySpace::reset(uint64_t pwNum, uint32_t *pwOut, uint32_t *charSetPoses, uint32_t &curSubKeySpace) { uint32_t *charSetLengths, *pw; char **subKeySpaces; uint32_t curSubKeySpaceTemp, charSetLength, divisor, remainder, quotient, offset; int a, t, passwordLength, numShortCutChars; if (pwNum >= m_keySpace) { return true; } pw = pwOut + 1; offset = m_offset; curSubKeySpaceTemp = 0; while (pwNum >= m_keySpaceBoundaries[curSubKeySpaceTemp + 1]) { curSubKeySpaceTemp++; } pwNum -= m_keySpaceBoundaries[curSubKeySpaceTemp]; passwordLength = (int) m_passwordLengths[curSubKeySpaceTemp]; numShortCutChars = (int) m_numShortCutChars[curSubKeySpaceTemp]; charSetLengths = m_charSetLengths[curSubKeySpaceTemp]; subKeySpaces = m_subKeySpaces[curSubKeySpaceTemp]; curSubKeySpace = curSubKeySpaceTemp; t = (int) m_pwBlocks; for (a = passwordLength >> 2; a < t; a++) { pw[a] = 0; } if (numShortCutChars > 0) { divisor = m_divShortCut[curSubKeySpaceTemp]; DIV_MOD_64_RET_32_32(pwNum, divisor, remainder, quotient); numShortCutChars = passwordLength - numShortCutChars; if ((m_charaterEncoding & CE_ASCII_BIN8) != 0) { // 8 bit for (a = passwordLength - 1; a >= numShortCutChars; a--) { charSetLength = charSetLengths[a]; charSetPoses[a] = t = remainder % charSetLength; remainder /= charSetLength; ((char*)pw)[a] = subKeySpaces[a][t]; } for (; a >= 0; a--) { charSetLength = charSetLengths[a]; charSetPoses[a] = t = quotient % charSetLength; quotient /= charSetLength; ((char*)pw)[a] = subKeySpaces[a][t]; } } else if ((m_charaterEncoding & (CE_UTF16_LE | CE_UTF16_BE)) != 0) { // 16 bit for (a = passwordLength - 1; a >= numShortCutChars; a--) { charSetLength = charSetLengths[a]; charSetPoses[a] = t = remainder % charSetLength; remainder /= charSetLength; ((char*)pw)[2 * a + offset] = subKeySpaces[a][t]; } for (; a >= 0; a--) { charSetLength = charSetLengths[a]; charSetPoses[a] = t = quotient % charSetLength; quotient /= charSetLength; ((char*)pw)[2 * a + offset] = subKeySpaces[a][t]; } } else if ((m_charaterEncoding & (CE_UTF32_LE | CE_UTF32_BE)) != 0) { // 32 bit for (a = passwordLength - 1; a >= numShortCutChars; a--) { charSetLength = charSetLengths[a]; charSetPoses[a] = t = remainder % charSetLength; remainder /= charSetLength; ((char*)pw)[4 * a + offset] = subKeySpaces[a][t]; } for (; a >= 0; a--) { charSetLength = charSetLengths[a]; charSetPoses[a] = t = quotient % charSetLength; quotient /= charSetLength; ((char*)pw)[4 * a + offset] = subKeySpaces[a][t]; } } } else if (passwordLength > 1) { quotient = (uint32_t) pwNum; if ((m_charaterEncoding & CE_ASCII_BIN8) != 0) { // 8 bit for (a = passwordLength - 1; a >= 0; a--) { charSetLength = charSetLengths[a]; charSetPoses[a] = t = quotient % charSetLength; quotient /= charSetLength; ((char*)pw)[a] = subKeySpaces[a][t]; } } else if ((m_charaterEncoding & (CE_UTF16_LE | CE_UTF16_BE)) != 0) { // 16 bit for (a = passwordLength - 1; a >= 0; a--) { charSetLength = charSetLengths[a]; charSetPoses[a] = t = quotient % charSetLength; quotient /= charSetLength; ((char*)pw)[2 * a + offset] = subKeySpaces[a][t]; } } else if ((m_charaterEncoding & (CE_UTF32_LE | CE_UTF32_BE)) != 0) { // 32 bit for (a = passwordLength - 1; a >= 0; a--) { charSetLength = charSetLengths[a]; charSetPoses[a] = t = quotient % charSetLength; quotient /= charSetLength; ((char*)pw)[4 * a + offset] = subKeySpaces[a][t]; } } } else { charSetPoses[0] = (uint32_t) pwNum; ((char*)pw)[offset] = subKeySpaces[0][pwNum]; } pwOut[0] = passwordLength; if ((m_charaterEncoding & CE_80_NULL_PADDED) != 0) { if (m_charaterEncoding == (CE_ASCII_BIN8 | CE_80_NULL_PADDED)) { ((char*)pw)[passwordLength] = (char) 0x80; } else if ((m_charaterEncoding & (CE_UTF16_LE | CE_UTF16_BE)) != 0) { ((char*)pw)[2 * passwordLength + offset] = (char) 0x80; } else if ((m_charaterEncoding & (CE_UTF32_LE | CE_UTF32_BE)) != 0) { ((char*)pw)[4 * passwordLength + offset] = (char) 0x80; } } return false; } uint32_t KeySpace::next(vector4 *pwOut, uint32_t numPws, uint32_t vecSize) { char *charSet; uint32_t *pw; uint32_t a, b, c, curSubKeySpace, passwordLength, charSetPos, charSetLength, offset, pwBlocks; pw = m_pw; offset = m_offset; pwBlocks = m_pwBlocks; curSubKeySpace = m_curSubKeySpace; passwordLength = m_passwordLengths[curSubKeySpace]; charSet = m_subKeySpaces[curSubKeySpace][passwordLength - 1]; charSetPos = m_charSetPoses[passwordLength - 1]; charSetLength = m_charSetLengths[curSubKeySpace][passwordLength - 1]; for (a = 0; a < numPws; a++) { if ((m_charaterEncoding & CE_ASCII_BIN8) != 0) { // 8 bit ((char*)(pw+1))[passwordLength - 1] = charSet[charSetPos]; } else if ((m_charaterEncoding & (CE_UTF16_LE | CE_UTF16_BE)) != 0) { // 16 bit ((char*)(pw+1))[2 * (passwordLength - 1) + offset] = charSet[charSetPos]; } else if ((m_charaterEncoding & (CE_UTF32_LE | CE_UTF32_BE)) != 0) { // 32 bit ((char*)(pw+1))[4 * (passwordLength - 1) + offset] = charSet[charSetPos]; } for (b = 0, c = 0; b < pwBlocks; b++, c += vecSize) { pwOut[c].data[a] = pw[b]; } charSetPos++; if (charSetPos >= charSetLength) { if (cycleLastChar()) { reset(0); } charSetPos = 0; curSubKeySpace = m_curSubKeySpace; passwordLength = m_passwordLengths[curSubKeySpace]; charSet = m_subKeySpaces[curSubKeySpace][passwordLength - 1]; charSetLength = m_charSetLengths[curSubKeySpace][passwordLength - 1]; } } m_charSetPoses[passwordLength - 1] = charSetPos; return a; } uint32_t KeySpace::get(vector4 *pwOut, uint32_t numPws, uint32_t vecSize, uint64_t *pwNums) { uint32_t *pw, *charSetPoses; uint32_t a, b, c, curSubKeySpace = 0, pwBlocks; pwBlocks = m_pwBlocks; pw = m_pwTemp; charSetPoses = m_charSetPosesTemp; // Thrown away for (a = 0; a < numPws; a++) { if (reset(pwNums[a], pw, charSetPoses, curSubKeySpace)) { break; } for (b = 0, c = 0; b <= pwBlocks; b++, c += vecSize) { pwOut[c].data[a] = pw[b]; } } return a; } uint32_t KeySpace::get(char *pwOut, uint64_t pwNum) { uint32_t *pw, *charSetPoses; uint32_t curSubKeySpace = 0, pwLen; pw = m_pwTemp; charSetPoses = m_charSetPosesTemp; // Thrown away reset(pwNum, pw, charSetPoses, curSubKeySpace); pwLen = pw[0]; pw++; for (uint32_t a = 0; a < pwLen; a++) { pwOut[a] = ((char*)pw)[a]; } pwOut[pwLen] = 0; return pwLen; } bool KeySpace::cycleLastChar() { uint32_t *charSetPoses, *pw; uint32_t offset, curSubKeySpace; int a, passwordLength; bool nextKeySpace = true; pw = m_pw + 1; curSubKeySpace = m_curSubKeySpace; passwordLength = (int) m_passwordLengths[curSubKeySpace]; a = passwordLength - 2; // supress g++ warning of unitialized use offset = m_offset; if (passwordLength > 1) { charSetPoses = m_charSetPoses; if ((m_charaterEncoding & CE_ASCII_BIN8) != 0) { // 8 bit for (a = passwordLength - 2; a >= 0; a--) { if (++charSetPoses[a] < m_charSetLengths[curSubKeySpace][a]) { ((char*)pw)[a] = m_subKeySpaces[curSubKeySpace][a][charSetPoses[a]]; break; } charSetPoses[a] = 0; ((char*)pw)[a] = m_subKeySpaces[curSubKeySpace][a][0]; } } else if ((m_charaterEncoding & (CE_UTF16_LE | CE_UTF16_BE)) != 0) { // 16 bit for (a = passwordLength - 2; a >= 0; a--) { if (++charSetPoses[a] < m_charSetLengths[curSubKeySpace][a]) { ((char*)pw)[2 * a + offset] = m_subKeySpaces[curSubKeySpace][a][charSetPoses[a]]; break; } charSetPoses[a] = 0; ((char*)pw)[2 * a + offset] = m_subKeySpaces[curSubKeySpace][a][0]; } } else if ((m_charaterEncoding & (CE_UTF32_LE | CE_UTF32_BE)) != 0) { // 32 bit for (a = passwordLength - 2; a >= 0; a--) { if (++charSetPoses[a] < m_charSetLengths[curSubKeySpace][a]) { ((char*)pw)[4 * a + offset] = m_subKeySpaces[curSubKeySpace][a][charSetPoses[a]]; break; } charSetPoses[a] = 0; ((char*)pw)[4 * a + offset] = m_subKeySpaces[curSubKeySpace][a][0]; } } nextKeySpace = a == -1; } if (nextKeySpace) { if (++curSubKeySpace >= m_numSubKeySpaces) { return true; } m_curSubKeySpace = curSubKeySpace; passwordLength = m_passwordLengths[curSubKeySpace]; charSetPoses = m_charSetPoses; m_pw[0] = passwordLength; int pwBlocks = (int) m_pwBlocks; for (a = passwordLength >> 2; a < pwBlocks; a++) { pw[a] = 0; } if ((m_charaterEncoding & CE_ASCII_BIN8) != 0) { // 8 bit for (a = 0; a < passwordLength; a++) { charSetPoses[a] = 0; ((char*)pw)[a] = m_subKeySpaces[curSubKeySpace][a][0]; } } else if ((m_charaterEncoding & (CE_UTF16_LE | CE_UTF16_BE)) != 0) { // 16 bit for (a = 0; a < passwordLength; a++) { charSetPoses[a] = 0; ((char*)pw)[2 * a + offset] = m_subKeySpaces[curSubKeySpace][a][0]; } } else if ((m_charaterEncoding & (CE_UTF32_LE | CE_UTF32_BE)) != 0) { // 32 bit for (a = 0; a < passwordLength; a++) { charSetPoses[a] = 0; ((char*)pw)[4 * a + offset] = m_subKeySpaces[curSubKeySpace][a][0]; } } if ((m_charaterEncoding & CE_80_NULL_PADDED) != 0) { if (m_charaterEncoding == (CE_ASCII_BIN8 | CE_80_NULL_PADDED)) { ((char*)pw)[a] = (char) 0x80; } else if ((m_charaterEncoding & (CE_UTF16_LE | CE_UTF16_BE)) != 0) { ((char*)pw)[2 * a + offset] = (char) 0x80; } else if ((m_charaterEncoding & (CE_UTF32_LE | CE_UTF32_BE)) != 0) { ((char*)pw)[4 * a + offset] = (char) 0x80; } } } return false; } const uint64_t KeySpace::getKeySpace() { return m_keySpace; } const uint32_t KeySpace::getMaxPwLen() { return m_maxPwLen; } const uint32_t KeySpace::getMinPwLen() { return m_minPwLen; } const std::string KeySpace::getName() { return m_name; } rcracki-mt-0.7.0/rcracki_mt/RTCPhalfReader.h0000640000175000017500000000315012043323152020063 0ustar dookiedookie/* * freerainbowtables is a project for generating, distributing, and using * perfect rainbow tables * * Copyright 2010, 2011 Martin Westergaard Jørgensen * Copyright 2010, 2011 James Nobis * * This file is part of freerainbowtables. * * freerainbowtables is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * freerainbowtables is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with freerainbowtables. If not, see . */ #ifndef _RTCPHALFREADER_H #define _RTCPHALFREADER_H #include #if defined(_WIN32) && !defined(__GNUC__) #include #endif #include "Public.h" #include "BaseRTReader.h" class RTCPhalfReader { private: FILE *dataFile; uint32_t chainPosition; uint32_t chainSizeBytes; uint64_t minimumStartPoint; std::string filename; void setChainSizeBytes( uint32_t chainSizeBytes ); void setFilename( std::string filename ); public: RTCPhalfReader( std::string filename ); ~RTCPhalfReader() { }; void dump(); uint32_t getChainsLeft(); std::string getFilename(); int readChains(uint32_t &numChains, RainbowChainCPhalf *pData); void setMinimumStartPoint(); }; #endif rcracki-mt-0.7.0/rcracki_mt/HashSet.cpp0000640000175000017500000000717312043323152017240 0ustar dookiedookie/* * rcracki_mt is a multithreaded implementation and fork of the original * RainbowCrack * * Copyright (C) Zhu Shuanglei * Copyright Martin Westergaard Jørgensen * Copyright 2009, 2010 Daniël Niggebrugge * Copyright 2009, 2010, 2011, 2012 James Nobis * * This file is part of rcracki_mt. * * rcracki_mt is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * rcracki_mt is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with rcracki_mt. If not, see . */ #include "HashSet.h" CHashSet::CHashSet() { } CHashSet::~CHashSet() { } void CHashSet::AddHash(std::string sHash) { if (sHash == "aad3b435b51404ee") return; uint32_t i; for (i = 0; i < m_vHash.size(); i++) { if (m_vHash[i] == sHash) return; } //printf("debug: adding hash %s\n", sHash.c_str()); m_vHash.push_back(sHash); m_vFound.push_back(false); m_vPlain.push_back(""); m_vBinary.push_back(""); } std::string CHashSet::GetHashInfo(int i) { std::string found; if (m_vFound[i]) found = "1"; else found = "0"; std::string buffer = m_vHash[i] + ":" + found + ":" + m_vPlain[i] + ":" + m_vBinary[i]; return buffer; } bool CHashSet::AnyhashLeft() { uint32_t i; for (i = 0; i < m_vHash.size(); i++) { if (!m_vFound[i]) return true; } return false; } bool CHashSet::AnyHashLeftWithLen(int nLen) { uint32_t i; for (i = 0; i < m_vHash.size(); i++) { if (!m_vFound[i]) if (m_vHash[i].size() == (unsigned long)nLen * 2) return true; } return false; } void CHashSet::GetLeftHashWithLen(std::vector& vHash, int nLen) { vHash.clear(); uint32_t i; for (i = 0; i < m_vHash.size(); i++) { if (!m_vFound[i]) if (m_vHash[i].size() == (unsigned long)nLen * 2) vHash.push_back(m_vHash[i]); } } void CHashSet::AddHashInfo(std::string sHash, bool found, std::string sPlain, std::string sBinary) { uint32_t i; for (i = 0; i < m_vHash.size(); i++) { if (m_vHash[i] == sHash) return; } m_vHash.push_back(sHash); m_vFound.push_back(found); m_vPlain.push_back(sPlain); m_vBinary.push_back(sBinary); } void CHashSet::SetPlain(std::string sHash, std::string sPlain, std::string sBinary) { uint32_t i; for (i = 0; i < m_vHash.size(); i++) { if (m_vHash[i] == sHash) { m_vFound[i] = true; m_vPlain[i] = sPlain; m_vBinary[i] = sBinary; return; } } } bool CHashSet::GetPlain(std::string sHash, std::string& sPlain, std::string& sBinary) { if (sHash == "aad3b435b51404ee") { sPlain = ""; sBinary = ""; return true; } uint32_t i; for (i = 0; i < m_vHash.size(); i++) { if (m_vHash[i] == sHash) { if (m_vFound[i]) { sPlain = m_vPlain[i]; sBinary = m_vBinary[i]; return true; } } } return false; } int CHashSet::GetStatHashFound() { int nHashFound = 0; uint32_t i; for (i = 0; i < m_vHash.size(); i++) { if (m_vFound[i]) nHashFound++; } return nHashFound; } int CHashSet::GetStatHashTotal() { return (int) m_vHash.size(); } rcracki-mt-0.7.0/rcracki_mt/HashAlgorithm.cpp0000640000175000017500000002744512043323152020437 0ustar dookiedookie/* * freerainbowtables is a project for generating, distributing, and using * perfect rainbow tables * * Copyright (C) Zhu Shuanglei * Copyright 2009, 2010, 2011 Martin Westergaard Jørgensen * Copyright 2009, 2010 Daniël Niggebrugge * Copyright 2009, 2010, 2011, 2012 James Nobis * Copyright 2011 Janosch Rux * * This file is part of freerainbowtables. * * freerainbowtables is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * freerainbowtables is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with freerainbowtables. If not, see . * * Changes: not using OpenSSL routines the slow way anymore, as suggested by jci. */ #include "HashAlgorithm.h" #include "Public.h" #ifndef LOCALDES #include #else #include "des.h" #endif #ifndef GPUONLY #include #endif //#include #include "fast_md5.h" #include "fast_md4.h" //#include "sha1.h" #if defined(_WIN32) && !defined(__GNUC__) #pragma comment(lib, "libeay32.lib") #endif #ifdef __NetBSD__ #include #endif #define MSCACHE_HASH_SIZE 16 void setup_des_key(unsigned char key_56[], des_key_schedule &ks) { des_cblock key; key[0] = key_56[0]; key[1] = (key_56[0] << 7) | (key_56[1] >> 1); key[2] = (key_56[1] << 6) | (key_56[2] >> 2); key[3] = (key_56[2] << 5) | (key_56[3] >> 3); key[4] = (key_56[3] << 4) | (key_56[4] >> 4); key[5] = (key_56[4] << 3) | (key_56[5] >> 5); key[6] = (key_56[5] << 2) | (key_56[6] >> 6); key[7] = (key_56[6] << 1); //des_set_odd_parity(&key); des_set_key(&key, ks); } //It doesnt convert to upper case that must be done before //otherwise it will produce a wrong a hash void HashLM(unsigned char* pPlain, int nPlainLen, unsigned char* pHash) { /* unsigned char data[7] = {0}; memcpy(data, pPlain, nPlainLen > 7 ? 7 : nPlainLen); */ int i; for (i = nPlainLen; i < 7; i++) pPlain[i] = 0; static unsigned char magic[] = {0x4B, 0x47, 0x53, 0x21, 0x40, 0x23, 0x24, 0x25}; des_key_schedule ks; //setup_des_key(data, ks); setup_des_key(pPlain, ks); des_ecb_encrypt((des_cblock*)magic, (des_cblock*)pHash, ks, DES_ENCRYPT); } void HashLMCHALL(unsigned char* pPlain, int nPlainLen, unsigned char* pHash) { unsigned char pass[14]; unsigned char pre_lmresp[21]; static unsigned char magic[] = {0x4B, 0x47, 0x53, 0x21, 0x40, 0x23, 0x24, 0x25}; static unsigned char spoofed_challange[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88}; des_key_schedule ks; memset (pass,0,sizeof(pass)); memset (pre_lmresp,0,sizeof(pre_lmresp)); memcpy (pass,pPlain, nPlainLen); setup_des_key(pass, ks); des_ecb_encrypt((des_cblock*)magic, (des_cblock*)pre_lmresp, ks, DES_ENCRYPT); setup_des_key(&pass[7], ks); des_ecb_encrypt((des_cblock*)magic, (des_cblock*)&pre_lmresp[8], ks, DES_ENCRYPT); setup_des_key(pre_lmresp, ks); des_ecb_encrypt((des_cblock*)spoofed_challange, (des_cblock*)pHash, ks, DES_ENCRYPT); setup_des_key(&pre_lmresp[7], ks); des_ecb_encrypt((des_cblock*)spoofed_challange, (des_cblock*)&pHash[8], ks, DES_ENCRYPT); setup_des_key(&pre_lmresp[14], ks); des_ecb_encrypt((des_cblock*)spoofed_challange, (des_cblock*)&pHash[16], ks, DES_ENCRYPT); } void HashHALFLMCHALL(unsigned char* pPlain, int nPlainLen, unsigned char* pHash) { unsigned char pre_lmresp[8]; static unsigned char magic[] = {0x4B, 0x47, 0x53, 0x21, 0x40, 0x23, 0x24, 0x25}; static unsigned char salt[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88}; des_key_schedule ks; unsigned char plain[8] = {0}; memcpy(plain, pPlain, nPlainLen); setup_des_key(plain, ks); des_ecb_encrypt((des_cblock*)magic, (des_cblock*)pre_lmresp, ks, DES_ENCRYPT); setup_des_key(pre_lmresp, ks); des_ecb_encrypt((des_cblock*)salt, (des_cblock*)pHash, ks, DES_ENCRYPT); } void HashNTLMCHALL(unsigned char* pPlain, int nPlainLen, unsigned char* pHash) { unsigned char UnicodePlain[MAX_PLAIN_LEN * 2]; static unsigned char spoofed_challange[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88}; int len = (nPlainLen < 127) ? nPlainLen : 127; int i; for (i = 0; i < len; i++) { UnicodePlain[i * 2] = pPlain[i]; UnicodePlain[i * 2 + 1] = 0x00; } des_key_schedule ks; unsigned char lm[21]; /*MD4_CTX ctx; MD4_Init(&ctx); MD4_Update(&ctx, UnicodePlain, len * 2); MD4_Final(lm, &ctx); */ MD4_NEW(UnicodePlain, len * 2, lm); //MD4(UnicodePlain, len * 2, lm); lm[16] = lm[17] = lm[18] = lm[19] = lm[20] = 0; setup_des_key(lm, ks); des_ecb_encrypt((des_cblock*)spoofed_challange, (des_cblock*)pHash, ks, DES_ENCRYPT); setup_des_key(&lm[7], ks); des_ecb_encrypt((des_cblock*)spoofed_challange, (des_cblock*)&pHash[8], ks, DES_ENCRYPT); setup_des_key(&lm[14], ks); des_ecb_encrypt((des_cblock*)spoofed_challange, (des_cblock*)&pHash[16], ks, DES_ENCRYPT); } /* void HashORACLE(unsigned char* pPlain, int nPlainLen, unsigned char* pHash) { char ToEncrypt[256]; char temp[256]; char username[256]; DES_cblock iv,iv2; DES_key_schedule ks1,ks2; unsigned char deskey_fixed[]={ 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef}; int i,j; #if defined(_WIN32) && !defined(__GNUC__) strcpy_s(username, sizeof(username), "SYS"); #else strcpy(username, "SYS"); #endif int userlen = 3; #if defined(_WIN32) && !defined(__GNUC__) _strupr((char*) pPlain); #else strupr((char*) pPlain); #endif memset (ToEncrypt,0,sizeof(ToEncrypt)); for (i=1,j=0; j ascii - 64 */ "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; void _crypt_to64(char *s, unsigned long v, int n) { while (--n >= 0) { *s++ = itoa64[v&0x3f]; v >>= 6; } } /* void HashPIX(unsigned char* pPlain, int nPlainLen, unsigned char* pHash) { char temp[MD5_DIGEST_LENGTH+1]; unsigned char final[MD5_DIGEST_LENGTH]; char* pass = (char*) calloc (nPlainLen+MD5_DIGEST_LENGTH,sizeof(char)); memcpy (pass,pPlain,nPlainLen); fast_MD5((unsigned char *) pass, MD5_DIGEST_LENGTH, final); char* p = (char*) temp; _crypt_to64(p,*(unsigned long*) (final+0),4); p += 4; _crypt_to64(p,*(unsigned long*) (final+4),4); p += 4; _crypt_to64(p,*(unsigned long*) (final+8),4); p += 4; _crypt_to64(p,*(unsigned long*) (final+12),4); p += 4; *p=0; memcpy(pHash,temp,MD5_DIGEST_LENGTH); free (pass); } */ #if !defined(_WIN32) || defined(__GNUC__) char *strupr(char *s1) { char *p = s1; while(*p) { *p = (char) toupper(*p); p++; } return s1; } #endif rcracki-mt-0.7.0/rcracki_mt/fast_md5.cpp0000640000175000017500000003134612043323152017402 0ustar dookiedookie/* * Fast implementation of the MD5 message-digest algorithm as per RFC * (see http://tools.ietf.org/html/rfc1321) * * Author: Joao Inacio * License: Use and share as you wish at your own risk, please keep this header ;) * * Optimizations: * - For lengths < 16, transformation steps are "unrolled" using macros/defines * - Constants used whenever possible, it's the compiler's job to sort them out * - Padding is done on 4-byte words, and memory copied as last resort. * * freerainbowtables is a project for generating, distributing, and using * perfect rainbow tables * * Copyright 2009, 2010 Daniël Niggebrugge * Copyright 2009, 2010, 2011, 2012 James Nobis * * This file is part of freerainbowtables. * * freerainbowtables is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * freerainbowtables is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with freerainbowtables. If not, see . */ #include "fast_md5.h" /* MD5 defines as per RFC reference implementation */ #define AC1 0xd76aa478 #define AC2 0xe8c7b756 #define AC3 0x242070db #define AC4 0xc1bdceee #define AC5 0xf57c0faf #define AC6 0x4787c62a #define AC7 0xa8304613 #define AC8 0xfd469501 #define AC9 0x698098d8 #define AC10 0x8b44f7af #define AC11 0xffff5bb1 #define AC12 0x895cd7be #define AC13 0x6b901122 #define AC14 0xfd987193 #define AC15 0xa679438e #define AC16 0x49b40821 #define AC17 0xf61e2562 #define AC18 0xc040b340 #define AC19 0x265e5a51 #define AC20 0xe9b6c7aa #define AC21 0xd62f105d #define AC22 0x02441453 #define AC23 0xd8a1e681 #define AC24 0xe7d3fbc8 #define AC25 0x21e1cde6 #define AC26 0xc33707d6 #define AC27 0xf4d50d87 #define AC28 0x455a14ed #define AC29 0xa9e3e905 #define AC30 0xfcefa3f8 #define AC31 0x676f02d9 #define AC32 0x8d2a4c8a #define AC33 0xfffa3942 #define AC34 0x8771f681 #define AC35 0x6d9d6122 #define AC36 0xfde5380c #define AC37 0xa4beea44 #define AC38 0x4bdecfa9 #define AC39 0xf6bb4b60 #define AC40 0xbebfbc70 #define AC41 0x289b7ec6 #define AC42 0xeaa127fa #define AC43 0xd4ef3085 #define AC44 0x04881d05 #define AC45 0xd9d4d039 #define AC46 0xe6db99e5 #define AC47 0x1fa27cf8 #define AC48 0xc4ac5665 #define AC49 0xf4292244 #define AC50 0x432aff97 #define AC51 0xab9423a7 #define AC52 0xfc93a039 #define AC53 0x655b59c3 #define AC54 0x8f0ccc92 #define AC55 0xffeff47d #define AC56 0x85845dd1 #define AC57 0x6fa87e4f #define AC58 0xfe2ce6e0 #define AC59 0xa3014314 #define AC60 0x4e0811a1 #define AC61 0xf7537e82 #define AC62 0xbd3af235 #define AC63 0x2ad7d2bb #define AC64 0xeb86d391 #define S11 7 #define S12 12 #define S13 17 #define S14 22 #define S21 5 #define S22 9 #define S23 14 #define S24 20 #define S31 4 #define S32 11 #define S33 16 #define S34 23 #define S41 6 #define S42 10 #define S43 15 #define S44 21 #define Ca 0x67452301 #define Cb 0xefcdab89 #define Cc 0x98badcfe #define Cd 0x10325476 #define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z)))) #define G(x, y, z) ((y) ^ ((z) & ((x) ^ (y)))) //#define G(x, y, z) F((z), (x), (y)) #define H(x, y, z) ((x) ^ (y) ^ (z)) #define I(x, y, z) ((y) ^ ((x) | ~(z))) #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n)))) // md5 step #define MD5STEP(f, a, b, c, d, AC, x, s) { \ (a) += f ((b), (c), (d)); \ (a) += (AC) + (x); \ (a) = ROTATE_LEFT ((a), (s)); \ (a) += (b); \ } // full MD5 transformation #define MD5_steps(w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15) { \ \ MD5STEP(F, a, b, c, d, AC1, w0, S11);\ MD5STEP(F, d, a, b, c, AC2, w1, S12);\ MD5STEP(F, c, d, a, b, AC3, w2, S13);\ MD5STEP(F, b, c, d, a, AC4, w3, S14);\ MD5STEP(F, a, b, c, d, AC5, w4, S11);\ MD5STEP(F, d, a, b, c, AC6, w5, S12);\ MD5STEP(F, c, d, a, b, AC7, w6, S13);\ MD5STEP(F, b, c, d, a, AC8, w7, S14);\ MD5STEP(F, a, b, c, d, AC9, w8, S11);\ MD5STEP(F, d, a, b, c, AC10, w9, S12);\ MD5STEP(F, c, d, a, b, AC11, w10, S13);\ MD5STEP(F, b, c, d, a, AC12, w11, S14);\ MD5STEP(F, a, b, c, d, AC13, w12, S11);\ MD5STEP(F, d, a, b, c, AC14, w13, S12);\ MD5STEP(F, c, d, a, b, AC15, w14, S13);\ MD5STEP(F, b, c, d, a, AC16, w15, S14);\ \ MD5STEP(G, a, b, c, d, AC17, w1, S21);\ MD5STEP(G, d, a, b, c, AC18, w6, S22);\ MD5STEP(G, c, d, a, b, AC19, w11, S23);\ MD5STEP(G, b, c, d, a, AC20, w0, S24);\ MD5STEP(G, a, b, c, d, AC21, w5, S21);\ MD5STEP(G, d, a, b, c, AC22, w10, S22);\ MD5STEP(G, c, d, a, b, AC23, w15, S23);\ MD5STEP(G, b, c, d, a, AC24, w4, S24);\ MD5STEP(G, a, b, c, d, AC25, w9, S21);\ MD5STEP(G, d, a, b, c, AC26, w14, S22);\ MD5STEP(G, c, d, a, b, AC27, w3, S23);\ MD5STEP(G, b, c, d, a, AC28, w8, S24);\ MD5STEP(G, a, b, c, d, AC29, w13, S21);\ MD5STEP(G, d, a, b, c, AC30, w2, S22);\ MD5STEP(G, c, d, a, b, AC31, w7, S23);\ MD5STEP(G, b, c, d, a, AC32, w12, S24);\ \ MD5STEP(H, a, b, c, d, AC33, w5, S31);\ MD5STEP(H, d, a, b, c, AC34, w8, S32);\ MD5STEP(H, c, d, a, b, AC35, w11, S33);\ MD5STEP(H, b, c, d, a, AC36, w14, S34);\ MD5STEP(H, a, b, c, d, AC37, w1, S31);\ MD5STEP(H, d, a, b, c, AC38, w4, S32);\ MD5STEP(H, c, d, a, b, AC39, w7, S33);\ MD5STEP(H, b, c, d, a, AC40, w10, S34);\ MD5STEP(H, a, b, c, d, AC41, w13, S31);\ MD5STEP(H, d, a, b, c, AC42, w0, S32);\ MD5STEP(H, c, d, a, b, AC43, w3, S33);\ MD5STEP(H, b, c, d, a, AC44, w6, S34);\ MD5STEP(H, a, b, c, d, AC45, w9, S31);\ MD5STEP(H, d, a, b, c, AC46, w12, S32);\ MD5STEP(H, c, d, a, b, AC47, w15, S33);\ MD5STEP(H, b, c, d, a, AC48, w2, S34);\ \ MD5STEP(I, a, b, c, d, AC49, w0, S41);\ MD5STEP(I, d, a, b, c, AC50, w7, S42);\ MD5STEP(I, c, d, a, b, AC51, w14, S43);\ MD5STEP(I, b, c, d, a, AC52, w5, S44);\ MD5STEP(I, a, b, c, d, AC53, w12, S41);\ MD5STEP(I, d, a, b, c, AC54, w3, S42);\ MD5STEP(I, c, d, a, b, AC55, w10, S43);\ MD5STEP(I, b, c, d, a, AC56, w1, S44);\ MD5STEP(I, a, b, c, d, AC57, w8, S41);\ MD5STEP(I, d, a, b, c, AC58, w15, S42);\ MD5STEP(I, c, d, a, b, AC59, w6, S43);\ MD5STEP(I, b, c, d, a, AC60, w13, S44);\ MD5STEP(I, a, b, c, d, AC61, w4, S41);\ MD5STEP(I, d, a, b, c, AC62, w11, S42);\ MD5STEP(I, c, d, a, b, AC63, w2, S43);\ MD5STEP(I, b, c, d, a, AC64, w9, S44);\ } // len >= 56 #define MD5_transform_add(w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15) { \ \ a = wOut[0]; b = wOut[1]; c = wOut[2]; d = wOut[3];\ \ MD5_steps(w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15);\ \ wOut[0] += a; wOut[1] += b; wOut[2] += c; wOut[3] += d;\ } // len < 56 #define MD5_transform_single(w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15) { \ \ a = CC[0]; b=CC[1]; c=CC[2]; d=CC[3];\ \ MD5_steps(w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15);\ \ wOut[0] = a+Ca; wOut[1] = b+Cb; wOut[2] = c+Cc; wOut[3] = d+Cd;\ } // len < 16 #define MD5_transform_16(w0, w1, w2, w3, w14) \ MD5_transform_single(w0, w1, w2, w3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, w14, 0); // pad word and append 0x80 at appropriate location #define MD5_pad_w0() (0x00000080) #define MD5_pad_w1(data) (((data) & 0x000000FF) | 0x00008000) #define MD5_pad_w2(data) (((data) & 0x0000FFFF) | 0x00800000) #define MD5_pad_w3(data) (((data) & 0x00FFFFFF) | 0x80000000) #ifndef MD5_pad_w1 static inline uint32_t MD5_pad_w1(uint32_t data) { // XXX x86 specific __asm__ ( "movb %%al, %%cl \n\t" "xorl %1, %1 \n\t" "orb $128, %%ah \n\t" "movb %%cl, %%al \n\t" "movl %1, %0 \n\t" : "=r" (data) : "a" (data) : "cl" ); return data; } #endif #ifndef MD5_pad_w3 static inline uint32_t MD5_pad_w3(uint32_t data) { // XXX x86 specific __asm__ ( "roll $8, %1 \n\t" "movb $128, %%al \n\t" "rorl $8, %1 \n\t" "movl %1, %0 \n\t" : "=r" (data) : "a" (data) ); return data; } #endif static inline void MD5_copy_pad_block(uint32_t *dData, uint32_t *wIn, int blocklen, int len) { register int cl; // copy full words for (cl = 0; cl < blocklen; cl++) dData[cl] = wIn[cl]; // copy with padding switch (len & 0x03) { case 0: dData[cl] = MD5_pad_w0(); break; case 1: dData[cl] = MD5_pad_w1(wIn[cl]); break; case 2: dData[cl] = MD5_pad_w2(wIn[cl]); break; case 3: dData[cl] = MD5_pad_w3(wIn[cl]); break; } // append 0's for (cl++; cl < 14; cl++) dData[cl] = 0; // append len dData[cl++] = (len << 3); dData[cl] = (len >> 29); } // fast initializer array //__attribute__((aligned(16))) //__declspec(align(16)) static const uint32_t CC[4] = {Ca, Cb, Cc, Cd}; /* * fast_MD5() * */ void fast_MD5(unsigned char *pData, int len, unsigned char *pDigest) { #define wIn ((uint32_t *)pData) #define wOut ((uint32_t *)pDigest) register uint32_t a; register uint32_t b; register uint32_t c; register uint32_t d; switch (len) { case 0: MD5_transform_16(MD5_pad_w0(), 0, 0, 0, 8*0); return; case 1: MD5_transform_16(MD5_pad_w1(wIn[0]), 0, 0, 0, 8*1); return; case 2: MD5_transform_16(MD5_pad_w2(wIn[0]), 0, 0, 0, 8*2); return; case 3: MD5_transform_16(MD5_pad_w3(wIn[0]), 0, 0, 0, 8*3); return; case 4: MD5_transform_16(wIn[0], MD5_pad_w0(), 0, 0, 8*4); return; case 5: MD5_transform_16(wIn[0], MD5_pad_w1(wIn[1]), 0, 0, 8*5); return; case 6: MD5_transform_16(wIn[0], MD5_pad_w2(wIn[1]), 0, 0, 8*6); return; case 7: MD5_transform_16(wIn[0], MD5_pad_w3(wIn[1]), 0, 0, 8*7); return; case 8: MD5_transform_16(wIn[0], wIn[1], MD5_pad_w0(), 0, 8*8); return; case 9: MD5_transform_16(wIn[0], wIn[1], MD5_pad_w1(wIn[2]), 0, 8*9); return; case 10: MD5_transform_16(wIn[0], wIn[1], MD5_pad_w2(wIn[2]), 0, 8*10); return; case 11: MD5_transform_16(wIn[0], wIn[1], MD5_pad_w3(wIn[2]), 0, 8*11); return; case 12: MD5_transform_16(wIn[0], wIn[1], wIn[2], MD5_pad_w0(), 8*12); return; case 13: MD5_transform_16(wIn[0], wIn[1], wIn[2], MD5_pad_w1(wIn[3]), 8*13); return; case 14: MD5_transform_16(wIn[0], wIn[1], wIn[2], MD5_pad_w2(wIn[3]), 8*14) return; case 15: MD5_transform_16(wIn[0], wIn[1], wIn[2], MD5_pad_w3(wIn[3]), 8*15) return; } // data block used for padding uint32_t dData[16]; if (len < 56) { // 16 < length < 56 MD5_copy_pad_block(dData, wIn, (len >> 2), len); // redefine data input, point to padded data #undef wIn #define wIn dData MD5_transform_single ( wIn[ 0], wIn[ 1], wIn[ 2], wIn[ 3], wIn[ 4], wIn[ 5], wIn[ 6], wIn[ 7], wIn[ 8], wIn[ 9], wIn[10], wIn[11], wIn[12], wIn[13], wIn[14], wIn[15] ); #undef wIn return; } else { // len >= 56 #define wIn ((uint32_t *)pData) // original len int tlen = len; // init digest for long lens wOut[0] = Ca; wOut[1] = Cb; wOut[2] = Cc; wOut[3] = Cd; while (tlen >= 64) { // Process 64-byte chunks MD5_transform_add( wIn[ 0], wIn[ 1], wIn[ 2], wIn[ 3], wIn[ 4], wIn[ 5], wIn[ 6], wIn[ 7], wIn[ 8], wIn[ 9], wIn[10], wIn[11], wIn[12], wIn[13], wIn[14], wIn[15] ); tlen -= 64; pData += 64; } if (tlen >= 56) { // Process > 56-byte chunk int cl = (tlen >> 2); // perform padding on last 2 byte if (cl > 14) { dData[14] = wIn[14]; } else { dData[15] = 0; } // copy 1 word with padding byte switch (len & 0x03) { case 0: dData[cl] = MD5_pad_w0(); break; case 1: dData[cl] = MD5_pad_w1(wIn[cl]); break; case 2: dData[cl] = MD5_pad_w2(wIn[cl]); break; case 3: dData[cl] = MD5_pad_w3(wIn[cl]); break; } // transform MD5_transform_add( wIn[ 0], wIn[ 1], wIn[ 2], wIn[ 3], wIn[ 4], wIn[ 5], wIn[ 6], wIn[ 7], wIn[ 8], wIn[ 9], wIn[10], wIn[11], wIn[12], wIn[13], dData[14], dData[15] ); // final transform #define w14 (len << 3) #define w15 (len >> 29) MD5_transform_add( 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, w14, w15 ); #undef w14 #undef w15 return; } else { // (len mod 64) < 56 MD5_copy_pad_block(dData, wIn, (tlen >> 2), len); #undef wIn #define wIn dData // transform MD5_transform_add( wIn[ 0], wIn[ 1], wIn[ 2], wIn[ 3], wIn[ 4], wIn[ 5], wIn[ 6], wIn[ 7], wIn[ 8], wIn[ 9], wIn[10], wIn[11], wIn[12], wIn[13], wIn[14], wIn[15] ); #undef wIn #define wIn ((uint32_t *)pData) return; } } /* end of fast_MD5() */ } rcracki-mt-0.7.0/rcracki_mt/MemoryPool.h0000640000175000017500000000273612043323152017450 0ustar dookiedookie/* * freerainbowtables is a project for generating, distributing, and using * perfect rainbow tables * * Copyright (C) Zhu Shuanglei * Copyright 2010 Martin Westergaard Jørgensen * Copyright 2009, 2010 Daniël Niggebrugge * Copyright 2009, 2010, 2011, 2012 James Nobis * Copyright 2010 uroskn * * This file is part of freerainbowtables. * * freerainbowtables is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * freerainbowtables is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with freerainbowtables. If not, see . */ #ifndef _MEMORYPOOL_H #define _MEMORYPOOL_H #include "Public.h" class CMemoryPool { public: CMemoryPool(); CMemoryPool(unsigned int bytesSaved, bool bDebug, uint64_t maxMem); virtual ~CMemoryPool(); private: bool debug; unsigned char* m_pMem; uint64_t m_nMemSize; uint64_t m_nMemMax; public: unsigned char* Allocate(unsigned int nFileLen, uint64_t& nAllocatedSize); }; #endif rcracki-mt-0.7.0/rcracki_mt/ChainWalkSet.cpp0000640000175000017500000002264512043323152020217 0ustar dookiedookie/* * freerainbowtables is a project for generating, distributing, and using * perfect rainbow tables * * Copyright (C) Zhu Shuanglei * Copyright Martin Westergaard Jørgensen * Copyright 2009, 2010 Daniël Niggebrugge * Copyright 2009, 2010, 2011, 2012 James Nobis * * This file is part of freerainbowtables. * * freerainbowtables is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * freerainbowtables is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with freerainbowtables. If not, see . */ #include "ChainWalkSet.h" CChainWalkSet::CChainWalkSet() { m_sHashRoutineName = ""; m_sPlainCharsetName = ""; m_nPlainLenMin = 0; m_nPlainLenMax = 0; m_nRainbowTableIndex = 0; m_nRainbowChainLen = 0; debug = false; sPrecalcPathName = ""; preCalcPart = 0; } CChainWalkSet::~CChainWalkSet() { DiscardAll(); } void CChainWalkSet::DiscardAll() { //printf("debug: discarding all walk...\n"); std::list::iterator it; for (it = m_lChainWalk.begin(); it != m_lChainWalk.end(); it++) delete [] it->pIndexE; m_lChainWalk.clear(); } std::string CChainWalkSet::CheckOrRotatePreCalcFile() { char sPreCalcFileName[255]; // 255 files limit to be sure for (; preCalcPart < 255; preCalcPart++) { sprintf(sPreCalcFileName, "%s.%d", sPrecalcPathName.c_str(), preCalcPart); std::string sReturnPreCalcPath(sPreCalcFileName); long fileLen = 0; FILE* file = fopen(sReturnPreCalcPath.c_str(), "ab"); if(file!=NULL) { fileLen = GetFileLen(sReturnPreCalcPath); long unsigned int nextFileLen = fileLen + (sizeof(uint64_t) * (m_nRainbowChainLen-1)); // Rotate to next file if we are going to pass 2GB filesize if (nextFileLen < ((unsigned)2 * 1024 * 1024 * 1024)) { // We might want to vPrecalcFiles.push_back(sReturnPreCalcPath) if we just created this file // We don't as only newly generated chainwalksets will be stored to this new file, so we don't have to look there if (debug) printf("Debug: Using for precalc: %s\n", sReturnPreCalcPath.c_str()); fclose(file); return sReturnPreCalcPath; } fclose(file); } } return std::string(""); } void CChainWalkSet::updateUsedPrecalcFiles() { // we might also use this function to search a wildcard path of precalc files vPrecalcFiles.clear(); char sPreCalcFileName[255]; int i; // 255 files max for (i = 0; i < 255; i++) { sprintf(sPreCalcFileName, "%s.%d", sPrecalcPathName.c_str(), i); std::string sTryPreCalcPath(sPreCalcFileName); FILE* file = fopen(sTryPreCalcPath.c_str(), "rb"); if(file!=NULL) { vPrecalcFiles.push_back(sTryPreCalcPath); fclose(file); } else { break; } } } void CChainWalkSet::removePrecalcFiles() { if (debug) printf("Debug: Removing precalc files.\n"); updateUsedPrecalcFiles(); std::string sCurrentPrecalcPathName = ""; std::string sCurrentPrecalcIndexPathName = ""; int i; for (i = 0; i < (int)vPrecalcFiles.size(); i++) { sCurrentPrecalcPathName = vPrecalcFiles[i]; sCurrentPrecalcIndexPathName = sCurrentPrecalcPathName + ".index"; if (debug) printf("Debug: Removing precalc file: %s\n", sCurrentPrecalcPathName.c_str()); if (remove(sCurrentPrecalcPathName.c_str()) != 0) if (debug) printf("Debug: Failed removing precalc file: %s\n", sCurrentPrecalcPathName.c_str()); if (debug) printf("Debug: Removing precalc index file: %s\n", sCurrentPrecalcIndexPathName.c_str()); if (remove(sCurrentPrecalcIndexPathName.c_str()) != 0) if (debug) printf("Debug: Failed removing precalc index file: %s\n", sCurrentPrecalcIndexPathName.c_str()); } } bool CChainWalkSet::FindInFile(uint64_t* pIndexE, unsigned char* pHash, int nHashLen) { int gotPrecalcOnLine = -1; char precalculationLine[255]; sprintf(precalculationLine, "%s_%s#%d-%d_%d_%d:%s\n", m_sHashRoutineName.c_str(), m_sPlainCharsetName.c_str(), m_nPlainLenMin, m_nPlainLenMax, m_nRainbowTableIndex, m_nRainbowChainLen, HexToStr(pHash, nHashLen).c_str() ); std::string precalcString(precalculationLine); std::string sCurrentPrecalcPathName = ""; std::string sCurrentPrecalcIndexPathName = ""; long unsigned int offset = 0; int i; for (i = 0; i < (int)vPrecalcFiles.size() && gotPrecalcOnLine == -1; i++) { sCurrentPrecalcPathName = vPrecalcFiles[i]; sCurrentPrecalcIndexPathName = sCurrentPrecalcPathName + ".index"; offset = 0; std::vector precalcLines; if (ReadLinesFromFile(sCurrentPrecalcIndexPathName.c_str(), precalcLines)) { int j; for (j = 0; j < (int)precalcLines.size(); j++) { if (precalcString.compare(0, precalcString.size()-1, precalcLines[j]) == 0) { gotPrecalcOnLine = j; break; } // Parse std::vector vPart; if (SeperateString(precalcLines[j], "___:", vPart)) { // add to offset offset += ((atoi(vPart[3].c_str())-1) * sizeof(uint64_t)); } else { // corrupt file printf("Corrupted precalculation file!\n"); gotPrecalcOnLine = -1; break; } } } } if (gotPrecalcOnLine > -1) { if (debug) { std::cout << "Debug: Reading pre calculations from file, line " << gotPrecalcOnLine << " offset " << offset << std::endl; } FILE* fp = fopen(sCurrentPrecalcPathName.c_str(), "rb"); if (fp!=NULL) { fseek(fp, offset, SEEK_SET); // We should do some verification here, for example by recalculating the middle chain, to catch corrupted files if(fread(pIndexE, sizeof(uint64_t), (unsigned long)m_nRainbowChainLen-1, fp) != (unsigned long)m_nRainbowChainLen-1) { std::cout << "Error reading " << sCurrentPrecalcPathName << std::endl; } fclose(fp); } else { std::cout << "Cannot open precalculation file " << sCurrentPrecalcPathName << "." << std::endl; } //printf("\npIndexE[0]: %s\n", uint64tostr(pIndexE[0]).c_str()); //printf("\npIndexE[nRainbowChainLen-2]: %s\n", uint64tostr(pIndexE[m_nRainbowChainLen-2]).c_str()); return true; } return false; } void CChainWalkSet::StoreToFile(uint64_t* pIndexE, unsigned char* pHash, int nHashLen) { if (debug) printf("\nDebug: Storing precalc\n"); std::string sCurrentPrecalcPathName = CheckOrRotatePreCalcFile(); std::string sCurrentPrecalcIndexPathName = sCurrentPrecalcPathName + ".index"; FILE* fp = fopen(sCurrentPrecalcPathName.c_str(), "ab"); if(fp!=NULL) { if(fwrite(pIndexE, sizeof(uint64_t), (unsigned long)m_nRainbowChainLen-1, fp) != (unsigned long)m_nRainbowChainLen-1) printf("File write error."); else { FILE* file = fopen(sCurrentPrecalcIndexPathName.c_str(), "a"); if (file!=NULL) { char precalculationLine[255]; sprintf(precalculationLine, "%s_%s#%d-%d_%d_%d:%s\n", m_sHashRoutineName.c_str(), m_sPlainCharsetName.c_str(), m_nPlainLenMin, m_nPlainLenMax, m_nRainbowTableIndex, m_nRainbowChainLen, HexToStr(pHash, nHashLen).c_str() ); fputs (precalculationLine, file); fclose (file); } } fclose(fp); } else printf("Cannot open precalculation file %s\n", sCurrentPrecalcPathName.c_str()); } uint64_t* CChainWalkSet::RequestWalk( unsigned char* pHash, int nHashLen , std::string sHashRoutineName, std::string sPlainCharsetName , int nPlainLenMin, int nPlainLenMax, int nRainbowTableIndex , int nRainbowChainLen, bool& fNewlyGenerated, bool setDebug , std::string sPrecalc ) { debug = setDebug; sPrecalcPathName = sPrecalc; if ( m_sHashRoutineName != sHashRoutineName || m_sPlainCharsetName != sPlainCharsetName || m_nPlainLenMin != nPlainLenMin || m_nPlainLenMax != nPlainLenMax || m_nRainbowTableIndex != nRainbowTableIndex || m_nRainbowChainLen != nRainbowChainLen) { DiscardAll(); m_sHashRoutineName = sHashRoutineName; m_sPlainCharsetName = sPlainCharsetName; m_nPlainLenMin = nPlainLenMin; m_nPlainLenMax = nPlainLenMax; m_nRainbowTableIndex = nRainbowTableIndex; m_nRainbowChainLen = nRainbowChainLen; ChainWalk cw; memcpy(cw.Hash, pHash, nHashLen); cw.pIndexE = new uint64_t[nRainbowChainLen - 1]; m_lChainWalk.push_back(cw); // Only update this list when we search through another rainbow table updateUsedPrecalcFiles(); if (!FindInFile(cw.pIndexE, pHash, nHashLen)) fNewlyGenerated = true; else fNewlyGenerated = false; return cw.pIndexE; } std::list::iterator it; for (it = m_lChainWalk.begin(); it != m_lChainWalk.end(); it++) { if (memcmp(it->Hash, pHash, nHashLen) == 0) { fNewlyGenerated = false; return it->pIndexE; } } ChainWalk cw; memcpy(cw.Hash, pHash, nHashLen); cw.pIndexE = new uint64_t[nRainbowChainLen - 1]; m_lChainWalk.push_back(cw); if (!FindInFile(cw.pIndexE, pHash, nHashLen)) fNewlyGenerated = true; else fNewlyGenerated = false; return cw.pIndexE; } void CChainWalkSet::DiscardWalk(uint64_t* pIndexE) { std::list::iterator it; for (it = m_lChainWalk.begin(); it != m_lChainWalk.end(); it++) { if (it->pIndexE == pIndexE) { delete it->pIndexE; m_lChainWalk.erase(it); return; } } printf("debug: pIndexE not found\n"); } rcracki-mt-0.7.0/rcracki_mt/ChainWalkContext.h0000640000175000017500000000670712043323152020556 0ustar dookiedookie/* * freerainbowtables is a project for generating, distributing, and using * perfect rainbow tables * * Copyright (C) Zhu Shuanglei * Copyright 2009, 2010 Daniël Niggebrugge * Copyright 2009, 2010, 2011, 2012 James Nobis * Copyright 2008, 2009, 2010, 2011 Steve Thomas (Sc00bz) * * This file is part of freerainbowtables. * * freerainbowtables is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * freerainbowtables is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with freerainbowtables. If not, see . */ #ifndef _CHAINWALKCONTEXT_H #define _CHAINWALKCONTEXT_H #include "Public.h" #include "HashRoutine.h" #include "keyspace.h" class CChainWalkContext { public: CChainWalkContext(); virtual ~CChainWalkContext(); //private: static std::string m_sHashRoutineName; static HASHROUTINE m_pHashRoutine; // Configuration static int m_nHashLen; // Configuration static uint8_t RTfileFormatId; static std::vector m_vCharset; static int m_nPlainLenMinTotal, m_nPlainLenMaxTotal; static uint64_t m_nPlainSpaceUpToX[MAX_PLAIN_LEN]; // Performance consideration static uint64_t m_nPlainSpaceTotal; // Performance consideration static int m_nHybridCharset; static int m_nRainbowTableIndex; // Configuration static uint64_t m_nReduceOffset; // Performance consideration static KeySpace *m_ks; // Context uint64_t m_nIndex; unsigned char m_Plain[MAX_PLAIN_LEN]; int m_nPlainLen; unsigned char m_Hash[MAX_HASH_LEN]; static unsigned char m_Salt[MAX_SALT_LEN]; static int m_nSaltLen; private: static bool LoadCharset( std::string sCharset ); union { unsigned char m_Hash[8]; uint64_t alias; } m_Hash_alias; public: static bool SetHashRoutine( std::string sHashRoutineName ); static bool SetPlainCharset( std::string sCharsetName, int nPlainLenMin, int nPlainLenMax ); static bool SetRainbowTableIndex(int nRainbowTableIndex); static bool SetSalt(unsigned char *Salt, int nSaltLength); static bool SetupWithPathName( std::string sPathName, int& nRainbowChainLen, int& nRainbowChainCount ); // Wrapper static std::string GetHashRoutineName(); static int GetHashLen(); static std::string GetPlainCharsetName(); static std::string GetPlainCharsetContent(); static int GetPlainLenMin(); static int GetPlainLenMax(); static uint64_t GetPlainSpaceTotal(); static int GetRainbowTableIndex(); static void Dump(); static uint8_t getRTfileFormat(); void SetIndex(uint64_t nIndex); void SetHash(unsigned char* pHash); // The length should be m_nHashLen void IndexToPlain(); int normalIndexToPlain(uint64_t index, uint64_t *plainSpaceUpToX, unsigned char *charSet, int charSetLen, int min, int max, unsigned char *plain); void PlainToHash(); void HashToIndex(int nPos); uint64_t GetIndex(); const uint64_t* GetIndexPtr(); std::string GetPlain(); std::string GetBinary(); std::string GetHash(); bool CheckHash(unsigned char* pHash); // The length should be m_nHashLen }; #endif rcracki-mt-0.7.0/rcracki_mt/fast_md4.h0000640000175000017500000000224112043323152017036 0ustar dookiedookie/* * freerainbowtables is a project for generating, distributing, and using * perfect rainbow tables * * Copyright Bitweasil * Copyright 2009, 2010 Daniël Niggebrugge * Copyright 2009, 2010, 2011, 2012 James Nobis * * This file is part of freerainbowtables. * * freerainbowtables is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * freerainbowtables is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with freerainbowtables. If not, see . */ #ifndef _FAST_MD4_H #define _FAST_MD4_H #include "global.h" #define MD4_DIGEST_LENGTH 16 //Main function void MD4_NEW( unsigned char * buf, int len, unsigned char * pDigest); #endif /* !_FAST_MD4_H */ rcracki-mt-0.7.0/rcracki_mt/RTCPhalfReader.cpp0000640000175000017500000000444612043323152020427 0ustar dookiedookie/* * freerainbowtables is a project for generating, distributing, and using * perfect rainbow tables * * Copyright 2010, 2011 Martin Westergaard Jørgensen * Copyright 2010, 2011 James Nobis * * This file is part of freerainbowtables. * * freerainbowtables is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * freerainbowtables is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with freerainbowtables. If not, see . */ #include "RTCPhalfReader.h" RTCPhalfReader::RTCPhalfReader( std::string filename ) { chainPosition = 0; // set it to the maximum possible value minimumStartPoint = (uint64_t)-1; setChainSizeBytes( 10 ); setFilename( filename ); dataFile = fopen(filename.c_str(), "rb"); } void RTCPhalfReader::dump() { } uint32_t RTCPhalfReader::getChainsLeft() { return (GetFileLen( getFilename() ) / chainSizeBytes) - chainPosition; } std::string RTCPhalfReader::getFilename() { return filename; } int RTCPhalfReader::readChains(uint32_t &numChains, RainbowChainCPhalf *pData) { unsigned int numRead = fread(pData, 1, chainSizeBytes * numChains, dataFile); numChains = numRead / chainSizeBytes; chainPosition += numChains; return 0; } void RTCPhalfReader::setChainSizeBytes( uint32_t chainSizeBytes ) { this->chainSizeBytes = chainSizeBytes; } void RTCPhalfReader::setFilename( std::string filename ) { this->filename = filename; } void RTCPhalfReader::setMinimumStartPoint() { uint64_t tmpStartPoint; uint64_t tmpEndPoint; long originalFilePos = ftell( dataFile ); //fseek( dataFile, 0, SEEK_SET ); rewind( dataFile ); while ( !feof( dataFile ) ) { fread( &tmpStartPoint, 8, 1, dataFile ); fread( &tmpEndPoint, 8, 1, dataFile ); if ( tmpStartPoint < minimumStartPoint ) minimumStartPoint = tmpStartPoint; } fseek( dataFile, originalFilePos, SEEK_SET ); } rcracki-mt-0.7.0/rcracki_mt/MemoryPool.cpp0000640000175000017500000000647612043323152020010 0ustar dookiedookie/* * freerainbowtables is a project for generating, distributing, and using * perfect rainbow tables * * Copyright (C) Zhu Shuanglei * Copyright Martin Westergaard Jørgensen * Copyright 2009, 2010 Daniël Niggebrugge * Copyright 2009, 2010, 2011, 2012 James Nobis * Copyright 2010 uroskn * Copyright 2011 Richard W. Watson * * This file is part of freerainbowtables. * * freerainbowtables is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * freerainbowtables is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with freerainbowtables. If not, see . */ #include "MemoryPool.h" CMemoryPool::CMemoryPool() { m_pMem = NULL; m_nMemSize = 0; unsigned long nAvailPhys = GetAvailPhysMemorySize(); if (nAvailPhys < 16 * 1024 * 1024) m_nMemMax = nAvailPhys / 2; // Leave some memory for CChainWalkSet else m_nMemMax = nAvailPhys - 8 * 1024 * 1024; // Leave some memory for CChainWalkSet } CMemoryPool::CMemoryPool(unsigned int bytesSaved, bool bDebug, uint64_t maxMem) { m_pMem = NULL; m_nMemSize = 0; debug = bDebug; unsigned long nAvailPhys = GetAvailPhysMemorySize(); if ( debug ) std::cout << "Debug: nAvailPhys: " << nAvailPhys << std::endl; if ( maxMem > 0 && maxMem < nAvailPhys ) nAvailPhys = maxMem; m_nMemMax = nAvailPhys - bytesSaved; // Leave memory for CChainWalkSet if (m_nMemMax < 16 * 1024 * 1024) m_nMemMax = 16 * 1024 * 1024; } CMemoryPool::~CMemoryPool() { if (m_pMem != NULL) { #ifdef _MEMORYDEBUG printf("Freeing %i bytes of memory\n", m_nMemSize); #endif delete [] m_pMem; m_pMem = NULL; m_nMemSize = 0; } } unsigned char* CMemoryPool::Allocate(unsigned int nFileLen, uint64_t& nAllocatedSize) { if (nFileLen <= m_nMemSize) { nAllocatedSize = nFileLen; return m_pMem; } unsigned int nTargetSize; if (nFileLen < m_nMemMax) nTargetSize = nFileLen; else nTargetSize = m_nMemMax; // Free existing memory if (m_pMem != NULL) { #ifdef _MEMORYDEBUG printf("Freeing %i bytes of memory\n", m_nMemSize); #endif delete [] m_pMem; m_pMem = NULL; m_nMemSize = 0; } // Allocate new memory //printf("allocating %u bytes memory\n", nTargetSize); #ifdef _MEMORYDEBUG printf("Allocating %i bytes of memory - ", nTargetSize); #endif m_pMem = new (std::nothrow) unsigned char[nTargetSize]; while (m_pMem == NULL && nTargetSize >= 32 * 1024 * 1024 ) { #ifdef _MEMORYDEBUG printf("failed!\n"); printf("Allocating %i bytes of memory (backup) - ", nTargetSize); #endif nTargetSize -= 16 * 1024 * 1024; m_pMem = new (std::nothrow) unsigned char[nTargetSize]; } if (m_pMem != NULL) { #ifdef _MEMORYDEBUG printf("success!\n"); #endif m_nMemSize = nTargetSize; nAllocatedSize = nTargetSize; return m_pMem; } else { m_nMemSize = 0; nAllocatedSize = 0; return NULL; } } rcracki-mt-0.7.0/rcracki_mt/README.txt0000640000175000017500000002077212043323152016673 0ustar dookiedookie[rcracki_mt README] USAGE ================ example: rcracki_mt -h 5d41402abc4b2a76b9719d911017c592 -t 4 -o save.txt C:\md5 Start rcracki_mt without any arguments to view usage information in short. This README describes the various options in more detail. Many options can be set to a default value by editing rcracki_mt.ini. Command line arguments get priority over settings in the ini file. INPUT ---------------- rcracki_mt takes one hash on the command line (using -h) or an input file containing the hashes. rcracki_mt supports three formats for the input file. Use one of the following options to specify the format followed by the filename: -l: specify a list of hashes (one hash per line) -f: specify a pwdump file -c: specify a .lst file (format in which Cain stores hashes and results) SELECTING RAINBOW TABLES ---------------- Any command line argument that is not an option will be interpreted as a directory to search for rainbow tables, multiple directories can be specified. rcracki_mt recursively scans all specified directories for *.rti (indexed) and *.rt (old/original) files. You can use .rt & .rti files at once, but this hasn't been tested thoroughly. You can set default locations to search for rainbow tables in rcracki_mt.ini. You need to use these in combination with the command line argument -a [algorithm]. See the comments in the ini file for examples. SESSIONS & RESUMING ---------------- Rcracki_mt has session support, which means that it stores its progress. This allows you to interrupt the session and resume later on. This also allows sessions that stopped because of a crash (application or even system) to resume. To use this feature, start rcracki_mt with all the options you'd like, then specify a session name with: -s session_name: specify a session name Now during cracking, all your valuable precalculations are stored to disk, as well as progress (which files have been checked) and cracked hashes. If you decide to interrupt the session (using CTRL+C), you can resume it using the -r option. For example: rcracki_mt -r -s my_personal_hashes While resuming rcracki_mt you can/have to specify the less important options again, like number of threads and showing debug information. Usually you will have these settings set to a default value in the .ini file anyway. Session are deleted after the run is completed. You can choose to keep the precalculation work on disk, for example if you want to reuse your session later on. Use the '-k' option to enable this feature. Rcracki_mt has a default session which gets overwritten every time you start a new job without specifying a session name. It might be interesting to always keep precalculation work by enabling this feature in rcracki_mt.ini. But pay attention, these precalculations can become quite large on disk. Currently there is a maximum of around 500 GB of storage for these precalculations. You can always decide to manually remove the .precalc and .precalc.index files from disk. Always remove both at the same time, you will screw up your results if you don't. A possible 'todo' for development is to do some verification before using stored precalculations. OPTIONAL ---------------- -t: Number of threads to use (for precalculation and false alarm checking) Note: In Windows the crack threads run with lower priority. -o: specify an output file to store found hashes in a colon (:) separated format. Hashes are saved immediately when found. Especially useful if you have a large list of hashes. -v: Show more information during cracking, for debugging purposes. Please use this flag if you want to show output and report a bug. EXTRA FEATURES ---------------- You can pause a running rcracki_mt by using 'P'. It might not pause right away, it actually pauses after doing precalculation or false alarm checking for one hash. Resume by pressing 'P' again. This pause option is different from the session/resume feature, as this just pauses a running job, you don't stop rcracki_mt this way. If you are trying to crack a pwdump or Cain (.lst) file, containing both LM and NTLM hashes, rcracki_mt will try and crack the LM hashes. The result will be an uppercase password, which rcracki_mt will then try to correct with the right casing, using the NTLM hashes. If this fails it will try and perform Unicode correction, using a built-in mapping. If you happen to have an LM hash coupled with the wrong NTLM hash, this attempt to perform Unicode correction might take 'forever'. You can press 'S' to skip this step for the current hash. HISTORY AND AUTHORS ================ rcracki_mt originally started as a modification of a modification (rcracki) of the original RainbowCrack (rcrack). These programs are all used to perform a rainbow table attack on password hashes, implementing Philippe Oechslin's faster time-memory trade-off technique. Original rcrack code was written by Zhu Shuanglei . Martin Westergaard Jrgensen wrote rcracki (improved) to support the rainbow tables generated by the distributed project www.freerainbowtables.com. These tables are perfected and indexed, making them faster and smaller. Rcracki also supported hybrid tables. Danil Niggebrugge further enhanced this version and made it multi threaded, creating rcracki_mt. More features were added over time, making it less of an unofficial version with every release. James Nobis - improved *nix compatibility and 64-bit compatability and continues work on the project. SUPPORTED HASH ALGORITHMS ================ Hash types supported by rcracki_mt are: LM, NTLM, MD2, MD4, MD5, DoubleMD5, SHA1, RIPEMD160, MSCACHE, MySQL323, MySQLSHA1, PIX, LMCHALL, HALFLMCHALL, NTLMCHALL, ORACLE Actual indexed&perfected tables that were generated by the Free Rainbow Tables project: LM, MD5, NTLM, FASTLM, HALFLMCHALL, SHA1 SUPPORTED PLATFORMS ================ Rcracki_mt is released both as win32 binary and as source package. Rcracki_mt should work on any Microsoft Windows system, but is only tested on a 32 bit Windows XP. The source should work on Linux distributions. It has been tested on: 32-bit Ubuntu 32-bit Debian GNU/Linux 64-bit Debian GNU/Linux The source should also work on other platforms and has been tested on: 32-bit MacOSX 32-bit FreeBSD 64-bit FreeBSD 32-bit NetBSD 32-bit OpenBSD - you must install and use eg++ from ports 64-bit OpenBSD Only compilation has been tested on: 64-bit MacOSX Please note that to compile under the BSDs you must use gmake. OpenBSD threading is a work in progress. 'OPTIONAL' TODO ================ - verification of an endpoint when restoring a chainwalkset from disk. - read multiple chainwalksets from disk at once to try and speed up this process. - read next table (part) from disk while doing cryptanalysis LINKS ================ rcracki_mt @ SourceForge: https://sourceforge.net/projects/rcracki/ Original rcrack: http://www.antsight.com/zsl/rainbowcrack/ Free Rainbow Tables: http://www.freerainbowtables.com/ My personal blog: http://blog.distracted.nl/ Download free rainbow tables: http://tbhost.eu/ Download free rainbow tables (mirror): http://freerainbowtables.mirror.garr.it/mirrors/freerainbowtables/ THANKS ================ the_drag0n Writing part of this README Patch to support Cain .lst files Joao Inacio Supplying some faster algorithm implementations FAQ ================ Q: Why do I get this message all the time? "this table contains hashes with length 8 only" A: You are probably trying to crack LM hashes. You have to split up the hash in 2 parts of 16 hex characters each. Q: rcracki_mt is so slow when I'm cracking 5000 hashes, why is that? A: Rainbow table attacks are only useful for a certain amount of hashes, mainly because of the precalculations that are needed for every hash you are cracking. At a certain point it is faster to brute force the same key space then to try and use rainbow tables. Especially if you use a GPU enabled brute forcer, this limit might be reached very soon. Play around with these to find you limits. Q: How can I speed up rcracki_mt? A: This depends on quite some factors. If your jobs usually comprise of disk access time, you can try and speed up your storage. For example by using RAID and/or by using solid state disks. If you are trying to crack many hashes at the same time, you might be better off with buying a faster CPU. rcracki-mt-0.7.0/rcracki_mt/BaseRTReader.cpp0000640000175000017500000000735112043323152020142 0ustar dookiedookie/* * freerainbowtables is a project for generating, distributing, and using * perfect rainbow tables * * Copyright 2010, 2011 Martin Westergaard Jørgensen * Copyright 2010 Daniël Niggebrugge * Copyright 2010, 2011, 2012 James Nobis * Copyright 2011 Logan Watt * * This file is part of freerainbowtables. * * freerainbowtables is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * freerainbowtables is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with freerainbowtables. If not, see . */ #include "BaseRTReader.h" /// Default Constructor BaseRTReader::BaseRTReader() { data = NULL; this->chainPosition = 0; this->chainCount = 0; this->chainLength = 0; this->tableIndex = 0; this->startPointBits = 0; this->endPointBits = 0; fileName = ""; salt = ""; } /** * Argument Constructor * @param uint32_t number of chains in the file * @param uint32_t size of the chain * @param uint32_t reduction function index offset * @param uint32_t start point in the chain * @param uint32_t end point in the chain * @param std::string name of the file on disk * @param std::string salt used for hash */ BaseRTReader::BaseRTReader(uint32_t chCount, uint32_t chLength, uint32_t tblIdx, uint32_t stPt, uint32_t endPt, std::string fname, std::string slt) { this->chainCount = chCount; this->chainLength = chLength; this->tableIndex = tblIdx; this->startPointBits = stPt; this->endPointBits = endPt; this->fileName = fname; this->data = NULL; this->data = fopen( fileName.c_str(), "rb" ); if( data == NULL ) { std::cerr << "ERROR: could not open file: " << fileName.c_str() << " EXITING!" << std::endl; exit(-1); } this->salt = slt; this->chainPosition = 0; } /// Destructor BaseRTReader::~BaseRTReader() { if( data != NULL ) { fclose( data ); } } /// getChainCount uint32_t BaseRTReader::getChainCount() { return this->chainCount; } /// getChainLength uint32_t BaseRTReader::getChainLength() { return this->chainLength; } /// getChainPosition uint32_t BaseRTReader::getChainPosition() { return this->chainPosition; } /// getTableIndex uint32_t BaseRTReader::getTableIndex() { return this->tableIndex; } /// getStartPointBits uint32_t BaseRTReader::getStartPointBits() { return this->startPointBits; } /// getEndPointBits uint32_t BaseRTReader::getEndPointBits() { return this->endPointBits; } /// getFileName std::string BaseRTReader::getFileName() { return this->fileName; } /// getSalt std::string BaseRTReader::getSalt() { return this->salt; } /// setChainCount void BaseRTReader::setChainCount(uint32_t chCount) { this->chainCount = chCount; } /// setChainLength void BaseRTReader::setChainLength(uint32_t chLength) { this->chainLength = chLength; } /// setTableIndex void BaseRTReader::setTableIndex(uint32_t tblIdx) { this->tableIndex = tblIdx; } /// setStartPointBits void BaseRTReader::setStartPointBits(uint32_t stPt) { this->startPointBits = stPt; } /// setEndPointBits void BaseRTReader::setEndPointBits(uint32_t endPt) { this->endPointBits = endPt; } /// setFileName void BaseRTReader::setFileName(std::string fname) { this->fileName = fname; } /// setSalt void BaseRTReader::setSalt(std::string slt) { this->salt = slt; } /// Dump void BaseRTReader::Dump() { } rcracki-mt-0.7.0/rcracki_mt/RTReader.cpp0000640000175000017500000001003012043323152017333 0ustar dookiedookie/* * freerainbowtables is a project for generating, distributing, and using * perfect rainbow tables * * Copyright 2010, 2011 Martin Westergaard Jørgensen * Copyright 2010, 2011, 2012 James Nobis * Copyright 2011 Logan Watt * * This file is part of freerainbowtables. * * freerainbowtables is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * freerainbowtables is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with freerainbowtables. If not, see . */ #include "RTReader.h" /// Default Constructor RTReader::RTReader() { RTReaderInit(); } /** Constructor with filename * @param std::string file name on disk */ RTReader::RTReader(std::string fname) { RTReaderInit(); //bytes per chain setFileName( fname ); if( stat( getFileName().c_str(), &fileStats ) == -1 ) { std::cerr << "ERROR: stat() for file: " << getFileName() << " FAILED! " << std::endl; exit(-1); } data = fopen( getFileName().c_str(), "rb" ); if( data == NULL ) { std::cerr << "ERROR: could not open table file: " << getFileName() << " EXITING!" << std::endl; exit(-1); } } /** * Argument Constructor * @param uint32_t number of chains in the file * @param uint32_t size of the chain * @param uint32_t reduction function index offset * @param uint32_t start point in the chain * @param uint32_t end point in the chain * @param std::string name of the file on disk * @param std::string salt used for hash */ RTReader::RTReader(uint32_t chCount, uint32_t chLength, uint32_t tblIdx, uint32_t stPt, uint32_t endPt, std::string fname, std::string slt) { RTReaderInit(); setFileName( fname ); if( stat( getFileName().c_str(), &fileStats ) == -1 ) { std::cerr << "ERROR: stat() for file: " << getFileName() << " FAILED! " << std::endl; exit(-1); } setChainCount( chCount ); setChainLength( chLength ); setTableIndex( tblIdx ); setStartPointBits( stPt ); setEndPointBits( endPt ); setSalt( slt ); data = fopen( getFileName().c_str(), "rb" ); if( data == NULL ) { std::cerr << "ERROR: could not open table file: " << getFileName() << " EXITING!" << std::endl; exit(-1); } } /// shared Init method void RTReader::RTReaderInit() { // bytes per chain this->chainSize = 16; setStartPointBits(8); setEndPointBits(8); } /// Deconstructor RTReader::~RTReader() { } /// getChainSize uint32_t RTReader::getChainSize() { return this->chainSize; } /// getDataFileSize uint32_t RTReader::getDataFileSize() { return fileStats.st_size; } /** * reads data chains into memory * @param uint32_t reference to the number of chains to read * @param RanbowChain0* pointer in memory to read the chains to * @return EXIT_SUCCESS or EXIT_FAILURE */ int RTReader::readChains(uint32_t &numChains, RainbowChainO *pData) { unsigned int numRead = fread(pData, 1, chainSize * numChains, data); if( numRead == 0 ) { chainPosition = 0; return EXIT_FAILURE; } numChains = numRead / chainSize; chainPosition += numChains; return EXIT_SUCCESS; } /// getChainsLeft uint32_t RTReader::getChainsLeft() { return ( fileStats.st_size / chainSize ) - chainPosition; } /// getMinimumStartPoint uint64_t RTReader::getMinimumStartPoint() { uint64_t tmpStartPoint; uint64_t tmpEndPoint; uint64_t minimumStartPoint = (uint64_t)-1; long originalFilePos = ftell( data ); rewind( data ); while ( !feof( data ) ) { fread( &tmpStartPoint, 8, 1, data ); fread( &tmpEndPoint, 8, 1, data ); if ( tmpStartPoint < minimumStartPoint ) minimumStartPoint = tmpStartPoint; } fseek( data, originalFilePos, SEEK_SET ); return minimumStartPoint; } rcracki-mt-0.7.0/rcracki_mt/ChainWalkContext.cpp0000640000175000017500000006671012043323152021111 0ustar dookiedookie/* * freerainbowtables is a multithreaded implementation and fork of the original * RainbowCrack * * Copyright (C) Zhu Shuanglei * Copyright Martin Westergaard Jørgensen * Copyright 2009, 2010 Daniël Niggebrugge * Copyright 2009, 2010, 2011, 2012 James Nobis * Copyright 2010 Yngve AAdlandsvik * Copyright 2008, 2009, 2010, 2011 Steve Thomas (Sc00bz) * * This file is part of freerainbowtables. * * freerainbowtables is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * freerainbowtables is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with freerainbowtables. If not, see . */ #include "ChainWalkContext.h" #include ////////////////////////////////////////////////////////////////////// std::string CChainWalkContext::m_sHashRoutineName; HASHROUTINE CChainWalkContext::m_pHashRoutine; int CChainWalkContext::m_nHashLen; uint8_t CChainWalkContext::RTfileFormatId; int CChainWalkContext::m_nPlainLenMinTotal = 0; int CChainWalkContext::m_nPlainLenMaxTotal = 0; int CChainWalkContext::m_nHybridCharset = 0; std::vector CChainWalkContext::m_vCharset; uint64_t CChainWalkContext::m_nPlainSpaceUpToX[MAX_PLAIN_LEN]; uint64_t CChainWalkContext::m_nPlainSpaceTotal; unsigned char CChainWalkContext::m_Salt[MAX_SALT_LEN]; int CChainWalkContext::m_nSaltLen = 0; int CChainWalkContext::m_nRainbowTableIndex; uint64_t CChainWalkContext::m_nReduceOffset; KeySpace *CChainWalkContext::m_ks = NULL; ////////////////////////////////////////////////////////////////////// CChainWalkContext::CChainWalkContext() { } CChainWalkContext::~CChainWalkContext() { } bool CChainWalkContext::LoadCharset( std::string sName ) { m_vCharset.clear(); if (sName == "byte") { stCharset tCharset; int i; for (i = 0x00; i <= 0xff; i++) tCharset.m_PlainCharset[i] = (unsigned char) i; tCharset.m_nPlainCharsetLen = MAX_PLAIN_LEN; tCharset.m_sPlainCharsetName = sName; tCharset.m_sPlainCharsetContent = "0x00, 0x01, ... 0xff"; m_vCharset.push_back(tCharset); return true; } if(sName.substr(0, 6) == "hybrid") // Hybrid charset consisting of 2 charsets { if (sName.substr(6, 2) == "3(") { size_t pos = sName.find_last_of(')'); if (pos == std::string::npos) return false; m_ks = KeySpace::load(sName.substr(8, pos - 8).c_str(), CE_ASCII_BIN8 | CE_NULL_PADDED); // hybrid3(file name)#0-0 if (m_ks == NULL) return false; m_nHybridCharset = 3; return true; } else if (sName.substr(6, 2) == "2(") m_nHybridCharset = 2; else if (sName.substr(6, 1) == "(") m_nHybridCharset = 1; else { printf("hybrid version not supported\n"); return false; } } else m_nHybridCharset = 0; bool readCharset = false; std::vector vLine; std::vector internal_charset; vLine.clear(); internal_charset.clear(); internal_charset.push_back("byte = []"); internal_charset.push_back("alpha = [ABCDEFGHIJKLMNOPQRSTUVWXYZ]"); internal_charset.push_back("alpha-space = [ABCDEFGHIJKLMNOPQRSTUVWXYZ ]"); internal_charset.push_back("alpha-numeric = [ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789]"); internal_charset.push_back("alpha-numeric-space = [ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ]"); internal_charset.push_back("alpha-numeric-symbol14 = [ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\x21\x40\x23\x24\x25\x5E\x26\x2A\x28\x29\x2D\x5F\x2B\x3D]"); internal_charset.push_back("alpha-numeric-symbol14-space= [ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\x21\x40\x23\x24\x25\x5E\x26\x2A\x28\x29\x2D\x5F\x2B\x3D\x20]"); internal_charset.push_back("all = [ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\x21\x40\x23\x24\x25\x5E\x26\x2A\x28\x29\x2D\x5F\x2B\x3D\x7E\x60\x5B\x5D\x7B\x7D\x7C\x5C\x3A\x3B\x22\x27\x3C\x3E\x2C\x2E\x3F\x2F]"); internal_charset.push_back("all-space = [ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\x21\x40\x23\x24\x25\x5E\x26\x2A\x28\x29\x2D\x5F\x2B\x3D\x7E\x60\x5B\x5D\x7B\x7D\x7C\x5C\x3A\x3B\x22\x27\x3C\x3E\x2C\x2E\x3F\x2F\x20]"); internal_charset.push_back("alpha-numeric-symbol32-space = [ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\x21\x40\x23\x24\x25\x5E\x26\x2A\x28\x29\x2D\x5F\x2B\x3D\x7E\x60\x5B\x5D\x7B\x7D\x7C\x5C\x3A\x3B\x22\x27\x3C\x3E\x2C\x2E\x3F\x2F\x20]"); internal_charset.push_back("lm-frt-cp437 = [\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2A\x2B\x2C\x2D\x2E\x2F\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3A\x3B\x3C\x3D\x3E\x3F\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4A\x4B\x4C\x4D\x4E\x4F\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5A\x5B\x5C\x5D\x5E\x5F\x60\x7B\x7C\x7D\x7E\x80\x8E\x8F\x90\x92\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA5\xE0\xE1\xE2\xE3\xE4\xE6\xE7\xE8\xE9\xEA\xEB\xEE]"); internal_charset.push_back("lm-frt-cp850 = [\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2A\x2B\x2C\x2D\x2E\x2F\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3A\x3B\x3C\x3D\x3E\x3F\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4A\x4B\x4C\x4D\x4E\x4F\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5A\x5B\x5C\x5D\x5E\x5F\x60\x7B\x7C\x7D\x7E\x80\x8E\x8F\x90\x92\x99\x9A\x9C\x9D\x9F\xA5\xB5\xB6\xB7\xBD\xBE\xC7\xCF\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xDE\xE0\xE1\xE2\xE3\xE5\xE6\xE8\xE9\xEA\xEB\xED\xEF]"); internal_charset.push_back("lm-frt-cp437-850 = [\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2A\x2B\x2C\x2D\x2E\x2F\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3A\x3B\x3C\x3D\x3E\x3F\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4A\x4B\x4C\x4D\x4E\x4F\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5A\x5B\x5C\x5D\x5E\x5F\x60\x7B\x7C\x7D\x7E\x80\x8E\x8F\x90\x92\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA5\xB5\xB6\xB7\xBD\xBE\xC7\xCF\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xDE\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xED\xEE\xEF]"); internal_charset.push_back("numeric = [0123456789]"); internal_charset.push_back("numeric-space = [0123456789 ]"); internal_charset.push_back("loweralpha = [abcdefghijklmnopqrstuvwxyz]"); internal_charset.push_back("loweralpha-space = [abcdefghijklmnopqrstuvwxyz ]"); internal_charset.push_back("loweralpha-numeric = [abcdefghijklmnopqrstuvwxyz0123456789]"); internal_charset.push_back("loweralpha-numeric-space = [abcdefghijklmnopqrstuvwxyz0123456789 ]"); internal_charset.push_back("loweralpha-numeric-symbol14 = [abcdefghijklmnopqrstuvwxyz0123456789\x21\x40\x23\x24\x25\x5E\x26\x2A\x28\x29\x2D\x5F\x2B\x3D]"); internal_charset.push_back("loweralpha-numeric-all = [abcdefghijklmnopqrstuvwxyz0123456789\x21\x40\x23\x24\x25\x5E\x26\x2A\x28\x29\x2D\x5F\x2B\x3D\x7E\x60\x5B\x5D\x7B\x7D\x7C\x5C\x3A\x3B\x22\x27\x3C\x3E\x2C\x2E\x3F\x2F]"); internal_charset.push_back("loweralpha-numeric-symbol32-space= [abcdefghijklmnopqrstuvwxyz0123456789\x21\x40\x23\x24\x25\x5E\x26\x2A\x28\x29\x2D\x5F\x2B\x3D\x7E\x60\x5B\x5D\x7B\x7D\x7C\x5C\x3A\x3B\x22\x27\x3C\x3E\x2C\x2E\x3F\x2F\x20]"); internal_charset.push_back("mixalpha = [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ]"); internal_charset.push_back("mixalpha-space = [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ]"); internal_charset.push_back("mixalpha-numeric = [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789]"); internal_charset.push_back("mixalpha-numeric-space = [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ]"); internal_charset.push_back("mixalpha-numeric-symbol14 = [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\x21\x40\x23\x24\x25\x5E\x26\x2A\x28\x29\x2D\x5F\x2B\x3D]"); internal_charset.push_back("mixalpha-numeric-all = [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\x21\x40\x23\x24\x25\x5E\x26\x2A\x28\x29\x2D\x5F\x2B\x3D\x7E\x60\x5B\x5D\x7B\x7D\x7C\x5C\x3A\x3B\x22\x27\x3C\x3E\x2C\x2E\x3F\x2F]"); internal_charset.push_back("mixalpha-numeric-symbol32-space = [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\x21\x40\x23\x24\x25\x5E\x26\x2A\x28\x29\x2D\x5F\x2B\x3D\x7E\x60\x5B\x5D\x7B\x7D\x7C\x5C\x3A\x3B\x22\x27\x3C\x3E\x2C\x2E\x3F\x2F\x20]"); internal_charset.push_back("mixalpha-numeric-all-space = [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\x21\x40\x23\x24\x25\x5E\x26\x2A\x28\x29\x2D\x5F\x2B\x3D\x7E\x60\x5B\x5D\x7B\x7D\x7C\x5C\x3A\x3B\x22\x27\x3C\x3E\x2C\x2E\x3F\x2F\x20]"); #ifdef USE_INTEGRATED_CHARSET vLine = internal_charset; readCharset = true; #else #ifdef BOINC if ( boinc_ReadLinesFromFile( "charset.txt", vLine ) ) readCharset = true; else { vLine = internal_charset; readCharset = true; } #else if ( ReadLinesFromFile("charset.txt", vLine) ) readCharset = true; else if ( ReadLinesFromFile(GetApplicationPath() + "charset.txt", vLine) ) readCharset = true; else { vLine = internal_charset; readCharset = true; } #endif #endif if ( readCharset ) { int i; for (i = 0; (uint32_t)i < vLine.size(); i++) { // Filter comment if (vLine[i][0] == '#') continue; std::vector vPart; if (SeperateString(vLine[i], "=", vPart)) { // sCharsetName std::string sCharsetName = TrimString(vPart[0]); if (sCharsetName == "") continue; // sCharsetName charset check bool fCharsetNameCheckPass = true; uint32_t j; for (j = 0; j < sCharsetName.size(); j++) { if ( !isalpha(sCharsetName[j]) && !isdigit(sCharsetName[j]) && (sCharsetName[j] != '-')) { fCharsetNameCheckPass = false; break; } } if (!fCharsetNameCheckPass) { printf("invalid charset name %s in charset configuration file\n", sCharsetName.c_str()); continue; } // sCharsetContent std::string sCharsetContent = TrimString(vPart[1]); if (sCharsetContent == "" || sCharsetContent == "[]") continue; if (sCharsetContent[0] != '[' || sCharsetContent[sCharsetContent.size() - 1] != ']') { printf("invalid charset content %s in charset configuration file\n", sCharsetContent.c_str()); continue; } sCharsetContent = sCharsetContent.substr(1, sCharsetContent.size() - 2); if (sCharsetContent.size() > MAX_PLAIN_LEN) { printf("charset content %s too long\n", sCharsetContent.c_str()); continue; } //printf("%s = [%s]\n", sCharsetName.c_str(), sCharsetContent.c_str()); // Is it a hybrid? if( m_nHybridCharset != 0 ) { std::vector vCharsets; if ( !GetHybridCharsets(sName, vCharsets) ) { std::cout << "Failed to GetHybridCharsets: " << sName << std::endl; return false; } if(sCharsetName == vCharsets[m_vCharset.size()].sName) { stCharset tCharset; tCharset.m_nPlainCharsetLen = sCharsetContent.size(); memcpy(tCharset.m_PlainCharset, sCharsetContent.c_str(), tCharset.m_nPlainCharsetLen); tCharset.m_sPlainCharsetName = sCharsetName; tCharset.m_sPlainCharsetContent = sCharsetContent; tCharset.m_nPlainLenMin = vCharsets[m_vCharset.size()].nPlainLenMin; tCharset.m_nPlainLenMax = vCharsets[m_vCharset.size()].nPlainLenMax; m_vCharset.push_back(tCharset); if(vCharsets.size() == m_vCharset.size()) return true; //i = 0; // Start the lookup over again for the next charset // Sc00bz indicates this fixes a bug of skipping line 1 // of charset.txt i = -1; // Start the lookup over again for the next charset } } else if (sCharsetName == sName) { stCharset tCharset; tCharset.m_nPlainCharsetLen = sCharsetContent.size(); memcpy(tCharset.m_PlainCharset, sCharsetContent.c_str(), tCharset.m_nPlainCharsetLen); tCharset.m_sPlainCharsetName = sCharsetName; tCharset.m_sPlainCharsetContent = sCharsetContent; m_vCharset.push_back(tCharset); return true; } } } printf("charset %s not found in charset.txt\n", sName.c_str()); } else printf("can't open charset configuration file\n"); return false; } ////////////////////////////////////////////////////////////////////// bool CChainWalkContext::SetHashRoutine( std::string sHashRoutineName ) { CHashRoutine hr; hr.GetHashRoutine(sHashRoutineName, m_pHashRoutine, m_nHashLen); if (m_pHashRoutine != NULL) { m_sHashRoutineName = sHashRoutineName; return true; } else return false; } bool CChainWalkContext::SetPlainCharset( std::string sCharsetName, int nPlainLenMin, int nPlainLenMax) { // m_PlainCharset, m_nPlainCharsetLen, m_sPlainCharsetName, m_sPlainCharsetContent if (!LoadCharset(sCharsetName)) return false; if(m_nHybridCharset == 3) // hybrid3 is already loaded into m_ks { m_nPlainSpaceTotal = m_ks->getKeySpace(); return true; } if(m_nHybridCharset == 0) // Not hybrid charset { // m_nPlainLenMin, m_nPlainLenMax if (nPlainLenMin < 1 || nPlainLenMax > MAX_PLAIN_LEN || nPlainLenMin > nPlainLenMax) { printf("invalid plaintext length range: %d - %d\n", nPlainLenMin, nPlainLenMax); return false; } m_vCharset[0].m_nPlainLenMin = nPlainLenMin; m_vCharset[0].m_nPlainLenMax = nPlainLenMax; } // m_nPlainSpaceUpToX m_nPlainSpaceUpToX[0] = 0; m_nPlainLenMaxTotal = 0; m_nPlainLenMinTotal = 0; m_nPlainSpaceTotal = 0; uint64_t nTemp = 1; uint32_t j, k = 1; int i = 1; for(j = 0; j < m_vCharset.size(); j++) { m_nPlainLenMaxTotal += m_vCharset[j].m_nPlainLenMax; m_nPlainLenMinTotal += m_vCharset[j].m_nPlainLenMin; m_vCharset[j].m_nPlainSpaceUpToX[0] = 0; uint64_t nTemp2 = 1; for (i = 1; i <= m_vCharset[j].m_nPlainLenMax; i++) { nTemp *= m_vCharset[j].m_nPlainCharsetLen; nTemp2 *= m_vCharset[j].m_nPlainCharsetLen; if (i < m_vCharset[j].m_nPlainLenMin) { m_nPlainSpaceUpToX[k] = 0; m_vCharset[j].m_nPlainSpaceUpToX[i] = 0; } else { // special case of the last keyspace in a hybrid2 set if ( i == 1 && j > 1 && m_vCharset[j].m_nPlainCharsetLen != 1 && j == m_vCharset.size() - 1 ) { m_nPlainSpaceUpToX[k] = nTemp; } else { m_nPlainSpaceUpToX[k] = m_nPlainSpaceUpToX[k - 1] + nTemp; } m_vCharset[j].m_nPlainSpaceUpToX[i] = m_vCharset[j].m_nPlainSpaceUpToX[i - 1] + nTemp2; } k++; } m_vCharset[j].m_nPlainSpaceTotal = m_vCharset[j].m_nPlainSpaceUpToX[i-1]; if ( m_nPlainSpaceTotal == 0 ) m_nPlainSpaceTotal = m_vCharset[j].m_nPlainSpaceTotal; else m_nPlainSpaceTotal *= m_vCharset[j].m_nPlainSpaceTotal; } return true; } bool CChainWalkContext::SetRainbowTableIndex(int nRainbowTableIndex) { if (nRainbowTableIndex < 0) return false; m_nRainbowTableIndex = nRainbowTableIndex; m_nReduceOffset = 65536 * nRainbowTableIndex; return true; } bool CChainWalkContext::SetSalt(unsigned char *Salt, int nSaltLength) { memcpy(&m_Salt[0], Salt, nSaltLength); m_nSaltLen = nSaltLength; // m_sSalt = sSalt; return true; } bool CChainWalkContext::SetupWithPathName( std::string sPathName, int& nRainbowChainLen, int& nRainbowChainCount) { // something like lm_alpha#1-7_0_100x16_test.rt #ifdef _WIN32 std::string::size_type nIndex = sPathName.find_last_of('\\'); #else std::string::size_type nIndex = sPathName.find_last_of('/'); #endif if (nIndex != std::string::npos) sPathName = sPathName.substr(nIndex + 1); if (sPathName.size() < 3) { printf("%s is not a rainbow table\n", sPathName.c_str()); return false; } if (sPathName.substr(sPathName.size() - 5) == ".rti2") { RTfileFormatId = getRTfileFormatId( "RTI2" ); } else if (sPathName.substr(sPathName.size() - 4) == ".rti") { RTfileFormatId = getRTfileFormatId( "RTI" ); } else if (sPathName.substr(sPathName.size() - 3) == ".rt") { RTfileFormatId = getRTfileFormatId( "RT" ); } else { printf("%s is not a rainbow table\n", sPathName.c_str()); return false; } // Parse std::vector vPart; if (!SeperateString(sPathName, "___x_", vPart)) { printf("filename %s not identified\n", sPathName.c_str()); return false; } std::string sHashRoutineName = vPart[0]; int nRainbowTableIndex = atoi(vPart[2].c_str()); nRainbowChainLen = atoi(vPart[3].c_str()); nRainbowChainCount = atoi(vPart[4].c_str()); // Parse charset definition std::string sCharsetDefinition = vPart[1]; std::string sCharsetName; int nPlainLenMin = 0, nPlainLenMax = 0; // printf("Charset: %s", sCharsetDefinition.c_str()); if(sCharsetDefinition.substr(0, 6) == "hybrid") // Hybrid table { sCharsetName = sCharsetDefinition; } else { if ( sCharsetDefinition.find('#') == std::string::npos ) // For backward compatibility, "#1-7" is implied { sCharsetName = sCharsetDefinition; nPlainLenMin = 1; nPlainLenMax = 7; } else { std::vector vCharsetDefinitionPart; if (!SeperateString(sCharsetDefinition, "#-", vCharsetDefinitionPart)) { printf("filename %s not identified\n", sPathName.c_str()); return false; } else { sCharsetName = vCharsetDefinitionPart[0]; nPlainLenMin = atoi(vCharsetDefinitionPart[1].c_str()); nPlainLenMax = atoi(vCharsetDefinitionPart[2].c_str()); } } } // Setup if (!SetHashRoutine(sHashRoutineName)) { printf("hash routine %s not supported\n", sHashRoutineName.c_str()); return false; } if (!SetPlainCharset(sCharsetName, nPlainLenMin, nPlainLenMax)) return false; if (!SetRainbowTableIndex(nRainbowTableIndex)) { printf("invalid rainbow table index %d\n", nRainbowTableIndex); return false; } return true; } std::string CChainWalkContext::GetHashRoutineName() { return m_sHashRoutineName; } int CChainWalkContext::GetHashLen() { return m_nHashLen; } std::string CChainWalkContext::GetPlainCharsetName() { /* * XXX dumb hack to return the hybrid character set name * in rcracki_mt the call to CChainWalkContext::SetupWithPathname is static * can't modify a static std::string there */ if ( m_nHybridCharset != 0 ) { std::string characterSet = "hybrid"; if ( m_nHybridCharset == 3 ) { characterSet += "3("; characterSet += m_ks->getName(); } else { if ( m_nHybridCharset == 2 ) characterSet += "2"; characterSet += "("; for ( unsigned int i = 0; i < m_vCharset.size(); i++ ) { char tempCharsetMerge[255]; sprintf( tempCharsetMerge, "%s#%d-%d," , m_vCharset[i].m_sPlainCharsetName.c_str() , m_vCharset[i].m_nPlainLenMin, m_vCharset[i].m_nPlainLenMax ); characterSet += tempCharsetMerge; } // removing trailing , characterSet = characterSet.substr( 0, characterSet.length() - 1 ); } characterSet += ")"; return characterSet; } return m_vCharset[0].m_sPlainCharsetName; } std::string CChainWalkContext::GetPlainCharsetContent() { return m_vCharset[0].m_sPlainCharsetContent; } int CChainWalkContext::GetPlainLenMin() { if ( m_nHybridCharset != 0 ) return 0; return m_vCharset[0].m_nPlainLenMin; } int CChainWalkContext::GetPlainLenMax() { if ( m_nHybridCharset != 0 ) return 0; return m_vCharset[0].m_nPlainLenMax; } uint64_t CChainWalkContext::GetPlainSpaceTotal() { return m_nPlainSpaceTotal; } int CChainWalkContext::GetRainbowTableIndex() { return m_nRainbowTableIndex; } void CChainWalkContext::Dump() { printf("hash routine: %s\n", m_sHashRoutineName.c_str()); printf("hash length: %d\n", m_nHashLen); for ( uint32_t i = 0; i < m_vCharset.size(); i++ ) { printf( "m_vCharset[%d].m_nPlainCharSetLen: %d\n", i, m_vCharset[i].m_nPlainCharsetLen ); printf("plain charset: "); for ( uint32_t j = 0; j < m_vCharset[i].m_nPlainCharsetLen; j++ ) { if (isprint(m_vCharset[i].m_PlainCharset[j])) printf("%c", m_vCharset[i].m_PlainCharset[j]); else printf("?"); } printf("\n"); for ( int j = 0; j <= m_vCharset[i].m_nPlainLenMax; j++ ) { printf( "m_vCharset[%d].m_nPlainSpaceUpToX[%d]: %"PRIu64"\n" , i, j, m_vCharset[i].m_nPlainSpaceUpToX[j] ); } printf("plain charset in hex: "); for ( uint32_t j = 0; j < m_vCharset[i].m_nPlainCharsetLen; j++ ) printf("%02x ", m_vCharset[i].m_PlainCharset[j]); printf("\n"); printf("plain length range: %d - %d\n", m_vCharset[i].m_nPlainLenMin, m_vCharset[i].m_nPlainLenMax); printf("plain charset name: %s\n", m_vCharset[i].m_sPlainCharsetName.c_str()); printf("plain subkey space total: %s\n", uint64tostr(m_vCharset[i].m_nPlainSpaceTotal).c_str()); } for ( int i = 0; i <= m_nPlainLenMaxTotal; i++ ) { printf( "m_nPlainSpaceUpToX[%d]: %"PRIu64"\n" , i, m_nPlainSpaceUpToX[i] ); } //printf("plain charset content: %s\n", m_sPlainCharsetContent.c_str()); //for (i = 0; i <= m_nPlainLenMax; i++) // printf("plain space up to %d: %s\n", i, uint64tostr(m_nPlainSpaceUpToX[i]).c_str()); printf("plain space total: %s\n", uint64tostr(m_nPlainSpaceTotal).c_str()); printf("rainbow table index: %d\n", m_nRainbowTableIndex); printf("reduce offset: %s\n", uint64tostr(m_nReduceOffset).c_str()); printf("\n"); } void CChainWalkContext::SetIndex(uint64_t nIndex) { m_nIndex = nIndex; } void CChainWalkContext::SetHash(unsigned char* pHash) { memcpy(m_Hash, pHash, m_nHashLen); } int CChainWalkContext::normalIndexToPlain(uint64_t index, uint64_t *plainSpaceUpToX, unsigned char *charSet, int charSetLen, int min, int max, unsigned char *plain) { int a; for ( a = max - 1; a >= min; a-- ) { if ( index >= plainSpaceUpToX[a]) break; } uint32_t plainLen = a + 1; index -= plainSpaceUpToX[a]; // plainLen - 1 == a for ( a = plainLen - 1; a >= 0; a-- ) { // XXX this is optimized for 32-bit platforms #if defined(_WIN32) && !defined(__GNUC__) if (index < 0x100000000I64) break; #else if (index < 0x100000000llu) break; #endif plain[a] = charSet[index % charSetLen]; index /= charSetLen; } unsigned int index32 = (unsigned int) index; for ( ; a >= 0; a-- ) { // remarks from Sc00bz // Note the lack of assembly code. // Assembly code is not needed since all the variables are in the stack. // If you add in assembly code it will be slower than the compiler's code. plain[a] = charSet[index32 % charSetLen]; index32 /= charSetLen; } return plainLen; } void CChainWalkContext::IndexToPlain() { if (m_nHybridCharset == 3) { m_nPlainLen = m_ks->get((char*) m_Plain, m_nIndex); } else { m_nPlainLen = 0; uint64_t indexTmp = m_nIndex; uint32_t numKeySpaces = m_vCharset.size(); for ( uint32_t a = 0; a < numKeySpaces - 1; a++ ) { m_vCharset[a].m_nIndexX = indexTmp % m_vCharset[a].m_nPlainSpaceTotal; indexTmp /= m_vCharset[a].m_nPlainSpaceTotal; m_nPlainLen += normalIndexToPlain(m_vCharset[a].m_nIndexX, m_vCharset[a].m_nPlainSpaceUpToX, m_vCharset[a].m_PlainCharset, m_vCharset[a].m_nPlainCharsetLen, m_vCharset[a].m_nPlainLenMin, m_vCharset[a].m_nPlainLenMax, m_Plain + m_nPlainLen); } m_vCharset[numKeySpaces-1].m_nIndexX = indexTmp; m_nPlainLen += normalIndexToPlain(m_vCharset[numKeySpaces-1].m_nIndexX, m_vCharset[numKeySpaces-1].m_nPlainSpaceUpToX, m_vCharset[numKeySpaces-1].m_PlainCharset, m_vCharset[numKeySpaces-1].m_nPlainCharsetLen, m_vCharset[numKeySpaces-1].m_nPlainLenMin, m_vCharset[numKeySpaces-1].m_nPlainLenMax, m_Plain + m_nPlainLen); } } /* void CChainWalkContext::IndexToPlain() { int i; m_nPlainLen = 0; for (i = m_nPlainLenMaxTotal - 1; i >= m_nPlainLenMinTotal - 1; i--) { if (m_nIndex >= m_nPlainSpaceUpToX[i]) { m_nPlainLen = i + 1; break; } } if(m_nPlainLen == 0) m_nPlainLen = m_nPlainLenMinTotal; uint64_t nIndexOfX = m_nIndex - m_nPlainSpaceUpToX[m_nPlainLen - 1]; // this is the generic code for non x86/x86_64 platforms #if !defined(_M_X64) && !defined(_M_IX86) && !defined(__i386__) && !defined(__x86_64__) // generic version (slow for non 64-bit platforms and gcc < 4.5.x) for (i = m_nPlainLen - 1; i >= 0; i--) { int nCharsetLen = 0; for(uint32_t j = 0; j < m_vCharset.size(); j++) { nCharsetLen += m_vCharset[j].m_nPlainLenMax; if(i < nCharsetLen) // We found the correct charset { m_Plain[i] = m_vCharset[j].m_PlainCharset[nIndexOfX % m_vCharset[j].m_nPlainCharsetLen]; nIndexOfX /= m_vCharset[j].m_nPlainCharsetLen; break; } } } #elif defined(_M_X64) || defined(_M_IX86) || defined(__i386__) || defined(__x86_64__) // Fast ia32 version for (i = m_nPlainLen - 1; i >= 0; i--) { // 0x100000000 = 2^32 #ifdef _M_IX86 if (nIndexOfX < 0x100000000I64) break; #else if (nIndexOfX < 0x100000000llu) break; #endif int nCharsetLen = 0; for(uint32_t j = 0; j < m_vCharset.size(); j++) { nCharsetLen += m_vCharset[j].m_nPlainLenMax; if(i < nCharsetLen) // We found the correct charset { m_Plain[i] = m_vCharset[j].m_PlainCharset[nIndexOfX % m_vCharset[j].m_nPlainCharsetLen]; nIndexOfX /= m_vCharset[j].m_nPlainCharsetLen; break; } } } uint32_t nIndexOfX32 = (uint32_t)nIndexOfX; for (; i >= 0; i--) { int nCharsetLen = 0; for(uint32_t j = 0; j < m_vCharset.size(); j++) { nCharsetLen += m_vCharset[j].m_nPlainLenMax; if(i < nCharsetLen) // We found the correct charset { m_Plain[i] = m_vCharset[j].m_PlainCharset[nIndexOfX % m_vCharset[j].m_nPlainCharsetLen]; nIndexOfX /= m_vCharset[j].m_nPlainCharsetLen; break; } } } uint32_t nIndexOfX32 = (uint32_t)nIndexOfX; for (; i >= 0; i--) { int nCharsetLen = 0; for(uint32_t j = 0; j < m_vCharset.size(); j++) { nCharsetLen += m_vCharset[j].m_nPlainLenMax; if(i < nCharsetLen) // We found the correct charset { // m_Plain[i] = m_vCharset[j].m_PlainCharset[nIndexOfX32 % m_vCharset[j].m_nPlainCharsetLen]; // nIndexOfX32 /= m_vCharset[j].m_nPlainCharsetLen; // moving nPlainCharsetLen into the asm body and avoiding the extra temp // variable results in a performance gain // unsigned int nPlainCharsetLen = m_vCharset[j].m_nPlainCharsetLen; unsigned int nTemp; #if defined(_WIN32) && !defined(__GNUC__) // VC++ still needs this unsigned int nPlainCharsetLen = m_vCharset[j].m_nPlainCharsetLen; __asm { mov eax, nIndexOfX32 xor edx, edx div nPlainCharsetLen mov nIndexOfX32, eax mov nTemp, edx } m_Plain[i] = m_vCharset[j].m_PlainCharset[nTemp]; #else __asm__ __volatile__ ("xor %%edx, %%edx;" "divl %3;" : "=a"(nIndexOfX32), "=d"(nTemp) : "a"(nIndexOfX32), "rm"(m_vCharset[j].m_nPlainCharsetLen) : ); m_Plain[i] = m_vCharset[j].m_PlainCharset[nTemp]; #endif break; } } } #endif } */ void CChainWalkContext::PlainToHash() { m_pHashRoutine(m_Plain, m_nPlainLen, m_Hash); } void CChainWalkContext::HashToIndex(int nPos) { // breaks strict aliasing //m_nIndex = (*(uint64_t*)m_Hash + m_nReduceOffset + nPos) % m_nPlainSpaceTotal; memcpy( m_Hash_alias.m_Hash, m_Hash, 8 ); m_nIndex = (m_Hash_alias.alias + m_nReduceOffset + nPos) % m_nPlainSpaceTotal; } uint64_t CChainWalkContext::GetIndex() { return m_nIndex; } const uint64_t *CChainWalkContext::GetIndexPtr() { return &m_nIndex; } std::string CChainWalkContext::GetPlain() { std::string sRet; int i; for (i = 0; i < m_nPlainLen; i++) { char c = m_Plain[i]; if (c >= 32 && c <= 126) sRet += c; else sRet += '?'; } return sRet; } std::string CChainWalkContext::GetBinary() { return HexToStr(m_Plain, m_nPlainLen); } std::string CChainWalkContext::GetHash() { return HexToStr(m_Hash, m_nHashLen); } bool CChainWalkContext::CheckHash(unsigned char* pHash) { if (memcmp(m_Hash, pHash, m_nHashLen) == 0) return true; return false; } uint8_t CChainWalkContext::getRTfileFormat() { return RTfileFormatId; } rcracki-mt-0.7.0/rcracki_mt/ChangeLog.txt0000640000175000017500000001166312043323352017566 0ustar dookiedookie[rcracki_mt ChangeLog] 0.7.0 (28 Oct 2012, 21:42:52): * charset.txt if missing from the running dir falls back to an internal set * merge gui (GTK) * Add -d to run sha1 hashes against mysqlsha1 tables (sourceforge bug #2940042) * HashAlgorithm.cpp/HashRoutine.cpp finally share the common versions * hybrid2 keyspace calculations corrected * cuda support (pre-calculation only as false alarm checking still has bugs) * refactoring of all RT file readers * refactoring of CrackEngine.cpp 0.6.6 (11 Jul 2011, 01:42:30): * RTI2.0 - improved format with header * memory leak fixes * file descriptor leak fixes * OSX (and some other compiler) warnings fixed * sourceforge bug #2926357 fix factorial for permutation display for unicode correction move from clock() to gettimeofday() * fix sourceforge bug #2875013, output ntlm case correction to -o file * merged with common/rt_api to remove some of the duplication of files * new make release target to make life easier for me in light of the merge * cleanup of using namespace std; and other using * constructs * move to the use of stat for filename length over the fseek/ftell method 0.6.5.2 (06 Nov 2010, 20:40:05): * rti2 fixes part 2 * UINT4 -> uint32 * memory long/unsigned cleanup 0.6.5.1 (25 Oct 2010, 15:50:10): * rti2 fixes courtesy of PowerBlade 0.6.5 (24 Oct 2010, 18:21:25): * code changes to allow building via mingw and avoid VC++ * linux thread priority set to nice value of 2 * rti2 support * replaced clock_t usage with gettimeofday * add pre-calculation timing per feature request #3025688 from sourceforge * fix bug #3050821 from sourceforge - missing break for non x86/x86_64 arch * improve hash performance by moving off openssl to the local faster methods * sha1 local implementation was *slower* than openssl for x86/x86_64 0.6.4 (05 Jul 2010, 03:12): * add -m to allow users to limit memory usage - courtesy of uroskn * fix memory code that made incorrect assumptions about the MemoryPool * fix linux memory code - using only info.freeram is incorrect * cleanup of the nested if/elif/else stuctures * annotate x86 specific sections of code * licensing review and GPLv2 compliance * cleanup of unused items * restructure Makefile * cleanup memory leaks 0.6.3 (21 Oct 2009, 21:05): * Fixed x86_64 linux compilation * Fixed x86_64 linux segmentation fault * Fixed 64bit support in md4 code * Added support for: FreeBSD, NetBSD, OpenBSD, and MacOSX 0.6.2 (2 Jul 2009, 13:37): * Fixed linux support (tty stuff and now actually compiles) * Fixed precalculation code 0.6.1 (14 May 2009, 22:12): * bug fixed where the list of rainbow tables is doubled when you resume a session and you have default RT locations in your ini 0.6 (14 May 2009, 20:47): * Finding .rti files recursively * Fixed memory allocation bugs (also trying to save appropriate amount of memory for chainwalksets... these can become really large with the new tables) * Real pause/resume function, you can resume a session with -r * Session support, use -s session_name. Combine this with -r to resume a session other then the default * Ini file support, store some default values such as rainbow table directories. * Tab separated results (stdout) * Support pause during cracking and 'skip' during unicode correction for Linux * A readme / 'manual' ! 0.5 (16 Apr 2009, 22:47): * Support for the old non-indexed .rt format, it should work with both type of tables in one run... I didn't test this feature thoroughly * Using some other pieces of code for algorithms * Support for .lst files from Cain as input (patch from James Dickson) - use for example -c LMNT.lst * Fixed some bugs * Dunno anymore, left this version lying around for too long... 0.4 (oops, a second 0.4) (13 Dec 2008, 18:20): * Improved file reading performance 0.4 (27 Nov 2008, 00:09): * Source included * Memory usage down to about 50% (tnx sc00bz for pointing out the inefficiency, tnx jci for helping with the code) * Works under Linux! (using pthreads now instead of Windows threads) * Speed up: implemented MD4 reference implementation, not using OpenSSL for NTLM anymore (tnx Bitweasil for supplying 98% of the code) * Speed up: using OpenSSL a lot faster (tnx jci for pointing that out) * Probably some more small things i forgot 0.3 (16 Nov 2008, 01:01): * Improved command line argument parsing (order no longer matters) * Option to write (temporary) output to a file, use -o pick_a_nice_filename.txt * Option to pause, press 'P' to pause/unpause (Windows only) * For pwdump searches: unicode correction is done when case correction fails 0.2 (28 Oct 2008, 01:42): * False alarm checking now also multi threaded * Search one level of subdirectories for rainbow table files 0.1 (27 Oct 2008, 00:14): * Initial multithreaded version, using Windows threads. * Using multiple threads for the pre-calculation part. * Added a simple 'progress' message, so you can see how many hashes are being pre-calculated rcracki-mt-0.7.0/rcracki_mt/Public.h0000640000175000017500000001121212043323152016551 0ustar dookiedookie/* * freerainbowtables is a project for generating, distributing, and using * perfect rainbow tables * * Copyright (C) Zhu Shuanglei * Copyright Martin Westergaard Jørgensen * Copyright 2009, 2010 Daniël Niggebrugge * Copyright 2009, 2010, 2011, 2012 James Nobis * Copyright 2011 Logan Watt * * This file is part of freerainbowtables. * * freerainbowtables is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, version 2 of the License. * * freerainbowtables is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with freerainbowtables. If not, see . */ #ifndef _PUBLIC_H #define _PUBLIC_H #define __STDC_FORMAT_MACROS /* for PRI macros */ #define __STDC_LIMIT_MACROS /* for uint64_t, UINT64_MAX, etc. */ #include "global.h" #include #include #if defined(_WIN32) && !defined(__GNUC__) #include "inttypes.h" #else #include "/usr/include/inttypes.h" #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #if defined(_WIN32) && !defined(__GNUC__) #include #endif struct RainbowChainO { uint64_t nIndexS; uint64_t nIndexE; }; #if defined(_WIN32) && !defined(__GNUC__) #pragma warning(disable: 4201) #endif union RainbowChain { uint64_t nIndexS; struct { unsigned short foo[3]; unsigned short nIndexE; }; //int nCheckPoint; }; #if defined(_WIN32) && !defined(__GNUC__) #pragma warning(default : 4201) #endif struct RainbowChainCP { uint64_t startpt; uint64_t endpt; unsigned short checkpts; }; struct IndexChain { uint64_t nPrefix; uint32_t nFirstChain; uint32_t nChainCount; }; /* rcracki_mt IndexChain #pragma pack(1) union IndexChain { uint64_t nPrefix; //5 struct { unsigned char foo[5]; unsigned int nFirstChain; //4 unsigned short nChainCount; //2 }; //unsigned short nChainCount; (maybe union with nPrefix, 1 byte spoiled, no pack(1) needed) }; #pragma pack() */ struct IndexRow { uint64_t prefix; unsigned int prefixstart, numchains; }; typedef struct { std::string sName; int nPlainLenMin; int nPlainLenMax; } tCharset; #define MAX_PLAIN_LEN 256 #define MIN_HASH_LEN 8 #define MAX_HASH_LEN 256 #define MAX_SALT_LEN 256 typedef struct { uint64_t m_nPlainSpaceUpToX[MAX_PLAIN_LEN]; // Performance consideration //unsigned char m_PlainCharset[255]; unsigned char m_PlainCharset[MAX_PLAIN_LEN]; uint64_t m_nPlainSpaceTotal; uint64_t m_nIndexX; unsigned int m_nPlainCharsetLen; int m_nPlainLenMin; int m_nPlainLenMax; std::string m_sPlainCharsetName; std::string m_sPlainCharsetContent; } stCharset; // XXX nmap is GPL2, will check newer releases regarding license // Code comes from nmap, used for the linux implementation of kbhit() #ifndef _WIN32 #include #include #include int tty_getchar(); void tty_done(); void tty_init(); void tty_flush(void); // end nmap code #endif #if defined(_WIN32) && !defined(__GNUC__) int gettimeofday( struct timeval *tv, struct timezone *tz ); #else #include #endif timeval sub_timeofday( timeval tv2, timeval tv ); long GetFileLen(FILE* file); long GetFileLen(char* file); long GetFileLen( std::string file ); uint8_t getRTfileFormatId( std::string RTfileFormatName ); std::string TrimString( std::string s ); bool boinc_ReadLinesFromFile( std::string sPathName, std::vector& vLine ); bool ReadLinesFromFile( std::string sPathName, std::vector& vLine); bool SeperateString( std::string s, std::string sSeperator, std::vector& vPart); std::string uint64tostr(uint64_t n); std::string uint64tohexstr(uint64_t n); std::string HexToBinary( const char* data, int len ); std::string HexToStr(const unsigned char* pData, int nLen); unsigned long GetAvailPhysMemorySize(); std::string GetApplicationPath(); void ParseHash( std::string sHash, unsigned char* pHash, int& nHashLen ); bool GetHybridCharsets( std::string sCharset, std::vector& vCharset ); void Logo(); bool writeResultLineToFile( std::string sOutputFile, std::string sHash, std::string sPlain, std::string sBinary ); #endif rcracki-mt-0.7.0/rcracki_mt/lm2ntlm.h0000640000175000017500000000552512043323152016732 0ustar dookiedookie/* * rcracki_mt is a multithreaded implementation and fork of the original * RainbowCrack * * Copyright 2009, 2010 Daniël Niggebrugge * Copyright 2009, 2010, 2011, 2012 James Nobis * * This file is part of rcracki_mt. * * rcracki_mt is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * rcracki_mt is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with rcracki_mt. If not, see . */ #ifndef _LM2NTLM_H #define _LM2NTLM_H #include "Public.h" #include #include #include #ifdef _WIN32 #include #include #include #endif #include "signal.h" #include "fast_md4.h" class LM2NTLMcorrector { public: LM2NTLMcorrector(); private: std::map > m_mapChar; uint64_t progressCurrentCombination; uint64_t totalCurrentCombination; uint64_t counterOverall; unsigned char NTLMHash[16]; timeval tvStart, tvEnd, tvFinal; int countCombinations; int countTotalCombinations; int counter; clock_t previousClock; unsigned char currentCharmap[16][128]; bool aborting; std::string sBinary; private: bool checkNTLMPassword(unsigned char* pLMPassword, int nLMPasswordLen, std::string& sNTLMPassword); bool startCorrecting(std::string sLMPassword, std::string& sNTLMPassword, unsigned char* pLMPassword); void printString(unsigned char* muteThis, int length); void setupCombinationAtPositions(int length, unsigned char* pMuteMe, unsigned char* pTempMute, int* jAtPos, bool* fullAtPos, int* sizeAtPos); bool checkPermutations(int length, unsigned char* pTempMute, int* jAtPos, int* sizeAtPos, unsigned char* pLMPassword, std::string& sNTLMPassword); int calculateTotalCombinations(int length, int setSize); uint64_t factorial (int num); bool parseHexPassword(std::string hexPassword, std::string& sPlain); bool NormalizeHexString(std::string& sHash); void ParseHash(std::string sHash, unsigned char* pHash, int& nHashLen); std::string ByteToStr(const unsigned char* pData, int nLen); void addToMapW(unsigned char key, unsigned char value1, unsigned char value2); void fillMapW(); void checkAbort(); void writeEndStats(); public: bool LMPasswordCorrectUnicode(std::string hexPassword, unsigned char* NTLMHash, std::string& sNTLMPassword); std::string getBinary(); }; #endif rcracki-mt-0.7.0/rcracki_mt/RTI2Common.h0000640000175000017500000000715512043323152017237 0ustar dookiedookie/* * freerainbowtables is a project for generating, distributing, and using * perfect rainbow tables * * Copyright 2011 Steve Thomas (Sc00bz) * Copyright 2011, 2012 James Nobis * * This file is part of freerainbowtables. * * freerainbowtables is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * freerainbowtables is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with freerainbowtables. If not, see . */ #ifndef _RTI2COMMON_H #define _RTI2COMMON_H #include "Public.h" struct Chain { uint64_t startPoint, endPoint; // uint64_t checkBits; }; struct CharacterSet { std::vector characterSet1; std::vector characterSet2; std::vector characterSet3; std::vector characterSet4; }; struct SubKeySpace { uint8_t hybridSets; std::vector passwordLength; std::vector charSetFlags; std::vector perPositionCharacterSets; }; struct RTI20_Header_RainbowTableParameters { uint64_t minimumStartPoint; uint32_t chainLength; uint32_t tableIndex; uint8_t algorithm; // 0 - Reserved // 1 - LM // 2 - NTLM // 3 - MD2 // 4 - MD4 // 5 - MD5 // 6 - Double MD5 // 7 - Binary Double MD5 // 8 - Cisco Pix (96 bit MD5) // 9 - SHA1 // 10 - MySQL SHA1 // 11 - SHA256 // 12 - SHA384 // 13 - SHA512 // 14 - RipeMD160 // 15 - MSCache // 16 - Half LM Challenge // 17 - Second Half LM Challenge // 18 - NTLM Challenge // 19 - Oracle uint8_t reductionFunction; // 0 - RC ("RainbowCrack" uses divide - project-rainbowcrack.com) // 1 - FPM ("Fixed Point Multiplication" - tobtu.com) // 2 - GRT ("GPU RT" uses lookup tables - cryptohaze.com) std::string salt; std::vector subKeySpaces; std::vector checkPointPositions; }; struct RTI20_Header { uint8_t major, minor; // '2', '0' uint8_t startPointBits, endPointBits, checkPointBits; uint32_t fileIndex, files; RTI20_Header_RainbowTableParameters rtParams; }; struct RTI20_Index { uint64_t firstPrefix; std::vector prefixIndex; }; struct RTI20_File { RTI20_Header header; RTI20_Index index; struct // RTI20_Data { uint8_t *data; }; }; #pragma pack(1) struct RTI20_File_Header { uint32_t tag; // "RTI2" uint8_t minor; // '0' uint8_t startPointBits, endPointBits, checkPointBits; uint32_t fileIndex, files; struct { uint64_t minimumStartPoint; uint32_t chainLength; uint32_t tableIndex; uint8_t algorithm; // 0 - Custom // 1 - LM // 2 - NTLM // 3 - MD2 // 4 - MD4 // 5 - MD5 // 6 - Double MD5 // 7 - Binary Double MD5 // 8 - Cisco Pix (96 bit MD5) // 9 - SHA1 // 10 - MySQL SHA1 // 11 - SHA256 // 12 - SHA384 // 13 - SHA512 // 14 - RipeMD160 // 15 - MSCache // 16 - Half LM Challenge // 17 - Second Half LM Challenge // 18 - NTLM Challenge // 19 - Oracle uint8_t reductionFunction; // 0 - RC ("RainbowCrack" uses divide - project-rainbowcrack.com) // 1 - FPM ("Fixed Point Multiplication" - tobtu.com) // 2 - GRT ("GPU RT" uses lookup tables - cryptohaze.com) }; }; #pragma pack() // you can't use pack(0) - it makes VC++ angry uint8_t getAlgorithmId( std::string algorithmName ); #endif rcracki-mt-0.7.0/rcracki_mt/RTIReader.h0000640000175000017500000000537312043323152017127 0ustar dookiedookie/* * freerainbowtables is a project for generating, distributing, and using * perfect rainbow tables * * Copyright 2010, 2011 Martin Westergaard Jørgensen * Copyright 2010, 2011, 2012 James Nobis * Copyright 2011 Logan Watt * * This file is part of freerainbowtables. * * freerainbowtables is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * freerainbowtables is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with freerainbowtables. If not, see . */ #ifndef _RTIREADER_H #define _RTIREADER_H #include "BaseRTReader.h" // http://www.tobtu.com/rtcalc.php#info -- RTI file format info class RTIReader : public BaseRTReader { private: uint32_t chainSize; // 8 bytes -> 6 byte start point + 2 byte end point uint32_t indexSize; // 11 bytes -> 5 byte EP prefix + 4 byte Chain offset + 2 bytes number of chains std::string indexFileName; FILE *indexFileData; struct stat fileStats; struct stat indexFileStats; IndexChain *index; void RTIReaderInit(); protected: /// Set methods void setChainSize(uint32_t); void setIndexFileName(std::string); void loadIndex(); public: /// Default Constructor RTIReader(); /** Constructor with filename * @param std::string file name on disk * index file is std::string + '.index' */ RTIReader( std::string filename ); /** * Argument Constructor * @param uint32_t number of chains in the file * @param uint32_t size of the chain * @param uint32_t reduction function index offset * @param uint32_t start point in the chain * @param uint32_t end point in the chain * @param std::string name of the file on disk * @param std::string salt used for hash */ RTIReader(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, std::string, std::string); /// Destructor ~RTIReader(); /// Get Methods std::string getIndexFileName(); uint32_t getChainSize(); uint32_t getIndexSize(); // XXX used for debugging, can remove later if not needed uint32_t getIndexFileSize(); uint32_t getDataFileSize(); FILE* getIndexFileData(); FILE* getDataFile(); // XXX end debug type functions int readChains(uint32_t &numChains, RainbowChainO *pData); uint32_t getChainsLeft(); uint64_t getMinimumStartPoint(); void Dump(); }; #endif rcracki-mt-0.7.0/rcracki_mt/RainbowCrack.h0000640000175000017500000000357712043323152017717 0ustar dookiedookie/* * rcracki_mt is a multithreaded implementation and fork of the original * RainbowCrack * * Copyright (C) Zhu Shuanglei * Copyright Martin Westergaard Jørgensen * Copyright 2009, 2010 Daniël Niggebrugge * Copyright 2009 James Dickson * Copyright 2009, 2010, 2011, 2012 James Nobis * Copyright 2010 uroskn * Copyright 2010, 2011, 2012 Paragon * Copyright 2011 Logan Watt * Copyright 2011 Jan Kyska * * Modified by Martin Westergaard Jørgensen to support * indexed and hybrid tables * * Modified by neinbrucke to support multi threading and a bunch of other stuff :) * * 2009-01-04 - - Slightly modified (or "fulhack" as * we say in sweden) to support cain .lst files. * * This file is part of rcracki_mt. * * rcracki_mt is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * rcracki_mt is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with rcracki_mt. If not, see . */ void LoadLMHashFromPwdumpFile(std::string, std::vector&, std::vector&, std::vector&); void GetTableList(std::string, std::vector&); void LoadLMHashFromCainLSTFile(std::string, std::vector&, std::vector&, std::vector&); bool NormalizeHash(std::string&); void *rcracki_mt(void*); rcracki-mt-0.7.0/rcracki_mt/RTI2Reader.cpp0000640000175000017500000003737512043323152017553 0ustar dookiedookie/* * freerainbowtables is a project for generating, distributing, and using * perfect rainbow tables * * Copyright 2010, 2011 Martin Westergaard Jørgensen * Copyright 2010, 2011, 2012 James Nobis * Copyright 2011 Logan Watt * * This file is part of freerainbowtables. * * freerainbowtables is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * freerainbowtables is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with freerainbowtables. If not, see . */ #include "RTI2Reader.h" RTI2Reader::RTI2Reader( std::string filename ) { SubKeySpace subKeySpace; CharacterSet charSet; char *str; uint8_t *indexTmp; uint32_t a, b, count, sum = 0, subKeySpacesCount = 0, hybridSets = 0, passwordLength = 0; int ret; uint8_t characterSetFlags; chainPosition = 0; // XXX for reading straight from data in memory //indexOffset = 0; fin.open( filename.c_str(), std::ios_base::binary | std::ios_base::in ); if( !fin.seekg( 0, std::ios_base::beg ).good() || !fin.read( (char*) (&header), sizeof(header) ).good() ) { std::cerr << "readHeader fin.read() error" << std::endl; exit( 1 ); // file error } if ( header.tag != 0x32495452 ) // RTI2 { std::cerr << "readHeader bad tag - this is not a RTI2 file" << std::endl; exit( 3 ); // bad tag } if ( header.minor != 0 ) { std::cerr << "readHeader bad minor version" << std::endl; exit( 4 ); // bad minor version } if ( header.startPointBits == 0 || header.startPointBits > 64 ) { std::cerr << "readHeader parsing error" << std::endl; std::cerr << "header.startPointBits: " << header.startPointBits << std::endl; exit( 2 ); // invalid header } if ( header.endPointBits == 0 || header.endPointBits > 64 ) { std::cerr << "readHeader parsing error" << std::endl; std::cerr << "header.endPointBits: " << header.endPointBits << std::endl; exit( 2 ); // invalid header } if ( header.checkPointBits > 64 ) { std::cerr << "readHeader parsing error" << std::endl; std::cerr << "header.checkPointBits: " << header.checkPointBits << std::endl; exit( 2 ); // invalid header } if ( header.startPointBits + header.checkPointBits + header.endPointBits > 64 ) { std::cerr << "readHeader parsing error" << std::endl; std::cerr << "header.startPointBits + header.checkPointBits + header.endPointBits > 64" << std::endl; std::cerr << "header.startPointBits: " << header.startPointBits << std::endl; std::cerr << "header.endPointBits: " << header.endPointBits << std::endl; std::cerr << "header.checkPointBits: " << header.checkPointBits << std::endl; exit( 2 ); // invalid header } if ( header.fileIndex > header.files ) { std::cerr << "readHeader parsing error" << std::endl; std::cerr << "fileIndex: " << header.fileIndex << std::endl; std::cerr << "files: " << header.files << std::endl; exit( 2 ); // invalid header } if ( header.algorithm > 19 ) { std::cerr << "readHeader parsing error" << std::endl; std::cerr << "undefined algorithm: " << header.algorithm << std::endl; exit( 2 ); // invalid header } if ( header.reductionFunction > 2 || (header.reductionFunction < 1 && header.tableIndex > 65535) || (header.reductionFunction == 1 && header.tableIndex > 255)) { std::cerr << "readHeader parsing error" << std::endl; std::cerr << "invalid reductionFunction parameters" << std::endl; std::cerr << "header.reductionFunction: " << header.reductionFunction << std::endl; std::cerr << "header.tableIndex: " << header.tableIndex << std::endl; exit( 2 ); // invalid header } if ( header.tableIndex != 0 && ((header.reductionFunction < 1 && header.chainLength - 2 > header.tableIndex << 16) || (header.reductionFunction == 2 && header.chainLength > header.tableIndex))) // I think this might be "header.chainLength - 2 > header.tableIndex" need to double check { // Sc00bz remarks "(these tables suck)" std::cerr << "WARNING: Table index is not large enough for this chain length" << std::endl; } str = new char[1024]; if ( header.algorithm == 0 ) { std::cerr << "readHeader fin.read() error, reserved algorithm" << std::endl; delete [] str; exit( 2 ); } // Salt setSalt( "" ); if ( header.algorithm == 0 || ( header.algorithm >= 15 && header.algorithm <= 19 )) { ret = readRTI2String( fin, str ); if ( ret < 0 ) { std::cerr << "readHeader fin.read() error, salt" << std::endl; delete [] str; exit( -ret ); } str[ret] = 0; setSalt( str ); } // Sub keyspaces subKeySpaces.clear(); subKeySpacesCount = 0; if ( !fin.read( (char*) (&subKeySpacesCount), 1 ).good() ) { std::cerr << "readHeader fin.read() error" << std::endl; delete [] str; exit( 1 ); // file error } if ( subKeySpacesCount == 0 ) { std::cerr << "readHeader fin.read() error" << std::endl; std::cerr << "subKeySpaces missing from header" << std::endl; delete [] str; exit( 2 ); // invalid header } for ( a = 0; a < subKeySpacesCount; a++ ) { subKeySpace.perPositionCharacterSets.clear(); subKeySpace.passwordLength.clear(); if ( !fin.read( (char*) (&hybridSets), 1 ).good() ) { std::cerr << "readHeader fin.read() error" << std::endl; delete [] str; exit( 1 ); // file error } if ( hybridSets == 0 ) { std::cerr << "readHeader fin.read() error, hybridSets is 0" << std::endl; delete [] str; exit( 2 ); // invalid header } subKeySpace.hybridSets = hybridSets; // Hybrid sets for ( b = 0; b < hybridSets; b++ ) { // Password length if ( !fin.read( (char*) (&passwordLength), 1 ).good() ) { std::cerr << "readHeader fin.read() error" << std::endl; delete [] str; exit( 1 ); // file error } if ( passwordLength == 0 ) { std::cerr << "readHeader fin.read() error, passwordLength is 0" << std::endl; delete [] str; exit( 2 ); //invalid header } subKeySpace.passwordLength.push_back( passwordLength ); // Character set flags if ( !fin.read( (char*) (&characterSetFlags), 1 ).good() ) { std::cerr << "readHeader fin.read() error" << std::endl; delete [] str; exit( 1 ); // file error } if ( characterSetFlags == 0 ) { std::cerr << "readHeader fin.read() error, characterSetFlags is 0" << std::endl; delete [] str; exit( 2 ); // invalid header } subKeySpace.charSetFlags.push_back( characterSetFlags ); // Character set charSet.characterSet1.clear(); charSet.characterSet2.clear(); charSet.characterSet3.clear(); charSet.characterSet4.clear(); if ( characterSetFlags & 1 ) { ret = readRTI2String( fin, str, 1 ); if ( ret < 0 ) { delete [] str; exit( -ret ); } charSet.characterSet1.assign((uint8_t*) str, ((uint8_t*) str) + ret ); } if ( characterSetFlags & 2 ) { ret = readRTI2String( fin, str, 2 ); if ( ret < 0 ) { delete [] str; exit( -ret ); } charSet.characterSet2.assign((uint16_t*) str, ((uint16_t*) str) + ret ); } if ( characterSetFlags & 4 ) { ret = readRTI2String( fin, str, 3 ); if ( ret < 0 ) { delete [] str; exit( -ret ); } charSet.characterSet3.assign((uint24_t*) str, ((uint24_t*) str) + ret ); } if ( characterSetFlags & 8 ) { ret = readRTI2String( fin, str, 4 ); if ( ret < 0 ) { delete [] str; exit( -ret ); } charSet.characterSet4.assign((uint32_t*) str, ((uint32_t*) str) + ret ); } subKeySpace.perPositionCharacterSets.push_back(charSet); } subKeySpaces.push_back(subKeySpace); } // Check point positions if ( !fin.read( str, 4 * header.checkPointBits ).good() ) { std::cerr << "readHeader fin.read() error" << std::endl; delete [] str; exit( 1 ); // file error } checkPointPositions.assign((uint32_t*) str, ((uint32_t*) str) + header.checkPointBits); delete [] str; // *** Index *** if ( !fin.read( (char*) (&index.firstPrefix), 8 ).good() ) { std::cerr << "readIndex fin.read() error" << std::endl; exit( 1 ); // file error } if ( !fin.read((char*) (&count), 4 ).good() ) { std::cerr << "readIndex fin.read() error" << std::endl; exit( 1 ); // file error } if ( count == 0 ) { std::cerr << "readIndex fin.read() error, prefixIndex count is 0" << std::endl; exit( 1 ); // file error } indexTmp = new uint8_t[count]; if ( !fin.read( (char*) indexTmp, count ).good() ) { std::cerr << "readIndex fin.read() error" << std::endl; delete [] indexTmp; exit( 1 ); // file error } index.prefixIndex.reserve(count + 1); index.prefixIndex.push_back(sum); for (a = 0; a < count; a++) { sum += indexTmp[a]; index.prefixIndex.push_back(sum); } delete [] indexTmp; // *** Data *** chainSizeBytes = (header.startPointBits + header.checkPointBits + header.endPointBits + 7) >> 3; chainCount = sum; /* * reads everything at once...doesn't work for memory constrained env data = new uint8_t[chainSizeBytes * sum + 8 - chainSizeBytes]; // (8 - chainSizeBytes) to avoid "reading past the end of the array" error if ( !fin.read( (char*) (data), chainSizeBytes * sum ).good() ) { std::cerr << "readData fin.read() error" << std::endl; delete [] data; data = NULL; exit( 1 ); // file error } */ } RTI2Reader::~RTI2Reader() { if ( fin.good() ) fin.close(); /* if ( data != NULL ) delete [] data; data = NULL; */ } int RTI2Reader::readRTI2String( std::ifstream &fin, void *str, uint32_t charSize ) { /* * String length (1 byte) * String (String length bytes or (charSize * (String length + 1)) bytes) */ uint32_t size = 0; int ret = 0; if ( !fin.read( (char*) (&ret), 1 ).good() ) { std::cerr << "readHeader find.read() error" << std::endl; return -1; // file error } if ( charSize ) { ret++; size = charSize * ret; } if ( size > 0 ) { if ( !fin.read( (char*) str, size ).good() ) { std::cerr << "readHeader fin.read() error" << std::endl; return -1; //file error } } return ret; } uint32_t RTI2Reader::getChainsLeft() { return chainCount - chainPosition; } void RTI2Reader::Dump() { std::cout << "header.tag: " << header.tag << std::endl; std::cout << "header.minor: " << (uint32_t)header.minor << std::endl; std::cout << "header.startPointBits: " << (uint32_t)header.startPointBits << std::endl; std::cout << "header.endPointBits: " << (uint32_t)header.endPointBits << std::endl; std::cout << "header.checkPointBits: " << (uint32_t)header.checkPointBits << std::endl; std::cout << "header.fileIndex: " << (uint32_t)header.fileIndex << std::endl; std::cout << "header.files: " << (uint32_t)header.files << std::endl; std::cout << "header.minimumStartPoint: " << (uint64_t)header.minimumStartPoint << std::endl; std::cout << "header.chainLength: " << (uint32_t)header.chainLength << std::endl; std::cout << "header.tableIndex: " << (uint16_t)header.tableIndex << std::endl; std::cout << "header.algorithm: " << (uint32_t)header.algorithm << std::endl; std::cout << "header.reductionFunction: " << (uint32_t)header.reductionFunction << std::endl; if ( getSalt().size() > 0 ) std::cout << "header.salt: " << getSalt() << std::endl; std::cout << "subKeySpaces Count: " << subKeySpaces.size() << std::endl; for ( uint32_t i = 0; i < subKeySpaces.size(); i++ ) { std::cout << "subKeySpace " << i + 1 << std::endl; std::cout << "Number of hybrid sets: " << (uint32_t)subKeySpaces[i].hybridSets << std::endl; for ( uint32_t j = 0; j < (uint32_t)subKeySpaces[i].hybridSets; j++ ) { std::cout << "Hybrid set " << j + 1 << std::endl; std::cout << "Password length: " << (uint32_t)subKeySpaces[i].passwordLength[j] << std::endl; std::cout << "charSetFlags: " << (uint32_t)subKeySpaces[i].charSetFlags[j] << std::endl; if ( subKeySpaces[i].charSetFlags[j] & 1 ) { std::cout << "characterSet1: "; for ( uint32_t k = 0; k < subKeySpaces[i].perPositionCharacterSets[j].characterSet1.size(); k++ ) { std::cout << subKeySpaces[i].perPositionCharacterSets[j].characterSet1[k]; } std::cout << std::endl; } } } std::cout << "header.checkPointBits: " << (uint32_t)header.checkPointBits << std::endl; if ( (uint32_t)header.checkPointBits > 0 ) { std::cout << "checkPointPositions:"; for ( uint32_t i = 0; i < (uint32_t)header.checkPointBits; i++ ) { std::cout << " " << checkPointPositions[i]; } std::cout << std::endl; } std::cout << "index.firstPrefix: " << index.firstPrefix << std::endl; std::cout << "index.prefixIndex.size(): " << index.prefixIndex.size() << std::endl; /* for ( uint32_t i = 0; i < index.prefixIndex.size(); i++ ) { std::cout << "index.prefixIndex[" << i << "]: " << index.prefixIndex[i] << std::endl; } */ // XXX data } // convert in memory rti2 to rt reading from the file as needed int RTI2Reader::readChains(unsigned int &numChains, RainbowChainO *pData) { unsigned int readChains = 0; unsigned int chainsleft = getChainsLeft(); uint64_t endPointMask = (( (uint64_t) 1 ) << header.endPointBits ) - 1; uint64_t startPointMask = (( (uint64_t) 1 ) << header.startPointBits ) - 1; uint32_t startPointShift = header.endPointBits; /* uint64_t checkPointMask = (( (uint64_t) ) << header.checkPointBits ) - 1; uint32_t checkPointShift = header.endPointBits + header.StartPointBits; */ uint64_t chainrow = 0; uint32_t i=1; union { uint8_t str[8];// = {0}; uint64_t alias; } str; str.alias = 0; // Fast forward to current position // XXX for chainPosition != 0 use a binary search // XXX get rid of this whole monstronsity for a nice pointer for( i = 1; i < index.prefixIndex.size(); i++ ) { if ( i == 1 && index.prefixIndex[i] > 0 && chainPosition == 0 ) { break; } if ( ( chainPosition + readChains ) > index.prefixIndex[i] ) { i++; break; } } for( ; i < index.prefixIndex.size(); i++ ) { /* XXX this is completely redundant * try the next index position if ( (chainPosition + readChains ) > index.prefixIndex[i] ) continue; */ while ( (chainPosition + readChains ) < index.prefixIndex[i] ) { // XXX for reading straight from data in memory //chainrow = *((uint64_t*) ( data + ( ( index.prefixIndex[i-1] + indexOffset ) * chainSizeBytes ) )); if ( !fin.read( (char*) (str.str), chainSizeBytes ).good() ) { std::cerr << "readData fin.read() error" << std::endl; exit( 1 ); // file error } chainrow = str.alias; // end point prefix pData[readChains].nIndexE = ( index.firstPrefix + i - 1 ) << header.endPointBits; // end point suffix pData[readChains].nIndexE |= chainrow & endPointMask; pData[readChains].nIndexS = ((chainrow >> startPointShift) & startPointMask) + header.minimumStartPoint; readChains++; // XXX for reading straight from data in memory //indexOffset++; if ( readChains == numChains || readChains == chainsleft ) break; } if ( readChains == numChains ) break; // XXX for reading straight from data in memory //indexOffset = 0; } if ( readChains != numChains ) numChains = readChains; // Update how many chains we read chainPosition += readChains; std::cout << "Chain Position is now " << chainPosition << std::endl; return 0; } void RTI2Reader::setMinimumStartPoint( uint64_t minimumStartPoint ) { header.minimumStartPoint = minimumStartPoint; } /// getChainSizeBytes uint32_t RTI2Reader::getChainSizeBytes() { return this->chainSizeBytes; } /// getMinimumStartPoint uint64_t RTI2Reader::getMinimumStartPoint() { return header.minimumStartPoint; } rcracki-mt-0.7.0/rcracki_mt/RTReader.h0000640000175000017500000000406612043323152017014 0ustar dookiedookie/* * freerainbowtables is a project for generating, distributing, and using * perfect rainbow tables * * Copyright 2010, 2011 Martin Westergaard Jørgensen * Copyright 2010, 2011, 2012 James Nobis * Copyright 2011 Logan Watt * * This file is part of freerainbowtables. * * freerainbowtables is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * freerainbowtables is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with freerainbowtables. If not, see . */ #ifndef _RTREADER_H #define _RTREADER_H #include "BaseRTReader.h" /** * Reader class for original .rt file format */ class RTReader : public BaseRTReader { private: uint32_t chainSize; struct stat fileStats; void RTReaderInit(); protected: public: /// Default Constructor RTReader(); /** Constructor with filename * @param std::string file name on disk */ RTReader(std::string); /** * Argument Constructor * @param uint32_t number of chains in the file * @param uint32_t size of the chain * @param uint32_t reduction function index offset * @param uint32_t start point in the chain * @param uint32_t end point in the chain * @param std::string name of the file on disk * @param std::string salt used for hash */ RTReader(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, std::string, std::string); /// Destructor ~RTReader(); /// Get Methods uint32_t getChainSize(); uint32_t getDataFileSize(); int readChains(uint32_t&, RainbowChainO*); uint32_t getChainsLeft(); uint64_t getMinimumStartPoint(); }; #endif rcracki-mt-0.7.0/rcracki_mt/Makefile.cuda0000640000175000017500000002165212043323152017546 0ustar dookiedookie# rcracki_mt is a multithreaded implementation and fork of the original # RainbowCrack # # Copyright Martin Westergaard Jørgensen # Copyright 2009, 2010 Daniël Niggebrugge # Copyright 2009, 2010, 2011, 2012 James Nobis # # This file is part of rcracki_mt. # # rcracki_mt is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 2 of the License, or # (at your option) any later version. # # rcracki_mt is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with rcracki_mt. If not, see . SHELL = /bin/sh BIN = $(DESTDIR)/usr/bin CC = g++ # -mtune=native doesn't work on NetBSD 5.1 with gcc 4.1.3 and make (fine with gmake) # -mtune=native doesn't work on OSX either # add -mtune=native to OPTIMIZATION for better performance (if it works) OPTIMIZATION = -O3 INCLUDES = -I. -I$(CUDA_PATH)/include CFLAGS = -Wall -ansi $(INCLUDES) $(OPTIMIZATION) -c $(DEBUG) -DGPU NVCCFLAGS = --ptxas-options=-v LFLAGS = -Wall -ansi -filt $(INCLUDES) $(OPTIMIZATION) $(DEBUG) \ -L$(CUDA_PATH)/lib64 -L$(CUDA_PATH)/lib -L. -Xlinker -rpath . LIBS = -L/lib -L/usr/lib -lcrypto -lpthread -lcudart OBJS = BaseRTReader.o ChainWalkContext.o ChainWalkSet.o CrackEngine.o \ fast_md4.o fast_md5.o HashAlgorithm.o HashRoutine.o HashSet.o keyspace.o \ lm2ntlm.o MemoryPool.o Public.o RainbowCrack.o rcrackiThread.o rcuda_ext.o \ rcuda.o RTReader.o RTIReader.o RTI2Reader.o COMMON_API_PATH = . CUDA_SHARED_PATH = . CUDA_PATH = /usr/local/cuda CUDA_LIB = libcudart.so.2 #sha1.o WARNALL = -Wextra -Wunused-macros -Wunsafe-loop-optimizations -Wundef -Woverlength-strings -Wdisabled-optimization -Wformat-extra-args -Wformat-security -Winline OSNAME = $(shell uname -s) # apparently --strip-debug works on FreeBSD, Linux, NetBSD, OpenBSD, and NetBSD # but not on OSX which only takes the short name -S # OpenSolaris effectively uses -x # Oh lets just forget this until we have autoconf #STRIP = $(shell which strip) -S #LIBS_Darwin = #LIBS_FreeBSD = #LIBS_Linux = LIBS_NetBSD = -ldes #LIBS_OpenBSD = #LIBS_SunOS = LIBS += ${LIBS_$(OSNAME)} RELEASE_DIR = rcracki_mt_0.7_beta2_src #all: rcracki_mt strip all: rcracki_mt rcracki_mt: $(OBJS) $(CC) -DGPU $(LFLAGS) $(OBJS) $(LIBS) -o rcracki_mt clean: rm -f core *.o *.gcno *.gcda *.gcov rcracki_mt rcracki.session \ rcracki.progress rcracki.precalc.0 rcracki.precalc.0.index debug: DEBUG += -DDEBUG -g debug: rcracki_mt debugall: DEBUG += -DDEBUG -g $(WARNALL) debugall: rcracki_mt dumpasmall: DEBUG += -S -fverbose-asm dumpasmall: rcracki_mt dumpasmprofileuseall: DEBUG += -S -fverbose-asm dumpasmprofileuseall: profileuseall debugprofileuseall: DEBUG += -fprofile-use debugprofileuseall: debugall m32: DEBUG += -m32 m32: rcracki_mt m32debug: DEBUG += -m32 m32debug: debug m32debugall: DEBUG += -m32 m32debugall: debugall m32dumpasmall: DEBUG += -m32 m32dumpasmall: dumpasmall m32dumpasmprofileuseall: DEBUG += -S -fverbose-asm -m32 m32dumpasmprofileuseall: profileuseall m32profilegenall: DEBUG += -m32 m32profilegenall: profilegenall m32profileuseall: DEBUG += -m32 m32profileuseall: profileuseall profilegenall: DEBUG += -fprofile-generate $(WARNALL) profilegenall: rcracki_mt profileuseall: DEBUG += -fprofile-use $(WARNALL) profileuseall: rcracki_mt gcovall: DEBUG += -DDEBUG -g -fprofile-arcs -ftest-coverage gcovall: rcracki_mt gprofall: DEBUG += -DDEBUG -g -pg gprofall: rcracki_mt install: install -d $(BIN) install --group=root --owner=root --mode=755 rcracki_mt $(BIN) release: clean mkdir $(RELEASE_DIR) cp $(COMMON_API_PATH)/architecture.h $(COMMON_API_PATH)/BaseRTReader.* \ $(COMMON_API_PATH)/ChainWalkContext.* \ $(COMMON_API_PATH)/ChainWalkSet.* CrackEngine.* \ $(COMMON_API_PATH)/fast_md5.* $(COMMON_API_PATH)/keyspace.* \ $(COMMON_API_PATH)/HashAlgorithm.* $(COMMON_API_PATH)/HashRoutine.* \ HashSet.* $(COMMON_API_PATH)/global.h \ lm2ntlm.* $(COMMON_API_PATH)/fast_md4.* $(COMMON_API_PATH)/MemoryPool.* \ $(COMMON_API_PATH)/Public.* RainbowCrack.* $(CUDA_SHARED_PATH)/rcuda.h \ $(CUDA_SHARED_PATH)/rcuda.cu $(CUDA_SHARED_PATH)/rcuda_ext.cpp \ $(CUDA_SHARED_PATH)/rcuda_ext.h $(CUDA_SHARED_PATH)/rcuda_lm.inc \ $(CUDA_SHARED_PATH)/rcuda_md4.inc $(CUDA_SHARED_PATH)/rcuda_md5.inc \ $(CUDA_SHARED_PATH)/rcuda_ntlm.inc $(CUDA_SHARED_PATH)/rcuda_sha1.inc \ rcrackiThread.* $(COMMON_API_PATH)/RTI2Common.* \ $(COMMON_API_PATH)/RT*Reader.* sha1.* ChangeLog.txt charset.txt COPYING \ INSTALLING.txt README.txt TODO rcracki_mt.ini ../../LICENSE.txt \ $(RELEASE_DIR)/ cat Makefile | sed 's/..\/..\/common\/rt_api/./' > $(RELEASE_DIR)/Makefile cat Makefile.cuda | sed 's/..\/..\/common\/rt_api/./' | \ sed 's/..\/..\/boinc_software\/boinc_client_apps\/distrrtgen_cuda/./' \ > $(RELEASE_DIR)/Makefile.cuda rebuild: clean all static: DEBUG += -static -static-libgcc static: all #strip: # $(STRIP) rcracki_mt uninstall: rm -f $(BIN)/rcracki_mt BaseRTReader.o: $(COMMON_API_PATH)/BaseRTReader.h \ $(COMMON_API_PATH)/BaseRTReader.cpp $(CC) $(CFLAGS) $(COMMON_API_PATH)/BaseRTReader.cpp ChainWalkContext.o: $(COMMON_API_PATH)/ChainWalkContext.h \ $(COMMON_API_PATH)/ChainWalkContext.cpp $(COMMON_API_PATH)/HashRoutine.h \ $(COMMON_API_PATH)/Public.h $(CC) $(CFLAGS) $(COMMON_API_PATH)/ChainWalkContext.cpp ChainWalkSet.o: $(COMMON_API_PATH)/Public.h $(COMMON_API_PATH)/ChainWalkSet.h \ $(COMMON_API_PATH)/ChainWalkSet.cpp $(CC) $(CFLAGS) $(COMMON_API_PATH)/ChainWalkSet.cpp CrackEngine.o: $(COMMON_API_PATH)/Public.h HashSet.h \ $(COMMON_API_PATH)/ChainWalkContext.h $(COMMON_API_PATH)/MemoryPool.h \ $(COMMON_API_PATH)/ChainWalkSet.h rcrackiThread.h \ $(COMMON_API_PATH)/RTReader.h $(COMMON_API_PATH)/RTIReader.h \ $(COMMON_API_PATH)/RTI2Reader.h CrackEngine.h CrackEngine.cpp $(CC) $(CFLAGS) CrackEngine.cpp fast_md5.o: $(COMMON_API_PATH)/fast_md5.h $(COMMON_API_PATH)/fast_md5.cpp \ $(COMMON_API_PATH)/global.h $(CC) $(CFLAGS) $(COMMON_API_PATH)/fast_md5.cpp #HashAlgorithm.o: $(COMMON_API_PATH)/HashAlgorithm.h HashAlgorithm.cpp \ $(COMMON_API_PATH)/Public.h $(COMMON_API_PATH)/fast_md5.h \ $(COMMON_API_PATH)/fast_md4.h sha1.h HashAlgorithm.o: $(COMMON_API_PATH)/HashAlgorithm.h \ $(COMMON_API_PATH)/HashAlgorithm.cpp $(COMMON_API_PATH)/Public.h \ $(COMMON_API_PATH)/fast_md5.h $(COMMON_API_PATH)/fast_md4.h $(CC) $(CFLAGS) $(COMMON_API_PATH)/HashAlgorithm.cpp HashRoutine.o: $(COMMON_API_PATH)/HashRoutine.h \ $(COMMON_API_PATH)/HashRoutine.cpp $(COMMON_API_PATH)/global.h \ $(COMMON_API_PATH)/HashAlgorithm.h $(CC) $(CFLAGS) $(COMMON_API_PATH)/HashRoutine.cpp HashSet.o: HashSet.h HashSet.cpp $(COMMON_API_PATH)/Public.h $(CC) $(CFLAGS) HashSet.cpp keyspace.o: $(COMMON_API_PATH)/keyspace.h $(COMMON_API_PATH)/global.h \ $(COMMON_API_PATH)/architecture.h $(CC) $(CFLAGS) $(COMMON_API_PATH)/keyspace.cpp lm2ntlm.o: lm2ntlm.h lm2ntlm.cpp $(COMMON_API_PATH)/Public.h \ $(COMMON_API_PATH)/fast_md4.h $(CC) $(CFLAGS) lm2ntlm.cpp fast_md4.o: $(COMMON_API_PATH)/fast_md4.h $(COMMON_API_PATH)/fast_md4.cpp \ $(COMMON_API_PATH)/global.h $(CC) $(CFLAGS) $(COMMON_API_PATH)/fast_md4.cpp MemoryPool.o: $(COMMON_API_PATH)/MemoryPool.h \ $(COMMON_API_PATH)/MemoryPool.cpp $(COMMON_API_PATH)/Public.h \ $(COMMON_API_PATH)/global.h $(CC) $(CFLAGS) $(COMMON_API_PATH)/MemoryPool.cpp Public.o: $(COMMON_API_PATH)/Public.h $(COMMON_API_PATH)/Public.cpp \ $(COMMON_API_PATH)/global.h $(CC) $(CFLAGS) $(COMMON_API_PATH)/Public.cpp RainbowCrack.o: RainbowCrack.cpp CrackEngine.h lm2ntlm.h $(CC) $(CFLAGS) RainbowCrack.cpp rcrackiThread.o: rcrackiThread.h rcrackiThread.cpp \ $(COMMON_API_PATH)/ChainWalkContext.h $(COMMON_API_PATH)/Public.h HashSet.h $(CC) -I$(CUDA_SHARED_PATH) $(CFLAGS) rcrackiThread.cpp rcuda_ext.o: $(CUDA_SHARED_PATH)/rcuda_ext.h $(CUDA_SHARED_PATH)/rcuda_ext.cpp $(COMMON_API_PATH)/ChainWalkContext.h $(CC) $(CFLAGS) $(CUDA_SHARED_PATH)/rcuda_ext.cpp rcuda.o: $(CUDA_SHARED_PATH)/rcuda.h $(CUDA_SHARED_PATH)/rcuda.cu $(COMMON_API_PATH)/Public.h $(COMMON_API_PATH)/global.h $(CUDA_PATH)/bin/nvcc --compiler-bindir=/usr/bin/gcc-4.3 $(OPTIMIZATION) \ $(NVCCDEBUG) $(NVCCFLAGS) --compiler-options="$(DEBUG)" \ --compiler-options="$(CXXFLAGS)" -I. \ --compile $(CUDA_SHARED_PATH)/rcuda.cu RTReader.o: $(COMMON_API_PATH)/RTReader.h $(COMMON_API_PATH)/RTReader.cpp $(CC) $(CFLAGS) $(COMMON_API_PATH)/RTReader.cpp RTIReader.o: $(COMMON_API_PATH)/RTIReader.h $(COMMON_API_PATH)/RTIReader.cpp $(CC) $(CFLAGS) $(COMMON_API_PATH)/RTIReader.cpp RTI2Reader.o: $(COMMON_API_PATH)/RTI2Reader.h \ $(COMMON_API_PATH)/RTI2Reader.cpp $(COMMON_API_PATH)/BaseRTReader.h $(CC) $(CFLAGS) $(COMMON_API_PATH)/RTI2Reader.cpp #sha1.o: sha1.h sha1.cpp $(COMMON_API_PATH)/global.h # $(CC) $(CFLAGS) sha1.cpp rcracki-mt-0.7.0/rcracki_mt/rcuda_md5.inc0000640000175000017500000001401212043323152017521 0ustar dookiedookie// freerainbowtables is a project for generating, distributing, and using // perfect rainbow tables // // Copyright 2010, 2011 Jan Kyska // Copyright 2010 Martin Westergaard Jørgensen // Copyright 2010, 2011, 2012 James Nobis // // This file is part of freerainbowtables. // // freerainbowtables is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 2 of the License, or // (at your option) any later version. // // freerainbowtables is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with freerainbowtables. If not, see . namespace RC_MD5 { __device__ __constant__ unsigned int h[4] = { 0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476 }; __device__ __constant__ unsigned char r[64] = { \ 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, \ 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, \ 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, \ 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21 }; __device__ __constant__ unsigned char g[64] = { \ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, \ 1, 6, 11, 0, 5, 10, 15, 4, 9, 14, 3, 8, 13, 2, 7, 12, \ 5, 8, 11, 14, 1, 4, 7, 10, 13, 0, 3, 6, 9, 12, 15, 2, \ 0, 7, 14, 5, 12, 3, 10, 1, 8, 15, 6, 13, 4, 11, 2, 9 }; __device__ __constant__ unsigned int ac[64] = { \ 0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, \ 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501, \ 0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be, \ 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821, \ \ 0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa, \ 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8, \ 0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, \ 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a, \ \ 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c, \ 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70, \ 0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05, \ 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665, \ \ 0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, \ 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1, \ 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, \ 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391 }; __device__ unsigned int FF(unsigned int a, unsigned int b, unsigned int c, unsigned int d, int i, const unsigned int* data) { unsigned int ret; ret = a + ((b&c)|((~b)&d)) + ac[i] + data[SHIDX(g[i])]; ret = (ret<>(32-r[i])); ret += b; return ret; } __device__ unsigned int GG(unsigned int a, unsigned int b, unsigned int c, unsigned int d, int i, const unsigned int* data) { unsigned int ret; ret = a + ((b&d)|(c&(~d))) + ac[i] + data[SHIDX(g[i])]; ret = (ret<>(32-r[i])); ret += b; return ret; } __device__ unsigned int HH(unsigned int a, unsigned int b, unsigned int c, unsigned int d, int i, const unsigned int* data) { unsigned int ret; ret = a + (b^c^d) + ac[i] + data[SHIDX(g[i])]; ret = (ret<>(32-r[i])); ret += b; return ret; } __device__ unsigned int II(unsigned int a, unsigned int b, unsigned int c, unsigned int d, int i, const unsigned int* data) { unsigned int ret; ret = a + (c^(b|(~d))) + ac[i] + data[SHIDX(g[i])]; ret = (ret<>(32-r[i])); ret += b; return ret; } __device__ void MD5(unsigned int* dataHash) { unsigned int a = h[0], b = h[1], c = h[2], d = h[3], x; int ii; // Round 1 for(ii = 0; ii < 16; ii++) { x = b; b = FF(a, b, c, d, ii, dataHash); a = d; d = c; c = x; } // Round 2 for(; ii < 32; ii++) { x = b; b = GG(a, b, c, d, ii, dataHash); a = d; d = c; c = x; } // Round 3 for(; ii < 48; ii++) { x = b; b = HH(a, b, c, d, ii, dataHash); a = d; d = c; c = x; } // Round 4 for(; ii < 64; ii++) { x = b; b = II(a, b, c, d, ii, dataHash); a = d; d = c; c = x; } dataHash[SHIDX(0)] = a + h[0]; dataHash[SHIDX(1)] = b + h[1]; dataHash[SHIDX(2)] = c + h[2]; dataHash[SHIDX(3)] = d + h[3]; } } #define RT_MD5_KERNEL(kerName, kerPrologue, kerEpilogue) \ __global__ void kerName(unsigned int chainStart, unsigned int chainStop) { \ unsigned int size, jj; \ unsigned int plain; \ \ kerPrologue; \ \ /* transform to the plain text */ \ plain = 0x80; \ jj = (PLAIN_MAX_SIZE>>2)+1; \ \ RTGEN_IDX2PLAIN_BEGIN; \ RTGEN_I2P_LOOP64_BEGIN; \ plain = (plain<<8) | cplChrSet[(dimItem.z&255u) + uiDiv]; \ if((ii&3) == 2) { \ hData[SHIDX(jj--)] = plain; \ plain = 0; \ } \ RTGEN_I2P_LOOP64_END; \ \ RTGEN_I2P_LOOP32_BEGIN; \ plain = (plain<<8) | cplChrSet[(dimItem.z&255u) + uiDiv]; \ if((ii&3) == 2) { \ hData[SHIDX(jj--)] = plain; \ plain = 0; \ } \ RTGEN_I2P_LOOP32_END; \ RTGEN_IDX2PLAIN_END; \ \ /* prepare for MD5 */ \ size = ii; \ ii = ((((3-(ii&3))<<3)-1)&0x1f)+1; \ plain = plain<>2)+1; plain = hData[SHIDX(jj++)], idx++) \ hData[SHIDX(idx)] = (plain>>ii)|(hData[SHIDX(jj)]<<(32-ii)); \ hData[SHIDX(idx)] = plain>>ii; \ for(idx++; idx < 14; idx++) \ hData[SHIDX(idx)] = 0; \ hData[SHIDX(idx++)] = size<<3; \ hData[SHIDX(idx)] = 0; \ \ /* hash */ \ RC_MD5::MD5(hData); \ \ kerEpilogue; \ } RT_MD5_KERNEL(RTGenMD5Kernel, RTGEN_PROLOGUE, RTGEN_EPILOGUE) RT_MD5_KERNEL(RTPreCalcMD5Kernel, RTPRECALC_PROLOGUE, RTPRECALC_EPILOGUE) RT_MD5_KERNEL(RTCheckAlarmMD5Kernel, RTCHKALARM_PROLOGUE, RTCHKALARM_EPILOGUE) rcracki-mt-0.7.0/rcracki_mt/sha1.h0000640000175000017500000000216012043323152016171 0ustar dookiedookie/* * rcracki_mt is a multithreaded implementation and fork of the original * RainbowCrack * * Copyright 2009, 2010 Daniël Niggebrugge * Copyright 2009, 2010, 2011, 2012 James Nobis * * This file is part of rcracki_mt. * * rcracki_mt is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * rcracki_mt is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with rcracki_mt. If not, see . */ #ifndef _SHA1_H #define _SHA1_H #include "global.h" #define SHA1_DIGEST_LENGTH 20 void SHA1_NEW( unsigned char * pData, int length, unsigned char * pDigest); #endif /* !_SHA1_H */ rcracki-mt-0.7.0/rcracki_mt/RainbowCrack.cpp0000640000175000017500000011233412043323152020242 0ustar dookiedookie/* * rcracki_mt is a multithreaded implementation and fork of the original * RainbowCrack * * Copyright (C) Zhu Shuanglei * Copyright Martin Westergaard Jrgensen * Copyright 2009, 2010 Danil Niggebrugge * Copyright 2009 James Dickson * Copyright 2009, 2010, 2011, 2012 James Nobis * Copyright 2010 uroskn * Copyright 2010, 2011, 2012 Paragon * Copyright 2011 Logan Watt * Copyright 2011 Jan Kyska * * Modified by Martin Westergaard Jrgensen to support * indexed and hybrid tables * * Modified by neinbrucke to support multi threading and a bunch of other stuff :) * * 2009-01-04 - - Slightly modified (or "fulhack" as * we say in sweden) to support cain .lst files. * * This file is part of rcracki_mt. * * rcracki_mt is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * rcracki_mt is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with rcracki_mt. If not, see . */ #include "Public.h" #include "CrackEngine.h" #include "lm2ntlm.h" #ifdef GUI #include #include "GUI.h" #include #include "RainbowCrack.h" extern GUI_l gui; extern Database db; extern Settings settings; extern TableDir *tabledir; #endif #ifdef _WIN32 #include #else #include #include #endif #if defined(_WIN32) && !defined(__GNUC__) #pragma comment(lib, "libeay32.lib") #endif ////////////////////////////////////////////////////////////////////// #ifdef _WIN32 void GetTableList( std::string sWildCharPathName, std::vector& vPathName ) { std::string sPath; std::string::size_type n = sWildCharPathName.find_last_of('\\'); if ( n == (sWildCharPathName.size() - 1) ) { sWildCharPathName = sWildCharPathName.substr(0, n); n = sWildCharPathName.find_last_of('\\'); } if (n != std::string::npos) sPath = sWildCharPathName.substr(0, n + 1); _finddata_t fd; long handle = _findfirst(sWildCharPathName.c_str(), &fd); if (handle != -1) { do { std::string sName = fd.name; if (sName.size()>3) { if (sName.substr(sName.size()-3, 3) == ".rt" && !(fd.attrib & _A_SUBDIR)) { std::string sPathName = sPath + sName; vPathName.push_back(sPathName); } } if (sName.size()>4) { if (sName.substr(sName.size()-4, 4) == ".rti" && !(fd.attrib & _A_SUBDIR)) { std::string sPathName = sPath + sName; vPathName.push_back(sPathName); } } if (sName.size()>5) { if (sName.substr(sName.size()-5, 5) == ".rti2" && !(fd.attrib & _A_SUBDIR)) { std::string sPathName = sPath + sName; vPathName.push_back(sPathName); } } if (sName != "." && sName != ".." && (fd.attrib & _A_SUBDIR)) { std::string sPath_sub = sPath + sName + '\\'; std::string sWildCharPathName_sub = sPath_sub + '*'; GetTableList(sWildCharPathName_sub, vPathName); } } while (_findnext(handle, &fd) == 0); _findclose(handle); } //printf("Found %d rainbowtables (files) in %d sub directories...\n", vPathName.size(), subDir_count); } #else //void GetTableList(int argc, char* argv[], vector& vPathName) void GetTableList( std::string sWildCharPathName, std::vector& vPathName ) { struct stat buf; if (lstat(sWildCharPathName.c_str(), &buf) == 0) { if (S_ISDIR(buf.st_mode)) { DIR *dir = opendir(sWildCharPathName.c_str()); if(dir) { struct dirent *pDir=NULL; while((pDir = readdir(dir)) != NULL) { std::string filename = ""; filename += (*pDir).d_name; if (filename != "." && filename != "..") { std::string new_filename = sWildCharPathName + '/' + filename; GetTableList(new_filename, vPathName); } } closedir(dir); } } else if (S_ISREG(buf.st_mode)) { if (sWildCharPathName.size()>3) { if (sWildCharPathName.substr(sWildCharPathName.size()-3, 3) == ".rt") { vPathName.push_back(sWildCharPathName); } } if (sWildCharPathName.size()>4) { if (sWildCharPathName.substr(sWildCharPathName.size()-4, 4) == ".rti") { //string sPathName_sub = sPath_sub + sName_sub; vPathName.push_back(sWildCharPathName); //printf("sPathName_sub: %s\n", sPathName_sub.c_str()); } } if ( sWildCharPathName.size() > 5 ) { if ( sWildCharPathName.substr( sWildCharPathName.size() - 5, 5 ) == ".rti2" ) { vPathName.push_back( sWildCharPathName ); } } } } } #endif bool NormalizeHash(std::string& sHash) { std::string sNormalizedHash = sHash; if ( sNormalizedHash.size() % 2 != 0 || sNormalizedHash.size() < MIN_HASH_LEN * 2 || sNormalizedHash.size() > MAX_HASH_LEN * 2) return false; // Make lower uint32_t i; for (i = 0; i < sNormalizedHash.size(); i++) { if (sNormalizedHash[i] >= 'A' && sNormalizedHash[i] <= 'F') sNormalizedHash[i] = (char) sNormalizedHash[i] - 'A' + 'a'; } // Character check for (i = 0; i < sNormalizedHash.size(); i++) { if ( (sNormalizedHash[i] < 'a' || sNormalizedHash[i] > 'f') && (sNormalizedHash[i] < '0' || sNormalizedHash[i] > '9')) return false; } sHash = sNormalizedHash; return true; } void LoadLMHashFromPwdumpFile( std::string sPathName, std::vector& vUserName, std::vector& vLMHash, std::vector& vNTLMHash ) { std::vector vLine; if (ReadLinesFromFile(sPathName, vLine)) { uint32_t i; for (i = 0; i < vLine.size(); i++) { std::vector vPart; if (SeperateString(vLine[i], "::::", vPart)) { std::string sUserName = vPart[0]; std::string sLMHash = vPart[2]; std::string sNTLMHash = vPart[3]; if (sLMHash.size() == 32 && sNTLMHash.size() == 32) { if (NormalizeHash(sLMHash) && NormalizeHash(sNTLMHash)) { vUserName.push_back(sUserName); vLMHash.push_back(sLMHash); vNTLMHash.push_back(sNTLMHash); #ifdef GUI gtk_list_store_append(gui.hash.store, &gui.hash.iter[db.n_hashes]); gtk_list_store_set(gui.hash.store, &gui.hash.iter[db.n_hashes], 0, "NTLM", 1, 32, 2, sNTLMHash.c_str(), -1); gtk_list_store_set(gui.hash.store, &gui.hash.iter[db.n_hashes], 0, "LM", 1, 32, 2, sLMHash.c_str(), -1); db.n_hashes++; #endif } else { #ifdef GUI MessageStackPush("col-grey", "Invalid lm/ntlm hash: %s:%s\n", sLMHash.c_str(), sNTLMHash.c_str()); #else std::cout << "invalid lm/ntlm hash " << sLMHash.c_str() << ":" << sNTLMHash.c_str() << std::endl; #endif } } } } } else { #ifdef GUI MessageStackPush("col-red", "Can't open %s\n", sPathName.c_str()); #else std::cout << "can't open " << sPathName.c_str() << std::endl; #endif } } // 2009-01-04 - james.dickson - Added this so we can load hashes from cain .LST files. void LoadLMHashFromCainLSTFile( std::string sPathName, std::vector& vUserName, std::vector& vLMHash, std::vector& vNTLMHash ) { std::vector vLine; if (ReadLinesFromFile(sPathName, vLine)) { uint32_t i; for (i = 0; i < vLine.size(); i++) { std::vector vPart; if (SeperateString(vLine[i], "\t\t\t\t\t\t", vPart)) { std::string sUserName = vPart[0]; std::string sLMHash = vPart[4]; std::string sNTLMHash = vPart[5]; if (sLMHash.size() == 32 && sNTLMHash.size() == 32) { if (NormalizeHash(sLMHash) && NormalizeHash(sNTLMHash)) { vUserName.push_back(sUserName); vLMHash.push_back(sLMHash); vNTLMHash.push_back(sNTLMHash); #ifdef GUI gtk_list_store_append(gui.hash.store, &gui.hash.iter[db.n_hashes]); gtk_list_store_set(gui.hash.store, &gui.hash.iter[db.n_hashes], 0, "NTLM", 1, 32, 2, sNTLMHash.c_str(), -1); db.n_hashes++; gtk_list_store_append(gui.hash.store, &gui.hash.iter[db.n_hashes]); gtk_list_store_set(gui.hash.store, &gui.hash.iter[db.n_hashes], 0, "LM", 1, 32, 2, sLMHash.c_str(), -1); db.n_hashes++; #endif } else { #ifdef GUI MessageStackPush("col-grey", "Invalid lm/ntlm hash %s:%s\n", sLMHash.c_str(), sNTLMHash.c_str()); #else std::cout << "invalid lm/ntlm hash " << sLMHash.c_str() << ":" << sNTLMHash.c_str() << std::endl; #endif } } } } } else { #ifdef GUI MessageStackPush("col-red", "Can't open %s\n", sPathName.c_str()); #else std::cout << "can't open " << sPathName.c_str() << std::endl; #endif } } bool NTLMPasswordSeek(unsigned char* pLMPassword, int nLMPasswordLen, int nLMPasswordNext, unsigned char* pNTLMHash, std::string& sNTLMPassword) { if (nLMPasswordNext == nLMPasswordLen) { unsigned char md[MD4_DIGEST_LENGTH]; MD4_NEW(pLMPassword, nLMPasswordLen * 2, md); if (memcmp(md, pNTLMHash, MD4_DIGEST_LENGTH) == 0) { sNTLMPassword = ""; int i; for (i = 0; i < nLMPasswordLen; i++) sNTLMPassword += char(pLMPassword[i * 2]); return true; } else return false; } if (NTLMPasswordSeek(pLMPassword, nLMPasswordLen, nLMPasswordNext + 1, pNTLMHash, sNTLMPassword)) return true; if ( pLMPassword[nLMPasswordNext * 2] >= 'A' && pLMPassword[nLMPasswordNext * 2] <= 'Z') { pLMPassword[nLMPasswordNext * 2] = (unsigned char) pLMPassword[nLMPasswordNext * 2] - 'A' + 'a'; if (NTLMPasswordSeek(pLMPassword, nLMPasswordLen, nLMPasswordNext + 1, pNTLMHash, sNTLMPassword)) return true; pLMPassword[nLMPasswordNext * 2] = (unsigned char) pLMPassword[nLMPasswordNext * 2] - 'a' + 'A'; } return false; } bool LMPasswordCorrectCase( std::string sLMPassword, unsigned char* pNTLMHash, std::string& sNTLMPassword ) { if (sLMPassword.size() == 0) { sNTLMPassword = ""; return true; } unsigned char* pLMPassword = new unsigned char[sLMPassword.size() * 2]; uint32_t i; for (i = 0; i < sLMPassword.size(); i++) { pLMPassword[i * 2 ] = sLMPassword[i]; pLMPassword[i * 2 + 1] = 0x00; } bool fRet = NTLMPasswordSeek(pLMPassword, sLMPassword.size(), 0, pNTLMHash, sNTLMPassword); delete pLMPassword; return fRet; } #ifndef GUI void Usage() { Logo(); std::cout << "usage: rcracki_mt -h hash rainbow_table_pathname" << std::endl << " rcracki_mt -l hash_list_file rainbow_table_pathname" << std::endl << " rcracki_mt -f pwdump_file rainbow_table_pathname" << std::endl << " rcracki_mt -c lst_file rainbow_table_pathname" << std::endl << std::endl << "-h hash: use raw hash as input" << std::endl << "-l hash_list_file: use hash list file as input, each hash in a line" << std::endl << "-f pwdump_file: use pwdump file as input, handles lanmanager hash only" << std::endl << "-c lst_file: use .lst (cain format) file as input" << std::endl << "-r [-s session_name]: resume from previous session, optional session name" << std::endl << "rainbow_table_pathname: pathname(s) of the rainbow table(s)" << std::endl << std::endl << "Extra options: -t [nr] use this amount of threads/cores, default is 1" << std::endl << " -o [output_file] write (temporary) results to this file" << std::endl << " -s [session_name] write session data with this name" << std::endl << " -k keep precalculation on disk" << std::endl << " -d run sha1 hashes against mysqlsha1 tables" << std::endl << " -m [megabytes] limit memory usage" << std::endl << " -v show debug information" << std::endl #ifdef GPU << " -g enable calculations on GPU" << std::endl #endif << std::endl; #ifdef _WIN32 std::cout << "example: rcracki_mt -h 5d41402abc4b2a76b9719d911017c592 -t 2 [path]\\MD5" << std::endl << " rcracki_mt -l hash.txt [path_to_specific_table]\\*" << std::endl; #else std::cout << "example: rcracki_mt -h 5d41402abc4b2a76b9719d911017c592 -t 2 [path]/MD5" << std::endl << " rcracki_mt -l hash.txt [path_to_specific_table]/*" << std::endl; #endif std::cout << " rcracki_mt -f hash.txt -t 4 -o results.txt *.rti" << std::endl; } int main(int argc, char* argv[]) { if (argc < 2) { Usage(); return 0; } std::vector vPathName; std::vector vDefaultRainbowTablePath; std::string sWildCharPathName = ""; std::string sInputType = ""; std::string sInput = ""; std::string outputFile = ""; std::string sApplicationPath = ""; std::string sIniPathName = "rcracki_mt.ini"; bool writeOutput = false; std::string sSessionPathName = "rcracki.session"; std::string sProgressPathName = "rcracki.progress"; std::string sPrecalcPathName = "rcracki.precalc"; bool resumeSession = false; bool useDefaultRainbowTablePath = false; bool debug = false; bool keepPrecalcFiles = false; bool runSha1AgainstMysqlSha1 = false; int enableGPU = 0; std::string sAlgorithm = ""; int maxThreads = 1; uint64_t maxMem = 0; CHashSet hs; // Read defaults from ini file; bool readFromIni = false; std::vector vLine; if (ReadLinesFromFile(sIniPathName, vLine)) { readFromIni = true; } else if (ReadLinesFromFile(GetApplicationPath() + sIniPathName, vLine)) { readFromIni = true; } if (readFromIni) { uint32_t i; for (i = 0; i < vLine.size(); i++) { if (vLine[i].substr(0,1) != "#") { std::vector vPart; if (SeperateString(vLine[i], "=", vPart)) { std::string sOption = vPart[0]; std::string sValue = vPart[1]; if (sOption == "Threads") { maxThreads = atoi(sValue.c_str()); } else if (sOption == "MaxMemoryUsage" ) { maxMem = atoi(sValue.c_str()) * 1024 *1024; } else if (sOption == "DefaultResultsFile") { outputFile = sValue; } else if (sOption == "AlwaysStoreResultsToFile") { if (sValue == "1") writeOutput = true; } else if (sOption.substr(0,24) == "DefaultRainbowTablePath.") { //printf("Default RT path: %s\n", sValue.c_str()); vDefaultRainbowTablePath.push_back(vLine[i]); } else if (sOption == "DefaultAlgorithm") { useDefaultRainbowTablePath = true; sAlgorithm = sValue; } else if (sOption == "AlwaysDebug") { if (sValue == "1") debug = true; } else if (sOption == "EnableGPU") { if (sValue == "1") enableGPU = 1; } else if (sOption == "AlwaysKeepPrecalcFiles") { if (sValue == "1") keepPrecalcFiles = true; } else { std::cout << "illegal option " << sOption.c_str() << " in ini file " << sIniPathName.c_str() << std::endl; return 0; } } } } if (writeOutput && outputFile == "") { std::cout << "You need to specify a 'DefaultResultsFile' " << "with 'AlwaysStoreResultsToFile=1'" << std::endl; writeOutput = false; } } // Parse command line arguments int i; for (i = 1; i < argc; i++) { std::string cla = argv[i]; if (cla == "-h") { sInputType = cla; i++; if (i < argc) sInput = argv[i]; } else if (cla == "-l") { sInputType = cla; i++; if (i < argc) sInput = argv[i]; } else if (cla == "-f") { sInputType = cla; i++; if (i < argc) sInput = argv[i]; } else if (cla == "-c") { sInputType = cla; i++; if (i < argc) sInput = argv[i]; } else if (cla == "-t") { i++; if (i < argc) maxThreads = atoi(argv[i]); } else if ( cla == "-d" ) { runSha1AgainstMysqlSha1 = true; } else if ( cla == "-m" ) { i++; if ( i < argc ) maxMem = atoi(argv[i]) * 1024 * 1024; } else if (cla == "-o") { writeOutput = true; i++; if (i < argc) outputFile = argv[i]; } else if (cla == "-r") { resumeSession = true; } else if (cla == "-s") { i++; if (i < argc) { sSessionPathName = argv[i]; sSessionPathName += ".session"; sProgressPathName = argv[i]; sProgressPathName += ".progress"; sPrecalcPathName = argv[i]; sPrecalcPathName += ".precalc"; } } else if (cla == "-v") { debug = true; } else if (cla == "-g") { enableGPU = 1; } else if (cla == "-k") { keepPrecalcFiles = true; } else if (cla == "-a") { useDefaultRainbowTablePath = true; i++; if (i < argc) sAlgorithm = argv[i]; } else { GetTableList(cla, vPathName); } } if (debug && !readFromIni) std::cout << "Debug: Couldn't read rcracki_mt.ini, continuing anyway." << std::endl; // Load session data if we are resuming if (resumeSession) { vPathName.clear(); std::vector sSessionData; if (ReadLinesFromFile(sSessionPathName.c_str(), sSessionData)) { std::cout << "Resuming from session: " << sSessionPathName.c_str() << std::endl; uint32_t i; for (i = 0; i < sSessionData.size(); i++) { std::vector vPart; if (SeperateString(sSessionData[i], "=", vPart)) { std::string sOption = vPart[0]; std::string sValue = vPart[1]; if (sOption == "sPathName") { vPathName.push_back(sValue); } else if (sOption == "sInputType") { sInputType = sValue; } else if (sOption == "sInput") { sInput = sValue; } else if (sOption == "outputFile") { writeOutput = true; outputFile = sValue; } else if (sOption == "keepPrecalcFiles") { if (sValue == "1") keepPrecalcFiles = true; } } } } else { std::cout << "Couldn't open session file " << sSessionPathName.c_str() << std::endl; return 0; } } if (maxThreads<1) maxThreads = 1; // don't load these if we are resuming a session that already has a list of tables if (useDefaultRainbowTablePath && !resumeSession) { uint32_t i; for (i = 0; i < vDefaultRainbowTablePath.size(); i++) { std::vector vPart; if (SeperateString(vDefaultRainbowTablePath[i], ".=", vPart)) { std::string lineAlgorithm = vPart[1]; std::string linePath = vPart[2]; if (lineAlgorithm == sAlgorithm) GetTableList(linePath, vPathName); } } } std::cout << "Using " << maxThreads << " threads for pre-calculation " << "and false alarm checking..." << std::endl; setvbuf(stdout, NULL, _IONBF,0); if (vPathName.size() == 0) { std::cout << "no rainbow table found" << std::endl; return 0; } std::cout << "Found " << vPathName.size() << " rainbowtable files..." << std::endl << std::endl; bool fCrackerType; // true: hash cracker, false: lm cracker std::vector vHash; // hash cracker std::vector vUserName; // lm cracker std::vector vLMHash; // lm cracker std::vector vNTLMHash; // lm cracker if (sInputType == "-h") { fCrackerType = true; std::string sHash = sInput; if (NormalizeHash(sHash)) vHash.push_back(sHash); else std::cout << "invalid hash: " << sHash.c_str() << std::endl; } else if (sInputType == "-l") { fCrackerType = true; std::string sPathName = sInput; std::vector vLine; if (ReadLinesFromFile(sPathName, vLine)) { uint32_t i; for (i = 0; i < vLine.size(); i++) { std::string sHash = vLine[i]; if (NormalizeHash(sHash)) vHash.push_back(sHash); else std::cout << "invalid hash: " << sHash.c_str() << std::endl; } } else std::cout << "can't open " << sPathName.c_str() << std::endl; } else if (sInputType == "-f") { fCrackerType = false; std::string sPathName = sInput; LoadLMHashFromPwdumpFile(sPathName, vUserName, vLMHash, vNTLMHash); } else if (sInputType == "-c") { // 2009-01-04 - james.dickson - Added this for cain-files. fCrackerType = false; std::string sPathName = sInput; LoadLMHashFromCainLSTFile(sPathName, vUserName, vLMHash, vNTLMHash); } else { Usage(); return 0; } if (fCrackerType && vHash.size() == 0) { std::cout << "no hashes found"; return 0; } if (!fCrackerType && vLMHash.size() == 0) { std::cout << "no hashes found"; return 0; } std::vector sha1AsMysqlSha1; if (fCrackerType) { uint32_t i; for (i = 0; i < vHash.size(); i++) { if ( runSha1AgainstMysqlSha1 ) { HASHROUTINE hashRoutine; CHashRoutine hr; std::string hashName = "sha1"; int hashLen = 20; hr.GetHashRoutine( hashName, hashRoutine, hashLen ); unsigned char* plain = new unsigned char[hashLen*2]; memcpy( plain, HexToBinary(vHash[i].c_str(), hashLen*2 ).c_str(), hashLen ); unsigned char hash_output[MAX_HASH_LEN]; hashRoutine( plain, hashLen, hash_output); sha1AsMysqlSha1.push_back(HexToStr(hash_output, hashLen)); hs.AddHash( sha1AsMysqlSha1[i] ); } else hs.AddHash(vHash[i]); } } else { uint32_t i; for (i = 0; i < vLMHash.size(); i++) { hs.AddHash(vLMHash[i].substr(0, 16)); hs.AddHash(vLMHash[i].substr(16, 16)); } } // Load found hashes from session file if (resumeSession) { std::vector sSessionData; if (ReadLinesFromFile(sSessionPathName.c_str(), sSessionData)) { uint32_t i; for (i = 0; i < sSessionData.size(); i++) { std::vector vPart; if (SeperateString(sSessionData[i], "=", vPart)) { std::string sOption = vPart[0]; std::string sValue = vPart[1]; if (sOption == "sHash") { std::vector vPartHash; if (SeperateString(sValue, "::", vPartHash)) { std::string sHash = vPartHash[0]; std::string sBinary = vPartHash[1]; std::string sPlain = vPartHash[2]; hs.SetPlain(sHash, sPlain, sBinary); } } } } } } else { FILE* file; std::string buffer = ""; // (Over)write session data if we are not resuming if ( ( file = fopen( sSessionPathName.c_str(), "w" ) ) != NULL ) { buffer += "sInputType=" + sInputType + "\n"; buffer += "sInput=" + sInput + "\n"; uint32_t i; for (i = 0; i < vPathName.size(); i++) { buffer += "sPathName=" + vPathName[i] + "\n"; } if (writeOutput) buffer += "outputFile=" + outputFile + "\n"; if (keepPrecalcFiles) buffer += "keepPrecalcFiles=1\n"; fputs (buffer.c_str(), file); fclose (file); } else { std::cout << "Error opening file " << sSessionPathName.c_str() << ". Check that you have write permission to the directory " << "that the application is run. Exiting Application." << std::endl; return -1; } if( (file = fopen( sProgressPathName.c_str(), "w" )) == NULL ) { std::cout << "Error opening file " << sProgressPathName.c_str() << ". Check that you have write permission to the directory " << "that the application is run. Exiting Application." << std::endl; return -1; } else fclose( file ); } // Run CCrackEngine ce; if (writeOutput) ce.setOutputFile(outputFile); ce.setSession(sSessionPathName, sProgressPathName, sPrecalcPathName, keepPrecalcFiles); ce.Run(vPathName, hs, maxThreads, maxMem, resumeSession, debug, enableGPU); // Remove session files if (debug) std::cout << "Debug: Removing session files." << std::endl; if (remove(sSessionPathName.c_str()) == 0) remove(sProgressPathName.c_str()); else { if (debug) std::cout << "Debug: Failed removing session files." << std::endl; } // Statistics std::cout << "statistics" << std::endl << "-------------------------------------------------------" << std::endl << "plaintext found: " << hs.GetStatHashFound() << " of " << hs.GetStatHashTotal() << "(" << 100.0f * hs.GetStatHashFound() / hs.GetStatHashTotal() << "%)" << std::endl << "total disk access time: " << ce.GetStatTotalDiskAccessTime() << "s" << std::endl << "total cryptanalysis time: " << ce.GetStatTotalCryptanalysisTime() << "s" << std::endl << "total pre-calculation time: " << ce.GetStatTotalPrecalculationTime() << "s" << std::endl << "total chain walk step: " << ce.GetStatTotalChainWalkStep() << std::endl << "total false alarm: " << ce.GetStatTotalFalseAlarm() << std::endl << "total chain walk step due to false alarm: " << ce.GetStatTotalChainWalkStepDueToFalseAlarm() << std::endl //<< "total chain walk step skipped due to checkpoints: " << ce.GetStatTotalFalseAlarmSkipped(); // Checkpoints not used - yet << std::endl; // Result std::cout << "result" << std::endl << "-------------------------------------------------------" << std::endl; if (fCrackerType) { uint32_t i; for (i = 0; i < vHash.size(); i++) { std::string sPlain, sBinary; std::string tmpHash = vHash[i]; if ( runSha1AgainstMysqlSha1 ) { tmpHash = sha1AsMysqlSha1[i]; } if (!hs.GetPlain(tmpHash, sPlain, sBinary)) { sPlain = ""; sBinary = ""; } std::cout << vHash[i].c_str() << "\t" << sPlain.c_str() <<"\thex:" << sBinary.c_str() << std::endl; } } else { uint32_t i; for (i = 0; i < vLMHash.size(); i++) { std::string sPlain1, sBinary1; bool fPart1Found = hs.GetPlain(vLMHash[i].substr(0, 16), sPlain1, sBinary1); if (!fPart1Found) { sPlain1 = ""; sBinary1 = ""; } std::string sPlain2, sBinary2; bool fPart2Found = hs.GetPlain(vLMHash[i].substr(16, 16), sPlain2, sBinary2); if (!fPart2Found) { sPlain2 = ""; sBinary2 = ""; } std::string sPlain = sPlain1 + sPlain2; std::string sBinary = sBinary1 + sBinary2; // Correct case if (fPart1Found && fPart2Found) { unsigned char NTLMHash[16]; int nHashLen; ParseHash(vNTLMHash[i], NTLMHash, nHashLen); if (nHashLen != 16) std::cout << "debug: nHashLen mismatch" << std::endl; std::string sNTLMPassword; if (LMPasswordCorrectCase(sPlain, NTLMHash, sNTLMPassword)) { sPlain = sNTLMPassword; sBinary = HexToStr((const unsigned char*)sNTLMPassword.c_str(), sNTLMPassword.size()); if (writeOutput) { if (!writeResultLineToFile(outputFile, vNTLMHash[i].c_str(), sPlain.c_str(), sBinary.c_str())) std::cout << "Couldn't write final result to file!" << std::endl; } } else { std::cout << vUserName[i].c_str() << "\t" << sPlain.c_str() << "\thex:" << sBinary.c_str() << std::endl << "Failed case correction, trying unicode correction for: " << sPlain.c_str() << std::endl; LM2NTLMcorrector corrector; if (corrector.LMPasswordCorrectUnicode(sBinary, NTLMHash, sNTLMPassword)) { sPlain = sNTLMPassword; sBinary = corrector.getBinary(); if (writeOutput) { if (!writeResultLineToFile(outputFile, vNTLMHash[i].c_str(), sPlain.c_str(), sBinary.c_str())) std::cout << "Couldn't write final result to file!" << std::endl; } } else { std::cout << "unicode correction for password " << sPlain.c_str() << " failed!" << std::endl; } } } std::cout << vUserName[i].c_str() << "\t" << sPlain.c_str() << "\thex:" << sBinary.c_str() << std::endl; } } return 0; } #else void Exit(int c) { pthread_exit((void*)(uint64_t)c); } void *rcracki_mt(void*) { std::vector vPathName; std::string outputFile = settings.plainfile; bool writeOutput = settings.save_plains; std::string sSessionPathName = (std::string)settings.sessionfile + ".session"; std::string sProgressPathName = (std::string)settings.sessionfile + ".progress"; std::string sPrecalcPathName = (std::string)settings.sessionfile + ".precalc"; bool resumeSession = settings.resume_session; bool debug = settings.debug; bool keepPrecalcFiles = settings.keep_precalcs; std::string sAlgorithm = ""; int maxThreads = settings.n_threads; uint64_t maxMem = settings.memlimit * 1024 * 1024; CHashSet hs; std::vector vHash; // hash cracker std::vector vUserName; // lm cracker std::vector vLMHash; // lm cracker std::vector vNTLMHash; // lm cracker db.fCrackerType = true; // Load session data if we are resuming if (resumeSession) { std::vector vPart; SeperateString(sSessionPathName, ".", vPart); sSessionPathName = vPart[0] + ".session"; sProgressPathName = vPart[0] + ".progress"; sPrecalcPathName = vPart[0] + ".precalc"; vPathName.clear(); vHash.clear(); db.n_hashes = 0; db.n_found = 0; std::vector sSessionData; if (ReadLinesFromFile(sSessionPathName.c_str(), sSessionData)) { MessageStackPush("col-black", "Resuming from session %s\n", sSessionPathName.c_str()); uint32_t i; for (i = 0; i < sSessionData.size(); i++) { std::vector vPart; if (SeperateString(sSessionData[i], "=", vPart)) { std::string sOption = vPart[0]; std::string sValue = vPart[1]; if (sOption == "sPathName") { db.tables.push_back(sValue); } else if (sOption == "outputFile") { writeOutput = true; outputFile = sValue; } else if (sOption == "keepPrecalcFiles") { if (sValue == "1") keepPrecalcFiles = true; } else if (sOption == "sHash") { db.hashes.push_back(sValue); db.fCrackerType = true; db.n_hashes++; } else if (sOption == "sPlain") { std::vector vPartHash; if (SeperateString(sValue, "::", vPartHash)) { std::string sHash = vPartHash[0]; std::string sBinary = vPartHash[1]; std::string sPlain = vPartHash[2]; hs.SetPlain(sHash, sPlain, sBinary); int j; for (j = 0; j < (int)db.hashes.size(); j++) { if (db.hashes[j] == sHash) db.hashes.erase(db.hashes.begin()+j); } PlainStackPush((sHash + ":" + sPlain).c_str()); db.n_found++; } } else if (sOption == "LMCracker") { if (sValue == "true") db.fCrackerType = false; else db.fCrackerType = true; } } } } else { MessageStackPush("col-red", "Couldn't open session file %s. Exiting.\n", sSessionPathName.c_str()); Exit(0); } } vPathName = db.tables; vHash = db.hashes; if (maxThreads < 1) maxThreads = 1; setvbuf(stdout, NULL, _IONBF,0); if (vPathName.size() == 0) { MessageStackPush("col-red", "No rainbow table(s) found. Exiting.\n"); Exit(0); } if (vHash.size() == 0) { MessageStackPush("col-red", "No hashes found. Exiting.\n"); Exit(0); } if (db.fCrackerType) { uint32_t i; for (i = 0; i < vHash.size(); i++) hs.AddHash(vHash[i]); } else { uint32_t i; for (i = 0; i < vLMHash.size(); i++) { hs.AddHash(vLMHash[i].substr(0, 16)); hs.AddHash(vLMHash[i].substr(16, 16)); } } // (Over)write session data if we are not resuming if (!resumeSession && settings.save_session) { FILE* file = fopen(sSessionPathName.c_str(), "w"); std::string buffer = ""; if (file != NULL) { uint32_t i; for (i = 0; i < vPathName.size(); i++) { buffer += "sPathName=" + vPathName[i] + "\n"; } if (writeOutput) buffer += "outputFile=" + outputFile + "\n"; if (keepPrecalcFiles) buffer += "keepPrecalcFiles=1\n"; for (i = 0; i < vHash.size(); i++) buffer += "sHash=" + vHash[i] + "\n"; if (db.fCrackerType) buffer += "LMCracker=false\n"; else buffer += "LMCracker=true\n"; fputs (buffer.c_str(), file); fclose (file); } file = fopen(sProgressPathName.c_str(), "w"); fclose (file); } MessageStackPush("col-black", "Using %d thread%s for pre-calculation and false alarm checking\n", maxThreads, maxThreads > 1 ? "s" : ""); MessageStackPush("col-black", "Searching for %lu hash%s ...\n", (unsigned long)vHash.size(), vHash.size() > 1 ? "es" : ""); strcpy(db.current_action, "Running"); gettimeofday(&db.timer_start, 0); // Run db.status = STATUS_RUNNING; db.button_state = STATUS_RUNNING; CCrackEngine ce; if (writeOutput) ce.setOutputFile(outputFile); ce.setSession(sSessionPathName, sProgressPathName, sPrecalcPathName, keepPrecalcFiles); ce.Run(vPathName, hs, maxThreads, maxMem, resumeSession, debug); /* Remove session files*/ if (!settings.save_session) { if (debug) MessageStackPush("col-grey", "Debug: Removing session files.\n"); if (remove(sSessionPathName.c_str()) == 0) remove(sProgressPathName.c_str()); else if (debug) MessageStackPush("col-grey", "Debug: Failed removing session files.\n"); } // Statistics MessageStackPush("col-blue", "Statistics\n"); MessageStackPush("col-black", "-------------------------------------------------------\n"); MessageStackPush("col-black", "plaintext found: %d of %d (%.2f%%)\n", hs.GetStatHashFound(), hs.GetStatHashTotal(), 100.0f * hs.GetStatHashFound() / hs.GetStatHashTotal()); MessageStackPush("col-black", "total disk access time: %.2f s\n", ce.GetStatTotalDiskAccessTime()); MessageStackPush("col-black", "total cryptanalysis time: %.2f s\n", ce.GetStatTotalCryptanalysisTime()); MessageStackPush("col-black", "total pre-calculation time: %.2f s\n", ce.GetStatTotalPrecalculationTime()); MessageStackPush("col-black", "total chain walk step: %d\n", ce.GetStatTotalChainWalkStep()); MessageStackPush("col-black", "total false alarm: %d\n", ce.GetStatTotalFalseAlarm()); MessageStackPush("col-black", "total chain walk step due to false alarm: %d\n\n", ce.GetStatTotalChainWalkStepDueToFalseAlarm()); // Result MessageStackPush("col-blue", "Result\n"); MessageStackPush("col-black", "-------------------------------------------------------\n"); if (db.fCrackerType) { uint32_t i; for (i = 0; i < vHash.size(); i++) { std::string sPlain, sBinary; if (!hs.GetPlain(vHash[i], sPlain, sBinary)) { sPlain = ""; sBinary = ""; } MessageStackPush("col-black", "%s:%s\n", vHash[i].c_str(), sPlain.c_str()); } } else { uint32_t i; for (i = 0; i < vLMHash.size(); i++) { std::string sPlain1, sBinary1; bool fPart1Found = hs.GetPlain(vLMHash[i].substr(0, 16), sPlain1, sBinary1); if (!fPart1Found) { sPlain1 = ""; sBinary1 = ""; } std::string sPlain2, sBinary2; bool fPart2Found = hs.GetPlain(vLMHash[i].substr(16, 16), sPlain2, sBinary2); if (!fPart2Found) { sPlain2 = ""; sBinary2 = ""; } std::string sPlain = sPlain1 + sPlain2; std::string sBinary = sBinary1 + sBinary2; // Correct case if (fPart1Found && fPart2Found) { unsigned char NTLMHash[16]; int nHashLen; ParseHash(vNTLMHash[i], NTLMHash, nHashLen); if (nHashLen != 16 && debug) MessageStackPush("col-grey", "Debug: nHashLen mismatch\n"); std::string sNTLMPassword; if (LMPasswordCorrectCase(sPlain, NTLMHash, sNTLMPassword)) { sPlain = sNTLMPassword; sBinary = HexToStr((const unsigned char*)sNTLMPassword.c_str(), sNTLMPassword.size()); } else { MessageStackPush("col-black", "%-14s:%s\n", vUserName[i].c_str(), sPlain.c_str()); LM2NTLMcorrector corrector; if (corrector.LMPasswordCorrectUnicode(sBinary, NTLMHash, sNTLMPassword)) { sPlain = sNTLMPassword; sBinary = corrector.getBinary(); if (writeOutput) { if (!writeResultLineToFile(outputFile, vNTLMHash[i].c_str(), sPlain.c_str(), sBinary.c_str())) MessageStackPush("col-grey", "Debug: Couldn't write final result to file!\n"); } } else { if (debug) MessageStackPush("col-grey", "Debug: case correction for password %s failed!\n", sPlain.c_str()); } } } /* Display */ MessageStackPush("col-black", "%-14s:%s\n", vUserName[i].c_str(), sPlain.c_str()); } } db.status = STATUS_IDLE; db.button_state = STATUS_IDLE; MessageStackPush("col-green", "RainbowCrack done.\n\n"); strcpy(db.current_action, "Idle"); db.progress = 1.0f; strcpy(db.progbartxt, "Finished"); pthread_exit(0); } #endif rcracki-mt-0.7.0/rcracki_mt/Public.cpp0000640000175000017500000004750712043323152017124 0ustar dookiedookie/* * freerainbowtables is a project for generating, distributing, and using * perfect rainbow tables * * Copyright (C) Zhu Shuanglei * Copyright Martin Westergaard Jørgensen * Copyright 2009, 2010 Daniël Niggebrugge * Copyright 2009, 2010, 2011, 2012 James Nobis * Copyright 2011 Logan Watt * Copyright 2011 Karl Fox * * This file is part of freerainbowtables. * * freerainbowtables is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, version 2 of the License. * * freerainbowtables is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with freerainbowtables. If not, see . */ #include "Public.h" #ifdef _WIN32 #ifdef BOINC #include "boinc_win.h" #endif #else #include #include #include #include #include #include #include #endif #include #include #include #include #include #include #ifdef BOINC #include "filesys.h" #include "boinc_api.h" #endif #ifdef _WIN32 #include #endif #if defined(_WIN32) && !defined(__GNUC__) #include #include #include #if defined(_MSC_VER) || defined(_MSC_EXTENSIONS) #define DELTA_EPOCH_IN_MICROSECS 11644473600000000Ui64 #else #define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL #endif struct timezone { int tz_minuteswest; /* minutes W of Greenwich */ int tz_dsttime; /* type of dst correction */ }; int gettimeofday(struct timeval *tv, struct timezone *tz) { // Define a structure to receive the current Windows filetime FILETIME ft; // Initialize the present time to 0 and the timezone to UTC unsigned __int64 tmpres = 0; static int tzflag = 0; if (NULL != tv) { GetSystemTimeAsFileTime(&ft); // The GetSystemTimeAsFileTime returns the number of 100 nanosecond // intervals since Jan 1, 1601 in a structure. Copy the high bits to // the 64 bit tmpres, shift it left by 32 then or in the low 32 bits. tmpres |= ft.dwHighDateTime; tmpres <<= 32; tmpres |= ft.dwLowDateTime; // Convert to microseconds by dividing by 10 tmpres /= 10; // The Unix epoch starts on Jan 1 1970. Need to subtract the difference // in seconds from Jan 1 1601. tmpres -= DELTA_EPOCH_IN_MICROSECS; // Finally change microseconds to seconds and place in the seconds value. // The modulus picks up the microseconds. tv->tv_sec = (long)(tmpres / 1000000UL); tv->tv_usec = (long)(tmpres % 1000000UL); } if (NULL != tz) { if (!tzflag) { _tzset(); tzflag++; } // Adjust for the timezone west of Greenwich tz->tz_minuteswest = _timezone / 60; tz->tz_dsttime = _daylight; } return 0; } #elif defined(__APPLE__) || \ ((defined(__unix__) || defined(unix)) && !defined(USG)) #include #if defined(BSD) #include #elif defined(__linux__) || defined(__sun__) #include #else #error Unsupported Operating System #endif #endif ////////////////////////////////////////////////////////////////////// enum RTfileFormatValue { RT , RTI , RTI2 }; static std::map mapRTFileFormatValue; static void initializeRTfileFormatMap() { mapRTFileFormatValue["RT"] = RT; mapRTFileFormatValue["RTI"] = RTI; mapRTFileFormatValue["RTI2"] = RTI2; } uint8_t getRTfileFormatId( std::string RTfileFormatName ) { initializeRTfileFormatMap(); std::map::iterator iter; iter = mapRTFileFormatValue.find( RTfileFormatName ); if ( iter == mapRTFileFormatValue.end() ) { std::cout << "RT file format " << RTfileFormatName << " is not supported" << std::endl; exit( 1 ); } return iter->second; } timeval sub_timeofday( timeval tv2, timeval tv ) { timeval final; final.tv_usec = tv2.tv_usec - tv.tv_usec; final.tv_sec = tv2.tv_sec - tv.tv_sec; if ( final.tv_usec < 0 ) { final.tv_usec += 1000000; --final.tv_sec; } return final; } /* * 32-bit this is a problem if the file is > (2^31-1) bytes * to get 64-bit behavior on 32 and 64 platforms: * for gcc add these before including sys/types.h and sys/stat.h: * #define __USE_LARGEFILE64 * #define _LARGEFILE_SOURCE * #define _LARGEFILE64_SOURCE * then use stat64 instead of stat for the structure and the call * for VS * use _stat64 for the structure and stat64 for the call */ long GetFileLen( char* file ) { struct stat sb; if ( stat(file, &sb ) == -1 ) return -1; return sb.st_size; } // 32-bit this is a problem if the file is > (2^31-1) bytes long GetFileLen( std::string file ) { struct stat sb; if ( stat(file.c_str(), &sb ) == -1 ) return -1; return sb.st_size; } /* * In use by items that resolve boinc filenames * 1) boinc_ReadLinesFromFile in this file * 2) boinc_software/boinc_client_apps/distrrtgen/distrrtgen.cpp * 3) boinc_software/boinc_client_apps/distrrtgen_cuda/distrrtgen.cpp */ long GetFileLen(FILE* file) { // XXX on x86/x86_64 linux returns long // 32-bit this is a problem if the file is > (2^31-1) bytes long pos = ftell(file); fseek(file, 0, SEEK_END); long len = ftell(file); fseek(file, pos, SEEK_SET); return len; } std::string TrimString( std::string s ) { while (s.size() > 0) { if (s[0] == ' ' || s[0] == '\t') s = s.substr(1); else break; } while (s.size() > 0) { if (s[s.size() - 1] == ' ' || s[s.size() - 1] == '\t') s = s.substr(0, s.size() - 1); else break; } return s; } bool GetHybridCharsets( std::string sCharset, std::vector& vCharset ) { // Example: hybrid(mixalpha-numeric-all-space#6-6,numeric#1-4) if(sCharset.substr(0, 6) != "hybrid") // Not hybrid charset return false; std::string::size_type nEnd = sCharset.rfind(')'); std::string::size_type nStart = sCharset.rfind('('); std::string sChar = sCharset.substr(nStart + 1, nEnd - nStart - 1); std::string commas = ""; int commaCount = std::count( sChar.begin(), sChar.end(), ',' ); for ( int i = 0; i < commaCount; i++ ) commas += ","; std::vector vParts; if ( !SeperateString(sChar, commas, vParts) ) { std::cout << "Failed to SeperateString: " << sChar << std::endl; return false; } for(uint32_t i = 0; i < vParts.size(); i++) { tCharset stCharset; std::vector vParts2; if ( !SeperateString(vParts[i], "#", vParts2) ) { std::cout << "Failed to SeperateString: " << vParts[i] << std::endl; return false; } stCharset.sName = vParts2[0]; std::vector vParts3; if( !SeperateString(vParts2[1], "-", vParts3) ) { std::cout << "Failed to SeperateString: " << vParts2[1] << std::endl; return false; } stCharset.nPlainLenMin = atoi(vParts3[0].c_str()); stCharset.nPlainLenMax = atoi(vParts3[1].c_str()); vCharset.push_back(stCharset); } return true; } #ifdef BOINC bool boinc_ReadLinesFromFile( std::string sPathName, std::vector& vLine ) { vLine.clear(); #ifdef USE_INTEGRATED_CHARSET vLine.push_back("byte = []"); vLine.push_back("alpha = [ABCDEFGHIJKLMNOPQRSTUVWXYZ]"); vLine.push_back("alpha-space = [ABCDEFGHIJKLMNOPQRSTUVWXYZ ]"); vLine.push_back("alpha-numeric = [ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789]"); vLine.push_back("alpha-numeric-space = [ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ]"); vLine.push_back("alpha-numeric-symbol14 = [ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\x21\x40\x23\x24\x25\x5E\x26\x2A\x28\x29\x2D\x5F\x2B\x3D]"); vLine.push_back("alpha-numeric-symbol14-space= [ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\x21\x40\x23\x24\x25\x5E\x26\x2A\x28\x29\x2D\x5F\x2B\x3D\x20]"); vLine.push_back("all = [ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\x21\x40\x23\x24\x25\x5E\x26\x2A\x28\x29\x2D\x5F\x2B\x3D\x7E\x60\x5B\x5D\x7B\x7D\x7C\x5C\x3A\x3B\x22\x27\x3C\x3E\x2C\x2E\x3F\x2F]"); vLine.push_back("all-space = [ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\x21\x40\x23\x24\x25\x5E\x26\x2A\x28\x29\x2D\x5F\x2B\x3D\x7E\x60\x5B\x5D\x7B\x7D\x7C\x5C\x3A\x3B\x22\x27\x3C\x3E\x2C\x2E\x3F\x2F\x20]"); vLine.push_back("alpha-numeric-symbol32-space = [ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\x21\x40\x23\x24\x25\x5E\x26\x2A\x28\x29\x2D\x5F\x2B\x3D\x7E\x60\x5B\x5D\x7B\x7D\x7C\x5C\x3A\x3B\x22\x27\x3C\x3E\x2C\x2E\x3F\x2F\x20]"); vLine.push_back("lm-frt-cp437 = [\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2A\x2B\x2C\x2D\x2E\x2F\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3A\x3B\x3C\x3D\x3E\x3F\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4A\x4B\x4C\x4D\x4E\x4F\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5A\x5B\x5C\x5D\x5E\x5F\x60\x7B\x7C\x7D\x7E\x80\x8E\x8F\x90\x92\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA5\xE0\xE1\xE2\xE3\xE4\xE6\xE7\xE8\xE9\xEA\xEB\xEE]"); vLine.push_back("lm-frt-cp850 = [\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2A\x2B\x2C\x2D\x2E\x2F\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3A\x3B\x3C\x3D\x3E\x3F\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4A\x4B\x4C\x4D\x4E\x4F\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5A\x5B\x5C\x5D\x5E\x5F\x60\x7B\x7C\x7D\x7E\x80\x8E\x8F\x90\x92\x99\x9A\x9C\x9D\x9F\xA5\xB5\xB6\xB7\xBD\xBE\xC7\xCF\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xDE\xE0\xE1\xE2\xE3\xE5\xE6\xE8\xE9\xEA\xEB\xED\xEF]"); vLine.push_back("lm-frt-cp437-850 = [\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2A\x2B\x2C\x2D\x2E\x2F\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3A\x3B\x3C\x3D\x3E\x3F\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4A\x4B\x4C\x4D\x4E\x4F\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5A\x5B\x5C\x5D\x5E\x5F\x60\x7B\x7C\x7D\x7E\x80\x8E\x8F\x90\x92\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA5\xB5\xB6\xB7\xBD\xBE\xC7\xCF\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xDE\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xED\xEE\xEF]"); vLine.push_back("numeric = [0123456789]"); vLine.push_back("numeric-space = [0123456789 ]"); vLine.push_back("loweralpha = [abcdefghijklmnopqrstuvwxyz]"); vLine.push_back("loweralpha-space = [abcdefghijklmnopqrstuvwxyz ]"); vLine.push_back("loweralpha-numeric = [abcdefghijklmnopqrstuvwxyz0123456789]"); vLine.push_back("loweralpha-numeric-space = [abcdefghijklmnopqrstuvwxyz0123456789 ]"); vLine.push_back("loweralpha-numeric-symbol14 = [abcdefghijklmnopqrstuvwxyz0123456789\x21\x40\x23\x24\x25\x5E\x26\x2A\x28\x29\x2D\x5F\x2B\x3D]"); vLine.push_back("loweralpha-numeric-all = [abcdefghijklmnopqrstuvwxyz0123456789\x21\x40\x23\x24\x25\x5E\x26\x2A\x28\x29\x2D\x5F\x2B\x3D\x7E\x60\x5B\x5D\x7B\x7D\x7C\x5C\x3A\x3B\x22\x27\x3C\x3E\x2C\x2E\x3F\x2F]"); vLine.push_back("loweralpha-numeric-symbol32-space= [abcdefghijklmnopqrstuvwxyz0123456789\x21\x40\x23\x24\x25\x5E\x26\x2A\x28\x29\x2D\x5F\x2B\x3D\x7E\x60\x5B\x5D\x7B\x7D\x7C\x5C\x3A\x3B\x22\x27\x3C\x3E\x2C\x2E\x3F\x2F\x20]"); vLine.push_back("mixalpha = [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ]"); vLine.push_back("mixalpha-space = [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ]"); vLine.push_back("mixalpha-numeric = [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789]"); vLine.push_back("mixalpha-numeric-space = [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ]"); vLine.push_back("mixalpha-numeric-symbol14 = [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\x21\x40\x23\x24\x25\x5E\x26\x2A\x28\x29\x2D\x5F\x2B\x3D]"); vLine.push_back("mixalpha-numeric-all = [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\x21\x40\x23\x24\x25\x5E\x26\x2A\x28\x29\x2D\x5F\x2B\x3D\x7E\x60\x5B\x5D\x7B\x7D\x7C\x5C\x3A\x3B\x22\x27\x3C\x3E\x2C\x2E\x3F\x2F]"); vLine.push_back("mixalpha-numeric-symbol32-space = [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\x21\x40\x23\x24\x25\x5E\x26\x2A\x28\x29\x2D\x5F\x2B\x3D\x7E\x60\x5B\x5D\x7B\x7D\x7C\x5C\x3A\x3B\x22\x27\x3C\x3E\x2C\x2E\x3F\x2F\x20]"); vLine.push_back("mixalpha-numeric-all-space = [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\x21\x40\x23\x24\x25\x5E\x26\x2A\x28\x29\x2D\x5F\x2B\x3D\x7E\x60\x5B\x5D\x7B\x7D\x7C\x5C\x3A\x3B\x22\x27\x3C\x3E\x2C\x2E\x3F\x2F\x20]"); #endif char input_path[512]; boinc_resolve_filename(sPathName.c_str(), input_path, sizeof(input_path)); FILE *file = boinc_fopen(input_path, "rb"); if (!file) { fprintf(stderr, "Couldn't find input file, resolved name %s.\n", input_path ); exit(-1); } if (file != NULL) { long len = GetFileLen(file); char* data = new char[len + 1]; fread(data, 1, len, file); data[len] = '\0'; std::string content = data; content += "\n"; delete [] data; unsigned int i; for (i = 0; i < content.size(); i++) { if (content[i] == '\r') content[i] = '\n'; } std::string::size_type n; while ((n = content.find("\n", 0)) != std::string::npos) { std::string line = content.substr(0, n); line = TrimString(line); if (line != "") vLine.push_back(line); content = content.substr(n + 1); } fclose(file); } else return false; return true; } #endif bool ReadLinesFromFile( std::string sPathName, std::vector& vLine ) { vLine.clear(); FILE* file = fopen(sPathName.c_str(), "rb"); if (file != NULL) { long len = GetFileLen( sPathName ); char* data = new char[len + 1]; fread(data, 1, len, file); data[len] = '\0'; std::string content = data; content += "\n"; delete [] data; unsigned int i; for (i = 0; i < content.size(); i++) { if (content[i] == '\r') content[i] = '\n'; } std::string::size_type n; while ((n = content.find("\n", 0)) != std::string::npos) { std::string line = content.substr(0, n); line = TrimString(line); if (line != "") vLine.push_back(line); content = content.substr(n + 1); } fclose(file); } else return false; return true; } bool writeResultLineToFile( std::string sOutputFile, std::string sHash, std::string sPlain, std::string sBinary ) { FILE* file = fopen(sOutputFile.c_str(), "a"); if (file!=NULL) { std::string buffer = sHash + ":" + sPlain + ":" + sBinary + "\n"; fputs (buffer.c_str(), file); fclose (file); return true; } else return false; } bool SeperateString( std::string s, std::string sSeperator, std::vector& vPart ) { vPart.clear(); unsigned int i; for (i = 0; i < sSeperator.size(); i++) { std::string::size_type n; if ( (n = s.find(sSeperator[i])) != std::string::npos) { vPart.push_back(s.substr(0, n)); s = s.substr(n + 1); } else { printf("not found: %c\n", sSeperator[i]); printf("s: %s\n", s.c_str()); return false; } } vPart.push_back(s); return true; } std::string uint64tostr(uint64_t n) { char str[32]; sprintf(str, "%"PRIu64, n); return str; } std::string uint64tohexstr(uint64_t n) { char str[32]; //sprintf(str, "%016llx", n); sprintf(str, "%016"PRIx64, n); return str; } std::string HexToBinary( const char* data, int len ) { std::string tmpData = std::string( data, len ); std::string binary; for ( int i = 0; i <= len; i += 2 ) { std::string dataPart = tmpData.substr( i, 2 ); std::istringstream iss( dataPart ); int j; iss >> std::hex >> j; binary += j; } return binary; } std::string HexToStr(const unsigned char* pData, int nLen) { std::string sRet; int i; for (i = 0; i < nLen; i++) { char szByte[3]; sprintf(szByte, "%02x", pData[i]); sRet += szByte; } return sRet; } unsigned long GetAvailPhysMemorySize() { #ifdef _WIN32 MEMORYSTATUS ms; GlobalMemoryStatus(&ms); return ms.dwAvailPhys; #elif defined(BSD) int mib[2] = { CTL_HW, HW_PHYSMEM }; uint64_t physMem; //XXX warning size_t isn't portable size_t len; len = sizeof(physMem); sysctl(mib, 2, &physMem, &len, NULL, 0); return physMem; #elif defined(__linux__) FILE *procfd = NULL; if ( (procfd = fopen("/proc/meminfo", "r")) != NULL ) { char result[256]={0}; char *tmp = NULL; unsigned int cachedram = 0, freeram = 0, bufferram = 0; uint64_t tempram = 0; while( fgets(result,sizeof(char)*256,procfd) != NULL ) { tmp = strtok(result, " "); if( (strncmp(tmp,"MemFree:" , 8)) == 0 ) { tmp = strtok(NULL, " "); freeram = atoi(tmp); } else if( (strncmp(tmp, "Buffers:", 8)) == 0 ) { tmp = strtok(NULL, " "); bufferram = atoi(tmp); } else if( (strncmp(tmp, "Cached:", 7)) == 0 ) { tmp = strtok(NULL, " "); cachedram = atoi(tmp); /* * in 2.6 and 3.0 kernels the order is maintained and this is the * last value to read. Break and don't read more lines */ break; } } fclose(procfd); tempram = (uint64_t)(freeram + bufferram + cachedram) * 1024; if ( sizeof(long) == 4 ) { // ensure that we don't return more than 2^31-1 on 32-bit platforms if ( tempram > 0x7FFFFFFFLLU ) return (unsigned long) 0x7FFFFFFFLLU; else return (unsigned long) tempram; } return tempram; } struct sysinfo info; sysinfo(&info); return ( info.freeram + info.bufferram ) * (unsigned long) info.mem_unit; #elif defined(__sun__) return ((unsigned long)sysconf(_SC_AVPHYS_PAGES) * (unsigned long)sysconf(_SC_PAGESIZE)); #else return 0; #error Unsupported Operating System #endif } std::string GetApplicationPath() { char fullPath[FILENAME_MAX]; #ifdef _WIN32 GetModuleFileName(NULL, fullPath, FILENAME_MAX); #else char szTmp[32]; // XXX linux/proc file system dependent sprintf(szTmp, "/proc/%d/exe", (int)getpid()); int bytes = readlink(szTmp, fullPath, FILENAME_MAX); if( bytes >= 0 ) fullPath[bytes] = '\0'; #endif std::string sApplicationPath = fullPath; #ifdef _WIN32 std::string::size_type nIndex = sApplicationPath.find_last_of('\\'); #else std::string::size_type nIndex = sApplicationPath.find_last_of('/'); #endif if ( nIndex != std::string::npos ) sApplicationPath = sApplicationPath.substr(0, nIndex+1); return sApplicationPath; } void ParseHash( std::string sHash, unsigned char* pHash, int& nHashLen ) { uint32_t i; for (i = 0; i < sHash.size() / 2; i++) { std::string sSub = sHash.substr(i * 2, 2); unsigned int nValue; sscanf(sSub.c_str(), "%02x", &nValue); pHash[i] = (unsigned char)nValue; } nHashLen = (int) sHash.size() / 2; } void Logo() { std::cout << "RainbowCrack (improved, multi-threaded) - Making a Faster Cryptanalytic Time-Memory Trade-Off" << std::endl << "by Martin Westergaard " << std::endl << "multi-threaded and enhanced by neinbrucke" << std::endl << "*nix/64-bit compatibility and co-maintainer - James Nobis " << std::endl << "http://www.freerainbowtables.com/" << std::endl << "All code/binaries are under GPL2 Copyright at a minimum" << std::endl << "original code by Zhu Shuanglei " << std::endl << std::endl; } // XXX nmap is GPL2, will check newer releases regarding license // Code comes from nmap, used for the linux implementation of kbhit() #ifndef _WIN32 static int tty_fd = 0; struct termios saved_ti; int tty_getchar() { int c, numChars; if (tty_fd && tcgetpgrp(tty_fd) == getpid()) { c = 0; numChars = read(tty_fd, &c, 1); if (numChars > 0) return c; } return -1; } void tty_done() { if (!tty_fd) return; tcsetattr(tty_fd, TCSANOW, &saved_ti); close(tty_fd); tty_fd = 0; } void tty_init() { struct termios ti; if (tty_fd) return; if ((tty_fd = open("/dev/tty", O_RDONLY | O_NONBLOCK)) < 0) return; tcgetattr(tty_fd, &ti); saved_ti = ti; ti.c_lflag &= ~(ICANON | ECHO); ti.c_cc[VMIN] = 1; ti.c_cc[VTIME] = 0; tcsetattr(tty_fd, TCSANOW, &ti); atexit(tty_done); } void tty_flush(void) { tcflush(tty_fd, TCIFLUSH); } // end nmap code #endif rcracki-mt-0.7.0/rcracki_mt/fast_md5.h0000640000175000017500000000316112043323152017041 0ustar dookiedookie/* * Fast implementation of the MD5 message-digest algorithm as per RFC * (see http://tools.ietf.org/html/rfc1321) * * Author: Joao Inacio * License: Use and share as you wish at your own risk, please keep this header ;) * * Optimizations: * - For lengths < 16, transformation steps are "unrolled" using macros/defines * - Constants used whenever possible, it's the compiler's job to sort them out * - Padding is done on 4-byte words, and memory copied as last resort. * * freerainbowtables is a project for generating, distributing, and using * perfect rainbow tables * * Copyright 2009, 2010 Daniël Niggebrugge * Copyright 2009, 2010, 2011, 2012 James Nobis * * This file is part of freerainbowtables. * * freerainbowtables is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * freerainbowtables is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with freerainbowtables. If not, see . */ #ifndef _FAST_MD5_H #define _FAST_MD5_H #include "global.h" #define MD5_DIGEST_LENGTH 16 void fast_MD5(unsigned char *pData, int len, unsigned char *pDigest); #endif // _FAST_MD5_H rcracki-mt-0.7.0/rcracki_mt/rcuda_md4.inc0000640000175000017500000001075012043323152017525 0ustar dookiedookie// freerainbowtables is a project for generating, distributing, and using // perfect rainbow tables // // Copyright 2010, 2011 Jan Kyska // Copyright 2010 Martin Westergaard Jørgensen // Copyright 2010, 2011, 2012 James Nobis // // This file is part of freerainbowtables. // // freerainbowtables is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 2 of the License, or // (at your option) any later version. // // freerainbowtables is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with freerainbowtables. If not, see . namespace RC_MD4 { __device__ __constant__ unsigned int h[4] = { 0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476 }; __device__ __constant__ unsigned char r[48] = { \ 3, 7, 11, 19, 3, 7, 11, 19, 3, 7, 11, 19, 3, 7, 11, 19, \ 3, 5, 9, 13, 3, 5, 9, 13, 3, 5, 9, 13, 3, 5, 9, 13, \ 3, 9, 11, 15, 3, 9, 11, 15, 3, 9, 11, 15, 3, 9, 11, 15 }; __device__ __constant__ unsigned char g[48] = { \ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, \ 0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15, \ 0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15 }; __device__ unsigned int FF(unsigned int a, unsigned int b, unsigned int c, unsigned int d, int i, const unsigned int* data) { unsigned int ret; ret = a + ((b&c)|((~b)&d)) + data[SHIDX(g[i])]; ret = (ret<>(32-r[i])); return ret; } __device__ unsigned int GG(unsigned int a, unsigned int b, unsigned int c, unsigned int d, int i, const unsigned int* data) { unsigned int ret; ret = a + ((b&c)|(b&d)|(c&d)) + data[SHIDX(g[i])] + 0x5a827999u; ret = (ret<>(32-r[i])); return ret; } __device__ unsigned int HH(unsigned int a, unsigned int b, unsigned int c, unsigned int d, int i, const unsigned int* data) { unsigned int ret; ret = a + (b^c^d) + data[SHIDX(g[i])] + 0x6ed9eba1u; ret = (ret<>(32-r[i])); return ret; } __device__ void MD4(unsigned int* dataHash) { unsigned int a = h[0], b = h[1], c = h[2], d = h[3], x; int ii; // Round 1 for(ii = 0; ii < 16; ii++) { x = b; b = FF(a, b, c, d, ii, dataHash); a = d; d = c; c = x; } // Round 2 for(; ii < 32; ii++) { x = b; b = GG(a, b, c, d, ii, dataHash); a = d; d = c; c = x; } // Round 3 for(; ii < 48; ii++) { x = b; b = HH(a, b, c, d, ii, dataHash); a = d; d = c; c = x; } dataHash[SHIDX(0)] = a + h[0]; dataHash[SHIDX(1)] = b + h[1]; dataHash[SHIDX(2)] = c + h[2]; dataHash[SHIDX(3)] = d + h[3]; } } #define RT_MD4_KERNEL(kerName, kerPrologue, kerEpilogue) \ __global__ void kerName(unsigned int chainStart, unsigned int chainStop) { \ unsigned int size, jj; \ unsigned int plain; \ \ kerPrologue; \ \ /* transform to the plain text */ \ plain = 0x80; \ jj = (PLAIN_MAX_SIZE>>2)+1; \ \ RTGEN_IDX2PLAIN_BEGIN; \ RTGEN_I2P_LOOP64_BEGIN; \ plain = (plain<<8) | cplChrSet[(dimItem.z&255u) + uiDiv]; \ if((ii&3) == 2) { \ hData[SHIDX(jj--)] = plain; \ plain = 0; \ } \ RTGEN_I2P_LOOP64_END; \ \ RTGEN_I2P_LOOP32_BEGIN; \ plain = (plain<<8) | cplChrSet[(dimItem.z&255u) + uiDiv]; \ if((ii&3) == 2) { \ hData[SHIDX(jj--)] = plain; \ plain = 0; \ } \ RTGEN_I2P_LOOP32_END; \ RTGEN_IDX2PLAIN_END; \ \ /* prepare for MD4 */ \ size = ii; \ ii = ((((3-(ii&3))<<3)-1)&0x1f)+1; \ plain = plain<>2)+1; plain = hData[SHIDX(jj++)], idx++) \ hData[SHIDX(idx)] = (plain>>ii)|(hData[SHIDX(jj)]<<(32-ii)); \ hData[SHIDX(idx)] = plain>>ii; \ for(idx++; idx < 14; idx++) \ hData[SHIDX(idx)] = 0; \ hData[SHIDX(idx++)] = size<<3; \ hData[SHIDX(idx)] = 0; \ \ /* hash */ \ RC_MD4::MD4(hData); \ \ kerEpilogue; \ } RT_MD4_KERNEL(RTGenMD4Kernel, RTGEN_PROLOGUE, RTGEN_EPILOGUE) RT_MD4_KERNEL(RTPreCalcMD4Kernel, RTPRECALC_PROLOGUE, RTPRECALC_EPILOGUE) RT_MD4_KERNEL(RTCheckAlarmMD4Kernel, RTCHKALARM_PROLOGUE, RTCHKALARM_EPILOGUE) rcracki-mt-0.7.0/rcracki_mt/fast_md4.cpp0000640000175000017500000001771512043323152017405 0ustar dookiedookie/* * freerainbowtables is a project for generating, distributing, and using * perfect rainbow tables * * Copyright Bitweasil * Copyright 2009, 2010 Daniël Niggebrugge * Copyright 2009, 2010, 2011, 2012 James Nobis * * This file is part of freerainbowtables. * * freerainbowtables is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * freerainbowtables is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with freerainbowtables. If not, see . * * This code implements the MD4 message-digest algorithm. * "Just the reference implementation, single stage. Hardly "optimized." Though a good bit faster than libssl's MD4, as it isn't doing nearly the same amount of work." - Bitweasil * * little bit optimized (or at least attempted) for NTLM (unicode) by neinbrucke */ //#include //#include #include "fast_md4.h" /* MD4 Defines as per RFC reference implementation */ #define F(x, y, z) (((x) & (y)) | ((~x) & (z))) #define G(x, y, z) (((x) & (y)) | ((x) & (z)) | ((y) & (z))) #define H(x, y, z) ((x) ^ (y) ^ (z)) #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n)))) #define FF(a, b, c, d, x, s) { \ (a) += F ((b), (c), (d)) + (x); \ (a) = ROTATE_LEFT ((a), (s)); \ } #define GG(a, b, c, d, x, s) { \ (a) += G ((b), (c), (d)) + (x) + (uint32_t)0x5a827999; \ (a) = ROTATE_LEFT ((a), (s)); \ } #define HH(a, b, c, d, x, s) { \ (a) += H ((b), (c), (d)) + (x) + (uint32_t)0x6ed9eba1; \ (a) = ROTATE_LEFT ((a), (s)); \ } #define S11 3 #define S12 7 #define S13 11 #define S14 19 #define S21 3 #define S22 5 #define S23 9 #define S24 13 #define S31 3 #define S32 9 #define S33 11 #define S34 15 /* End MD4 Defines */ void MD4_NEW( unsigned char * pData, int length, unsigned char * pDigest) { // access data as 4-byte word #define uData ((uint32_t *)pData) #define uDigest ((uint32_t *)pDigest) // pad word and append bit at appropriate location #define MD4_pad_w0() (0x00000080) #define MD4_pad_w1(data) (((data) & 0x000000FF) | 0x00008000) #define MD4_pad_w2(data) (((data) & 0x0000FFFF) | 0x00800000) #define MD4_pad_w3(data) (((data) & 0x00FFFFFF) | 0x80000000) // For the hash working space //__attribute__((aligned(16))) uint32_t data[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; //__declspec(align(16)) uint32_t data[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; uint32_t data[MD4_DIGEST_LENGTH] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; // For the output result uint32_t a,b,c,d; switch (length) { case 0: { data[ 0] = MD4_pad_w0(); data[14] = 0; } break; case 1: { data[ 0] = MD4_pad_w1(uData[0]); data[14] = 1 << 3; } break; case 2: { data[ 0] = MD4_pad_w2(uData[0]); data[14] = 2 << 3; } break; case 3: { data[ 0] = MD4_pad_w3(uData[0]); data[14] = 3 << 3; } break; case 4: { data[ 0] = uData[0]; data[ 1] = MD4_pad_w0(); data[14] = 4 << 3; } break; case 5: { data[ 0] = uData[0]; data[ 1] = MD4_pad_w1(uData[1]); data[14] = 5 << 3; } break; case 6: { data[ 0] = uData[0]; data[ 1] = MD4_pad_w2(uData[1]); data[14] = 6 << 3; } break; case 7: { data[ 0] = uData[0]; data[ 1] = MD4_pad_w3(uData[1]); data[14] = 7 << 3; } break; case 8: { data[ 0] = uData[0]; data[ 1] = uData[1]; data[ 2] = MD4_pad_w0(); data[14] = 8 << 3; } break; case 9: { data[ 0] = uData[0]; data[ 1] = uData[1]; data[ 2] = MD4_pad_w1(uData[2]); data[14] = 9 << 3; } break; case 10: { data[ 0] = uData[0]; data[ 1] = uData[1]; data[ 2] = MD4_pad_w2(uData[2]); data[14] = 10 << 3; } break; case 11: { data[ 0] = uData[0]; data[ 1] = uData[1]; data[ 2] = MD4_pad_w3(uData[2]); data[14] = 11 << 3; } break; case 12: { data[ 0] = uData[0]; data[ 1] = uData[1]; data[ 2] = uData[2]; data[ 3] = MD4_pad_w0(); data[14] = 12 << 3; } break; case 13: { data[ 0] = uData[0]; data[ 1] = uData[1]; data[ 2] = uData[2]; data[ 3] = MD4_pad_w1(uData[3]); data[14] = 13 << 3; } break; case 14: { data[ 0] = uData[0]; data[ 1] = uData[1]; data[ 2] = uData[2]; data[ 3] = MD4_pad_w2(uData[3]); data[14] = 14 << 3; } break; case 15: { data[ 0] = uData[0]; data[ 1] = uData[1]; data[ 2] = uData[2]; data[ 3] = MD4_pad_w3(uData[3]); data[14] = 15 << 3; } break; default: { length = length % 32; // lenght >= 32 not suported int word = length >> 2; int i = 0; while (i < word) { data[i] = uData[i]; i++; } switch (length & 0x3) { case 0: { data[word] = MD4_pad_w0(); } break; case 1: { data[word] = MD4_pad_w1(uData[word]); } break; case 2: { data[word] = MD4_pad_w2(uData[word]); } break; case 3: { data[word] = MD4_pad_w3(uData[word]); } break; } data[14] = length << 3; } break; } a = 0x67452301; b = 0xefcdab89; c = 0x98badcfe; d = 0x10325476; /* Round 1 */ FF (a, b, c, d, data[ 0], S11); /* 1 */ FF (d, a, b, c, data[ 1], S12); /* 2 */ FF (c, d, a, b, data[ 2], S13); /* 3 */ FF (b, c, d, a, data[ 3], S14); /* 4 */ FF (a, b, c, d, data[ 4], S11); /* 5 */ FF (d, a, b, c, data[ 5], S12); /* 6 */ FF (c, d, a, b, data[ 6], S13); /* 7 */ FF (b, c, d, a, data[ 7], S14); /* 8 */ FF (a, b, c, d, 0, S11); /* 9 */ FF (d, a, b, c, 0, S12); /* 10 */ FF (c, d, a, b, 0, S13); /* 11 */ FF (b, c, d, a, 0, S14); /* 12 */ FF (a, b, c, d, 0, S11); /* 13 */ FF (d, a, b, c, 0, S12); /* 14 */ FF (c, d, a, b, data[14], S13); /* 15 */ FF (b, c, d, a, 0, S14); /* 16 */ /* Round 2 */ GG (a, b, c, d, data[ 0], S21); /* 17 */ GG (d, a, b, c, data[ 4], S22); /* 18 */ GG (c, d, a, b, 0, S23); /* 19 */ GG (b, c, d, a, 0, S24); /* 20 */ GG (a, b, c, d, data[ 1], S21); /* 21 */ GG (d, a, b, c, data[ 5], S22); /* 22 */ GG (c, d, a, b, 0, S23); /* 23 */ GG (b, c, d, a, 0, S24); /* 24 */ GG (a, b, c, d, data[ 2], S21); /* 25 */ GG (d, a, b, c, data[ 6], S22); /* 26 */ GG (c, d, a, b, 0, S23); /* 27 */ GG (b, c, d, a, data[14], S24); /* 28 */ GG (a, b, c, d, data[ 3], S21); /* 29 */ GG (d, a, b, c, data[ 7], S22); /* 30 */ GG (c, d, a, b, 0, S23); /* 31 */ GG (b, c, d, a, 0, S24); /* 32 */ /* Round 3 */ HH (a, b, c, d, data[ 0], S31); /* 33 */ HH (d, a, b, c, 0, S32); /* 34 */ HH (c, d, a, b, data[ 4], S33); /* 35 */ HH (b, c, d, a, 0, S34); /* 36 */ HH (a, b, c, d, data[ 2], S31); /* 37 */ HH (d, a, b, c, 0, S32); /* 38 */ HH (c, d, a, b, data[ 6], S33); /* 39 */ HH (b, c, d, a, data[14], S34); /* 40 */ HH (a, b, c, d, data[ 1], S31); /* 41 */ HH (d, a, b, c, 0, S32); /* 42 */ HH (c, d, a, b, data[ 5], S33); /* 43 */ HH (b, c, d, a, 0, S34); /* 44 */ HH (a, b, c, d, data[ 3], S31); /* 45 */ HH (d, a, b, c, 0, S32); /* 46 */ HH (c, d, a, b, data[ 7], S33); /* 47 */ HH (b, c, d, a, 0, S34); /* 48 */ // Finally, add initial values, as this is the only pass we make. a += 0x67452301; b += 0xefcdab89; c += 0x98badcfe; d += 0x10325476; uDigest[0] = a; uDigest[1] = b; uDigest[2] = c; uDigest[3] = d; } rcracki-mt-0.7.0/rcracki_mt/sha1.cpp0000640000175000017500000002151712043323152016533 0ustar dookiedookie/* * rcracki_mt is a multithreaded implementation and fork of the original * RainbowCrack * * Copyright Martin Westergaard Jørgensen * Copyright Wei Dai * Copyright 2009, 2010 Daniël Niggebrugge * Copyright 2009, 2010, 2011, 2012 James Nobis * * This file is part of rcracki_mt. * * rcracki_mt is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * rcracki_mt is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with rcracki_mt. If not, see . */ //#include #if defined(_WIN32) #include #endif #include #include "sha1.h" #define SHA1CircularShift(bits,word) (((word) << (bits)) | ((word) >> (32-(bits)))) // this rotate isn't faster with me #if defined(_WIN32) #define ROTATE(a,n) _lrotl(a,n) #else #define ROTATE(a,n) (((a)<<(n))|(((a)&0xffffffff)>>(32-(n)))) #endif /* A nice byte order reversal from Wei Dai */ #if defined(_WIN32) /* 5 instructions with rotate instruction, else 9 */ #define Endian_Reverse32(a) \ { \ unsigned long l=(a); \ (a)=((ROTATE(l,8)&0x00FF00FF)|(ROTATE(l,24)&0xFF00FF00)); \ } #else /* 6 instructions with rotate instruction, else 8 */ #define Endian_Reverse32(a) \ { \ unsigned long l=(a); \ l=(((l&0xFF00FF00)>>8L)|((l&0x00FF00FF)<<8L)); \ (a)=ROTATE(l,16L); \ } #endif #define F_00_19(b,c,d) ((((c) ^ (d)) & (b)) ^ (d)) #define F_20_39(b,c,d) ((b) ^ (c) ^ (d)) #define F_40_59(b,c,d) (((b) & (c)) | (((b)|(c)) & (d))) #define F_60_79(b,c,d) F_20_39(b,c,d) #define K0 0x5A827999 #define K1 0x6ED9EBA1 #define K2 0x8F1BBCDC #define K3 0xCA62C1D6 #define H0 0x67452301 #define H1 0xEFCDAB89 #define H2 0x98BADCFE #define H3 0x10325476 #define H4 0xC3D2E1F0 #define SHA1HashSize 20 void SHA1_NEW( unsigned char * pData, int length, unsigned char * pDigest) { if (length > 16) return; uint32_t Message_Block_Index = 0; union { unsigned char Message_Block[64]; uint32_t Message_Block_W[16]; }; Message_Block_W[0] = 0x00000000; Message_Block_W[1] = 0x00000000; Message_Block_W[2] = 0x00000000; Message_Block_W[3] = 0x00000000; Message_Block_W[4] = 0x00000000; uint32_t Intermediate_Hash[5] = { H0, H1, H2, H3, H4 }; memcpy(Message_Block, pData, length); Message_Block_Index += length; //padMessage Message_Block[length] = 0x80; uint32_t W_15 = length << 3; int t; /* Loop counter */ uint32_t temp; /* Temporary word value */ uint32_t W[80]; /* Word sequence */ uint32_t A, B, C, D, E; /* Word buffers */ /* * Initialize the first 16 words in the array W */ #define INIT(x) W[x] = Message_Block_W[x]; #define INIT_NULL(x) W[x] = 0; Endian_Reverse32(Message_Block_W[0]); INIT(0); #define INIT_NULL_1_14 \ INIT_NULL(1); INIT_NULL_2_14; #define INIT_NULL_2_14 \ INIT_NULL(2); INIT_NULL_3_14; #define INIT_NULL_3_14 \ INIT_NULL(3); INIT_NULL_4_14; #define INIT_NULL_4_14 \ INIT_NULL(4); INIT_NULL_5_14; #define INIT_NULL_5_14 \ INIT_NULL(5); INIT_NULL(6); INIT_NULL(7); \ INIT_NULL(8); INIT_NULL(9); INIT_NULL(10); INIT_NULL(11); \ INIT_NULL(12); INIT_NULL(13); INIT_NULL(14); #define ROTATE1_NULL_5_14 \ ROTATE1_NULL; ROTATE1_NULL; ROTATE1_NULL; \ ROTATE1_NULL; ROTATE1_NULL; ROTATE1_NULL; ROTATE1_NULL; \ ROTATE1_NULL; ROTATE1_NULL; ROTATE1_NULL; #define EXPAND(t) \ W[t] = SHA1CircularShift(1,W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]); \ #define EXPAND_3(t) W[t] = SHA1CircularShift(1,W[t-3]); #define EXPAND_16(t) W[t] = SHA1CircularShift(1,W[t-16]); #define EXPAND_3_8(t) W[t] = SHA1CircularShift(1,W[t-3] ^ W[t-8]); if (length < 4) { INIT_NULL_1_14; W[15] = W_15; EXPAND_16(16); W[17] = 0; W[18] = W_15<<1; } else if (length < 8) { Endian_Reverse32(Message_Block_W[1]); INIT(1); INIT_NULL_2_14; W[15] = W_15; EXPAND_16(16); EXPAND_16(17); W[18] = W_15<<1; } else { Endian_Reverse32(Message_Block_W[1]); Endian_Reverse32(Message_Block_W[2]); Endian_Reverse32(Message_Block_W[3]); Endian_Reverse32(Message_Block_W[4]); INIT(1); INIT(2); INIT(3); INIT(4); INIT_NULL_5_14; W[15] = W_15; EXPAND(16); EXPAND(17); EXPAND(18); } if (length < 12) { EXPAND_3(19); } else { EXPAND(19); } if (length < 16) { EXPAND_3(20); } else { EXPAND(20); } EXPAND_3(21); EXPAND_3(22); EXPAND(23); EXPAND(24); EXPAND(25); EXPAND_3_8(26); EXPAND_3_8(27); EXPAND(28); EXPAND(29); EXPAND(30); EXPAND(31); EXPAND(32); EXPAND(33); EXPAND(34); EXPAND(35); EXPAND(36); EXPAND(37); EXPAND(38); EXPAND(39); EXPAND(40); EXPAND(41); EXPAND(42); EXPAND(43); EXPAND(44); EXPAND(45); EXPAND(46); EXPAND(47); EXPAND(48); EXPAND(49); EXPAND(50); EXPAND(51); EXPAND(52); EXPAND(53); EXPAND(54); EXPAND(55); EXPAND(56); EXPAND(57); EXPAND(58); EXPAND(59); EXPAND(60); EXPAND(61); EXPAND(62); EXPAND(63); EXPAND(64); EXPAND(65); EXPAND(66); EXPAND(67); EXPAND(68); EXPAND(69); EXPAND(70); EXPAND(71); EXPAND(72); EXPAND(73); EXPAND(74); EXPAND(75); EXPAND(76); EXPAND(77); EXPAND(78); EXPAND(79); #define ROTATE1_NEW(a, b, c, d, e, x) \ e += SHA1CircularShift(5,a) + F_00_19(b,c,d) + x + K0; \ b = SHA1CircularShift(30,b); #define ROTATE1_NULL \ temp = SHA1CircularShift(5,A) + F_00_19(B,C,D) + E + K0; \ E = D; D = C; \ C = SHA1CircularShift(30,B); \ B = A; A = temp; \ #define ROTATE2_NEW(a, b, c, d, e, x) \ e += SHA1CircularShift(5,a) + F_20_39(b,c,d) + x + K1; \ b = SHA1CircularShift(30,b); #define ROTATE2(t) \ temp = SHA1CircularShift(5,A) + F_20_39(B,C,D) + E + W[t] + K1; \ E = D; D = C; \ C = SHA1CircularShift(30,B); \ B = A; A = temp; #define ROTATE2_W(w) \ temp = SHA1CircularShift(5,A) + F_20_39(B,C,D) + E + w + K1; \ E = D; D = C; \ C = SHA1CircularShift(30,B); \ B = A; A = temp; #define ROTATE3(t) \ temp = SHA1CircularShift(5,A) + F_40_59(B,C,D) + E + W[t] + K2; \ E = D; D = C; \ C = SHA1CircularShift(30,B); \ B = A; A = temp; #define ROTATE4(t) \ temp = SHA1CircularShift(5,A) + F_60_79(B,C,D) + E + W[t] + K3; \ E = D; D = C; \ C = SHA1CircularShift(30,B); \ B = A; A = temp; A = H0; B = H1; C = H2; D = H3; E = H4; E = H2; //D = 2079550178; //C = 1506887872; B = 2679412915u + W[0]; if (length < 4) { A = SHA1CircularShift(5,B) + 1722862861; } else { A = SHA1CircularShift(5,B) + 1722862861 + W[1]; } if (length < 8) { temp = SHA1CircularShift(5,A) + ((((1506887872) ^ (2079550178)) & (B)) ^ (2079550178)) + H2 + K0; } else { temp = SHA1CircularShift(5,A) + (((572662306) & (B)) ^ (2079550178)) + H2 + K0 + W[2]; } C = SHA1CircularShift(30,B); //SHA1CircularShift(30,(2679412915 + W[0])); B = A; A = temp; if (length < 12) { temp = SHA1CircularShift(5,A) + ((((C) ^ (1506887872)) & (B)) ^ (1506887872)) + 2079550178 + K0; } else { temp = SHA1CircularShift(5,A) + ((((C) ^ (1506887872)) & (B)) ^ (1506887872)) + 2079550178 + K0 + W[3]; } E = 1506887872; D = C; C = SHA1CircularShift(30,B); B = A; A = temp; if (length < 16) { temp = SHA1CircularShift(5,A) + F_00_19(B,C,D) + 1506887872 + K0; } else { temp = SHA1CircularShift(5,A) + F_00_19(B,C,D) + 1506887872 + K0 + W[4]; } E = D; D = C; C = SHA1CircularShift(30,B); B = A; A = temp; ROTATE1_NULL_5_14; ROTATE1_NEW( A, B, C, D, E, W_15 ); ROTATE1_NEW( E, A, B, C, D, W[16] ); ROTATE1_NEW( D, E, A, B, C, W[17] ); ROTATE1_NEW( C, D, E, A, B, W[18] ); ROTATE1_NEW( B, C, D, E, A, W[19] ); for(t = 20; t < 40; t++) { if (t == 21 && length < 8) { ROTATE2_W((length<<5)); // *32 } else { ROTATE2(t); } } for(t = 40; t < 60; t++) { ROTATE3(t); } for(t = 60; t < 80; t++) { ROTATE4(t); } Intermediate_Hash[0] += A; Intermediate_Hash[1] += B; Intermediate_Hash[2] += C; Intermediate_Hash[3] += D; Intermediate_Hash[4] += E; Endian_Reverse32(Intermediate_Hash[0]); Endian_Reverse32(Intermediate_Hash[1]); Endian_Reverse32(Intermediate_Hash[2]); Endian_Reverse32(Intermediate_Hash[3]); Endian_Reverse32(Intermediate_Hash[4]); memcpy(pDigest, Intermediate_Hash, 20); } rcracki-mt-0.7.0/rcracki_mt/RTI2Common.cpp0000640000175000017500000000476312043323152017574 0ustar dookiedookie/* * freerainbowtables is a project for generating, distributing, and using * perfect rainbow tables * * Copyright 2011 Sc00bz * Copyright 2011, 2012 James Nobis * * This file is part of freerainbowtables. * * freerainbowtables is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * freerainbowtables is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with freerainbowtables. If not, see . */ #include "RTI2Common.h" #include #include #include enum algorithmValue { Custom , LM , NTLM , MD2 , MD4 , MD5 , DoubleMD5 , DoubleBinaryMD5 , CiscoPIX , SHA1 , MySQLSHA1 , SHA256 , SHA384 , SHA512 , RIPEMD160 , MSCache , HalfLMChallenge , SecondHalfLMChallenge , NTLMChallenge , Oracle }; static std::map mapAlgorithmValue; static void initializeAlgorithmMap() { mapAlgorithmValue["Custom"] = Custom; mapAlgorithmValue["lm"] = LM; mapAlgorithmValue["ntlm"] = NTLM; mapAlgorithmValue["md2"] = MD2; mapAlgorithmValue["md4"] = MD4; mapAlgorithmValue["md5"] = MD5; mapAlgorithmValue["doublemd5"] = DoubleMD5; mapAlgorithmValue["doublebinarymd5"] = DoubleBinaryMD5; mapAlgorithmValue["ciscopix"] = CiscoPIX; mapAlgorithmValue["sha1"] = SHA1; mapAlgorithmValue["mysqlsha1"] = MySQLSHA1; mapAlgorithmValue["sha256"] = SHA256; mapAlgorithmValue["sha384"] = SHA384; mapAlgorithmValue["sha512"] = SHA512; mapAlgorithmValue["ripemd160"] = RIPEMD160; mapAlgorithmValue["mscache"] = MSCache; mapAlgorithmValue["halflmchall"] = HalfLMChallenge; mapAlgorithmValue["SecondHalfLMChallenge"] = SecondHalfLMChallenge; mapAlgorithmValue["ntlmchall"] = NTLMChallenge; mapAlgorithmValue["oracle"] = Oracle; } uint8_t getAlgorithmId( std::string algorithmName ) { initializeAlgorithmMap(); std::map::iterator iter; iter = mapAlgorithmValue.find(algorithmName); if ( iter == mapAlgorithmValue.end() ) { std::cout << "Hash Algorithm " << algorithmName << " is not supported" << std::endl; exit( 1 ); } return iter->second; } rcracki-mt-0.7.0/rcracki_mt/charset.txt0000640000175000017500000000532412043323152017363 0ustar dookiedookie# charset configuration file for DistrRTgen v3.2 by Martin Westergaard (martinwj2005@gmail.com) byte = [] alpha = [ABCDEFGHIJKLMNOPQRSTUVWXYZ] alpha-space = [ABCDEFGHIJKLMNOPQRSTUVWXYZ ] alpha-numeric = [ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789] alpha-numeric-space = [ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ] alpha-numeric-symbol14 = [ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()-_+=] alpha-numeric-symbol14-space= [ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()-_+= ] all = [ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()-_+=~`[]{}|\:;"'<>,.?/] all-space = [ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()-_+=~`[]{}|\:;"'<>,.?/ ] alpha-numeric-symbol32-space = [ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()-_+=~`[]{}|\:;"'<>,.?/ ] lm-frt-cp437 = [ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`{|}~] lm-frt-cp850 = [ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`{|}~] lm-frt-cp437-850 = [ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`{|}~] numeric = [0123456789] numeric-space = [0123456789 ] loweralpha = [abcdefghijklmnopqrstuvwxyz] loweralpha-space = [abcdefghijklmnopqrstuvwxyz ] loweralpha-numeric = [abcdefghijklmnopqrstuvwxyz0123456789] loweralpha-numeric-space = [abcdefghijklmnopqrstuvwxyz0123456789 ] loweralpha-numeric-symbol14 = [abcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()-_+=] loweralpha-numeric-all = [abcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()-_+=~`[]{}|\:;"'<>,.?/] loweralpha-numeric-symbol32-space= [abcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()-_+=~`[]{}|\:;"'<>,.?/ ] mixalpha = [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ] mixalpha-space = [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ] mixalpha-numeric = [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789] mixalpha-numeric-space = [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ] mixalpha-numeric-symbol14 = [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()-_+=] mixalpha-numeric-all = [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()-_+=~`[]{}|\:;"'<>,.?/] mixalpha-numeric-symbol32-space = [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()-_+=~`[]{}|\:;"'<>,.?/ ] mixalpha-numeric-all-space = [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()-_+=~`[]{}|\:;"'<>,.?/ ] rcracki-mt-0.7.0/rcracki_mt/INSTALLING.txt0000640000175000017500000000400312043323152017367 0ustar dookiedookieWindows users vc binaries: Ensure you have the VC++ 2010 x86 Redistributables installed https://www.microsoft.com/en-us/download/details.aspx?id=8328 Later builds may require the x86 or x64 VC++ 2012 edition of the above https://www.microsoft.com/en-us/download/details.aspx?id=30679 mingw binaries have no external requirements. Extract the binary archive to a directory and setup is complete. If you wish to build from source you can either use VC++ or MSYS/mingw. You will need both openssl and pthreads includes and libraries. -------------------------------------------------------------------------------- *nix users Ad-hoc binary builds are statically linked and have no external dependencies. Source builds need: 1) g++ 2) make 3) libc dev libs libc6-dev in Debian/Ubuntu glibc-headers in Centos, Fedora, and RHEL 4) openssl dev libs libssl-dev in Debian/Ubuntu libopenssl-devel in Suse > 1110 openssl-devel in Centos, Fedora, Mandriva, OpenSUSE (older), SLE (older), RHEL 5) pthreads dev libs normally part of libc6-dev in Debian/Ubuntu Runtime performance is best when built using gcc >= 4.4.x, with large improvements in 4.5.x, larger in 4.6.x, and I have no benchmarked 4.7.x yet. Linux users Run make and you should be finished. For better performance add -mtune=native to the OPTIMIZATION variable in the Makefile. *bsd users You must use gmake instead of make at the current time. Mac OSX users You will need Xcode fully installed and then just run make. Some versions of g++ will allow -mtune=native as noted for better performance for Linux users. If you enable the option and it fails to build then just use the Makefile as shipped. SunOS/Solaris/OpenSolaris users You must use gmake. If the system fails to find g++ then either edit CC in the Makefile as needed or create a symlink in your PATH for g++. Linux binary builds/packages https://build.opensuse.org/package/show?package=rcracki&project=home%3Aquelrod is the head/trunk build and you may look for derived packages named similar to the release names. rcracki-mt-0.7.0/rcracki_mt/architecture.h0000640000175000017500000000476712043323152020036 0ustar dookiedookie/* * freerainbowtables is a project for generating, distributing, and using * perfect rainbow tables * * Copyright 2011 Steve Thomas (Sc00bz) * Copyright 2011, 2012 James Nobis * * This file is part of freerainbowtables. * * freerainbowtables is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, version 2 of the License. * * freerainbowtables is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with freerainbowtables. If not, see . */ #ifndef ARCHITECTURE_H #define ARCHITECTURE_H #if defined (__GLIBC__) #include #if (__BYTE_ORDER == __LITTLE_ENDIAN) #define ARC_LITTLE_ENDIAN #elif (__BYTE_ORDER == __BIG_ENDIAN) #define ARC_BIG_ENDIAN #else #error "Unknown machine endianness" #endif #elif defined(_BIG_ENDIAN) && !defined(_LITTLE_ENDIAN) #define ARC_BIG_ENDIAN #elif defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN) #define ARC_LITTLE_ENDIAN #elif defined(__sparc) || defined(__sparc__) || \ defined(_POWER) || defined(__powerpc__) || \ defined(__ppc__) || defined(__hpux) || \ defined(_MIPSEB) || defined(_POWER) || \ defined(__s390__) #define ARC_BIG_ENDIAN #elif defined(__i386__) || defined(__alpha__) || \ defined(__ia64) || defined(__ia64__) || \ defined(_M_IX86) || defined(_M_IA64) || \ defined(_M_ALPHA) || defined(__amd64) || \ defined(__amd64__) || defined(_M_AMD64) || \ defined(__x86_64) || defined(__x86_64__) || \ defined(_M_X64) #define ARC_LITTLE_ENDIAN #else #error "Unknown machine endianness" #endif #if defined(_M_X64) || defined(__x86_64__) #define ARC_x86_64 #define ARC_x86 #elif defined(_M_IX86) || defined(__i386__) #define ARC_x86_32 #define ARC_x86 #endif #if defined(_LP64) || defined(__LP64__) || \ defined(__ia64) || defined(__ia64__) || \ defined(_M_IA64) || defined(__amd64) || \ defined(__amd64__) || defined(_M_AMD64) || \ defined(__x86_64) || defined(__x86_64__) || \ defined(_M_X64) || defined(_WIN64) #define ARC_64 #endif #endif rcracki-mt-0.7.0/rcracki_mt/keyspace.h0000640000175000017500000000757212043323152017155 0ustar dookiedookie/* * This file is part of Advanced RTGen. * Copyright (C) 2011 Steve Thomas * Copyright 2011, 2012 James Nobis * * Advanced RTGen is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Advanced RTGen is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Advanced RTGen. If not, see . */ #ifndef KEY_SPACE_H #define KEY_SPACE_H #include "global.h" //#include "common.h" #include "architecture.h" union uint16u { uint16_t u16; uint8_t u8[2]; struct { #ifdef ARC_LITTLE_ENDIAN uint8_t lo8, hi8; #else uint8_t hi8, lo8; #endif }; }; union uint32u { uint32_t u32; uint16_t u16[2]; uint8_t u8[4]; struct { #ifdef ARC_LITTLE_ENDIAN uint16u lo16, hi16; #else uint16u hi16, lo16; #endif }; }; union uint64u { uint64_t u64; uint32_t u32[2]; uint16_t u16[4]; uint8_t u8[8]; struct { #ifdef ARC_LITTLE_ENDIAN uint32u lo32, hi32; #else uint32u hi32, lo32; #endif }; }; #ifdef _WIN32 #define WIN_ALIGN_16 __declspec(align(16)) #define ALIGN_16 #else #define WIN_ALIGN_16 #define ALIGN_16 __attribute__((aligned(16))) #endif #if defined(_M_X64) || defined(__x86_64__) || defined(_M_IX86) || defined(__i386__) #if defined(_WIN32) && !defined(__GNUC__) #define DIV_MOD_64_RET_32_32(n64,d32,r32,q32) \ { \ __asm mov eax,[DWORD PTR n64] \ __asm mov edx,[DWORD PTR n64+4] \ __asm div d32 \ __asm mov q32,eax \ __asm mov r32,edx \ } #else #define DIV_MOD_64_RET_32_32(n64,d32,r32,q32) \ asm( \ "divl %2" \ : "=a"(q32), "=d"(r32) \ : "rm"(d32), "a"(((uint64u*)&n64)->lo32), "d"(((uint64u*)&n64)->hi32) ); #endif #else #define DIV_MOD_64_RET_32_32(n64,d32,r32,q32) \ r32 = (uint32_t) (n64 % d32); \ q32 = (uint32_t) (n64 / d32); #endif struct vector4 { WIN_ALIGN_16 uint32_t data[4] ALIGN_16; }; enum charaterEncoding { CE_ASCII_BIN8 = 1, CE_UTF8 = 2, CE_UTF16_LE = 4, CE_UTF16_BE = 8, CE_UCS2_LE = 4, CE_UCS2_BE = 8, CE_UTF32_LE = 16, CE_UTF32_BE = 32, CE_NULL_PADDED = 64, CE_80_NULL_PADDED = 128 }; #include #include class KeySpace { public: KeySpace(const KeySpace &ks); virtual ~KeySpace(); static KeySpace *load(const char *fileName, uint32_t charaterEncoding); static KeySpace *load(std::list > subKeySpaces, uint32_t charaterEncoding); KeySpace& operator=(const KeySpace &ks); bool reset(uint64_t pwNum); uint32_t next(vector4 *pwOut, uint32_t numPws, uint32_t vecSize); uint32_t get(vector4 *pwOut, uint32_t numPws, uint32_t vecSize, uint64_t *pwNums); uint32_t get(char *pwOut, uint64_t pwNum); const uint64_t getKeySpace(); const uint32_t getMaxPwLen(); const uint32_t getMinPwLen(); const std::string getName(); protected: KeySpace() {} static KeySpace *init(std::list > subKeySpaces, uint32_t charaterEncoding); void cleanUp(); void copyObject(const KeySpace &ks); inline const bool reset(uint64_t pwNum, uint32_t *pwOut, uint32_t *charSetPoses, uint32_t &curSubKeySpace); bool cycleLastChar(); uint64_t m_keySpace; uint64_t *m_keySpaceBoundaries; uint32_t *m_passwordLengths, *m_divShortCut, *m_charSetPoses, **m_charSetLengths, *m_pw, *m_pwTemp, *m_charSetPosesTemp; int *m_numShortCutChars; char *m_charSet, ***m_subKeySpaces; uint32_t m_numSubKeySpaces, m_curSubKeySpace, m_maxPwLen, m_minPwLen; uint32_t m_charaterEncoding, m_offset, m_pwBlocks; std::string m_name; }; #endif rcracki-mt-0.7.0/rcracki_mt/rcuda_ext.h0000640000175000017500000000372512043323152017323 0ustar dookiedookie// freerainbowtables is a project for generating, distributing, and using // perfect rainbow tables // // Copyright 2010, 2011 Jan Kyska // Copyright 2010 Martin Westergaard Jørgensen // Copyright 2010, 2011, 2012 James Nobis // // This file is part of freerainbowtables. // // freerainbowtables is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 2 of the License, or // (at your option) any later version. // // freerainbowtables is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with freerainbowtables. If not, see . #ifndef RCUDA_EXT_H #define RCUDA_EXT_H #include "rcuda.h" #include "ChainWalkContext.h" class CudaCWCExtender { public: CudaCWCExtender(CChainWalkContext *cwc); void Init(void); inline rcuda::RHash GetHash(void) { return hash; } inline int GetHashLen(void) { return CChainWalkContext::m_nHashLen; } inline unsigned int* GetPlainDimVec(void) { return &plainDimVec[0]; } inline int GetPlainDimVecSize(void) { return plainDimVec.size(); } inline unsigned char* GetCharSet(void) { return (unsigned char*)plainCharSet.c_str(); } inline int GetCharSetSize(void) { return plainCharSet.size(); } inline uint64_t GetPlainSpaceTotal(void) { return CChainWalkContext::m_nPlainSpaceTotal; } inline uint64_t GetRainbowTableIndex(void) { return CChainWalkContext::m_nRainbowTableIndex; } inline uint64_t GetReduceOffset(void) { return CChainWalkContext::m_nReduceOffset; } protected: CChainWalkContext *cwc; rcuda::RHash hash; std::vector plainDimVec; std::string plainCharSet; }; #endif //RCUDA_EXT_H rcracki-mt-0.7.0/rcracki_mt/TODO0000640000175000017500000000273412043323152015663 0ustar dookiedookie* make use of prefix index for searching tables - decrease i/o * testing/benchmarking suite * remove openssl dependencies HashAlgorithm.cpp des.h - can't use frt upstream as it's BSD licensed ad clause and is GPL incompatible md4.h (fix md4 so it can handle mscache lengths) sha.h (the local sha1 impl is slower than openssl's) * more generic method for path seperator than _WIN32 ifdef? OpenBSD threading misc warnings: ################################################################################ OpenBSD x86_64 /usr/local/lib/gcc/amd64-unknown-openbsd4.5/4.2.0/../../../libestdc++.so.8.0: warning: vsprintf() is often misused, please use vsnprintf() /usr/local/lib/gcc/amd64-unknown-openbsd4.5/4.2.0/../../../libestdc++.so.8.0: warning: strcpy() is almost always misused, please use strlcpy() /usr/local/lib/gcc/amd64-unknown-openbsd4.5/4.2.0/../../../libestdc++.so.8.0: warning: strcat() is almost always misused, please use strlcat() ChainWalkSet.o(.text+0x121): In function `CChainWalkSet::CheckOrRotatePreCalcFile()': : warning: sprintf() is often misused, please use snprintf() ################################################################################ ../../common/rt_api/ChainWalkContext.cpp: In member function ‘void CChainWalkContext::HashToIndex(int)’: ../../common/rt_api/ChainWalkContext.cpp:815: warning: dereferencing type-punned pointer will break strict-aliasing rules HashAlgorithm.cpp: In function 'void HashPIX(unsigned char*, int, unsigned char*)': rcracki-mt-0.7.0/rcracki_mt/rcuda_ntlm.inc0000640000175000017500000001105312043323152020010 0ustar dookiedookie// freerainbowtables is a project for generating, distributing, and using // perfect rainbow tables // // Copyright 2010, 2011 Jan Kyska // Copyright 2010 Martin Westergaard Jørgensen // Copyright 2010, 2011, 2012 James Nobis // // This file is part of freerainbowtables. // // freerainbowtables is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 2 of the License, or // (at your option) any later version. // // freerainbowtables is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with freerainbowtables. If not, see . namespace RC_NTLM { __device__ __constant__ unsigned int h[4] = { 0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476 }; __device__ __constant__ unsigned char r[48] = { \ 3, 7, 11, 19, 3, 7, 11, 19, 3, 7, 11, 19, 3, 7, 11, 19, \ 3, 5, 9, 13, 3, 5, 9, 13, 3, 5, 9, 13, 3, 5, 9, 13, \ 3, 9, 11, 15, 3, 9, 11, 15, 3, 9, 11, 15, 3, 9, 11, 15 }; __device__ __constant__ unsigned char g[48] = { \ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, \ 0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15, \ 0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15 }; __device__ unsigned int FF(unsigned int a, unsigned int b, unsigned int c, unsigned int d, int i, const unsigned int* data) { unsigned int ret; ret = a + ((b&c)|((~b)&d)) + data[SHIDX(g[i])]; ret = (ret<>(32-r[i])); return ret; } __device__ unsigned int GG(unsigned int a, unsigned int b, unsigned int c, unsigned int d, int i, const unsigned int* data) { unsigned int ret; ret = a + ((b&c)|(b&d)|(c&d)) + data[SHIDX(g[i])] + 0x5a827999u; ret = (ret<>(32-r[i])); return ret; } __device__ unsigned int HH(unsigned int a, unsigned int b, unsigned int c, unsigned int d, int i, const unsigned int* data) { unsigned int ret; ret = a + (b^c^d) + data[SHIDX(g[i])] + 0x6ed9eba1u; ret = (ret<>(32-r[i])); return ret; } __device__ void MD4(unsigned int* dataHash) { unsigned int a = h[0], b = h[1], c = h[2], d = h[3], x; int ii; // Round 1 for(ii = 0; ii < 16; ii++) { x = b; b = FF(a, b, c, d, ii, dataHash); a = d; d = c; c = x; } // Round 2 for(; ii < 32; ii++) { x = b; b = GG(a, b, c, d, ii, dataHash); a = d; d = c; c = x; } // Round 3 for(; ii < 48; ii++) { x = b; b = HH(a, b, c, d, ii, dataHash); a = d; d = c; c = x; } dataHash[SHIDX(0)] = a + h[0]; dataHash[SHIDX(1)] = b + h[1]; dataHash[SHIDX(2)] = c + h[2]; dataHash[SHIDX(3)] = d + h[3]; } } #define RT_NTLM_KERNEL(kerName, kerPrologue, kerEpilogue) \ __global__ void kerName(unsigned int chainStart, unsigned int chainStop) { \ unsigned int size, jj, kk; \ unsigned int plain; \ \ kerPrologue; \ \ /* transform to the plain text */ \ plain = 0x80; \ jj = (PLAIN_MAX_SIZE>>1)+1; \ \ kk = 0; \ RTGEN_IDX2PLAIN_BEGIN; \ RTGEN_I2P_LOOP64_BEGIN; \ plain = (plain<<8); \ if((kk++)&1) { \ hData[SHIDX(jj--)] = plain; \ plain = 0; \ } \ plain = (plain<<8) | cplChrSet[(dimItem.z&255u) + uiDiv]; \ RTGEN_I2P_LOOP64_END; \ \ RTGEN_I2P_LOOP32_BEGIN; \ plain = (plain<<8); \ if((kk++)&1) { \ hData[SHIDX(jj--)] = plain; \ plain = 0; \ } \ plain = (plain<<8) | cplChrSet[(dimItem.z&255u) + uiDiv]; \ RTGEN_I2P_LOOP32_END; \ RTGEN_IDX2PLAIN_END; \ \ /* prepare for MD4 */ \ size = (ii<<1); \ ii = (((kk^1)&1)<<4)+8; \ plain = plain<>1)+1; plain = hData[SHIDX(jj++)], idx++) \ hData[SHIDX(idx)] = (plain>>ii)|(hData[SHIDX(jj)]<<(32-ii)); \ hData[SHIDX(idx)] = plain>>ii; \ for(idx++; idx < 14; idx++) \ hData[SHIDX(idx)] = 0; \ hData[SHIDX(idx++)] = size<<3; \ hData[SHIDX(idx)] = 0; \ \ /* hash */ \ RC_NTLM::MD4(hData); \ \ kerEpilogue; \ } RT_NTLM_KERNEL(RTGenNTLMKernel, RTGEN_PROLOGUE, RTGEN_EPILOGUE) RT_NTLM_KERNEL(RTPreCalcNTLMKernel, RTPRECALC_PROLOGUE, RTPRECALC_EPILOGUE) RT_NTLM_KERNEL(RTCheckAlarmNTLMKernel, RTCHKALARM_PROLOGUE, RTCHKALARM_EPILOGUE) rcracki-mt-0.7.0/rcracki_mt/HashSet.h0000640000175000017500000000364312043323152016703 0ustar dookiedookie/* * rcracki_mt is a multithreaded implementation and fork of the original * RainbowCrack * * Copyright (C) Zhu Shuanglei * Copyright Martin Westergaard Jørgensen * Copyright 2009, 2010 Daniël Niggebrugge * Copyright 2009, 2010, 2011, 2012 James Nobis * * This file is part of rcracki_mt. * * rcracki_mt is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * rcracki_mt is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with rcracki_mt. If not, see . */ #ifndef _HASHSET_H #define _HASHSET_H #include "Public.h" class CHashSet { public: CHashSet(); virtual ~CHashSet(); private: std::vector m_vHash; std::vector m_vFound; std::vector m_vPlain; std::vector m_vBinary; public: void AddHash(std::string sHash); // lowercase, len % 2 == 0, MIN_HASH_LEN * 2 <= len <= MAX_HASH_LEN * 2 bool AnyhashLeft(); bool AnyHashLeftWithLen(int nLen); void GetLeftHashWithLen(std::vector& vHash, int nLen); void SetPlain(std::string sHash, std::string sPlain, std::string sBinary); bool GetPlain(std::string sHash, std::string& sPlain, std::string& sBinary); int GetStatHashFound(); int GetStatHashTotal(); std::string GetHashInfo(int i); void AddHashInfo(std::string sHash, bool found, std::string sPlain, std::string sBinary); }; #endif rcracki-mt-0.7.0/rcracki_mt/RTIReader.cpp0000640000175000017500000002130012043323152017446 0ustar dookiedookie/* * freerainbowtables is a project for generating, distributing, and using * perfect rainbow tables * * Copyright 2010, 2011 Martin Westergaard Jørgensen * Copyright 2010, 2011, 2012 James Nobis * Copyright 2011 Logan Watt * * This file is part of freerainbowtables. * * freerainbowtables is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * freerainbowtables is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with freerainbowtables. If not, see . */ #include "RTIReader.h" /// Default constructor RTIReader::RTIReader() { RTIReaderInit(); } /** Constructor with filename * @param std::string file name on disk * index file is std::string + '.index' */ RTIReader::RTIReader( std::string fname ) { RTIReaderInit(); this->indexFileName = fname + ".index"; setFileName( fname ); if( stat( getFileName().c_str(), &fileStats ) == -1 ) { std::cerr << "ERROR: stat() for file: " << getFileName() << " FAILED! " << std::endl; exit(-1); } if( stat( indexFileName.c_str(), &indexFileStats ) == -1 ) { std::cerr << "ERROR: stat() for file: " << indexFileName << " FAILED! " << std::endl; exit(-1); } data = fopen( getFileName().c_str(), "rb"); if( data == NULL ) { std::cerr << "ERROR: could not open table file: " << getFileName() << " EXITING!" << std::endl; exit(-1); } indexFileData = fopen( indexFileName.c_str(), "rb"); if( indexFileData == NULL ) { std::cerr << "ERROR: could not open index file: " << indexFileName.c_str() << " EXITING!" << std::endl; exit(-1); } // XXX possibly remove if we dont want this to happen automagically loadIndex(); } /** * Argument Constructor * @param uint32_t number of chains in the file * @param uint32_t size of the chain * @param uint32_t reduction function index offset * @param uint32_t start point in the chain * @param uint32_t end point in the chain * @param std::string name of the file on disk * @param std::string salt used for hash */ RTIReader::RTIReader(uint32_t chCount, uint32_t chLength, uint32_t tblIdx, uint32_t stPt, uint32_t endPt, std::string fname, std::string slt) { RTIReaderInit(); this->indexFileName = fname + ".index"; setFileName( fname ); if( stat( getFileName().c_str(), &fileStats ) == -1 ) { std::cerr << "ERROR: stat() for file: " << getFileName() << " FAILED! " << std::endl; exit(-1); } if( stat( indexFileName.c_str(), &indexFileStats ) == -1 ) { std::cerr << "ERROR: stat() for file: " << indexFileName << " FAILED! " << std::endl; exit(-1); } data = fopen( getFileName().c_str(), "rb"); if( data == NULL ) { std::cerr << "ERROR: could not open table file: " << getFileName() << " EXITING!" << std::endl; exit(-1); } indexFileData = fopen( indexFileName.c_str(), "rb"); if( indexFileData == NULL ) { std::cerr << "ERROR: could not open index file: " << indexFileName.c_str() << " EXITING!" << std::endl; exit(-1); } // XXX remove this if we don't want it to happen automagically loadIndex(); setChainCount( chCount ); setChainLength( chLength ); setTableIndex( tblIdx ); setStartPointBits( stPt ); setEndPointBits( endPt ); setSalt( slt ); } /// shared init method void RTIReader::RTIReaderInit() { this->chainSize = 8; this->indexSize = 11; setStartPointBits(6); setEndPointBits(2); index = NULL; } /// loadIndex void RTIReader::loadIndex() { if( ( fileStats.st_size % chainSize ) != 0 ) { std::cerr << "ERROR: file length mismatch (" << fileStats.st_size << " bytes) EXITING!" << std::endl; exit(-1); } if( ( indexFileStats.st_size % indexSize ) != 0 ) { std::cerr << "ERROR: index file length mismatch (" << indexFileStats.st_size << " bytes) EXITING!" << std::endl; exit(-1); } if( index != NULL ) { delete index; index = NULL; } index = new (std::nothrow) IndexChain[ indexFileStats.st_size / indexSize ]; if( index == NULL ) { std::cerr << "ERROR: failed to allocate " << ( indexFileStats.st_size / indexSize / 1024/ 1024 ) << " MB of memory. EXITING!" << std::endl; exit(-2); } memset( index, 0x00, sizeof(IndexChain) * ( indexFileStats.st_size / indexSize ) ); fseek( indexFileData, 0, SEEK_SET ); uint32_t rows; for( rows = 0; (rows * indexSize) < (unsigned)indexFileStats.st_size; rows++ ) { if( fread( &index[rows].nPrefix, 5, 1, indexFileData ) != 1 ) break; if( fread( &index[rows].nFirstChain, 4, 1, indexFileData ) != 1 ) break; if( fread( &index[rows].nChainCount, 2, 1, indexFileData ) != 1) break; // Index Check if( rows != 0 && index[rows].nFirstChain < index[rows - 1].nFirstChain ) { std::cerr << "ERROR: Corrupted index detected (FirstChain is less than previous) EXITING!" << std::endl; exit(-1); } else if( rows != 0 && index[rows].nFirstChain != index[rows - 1].nFirstChain + index[rows - 1].nChainCount ) { std::cerr << "ERROR: Corrupted index detected ( LastChain + nChainCount != FirstChain ) EXITING!" << std::endl; exit(-1); } } if( index[rows - 1].nFirstChain + index[rows - 1].nChainCount + 1 <= fileStats.st_size / chainSize ) { std::cerr << "ERROR: Corrupted index detected. Not covering the entire file EXITING!" << std::endl; exit(-1); } if( index[rows - 1].nFirstChain + index[rows - 1].nChainCount > fileStats.st_size / chainSize ) { std::cerr << "ERROR: Corrupted index detected. The index is covering more than the file" << index[rows - 1].nFirstChain + index[rows - 1].nChainCount << " chains of " << fileStats.st_size / chainSize << "chains) EXITING!"<< std::endl; exit(-1); } // XXX this was in the original RTIReader - i dont know why but putting it // here just in case indexSize = rows; } /// getIndexFileName std::string RTIReader::getIndexFileName() { return this->indexFileName; } /// getChainSize uint32_t RTIReader::getChainSize() { return this->chainSize; } /// getIndexSize uint32_t RTIReader::getIndexSize() { return this->indexSize; } // XXX used for debugging getIndexFileSize uint32_t RTIReader::getIndexFileSize() { return indexFileStats.st_size; } uint32_t RTIReader::getDataFileSize() { return fileStats.st_size; } FILE* RTIReader::getIndexFileData() { return indexFileData; } FILE* RTIReader::getDataFile() { return data; } // XXX end debug type functions /// getChainsLeft uint32_t RTIReader::getChainsLeft() { return ( fileStats.st_size / chainSize ) - chainPosition; } /** * reads data chains into memory * @param uint32_t reference to the number of chains to read * @param RanbowChain0* pointer in memory to read the chains to * @return EXIT_SUCCESS or EXIT_FAILURE */ int RTIReader::readChains(uint32_t &numChains, RainbowChainO *pData) { // reset data to 0x00 or something bad happens memset( pData, 0x00, sizeof( RainbowChainO ) * numChains ); uint32_t readChains = 0; uint32_t chainsLeft = getChainsLeft(); for( uint32_t i = 0; i < indexSize; i++ ) { if( chainPosition + readChains > index[i].nFirstChain + index[i].nChainCount ) continue; while( chainPosition + readChains < index[i].nFirstChain + index[i].nChainCount ) { pData[readChains].nIndexE = index[i].nPrefix << 16; uint32_t endPoint = 0; // have to set to 0 // XXX start points may not exceed 6 bytes ( 2^48 ) fread( &pData[readChains].nIndexS, 6, 1, data); fread( &endPoint, 2, 1, data); pData[readChains].nIndexE += endPoint; readChains++; if( readChains == numChains || readChains == chainsLeft ) break; } if( readChains == numChains ) break; } if( readChains != numChains ) numChains = readChains; // update how many chains we read chainPosition += readChains; std::cout << "Chain Position is now " << chainPosition << std::endl; return EXIT_SUCCESS; } uint64_t RTIReader::getMinimumStartPoint() { uint64_t tmpStartPoint = 0; uint64_t minimumStartPoint = (uint64_t)-1; uint16_t tmpEndPoint; long originalFilePos = ftell( data ); rewind( data ); while ( !feof( data ) ) { fread( &tmpStartPoint, 6, 1, data ); fread( &tmpEndPoint, 2, 1, data ); if ( tmpStartPoint < minimumStartPoint ) minimumStartPoint = tmpStartPoint; } fseek( data, originalFilePos, SEEK_SET ); return minimumStartPoint; } void RTIReader::Dump() { } /// Destructor RTIReader::~RTIReader() { if( indexFileData != NULL ) fclose( indexFileData ); if ( index != NULL ) { delete index; index = NULL; } } rcracki-mt-0.7.0/rcracki_mt/CrackEngine.h0000640000175000017500000000767212043323152017523 0ustar dookiedookie/* * rcracki_mt is a multithreaded implementation and fork of the original * RainbowCrack * * Copyright (C) Zhu Shuanglei * Copyright Martin Westergaard Jørgensen * Copyright 2009, 2010 Daniël Niggebrugge * Copyright 2009, 2010, 2011, 2012 James Nobis * Copyright 2010 uroskn * Copyright 2011 Jan Kyska * * This file is part of rcracki_mt. * * rcracki_mt is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * rcracki_mt is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with rcracki_mt. If not, see . */ #ifndef _CRACKENGINE_H #define _CRACKENGINE_H #include "Public.h" #include "HashSet.h" #include "ChainWalkContext.h" #include "MemoryPool.h" #include "ChainWalkSet.h" #include "rcrackiThread.h" #ifdef _WIN32 #include #include #endif #include #pragma pack(1) union RTIrcrackiIndexChain { uint64_t nPrefix; //5 struct { unsigned char foo[5]; unsigned int nFirstChain; //4 unsigned short nChainCount; //2 }; //unsigned short nChainCount; (maybe union with nPrefix, 1 byte spoiled, no pack(1) needed) }; #pragma pack() // you can't use pack(0) - it makes VC++ angry class CCrackEngine { public: CCrackEngine(); virtual ~CCrackEngine(); private: CChainWalkSet m_cws; int maxThreads; uint64_t maxMem; bool writeOutput; bool resumeSession; std::string outputFile; std::string sSessionPathName; std::string sProgressPathName; std::string sPrecalcPathName; //string sPrecalcIndexPathName; bool debug; bool keepPrecalcFiles; int gpu; // Statistics float m_fTotalDiskAccessTime; float m_fTotalCryptanalysisTime; float m_fTotalPrecalculationTime; uint64_t m_nTotalChainWalkStep; int m_nTotalFalseAlarm; uint64_t m_nTotalChainWalkStepDueToFalseAlarm; FILE *m_fChains; private: void ResetStatistics(); RainbowChain *BinarySearch(RainbowChain *pChain, int nChainCountRead, uint64_t nIndex, RTIrcrackiIndexChain *pIndex, int nIndexSize, int nIndexStart); int BinarySearchOld(RainbowChainO* pChain, int nRainbowChainCount, uint64_t nIndex); void GetChainIndexRangeWithSameEndpoint(RainbowChainO* pChain, int nRainbowChainCount, int nChainIndex, int& nChainIndexFrom, int& nChainIndexTo); void SearchTableChunk(RainbowChain* pChain, int nRainbowChainLen, int nRainbowChainCount, CHashSet& hs, RTIrcrackiIndexChain *pIndex, int nIndexSize, int nChainStart); void SearchTableChunkOld(RainbowChainO* pChain, int nRainbowChainLen, int nRainbowChainCount, CHashSet& hs); //bool CheckAlarm(RainbowChain* pChain, int nGuessedPos, unsigned char* pHash, CHashSet& hs); //bool CheckAlarmOld(RainbowChainO* pChain, int nGuessedPos, unsigned char* pHash, CHashSet& hs); public: void SearchRainbowTable(std::string pathName, CHashSet& hs); void Run(std::vector vPathName, CHashSet& hs, int i_maxThreads, uint64_t i_maxMem, bool resume, bool bDebug, int gpu = 0); float GetStatTotalDiskAccessTime(); float GetStatTotalCryptanalysisTime(); float GetStatTotalPrecalculationTime(); uint64_t GetStatTotalChainWalkStep(); uint64_t GetStatTotalFalseAlarm(); uint64_t GetStatTotalChainWalkStepDueToFalseAlarm(); void setOutputFile(std::string pathName); void setSession(std::string sSessionPathName, std::string sProgressPathName, std::string sPrecalcPathName, bool keepPrecalc); }; #endif rcracki-mt-0.7.0/rcracki_mt/rcuda_sha1.inc0000640000175000017500000001650312043323152017677 0ustar dookiedookie// freerainbowtables is a project for generating, distributing, and using // perfect rainbow tables // // Copyright 2010, 2011 Jan Kyska // Copyright 2010 Martin Westergaard Jørgensen // Copyright 2010, 2011, 2012 James Nobis // // This file is part of freerainbowtables. // // freerainbowtables is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 2 of the License, or // (at your option) any later version. // // freerainbowtables is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with freerainbowtables. If not, see . namespace RC_SHA1 { __device__ __constant__ unsigned int h[5] = { 0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0 }; __device__ unsigned int SwapEndian(unsigned int n) { return (n<<24)|((n&0x0000ff00)<<8)|((n>>8)&0x0000ff00)|(n>>24); } __device__ unsigned int FF(unsigned int a, unsigned int b, unsigned int c, unsigned int d, unsigned int e, int i, unsigned int* data) { return ((a<<5)|(a>>27)) + ((b&c)|((~b)&d)) + e + 0x5A827999 + data[SHIDX(i)]; } __device__ unsigned int FF2(unsigned int a, unsigned int b, unsigned int c, unsigned int d, unsigned int e, int i, unsigned int* data) { unsigned int dt; dt = data[SHIDX(i&15)]^data[SHIDX((i-3)&15)]^data[SHIDX((i-8)&15)]^data[SHIDX((i-14)&15)]; data[SHIDX(i&15)] = dt = ((dt<<1)|(dt>>31)); return ((a<<5)|(a>>27)) + ((b&c)|((~b)&d)) + e + 0x5A827999 + dt; } __device__ unsigned int GG(unsigned int a, unsigned int b, unsigned int c, unsigned int d, unsigned int e, int i, unsigned int* data) { unsigned int dt; dt = data[SHIDX(i&15)]^data[SHIDX((i-3)&15)]^data[SHIDX((i-8)&15)]^data[SHIDX((i-14)&15)]; data[SHIDX(i&15)] = dt = ((dt<<1)|(dt>>31)); return ((a<<5)|(a>>27)) + (b^c^d) + e + 0x6ED9EBA1 + dt; } __device__ unsigned int HH(unsigned int a, unsigned int b, unsigned int c, unsigned int d, unsigned int e, int i, unsigned int* data) { unsigned int dt; dt = data[SHIDX(i&15)]^data[SHIDX((i-3)&15)]^data[SHIDX((i-8)&15)]^data[SHIDX((i-14)&15)]; data[SHIDX(i&15)] = dt = ((dt<<1)|(dt>>31)); return ((a<<5)|(a>>27)) + ((b&c)|(b&d)|(c&d)) + e + 0x8F1BBCDC + dt; } __device__ unsigned int II(unsigned int a, unsigned int b, unsigned int c, unsigned int d, unsigned int e, int i, unsigned int* data) { unsigned int dt; dt = data[SHIDX(i&15)]^data[SHIDX((i-3)&15)]^data[SHIDX((i-8)&15)]^data[SHIDX((i-14)&15)]; data[SHIDX(i&15)] = dt = ((dt<<1)|(dt>>31)); return ((a<<5)|(a>>27)) + (b^c^d) + e + 0xCA62C1D6 + dt; } __device__ void SHA1(unsigned int* dataHash) { unsigned int a = h[0], b = h[1], c = h[2], d = h[3], e = h[4], x; int ii; // Round 1 for(ii = 0; ii < 16; ii++) { x = FF(a, b, c, d, e, ii, dataHash); e = d; d = c; c = ((b<<30)|(b>>2)); b = a; a = x; } for(; ii < 20; ii++) { x = FF2(a, b, c, d, e, ii, dataHash); e = d; d = c; c = ((b<<30)|(b>>2)); b = a; a = x; } // Round 2 for(; ii < 40; ii++) { x = GG(a, b, c, d, e, ii, dataHash); e = d; d = c; c = ((b<<30)|(b>>2)); b = a; a = x; } // Round 3 for(; ii < 60; ii++) { x = HH(a, b, c, d, e, ii, dataHash); e = d; d = c; c = ((b<<30)|(b>>2)); b = a; a = x; } // Round 4 for(; ii < 80; ii++) { x = II(a, b, c, d, e, ii, dataHash); e = d; d = c; c = ((b<<30)|(b>>2)); b = a; a = x; } dataHash[SHIDX(0)] = a + h[0]; dataHash[SHIDX(1)] = b + h[1]; dataHash[SHIDX(2)] = c + h[2]; dataHash[SHIDX(3)] = d + h[3]; dataHash[SHIDX(4)] = e + h[4]; } } #define RT_SHA1_KERNEL(kerName, kerPrologue, kerEpilogue) \ __global__ void kerName(unsigned int chainStart, unsigned int chainStop) { \ unsigned int size, jj; \ unsigned int plain; \ \ kerPrologue; \ \ /* transform to the plain text */ \ plain = 0x80; \ jj = (PLAIN_MAX_SIZE>>2)+1; \ \ RTGEN_IDX2PLAIN_BEGIN; \ RTGEN_I2P_LOOP64_BEGIN; \ plain = (plain<<8) | cplChrSet[(dimItem.z&255u) + uiDiv]; \ if((ii&3) == 2) { \ hData[SHIDX(jj--)] = plain; \ plain = 0; \ } \ RTGEN_I2P_LOOP64_END; \ \ RTGEN_I2P_LOOP32_BEGIN; \ plain = (plain<<8) | cplChrSet[(dimItem.z&255u) + uiDiv]; \ if((ii&3) == 2) { \ hData[SHIDX(jj--)] = plain; \ plain = 0; \ } \ RTGEN_I2P_LOOP32_END; \ RTGEN_IDX2PLAIN_END; \ \ /* prepare for SHA1 */ \ size = ii; \ ii = ((((3-(ii&3))<<3)-1)&0x1f)+1; \ plain = plain<>2)+1; plain = hData[SHIDX(jj++)], idx++) \ hData[SHIDX(idx)] = RC_SHA1::SwapEndian((plain>>ii)|(hData[SHIDX(jj)]<<(32-ii))); \ hData[SHIDX(idx)] = RC_SHA1::SwapEndian(plain>>ii); \ for(idx++; idx < 14; idx++) \ hData[SHIDX(idx)] = 0; \ hData[SHIDX(idx++)] = 0; \ hData[SHIDX(idx)] = size<<3; \ \ /* hash */ \ RC_SHA1::SHA1(hData); \ \ hData[SHIDX(0)] = RC_SHA1::SwapEndian(hData[SHIDX(0)]); \ hData[SHIDX(1)] = RC_SHA1::SwapEndian(hData[SHIDX(1)]); \ \ kerEpilogue; \ } #define RT_MYSQLSHA1_KERNEL(kerName, kerPrologue, kerEpilogue) \ __global__ void kerName(unsigned int chainStart, unsigned int chainStop) { \ unsigned int size, jj, kk; \ unsigned int plain; \ \ kerPrologue; \ \ /* transform to the plain text */ \ plain = 0x80; \ jj = (PLAIN_MAX_SIZE>>2)+1; \ \ RTGEN_IDX2PLAIN_BEGIN; \ RTGEN_I2P_LOOP64_BEGIN; \ plain = (plain<<8) | cplChrSet[(dimItem.z&255u) + uiDiv]; \ if((ii&3) == 2) { \ hData[SHIDX(jj--)] = plain; \ plain = 0; \ } \ RTGEN_I2P_LOOP64_END; \ \ RTGEN_I2P_LOOP32_BEGIN; \ plain = (plain<<8) | cplChrSet[(dimItem.z&255u) + uiDiv]; \ if((ii&3) == 2) { \ hData[SHIDX(jj--)] = plain; \ plain = 0; \ } \ RTGEN_I2P_LOOP32_END; \ RTGEN_IDX2PLAIN_END; \ \ /* prepare for SHA1 */ \ size = ii; \ ii = ((((3-(ii&3))<<3)-1)&0x1f)+1; \ plain = plain<>2)+1; plain = hData[SHIDX(jj++)], idx++) \ hData[SHIDX(idx)] = RC_SHA1::SwapEndian((plain>>ii)|(hData[SHIDX(jj)]<<(32-ii))); \ hData[SHIDX(idx)] = RC_SHA1::SwapEndian(plain>>ii); \ for(kk = 0; kk < 2; kk++) { \ for(idx++; idx < 14; idx++) \ hData[SHIDX(idx)] = 0; \ hData[SHIDX(idx++)] = 0; \ hData[SHIDX(idx)] = size<<3; \ \ /* hash */ \ RC_SHA1::SHA1(hData); \ \ idx = 5; \ hData[SHIDX(idx)] = RC_SHA1::SwapEndian(0x80); \ size = 20; \ } \ hData[SHIDX(0)] = RC_SHA1::SwapEndian(hData[SHIDX(0)]); \ hData[SHIDX(1)] = RC_SHA1::SwapEndian(hData[SHIDX(1)]); \ \ kerEpilogue; \ } RT_SHA1_KERNEL(RTGenSHA1Kernel, RTGEN_PROLOGUE, RTGEN_EPILOGUE) RT_SHA1_KERNEL(RTPreCalcSHA1Kernel, RTPRECALC_PROLOGUE, RTPRECALC_EPILOGUE) RT_SHA1_KERNEL(RTCheckAlarmSHA1Kernel, RTCHKALARM_PROLOGUE, RTCHKALARM_EPILOGUE) RT_MYSQLSHA1_KERNEL(RTGenMySQLSHA1Kernel, RTGEN_PROLOGUE, RTGEN_EPILOGUE) RT_MYSQLSHA1_KERNEL(RTPreCalcMySQLSHA1Kernel, RTPRECALC_PROLOGUE, RTPRECALC_EPILOGUE) RT_MYSQLSHA1_KERNEL(RTCheckAlarmMySQLSHA1Kernel, RTCHKALARM_PROLOGUE, RTCHKALARM_EPILOGUE) rcracki-mt-0.7.0/rcracki_mt/rcrackiThread.h0000640000175000017500000000526512043323152020114 0ustar dookiedookie/* * rcracki_mt is a multithreaded implementation and fork of the original * RainbowCrack * * Copyright 2009, 2010 Daniël Niggebrugge * Copyright 2009, 2010, 2011, 2012 James Nobis * Copyright 2011 Jan Kyska * * This file is part of rcracki_mt. * * rcracki_mt is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * rcracki_mt is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with rcracki_mt. If not, see . */ #ifndef _RCRACKITHREAD_H #define _RCRACKITHREAD_H #include "ChainWalkContext.h" #include "Public.h" #include "HashSet.h" //#include #include class rcrackiThread { private: unsigned char* t_TargetHash; int t_nPos; int t_nRainbowChainLen; CChainWalkContext t_cwc; std::vector t_vStartPosIndexE; int t_ID; int t_count; uint64_t* t_pStartPosIndexE; int t_nChainWalkStep; bool falseAlarmChecker; bool falseAlarmCheckerO; std::vector t_pChainsFound; std::vector t_pChainsFoundO; std::vector t_nGuessedPoss; unsigned char* t_pHash; bool foundHash; int t_nChainWalkStepDueToFalseAlarm; int t_nFalseAlarm; std::string t_Hash; std::string t_Plain; std::string t_Binary; int gpu; int cudaDevId; int cudaBuffCount; int cudaChainSize; public: rcrackiThread(unsigned char* TargetHash, int thread_id, int nRainbowChainLen, int thread_count, uint64_t* pStartPosIndexE); rcrackiThread(unsigned char* pHash, bool oldFormat = false); rcrackiThread(void); ~rcrackiThread(void); //void SetWork(unsigned char* TargetHash, int nPos, int nRainbowChainLen); //static unsigned __stdcall rcrackiThread::rcrackiThreadStaticEntryPoint(void * pThis); static void * rcrackiThreadStaticEntryPointPthread(void * pThis); int GetIndexCount(); int GetChainWalkStep(); uint64_t GetIndex(int nPos); bool FoundHash(); void AddAlarmCheck(RainbowChain* pChain, int nGuessedPos); void AddAlarmCheckO(RainbowChainO* pChain, int nGuessedPos); int GetChainWalkStepDueToFalseAlarm(); int GetnFalseAlarm(); std::string GetHash(); std::string GetPlain(); std::string GetBinary(); void Configure(int gpu); private: void rcrackiThreadEntryPoint(); void PreCalculate(); void CheckAlarm(); void CheckAlarmO(); }; #endif rcracki-mt-0.7.0/rcracki_mt/rcrackiThread.cpp0000640000175000017500000002613312043323152020444 0ustar dookiedookie/* * rcracki_mt is a multithreaded implementation and fork of the original * RainbowCrack * * Copyright 2009, 2010 Daniël Niggebrugge * Copyright 2009, 2010, 2011, 2012 James Nobis * Copyright 2011 Jan Kyska * * This file is part of rcracki_mt. * * rcracki_mt is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * rcracki_mt is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with rcracki_mt. If not, see . */ #include "rcrackiThread.h" #if GPU #include "rcuda.h" #include "rcuda_ext.h" #include #include #endif // create job for pre-calculation rcrackiThread::rcrackiThread(unsigned char* TargetHash, int thread_id, int nRainbowChainLen, int thread_count, uint64_t* pStartPosIndexE) { t_TargetHash = TargetHash; t_nRainbowChainLen = nRainbowChainLen; t_ID = thread_id; t_count = thread_count; t_pStartPosIndexE = pStartPosIndexE; t_nChainWalkStep = 0; falseAlarmChecker = false; falseAlarmCheckerO = false; gpu = 0; cudaDevId = -1; } // create job for false alarm checking rcrackiThread::rcrackiThread(unsigned char* pHash, bool oldFormat) { falseAlarmChecker = true; falseAlarmCheckerO = oldFormat; t_pChainsFound.clear(); t_nGuessedPoss.clear(); t_pHash = pHash; t_nChainWalkStepDueToFalseAlarm = 0; t_nFalseAlarm = 0; foundHash = false; gpu = 0; cudaDevId = -1; } void rcrackiThread::AddAlarmCheck(RainbowChain* pChain, int nGuessedPos) { t_pChainsFound.push_back(pChain); t_nGuessedPoss.push_back(nGuessedPos); } void rcrackiThread::AddAlarmCheckO(RainbowChainO* pChain, int nGuessedPos) { t_pChainsFoundO.push_back(pChain); t_nGuessedPoss.push_back(nGuessedPos); } // Windows (beginthreadex) way of threads //unsigned __stdcall rcrackiThread::rcrackiThreadStaticEntryPoint(void * pThis) //{ // rcrackiThread* pTT = (rcrackiThread*)pThis; // pTT->rcrackiThreadEntryPoint(); // _endthreadex( 2 ); // return 2; //} // entry point for the posix thread void * rcrackiThread::rcrackiThreadStaticEntryPointPthread(void * pThis) { rcrackiThread* pTT = (rcrackiThread*)pThis; pTT->rcrackiThreadEntryPoint(); pthread_exit(NULL); return NULL; } // start processing of jobs void rcrackiThread::rcrackiThreadEntryPoint() { #if GPU if(gpu != 0 && cudaGetDevice(&cudaDevId) == CUDA_SUCCESS) { cudaBuffCount = 0x2000; cudaChainSize = 100; cudaDeviceProp deviceProp; if(cudaGetDeviceProperties(&deviceProp, cudaDevId) == CUDA_SUCCESS) { switch(deviceProp.major) { case 1: ; break; case 2: cudaBuffCount = 0x4000; cudaChainSize = 200; break; } } cudaBuffCount = rcuda::GetChainsBufferSize(cudaBuffCount); } else #endif cudaDevId = -1; if (falseAlarmChecker) { if (falseAlarmCheckerO) { CheckAlarmO(); } else { CheckAlarm(); } } else { PreCalculate(); } } uint64_t rcrackiThread::GetIndex(int nPos) { uint64_t t_index = t_vStartPosIndexE[nPos - t_ID]; return t_index; } int rcrackiThread::GetChainWalkStep() { return t_nChainWalkStep; } int rcrackiThread::GetIndexCount() { return t_vStartPosIndexE.size(); } rcrackiThread::~rcrackiThread(void) { } void rcrackiThread::PreCalculate() { if(cudaDevId < 0) { for (t_nPos = t_nRainbowChainLen - 2 - t_ID; t_nPos >= 0; t_nPos -= t_count) { t_cwc.SetHash(t_TargetHash); t_cwc.HashToIndex(t_nPos); int i; for ( i = t_nPos + 1; i <= t_nRainbowChainLen - 2; i++ ) { t_cwc.IndexToPlain(); t_cwc.PlainToHash(); t_cwc.HashToIndex(i); } t_pStartPosIndexE[t_nPos] = t_cwc.GetIndex(); t_nChainWalkStep += t_nRainbowChainLen - 2 - t_nPos; } } #if GPU else { CudaCWCExtender ex(&t_cwc); rcuda::RCudaTask cuTask; int ii, calcSize; ex.Init(); for (t_nPos = 0; t_nPos < t_nRainbowChainLen - 1; ) { calcSize = std::min(t_nPos + cudaBuffCount, t_nRainbowChainLen - 1); for (ii = t_nPos; ii < calcSize; ii++) { t_cwc.SetHash(t_TargetHash); t_cwc.HashToIndex(ii); t_pStartPosIndexE[ii] = t_cwc.GetIndex(); } calcSize -= t_nPos; cuTask.hash = ex.GetHash(); cuTask.startIdx = t_nPos; cuTask.idxCount = calcSize; cuTask.dimVec = ex.GetPlainDimVec(); cuTask.dimVecSize = ex.GetPlainDimVecSize()/2; cuTask.charSet = ex.GetCharSet(); cuTask.charSetSize = ex.GetCharSetSize(); cuTask.reduceOffset = ex.GetReduceOffset(); cuTask.plainSpaceTotal = ex.GetPlainSpaceTotal(); cuTask.rainbowChainLen = t_nRainbowChainLen; cuTask.kernChainSize = cudaChainSize; calcSize = rcuda::PreCalculateOnCUDA(&cuTask, t_pStartPosIndexE + cuTask.startIdx); if(calcSize > 0 && calcSize == cuTask.idxCount) { t_nChainWalkStep += calcSize*(t_nRainbowChainLen - 2) - (calcSize*(2*t_nPos + calcSize - 1))/2; t_nPos += calcSize; } else { printf("PreCalculate() on CUDA failed!\n"); exit(100); } } } #endif } void rcrackiThread::CheckAlarm() { uint32_t i; if(cudaDevId < 0) { for (i = 0; i < t_pChainsFound.size(); i++) { RainbowChain* t_pChain = t_pChainsFound[i]; int t_nGuessedPos = t_nGuessedPoss[i]; CChainWalkContext cwc; //uint64_t nIndexS = t_pChain->nIndexS & 0x0000FFFFFFFFFFFF; // for first 6 bytes //uint64_t nIndexS = t_pChain->nIndexS >> 16; uint64_t nIndexS = t_pChain->nIndexS & 0x0000FFFFFFFFFFFFULL; // for first 6 bytes cwc.SetIndex(nIndexS); //cwc.SetIndex(t_pChain->nIndexS); int nPos; for (nPos = 0; nPos < t_nGuessedPos; nPos++) { cwc.IndexToPlain(); cwc.PlainToHash(); cwc.HashToIndex(nPos); } cwc.IndexToPlain(); cwc.PlainToHash(); if (cwc.CheckHash(t_pHash)) { t_Hash = cwc.GetHash(); t_Plain = cwc.GetPlain(); t_Binary = cwc.GetBinary(); foundHash = true; break; } else { foundHash = false; t_nChainWalkStepDueToFalseAlarm += t_nGuessedPos + 1; t_nFalseAlarm++; } } } #if GPU else { uint64_t *calcBuff = new uint64_t[2*cudaBuffCount]; CudaCWCExtender ex(&t_cwc); rcuda::RCudaTask cuTask; int nGuessedPos, nMaxGuessedPos; int ii, calcSize; size_t chainSize; ex.Init(); chainSize = t_pChainsFound.size(); foundHash = false; for(i = 0; !foundHash && i < chainSize; ) { calcSize = std::min(i + cudaBuffCount, chainSize); nMaxGuessedPos = 0; for(ii = i; ii < calcSize; ii++) { calcBuff[(ii<<1)] = (t_pChainsFound[ii]->nIndexS & 0x0000FFFFFFFFFFFFull); // for first 6 bytes nGuessedPos = t_nGuessedPoss[ii]; calcBuff[(ii<<1)+1] = (unsigned int)nGuessedPos; nMaxGuessedPos = (nMaxGuessedPos>=nGuessedPos? nMaxGuessedPos : nGuessedPos); } calcSize -= i; cuTask.hash = ex.GetHash(); cuTask.startIdx = i; cuTask.idxCount = calcSize; cuTask.dimVec = ex.GetPlainDimVec(); cuTask.dimVecSize = ex.GetPlainDimVecSize()/2; cuTask.charSet = ex.GetCharSet(); cuTask.charSetSize = ex.GetCharSetSize(); cuTask.reduceOffset = ex.GetReduceOffset(); cuTask.plainSpaceTotal = ex.GetPlainSpaceTotal(); cuTask.rainbowChainLen = nMaxGuessedPos; cuTask.kernChainSize = cudaChainSize; cuTask.targetHash = t_pHash; calcSize = rcuda::CheckAlarmOnCUDA(&cuTask, calcBuff); if(calcSize > 0 && calcSize == cuTask.idxCount) { for(ii = 0; ii < calcSize; ii++) { if(calcBuff[(ii<<1)|1] >= (1ull<<63)) { CChainWalkContext cwc; cwc.SetIndex(calcBuff[ii<<1]); cwc.IndexToPlain(); cwc.PlainToHash(); t_Hash = cwc.GetHash(); t_Plain = cwc.GetPlain(); t_Binary = cwc.GetBinary(); foundHash = true; break; } else { t_nChainWalkStepDueToFalseAlarm += calcBuff[(ii<<1)|1] + 1; t_nFalseAlarm++; } } i += calcSize; } else { printf("CheckAlarm() on CUDA failed!\n"); exit(101); } } delete [] calcBuff; } #endif } void rcrackiThread::CheckAlarmO() { uint32_t i; if(cudaDevId < 0) { for (i = 0; i < t_pChainsFoundO.size(); i++) { RainbowChainO* t_pChain = t_pChainsFoundO[i]; int t_nGuessedPos = t_nGuessedPoss[i]; CChainWalkContext cwc; uint64_t nIndexS = t_pChain->nIndexS; cwc.SetIndex(nIndexS); int nPos; for (nPos = 0; nPos < t_nGuessedPos; nPos++) { cwc.IndexToPlain(); cwc.PlainToHash(); cwc.HashToIndex(nPos); } cwc.IndexToPlain(); cwc.PlainToHash(); if (cwc.CheckHash(t_pHash)) { t_Hash = cwc.GetHash(); t_Plain = cwc.GetPlain(); t_Binary = cwc.GetBinary(); foundHash = true; break; } else { foundHash = false; t_nChainWalkStepDueToFalseAlarm += t_nGuessedPos + 1; t_nFalseAlarm++; } } } #if GPU else { uint64_t *calcBuff = new uint64_t[2*cudaBuffCount]; CudaCWCExtender ex(&t_cwc); rcuda::RCudaTask cuTask; int nGuessedPos, nMaxGuessedPos; int ii, calcSize; size_t chainSize; ex.Init(); chainSize = t_pChainsFoundO.size(); foundHash = false; for(i = 0; !foundHash && i < chainSize; ) { calcSize = std::min(i + cudaBuffCount, chainSize); nMaxGuessedPos = 0; for(ii = i; ii < calcSize; ii++) { calcBuff[(ii<<1)] = t_pChainsFoundO[ii]->nIndexS; nGuessedPos = t_nGuessedPoss[ii]; calcBuff[(ii<<1)+1] = (unsigned int)nGuessedPos; nMaxGuessedPos = (nMaxGuessedPos>=nGuessedPos? nMaxGuessedPos : nGuessedPos); } calcSize -= i; cuTask.hash = ex.GetHash(); cuTask.startIdx = i; cuTask.idxCount = calcSize; cuTask.dimVec = ex.GetPlainDimVec(); cuTask.dimVecSize = ex.GetPlainDimVecSize()/2; cuTask.charSet = ex.GetCharSet(); cuTask.charSetSize = ex.GetCharSetSize(); cuTask.reduceOffset = ex.GetReduceOffset(); cuTask.plainSpaceTotal = ex.GetPlainSpaceTotal(); cuTask.rainbowChainLen = nMaxGuessedPos; cuTask.kernChainSize = cudaChainSize; cuTask.targetHash = t_pHash; calcSize = rcuda::CheckAlarmOnCUDA(&cuTask, calcBuff); if(calcSize > 0 && calcSize == cuTask.idxCount) { for(ii = 0; ii < calcSize; ii++) { if(calcBuff[(ii<<1)|1] >= (1ull<<63)) { CChainWalkContext cwc; cwc.SetIndex(calcBuff[ii<<1]); cwc.IndexToPlain(); cwc.PlainToHash(); t_Hash = cwc.GetHash(); t_Plain = cwc.GetPlain(); t_Binary = cwc.GetBinary(); foundHash = true; break; } else { t_nChainWalkStepDueToFalseAlarm += calcBuff[(ii<<1)|1] + 1; t_nFalseAlarm++; } } i += calcSize; } else { printf("CheckAlarmO() on CUDA failed!\n"); exit(101); } } delete [] calcBuff; } #endif } bool rcrackiThread::FoundHash() { return foundHash; } int rcrackiThread::GetChainWalkStepDueToFalseAlarm() { return t_nChainWalkStepDueToFalseAlarm; } int rcrackiThread::GetnFalseAlarm() { return t_nFalseAlarm; } std::string rcrackiThread::GetHash() { return t_Hash; } std::string rcrackiThread::GetPlain() { return t_Plain; } std::string rcrackiThread::GetBinary() { return t_Binary; } void rcrackiThread::Configure(int gpu) { this->gpu = gpu; } rcracki-mt-0.7.0/rcracki_mt/rcracki_mt.ini0000640000175000017500000000274612043323152020015 0ustar dookiedookie# Default settings for rcracki_mt # Command line arguments override these defaults # Specify default amount of threads Threads=1 # Set a default file to store temporary results. # Set AlwaysStoreResultsToFile=1 or use -o to actually store results. DefaultResultsFile=e:\default_rcracki_results.txt # This option requires DefaultResultsFile to be set to a file #AlwaysStoreResultsToFile=1 # Set some default file locations to search for rainbow tables. # You need to use these in combination with the command line argument -a [algorithm] # Or you can set a default algorithm here with 'DefaultAlgorithm'. # Algorithm is the name you use as specifier after 'DefaultRainbowTablesPath.' # You can specify multiple lines per algorithm, one path/directory per line. # Any locations you specify on the command line will be added to the list as well. # For Windows users: locations in this file with a different case # as on the command line are treated as separate locations (run through twice) #DefaultRainbowTablePath.MD5=X:\RTI\MD5 #DefaultRainbowTablePath.NTLM=X:\RTI\NTLM\ntlm_loweralpha-space#1-9_* # This option requires at least one 'DefaultRainbowTablePath.[algorithm]' to be set #DefaultAlgorithm=MD5 # Always show debugging infomation (command line option -v) # AlwaysDebug=1 # Always keep precalculation files after cracking, don't remove them. # These files are saved by session name. So you can store precalculations over multiple jobs. #AlwaysKeepPrecalcFiles=1rcracki-mt-0.7.0/rcracki_mt/LICENSE.txt0000640000175000017500000002071312043323152017013 0ustar dookiedookieThis notice applies to all source code within the freerainbowtables project and may not necessarily apply to specific applications. It is included as a catch-all and it is up to any users of this code to confirm licensing for individual applications which may use only a subset of code mentioned here. All source code and drived binaries fall primarily under the GNU GPL version 2 license, as found in COPYING. The clause, "either version 2 of the License, or (at your option) any later version" also applies to most source code and dervied binaries. Known exceptions for GPL licensed code include at least: Public.h (portions) Public.cpp (portions) The above referenced files have small bits of code that is from nmap and explicitly they do not allow any later versions of the license. You will find that code enclosed with a note "XXX nmap is GPL2". Files that are not released under the GPL include at least: des.h des_enc.c des_local.h des_setkey.c ecb_enc.c inttypes.h (C99 standard implementation that is not part of VC++) libeay32.dll libeay32.lib podd.h pthreadGC2.dll sk.h spr.h inttypes.h (used extensively throughout the project where VC++ windows builds are created) falls under the following licensing terms: // ISO C9x compliant inttypes.h for Microsoft Visual Studio // Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124 // // Copyright (c) 2006 Alexander Chemeris // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: // // 1. Redistributions of source code must retain the above copyright notice, // this list of conditions and the following disclaimer. // // 2. Redistributions in binary form must reproduce the above copyright // notice, this list of conditions and the following disclaimer in the // documentation and/or other materials provided with the distribution. // // 3. The name of the author may be used to endorse or promote products // derived from this software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED // WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO // EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; // OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, // WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF // ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // /////////////////////////////////////////////////////////////////////////////// These files are from OpenSSL implementations: des.h des_enc.c des_local.h des_setkey.c ecb_enc.c libeay32.dll libeay32.lib podd.h pthreadGC2.dll sk.h spr.h The license for the above files is: The OpenSSL toolkit stays under a dual license, i.e. both the conditions of the OpenSSL License and the original SSLeay license apply to the toolkit. See below for the actual license texts. Actually both licenses are BSD-style Open Source licenses. In case of any license issues related to OpenSSL please contact openssl-core@openssl.org. OpenSSL License --------------- /* ==================================================================== * Copyright (c) 1998-2011 The OpenSSL Project. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in * the documentation and/or other materials provided with the * distribution. * * 3. All advertising materials mentioning features or use of this * software must display the following acknowledgment: * "This product includes software developed by the OpenSSL Project * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" * * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to * endorse or promote products derived from this software without * prior written permission. For written permission, please contact * openssl-core@openssl.org. * * 5. Products derived from this software may not be called "OpenSSL" * nor may "OpenSSL" appear in their names without prior written * permission of the OpenSSL Project. * * 6. Redistributions of any form whatsoever must retain the following * acknowledgment: * "This product includes software developed by the OpenSSL Project * for use in the OpenSSL Toolkit (http://www.openssl.org/)" * * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED * OF THE POSSIBILITY OF SUCH DAMAGE. * ==================================================================== * * This product includes cryptographic software written by Eric Young * (eay@cryptsoft.com). This product includes software written by Tim * Hudson (tjh@cryptsoft.com). * */ Original SSLeay License ----------------------- /* Copyright (C) 1995-1996 Eric Young (eay@mincom.oz.au) * All rights reserved. * * This file is part of an SSL implementation written * by Eric Young (eay@mincom.oz.au). * The implementation was written so as to conform with Netscapes SSL * specification. This library and applications are * FREE FOR COMMERCIAL AND NON-COMMERCIAL USE * as long as the following conditions are aheared to. * * Copyright remains Eric Young's, and as such any Copyright notices in * the code are not to be removed. If this code is used in a product, * Eric Young should be given attribution as the author of the parts used. * This can be in the form of a textual message at program startup or * in documentation (online or textual) provided with the package. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by Eric Young (eay@mincom.oz.au) * * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * The licence and distribution terms for any publically available version or * derivative of this code cannot be changed. i.e. this code cannot simply be * copied and put under another distribution licence * [including the GNU Public Licence.] */ rcracki-mt-0.7.0/rcracki_mt/Makefile0000640000175000017500000002070312043323152016627 0ustar dookiedookie# rcracki_mt is a multithreaded implementation and fork of the original # RainbowCrack # # Copyright Martin Westergaard Jørgensen # Copyright 2009, 2010 Daniël Niggebrugge # Copyright 2009, 2010, 2011, 2012 James Nobis # # This file is part of rcracki_mt. # # rcracki_mt is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 2 of the License, or # (at your option) any later version. # # rcracki_mt is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with rcracki_mt. If not, see . SHELL = /bin/sh BIN = $(DESTDIR)/usr/bin CC = g++ # -mtune=native doesn't work on NetBSD 5.1 with gcc 4.1.3 and make (fine with gmake) # -mtune=native doesn't work on OSX either # add -mtune=native to OPTIMIZATION for better performance (if it works) OPTIMIZATION = -O3 INCLUDES = -I. CFLAGS = -Wall -ansi $(INCLUDES) $(OPTIMIZATION) -c $(DEBUG) LFLAGS = -Wall -ansi $(INCLUDES) $(OPTIMIZATION) $(DEBUG) # doesn't play well with some distros # LFLAGS += -filt LIBS = -L/lib -L/usr/lib -lcrypto -lpthread OBJS = BaseRTReader.o ChainWalkContext.o ChainWalkSet.o CrackEngine.o \ fast_md4.o fast_md5.o HashAlgorithm.o HashRoutine.o HashSet.o keyspace.o \ lm2ntlm.o MemoryPool.o Public.o RainbowCrack.o rcrackiThread.o RTReader.o \ RTIReader.o RTI2Reader.o COMMON_API_PATH = . CUDA_SHARED_PATH = ../../boinc_software/boinc_client_apps/distrrtgen_cuda #sha1.o WARNALL = -Wextra -Wunused-macros -Wunsafe-loop-optimizations -Wundef -Woverlength-strings -Wdisabled-optimization -Wformat-extra-args -Wformat-security -Winline OSNAME = $(shell uname -s) # apparently --strip-debug works on FreeBSD, Linux, NetBSD, OpenBSD, and NetBSD # but not on OSX which only takes the short name -S # OpenSolaris effectively uses -x # Oh lets just forget this until we have autoconf #STRIP = $(shell which strip) -S #LIBS_Darwin = #LIBS_FreeBSD = #LIBS_Linux = LIBS_NetBSD = -ldes #LIBS_OpenBSD = #LIBS_SunOS = LIBS += ${LIBS_$(OSNAME)} RELEASE_DIR = rcracki_mt_0.7.0_src #all: rcracki_mt strip all: rcracki_mt gui: CFLAGS += -DGUI=1 gui: CFLAGS += -I../rcracki_mt-gui/gui gui: CFLAGS += $(shell pkg-config --cflags gtk+-2.0) gui: LFLAGS += $(shell pkg-config --libs gtk+-2.0) gui: $(OBJS) rcracki_mt: $(OBJS) $(CC) $(LFLAGS) $(OBJS) $(LIBS) -o rcracki_mt clean: rm -f core *.o *.gcno *.gcda *.gcov rcracki_mt rcracki.session \ rcracki.progress rcracki.precalc.0 rcracki.precalc.0.index debug: DEBUG += -DDEBUG -g debug: all debugall: DEBUG += -DDEBUG -g $(WARNALL) debugall: all dumpasmall: DEBUG += -S -fverbose-asm dumpasmall: all dumpasmprofileuseall: DEBUG += -S -fverbose-asm dumpasmprofileuseall: profileuseall debugprofileuseall: DEBUG += -fprofile-use debugprofileuseall: debugall m32: DEBUG += -m32 m32: all m32debug: DEBUG += -m32 m32debug: debug m32debugall: DEBUG += -m32 m32debugall: debugall m32dumpasmall: DEBUG += -m32 m32dumpasmall: dumpasmall m32dumpasmprofileuseall: DEBUG += -S -fverbose-asm -m32 m32dumpasmprofileuseall: profileuseall m32profilegenall: DEBUG += -m32 m32profilegenall: profilegenall m32profileuseall: DEBUG += -m32 m32profileuseall: profileuseall profilegenall: DEBUG += -fprofile-generate $(WARNALL) profilegenall: all profileuseall: DEBUG += -fprofile-use $(WARNALL) profileuseall: rcracki_mt gcovall: DEBUG += -DDEBUG -g -fprofile-arcs -ftest-coverage gcovall: rcracki_mt gprofall: DEBUG += -DDEBUG -g -pg gprofall: rcracki_mt install: install -d $(BIN) install --group=root --owner=root --mode=755 rcracki_mt $(BIN) release: clean mkdir $(RELEASE_DIR) cp $(COMMON_API_PATH)/architecture.h $(COMMON_API_PATH)/BaseRTReader.* \ $(COMMON_API_PATH)/ChainWalkContext.* \ $(COMMON_API_PATH)/ChainWalkSet.* CrackEngine.* \ $(COMMON_API_PATH)/fast_md5.* $(COMMON_API_PATH)/keyspace.* \ $(COMMON_API_PATH)/HashAlgorithm.* $(COMMON_API_PATH)/HashRoutine.* \ HashSet.* $(COMMON_API_PATH)/global.h \ lm2ntlm.* $(COMMON_API_PATH)/fast_md4.* $(COMMON_API_PATH)/MemoryPool.* \ $(COMMON_API_PATH)/Public.* RainbowCrack.* $(CUDA_SHARED_PATH)/rcuda.h \ $(CUDA_SHARED_PATH)/rcuda.cu $(CUDA_SHARED_PATH)/rcuda_ext.cpp \ $(CUDA_SHARED_PATH)/rcuda_ext.h $(CUDA_SHARED_PATH)/rcuda_lm.inc \ $(CUDA_SHARED_PATH)/rcuda_md4.inc $(CUDA_SHARED_PATH)/rcuda_md5.inc \ $(CUDA_SHARED_PATH)/rcuda_ntlm.inc $(CUDA_SHARED_PATH)/rcuda_sha1.inc \ rcrackiThread.* $(COMMON_API_PATH)/RTI2Common.* \ $(COMMON_API_PATH)/RT*Reader.* sha1.* ChangeLog.txt charset.txt COPYING \ INSTALLING.txt README.txt TODO rcracki_mt.ini ../../LICENSE.txt \ $(RELEASE_DIR)/ cat Makefile | sed 's/..\/..\/common\/rt_api/./' > $(RELEASE_DIR)/Makefile cat Makefile.cuda | sed 's/..\/..\/common\/rt_api/./' | \ sed 's/..\/..\/boinc_software\/boinc_client_apps\/distrrtgen_cuda/./' \ > $(RELEASE_DIR)/Makefile.cuda rebuild: clean all static: DEBUG += -static -static-libgcc static: all #strip: # $(STRIP) rcracki_mt uninstall: rm -f $(BIN)/rcracki_mt BaseRTReader.o: $(COMMON_API_PATH)/BaseRTReader.h \ $(COMMON_API_PATH)/BaseRTReader.cpp $(CC) $(CFLAGS) $(COMMON_API_PATH)/BaseRTReader.cpp ChainWalkContext.o: $(COMMON_API_PATH)/ChainWalkContext.h \ $(COMMON_API_PATH)/ChainWalkContext.cpp $(COMMON_API_PATH)/HashRoutine.h \ $(COMMON_API_PATH)/Public.h $(CC) $(CFLAGS) $(COMMON_API_PATH)/ChainWalkContext.cpp ChainWalkSet.o: $(COMMON_API_PATH)/Public.h $(COMMON_API_PATH)/ChainWalkSet.h \ $(COMMON_API_PATH)/ChainWalkSet.cpp $(CC) $(CFLAGS) $(COMMON_API_PATH)/ChainWalkSet.cpp CrackEngine.o: $(COMMON_API_PATH)/Public.h HashSet.h \ $(COMMON_API_PATH)/ChainWalkContext.h $(COMMON_API_PATH)/MemoryPool.h \ $(COMMON_API_PATH)/ChainWalkSet.h rcrackiThread.h \ $(COMMON_API_PATH)/RTReader.h $(COMMON_API_PATH)/RTIReader.h \ $(COMMON_API_PATH)/RTI2Reader.h CrackEngine.h CrackEngine.cpp $(CC) $(CFLAGS) CrackEngine.cpp fast_md5.o: $(COMMON_API_PATH)/fast_md5.h $(COMMON_API_PATH)/fast_md5.cpp \ $(COMMON_API_PATH)/global.h $(CC) $(CFLAGS) $(COMMON_API_PATH)/fast_md5.cpp #HashAlgorithm.o: $(COMMON_API_PATH)/HashAlgorithm.h HashAlgorithm.cpp \ $(COMMON_API_PATH)/Public.h $(COMMON_API_PATH)/fast_md5.h \ $(COMMON_API_PATH)/fast_md4.h sha1.h HashAlgorithm.o: $(COMMON_API_PATH)/HashAlgorithm.h \ $(COMMON_API_PATH)/HashAlgorithm.cpp $(COMMON_API_PATH)/Public.h \ $(COMMON_API_PATH)/fast_md5.h $(COMMON_API_PATH)/fast_md4.h $(CC) $(CFLAGS) $(COMMON_API_PATH)/HashAlgorithm.cpp HashRoutine.o: $(COMMON_API_PATH)/HashRoutine.h \ $(COMMON_API_PATH)/HashRoutine.cpp $(COMMON_API_PATH)/global.h \ $(COMMON_API_PATH)/HashAlgorithm.h $(CC) $(CFLAGS) $(COMMON_API_PATH)/HashRoutine.cpp HashSet.o: HashSet.h HashSet.cpp $(COMMON_API_PATH)/Public.h $(CC) $(CFLAGS) HashSet.cpp keyspace.o: $(COMMON_API_PATH)/keyspace.h $(COMMON_API_PATH)/global.h \ $(COMMON_API_PATH)/architecture.h $(CC) $(CFLAGS) $(COMMON_API_PATH)/keyspace.cpp lm2ntlm.o: lm2ntlm.h lm2ntlm.cpp $(COMMON_API_PATH)/Public.h \ $(COMMON_API_PATH)/fast_md4.h $(CC) $(CFLAGS) lm2ntlm.cpp fast_md4.o: $(COMMON_API_PATH)/fast_md4.h $(COMMON_API_PATH)/fast_md4.cpp \ $(COMMON_API_PATH)/global.h $(CC) $(CFLAGS) $(COMMON_API_PATH)/fast_md4.cpp MemoryPool.o: $(COMMON_API_PATH)/MemoryPool.h \ $(COMMON_API_PATH)/MemoryPool.cpp $(COMMON_API_PATH)/Public.h \ $(COMMON_API_PATH)/global.h $(CC) $(CFLAGS) $(COMMON_API_PATH)/MemoryPool.cpp Public.o: $(COMMON_API_PATH)/Public.h $(COMMON_API_PATH)/Public.cpp \ $(COMMON_API_PATH)/global.h $(CC) $(CFLAGS) $(COMMON_API_PATH)/Public.cpp RainbowCrack.o: RainbowCrack.h RainbowCrack.cpp CrackEngine.h lm2ntlm.h $(CC) $(CFLAGS) RainbowCrack.cpp rcrackiThread.o: rcrackiThread.h rcrackiThread.cpp \ $(COMMON_API_PATH)/ChainWalkContext.h $(COMMON_API_PATH)/Public.h HashSet.h $(CC) $(CFLAGS) rcrackiThread.cpp RTReader.o: $(COMMON_API_PATH)/RTReader.h $(COMMON_API_PATH)/RTReader.cpp $(CC) $(CFLAGS) $(COMMON_API_PATH)/RTReader.cpp RTIReader.o: $(COMMON_API_PATH)/RTIReader.h $(COMMON_API_PATH)/RTIReader.cpp $(CC) $(CFLAGS) $(COMMON_API_PATH)/RTIReader.cpp RTI2Reader.o: $(COMMON_API_PATH)/RTI2Reader.h \ $(COMMON_API_PATH)/RTI2Reader.cpp $(COMMON_API_PATH)/BaseRTReader.h $(CC) $(CFLAGS) $(COMMON_API_PATH)/RTI2Reader.cpp #sha1.o: sha1.h sha1.cpp $(COMMON_API_PATH)/global.h # $(CC) $(CFLAGS) sha1.cpp rcracki-mt-0.7.0/rcracki_mt/HashRoutine.h0000640000175000017500000000365312043323152017576 0ustar dookiedookie/* * freerainbowtables is a project for generating, distributing, and using * perfect rainbow tables * * Copyright (C) Zhu Shuanglei * Copyright Martin Westergaard Jørgensen * Copyright 2009, 2010 Daniël Niggebrugge * Copyright 2009, 2010, 2011, 2012 James Nobis * Copyright 2011 Janosch Rux * * This file is part of freerainbowtables. * * freerainbowtables is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * freerainbowtables is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with freerainbowtables. If not, see . */ #ifndef _HASHROUTINE_H #define _HASHROUTINE_H #include "global.h" #include #include typedef void (*HASHROUTINE)(unsigned char* pPlain, int nPlainLen, unsigned char* pHash); class CHashRoutine { public: CHashRoutine(); virtual ~CHashRoutine(); //XXX change both to private again and make function for it std::vector vHashRoutineName; //-1 means unlimited std::vector vMaxPlainLen; private: std::vector vHashRoutine; std::vector vHashLen; void AddHashRoutine( std::string sHashRoutineName, HASHROUTINE pHashRoutine, int nHashLen, int nMaxPlainLen); public: std::string GetAllHashRoutineName(); //std::vector GetAllHashRoutineNameV(); void GetHashRoutine( std::string sHashRoutineName, HASHROUTINE& pHashRoutine, int& nHashLen ); }; #endif rcracki-mt-0.7.0/rcracki_mt/rcuda_lm.inc0000640000175000017500000005056112043323152017455 0ustar dookiedookie// freerainbowtables is a project for generating, distributing, and using // perfect rainbow tables // // Copyright 2010, 2011 Jan Kyska // Copyright 2010 Martin Westergaard Jørgensen // Copyright 2010, 2011, 2012 James Nobis // // This file is part of freerainbowtables. // // freerainbowtables is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 2 of the License, or // (at your option) any later version. // // freerainbowtables is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with freerainbowtables. If not, see . namespace RC_LM { #define ITERATIONS 16 __device__ __constant__ int shifts2[16] = { 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0 }; __device__ __constant__ unsigned int des_skb[8][64] = { { /* for C bits (numbered as per FIPS 46) 1 2 3 4 5 6 */ 0x00000000L,0x00000010L,0x20000000L,0x20000010L, 0x00010000L,0x00010010L,0x20010000L,0x20010010L, 0x00000800L,0x00000810L,0x20000800L,0x20000810L, 0x00010800L,0x00010810L,0x20010800L,0x20010810L, 0x00000020L,0x00000030L,0x20000020L,0x20000030L, 0x00010020L,0x00010030L,0x20010020L,0x20010030L, 0x00000820L,0x00000830L,0x20000820L,0x20000830L, 0x00010820L,0x00010830L,0x20010820L,0x20010830L, 0x00080000L,0x00080010L,0x20080000L,0x20080010L, 0x00090000L,0x00090010L,0x20090000L,0x20090010L, 0x00080800L,0x00080810L,0x20080800L,0x20080810L, 0x00090800L,0x00090810L,0x20090800L,0x20090810L, 0x00080020L,0x00080030L,0x20080020L,0x20080030L, 0x00090020L,0x00090030L,0x20090020L,0x20090030L, 0x00080820L,0x00080830L,0x20080820L,0x20080830L, 0x00090820L,0x00090830L,0x20090820L,0x20090830L, },{ /* for C bits (numbered as per FIPS 46) 7 8 10 11 12 13 */ 0x00000000L,0x02000000L,0x00002000L,0x02002000L, 0x00200000L,0x02200000L,0x00202000L,0x02202000L, 0x00000004L,0x02000004L,0x00002004L,0x02002004L, 0x00200004L,0x02200004L,0x00202004L,0x02202004L, 0x00000400L,0x02000400L,0x00002400L,0x02002400L, 0x00200400L,0x02200400L,0x00202400L,0x02202400L, 0x00000404L,0x02000404L,0x00002404L,0x02002404L, 0x00200404L,0x02200404L,0x00202404L,0x02202404L, 0x10000000L,0x12000000L,0x10002000L,0x12002000L, 0x10200000L,0x12200000L,0x10202000L,0x12202000L, 0x10000004L,0x12000004L,0x10002004L,0x12002004L, 0x10200004L,0x12200004L,0x10202004L,0x12202004L, 0x10000400L,0x12000400L,0x10002400L,0x12002400L, 0x10200400L,0x12200400L,0x10202400L,0x12202400L, 0x10000404L,0x12000404L,0x10002404L,0x12002404L, 0x10200404L,0x12200404L,0x10202404L,0x12202404L, },{ /* for C bits (numbered as per FIPS 46) 14 15 16 17 19 20 */ 0x00000000L,0x00000001L,0x00040000L,0x00040001L, 0x01000000L,0x01000001L,0x01040000L,0x01040001L, 0x00000002L,0x00000003L,0x00040002L,0x00040003L, 0x01000002L,0x01000003L,0x01040002L,0x01040003L, 0x00000200L,0x00000201L,0x00040200L,0x00040201L, 0x01000200L,0x01000201L,0x01040200L,0x01040201L, 0x00000202L,0x00000203L,0x00040202L,0x00040203L, 0x01000202L,0x01000203L,0x01040202L,0x01040203L, 0x08000000L,0x08000001L,0x08040000L,0x08040001L, 0x09000000L,0x09000001L,0x09040000L,0x09040001L, 0x08000002L,0x08000003L,0x08040002L,0x08040003L, 0x09000002L,0x09000003L,0x09040002L,0x09040003L, 0x08000200L,0x08000201L,0x08040200L,0x08040201L, 0x09000200L,0x09000201L,0x09040200L,0x09040201L, 0x08000202L,0x08000203L,0x08040202L,0x08040203L, 0x09000202L,0x09000203L,0x09040202L,0x09040203L, },{ /* for C bits (numbered as per FIPS 46) 21 23 24 26 27 28 */ 0x00000000L,0x00100000L,0x00000100L,0x00100100L, 0x00000008L,0x00100008L,0x00000108L,0x00100108L, 0x00001000L,0x00101000L,0x00001100L,0x00101100L, 0x00001008L,0x00101008L,0x00001108L,0x00101108L, 0x04000000L,0x04100000L,0x04000100L,0x04100100L, 0x04000008L,0x04100008L,0x04000108L,0x04100108L, 0x04001000L,0x04101000L,0x04001100L,0x04101100L, 0x04001008L,0x04101008L,0x04001108L,0x04101108L, 0x00020000L,0x00120000L,0x00020100L,0x00120100L, 0x00020008L,0x00120008L,0x00020108L,0x00120108L, 0x00021000L,0x00121000L,0x00021100L,0x00121100L, 0x00021008L,0x00121008L,0x00021108L,0x00121108L, 0x04020000L,0x04120000L,0x04020100L,0x04120100L, 0x04020008L,0x04120008L,0x04020108L,0x04120108L, 0x04021000L,0x04121000L,0x04021100L,0x04121100L, 0x04021008L,0x04121008L,0x04021108L,0x04121108L, },{ /* for D bits (numbered as per FIPS 46) 1 2 3 4 5 6 */ 0x00000000L,0x10000000L,0x00010000L,0x10010000L, 0x00000004L,0x10000004L,0x00010004L,0x10010004L, 0x20000000L,0x30000000L,0x20010000L,0x30010000L, 0x20000004L,0x30000004L,0x20010004L,0x30010004L, 0x00100000L,0x10100000L,0x00110000L,0x10110000L, 0x00100004L,0x10100004L,0x00110004L,0x10110004L, 0x20100000L,0x30100000L,0x20110000L,0x30110000L, 0x20100004L,0x30100004L,0x20110004L,0x30110004L, 0x00001000L,0x10001000L,0x00011000L,0x10011000L, 0x00001004L,0x10001004L,0x00011004L,0x10011004L, 0x20001000L,0x30001000L,0x20011000L,0x30011000L, 0x20001004L,0x30001004L,0x20011004L,0x30011004L, 0x00101000L,0x10101000L,0x00111000L,0x10111000L, 0x00101004L,0x10101004L,0x00111004L,0x10111004L, 0x20101000L,0x30101000L,0x20111000L,0x30111000L, 0x20101004L,0x30101004L,0x20111004L,0x30111004L, },{ /* for D bits (numbered as per FIPS 46) 8 9 11 12 13 14 */ 0x00000000L,0x08000000L,0x00000008L,0x08000008L, 0x00000400L,0x08000400L,0x00000408L,0x08000408L, 0x00020000L,0x08020000L,0x00020008L,0x08020008L, 0x00020400L,0x08020400L,0x00020408L,0x08020408L, 0x00000001L,0x08000001L,0x00000009L,0x08000009L, 0x00000401L,0x08000401L,0x00000409L,0x08000409L, 0x00020001L,0x08020001L,0x00020009L,0x08020009L, 0x00020401L,0x08020401L,0x00020409L,0x08020409L, 0x02000000L,0x0A000000L,0x02000008L,0x0A000008L, 0x02000400L,0x0A000400L,0x02000408L,0x0A000408L, 0x02020000L,0x0A020000L,0x02020008L,0x0A020008L, 0x02020400L,0x0A020400L,0x02020408L,0x0A020408L, 0x02000001L,0x0A000001L,0x02000009L,0x0A000009L, 0x02000401L,0x0A000401L,0x02000409L,0x0A000409L, 0x02020001L,0x0A020001L,0x02020009L,0x0A020009L, 0x02020401L,0x0A020401L,0x02020409L,0x0A020409L, },{ /* for D bits (numbered as per FIPS 46) 16 17 18 19 20 21 */ 0x00000000L,0x00000100L,0x00080000L,0x00080100L, 0x01000000L,0x01000100L,0x01080000L,0x01080100L, 0x00000010L,0x00000110L,0x00080010L,0x00080110L, 0x01000010L,0x01000110L,0x01080010L,0x01080110L, 0x00200000L,0x00200100L,0x00280000L,0x00280100L, 0x01200000L,0x01200100L,0x01280000L,0x01280100L, 0x00200010L,0x00200110L,0x00280010L,0x00280110L, 0x01200010L,0x01200110L,0x01280010L,0x01280110L, 0x00000200L,0x00000300L,0x00080200L,0x00080300L, 0x01000200L,0x01000300L,0x01080200L,0x01080300L, 0x00000210L,0x00000310L,0x00080210L,0x00080310L, 0x01000210L,0x01000310L,0x01080210L,0x01080310L, 0x00200200L,0x00200300L,0x00280200L,0x00280300L, 0x01200200L,0x01200300L,0x01280200L,0x01280300L, 0x00200210L,0x00200310L,0x00280210L,0x00280310L, 0x01200210L,0x01200310L,0x01280210L,0x01280310L, },{ /* for D bits (numbered as per FIPS 46) 22 23 24 25 27 28 */ 0x00000000L,0x04000000L,0x00040000L,0x04040000L, 0x00000002L,0x04000002L,0x00040002L,0x04040002L, 0x00002000L,0x04002000L,0x00042000L,0x04042000L, 0x00002002L,0x04002002L,0x00042002L,0x04042002L, 0x00000020L,0x04000020L,0x00040020L,0x04040020L, 0x00000022L,0x04000022L,0x00040022L,0x04040022L, 0x00002020L,0x04002020L,0x00042020L,0x04042020L, 0x00002022L,0x04002022L,0x00042022L,0x04042022L, 0x00000800L,0x04000800L,0x00040800L,0x04040800L, 0x00000802L,0x04000802L,0x00040802L,0x04040802L, 0x00002800L,0x04002800L,0x00042800L,0x04042800L, 0x00002802L,0x04002802L,0x00042802L,0x04042802L, 0x00000820L,0x04000820L,0x00040820L,0x04040820L, 0x00000822L,0x04000822L,0x00040822L,0x04040822L, 0x00002820L,0x04002820L,0x00042820L,0x04042820L, 0x00002822L,0x04002822L,0x00042822L,0x04042822L, }}; __device__ __constant__ unsigned int des_SPtrans[8][64] = { { /* nibble 0 */ 0x02080800L, 0x00080000L, 0x02000002L, 0x02080802L, 0x02000000L, 0x00080802L, 0x00080002L, 0x02000002L, 0x00080802L, 0x02080800L, 0x02080000L, 0x00000802L, 0x02000802L, 0x02000000L, 0x00000000L, 0x00080002L, 0x00080000L, 0x00000002L, 0x02000800L, 0x00080800L, 0x02080802L, 0x02080000L, 0x00000802L, 0x02000800L, 0x00000002L, 0x00000800L, 0x00080800L, 0x02080002L, 0x00000800L, 0x02000802L, 0x02080002L, 0x00000000L, 0x00000000L, 0x02080802L, 0x02000800L, 0x00080002L, 0x02080800L, 0x00080000L, 0x00000802L, 0x02000800L, 0x02080002L, 0x00000800L, 0x00080800L, 0x02000002L, 0x00080802L, 0x00000002L, 0x02000002L, 0x02080000L, 0x02080802L, 0x00080800L, 0x02080000L, 0x02000802L, 0x02000000L, 0x00000802L, 0x00080002L, 0x00000000L, 0x00080000L, 0x02000000L, 0x02000802L, 0x02080800L, 0x00000002L, 0x02080002L, 0x00000800L, 0x00080802L, },{ /* nibble 1 */ 0x40108010L, 0x00000000L, 0x00108000L, 0x40100000L, 0x40000010L, 0x00008010L, 0x40008000L, 0x00108000L, 0x00008000L, 0x40100010L, 0x00000010L, 0x40008000L, 0x00100010L, 0x40108000L, 0x40100000L, 0x00000010L, 0x00100000L, 0x40008010L, 0x40100010L, 0x00008000L, 0x00108010L, 0x40000000L, 0x00000000L, 0x00100010L, 0x40008010L, 0x00108010L, 0x40108000L, 0x40000010L, 0x40000000L, 0x00100000L, 0x00008010L, 0x40108010L, 0x00100010L, 0x40108000L, 0x40008000L, 0x00108010L, 0x40108010L, 0x00100010L, 0x40000010L, 0x00000000L, 0x40000000L, 0x00008010L, 0x00100000L, 0x40100010L, 0x00008000L, 0x40000000L, 0x00108010L, 0x40008010L, 0x40108000L, 0x00008000L, 0x00000000L, 0x40000010L, 0x00000010L, 0x40108010L, 0x00108000L, 0x40100000L, 0x40100010L, 0x00100000L, 0x00008010L, 0x40008000L, 0x40008010L, 0x00000010L, 0x40100000L, 0x00108000L, },{ /* nibble 2 */ 0x04000001L, 0x04040100L, 0x00000100L, 0x04000101L, 0x00040001L, 0x04000000L, 0x04000101L, 0x00040100L, 0x04000100L, 0x00040000L, 0x04040000L, 0x00000001L, 0x04040101L, 0x00000101L, 0x00000001L, 0x04040001L, 0x00000000L, 0x00040001L, 0x04040100L, 0x00000100L, 0x00000101L, 0x04040101L, 0x00040000L, 0x04000001L, 0x04040001L, 0x04000100L, 0x00040101L, 0x04040000L, 0x00040100L, 0x00000000L, 0x04000000L, 0x00040101L, 0x04040100L, 0x00000100L, 0x00000001L, 0x00040000L, 0x00000101L, 0x00040001L, 0x04040000L, 0x04000101L, 0x00000000L, 0x04040100L, 0x00040100L, 0x04040001L, 0x00040001L, 0x04000000L, 0x04040101L, 0x00000001L, 0x00040101L, 0x04000001L, 0x04000000L, 0x04040101L, 0x00040000L, 0x04000100L, 0x04000101L, 0x00040100L, 0x04000100L, 0x00000000L, 0x04040001L, 0x00000101L, 0x04000001L, 0x00040101L, 0x00000100L, 0x04040000L, },{ /* nibble 3 */ 0x00401008L, 0x10001000L, 0x00000008L, 0x10401008L, 0x00000000L, 0x10400000L, 0x10001008L, 0x00400008L, 0x10401000L, 0x10000008L, 0x10000000L, 0x00001008L, 0x10000008L, 0x00401008L, 0x00400000L, 0x10000000L, 0x10400008L, 0x00401000L, 0x00001000L, 0x00000008L, 0x00401000L, 0x10001008L, 0x10400000L, 0x00001000L, 0x00001008L, 0x00000000L, 0x00400008L, 0x10401000L, 0x10001000L, 0x10400008L, 0x10401008L, 0x00400000L, 0x10400008L, 0x00001008L, 0x00400000L, 0x10000008L, 0x00401000L, 0x10001000L, 0x00000008L, 0x10400000L, 0x10001008L, 0x00000000L, 0x00001000L, 0x00400008L, 0x00000000L, 0x10400008L, 0x10401000L, 0x00001000L, 0x10000000L, 0x10401008L, 0x00401008L, 0x00400000L, 0x10401008L, 0x00000008L, 0x10001000L, 0x00401008L, 0x00400008L, 0x00401000L, 0x10400000L, 0x10001008L, 0x00001008L, 0x10000000L, 0x10000008L, 0x10401000L, },{ /* nibble 4 */ 0x08000000L, 0x00010000L, 0x00000400L, 0x08010420L, 0x08010020L, 0x08000400L, 0x00010420L, 0x08010000L, 0x00010000L, 0x00000020L, 0x08000020L, 0x00010400L, 0x08000420L, 0x08010020L, 0x08010400L, 0x00000000L, 0x00010400L, 0x08000000L, 0x00010020L, 0x00000420L, 0x08000400L, 0x00010420L, 0x00000000L, 0x08000020L, 0x00000020L, 0x08000420L, 0x08010420L, 0x00010020L, 0x08010000L, 0x00000400L, 0x00000420L, 0x08010400L, 0x08010400L, 0x08000420L, 0x00010020L, 0x08010000L, 0x00010000L, 0x00000020L, 0x08000020L, 0x08000400L, 0x08000000L, 0x00010400L, 0x08010420L, 0x00000000L, 0x00010420L, 0x08000000L, 0x00000400L, 0x00010020L, 0x08000420L, 0x00000400L, 0x00000000L, 0x08010420L, 0x08010020L, 0x08010400L, 0x00000420L, 0x00010000L, 0x00010400L, 0x08010020L, 0x08000400L, 0x00000420L, 0x00000020L, 0x00010420L, 0x08010000L, 0x08000020L, },{ /* nibble 5 */ 0x80000040L, 0x00200040L, 0x00000000L, 0x80202000L, 0x00200040L, 0x00002000L, 0x80002040L, 0x00200000L, 0x00002040L, 0x80202040L, 0x00202000L, 0x80000000L, 0x80002000L, 0x80000040L, 0x80200000L, 0x00202040L, 0x00200000L, 0x80002040L, 0x80200040L, 0x00000000L, 0x00002000L, 0x00000040L, 0x80202000L, 0x80200040L, 0x80202040L, 0x80200000L, 0x80000000L, 0x00002040L, 0x00000040L, 0x00202000L, 0x00202040L, 0x80002000L, 0x00002040L, 0x80000000L, 0x80002000L, 0x00202040L, 0x80202000L, 0x00200040L, 0x00000000L, 0x80002000L, 0x80000000L, 0x00002000L, 0x80200040L, 0x00200000L, 0x00200040L, 0x80202040L, 0x00202000L, 0x00000040L, 0x80202040L, 0x00202000L, 0x00200000L, 0x80002040L, 0x80000040L, 0x80200000L, 0x00202040L, 0x00000000L, 0x00002000L, 0x80000040L, 0x80002040L, 0x80202000L, 0x80200000L, 0x00002040L, 0x00000040L, 0x80200040L, },{ /* nibble 6 */ 0x00004000L, 0x00000200L, 0x01000200L, 0x01000004L, 0x01004204L, 0x00004004L, 0x00004200L, 0x00000000L, 0x01000000L, 0x01000204L, 0x00000204L, 0x01004000L, 0x00000004L, 0x01004200L, 0x01004000L, 0x00000204L, 0x01000204L, 0x00004000L, 0x00004004L, 0x01004204L, 0x00000000L, 0x01000200L, 0x01000004L, 0x00004200L, 0x01004004L, 0x00004204L, 0x01004200L, 0x00000004L, 0x00004204L, 0x01004004L, 0x00000200L, 0x01000000L, 0x00004204L, 0x01004000L, 0x01004004L, 0x00000204L, 0x00004000L, 0x00000200L, 0x01000000L, 0x01004004L, 0x01000204L, 0x00004204L, 0x00004200L, 0x00000000L, 0x00000200L, 0x01000004L, 0x00000004L, 0x01000200L, 0x00000000L, 0x01000204L, 0x01000200L, 0x00004200L, 0x00000204L, 0x00004000L, 0x01004204L, 0x01000000L, 0x01004200L, 0x00000004L, 0x00004004L, 0x01004204L, 0x01000004L, 0x01004200L, 0x01004000L, 0x00004004L, },{ /* nibble 7 */ 0x20800080L, 0x20820000L, 0x00020080L, 0x00000000L, 0x20020000L, 0x00800080L, 0x20800000L, 0x20820080L, 0x00000080L, 0x20000000L, 0x00820000L, 0x00020080L, 0x00820080L, 0x20020080L, 0x20000080L, 0x20800000L, 0x00020000L, 0x00820080L, 0x00800080L, 0x20020000L, 0x20820080L, 0x20000080L, 0x00000000L, 0x00820000L, 0x20000000L, 0x00800000L, 0x20020080L, 0x20800080L, 0x00800000L, 0x00020000L, 0x20820000L, 0x00000080L, 0x00800000L, 0x00020000L, 0x20000080L, 0x20820080L, 0x00020080L, 0x20000000L, 0x00000000L, 0x00820000L, 0x20800080L, 0x20020080L, 0x20020000L, 0x00800080L, 0x20820000L, 0x00000080L, 0x00800080L, 0x20020000L, 0x20820080L, 0x00800000L, 0x20800000L, 0x20000080L, 0x00820000L, 0x00020080L, 0x20020080L, 0x20800000L, 0x00000080L, 0x20820000L, 0x00820080L, 0x00000000L, 0x20000000L, 0x20800080L, 0x00020000L, 0x00820080L, }}; __device__ void PERM_OP(int ia, int ib, int it, unsigned int n, unsigned int m, unsigned int* data) { data[it] =((data[ia] >> n ) ^ data[ib]) & m; data[ib] ^= data[it]; data[ia] ^= data[it] << n; } __device__ void HPERM_OP(int ia, int it, int n, unsigned int m, unsigned int* data) { data[it] = ((data[ia] << (16-n)) ^ data[ia]) & m; data[ia] = data[ia] ^ data[it] ^ (data[it]>>(16-n)); } __device__ void IP(int il, int ir, int it, unsigned int* data) { PERM_OP(ir, il, it, 4, 0x0f0f0f0f, data); PERM_OP(il, ir, it, 16, 0x0000ffff, data); PERM_OP(ir, il, it, 2, 0x33333333, data); PERM_OP(il, ir, it, 8, 0x00ff00ff, data); PERM_OP(ir, il, it, 1, 0x55555555, data); } __device__ void FP(int il, int ir, int it, unsigned int* data) { PERM_OP(il, ir, it, 1, 0x55555555, data); PERM_OP(ir, il, it, 8, 0x00ff00ff, data); PERM_OP(il, ir, it, 2, 0x33333333, data); PERM_OP(ir, il, it, 16, 0x0000ffff, data); PERM_OP(il, ir, it, 4, 0x0f0f0f0f, data); } __device__ unsigned int D_ENCRYPT(unsigned int ll, unsigned int uu, unsigned int tt) { tt = (tt>>4)|(tt<<28); return ll ^ des_SPtrans[0][(uu>>2)&0x3f] ^ des_SPtrans[2][(uu>>10)&0x3f] ^ des_SPtrans[4][(uu>>18)&0x3f] ^ des_SPtrans[6][(uu>>26)&0x3f] ^ des_SPtrans[1][(tt>>2)&0x3f] ^ des_SPtrans[3][(tt>>10)&0x3f] ^ des_SPtrans[5][(tt>>18)&0x3f] ^ des_SPtrans[7][(tt>>26)&0x3f]; } } #define RT_LM_KERNEL(kerName, kerPrologue, kerEpilogue) \ __global__ void kerName(unsigned int chainStart, unsigned int chainStop) { \ unsigned int *hData2, *hData3; \ unsigned int jj, rs, rt; \ \ __shared__ unsigned int shData2[SHIDX(BLOCK_X_SIZE)]; \ __shared__ unsigned int shData3[BLOCK_X_SIZE<<2]; \ hData2 = shData2 + DATAIDX(4, threadIdx.x); \ hData3 = shData3 + DATAIDX(2, threadIdx.x); \ \ kerPrologue; \ \ /* transform to the plain text */ \ for(ii = 0; ii < 8; ii++) \ hData[SHIDX(ii)] = 0; \ \ RTGEN_IDX2PLAIN_BEGIN; \ RTGEN_I2P_LOOP64_BEGIN; \ hData[SHIDX(ii&7)] = cplChrSet[(dimItem.z&255u) + uiDiv]; \ RTGEN_I2P_LOOP64_END; \ \ RTGEN_I2P_LOOP32_BEGIN; \ hData[SHIDX(ii&7)] = cplChrSet[(dimItem.z&255u) + uiDiv]; \ RTGEN_I2P_LOOP32_END; \ RTGEN_IDX2PLAIN_END; \ \ for(jj = 8, ii--; jj < 15; jj++, ii--) \ hData[SHIDX(jj)] = hData[SHIDX(ii&7)]; \ \ /* set key */ \ ii = 255; \ uiVal = ((hData[SHIDX(10)] << 5) | (hData[SHIDX(11)] >> 3))ⅈ \ uiVal = (uiVal<<8) | (((hData[SHIDX(9)] << 6) | (hData[SHIDX(10)] >> 2))&ii); \ uiVal = (uiVal<<8) | (((hData[SHIDX(8)] << 7) | (hData[SHIDX(9)] >> 1))&ii); \ uiVal = (uiVal<<8) | hData[SHIDX(8)]; \ \ uiDiv = (hData[SHIDX(14)] << 1)ⅈ \ uiDiv = (uiDiv<<8) | (((hData[SHIDX(13)] << 2) | (hData[SHIDX(14)] >> 6))&ii); \ uiDiv = (uiDiv<<8) | (((hData[SHIDX(12)] << 3) | (hData[SHIDX(13)] >> 5))&ii); \ uiDiv = (uiDiv<<8) | (((hData[SHIDX(11)] << 4) | (hData[SHIDX(12)] >> 4))&ii); \ \ hData[SHIDX(0)] = uiVal; \ hData[SHIDX(1)] = uiDiv; \ RC_LM::PERM_OP(SHIDX(1), SHIDX(0), SHIDX(2), 4, 0x0f0f0f0f, hData); \ RC_LM::HPERM_OP(SHIDX(0), SHIDX(2), -2, 0xcccc0000, hData); \ RC_LM::HPERM_OP(SHIDX(1), SHIDX(2), -2, 0xcccc0000, hData); \ RC_LM::PERM_OP(SHIDX(1), SHIDX(0), SHIDX(2), 1, 0x55555555, hData); \ RC_LM::PERM_OP(SHIDX(0), SHIDX(1), SHIDX(2), 8, 0x00ff00ff, hData); \ RC_LM::PERM_OP(SHIDX(1), SHIDX(0), SHIDX(2), 1, 0x55555555, hData); \ uiVal = hData[SHIDX(0)]; \ uiDiv = hData[SHIDX(1)]; \ uiDiv = ((uiDiv&0x000000ff)<<16) | (uiDiv&0x0000ff00) | ((uiDiv&0x00ff0000)>>16) | ((uiVal&0xf0000000)>>4); \ uiVal &= 0x0fffffff; \ \ for(ii = 0; ii < ITERATIONS; ii++) { \ if(RC_LM::shifts2[ii]) { \ uiVal = ((uiVal>>2)|(uiVal<<26)); \ uiDiv =((uiDiv>>2)|(uiDiv<<26)); \ } else { \ uiVal = ((uiVal>>1)|(uiVal<<27)); \ uiDiv = ((uiDiv>>1)|(uiDiv<<27)); \ } \ uiVal &= 0x0fffffff; \ uiDiv &= 0x0fffffff; \ \ rs = RC_LM::des_skb[0][uiVal&0x3f] | \ RC_LM::des_skb[1][((uiVal>>6)&0x03)|((uiVal>>7)&0x3c)] | \ RC_LM::des_skb[2][((uiVal>>13)&0x0f)|((uiVal>>14)&0x30)] | \ RC_LM::des_skb[3][((uiVal>>20)&0x01)|((uiVal>>21)&0x06) | \ ((uiVal>>22)&0x38)]; \ rt = RC_LM::des_skb[4][uiDiv&0x3f] | \ RC_LM::des_skb[5][((uiDiv>>7)&0x03)|((uiDiv>>8)&0x3c)] | \ RC_LM::des_skb[6][(uiDiv>>15)&0x3f] | \ RC_LM::des_skb[7][((uiDiv>>21)&0x0f)|((uiDiv>>22)&0x30)]; \ \ /* table contained 0213 4657 */ \ idx = (rt<<16)|(rs&0x0000ffff); \ hData[SHIDX(ii)] = (idx>>30)|(idx<<2); \ idx = (rs>>16)|(rt&0xffff0000); \ hData2[SHIDX(ii)] = (idx>>26)|(idx<<6); \ } \ \ /* encrypt the "magic" data */ \ hData3[SHIDX(0)] = 0x2153474B; \ hData3[SHIDX(1)] = 0x25242340; \ \ RC_LM::IP(SHIDX(0), SHIDX(1), SHIDX(2), hData3); \ uiVal = hData3[SHIDX(0)]; \ uiVal = ((uiVal>>29)|(uiVal<<3)); \ uiDiv = hData3[SHIDX(1)]; \ uiDiv = ((uiDiv>>29)|(uiDiv<<3)); \ \ for(ii = 0; ii < 16; ii+=2) { \ uiDiv = RC_LM::D_ENCRYPT(uiDiv, uiVal^hData[SHIDX(ii)], uiVal^hData2[SHIDX(ii)]); \ uiVal = RC_LM::D_ENCRYPT(uiVal, uiDiv^hData[SHIDX(ii+1)], uiDiv^hData2[SHIDX(ii+1)]); \ } \ \ hData3[SHIDX(0)] = ((uiVal>>3)|(uiVal<<29)); \ hData3[SHIDX(1)] = ((uiDiv>>3)|(uiDiv<<29)); \ RC_LM::FP(SHIDX(0), SHIDX(1), SHIDX(2), hData3); \ \ hData[SHIDX(0)] = hData3[SHIDX(1)]; \ hData[SHIDX(1)] = hData3[SHIDX(0)]; \ \ kerEpilogue; \ } RT_LM_KERNEL(RTGenLMKernel, RTGEN_PROLOGUE, RTGEN_EPILOGUE) RT_LM_KERNEL(RTPreCalcKernel, RTPRECALC_PROLOGUE, RTPRECALC_EPILOGUE) RT_LM_KERNEL(RTCheckAlarmLMKernel, RTCHKALARM_PROLOGUE, RTCHKALARM_EPILOGUE) rcracki-mt-0.7.0/rcracki_mt/BaseRTReader.h0000640000175000017500000000635712043323152017614 0ustar dookiedookie/* * freerainbowtables is a project for generating, distributing, and using * perfect rainbow tables * * Copyright 2010, 2011 Martin Westergaard Jørgensen * Copyright 2010 Daniël Niggebrugge * Copyright 2010, 2011, 2012 James Nobis * Copyright 2011 Logan Watt * * This file is part of freerainbowtables. * * freerainbowtables is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * freerainbowtables is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with freerainbowtables. If not, see . */ #ifndef _BASERTREADER_H #define _BASERTREADER_H #include "Public.h" /** * The foundation for all the RT reader implementations */ class BaseRTReader { private: /// Members uint32_t chainCount; // number of chains in file uint32_t chainLength; // size of chain uint32_t tableIndex; // reduction function index offset uint32_t startPointBits; // start point in the chain uint32_t endPointBits; // end point in the chain std::string fileName; // name of file on disk std::string salt; // salt used for hash protected: FILE *data; // binary data uint32_t chainPosition; /// Set Methods virtual void setChainCount(uint32_t); virtual void setChainLength(uint32_t); virtual void setTableIndex(uint32_t); virtual void setStartPointBits(uint32_t); virtual void setEndPointBits(uint32_t); virtual void setFileName(std::string); virtual void setSalt(std::string); public: /// Default constructor BaseRTReader(); /** * Argument Constructor * @param uint32_t number of chains in the file * @param uint32_t size of the chain * @param uint32_t reduction function index offset * @param uint32_t start point in the chain * @param uint32_t end point in the chain * @param std::string name of the file on disk * @param std::string salt used for hash */ BaseRTReader(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, std::string, std::string); /// Default destructor virtual ~BaseRTReader(); /** * reads data chains into memory * @param uint32_t reference to the number of chains to read * @param RanbowChain0* pointer in memory to read the chains to * @return EXIT_SUCCESS or EXIT_FAILURE */ virtual int readChains(uint32_t &numChains, RainbowChainO *pData) = 0; virtual uint32_t getChainsLeft() = 0; virtual uint64_t getMinimumStartPoint() = 0; /// Get Methods virtual uint32_t getChainCount(); virtual uint32_t getChainLength(); virtual uint32_t getChainPosition(); virtual uint32_t getTableIndex(); virtual uint32_t getStartPointBits(); virtual uint32_t getEndPointBits(); virtual std::string getFileName(); virtual std::string getSalt(); /** * Debugging function */ virtual void Dump(); }; #endif rcracki-mt-0.7.0/rcracki_mt/rcuda.cu0000640000175000017500000004643212043323152016625 0ustar dookiedookie// freerainbowtables is a project for generating, distributing, and using // perfect rainbow tables // // Copyright 2010, 2011 Jan Kyska // Copyright 2010 Martin Westergaard Jørgensen // Copyright 2010, 2011, 2012 James Nobis // // This file is part of freerainbowtables. // // freerainbowtables is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 2 of the License, or // (at your option) any later version. // // freerainbowtables is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with freerainbowtables. If not, see . #include #include #include "rcuda.h" #define GRID_X_L2 6 #define GRID_Y_L2 6 #define BLOCK_X_L2 6 #define GRID_X_SIZE (1<>4)<<(4+vol))+((idx)&15)) #define THREADIDX ((((blockIdx.y<>32; \ hData[SHIDX(2)] = dataHeap[nPos+1]; \ } \ } \ __syncthreads(); \ \ hData = shData + DATAIDX(4, threadIdx.x); \ \ idx64 = hData[SHIDX(1)]; \ idx64 = (idx64<<32) | hData[SHIDX(0)]; \ cpcheck = hData[SHIDX(2)]; \ checkpoint = cpcheck&0x0000ffff; \ cpcheck = cpcheck>>16; \ \ for(nPos = chainStart; nPos < chainStop; nPos++) { #define RTGEN_EPILOGUE \ idx64 = hData[SHIDX(1)]; \ idx64 = (idx64<<32) | hData[SHIDX(0)]; \ idx64 += reduceOffset + nPos; \ uiDiv64 = __umul64hi(idx64, rPlainSpaceTotal); \ idx64 -= uiDiv64*plainSpaceTotal; \ if(idx64 >= plainSpaceTotal) \ idx64 -= plainSpaceTotal; \ \ if(cpcheck < plCpPosSize && nPos == plCpPos[cpcheck]) { \ checkpoint |= ((unsigned int)idx64&1) << cpcheck; \ cpcheck++; \ } \ } \ \ hData[SHIDX(0)] = idx64; \ hData[SHIDX(1)] = idx64>>32; \ hData[SHIDX(2)] = (cpcheck<<16)|(checkpoint&0x0000ffff); \ __syncthreads(); \ \ if(threadIdx.x == 0) { \ nPos = (THREADIDX<<1); \ for(ii = 0; ii < BLOCK_X_SIZE; ii++, nPos+=2) { \ hData = shData + DATAIDX(4, ii); \ dataHeap[nPos] = ((uint64_t)hData[SHIDX(1)]<<32)|(uint64_t)hData[SHIDX(0)]; \ dataHeap[nPos+1] = hData[SHIDX(2)]; \ } \ } #define RTGEN_IDX2PLAIN_BEGIN \ dimVecIdx = 0; \ ii = 0; \ do { \ plainSpace = (uint64_t)cplDimVec[dimVecIdx].x | ((uint64_t)cplDimVec[dimVecIdx].y<<32); \ dimVecIdx++; \ uiVal64 = idx64/plainSpace; \ idx64mod = idx64 - uiVal64*plainSpace; \ idx64 = uiVal64 #define RTGEN_IDX2PLAIN_END \ if(!(dimItem.z&512)) { \ while(!((cplDimVec[dimVecIdx].x>>16)&512)) \ dimVecIdx++; \ dimVecIdx++; \ } \ \ idx64 = idx64mod; \ } while(plainSpace > 1) #define RTGEN_I2P_LOOP64_BEGIN \ dimItem.z = 0; \ for(; idx64 > 0xfffffff0ull && ii < PLAIN_MAX_SIZE && !(dimItem.z&512); ii++, dimVecIdx++) { \ uiVal64 = idx64; \ dimItem.x = (cplDimVec[dimVecIdx].x&0xffffu); \ dimItem.y = cplDimVec[dimVecIdx].y; \ dimItem.z = (cplDimVec[dimVecIdx].x>>16); \ \ uiMul64 = (uint64_t)dimItem.y<<32; \ idx64 = __umul64hi(uiVal64, uiMul64); \ uiDiv64 = uiVal64 - idx64*(uint64_t)dimItem.x; \ uiVal = __umulhi((unsigned int)uiDiv64, dimItem.y); \ uiDiv = (unsigned int)uiDiv64 - uiVal * dimItem.x; \ idx64 += uiVal; \ if(uiDiv >= dimItem.x) { \ uiDiv -= dimItem.x; \ idx64++; \ } \ \ if(dimItem.z&256) { \ if(!uiDiv && idx64>0) { \ uiDiv = dimItem.x; \ idx64--; \ } \ uiDiv -= (uiDiv>0?1u:0); \ } #define RTGEN_I2P_LOOP64_END \ } #define RTGEN_I2P_LOOP32_BEGIN \ dimItem.z = 0; \ for(idx = (unsigned int)idx64; ii < PLAIN_MAX_SIZE && !(dimItem.z&512); ii++, dimVecIdx++) { \ uiVal = idx; \ dimItem.x = (cplDimVec[dimVecIdx].x&0xffffu); \ dimItem.y = cplDimVec[dimVecIdx].y; \ dimItem.z = (cplDimVec[dimVecIdx].x>>16); \ \ idx = __umulhi(uiVal, dimItem.y); \ uiDiv = uiVal - idx*dimItem.x; \ if(uiDiv >= dimItem.x) { \ uiDiv -= dimItem.x; \ idx++; \ } \ \ if(dimItem.z&256) { \ if(!uiDiv && !idx) { \ dimVecIdx++; \ break; \ } \ if(!uiDiv && idx>0) { \ uiDiv = dimItem.x; \ idx--; \ } \ uiDiv -= (uiDiv>0?1u:0); \ } #define RTGEN_I2P_LOOP32_END \ } /*********** PreCalculate **************/ #define RTPRECALC_PROLOGUE \ unsigned int *hData; \ unsigned int idx; \ uint64_t idx64; \ unsigned int nPos, ii; \ unsigned int startNPos; \ uint3 dimItem; \ uint64_t uiDiv64, uiVal64, uiMul64; \ uint64_t plainSpace, idx64mod; \ unsigned int uiVal, uiDiv; \ unsigned int dimVecIdx; \ \ __shared__ unsigned int shData[SHIDX(BLOCK_X_SIZE)]; \ \ if(threadIdx.x == 0) { \ nPos = THREADIDX; \ for(ii = 0; ii < BLOCK_X_SIZE; ii++, nPos++) { \ hData = shData + DATAIDX(4, ii); \ hData[SHIDX(0)] = dataHeap[nPos]; \ hData[SHIDX(1)] = dataHeap[nPos]>>32; \ hData[SHIDX(2)] = (unsigned int)cplStartIdx + nPos + 1; \ } \ } \ __syncthreads(); \ \ hData = shData + DATAIDX(4, threadIdx.x); \ \ idx64 = hData[SHIDX(1)]; \ idx64 = (idx64<<32) | hData[SHIDX(0)]; \ startNPos = hData[SHIDX(2)]; \ \ for(nPos = (startNPos>chainStart? startNPos : chainStart); nPos < chainStop; nPos++) { #define RTPRECALC_EPILOGUE \ idx64 = hData[SHIDX(1)]; \ idx64 = (idx64<<32) | hData[SHIDX(0)]; \ idx64 += reduceOffset + nPos; \ uiDiv64 = __umul64hi(idx64, rPlainSpaceTotal); \ idx64 -= uiDiv64*plainSpaceTotal; \ if(idx64 >= plainSpaceTotal) \ idx64 -= plainSpaceTotal; \ \ } \ \ hData[SHIDX(0)] = idx64; \ hData[SHIDX(1)] = idx64>>32; \ __syncthreads(); \ \ if(threadIdx.x == 0) { \ nPos = THREADIDX; \ for(ii = 0; ii < BLOCK_X_SIZE; ii++, nPos++) { \ hData = shData + DATAIDX(4, ii); \ dataHeap[nPos] = ((uint64_t)hData[SHIDX(1)]<<32)|(uint64_t)hData[SHIDX(0)]; \ } \ } /*********** CheckAlarm **************/ #define PARAMIDX_ALARM 0 #define PARAMIDX_GUESSEDPOS 1 #define RTCHKALARM_PROLOGUE \ unsigned int *hData, *hDataX; \ unsigned int idx; \ uint64_t idx64, lastIdx64; \ unsigned int nPos, ii; \ unsigned int stopNPos; \ uint3 dimItem; \ uint64_t uiDiv64, uiVal64, uiMul64; \ uint64_t plainSpace, idx64mod; \ unsigned int uiVal, uiDiv; \ unsigned int dimVecIdx; \ \ __shared__ unsigned int shData[SHIDX(BLOCK_X_SIZE)]; \ __shared__ unsigned int shDataX[BLOCK_X_SIZE<<1]; \ \ if(threadIdx.x == 0) { \ nPos = (THREADIDX<<1); \ for(ii = 0; ii < BLOCK_X_SIZE; ii++, nPos+=2) { \ hData = shData + DATAIDX(4, ii); \ hDataX = shDataX + DATAIDX(1, ii); \ hData[SHIDX(0)] = dataHeap[nPos]; \ hData[SHIDX(1)] = dataHeap[nPos]>>32; \ hDataX[SHIDX(PARAMIDX_ALARM)] = dataHeap[nPos+1]>>32; \ hDataX[SHIDX(PARAMIDX_GUESSEDPOS)] = dataHeap[nPos+1]; \ } \ } \ __syncthreads(); \ \ hData = shData + DATAIDX(4, threadIdx.x); \ hDataX = shDataX + DATAIDX(1, threadIdx.x); \ \ idx64 = hData[SHIDX(1)]; \ idx64 = (idx64<<32) | hData[SHIDX(0)]; \ stopNPos = hDataX[SHIDX(PARAMIDX_GUESSEDPOS)]; \ if(chainStart > stopNPos || (stopNPos == 0xfffffffful && hDataX[SHIDX(PARAMIDX_ALARM)] == 0xfffffffful)) \ return; \ chainStop = (chainStop>stopNPos? stopNPos : chainStop); \ \ lastIdx64 = 0; \ for(nPos = chainStart; nPos <= chainStop; nPos++) { \ lastIdx64 = idx64; #define RTCHKALARM_EPILOGUE \ idx64 = hData[SHIDX(1)]; \ idx64 = (idx64<<32) | hData[SHIDX(0)]; \ idx64 += reduceOffset + nPos; \ uiDiv64 = __umul64hi(idx64, rPlainSpaceTotal); \ idx64 -= uiDiv64*plainSpaceTotal; \ if(idx64 >= plainSpaceTotal) \ idx64 -= plainSpaceTotal; \ \ } \ \ if(nPos <= stopNPos) { \ hData[SHIDX(0)] = idx64; \ hData[SHIDX(1)] = idx64>>32; \ hDataX[SHIDX(PARAMIDX_ALARM)] = 0; \ } else { \ uiVal = 1; \ for(nPos = 0; nPos < cplTargetHashSize; nPos++) \ uiVal = (cplTargetHash[nPos]==hData[SHIDX(nPos)]? uiVal : 0); \ hData[SHIDX(0)] = lastIdx64; \ hData[SHIDX(1)] = lastIdx64>>32; \ hDataX[SHIDX(PARAMIDX_ALARM)] = uiVal; \ } \ __syncthreads(); \ \ if(threadIdx.x == 0) { \ nPos = (THREADIDX<<1); \ for(ii = 0; ii < BLOCK_X_SIZE; ii++, nPos+=2) { \ hData = shData + DATAIDX(4, ii); \ hDataX = shDataX + DATAIDX(1, ii); \ dataHeap[nPos] = ((uint64_t)hData[SHIDX(1)]<<32)|(uint64_t)hData[SHIDX(0)]; \ if(hDataX[SHIDX(PARAMIDX_ALARM)]) { \ dataHeap[nPos+1] = 0xffffffffffffffffull; \ termKernel = 1; \ } \ } \ } #include "rcuda_md5.inc" #include "rcuda_md4.inc" #include "rcuda_ntlm.inc" #include "rcuda_sha1.inc" #include "rcuda_lm.inc" extern "C" int CalcChainsOnCUDA(const rcuda::RCudaTask* task, uint64_t *resultBuff) { cudaSetDeviceFlags(cudaDeviceBlockingSync); cudaError_t cuErr; uint64_t *data; int *cpPos; uint64_t uiVal64; if(task->charSetSize > CHAR_SET_MAXLEN) return -1; switch(task->hash) { case rcuda::RHASH_MD5: case rcuda::RHASH_MD4: case rcuda::RHASH_NTLM: case rcuda::RHASH_SHA1: case rcuda::RHASH_MYSQLSHA1: case rcuda::RHASH_LM: break; default: return 0; } cudaMalloc((void**)&data, (task->idxCount+BLOCK_X_SIZE)*2*sizeof(uint64_t)); cudaMalloc((void**)&cpPos, task->cpPosSize*sizeof(int)); cudaMemcpy(data, resultBuff, task->idxCount*2*sizeof(uint64_t), cudaMemcpyHostToDevice); cudaMemcpy(cpPos, task->cpPositions, task->cpPosSize*sizeof(int), cudaMemcpyHostToDevice); cudaMemcpyToSymbol(dataHeap, &data, sizeof(data)); cudaMemcpyToSymbol(cplDimVec, task->dimVec, min((unsigned long long)task->dimVecSize*sizeof(uint2), (unsigned long long)sizeof(cplDimVec))); cudaMemcpyToSymbol(cplChrSet, task->charSet, min(task->charSetSize, CHAR_SET_MAXLEN)); cudaMemcpyToSymbol(plCpPos, &cpPos, sizeof(cpPos)); cudaMemcpyToSymbol(plCpPosSize, &task->cpPosSize, sizeof(task->cpPosSize)); cudaMemcpyToSymbol(reduceOffset, &task->reduceOffset, sizeof(task->reduceOffset)); cudaMemcpyToSymbol(plainSpaceTotal, &task->plainSpaceTotal, sizeof(task->plainSpaceTotal)); uiVal64 = (uint64_t)-1/task->plainSpaceTotal; cudaMemcpyToSymbol(rPlainSpaceTotal, &uiVal64, sizeof(uiVal64)); int grSizeX = (task->idxCount-1)/BLOCK_X_SIZE + 1; int grSizeY = (grSizeX-1)/GRID_X_SIZE + 1; grSizeX = GRID_X_SIZE; dim3 numBlocks(grSizeX, grSizeY); cuErr = cudaSuccess; for(unsigned int idx = 0; idx < task->rainbowChainLen-1 && cuErr == cudaSuccess; idx+=task->kernChainSize) { switch(task->hash) { case rcuda::RHASH_MD5: RTGenMD5Kernel<<>>(idx, min(idx+task->kernChainSize, task->rainbowChainLen-1)); break; case rcuda::RHASH_MD4: RTGenMD4Kernel<<>>(idx, min(idx+task->kernChainSize, task->rainbowChainLen-1)); break; case rcuda::RHASH_NTLM: RTGenNTLMKernel<<>>(idx, min(idx+task->kernChainSize, task->rainbowChainLen-1)); break; case rcuda::RHASH_SHA1: RTGenSHA1Kernel<<>>(idx, min(idx+task->kernChainSize, task->rainbowChainLen-1)); break; case rcuda::RHASH_MYSQLSHA1: RTGenMySQLSHA1Kernel<<>>(idx, min(idx+task->kernChainSize, task->rainbowChainLen-1)); break; case rcuda::RHASH_LM: RTGenLMKernel<<>>(idx, min(idx+task->kernChainSize, task->rainbowChainLen-1)); break; case rcuda::RHASH_UNDEF: break; } cuErr = cudaThreadSynchronize(); } if(cuErr == cudaSuccess) cudaMemcpy(resultBuff, data, task->idxCount*2*sizeof(uint64_t), cudaMemcpyDeviceToHost); else fprintf(stderr, "Error happened: %d (%s)\n", cuErr, cudaGetErrorString(cuErr)); if(task->cpPosSize > 0) { cudaFree(cpPos); } cudaFree(data); return cuErr==cudaSuccess? task->idxCount : -1; } extern "C" int PreCalculateOnCUDA(const rcuda::RCudaTask* task, uint64_t *resultBuff) { cudaSetDeviceFlags(cudaDeviceBlockingSync); cudaError_t cuErr; uint64_t *data; uint64_t uiVal64; if(task->charSetSize > CHAR_SET_MAXLEN) return -1; switch(task->hash) { case rcuda::RHASH_MD5: case rcuda::RHASH_MD4: case rcuda::RHASH_NTLM: case rcuda::RHASH_SHA1: case rcuda::RHASH_MYSQLSHA1: case rcuda::RHASH_LM: break; default: return 0; } cudaMalloc((void**)&data, (task->idxCount+BLOCK_X_SIZE)*sizeof(uint64_t)); cudaMemcpy(data, resultBuff, task->idxCount*sizeof(uint64_t), cudaMemcpyHostToDevice); cudaMemcpyToSymbol(dataHeap, &data, sizeof(data)); cudaMemcpyToSymbol(cplDimVec, task->dimVec, min((unsigned long long)task->dimVecSize*sizeof(uint2),(unsigned long long)sizeof(cplDimVec))); cudaMemcpyToSymbol(cplChrSet, task->charSet, min(task->charSetSize, CHAR_SET_MAXLEN)); cudaMemcpyToSymbol(reduceOffset, &task->reduceOffset, sizeof(task->reduceOffset)); cudaMemcpyToSymbol(plainSpaceTotal, &task->plainSpaceTotal, sizeof(task->plainSpaceTotal)); uiVal64 = (uint64_t)-1/task->plainSpaceTotal; cudaMemcpyToSymbol(rPlainSpaceTotal, &uiVal64, sizeof(uiVal64)); cudaMemcpyToSymbol(cplStartIdx, &task->startIdx, sizeof(task->startIdx)); int grSizeX = (task->idxCount-1)/BLOCK_X_SIZE + 1; int grSizeY = (grSizeX-1)/GRID_X_SIZE + 1; grSizeX = GRID_X_SIZE; dim3 numBlocks(grSizeX, grSizeY); cuErr = cudaSuccess; for(unsigned int idx = (unsigned int)task->startIdx; idx < task->rainbowChainLen-1 && cuErr == cudaSuccess; idx+=task->kernChainSize) { switch(task->hash) { case rcuda::RHASH_MD5: RTPreCalcMD5Kernel<<>>(idx, min(idx+task->kernChainSize, task->rainbowChainLen-1)); break; case rcuda::RHASH_MD4: RTPreCalcMD4Kernel<<>>(idx, min(idx+task->kernChainSize, task->rainbowChainLen-1)); break; case rcuda::RHASH_NTLM: RTPreCalcNTLMKernel<<>>(idx, min(idx+task->kernChainSize, task->rainbowChainLen-1)); break; case rcuda::RHASH_SHA1: RTPreCalcSHA1Kernel<<>>(idx, min(idx+task->kernChainSize, task->rainbowChainLen-1)); break; case rcuda::RHASH_MYSQLSHA1: RTPreCalcMySQLSHA1Kernel<<>>(idx, min(idx+task->kernChainSize, task->rainbowChainLen-1)); break; case rcuda::RHASH_LM: RTPreCalcKernel<<>>(idx, min(idx+task->kernChainSize, task->rainbowChainLen-1)); break; case rcuda::RHASH_UNDEF: break; } cuErr = cudaThreadSynchronize(); } if(cuErr == cudaSuccess) cudaMemcpy(resultBuff, data, task->idxCount*sizeof(uint64_t), cudaMemcpyDeviceToHost); else fprintf(stderr, "Error happened: %d (%s)\n", cuErr, cudaGetErrorString(cuErr)); cudaFree(data); return cuErr==cudaSuccess? task->idxCount : -1; } extern "C" int CheckAlarmOnCUDA(const rcuda::RCudaTask* task, uint64_t *resultBuff) { cudaSetDeviceFlags(cudaDeviceBlockingSync); cudaError_t cuErr; uint64_t *data; uint64_t uiVal64; int isize; if(task->charSetSize > CHAR_SET_MAXLEN) return -1; isize = 0; switch(task->hash) { case rcuda::RHASH_MD5: case rcuda::RHASH_MD4: case rcuda::RHASH_NTLM: isize = (isize==0? 16 : isize); case rcuda::RHASH_SHA1: case rcuda::RHASH_MYSQLSHA1: isize = (isize==0? 20 : isize); case rcuda::RHASH_LM: isize = (isize==0? 8 : isize); cudaMemcpyToSymbol(cplTargetHash, task->targetHash, isize); isize = (isize>>2); cudaMemcpyToSymbol(cplTargetHashSize, &isize, sizeof(isize)); break; default: return 0; } cudaMalloc((void**)&data, (task->idxCount+BLOCK_X_SIZE)*2*sizeof(uint64_t)); cudaMemcpy(data, resultBuff, task->idxCount*2*sizeof(uint64_t), cudaMemcpyHostToDevice); cudaMemcpyToSymbol(dataHeap, &data, sizeof(data)); cudaMemcpyToSymbol(cplDimVec, task->dimVec, min((unsigned long long)task->dimVecSize*sizeof(uint2), (unsigned long long)sizeof(cplDimVec))); cudaMemcpyToSymbol(cplChrSet, task->charSet, min(task->charSetSize, CHAR_SET_MAXLEN)); cudaMemcpyToSymbol(reduceOffset, &task->reduceOffset, sizeof(task->reduceOffset)); cudaMemcpyToSymbol(plainSpaceTotal, &task->plainSpaceTotal, sizeof(task->plainSpaceTotal)); uiVal64 = (uint64_t)-1/task->plainSpaceTotal; cudaMemcpyToSymbol(rPlainSpaceTotal, &uiVal64, sizeof(uiVal64)); int grSizeX = (task->idxCount-1)/BLOCK_X_SIZE + 1; int grSizeY = (grSizeX-1)/GRID_X_SIZE + 1; grSizeX = GRID_X_SIZE; dim3 numBlocks(grSizeX, grSizeY); cuErr = cudaSuccess; isize = 0; cudaMemcpyToSymbol(termKernel, &isize, sizeof(isize)); for(unsigned int idx = 0; idx <= task->rainbowChainLen && cuErr == cudaSuccess; idx+=task->kernChainSize) { switch(task->hash) { case rcuda::RHASH_MD5: RTCheckAlarmMD5Kernel<<>>(idx, min(idx+task->kernChainSize-1, task->rainbowChainLen)); break; case rcuda::RHASH_MD4: RTCheckAlarmMD4Kernel<<>>(idx, min(idx+task->kernChainSize-1, task->rainbowChainLen)); break; case rcuda::RHASH_NTLM: RTCheckAlarmNTLMKernel<<>>(idx, min(idx+task->kernChainSize-1, task->rainbowChainLen)); break; case rcuda::RHASH_SHA1: RTCheckAlarmSHA1Kernel<<>>(idx, min(idx+task->kernChainSize-1, task->rainbowChainLen)); break; case rcuda::RHASH_MYSQLSHA1: RTCheckAlarmMySQLSHA1Kernel<<>>(idx, min(idx+task->kernChainSize-1, task->rainbowChainLen)); break; case rcuda::RHASH_LM: RTCheckAlarmLMKernel<<>>(idx, min(idx+task->kernChainSize-1, task->rainbowChainLen)); break; case rcuda::RHASH_UNDEF: break; } cuErr = cudaThreadSynchronize(); cudaMemcpyFromSymbol(&isize, termKernel, sizeof(isize)); if(isize) break; } if(cuErr == cudaSuccess) cudaMemcpy(resultBuff, data, task->idxCount*2*sizeof(uint64_t), cudaMemcpyDeviceToHost); else fprintf(stderr, "Error happened: %d (%s)\n", cuErr, cudaGetErrorString(cuErr)); cudaFree(data); return cuErr==cudaSuccess? task->idxCount : -1; } extern "C" int GetChainsBufferSize(int minSize) { int grSizeX = (minSize-1)/BLOCK_X_SIZE + 1; int grSizeY = (grSizeX-1)/GRID_X_SIZE + 1; grSizeX = GRID_X_SIZE; return grSizeX*grSizeY*BLOCK_X_SIZE; } extern "C" int SetCudaDevice(int device) { return cudaSetDevice(device); } rcracki-mt-0.7.0/rcracki_mt/global.h0000640000175000017500000000447212043323152016605 0ustar dookiedookie/* * freerainbowtables is a project for generating, distributing, and using * perfect rainbow tables * * Copyright 2009, 2010 Daniël Niggebrugge * Copyright 2009, 2010, 2011, 2012 James Nobis * * This file is part of freerainbowtables. * * freerainbowtables is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * freerainbowtables is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with freerainbowtables. If not, see . */ #ifndef _GLOBAL_H #define _GLOBAL_H #ifndef __STDC_FORMAT_MACROS #define __STDC_FORMAT_MACROS /* for PRI macros */ #endif #ifndef __STDC_LIMIT_MACROS #define __STDC_LIMIT_MACROS /* for uint64_t, UINT64_MAX, etc. */ #endif #include #include #if defined(_WIN32) && !defined(__GNUC__) #include "inttypes.h" #else #include "/usr/include/inttypes.h" #endif /* * XXX * add universal support for unsigned 64-bit int values * 0x00FFFFFFFFFFFFFFI64 * 0x00FFFFFFFFFFFFFFllu */ #if defined(_WIN32) && !defined(__GNUC__) #ifndef INT64_MAX #error "INT64_MAX not defined" #define int64_t __int64 #endif #ifndef UINT64_MAX #error "UINT64_MAX not defined" #define uint64_t unsigned __int64 #endif #ifndef UINT32_MAX #error "UINT32_MAX not defined" #define uint32_t unsigned __int32 #endif #ifndef UINT16_MAX #error "UINT16_MAX not defined" #define uint16_t unsigned short #endif #ifndef UINT8_MAX #error "UINT8_MAX not defined" #define uint8_t unsigned char #endif #else #ifndef INT64_MAX #error "INT64_MAX not defined" #endif #ifndef UINT64_MAX #error "UINT64_MAX not defined" #endif #ifndef UINT32_MAX #error "UINT32_MAX not defined" #endif #ifndef UINT16_MAX #error "UINT16_MAX not defined" #endif #ifndef UINT8_MAX #error "UINT8_MAX not defined" #endif #endif struct uint24_t { uint8_t data[3]; }; #endif /* !GLOBAL_H */ rcracki-mt-0.7.0/rcracki_mt/CrackEngine.cpp0000640000175000017500000012123212043323152020043 0ustar dookiedookie/* * rcracki_mt is a multithreaded implementation and fork of the original * RainbowCrack * * Copyright (C) Zhu Shuanglei * Copyright 2009, 2010 Martin Westergaard Jørgensen * Copyright 2009, 2010 Daniël Niggebrugge * Copyright 2009, 2010, 2011, 2012 James Nobis * Copyright 2010 uroskn * Copyright 2011 Janosch Rux * Copyright 2011 Logan Watt * Copyright 2011 Jan Kyska * * This file is part of rcracki_mt. * * rcracki_mt is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * rcracki_mt is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with rcracki_mt. If not, see . */ #include "CrackEngine.h" #include "RTReader.h" #include "RTIReader.h" #include "RTI2Reader.h" #ifdef GUI #include #include "GUI_database.h" #include "GUI.h" #endif #ifndef _WIN32 #include #endif CCrackEngine::CCrackEngine() { ResetStatistics(); writeOutput = false; resumeSession = false; debug = false; keepPrecalcFiles = false; gpu = 0; sSessionPathName = ""; sProgressPathName = ""; } CCrackEngine::~CCrackEngine() { } ////////////////////////////////////////////////////////////////////// void CCrackEngine::ResetStatistics() { m_fTotalDiskAccessTime = 0.0f; m_fTotalCryptanalysisTime = 0.0f; m_fTotalPrecalculationTime = 0.0f; m_nTotalChainWalkStep = 0; m_nTotalFalseAlarm = 0; m_nTotalChainWalkStepDueToFalseAlarm = 0; // m_nTotalFalseAlarmSkipped = 0; } int CCrackEngine::BinarySearchOld(RainbowChainO* pChain, int nRainbowChainCount, uint64_t nIndex) { int nLow = 0; int nHigh = nRainbowChainCount - 1; while (nLow <= nHigh) { int nMid = (nLow + nHigh) / 2; if (nIndex == pChain[nMid].nIndexE) return nMid; else if (nIndex < pChain[nMid].nIndexE) nHigh = nMid - 1; else nLow = nMid + 1; } return -1; } RainbowChain *CCrackEngine::BinarySearch(RainbowChain *pChain, int nChainCountRead, uint64_t nIndex, RTIrcrackiIndexChain *pIndex, int nIndexSize, int nIndexStart) { uint64_t nPrefix = nIndex >> 16; int nLow, nHigh; bool found = false; //int nChains = 0; if(nPrefix > (pIndex[nIndexSize-1].nPrefix & 0x000000FFFFFFFFFFULL)) // check if its in the index file { return NULL; } int nBLow = 0; int nBHigh = nIndexSize - 1; while (nBLow <= nBHigh) { int nBMid = (nBLow + nBHigh) / 2; if (nPrefix == (pIndex[nBMid].nPrefix & 0x000000FFFFFFFFFFULL)) { //nLow = nChains; //int nChains = 0; nLow = pIndex[nBMid].nFirstChain; nHigh = nLow + pIndex[nBMid].nChainCount; if(nLow >= nIndexStart && nLow <= nIndexStart + nChainCountRead) { if(nHigh > nIndexStart + nChainCountRead) nHigh = nIndexStart + nChainCountRead; } else if(nLow < nIndexStart && nHigh >= nIndexStart) { nLow = nIndexStart; } else break; found = true; break; } else if (nPrefix < (pIndex[nBMid].nPrefix & 0x000000FFFFFFFFFFULL)) nBHigh = nBMid - 1; else nBLow = nBMid + 1; } if(found == true) { for(int i = nLow - nIndexStart; i < nHigh - nIndexStart; i++) { int nSIndex = ((int)nIndex) & 0x0000FFFF; if (nSIndex == pChain[i].nIndexE) { return &pChain[i]; } else if(pChain[i].nIndexE > nSIndex) break; } } return NULL; } // not used currently, leaving code for future checkpoints //bool CCrackEngine::CheckAlarm(RainbowChain* pChain, int nGuessedPos, unsigned char* pHash, CHashSet& hs) //{ // CChainWalkContext cwc; // //uint64_t nIndexS = pChain->nIndexS >> 16; // uint64_t nIndexS = pChain->nIndexS & 0x0000FFFFFFFFFFFFULL; // for first 6 bytes // cwc.SetIndex(nIndexS); // int nPos; // for (nPos = 0; nPos < nGuessedPos; nPos++) // { // cwc.IndexToPlain(); // cwc.PlainToHash(); // cwc.HashToIndex(nPos); // // Not using checkpoints atm // /* // switch(nPos) // { // case 5000: // if((cwc.GetIndex() & 0x00000001) != (pChain->nCheckPoint & 0x00000080) >> 7) // { // m_nTotalFalseAlarmSkipped += 10000 - 5000; //// printf("CheckPoint caught false alarm at position 7600\n"); // return false; // } // break; // case 6000: // if((cwc.GetIndex() & 0x00000001) != (pChain->nCheckPoint & 0x00000040) >> 6) // { //// printf("CheckPoint caught false alarm at position 8200\n"); // m_nTotalFalseAlarmSkipped += 10000 - 6000; // return false; // } // break; // // case 7600: // if((cwc.GetIndex() & 0x00000001) != (pChain->nCheckPoint & 0x00000020) >> 5) // { //// printf("CheckPoint caught false alarm at position 8700\n"); // m_nTotalFalseAlarmSkipped += 10000 - 7600; // return false; // } // break; // // case 8200: // if((cwc.GetIndex() & 0x00000001) != (pChain->nCheckPoint & 0x00000010) >> 4) // { //// printf("CheckPoint caught false alarm at position 9000\n"); // m_nTotalFalseAlarmSkipped += 10000 - 8200; // return false; // } // break; // // case 8700: // if((cwc.GetIndex() & 0x00000001) != (pChain->nCheckPoint & 0x00000008) >> 3) // { //// printf("CheckPoint caught false alarm at position 9300\n"); // m_nTotalFalseAlarmSkipped += 10000 - 8700; // return false; // } // // break; // case 9000: // if((cwc.GetIndex() & 0x00000001) != (pChain->nCheckPoint & 0x00000004) >> 2) // { //// printf("CheckPoint caught false alarm at position 9600\n"); // m_nTotalFalseAlarmSkipped += 10000 - 9000; // return false; // } // // break; // case 9300: // if((cwc.GetIndex() & 0x00000001) != (pChain->nCheckPoint & 0x00000002) >> 1) // { //// printf("CheckPoint caught false alarm at position 9600\n"); // m_nTotalFalseAlarmSkipped += 10000 - 9300; // return false; // } // break; // case 9600: // if((cwc.GetIndex() & 0x00000001) != (pChain->nCheckPoint & 0x00000001)) // { //// printf("CheckPoint caught false alarm at position 9600\n"); // m_nTotalFalseAlarmSkipped += 10000 - 9600; // return false; // } // break; // // }*/ // } // cwc.IndexToPlain(); // cwc.PlainToHash(); // if (cwc.CheckHash(pHash)) // { // printf("plaintext of %s is %s\n", cwc.GetHash().c_str(), cwc.GetPlain().c_str()); // hs.SetPlain(cwc.GetHash(), cwc.GetPlain(), cwc.GetBinary()); // return true; // } // // return false; //} //bool CCrackEngine::CheckAlarmOld(RainbowChainO* pChain, int nGuessedPos, unsigned char* pHash, CHashSet& hs) //{ // CChainWalkContext cwc; // cwc.SetIndex(pChain->nIndexS); // int nPos; // for (nPos = 0; nPos < nGuessedPos; nPos++) // { // cwc.IndexToPlain(); // cwc.PlainToHash(); // cwc.HashToIndex(nPos); // } // cwc.IndexToPlain(); // cwc.PlainToHash(); // if (cwc.CheckHash(pHash)) // { // printf("plaintext of %s is %s\n", cwc.GetHash().c_str(), cwc.GetPlain().c_str()); // hs.SetPlain(cwc.GetHash(), cwc.GetPlain(), cwc.GetBinary()); // return true; // } // // return false; //} void CCrackEngine::GetChainIndexRangeWithSameEndpoint(RainbowChainO* pChain, int nRainbowChainCount, int nMatchingIndexE, int& nMatchingIndexEFrom, int& nMatchingIndexETo) { nMatchingIndexEFrom = nMatchingIndexE; nMatchingIndexETo = nMatchingIndexE; while (nMatchingIndexEFrom > 0) { if (pChain[nMatchingIndexEFrom - 1].nIndexE == pChain[nMatchingIndexE].nIndexE) nMatchingIndexEFrom--; else break; } while (nMatchingIndexETo < nRainbowChainCount - 1) { if (pChain[nMatchingIndexETo + 1].nIndexE == pChain[nMatchingIndexE].nIndexE) nMatchingIndexETo++; else break; } } void CCrackEngine::SearchTableChunkOld(RainbowChainO* pChain, int nRainbowChainLen, int nRainbowChainCount, CHashSet& hs) { std::vector vHash; hs.GetLeftHashWithLen(vHash, CChainWalkContext::GetHashLen()); printf("searching for %lu hash%s...\n", (unsigned long)vHash.size(), vHash.size() > 1 ? "es" : ""); uint64_t nChainWalkStep = 0; int nFalseAlarm = 0; int nChainWalkStepDueToFalseAlarm = 0; std::vector threadPool; std::vector pThreads; #ifndef _WIN32 /* * On linux you cannot set the priority of a thread in the non real time * scheduling groups. You can set the priority of the process. In * windows BELOW_NORMAL represents a 1/8th drop in priority and this would * be 20 * 1/8 on linux or about 2.5 */ setpriority( PRIO_PROCESS, 0, 2 ); #endif pthread_attr_t attr; pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); #ifdef _WIN32 sched_param param; /* * windows scheduling is 0 to 32 (low to high) with 8 as normal and 7 as * BELOW_NORMAL */ param.sched_priority = THREAD_PRIORITY_BELOW_NORMAL; pthread_attr_setschedparam (&attr, ¶m); #endif // else set it to 5 or something (for linux)? bool pausing = false; uint32_t nHashIndex; for (nHashIndex = 0; nHashIndex < vHash.size(); nHashIndex++) { #ifdef _WIN32 if (_kbhit()) { int ch = _getch(); ch = toupper(ch); if (ch == 'P') { pausing = true; printf( "\nPausing, press P again to continue... "); timeval tv; timeval tv2; timeval final; gettimeofday( &tv, NULL ); while (pausing) { if (_kbhit()) { ch = _getch(); ch = toupper(ch); if (ch == 'P') { printf( " [Continuing]\n"); pausing = false; gettimeofday( &tv2, NULL ); final = sub_timeofday( tv2, tv ); float fTime = 1.0f * final.tv_sec + 1.0f * final.tv_usec / 1000000; m_fTotalCryptanalysisTime -= fTime; } } Sleep(500); } } else { printf( "\nPress 'P' to pause...\n"); } } #else int c = tty_getchar(); if (c >= 0) { tty_flush(); if (c==112) { // = p pausing = true; printf( "\nPausing, press 'p' again to continue... "); timeval tv; timeval tv2; timeval final; gettimeofday( &tv, NULL ); while (pausing) { if ((c = tty_getchar()) >= 0) { tty_flush(); if (c == 112) { printf( " [Continuing]\n"); pausing = false; gettimeofday( &tv2, NULL ); final = sub_timeofday( tv2, tv ); float fTime = 1.0f * final.tv_sec + 1.0f * final.tv_usec / 1000000; m_fTotalCryptanalysisTime -= fTime; } } usleep(500*1000); } } else { printf( "\nPress 'p' to pause...\n"); } } #endif unsigned char TargetHash[MAX_HASH_LEN]; int nHashLen; ParseHash(vHash[nHashIndex], TargetHash, nHashLen); if (nHashLen != CChainWalkContext::GetHashLen()) printf("Debug: nHashLen mismatch\n"); // Request ChainWalk bool fNewlyGenerated; uint64_t* pStartPosIndexE = m_cws.RequestWalk(TargetHash, nHashLen, CChainWalkContext::GetHashRoutineName(), CChainWalkContext::GetPlainCharsetName(), CChainWalkContext::GetPlainLenMin(), CChainWalkContext::GetPlainLenMax(), CChainWalkContext::GetRainbowTableIndex(), nRainbowChainLen, fNewlyGenerated, debug, sPrecalcPathName); // printf("Debug: using %s walk for %s\n", fNewlyGenerated ? "newly generated" : "existing", // vHash[nHashIndex].c_str()); if (fNewlyGenerated) { timeval tv; timeval tv2; timeval final; gettimeofday( &tv, NULL ); printf("Pre-calculating hash %lu of %lu.%-20s\r", (unsigned long)nHashIndex+1, (unsigned long)vHash.size(), ""); threadPool.clear(); pThreads.clear(); uint32_t thread_ID; for (thread_ID = 0; thread_ID < (unsigned long)maxThreads; thread_ID++) { rcrackiThread* r_Thread = new rcrackiThread(TargetHash, thread_ID, nRainbowChainLen, maxThreads, pStartPosIndexE); if (r_Thread) { r_Thread->Configure(gpu); pthread_t pThread; int returnValue = pthread_create( &pThread, &attr, rcrackiThread::rcrackiThreadStaticEntryPointPthread, (void *) r_Thread); if( returnValue != 0 ) { printf("pThread creation failed, returnValue: %d\n", returnValue); } else { pThreads.push_back(pThread); } threadPool.push_back(r_Thread); } else { printf("r_Thread creation failed!\n"); } } //printf("%d r_Threads created\t\t\n", threadPool.size()); for (thread_ID = 0; thread_ID < threadPool.size(); thread_ID++) { pthread_t pThread = pThreads[thread_ID]; int returnValue = pthread_join(pThread, NULL); if( returnValue != 0 ) { printf("pThread join failed, returnValue: %d\n", returnValue); } rcrackiThread* rThread = threadPool[thread_ID]; nChainWalkStep += rThread->GetChainWalkStep(); delete rThread; } m_cws.StoreToFile(pStartPosIndexE, TargetHash, nHashLen); gettimeofday( &tv2, NULL ); final = sub_timeofday( tv2, tv ); float fTime = 1.0f * final.tv_sec + 1.0f * final.tv_usec / 1000000; m_fTotalPrecalculationTime += fTime; m_fTotalCryptanalysisTime -= fTime; printf("%-50s\r", ""); if ( debug ) printf("Debug: pre-calculation time: %.2f s\n", fTime); } threadPool.clear(); pThreads.clear(); printf("Checking false alarms for hash %lu of %lu.%-20s\r", (unsigned long)nHashIndex+1, (unsigned long)vHash.size(), ""); int i; for (i = 0; i < maxThreads; i++) { rcrackiThread* r_Thread = new rcrackiThread(TargetHash, true); r_Thread->Configure(gpu); threadPool.push_back(r_Thread); } uint32_t thread_ID = 0; int nPos; for (nPos = nRainbowChainLen - 2; nPos >= 0; nPos--) { uint64_t nIndexEOfCurPos = pStartPosIndexE[nPos]; // Search matching nIndexE int nMatchingIndexE = BinarySearchOld(pChain, nRainbowChainCount, nIndexEOfCurPos); if (nMatchingIndexE != -1) { int nMatchingIndexEFrom, nMatchingIndexETo; GetChainIndexRangeWithSameEndpoint(pChain, nRainbowChainCount, nMatchingIndexE, nMatchingIndexEFrom, nMatchingIndexETo); int i; for (i = nMatchingIndexEFrom; i <= nMatchingIndexETo; i++) { rcrackiThread* rThread = threadPool[thread_ID]; rThread->AddAlarmCheckO(pChain + i, nPos); if (thread_ID < (unsigned long)maxThreads - 1 ) { thread_ID++; } else { thread_ID = 0; } } } } for (thread_ID = 0; thread_ID < (unsigned long)maxThreads; thread_ID++) { rcrackiThread* r_Thread = threadPool[thread_ID]; pthread_t pThread; int returnValue = pthread_create( &pThread, &attr, rcrackiThread::rcrackiThreadStaticEntryPointPthread, (void *) r_Thread); if( returnValue != 0 ) { printf("pThread creation failed, returnValue: %d\n", returnValue); } else { pThreads.push_back(pThread); } } //printf("%d r_Threads created\t\t\n", threadPool.size()); bool foundHashInThread = false; for (thread_ID = 0; thread_ID < threadPool.size(); thread_ID++) { rcrackiThread* rThread = threadPool[thread_ID]; pthread_t pThread = pThreads[thread_ID]; int returnValue = pthread_join(pThread, NULL); if( returnValue != 0 ) { printf("pThread join failed, returnValue: %d\n", returnValue); } nChainWalkStepDueToFalseAlarm += rThread->GetChainWalkStepDueToFalseAlarm(); nFalseAlarm += rThread->GetnFalseAlarm(); if (rThread->FoundHash() && !foundHashInThread) { printf("%-50s\r", ""); printf("plaintext of %s is %s\n", rThread->GetHash().c_str(), rThread->GetPlain().c_str()); if (writeOutput) { if (!writeResultLineToFile(outputFile, rThread->GetHash(), rThread->GetPlain(), rThread->GetBinary())) printf("Couldn't write this result to file!\n"); } hs.SetPlain(rThread->GetHash(), rThread->GetPlain(), rThread->GetBinary()); FILE* file; if ( ( file = fopen( sSessionPathName.c_str(), "a" ) ) != NULL ) { std::string buffer = "sHash=" + rThread->GetHash() + ":" + rThread->GetBinary() + ":" + rThread->GetPlain() + "\n"; fputs (buffer.c_str(), file); fclose (file); } m_cws.DiscardWalk(pStartPosIndexE); foundHashInThread = true; } //pthread delete rThread; } pThreads.clear(); threadPool.clear(); } printf("%-50s\r", ""); pThreads.clear(); threadPool.clear(); pthread_attr_destroy(&attr); if ( debug ) { std::cout << "Debug: chain walk step: " << nChainWalkStep << std::endl; std::cout << "Debug: false alarm: " << nFalseAlarm << std::endl; std::cout << "Debug: chain walk step due to false alarm: " << nChainWalkStepDueToFalseAlarm << std::endl; } m_nTotalChainWalkStep += nChainWalkStep; m_nTotalFalseAlarm += nFalseAlarm; m_nTotalChainWalkStepDueToFalseAlarm += nChainWalkStepDueToFalseAlarm; } void CCrackEngine::SearchTableChunk(RainbowChain* pChain, int nRainbowChainLen, int nRainbowChainCount, CHashSet& hs, RTIrcrackiIndexChain *pIndex, int nIndexSize, int nChainStart) { std::vector vHash; hs.GetLeftHashWithLen(vHash, CChainWalkContext::GetHashLen()); printf("searching for %lu hash%s...\n", (unsigned long)vHash.size(), vHash.size() > 1 ? "es" : ""); uint64_t nChainWalkStep = 0; int nFalseAlarm = 0; int nChainWalkStepDueToFalseAlarm = 0; std::vector threadPool; std::vector pThreads; #ifndef _WIN32 /* * On linux you cannot set the priority of a thread in the non real time * scheduling groups. You can set the priority of the process. In * windows BELOW_NORMAL represents a 1/8th drop in priority and this would * be 20 * 1/8 on linux or about 2.5 */ setpriority( PRIO_PROCESS, 0, 2 ); #endif pthread_attr_t attr; pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); #ifdef _WIN32 sched_param param; /* * windows scheduling is 0 to 32 (low to high) with 8 as normal and 7 as * BELOW_NORMAL */ param.sched_priority = THREAD_PRIORITY_BELOW_NORMAL; pthread_attr_setschedparam (&attr, ¶m); #endif // else set it to 5 or something (for linux)? bool pausing = false; uint32_t nHashIndex; for (nHashIndex = 0; nHashIndex < vHash.size(); nHashIndex++) { #ifdef _WIN32 if (_kbhit()) { int ch = _getch(); ch = toupper(ch); if (ch == 'P') { pausing = true; printf( "\nPausing, press P again to continue... "); timeval tv; timeval tv2; timeval final; gettimeofday( &tv, NULL ); while (pausing) { if (_kbhit()) { ch = _getch(); ch = toupper(ch); if (ch == 'P') { printf( " [Continuing]\n"); pausing = false; gettimeofday( &tv2, NULL ); final = sub_timeofday( tv2, tv ); float fTime = 1.0f * final.tv_sec + 1.0f * final.tv_usec / 1000000; m_fTotalCryptanalysisTime -= fTime; } } Sleep(500); } } else { printf( "\nPress 'P' to pause...\n"); } } #else int c = tty_getchar(); if (c >= 0) { tty_flush(); if (c==112) { // = p pausing = true; printf( "\nPausing, press 'p' again to continue... "); timeval tv; timeval tv2; timeval final; gettimeofday( &tv, NULL ); while (pausing) { if ((c = tty_getchar()) >= 0) { tty_flush(); if (c == 112) { printf( " [Continuing]\n"); pausing = false; gettimeofday( &tv2, NULL ); final = sub_timeofday( tv2, tv ); float fTime = 1.0f * final.tv_sec + 1.0f * final.tv_usec / 1000000; m_fTotalCryptanalysisTime -= fTime; } } usleep(500*1000); } } else { printf( "\nPress 'p' to pause...\n"); } } #endif unsigned char TargetHash[MAX_HASH_LEN]; int nHashLen; ParseHash(vHash[nHashIndex], TargetHash, nHashLen); if (nHashLen != CChainWalkContext::GetHashLen()) printf("Debug: nHashLen mismatch\n"); // Request ChainWalk bool fNewlyGenerated; uint64_t* pStartPosIndexE = m_cws.RequestWalk(TargetHash, nHashLen, CChainWalkContext::GetHashRoutineName(), CChainWalkContext::GetPlainCharsetName(), CChainWalkContext::GetPlainLenMin(), CChainWalkContext::GetPlainLenMax(), CChainWalkContext::GetRainbowTableIndex(), nRainbowChainLen, fNewlyGenerated, debug, sPrecalcPathName); // printf("Debug: using %s walk for %s\n", fNewlyGenerated ? "newly generated" : "existing", // vHash[nHashIndex].c_str()); if (fNewlyGenerated) { timeval tv; timeval tv2; timeval final; gettimeofday( &tv, NULL ); printf("Pre-calculating hash %lu of %lu.%-20s\r", (unsigned long)nHashIndex+1, (unsigned long)vHash.size(), ""); threadPool.clear(); pThreads.clear(); uint32_t thread_ID; for (thread_ID = 0; thread_ID < (unsigned long)maxThreads; thread_ID++) { rcrackiThread* r_Thread = new rcrackiThread(TargetHash, thread_ID, nRainbowChainLen, maxThreads, pStartPosIndexE); if (r_Thread) { r_Thread->Configure(gpu); pthread_t pThread; int returnValue = pthread_create( &pThread, &attr, rcrackiThread::rcrackiThreadStaticEntryPointPthread, (void *) r_Thread); if( returnValue != 0 ) { printf("pThread creation failed, returnValue: %d\n", returnValue); } else { pThreads.push_back(pThread); } threadPool.push_back(r_Thread); } else { printf("r_Thread creation failed!\n"); } } //printf("%d r_Threads created\t\t\n", threadPool.size()); for (thread_ID = 0; thread_ID < threadPool.size(); thread_ID++) { pthread_t pThread = pThreads[thread_ID]; int returnValue = pthread_join(pThread, NULL); if( returnValue != 0 ) { printf("pThread join failed, returnValue: %d\n", returnValue); } rcrackiThread* rThread = threadPool[thread_ID]; nChainWalkStep += rThread->GetChainWalkStep(); delete rThread; } m_cws.StoreToFile(pStartPosIndexE, TargetHash, nHashLen); gettimeofday( &tv2, NULL ); final = sub_timeofday( tv2, tv ); float fTime = 1.0f * final.tv_sec + 1.0f * final.tv_usec / 1000000; m_fTotalPrecalculationTime += fTime; m_fTotalCryptanalysisTime -= fTime; printf("%-50s\r", ""); if ( debug ) printf("Debug: pre-calculation time: %.2f s\n", fTime); } threadPool.clear(); pThreads.clear(); printf("Checking false alarms for hash %lu of %lu.%-20s\r", (unsigned long)nHashIndex+1, (unsigned long)vHash.size(), ""); int i; for (i = 0; i < maxThreads; i++) { rcrackiThread* r_Thread = new rcrackiThread(TargetHash); r_Thread->Configure(gpu); threadPool.push_back(r_Thread); } uint32_t thread_ID = 0; int nPos; for (nPos = nRainbowChainLen - 2; nPos >= 0; nPos--) { uint64_t nIndexEOfCurPos = pStartPosIndexE[nPos]; // Search matching nIndexE RainbowChain *pChainFound = BinarySearch(pChain, nRainbowChainCount, nIndexEOfCurPos, pIndex, nIndexSize, nChainStart); if (pChainFound != NULL) // For perfected indexed tables we only recieve 1 result (huge speed increase!) { rcrackiThread* rThread = threadPool[thread_ID]; rThread->AddAlarmCheck(pChainFound, nPos); if (thread_ID < (unsigned long)maxThreads - 1 ) { thread_ID++; } else { thread_ID = 0; } } } for (thread_ID = 0; thread_ID < (unsigned long)maxThreads; thread_ID++) { rcrackiThread* r_Thread = threadPool[thread_ID]; pthread_t pThread; int returnValue = pthread_create( &pThread, &attr, rcrackiThread::rcrackiThreadStaticEntryPointPthread, (void *) r_Thread); if( returnValue != 0 ) { printf("pThread creation failed, returnValue: %d\n", returnValue); } else { pThreads.push_back(pThread); } } //printf("%d r_Threads created\t\t\n", threadPool.size()); bool foundHashInThread = false; for (thread_ID = 0; thread_ID < threadPool.size(); thread_ID++) { rcrackiThread* rThread = threadPool[thread_ID]; pthread_t pThread = pThreads[thread_ID]; int returnValue = pthread_join(pThread, NULL); if( returnValue != 0 ) { printf("pThread join failed, returnValue: %d\n", returnValue); } nChainWalkStepDueToFalseAlarm += rThread->GetChainWalkStepDueToFalseAlarm(); nFalseAlarm += rThread->GetnFalseAlarm(); if (rThread->FoundHash() && !foundHashInThread) { printf("%-50s\r", ""); printf("plaintext of %s is %s\n", rThread->GetHash().c_str(), rThread->GetPlain().c_str()); if (writeOutput) { if (!writeResultLineToFile(outputFile, rThread->GetHash(), rThread->GetPlain(), rThread->GetBinary())) printf("Couldn't write this result to file!\n"); } hs.SetPlain(rThread->GetHash(), rThread->GetPlain(), rThread->GetBinary()); FILE* file; if ( ( file = fopen( sSessionPathName.c_str(), "a" ) ) != NULL ) { std::string buffer = "sHash=" + rThread->GetHash() + ":" + rThread->GetBinary() + ":" + rThread->GetPlain() + "\n"; fputs (buffer.c_str(), file); fclose (file); } m_cws.DiscardWalk(pStartPosIndexE); foundHashInThread = true; } //pthread delete rThread; } pThreads.clear(); threadPool.clear(); } printf("%-50s\r", ""); pThreads.clear(); threadPool.clear(); pthread_attr_destroy(&attr); if ( debug ) { std::cout << "Debug: chain walk step: " << nChainWalkStep << std::endl; std::cout << "Debug: false alarm: " << nFalseAlarm << std::endl; std::cout << "Debug: chain walk step due to false alarm: " << nChainWalkStepDueToFalseAlarm << std::endl; } m_nTotalChainWalkStep += nChainWalkStep; m_nTotalFalseAlarm += nFalseAlarm; m_nTotalChainWalkStepDueToFalseAlarm += nChainWalkStepDueToFalseAlarm; } void CCrackEngine::SearchRainbowTable( std::string pathName, CHashSet& hs ) { // Did we already go through this file in this session? if (resumeSession) { std::vector sessionFinishedPathNames; if (ReadLinesFromFile(sProgressPathName.c_str(), sessionFinishedPathNames)) { uint32_t i; for (i = 0; i < sessionFinishedPathNames.size(); i++) { if (sessionFinishedPathNames[i] == pathName) { std::cout << "Skipping " << pathName.c_str() << std::endl; return; } } } } // FileName #ifdef _WIN32 std::string::size_type nIndex = pathName.find_last_of('\\'); #else std::string::size_type nIndex = pathName.find_last_of('/'); #endif std::cout.precision(2); std::cout.setf(std::ios::fixed,std::ios::floatfield); std::string sFileName; if (nIndex != std::string::npos) sFileName = pathName.substr(nIndex + 1); else sFileName = pathName; // Info std::cout << sFileName.c_str() << std::endl; // Setup int nRainbowChainLen, nRainbowChainCount; if (!CChainWalkContext::SetupWithPathName( pathName, nRainbowChainLen, nRainbowChainCount) ) return; // Already finished? if (!hs.AnyHashLeftWithLen(CChainWalkContext::GetHashLen())) { std::cout << "this table contains hashes with length " << CChainWalkContext::GetHashLen() << " only" << std::endl; return; } bool fVerified = false; timeval tv; timeval tv2; timeval final; if( CChainWalkContext::getRTfileFormat() == getRTfileFormatId("RT") ) { RTReader *reader = new RTReader( pathName ); uint64_t nAllocatedSize = 0; unsigned int bytesForChainWalkSet = hs.GetStatHashTotal() * (nRainbowChainLen-1) * 8; if (debug) { std::cout << "Debug: Saving " << bytesForChainWalkSet << " bytes of memory for chainwalkset." << std::endl; std::cout << "Debug: This is a table in .rt format." << std::endl; } static CMemoryPool mp( bytesForChainWalkSet, debug, maxMem ); //uint64_t size = reader->getChainsLeft() * sizeof( RainbowChainO ); RainbowChainO* pChain = ( RainbowChainO* )mp.Allocate( reader->getDataFileSize() , nAllocatedSize ); if( debug ) { std::cout << "Debug: Allocate " << nAllocatedSize << " bytes, filelen " << reader->getDataFileSize() << std::endl; } if( pChain != NULL ) { // Round to sizeOfChain boundary nAllocatedSize = nAllocatedSize / sizeof( RainbowChainO ) * sizeof( RainbowChainO ); // XXX safe for now...fix to use uint64_t throughout uint32_t nChains = nAllocatedSize / sizeof( RainbowChainO ); while( reader->getChainsLeft() > 0 ) { gettimeofday( &tv, NULL ); if( reader->readChains( nChains, pChain ) == EXIT_FAILURE ) break; // Load table chunk if( debug ) std::cout << "Debug: reading..." << std::endl; gettimeofday( &tv2, NULL ); final = sub_timeofday( tv2, tv ); float fTime = 1.0f * final.tv_sec + 1.0f * final.tv_usec / 1000000; std::cout << (nChains * reader->getChainSize() ) << " bytes read, disk access time: " << fTime << "s" << std::endl; m_fTotalDiskAccessTime += fTime; // Verify table chunk if( debug && !fVerified ) { std::cout << "Debug: verify the file..." << std::endl; // Chain length test int nIndexToVerify = nChains / 2; CChainWalkContext cwc; cwc.SetIndex( pChain[nIndexToVerify].nIndexS ); int nPos; for( nPos = 0; nPos < nRainbowChainLen - 1; nPos++ ) { cwc.IndexToPlain(); cwc.PlainToHash(); cwc.HashToIndex(nPos); } if( cwc.GetIndex() != pChain[nIndexToVerify].nIndexE ) { std::cout << "rainbow chain length verify fail" << std::endl; break; } // Chain sort test uint32_t i; for( i = 0; i < nChains - 1; i++ ) { if( pChain[i].nIndexE > pChain[i + 1].nIndexE ) break; } if( i != nChains - 1 ) { std::cout << "this file is not sorted" << std::endl; break; } fVerified = true; } // Search table chunk gettimeofday( &tv, NULL ); SearchTableChunkOld( pChain, nRainbowChainLen, nChains, hs ); gettimeofday( &tv2, NULL ); final = sub_timeofday( tv2, tv ); fTime = 1.0f * final.tv_sec + 1.0f * final.tv_usec / 1000000; std::cout << "cryptanalysis time: " << fTime <<" s" << std::endl; m_fTotalCryptanalysisTime += fTime; // Already finished? if( !hs.AnyHashLeftWithLen( CChainWalkContext::GetHashLen() ) ) break; } } else std::cout << "memory allocation fail" << std::endl; // XXX // delete pChain; if( reader != NULL ) delete reader; } else if( CChainWalkContext::getRTfileFormat() == getRTfileFormatId("RTI") ) { RTIReader *reader = new RTIReader( pathName ); uint32_t sizeOfChain = reader->getChainSize(); uint64_t nAllocatedSize = 0; unsigned int bytesForChainWalkSet = hs.GetStatHashTotal() * (nRainbowChainLen-1) * 8; if (debug) { std::cout << "Debug: Saving " << bytesForChainWalkSet << " bytes of memory for chainwalkset." << std::endl; std::cout << "Debug: This is a table in .rti format." << std::endl; } static CMemoryPool mpIndex( bytesForChainWalkSet, debug, maxMem ); uint64_t nAllocatedSizeIndex; RTIrcrackiIndexChain *pIndex = (RTIrcrackiIndexChain*)mpIndex.Allocate( reader->getIndexFileSize(), nAllocatedSizeIndex ); if( debug ) { std::cout << "Debug: Allocated " << nAllocatedSizeIndex << " bytes for index with filelen " << reader->getIndexFileSize() << std::endl; } static CMemoryPool mp( bytesForChainWalkSet + nAllocatedSizeIndex, debug, maxMem ); if( pIndex != NULL && nAllocatedSizeIndex > 0 ) { // Round to sizeOfIndexChain boundary nAllocatedSizeIndex = nAllocatedSizeIndex / sizeof( RTIrcrackiIndexChain ) * sizeof( RTIrcrackiIndexChain ); fseek( reader->getIndexFileData(), 0, SEEK_SET ); // Index chunk read loop while( (unsigned)ftell( reader->getIndexFileData() ) != reader->getIndexFileSize() ) { // Load index chunk memset( pIndex, 0x00, nAllocatedSizeIndex ); std::cout << "reading index... "; gettimeofday( &tv, NULL ); unsigned int nDataRead = fread( pIndex, 1, nAllocatedSizeIndex, reader->getIndexFileData() ); gettimeofday( &tv2, NULL ); final = sub_timeofday( tv2, tv ); float fTime = 1.0f * final.tv_sec + 1.0f * final.tv_usec / 1000000; std::cout << nDataRead << " bytes read, disk access time: " << fTime << " s" << std::endl; m_fTotalDiskAccessTime += fTime; int nIndexChainCountRead = nDataRead / sizeof( RTIrcrackiIndexChain ); unsigned int nCoveredRainbowTableChains = 0; for( int i = 0; i < nIndexChainCountRead; i++ ) { nCoveredRainbowTableChains += pIndex[i].nChainCount; } RainbowChain* pChain = (RainbowChain*)mp.Allocate( nCoveredRainbowTableChains * sizeOfChain, nAllocatedSize ); if( debug ) { std::cout << "Debug: Allocated " << nAllocatedSize << " for " << nCoveredRainbowTableChains << " chains, filelen " << reader->getDataFileSize() << std::endl; } if( pChain != NULL && nAllocatedSize > 0 ) { // Round to sizeOfChain boundary nAllocatedSize = nAllocatedSize / sizeOfChain * sizeOfChain; uint32_t nProcessedChains = 0; // Chunk read loop while( (unsigned)ftell( reader->getDataFile() ) != reader->getDataFileSize() && nProcessedChains < nCoveredRainbowTableChains ) { // Load table chunk memset( pChain, 0x00, nAllocatedSize ); std::cout << "reading table... "; gettimeofday( &tv, NULL ); unsigned int nDataRead = fread( pChain, 1, nAllocatedSize, reader->getDataFile() ); gettimeofday( &tv2, NULL ); final = sub_timeofday( tv2, tv ); float fTime = 1.0f * final.tv_sec + 1.0f * final.tv_sec / 1000000; std::cout << nDataRead << " bytes read, disk access time: " << fTime << " s" << std::endl; m_fTotalDiskAccessTime += fTime; int nRainbowChainCountRead = nDataRead / sizeOfChain; // Verify table chunk (someone was too lazy to implement) if( debug && !fVerified ) { std::cout << "Debug: verifying the file..."; // Chain length test unsigned int nIndexToVerify = nRainbowChainCountRead / 2; CChainWalkContext cwc; uint64_t nIndexS; nIndexS = pChain[nIndexToVerify].nIndexS & 0x0000FFFFFFFFFFFFULL; // for first 6 bytes cwc.SetIndex( nIndexS ); int nPos; for( nPos = 0; nPos < nRainbowChainLen - 1; nPos++ ) { cwc.IndexToPlain(); cwc.PlainToHash(); cwc.HashToIndex( nPos ); } uint64_t nEndPoint = 0; for( int i = 0; i < nIndexChainCountRead; i++ ) { // Find matching index if( nIndexToVerify >= pIndex[i].nFirstChain && nIndexToVerify < pIndex[i].nFirstChain + pIndex[i].nChainCount ) { // Now we need to seek nIndexToVerify into the // chains // first 5 bytes nEndPoint += ( pIndex[i].nPrefix & 0x000000FFFFFFFFFFULL) << 16; nEndPoint += pChain[nIndexToVerify].nIndexE; break; } } if( cwc.GetIndex() != nEndPoint ) { std::cout << "rainbow chain length verify fail" << std::endl; break; } fVerified = true; std::cout << "ok" << std::endl; } // Search table chunk gettimeofday( &tv, NULL ); float preTime = m_fTotalCryptanalysisTime; SearchTableChunk( pChain, nRainbowChainLen, nRainbowChainCountRead, hs, pIndex, nIndexChainCountRead, nProcessedChains ); float postTime = m_fTotalCryptanalysisTime; gettimeofday( &tv2, NULL ); final = sub_timeofday( tv2, tv ); fTime = 1.0f * final.tv_sec + 1.0f * final.tv_usec / 1000000; std::cout << "cryptanalysis time: " << ( fTime + postTime - preTime ) << " s" << std::endl; m_fTotalCryptanalysisTime += fTime; nProcessedChains += nRainbowChainCountRead; // Already finished? if( !hs.AnyHashLeftWithLen( CChainWalkContext::GetHashLen() ) ) break; } } else std::cout << "memory allocation failed for rainbow table" << std::endl; } } // XXX // delete pChain if( reader != NULL ) delete reader; } else if( CChainWalkContext::getRTfileFormat() == getRTfileFormatId("RTI2") ) { RTI2Reader *reader = new RTI2Reader( pathName ); uint32_t sizeOfChain = reader->getChainSizeBytes(); uint64_t nAllocatedSize = 0; unsigned int bytesForChainWalkSet = hs.GetStatHashTotal() * (nRainbowChainLen-1) * 8; if (debug) { std::cout << "Debug: Saving " << bytesForChainWalkSet << " bytes of memory for chainwalkset." << std::endl; std::cout << "Debug: This is a table in .rti2 format." << std::endl; } static CMemoryPool mp( bytesForChainWalkSet, debug, maxMem ); uint64_t size = reader->getChainsLeft() * sizeof( RainbowChainO ); RainbowChainO* pChain = ( RainbowChainO* )mp.Allocate( size, nAllocatedSize ); if( debug ) { std::cout << "Debug: Allocate " << nAllocatedSize << " bytes, filelen " << GetFileLen( pathName ) << std::endl; } if( pChain != NULL ) { // Round to sizeOfChain boundary nAllocatedSize = nAllocatedSize / sizeof( RainbowChainO ) * sizeof( RainbowChainO ); // XXX safe for now...fix to use uint64_t throughout uint32_t nChains = nAllocatedSize / sizeof( RainbowChainO ); while( reader->getChainsLeft() > 0 ) { // Load table chunk if( debug ) std::cout << "Debug: reading..." << std::endl; gettimeofday( &tv, NULL ); reader->readChains( nChains, pChain ); gettimeofday( &tv2, NULL ); final = sub_timeofday( tv2, tv ); float fTime = 1.0f * final.tv_sec + 1.0f * final.tv_usec / 1000000; std::cout << (nChains * sizeOfChain ) << " bytes read, disk access time: " << fTime << "s" << std::endl; m_fTotalDiskAccessTime += fTime; // Verify table chunk if( debug && !fVerified ) { std::cout << "Debug: verify the file..." << std::endl; // Chain length test int nIndexToVerify = nChains / 2; CChainWalkContext cwc; cwc.SetIndex( pChain[nIndexToVerify].nIndexS ); int nPos; for( nPos = 0; nPos < nRainbowChainLen - 1; nPos++ ) { cwc.IndexToPlain(); cwc.PlainToHash(); cwc.HashToIndex(nPos); } if( cwc.GetIndex() != pChain[nIndexToVerify].nIndexE ) { std::cout << "rainbow chain length verify fail" << std::endl; break; } // Chain sort test uint32_t i; for( i = 0; i < nChains - 1; i++ ) { if( pChain[i].nIndexE > pChain[i + 1].nIndexE ) break; } if( i != nChains - 1 ) { std::cout << "this file is not sorted" << std::endl; break; } fVerified = true; } // Search table chunk gettimeofday( &tv, NULL ); SearchTableChunkOld( pChain, nRainbowChainLen, nChains, hs ); gettimeofday( &tv2, NULL ); final = sub_timeofday( tv2, tv ); fTime = 1.0f * final.tv_sec + 1.0f * final.tv_usec / 1000000; std::cout << "cryptanalysis time: " << fTime <<" s" << std::endl; m_fTotalCryptanalysisTime += fTime; // Already finished? if( !hs.AnyHashLeftWithLen( CChainWalkContext::GetHashLen() ) ) break; } } else std::cout << "memory allocation fail" << std::endl; // XXX // delete pChain; if( reader != NULL ) delete reader; } else std::cout << "Unsupported file format or corrupt table." << std::endl; /* if (debug) printf("Debug: writing progress to %s\n", sProgressPathName.c_str()); FILE* file; if ( ( file = fopen( sProgressPathName.c_str(), "a" ) ) != NULL ) { std::string buffer = pathName + std::endl; fputs (buffer.c_str(), file); fclose (file); } */ } void CCrackEngine::Run(std::vector vPathName, CHashSet& hs, int i_maxThreads, uint64_t i_maxMem, bool resume, bool bDebug, int gpu) { uint32_t i; #ifndef _WIN32 tty_init(); #endif resumeSession = resume; debug = bDebug; this->gpu = gpu; maxThreads = (gpu? 1 : i_maxThreads); maxMem = i_maxMem; // Reset statistics ResetStatistics(); // Sort vPathName (CChainWalkSet need it) std::sort(vPathName.begin(), vPathName.end()); // Run for (i = 0; i < vPathName.size() && hs.AnyhashLeft(); i++) { SearchRainbowTable(vPathName[i], hs); printf("\n"); } // delete precalc files if (!keepPrecalcFiles) m_cws.removePrecalcFiles(); #ifndef _WIN32 tty_done(); #endif } void CCrackEngine::setOutputFile(std::string pathName) { writeOutput = true; outputFile = pathName; } void CCrackEngine::setSession(std::string sSession, std::string sProgress, std::string sPrecalc, bool keepPrecalc) { sSessionPathName = sSession; sProgressPathName = sProgress; sPrecalcPathName = sPrecalc; keepPrecalcFiles = keepPrecalc; } float CCrackEngine::GetStatTotalDiskAccessTime() { return m_fTotalDiskAccessTime; } float CCrackEngine::GetStatTotalCryptanalysisTime() { return m_fTotalCryptanalysisTime; } float CCrackEngine::GetStatTotalPrecalculationTime() { return m_fTotalPrecalculationTime; } uint64_t CCrackEngine::GetStatTotalChainWalkStep() { return m_nTotalChainWalkStep; } uint64_t CCrackEngine::GetStatTotalFalseAlarm() { return m_nTotalFalseAlarm; } uint64_t CCrackEngine::GetStatTotalChainWalkStepDueToFalseAlarm() { return m_nTotalChainWalkStepDueToFalseAlarm; } rcracki-mt-0.7.0/rcracki_mt/ChainWalkSet.h0000640000175000017500000000470012043323152017654 0ustar dookiedookie/* * freerainbowtables is a project for generating, distributing, and using * perfect rainbow tables * * Copyright (C) Zhu Shuanglei * Copyright Martin Westergaard Jørgensen * Copyright 2009, 2010 Daniël Niggebrugge * Copyright 2009, 2010, 2011, 2012 James Nobis * * This file is part of freerainbowtables. * * freerainbowtables is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * freerainbowtables is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with freerainbowtables. If not, see . */ #ifndef _CHAINWALKSET_H #define _CHAINWALKSET_H #include "Public.h" struct ChainWalk { unsigned char Hash[MAX_HASH_LEN]; //int nHashLen; // Implied uint64_t* pIndexE; // mapStartPosIndexE, Len = nRainbowChainLen - 1 }; class CChainWalkSet { public: CChainWalkSet(); virtual ~CChainWalkSet(); private: std::string m_sHashRoutineName; // Discard all if not match std::string m_sPlainCharsetName; // Discard all if not match int m_nPlainLenMin; // Discard all if not match int m_nPlainLenMax; // Discard all if not match int m_nRainbowTableIndex; // Discard all if not match int m_nRainbowChainLen; // Discard all if not match std::list m_lChainWalk; bool debug; std::string sPrecalcPathName; int preCalcPart; std::vector vPrecalcFiles; private: void DiscardAll(); bool FindInFile(uint64_t* pIndexE, unsigned char* pHash, int nHashLen); std::string CheckOrRotatePreCalcFile(); void updateUsedPrecalcFiles(); public: uint64_t* RequestWalk( unsigned char* pHash, int nHashLen , std::string sHashRoutineName, std::string sPlainCharsetName , int nPlainLenMin, int nPlainLenMax, int nRainbowTableIndex , int nRainbowChainLen, bool& fNewlyGenerated, bool setDebug , std::string sPrecalc ); void DiscardWalk(uint64_t* pIndexE); void StoreToFile(uint64_t* pIndexE, unsigned char* pHash, int nHashLen); void removePrecalcFiles(); }; #endif rcracki-mt-0.7.0/rcracki_mt/RTCPReader.h0000640000175000017500000000312012043323152017225 0ustar dookiedookie/* * freerainbowtables is a project for generating, distributing, and using * perfect rainbow tables * * Copyright 2010, 2011 Martin Westergaard Jørgensen * Copyright 2010, 2011 James Nobis * * This file is part of freerainbowtables. * * freerainbowtables is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * freerainbowtables is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with freerainbowtables. If not, see . */ #ifndef _RTCPREADER_H #define _RTCPREADER_H #include #if defined(_WIN32) && !defined(__GNUC__) #include #endif #include "Public.h" #include "BaseRTReader.h" class RTCPReader { private: FILE *dataFile; uint32_t chainPosition; uint32_t chainSizeBytes; uint64_t minimumStartPoint; std::string filename; void setChainSizeBytes( uint32_t chainSizeBytes ); void setFilename( std::string filename ); public: RTCPReader( std::string filename ); ~RTCPReader() { }; void dump(); uint32_t getChainsLeft(); std::string getFilename(); int readChains(uint32_t &numChains, RainbowChainCP *pData); void setMinimumStartPoint(); }; #endif rcracki-mt-0.7.0/rcracki_mt/HashAlgorithm.h0000640000175000017500000000560112043323152020072 0ustar dookiedookie/* * freerainbowtables is a project for generating, distributing, and using * perfect rainbow tables * * Copyright (C) Zhu Shuanglei * Copyright Martin Westergaard Jørgensen * Copyright 2009, 2010 Daniël Niggebrugge * Copyright 2009, 2010, 2011, 2012 James Nobis * * This file is part of freerainbowtables. * * freerainbowtables is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * freerainbowtables is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with freerainbowtables. If not, see . */ #ifndef _HASHALGORITHM_H #define _HASHALGORITHM_H void HashLM(unsigned char* pPlain, int nPlainLen, unsigned char* pHash); void HashNTLM(unsigned char* pPlain, int nPlainLen, unsigned char* pHash); //void HashMD2(unsigned char* pPlain, int nPlainLen, unsigned char* pHash); void HashMD4(unsigned char* pPlain, int nPlainLen, unsigned char* pHash); void HashMD5(unsigned char* pPlain, int nPlainLen, unsigned char* pHash); void HashDoubleMD5(unsigned char* pPlain, int nPlainLen, unsigned char* pHash); void HashSHA1(unsigned char* pPlain, int nPlainLen, unsigned char* pHash); //void HashRIPEMD160(unsigned char* pPlain, int nPlainLen, unsigned char* pHash); void HashMSCACHE(unsigned char *pPlain, int nPlainLen, unsigned char* pHash); //**************************************************************************** // MySQL Password Hashing //**************************************************************************** void HashMySQL323(unsigned char* pPlain, int nPlainLen, unsigned char* pHash); void HashMySQLSHA1(unsigned char* pPlain, int nPlainLen, unsigned char* pHash); //**************************************************************************** // Cisco PIX Password Hashing //**************************************************************************** void HashPIX(unsigned char* pPlain, int nPlainLen, unsigned char* pHash); //**************************************************************************** // (HALF) LM CHALL hashing void HashLMCHALL(unsigned char* pPlain, int nPlainLen, unsigned char* pHash); void HashHALFLMCHALL(unsigned char* pPlain, int nPlainLen, unsigned char* pHash); // From mao void HashNTLMCHALL(unsigned char* pPlain, int nPlainLen, unsigned char* pHash); void HashORACLE(unsigned char* pPlain, int nPlainLen, unsigned char* pHash); #if !defined(_WIN32) || defined(__GNUC__) char *strupr(char *s1); #endif #endif rcracki-mt-0.7.0/rcracki_mt/RTCPReader.cpp0000640000175000017500000000437312043323152017573 0ustar dookiedookie/* * freerainbowtables is a project for generating, distributing, and using * perfect rainbow tables * * Copyright 2010, 2011 Martin Westergaard Jørgensen * Copyright 2010, 2011 James Nobis * * This file is part of freerainbowtables. * * freerainbowtables is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * freerainbowtables is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with freerainbowtables. If not, see . */ #include "RTCPReader.h" RTCPReader::RTCPReader( std::string filename ) { chainPosition = 0; // set it to the maximum possible value minimumStartPoint = (uint64_t)-1; setChainSizeBytes( 18 ); setFilename( filename ); dataFile = fopen( filename.c_str(), "rb" ); } void RTCPReader::dump() { } uint32_t RTCPReader::getChainsLeft() { return (GetFileLen( getFilename() ) / chainSizeBytes) - chainPosition; } std::string RTCPReader::getFilename() { return filename; } int RTCPReader::readChains(uint32_t &numChains, RainbowChainCP *pData) { unsigned int numRead = fread(pData, 1, chainSizeBytes * numChains, dataFile); numChains = numRead / chainSizeBytes; chainPosition += numChains; return 0; } void RTCPReader::setChainSizeBytes( uint32_t chainSizeBytes ) { this->chainSizeBytes = chainSizeBytes; } void RTCPReader::setFilename( std::string filename ) { this->filename = filename; } void RTCPReader::setMinimumStartPoint() { uint64_t tmpStartPoint; uint64_t tmpEndPoint; long originalFilePos = ftell( dataFile ); //fseek( dataFile, 0, SEEK_SET ); rewind( dataFile ); while ( !feof( dataFile ) ) { fread( &tmpStartPoint, 8, 1, dataFile ); fread( &tmpEndPoint, 8, 1, dataFile ); if ( tmpStartPoint < minimumStartPoint ) minimumStartPoint = tmpStartPoint; } fseek( dataFile, originalFilePos, SEEK_SET ); } rcracki-mt-0.7.0/rcracki_mt/HashRoutine.cpp0000640000175000017500000000600512043323152020123 0ustar dookiedookie/* * freerainbowtables is a project for generating, distributing, and using * perfect rainbow tables * * Copyright (C) Zhu Shuanglei * Copyright Martin Westergaard Jørgensen * Copyright 2009, 2010 Daniël Niggebrugge * Copyright 2009, 2010, 2011, 2012 James Nobis * Copyright 2011 Janosch Rux * * This file is part of freerainbowtables. * * freerainbowtables is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * freerainbowtables is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with freerainbowtables. If not, see . */ #include "HashRoutine.h" #include "HashAlgorithm.h" ////////////////////////////////////////////////////////////////////// CHashRoutine::CHashRoutine() { // Notice: MIN_HASH_LEN <= nHashLen <= MAX_HASH_LEN AddHashRoutine("lm", HashLM, 8, 14); AddHashRoutine("ntlm", HashNTLM, 16, 15); // AddHashRoutine("md2", HashMD2, 16); AddHashRoutine("md4", HashMD4, 16, 31); AddHashRoutine("md5", HashMD5, 16, -1); AddHashRoutine("doublemd5", HashDoubleMD5, 16, -1); AddHashRoutine("sha1", HashSHA1, 20, -1); // AddHashRoutine("ripemd160", HashRIPEMD160, 20); AddHashRoutine("mysql323", HashMySQL323, 8, -1); AddHashRoutine("mysqlsha1", HashMySQLSHA1, 20, -1); // AddHashRoutine("ciscopix", HashPIX, 16); // AddHashRoutine("mscache", HashMSCACHE, 16); AddHashRoutine("halflmchall", HashHALFLMCHALL, 8, -1); // Added from mao AddHashRoutine("lmchall", HashLMCHALL, 24, -1); AddHashRoutine("ntlmchall", HashNTLMCHALL, 24, -1); // AddHashRoutine("oracle", HashORACLE, 8, -1); } CHashRoutine::~CHashRoutine() { } void CHashRoutine::AddHashRoutine( std::string sHashRoutineName, HASHROUTINE pHashRoutine, int nHashLen, int nMaxPlainLen ) { vHashRoutineName.push_back(sHashRoutineName); vHashRoutine.push_back(pHashRoutine); vHashLen.push_back(nHashLen); vMaxPlainLen.push_back(nMaxPlainLen); } std::string CHashRoutine::GetAllHashRoutineName() { std::string sRet; uint32_t i; for (i = 0; i < vHashRoutineName.size(); i++) sRet += vHashRoutineName[i] + " "; return sRet; } /* std::vector CHashRoutine::GetAllHashRoutineNameV() { return vHashRoutineName; } */ void CHashRoutine::GetHashRoutine( std::string sHashRoutineName, HASHROUTINE& pHashRoutine, int& nHashLen ) { uint32_t i; for (i = 0; i < vHashRoutineName.size(); i++) { if (sHashRoutineName == vHashRoutineName[i]) { pHashRoutine = vHashRoutine[i]; nHashLen = vHashLen[i]; return; } } pHashRoutine = NULL; nHashLen = 0; } rcracki-mt-0.7.0/rcracki_mt/rcuda.h0000640000175000017500000000346312043323152016442 0ustar dookiedookie// freerainbowtables is a project for generating, distributing, and using // perfect rainbow tables // // Copyright 2010, 2011 Jan Kyska // Copyright 2010 Martin Westergaard Jørgensen // Copyright 2010, 2011, 2012 James Nobis // // This file is part of freerainbowtables. // // freerainbowtables is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 2 of the License, or // (at your option) any later version. // // freerainbowtables is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with freerainbowtables. If not, see . #ifndef RCUDA_H #define RCUDA_H #include "Public.h" namespace rcuda { enum RHash { RHASH_UNDEF = -1, RHASH_LM, RHASH_MD4, RHASH_MD5, RHASH_SHA1, RHASH_NTLM, RHASH_MYSQLSHA1 }; struct RCudaTask { RHash hash; uint64_t startIdx; int idxCount; unsigned int* dimVec; int dimVecSize; unsigned char* charSet; int charSetSize; int *cpPositions; int cpPosSize; int kernChainSize; uint64_t reduceOffset; uint64_t plainSpaceTotal; unsigned int rainbowChainLen; unsigned char *targetHash; }; extern "C" int SetCudaDevice(int device); extern "C" int GetChainsBufferSize(int minSize); extern "C" int CalcChainsOnCUDA(const RCudaTask* task, uint64_t *resultBuff); extern "C" int PreCalculateOnCUDA(const rcuda::RCudaTask* task, uint64_t *resultBuff); extern "C" int CheckAlarmOnCUDA(const rcuda::RCudaTask* task, uint64_t *resultBuff); } #endif //RCUDA_H rcracki-mt-0.7.0/rcracki_mt/RTI2Reader.h0000640000175000017500000000344612043323152017210 0ustar dookiedookie/* * freerainbowtables is a project for generating, distributing, and using * perfect rainbow tables * * Copyright 2010, 2011 Martin Westergaard Jørgensen * Copyright 2010, 2011, 2012 James Nobis * Copyright 2011 Logan Watt * * This file is part of freerainbowtables. * * freerainbowtables is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * freerainbowtables is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with freerainbowtables. If not, see . */ #ifndef _RTI2READER_H #define _RTI2READER_H #include "BaseRTReader.h" #include "RTI2Common.h" class RTI2Reader : public BaseRTReader { private: std::ifstream fin; uint32_t chainPosition; uint8_t indexOffset; RTI20_File in; RTI20_File_Header header; RTI20_Index index; uint8_t *data; uint32_t chainCount; uint32_t chainSizeBytes; std::vector subKeySpaces; std::vector checkPointPositions; int readRTI2String( std::ifstream &fin, void *str, uint32_t charSize = 0 ); protected: void setMinimumStartPoint(uint64_t); public: RTI2Reader( std::string filename ); ~RTI2Reader(); uint32_t getChainsLeft(); int readChains(uint32_t &numChains, RainbowChainO *pData); uint32_t getChainSizeBytes(); uint64_t getMinimumStartPoint(); void Dump(); }; #endif rcracki-mt-0.7.0/rcracki_mt/rcuda_ext.cpp0000640000175000017500000000544212043323152017654 0ustar dookiedookie// freerainbowtables is a project for generating, distributing, and using // perfect rainbow tables // // Copyright 2010, 2011 Jan Kyska // Copyright 2010 Martin Westergaard Jørgensen // Copyright 2010, 2011, 2012 James Nobis // // This file is part of freerainbowtables. // // freerainbowtables is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 2 of the License, or // (at your option) any later version. // // freerainbowtables is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with freerainbowtables. If not, see . #include "rcuda_ext.h" #include #include #include #include #include CudaCWCExtender::CudaCWCExtender(CChainWalkContext *cwc) { this->cwc = cwc; hash = rcuda::RHASH_UNDEF; } // sets rcuda kernel hash name // sets basic charset lengths and keyspaces per position of the plaintext // plainDimVec represents the primary data passed to CUDA void CudaCWCExtender::Init(void) { std::string hashName; int ii, jj; plainDimVec.clear(); plainCharSet.clear(); hashName = CChainWalkContext::m_sHashRoutineName; std::transform(hashName.begin(), hashName.end(), hashName.begin(), ::tolower); if(hashName.compare("lm") == 0) hash = rcuda::RHASH_LM; else if(hashName.compare("md4") == 0) hash = rcuda::RHASH_MD4; else if(hashName.compare("md5") == 0) hash = rcuda::RHASH_MD5; else if(hashName.compare("sha1") == 0) hash = rcuda::RHASH_SHA1; else if(hashName.compare("mysqlsha1") == 0) hash = rcuda::RHASH_MYSQLSHA1; else if(hashName.compare("ntlm") == 0) hash = rcuda::RHASH_NTLM; else hash = rcuda::RHASH_UNDEF; for(ii = (int)CChainWalkContext::m_vCharset.size()-1; !(ii < 0); ii--) { stCharset &chs = CChainWalkContext::m_vCharset[ii]; int chSetOffset = plainCharSet.size(); plainCharSet.append((char*)chs.m_PlainCharset, chs.m_nPlainCharsetLen); uint64_t plainSpace = 1; for(jj = 0; jj < ii; jj++) plainSpace *= CChainWalkContext::m_vCharset[jj].m_nPlainSpaceTotal; plainDimVec.push_back((unsigned int)plainSpace); plainDimVec.push_back((unsigned int)(plainSpace>>32)); for(jj = 0; jj < chs.m_nPlainLenMax; jj++) { plainDimVec.push_back((unsigned int)chs.m_nPlainCharsetLen|((unsigned int)chSetOffset<<16)|(jj * Copyright 2009, 2010, 2011, 2012 James Nobis * * This file is part of rcracki_mt. * * rcracki_mt is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * rcracki_mt is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with rcracki_mt. If not, see . */ #include "lm2ntlm.h" LM2NTLMcorrector::LM2NTLMcorrector() { progressCurrentCombination = 0; totalCurrentCombination = 1; counterOverall = 0; countCombinations = 0; countTotalCombinations = 0; counter = 0; fillMapW(); aborting = false; sBinary = ""; } std::string LM2NTLMcorrector::getBinary() { return sBinary; } bool LM2NTLMcorrector::LMPasswordCorrectUnicode( std::string hexPassword, unsigned char* pNTLMHash, std::string& sNTLMPassword ) //, unsigned char* pLMPassword { std::string sPlain = ""; uint32_t i; for (i = 0; i < hexPassword.size() / 2; i++) { std::string sSub = hexPassword.substr(i * 2, 2); int nValue; sscanf(sSub.c_str(), "%02x", &nValue); sPlain += (unsigned char)nValue; } memcpy(NTLMHash, pNTLMHash, MD4_DIGEST_LENGTH); unsigned long int tmpLength = sPlain.size() * 2; unsigned char* pLMPassword = new unsigned char[tmpLength]; //printf("Searching for unicode password.\n"); //printf("NTLM hash: %s\n\n", sNTLMHash.c_str()); setvbuf(stdout, NULL, _IONBF,0); gettimeofday( &tvStart, NULL ); previousClock = clock(); #ifndef _WIN32 tty_init(); #endif if (startCorrecting(sPlain, sNTLMPassword, pLMPassword)) { sBinary = ByteToStr(pLMPassword, tmpLength).c_str(); //printf("\nFound unicode password: %s\n", sNTLMPassword.c_str()); //printf("Password in hex: %s\n", sBinary.c_str()); writeEndStats(); #ifndef _WIN32 tty_done(); #endif return true; } else { //printf("\ncase correction for password %s fail!\n", sPlain.c_str()); writeEndStats(); #ifndef _WIN32 tty_done(); #endif return false; } } bool LM2NTLMcorrector::startCorrecting( std::string sLMPassword, std::string& sNTLMPassword, unsigned char* pLMPassword ) { if (sLMPassword.size() == 0) { sNTLMPassword = ""; return true; } std::string muteMe = sLMPassword; int length = muteMe.size(); unsigned char* pMuteMe = new unsigned char[length]; unsigned char* pTempMute = new unsigned char[length * 2]; int i; for (i = 0; i < length; i++) { pMuteMe[i] = muteMe[i]; pTempMute[i * 2 ] = muteMe[i]; pTempMute[i * 2 + 1] = 0x00; unsigned char muteChar = pMuteMe[i]; int sizeMapForChar = m_mapChar[muteChar].size(); int j; for (j = 0; j < sizeMapForChar; j++) { currentCharmap[i][j] = m_mapChar[muteChar][j]; } } int* jAtPos = new int[length]; int* sizeAtPos = new int[length]; bool* fullAtPos = new bool[length]; int setSize; for (setSize = 0; setSize <= length; setSize++) { int cntFull = 0; // clear all 'fullatpos' before new setSize int i; for (i=0; i < length; i++) { fullAtPos[i] = false; } //printf("Trying full unicode map for %d/%d characters...\t\t\n", setSize, length); printf("Trying full unicode map for %d/%d characters...%-20s\n", setSize, length, ""); bool notFirst = true; // start at end and set 'full' combination countCombinations = 0; countTotalCombinations = calculateTotalCombinations(length, setSize); int sPos = length - 1; while (sPos >= 0 && notFirst) // finding combinations for current 'setSize' { if (aborting) return false; if (cntFull < setSize) { if (fullAtPos[sPos] == false) { fullAtPos[sPos] = true; cntFull++; } sPos--; } else { if (fullAtPos[sPos] == false && setSize > 0) { fullAtPos[sPos] = true; cntFull++; // reset positions after sPos int k; for (k = sPos+1; k < length; k++) { if (fullAtPos[k] == true) { fullAtPos[k] = false; cntFull--; } } // start at end again sPos = length - 1; } else { sPos--; } } // we have a combination if (cntFull == setSize) { countCombinations++; setupCombinationAtPositions(length, pMuteMe, pTempMute, jAtPos, fullAtPos, sizeAtPos); if (checkPermutations(length, pTempMute, jAtPos, sizeAtPos, pLMPassword, sNTLMPassword)) { return true; } } if (setSize == 0) notFirst = false; } } return false; } // set up combination at positions void LM2NTLMcorrector::setupCombinationAtPositions(int length, unsigned char* pMuteMe, unsigned char* pTempMute, int* jAtPos, bool* fullAtPos, int* sizeAtPos) { progressCurrentCombination = 0; totalCurrentCombination = 1; int i; for (i=0; i < length; i++) { pTempMute[i*2] = currentCharmap[i][0]; pTempMute[i*2+1] = currentCharmap[i][1]; // reset to first char in map jAtPos[i] = 0; // reset charcounter for this char (that is all chars) // based on combination, set full map or only upper/lowercase if (fullAtPos[i] == true) { unsigned char muteChar = pMuteMe[i]; long unsigned int sizeMapForChar = m_mapChar[muteChar].size()/2; // 2 bytes per char sizeAtPos[i] = sizeMapForChar; } else { sizeAtPos[i] = 2; } totalCurrentCombination *= sizeAtPos[i]; } //printf("Trying %"PRIu64" passwords for current combination\t\t\r", totalCurrentCombination); } // go check all permutations for this combination bool LM2NTLMcorrector::checkPermutations( int length, unsigned char* pTempMute, int* jAtPos, int* sizeAtPos, unsigned char* pLMPassword, std::string& sNTLMPassword ) { int pos = length - 1; while (pos >= 0) { counter++; pos = length - 1; int jAtCurPos = jAtPos[pos]; int sizeMapForCharPos = sizeAtPos[pos]; // move to start of string and find character with permutations left while (jAtCurPos >= sizeMapForCharPos-1 && pos >= -1) { pos--; if (pos >= 0 ) { jAtCurPos = jAtPos[pos]; sizeMapForCharPos = sizeAtPos[pos]; } } if (pos < 0) continue; // next permutation for character jAtCurPos++; jAtPos[pos] = jAtCurPos; pTempMute[pos*2] = currentCharmap[pos][jAtCurPos*2]; pTempMute[pos*2+1] = currentCharmap[pos][jAtCurPos*2+1]; // reset positions after pos int k; for (k = pos+1; k < length; k++) { jAtPos[k] = 0; pTempMute[k*2] = currentCharmap[k][0]; // reset to first char in map pTempMute[k*2+1] = currentCharmap[k][1]; } if (checkNTLMPassword(pTempMute, length, sNTLMPassword) == true) { int i; for (i = 0; i < length*2; i++) pLMPassword[i] = pTempMute[i]; return true; } if (counter > 10000) // don't check clocks too often { gettimeofday( &tvEnd, NULL ); tvFinal = sub_timeofday( tvEnd, tvStart ); clock_t currentClock = clock(); float fTime = 1.0f * (currentClock - previousClock); if (fTime > 1.0f * CLOCKS_PER_SEC) { float progressPercentageCurrentCombination = progressCurrentCombination * 100.0f / totalCurrentCombination; float fTime = 1.0f * tvFinal.tv_sec + 1.0f * tvFinal.tv_usec / 1000000; float currentSpeed = (counterOverall + progressCurrentCombination) / fTime / 1000000; //printf("%.2f%% of combination %d/%d (%.2f Mhashes/s)\t\t\t\t\r", progressPercentageCurrentCombination, countCombinations, countTotalCombinations, currentSpeed); printf("%.2f%% of combination %d/%d (%.2f Mhashes/s)%-30s\r", progressPercentageCurrentCombination, countCombinations, countTotalCombinations, currentSpeed, ""); previousClock = clock(); #ifdef _WIN32 if (_kbhit()) { int ch = _getch(); ch = toupper(ch); if (ch == 'S') { aborting = true; printf( "\nAborting unicode correction for this hash...\n"); } else { printf( "\nPress 'S' to skip unicode correction for this hash...\n"); } } #else int c = tty_getchar(); if (c >= 0) { tty_flush(); if (c==115) { // = s aborting = true; printf( "\nAborting unicode correction for this hash...\n"); } else { printf( "\nPress 's' to skip unicode correction for this hash...\n"); } } #endif if (aborting) return false; } counter = 0; } progressCurrentCombination++; counterOverall++; } return false; } // check password, maybe integrate this function in checkPermutations() for performance reasons. bool LM2NTLMcorrector::checkNTLMPassword( unsigned char* pLMPassword, int nLMPasswordLen, std::string& sNTLMPassword ) { unsigned char md[MD4_DIGEST_LENGTH]; MD4_NEW( pLMPassword, nLMPasswordLen * 2, md ); if (memcmp(md, NTLMHash, MD4_DIGEST_LENGTH) == 0) { sNTLMPassword = ""; int i; for (i = 0; i < nLMPasswordLen; i++) { sNTLMPassword += char(pLMPassword[i * 2]); } return true; } else return false; } void LM2NTLMcorrector::checkAbort() { #ifdef _WIN32 if (_kbhit()) { int ch = _getch(); ch = toupper(ch); if (ch == 'S') { aborting = true; printf( "\nAborting unicode correction for this hash...\n"); } else { printf( "\nPress 'S' to skip unicode correction for this hash...\n"); } } #endif } void LM2NTLMcorrector::writeEndStats() { gettimeofday( &tvEnd, NULL ); tvFinal = sub_timeofday( tvEnd, tvStart ); float fTime = 1.0f * tvFinal.tv_sec + 1.0f * tvFinal.tv_usec / 1000000; float speedOverall = counterOverall / fTime / 1000000; printf("\nTried %s passwords in %.2f s (%.2f Mhashes/s)\n", uint64tostr(counterOverall).c_str(), fTime, speedOverall); printf("\n"); } int LM2NTLMcorrector::calculateTotalCombinations(int length, int setSize) { return factorial(length) / (factorial(setSize) * factorial(length-setSize)); } uint64_t LM2NTLMcorrector::factorial (int num) { uint64_t result = 1; while ( num > 1 ) { result *= num; num--; } return result; } // convert some bytes into a string std::string LM2NTLMcorrector::ByteToStr(const unsigned char* pData, int nLen) { std::string sRet = ""; int i; for (i = 0; i < nLen/2; i++) { char szByte[3]; sprintf(szByte, "%02x", pData[i*2+1]); // swap 2-byte characters again sRet += szByte; sprintf(szByte, "%02x", pData[i*2]); sRet += szByte; } return sRet; } void LM2NTLMcorrector::addToMapW(unsigned char key, unsigned char value1, unsigned char value2) { unsigned long int cnt = m_mapChar[key].size(); m_mapChar[key][cnt] = value2; m_mapChar[key][cnt+1] = value1; //reverse for endiannes } // construct the mappings, would be nicer in a separate (importable) file void LM2NTLMcorrector::fillMapW() { addToMapW(0x01, 0x00, 0x01); addToMapW(0x01, 0x26, 0x3A); addToMapW(0x02, 0x00, 0x02); addToMapW(0x02, 0x26, 0x3B); addToMapW(0x03, 0x00, 0x03); addToMapW(0x03, 0x26, 0x65); addToMapW(0x04, 0x00, 0x04); addToMapW(0x04, 0x26, 0x66); addToMapW(0x05, 0x00, 0x05); addToMapW(0x05, 0x26, 0x63); addToMapW(0x06, 0x00, 0x06); addToMapW(0x06, 0x26, 0x60); addToMapW(0x07, 0x00, 0x07); addToMapW(0x07, 0x00, 0xB7); addToMapW(0x07, 0x20, 0x22); addToMapW(0x07, 0x20, 0x24); addToMapW(0x07, 0x20, 0x26); addToMapW(0x07, 0x22, 0x19); addToMapW(0x07, 0x22, 0xC5); addToMapW(0x07, 0x30, 0xFB); addToMapW(0x08, 0x00, 0x08); addToMapW(0x08, 0x25, 0xD8); addToMapW(0x09, 0x00, 0x09); addToMapW(0x09, 0x20, 0xDD); addToMapW(0x09, 0x25, 0xCB); addToMapW(0x09, 0x30, 0x07); addToMapW(0x0a, 0x00, 0x0A); addToMapW(0x0a, 0x25, 0xD9); addToMapW(0x0b, 0x00, 0x0B); addToMapW(0x0b, 0x26, 0x42); addToMapW(0x0c, 0x00, 0x0C); addToMapW(0x0c, 0x26, 0x40); addToMapW(0x0d, 0x00, 0x0D); addToMapW(0x0d, 0x26, 0x6A); addToMapW(0x0e, 0x00, 0x0E); addToMapW(0x0e, 0x26, 0x6B); addToMapW(0x0f, 0x00, 0x0F); addToMapW(0x0f, 0x00, 0xA4); addToMapW(0x0f, 0x26, 0x3C); addToMapW(0x10, 0x00, 0x10); addToMapW(0x10, 0x25, 0xBA); addToMapW(0x11, 0x00, 0x11); addToMapW(0x11, 0x25, 0xC4); addToMapW(0x12, 0x00, 0x12); addToMapW(0x12, 0x21, 0x95); addToMapW(0x13, 0x00, 0x13); addToMapW(0x13, 0x20, 0x3C); addToMapW(0x14, 0x00, 0x14); addToMapW(0x14, 0x00, 0xB6); addToMapW(0x15, 0x00, 0x15); addToMapW(0x15, 0x00, 0xA7); addToMapW(0x16, 0x00, 0x16); addToMapW(0x16, 0x02, 0xC9); addToMapW(0x16, 0x25, 0xAC); addToMapW(0x17, 0x00, 0x17); addToMapW(0x17, 0x21, 0xA8); addToMapW(0x18, 0x00, 0x18); addToMapW(0x18, 0x21, 0x91); addToMapW(0x19, 0x00, 0x19); addToMapW(0x19, 0x21, 0x93); addToMapW(0x1a, 0x00, 0x1A); addToMapW(0x1a, 0x21, 0x92); addToMapW(0x1b, 0x00, 0x1B); addToMapW(0x1b, 0x21, 0x90); addToMapW(0x1c, 0x00, 0x1C); addToMapW(0x1c, 0x22, 0x1F); addToMapW(0x1d, 0x00, 0x1D); addToMapW(0x1d, 0x21, 0x94); addToMapW(0x1e, 0x00, 0x1E); addToMapW(0x1e, 0x25, 0xB2); addToMapW(0x1f, 0x00, 0x1F); addToMapW(0x1f, 0x25, 0xBC); addToMapW(0x20, 0x00, 0x20); addToMapW(0x20, 0x20, 0x00); addToMapW(0x20, 0x20, 0x01); addToMapW(0x20, 0x20, 0x02); addToMapW(0x20, 0x20, 0x03); addToMapW(0x20, 0x20, 0x04); addToMapW(0x20, 0x20, 0x05); addToMapW(0x20, 0x20, 0x06); addToMapW(0x20, 0x30, 0x00); addToMapW(0x21, 0x00, 0x21); addToMapW(0x21, 0x00, 0xA1); addToMapW(0x21, 0x01, 0xC3); addToMapW(0x21, 0xFF, 0x01); addToMapW(0x22, 0x00, 0x22); addToMapW(0x22, 0x00, 0xA8); addToMapW(0x22, 0x02, 0xBA); addToMapW(0x22, 0x03, 0x08); addToMapW(0x22, 0x03, 0x0E); addToMapW(0x22, 0x20, 0x1C); addToMapW(0x22, 0x20, 0x1D); addToMapW(0x22, 0x20, 0x1E); addToMapW(0x22, 0x20, 0x33); addToMapW(0x22, 0x20, 0x35); addToMapW(0x22, 0x27, 0x5D); addToMapW(0x22, 0x27, 0x5E); addToMapW(0x22, 0x30, 0x1D); addToMapW(0x22, 0x30, 0x1E); addToMapW(0x22, 0x30, 0x1F); addToMapW(0x22, 0xFF, 0x02); addToMapW(0x23, 0x00, 0x23); addToMapW(0x23, 0xFF, 0x03); addToMapW(0x24, 0x00, 0x24); addToMapW(0x24, 0xFF, 0x04); addToMapW(0x25, 0x00, 0x25); addToMapW(0x25, 0x06, 0x6A); addToMapW(0x25, 0x20, 0x30); addToMapW(0x25, 0xFF, 0x05); addToMapW(0x26, 0x00, 0x26); addToMapW(0x26, 0xFF, 0x06); addToMapW(0x27, 0x00, 0x27); addToMapW(0x27, 0x00, 0xB4); addToMapW(0x27, 0x02, 0xB9); addToMapW(0x27, 0x02, 0xBB); addToMapW(0x27, 0x02, 0xBC); addToMapW(0x27, 0x02, 0xC8); addToMapW(0x27, 0x02, 0xCA); addToMapW(0x27, 0x02, 0xCB); addToMapW(0x27, 0x03, 0x00); addToMapW(0x27, 0x03, 0x01); addToMapW(0x27, 0x20, 0x18); addToMapW(0x27, 0x20, 0x19); addToMapW(0x27, 0x20, 0x1A); addToMapW(0x27, 0x20, 0x32); addToMapW(0x27, 0x27, 0x5B); addToMapW(0x27, 0x27, 0x5C); addToMapW(0x27, 0xFF, 0x07); addToMapW(0x28, 0x00, 0x28); addToMapW(0x28, 0x23, 0x20); addToMapW(0x28, 0xFF, 0x08); addToMapW(0x29, 0x00, 0x29); addToMapW(0x29, 0x23, 0x21); addToMapW(0x29, 0xFF, 0x09); addToMapW(0x2a, 0x00, 0x2A); addToMapW(0x2a, 0x22, 0x17); addToMapW(0x2a, 0xFF, 0x0A); addToMapW(0x2b, 0x00, 0x2B); addToMapW(0x2b, 0x00, 0xB1); addToMapW(0x2b, 0x20, 0x20); addToMapW(0x2b, 0x20, 0x21); addToMapW(0x2b, 0xFF, 0x0B); addToMapW(0x2c, 0x00, 0x2C); addToMapW(0x2c, 0x00, 0xB8); addToMapW(0x2c, 0x03, 0x27); addToMapW(0x2c, 0x20, 0x1A); addToMapW(0x2c, 0x20, 0x1E); addToMapW(0x2c, 0xFF, 0x0C); addToMapW(0x2d, 0x00, 0x2D); addToMapW(0x2d, 0x00, 0xAC); addToMapW(0x2d, 0x00, 0xAD); addToMapW(0x2d, 0x20, 0x10); addToMapW(0x2d, 0x20, 0x11); addToMapW(0x2d, 0x20, 0x13); addToMapW(0x2d, 0x20, 0x14); addToMapW(0x2d, 0x22, 0x12); addToMapW(0x2d, 0x22, 0x13); addToMapW(0x2d, 0xFF, 0x0D); addToMapW(0x2e, 0x00, 0x2E); addToMapW(0x2e, 0x20, 0x26); addToMapW(0x2e, 0xFF, 0x0E); addToMapW(0x2f, 0x00, 0x2F); addToMapW(0x2f, 0x20, 0x44); addToMapW(0x2f, 0x22, 0x15); addToMapW(0x2f, 0x22, 0x16); addToMapW(0x2f, 0xFF, 0x0F); addToMapW(0x30, 0x00, 0x30); addToMapW(0x30, 0x20, 0x70); addToMapW(0x30, 0x20, 0x80); addToMapW(0x30, 0xFF, 0x10); addToMapW(0x31, 0x00, 0x31); addToMapW(0x31, 0x00, 0xB9); addToMapW(0x31, 0x00, 0xBC); addToMapW(0x31, 0x00, 0xBD); addToMapW(0x31, 0x20, 0x81); addToMapW(0x31, 0xFF, 0x11); addToMapW(0x32, 0x00, 0x32); addToMapW(0x32, 0x00, 0xB2); addToMapW(0x32, 0x20, 0x82); addToMapW(0x32, 0xFF, 0x12); addToMapW(0x33, 0x00, 0x33); addToMapW(0x33, 0x00, 0xB3); addToMapW(0x33, 0x00, 0xBE); addToMapW(0x33, 0x20, 0x83); addToMapW(0x33, 0xFF, 0x13); addToMapW(0x34, 0x00, 0x34); addToMapW(0x34, 0x20, 0x74); addToMapW(0x34, 0x20, 0x84); addToMapW(0x34, 0xFF, 0x14); addToMapW(0x35, 0x00, 0x35); addToMapW(0x35, 0x20, 0x75); addToMapW(0x35, 0x20, 0x85); addToMapW(0x35, 0xFF, 0x15); addToMapW(0x36, 0x00, 0x36); addToMapW(0x36, 0x20, 0x76); addToMapW(0x36, 0x20, 0x86); addToMapW(0x36, 0xFF, 0x16); addToMapW(0x37, 0x00, 0x37); addToMapW(0x37, 0x20, 0x77); addToMapW(0x37, 0x20, 0x87); addToMapW(0x37, 0xFF, 0x17); addToMapW(0x38, 0x00, 0x38); addToMapW(0x38, 0x20, 0x78); addToMapW(0x38, 0x20, 0x88); addToMapW(0x38, 0x22, 0x1E); addToMapW(0x38, 0xFF, 0x18); addToMapW(0x39, 0x00, 0x39); addToMapW(0x39, 0x20, 0x78); addToMapW(0x39, 0x20, 0x89); addToMapW(0x39, 0xFF, 0x19); addToMapW(0x3a, 0x00, 0x3A); addToMapW(0x3a, 0x05, 0x89); addToMapW(0x3a, 0x20, 0x26); addToMapW(0x3a, 0x22, 0x36); addToMapW(0x3a, 0xFF, 0x1A); addToMapW(0x3b, 0x00, 0x3B); addToMapW(0x3b, 0x03, 0x7E); addToMapW(0x3b, 0xFF, 0x1B); addToMapW(0x3c, 0x00, 0x3C); addToMapW(0x3c, 0x00, 0xAB); addToMapW(0x3c, 0x20, 0x39); addToMapW(0x3c, 0x23, 0x29); addToMapW(0x3c, 0x30, 0x08); addToMapW(0x3c, 0xFF, 0x1C); addToMapW(0x3d, 0x00, 0x3D); addToMapW(0x3d, 0x22, 0x61); addToMapW(0x3d, 0x22, 0x64); addToMapW(0x3d, 0x22, 0x65); addToMapW(0x3d, 0xFF, 0x1D); addToMapW(0x3e, 0x00, 0x3E); addToMapW(0x3e, 0x00, 0xBB); addToMapW(0x3e, 0x20, 0x3A); addToMapW(0x3e, 0x23, 0x2A); addToMapW(0x3e, 0x30, 0x09); addToMapW(0x3e, 0xFF, 0x1E); addToMapW(0x3f, 0x00, 0x3F); addToMapW(0x40, 0x00, 0x40); addToMapW(0x40, 0xFF, 0x20); addToMapW(0x41, 0x00, 0x41); addToMapW(0x41, 0x00, 0x61); addToMapW(0x41, 0x00, 0xAA); addToMapW(0x41, 0x00, 0xC0); addToMapW(0x41, 0x00, 0xC1); addToMapW(0x41, 0x00, 0xC2); addToMapW(0x41, 0x00, 0xC3); addToMapW(0x41, 0x00, 0xC4); addToMapW(0x41, 0x00, 0xC5); addToMapW(0x41, 0x00, 0xC6); addToMapW(0x41, 0x00, 0xE0); addToMapW(0x41, 0x00, 0xE1); addToMapW(0x41, 0x00, 0xE2); addToMapW(0x41, 0x00, 0xE3); addToMapW(0x41, 0x00, 0xE4); addToMapW(0x41, 0x00, 0xE5); addToMapW(0x41, 0x00, 0xE6); addToMapW(0x41, 0x01, 0x00); addToMapW(0x41, 0x01, 0x01); addToMapW(0x41, 0x01, 0x02); addToMapW(0x41, 0x01, 0x03); addToMapW(0x41, 0x01, 0x04); addToMapW(0x41, 0x01, 0x05); addToMapW(0x41, 0x01, 0xCD); addToMapW(0x41, 0x01, 0xCE); addToMapW(0x41, 0x01, 0xDE); addToMapW(0x41, 0x01, 0xDF); addToMapW(0x41, 0x03, 0xB1); addToMapW(0x41, 0x21, 0x2B); addToMapW(0x41, 0xFF, 0x21); addToMapW(0x41, 0xFF, 0x41); addToMapW(0x42, 0x00, 0x42); addToMapW(0x42, 0x00, 0x62); addToMapW(0x42, 0x01, 0x80); addToMapW(0x42, 0x21, 0x2C); addToMapW(0x42, 0xFF, 0x22); addToMapW(0x42, 0xFF, 0x42); addToMapW(0x43, 0x00, 0x43); addToMapW(0x43, 0x00, 0x63); addToMapW(0x43, 0x00, 0xA2); addToMapW(0x43, 0x00, 0xA9); addToMapW(0x43, 0x00, 0xC7); addToMapW(0x43, 0x00, 0xE7); addToMapW(0x43, 0x00, 0xE8); addToMapW(0x43, 0x01, 0x06); addToMapW(0x43, 0x01, 0x07); addToMapW(0x43, 0x01, 0x08); addToMapW(0x43, 0x01, 0x09); addToMapW(0x43, 0x01, 0x0A); addToMapW(0x43, 0x01, 0x0B); addToMapW(0x43, 0x01, 0x0C); addToMapW(0x43, 0x01, 0x0D); addToMapW(0x43, 0x21, 0x02); addToMapW(0x43, 0x21, 0x2D); addToMapW(0x43, 0xFF, 0x23); addToMapW(0x43, 0xFF, 0x43); addToMapW(0x44, 0x00, 0x44); addToMapW(0x44, 0x00, 0x64); addToMapW(0x44, 0x00, 0xD0); addToMapW(0x44, 0x00, 0xF0); addToMapW(0x44, 0x01, 0x0E); addToMapW(0x44, 0x01, 0x0F); addToMapW(0x44, 0x01, 0x10); addToMapW(0x44, 0x01, 0x11); addToMapW(0x44, 0x01, 0x89); addToMapW(0x44, 0x03, 0xB4); addToMapW(0x44, 0x26, 0x6A); addToMapW(0x44, 0x26, 0x6B); addToMapW(0x44, 0xFF, 0x24); addToMapW(0x44, 0xFF, 0x44); addToMapW(0x45, 0x00, 0x45); addToMapW(0x45, 0x00, 0x65); addToMapW(0x45, 0x00, 0xC8); addToMapW(0x45, 0x00, 0xC9); addToMapW(0x45, 0x00, 0xCA); addToMapW(0x45, 0x00, 0xCB); addToMapW(0x45, 0x00, 0xE8); addToMapW(0x45, 0x00, 0xE9); addToMapW(0x45, 0x00, 0xEA); addToMapW(0x45, 0x00, 0xEB); addToMapW(0x45, 0x01, 0x12); addToMapW(0x45, 0x01, 0x13); addToMapW(0x45, 0x01, 0x14); addToMapW(0x45, 0x01, 0x15); addToMapW(0x45, 0x01, 0x16); addToMapW(0x45, 0x01, 0x17); addToMapW(0x45, 0x01, 0x18); addToMapW(0x45, 0x01, 0x19); addToMapW(0x45, 0x01, 0x1A); addToMapW(0x45, 0x01, 0x1B); addToMapW(0x45, 0x03, 0xB5); addToMapW(0x45, 0x21, 0x07); addToMapW(0x45, 0x21, 0x2E); addToMapW(0x45, 0x21, 0x2F); addToMapW(0x45, 0x21, 0x30); addToMapW(0x45, 0xFF, 0x25); addToMapW(0x45, 0xFF, 0x45); addToMapW(0x46, 0x00, 0x46); addToMapW(0x46, 0x00, 0x66); addToMapW(0x46, 0x01, 0x91); addToMapW(0x46, 0x01, 0x92); addToMapW(0x46, 0x03, 0xA6); addToMapW(0x46, 0x03, 0xC6); addToMapW(0x46, 0x21, 0x31); addToMapW(0x46, 0xFF, 0x26); addToMapW(0x46, 0xFF, 0x46); addToMapW(0x47, 0x00, 0x47); addToMapW(0x47, 0x00, 0x67); addToMapW(0x47, 0x01, 0x1C); addToMapW(0x47, 0x01, 0x1D); addToMapW(0x47, 0x01, 0x1E); addToMapW(0x47, 0x01, 0x1F); addToMapW(0x47, 0x01, 0x20); addToMapW(0x47, 0x01, 0x21); addToMapW(0x47, 0x01, 0x22); addToMapW(0x47, 0x01, 0x23); addToMapW(0x47, 0x01, 0xE4); addToMapW(0x47, 0x01, 0xE5); addToMapW(0x47, 0x01, 0xE6); addToMapW(0x47, 0x01, 0xE7); addToMapW(0x47, 0x02, 0x61); addToMapW(0x47, 0x03, 0x93); addToMapW(0x47, 0x21, 0x0A); addToMapW(0x47, 0xFF, 0x27); addToMapW(0x47, 0xFF, 0x47); addToMapW(0x48, 0x00, 0x48); addToMapW(0x48, 0x00, 0x68); addToMapW(0x48, 0x01, 0x24); addToMapW(0x48, 0x01, 0x25); addToMapW(0x48, 0x01, 0x26); addToMapW(0x48, 0x01, 0x27); addToMapW(0x48, 0x04, 0xBB); addToMapW(0x48, 0x21, 0x0B); addToMapW(0x48, 0x21, 0x0C); addToMapW(0x48, 0x21, 0x0D); addToMapW(0x48, 0x21, 0x0E); addToMapW(0x48, 0xFF, 0x28); addToMapW(0x48, 0xFF, 0x48); addToMapW(0x49, 0x00, 0x49); addToMapW(0x49, 0x00, 0x69); addToMapW(0x49, 0x00, 0xCC); addToMapW(0x49, 0x00, 0xCD); addToMapW(0x49, 0x00, 0xCE); addToMapW(0x49, 0x00, 0xCF); addToMapW(0x49, 0x00, 0xEC); addToMapW(0x49, 0x00, 0xED); addToMapW(0x49, 0x00, 0xEE); addToMapW(0x49, 0x00, 0xEF); addToMapW(0x49, 0x01, 0x28); addToMapW(0x49, 0x01, 0x29); addToMapW(0x49, 0x01, 0x2A); addToMapW(0x49, 0x01, 0x2B); addToMapW(0x49, 0x01, 0x2C); addToMapW(0x49, 0x01, 0x2D); addToMapW(0x49, 0x01, 0x2E); addToMapW(0x49, 0x01, 0x2F); addToMapW(0x49, 0x01, 0x30); addToMapW(0x49, 0x01, 0x31); addToMapW(0x49, 0x01, 0x97); addToMapW(0x49, 0x01, 0xCF); addToMapW(0x49, 0x01, 0xD0); addToMapW(0x49, 0x21, 0x10); addToMapW(0x49, 0x21, 0x11); addToMapW(0x49, 0xFF, 0x29); addToMapW(0x49, 0xFF, 0x49); addToMapW(0x4a, 0x00, 0x4A); addToMapW(0x4a, 0x00, 0x6A); addToMapW(0x4a, 0x01, 0x34); addToMapW(0x4a, 0x01, 0x35); addToMapW(0x4a, 0x01, 0xF0); addToMapW(0x4a, 0xFF, 0x2A); addToMapW(0x4a, 0xFF, 0x4A); addToMapW(0x4b, 0x00, 0x4B); addToMapW(0x4b, 0x00, 0x6B); addToMapW(0x4b, 0x01, 0x36); addToMapW(0x4b, 0x01, 0x37); addToMapW(0x4b, 0x01, 0xE8); addToMapW(0x4b, 0x01, 0xE9); addToMapW(0x4b, 0x21, 0x2A); addToMapW(0x4b, 0xFF, 0x2B); addToMapW(0x4b, 0xFF, 0x4B); addToMapW(0x4c, 0x00, 0x4C); addToMapW(0x4c, 0x00, 0x6C); addToMapW(0x4c, 0x00, 0xA3); addToMapW(0x4c, 0x01, 0x39); addToMapW(0x4c, 0x01, 0x3A); addToMapW(0x4c, 0x01, 0x3B); addToMapW(0x4c, 0x01, 0x3C); addToMapW(0x4c, 0x01, 0x3D); addToMapW(0x4c, 0x01, 0x3E); addToMapW(0x4c, 0x01, 0x41); addToMapW(0x4c, 0x01, 0x42); addToMapW(0x4c, 0x01, 0x9A); addToMapW(0x4c, 0x20, 0xA4); addToMapW(0x4c, 0x21, 0x12); addToMapW(0x4c, 0x21, 0x13); addToMapW(0x4c, 0xFF, 0x2C); addToMapW(0x4c, 0xFF, 0x4C); addToMapW(0x4d, 0x00, 0x4D); addToMapW(0x4d, 0x00, 0x6D); addToMapW(0x4d, 0x21, 0x33); addToMapW(0x4d, 0xFF, 0x2D); addToMapW(0x4d, 0xFF, 0x4D); addToMapW(0x4e, 0x00, 0x4E); addToMapW(0x4e, 0x00, 0x6E); addToMapW(0x4e, 0x00, 0xD1); addToMapW(0x4e, 0x00, 0xF1); addToMapW(0x4e, 0x01, 0x43); addToMapW(0x4e, 0x01, 0x44); addToMapW(0x4e, 0x01, 0x45); addToMapW(0x4e, 0x01, 0x46); addToMapW(0x4e, 0x01, 0x47); addToMapW(0x4e, 0x01, 0x48); addToMapW(0x4e, 0x20, 0x7F); addToMapW(0x4e, 0x21, 0x15); addToMapW(0x4e, 0x22, 0x29); addToMapW(0x4e, 0xFF, 0x2E); addToMapW(0x4e, 0xFF, 0x4E); addToMapW(0x4f, 0x00, 0x4F); addToMapW(0x4f, 0x00, 0x6F); addToMapW(0x4f, 0x00, 0xB0); addToMapW(0x4f, 0x00, 0xBA); addToMapW(0x4f, 0x00, 0xD2); addToMapW(0x4f, 0x00, 0xD3); addToMapW(0x4f, 0x00, 0xD4); addToMapW(0x4f, 0x00, 0xD5); addToMapW(0x4f, 0x00, 0xD6); addToMapW(0x4f, 0x00, 0xD8); addToMapW(0x4f, 0x00, 0xF2); addToMapW(0x4f, 0x00, 0xF3); addToMapW(0x4f, 0x00, 0xF4); addToMapW(0x4f, 0x00, 0xF5); addToMapW(0x4f, 0x00, 0xF6); addToMapW(0x4f, 0x00, 0xF8); addToMapW(0x4f, 0x01, 0x4C); addToMapW(0x4f, 0x01, 0x4D); addToMapW(0x4f, 0x01, 0x4E); addToMapW(0x4f, 0x01, 0x4F); addToMapW(0x4f, 0x01, 0x50); addToMapW(0x4f, 0x01, 0x51); addToMapW(0x4f, 0x01, 0x52); addToMapW(0x4f, 0x01, 0x53); addToMapW(0x4f, 0x01, 0x9F); addToMapW(0x4f, 0x01, 0xA0); addToMapW(0x4f, 0x01, 0xA1); addToMapW(0x4f, 0x01, 0xD1); addToMapW(0x4f, 0x01, 0xD2); addToMapW(0x4f, 0x01, 0xEA); addToMapW(0x4f, 0x01, 0xEB); addToMapW(0x4f, 0x01, 0xEC); addToMapW(0x4f, 0x01, 0xED); addToMapW(0x4f, 0x03, 0xA9); addToMapW(0x4f, 0x20, 0xDD); addToMapW(0x4f, 0x21, 0x26); addToMapW(0x4f, 0x21, 0x34); addToMapW(0x4f, 0x22, 0x05); addToMapW(0x4f, 0x30, 0x07); addToMapW(0x4f, 0xFF, 0x2F); addToMapW(0x4f, 0xFF, 0x4F); addToMapW(0x50, 0x00, 0x50); addToMapW(0x50, 0x00, 0x70); addToMapW(0x50, 0x03, 0xC0); addToMapW(0x50, 0x20, 0xA7); addToMapW(0x50, 0x21, 0x18); addToMapW(0x50, 0x21, 0x19); addToMapW(0x50, 0xFF, 0x30); addToMapW(0x50, 0xFF, 0x50); addToMapW(0x51, 0x00, 0x51); addToMapW(0x51, 0x00, 0x71); addToMapW(0x51, 0x21, 0x1A); addToMapW(0x51, 0xFF, 0x31); addToMapW(0x51, 0xFF, 0x51); addToMapW(0x52, 0x00, 0x52); addToMapW(0x52, 0x00, 0x72); addToMapW(0x52, 0x00, 0xAE); addToMapW(0x52, 0x01, 0x54); addToMapW(0x52, 0x01, 0x55); addToMapW(0x52, 0x01, 0x56); addToMapW(0x52, 0x01, 0x57); addToMapW(0x52, 0x01, 0x58); addToMapW(0x52, 0x01, 0x59); addToMapW(0x52, 0x21, 0x1B); addToMapW(0x52, 0x21, 0x1C); addToMapW(0x52, 0x21, 0x1D); addToMapW(0x52, 0xFF, 0x32); addToMapW(0x52, 0xFF, 0x52); addToMapW(0x53, 0x00, 0x53); addToMapW(0x53, 0x00, 0x73); addToMapW(0x53, 0x00, 0xDF); addToMapW(0x53, 0x01, 0x5A); addToMapW(0x53, 0x01, 0x5B); addToMapW(0x53, 0x01, 0x5C); addToMapW(0x53, 0x01, 0x5D); addToMapW(0x53, 0x01, 0x5E); addToMapW(0x53, 0x01, 0x5F); addToMapW(0x53, 0x01, 0x60); addToMapW(0x53, 0x01, 0x61); addToMapW(0x53, 0x01, 0xA9); addToMapW(0x53, 0x03, 0xA3); addToMapW(0x53, 0x03, 0xC3); addToMapW(0x53, 0x22, 0x11); addToMapW(0x53, 0xFF, 0x33); addToMapW(0x53, 0xFF, 0x53); addToMapW(0x54, 0x00, 0x54); addToMapW(0x54, 0x00, 0x74); addToMapW(0x54, 0x00, 0xDE); addToMapW(0x54, 0x00, 0xFE); addToMapW(0x54, 0x01, 0x62); addToMapW(0x54, 0x01, 0x63); addToMapW(0x54, 0x01, 0x64); addToMapW(0x54, 0x01, 0x65); addToMapW(0x54, 0x01, 0x66); addToMapW(0x54, 0x01, 0x67); addToMapW(0x54, 0x01, 0xAB); addToMapW(0x54, 0x01, 0xAE); addToMapW(0x54, 0x03, 0xC4); addToMapW(0x54, 0x21, 0x22); addToMapW(0x54, 0xFF, 0x34); addToMapW(0x54, 0xFF, 0x54); addToMapW(0x55, 0x00, 0x55); addToMapW(0x55, 0x00, 0x75); addToMapW(0x55, 0x00, 0xB5); addToMapW(0x55, 0x00, 0xD9); addToMapW(0x55, 0x00, 0xDA); addToMapW(0x55, 0x00, 0xDB); addToMapW(0x55, 0x00, 0xDC); addToMapW(0x55, 0x00, 0xF9); addToMapW(0x55, 0x00, 0xFA); addToMapW(0x55, 0x00, 0xFB); addToMapW(0x55, 0x00, 0xFC); addToMapW(0x55, 0x01, 0x68); addToMapW(0x55, 0x01, 0x69); addToMapW(0x55, 0x01, 0x6A); addToMapW(0x55, 0x01, 0x6B); addToMapW(0x55, 0x01, 0x6C); addToMapW(0x55, 0x01, 0x6D); addToMapW(0x55, 0x01, 0x6E); addToMapW(0x55, 0x01, 0x6F); addToMapW(0x55, 0x01, 0x70); addToMapW(0x55, 0x01, 0x71); addToMapW(0x55, 0x01, 0x72); addToMapW(0x55, 0x01, 0x73); addToMapW(0x55, 0x01, 0xAF); addToMapW(0x55, 0x01, 0xB0); addToMapW(0x55, 0x01, 0xD3); addToMapW(0x55, 0x01, 0xD4); addToMapW(0x55, 0x01, 0xD5); addToMapW(0x55, 0x01, 0xD6); addToMapW(0x55, 0x01, 0xD7); addToMapW(0x55, 0x01, 0xD8); addToMapW(0x55, 0x01, 0xD9); addToMapW(0x55, 0x01, 0xDA); addToMapW(0x55, 0x01, 0xDB); addToMapW(0x55, 0x01, 0xDC); addToMapW(0x55, 0x03, 0xBC); addToMapW(0x55, 0xFF, 0x35); addToMapW(0x55, 0xFF, 0x55); addToMapW(0x56, 0x00, 0x56); addToMapW(0x56, 0x00, 0x76); addToMapW(0x56, 0x22, 0x1A); addToMapW(0x56, 0x27, 0x13); addToMapW(0x56, 0xFF, 0x36); addToMapW(0x56, 0xFF, 0x56); addToMapW(0x57, 0x00, 0x57); addToMapW(0x57, 0x00, 0x77); addToMapW(0x57, 0x01, 0x74); addToMapW(0x57, 0x01, 0x75); addToMapW(0x57, 0xFF, 0x37); addToMapW(0x57, 0xFF, 0x57); addToMapW(0x58, 0x00, 0x58); addToMapW(0x58, 0x00, 0x78); addToMapW(0x58, 0x00, 0xD7); addToMapW(0x58, 0xFF, 0x38); addToMapW(0x58, 0xFF, 0x58); addToMapW(0x59, 0x00, 0x59); addToMapW(0x59, 0x00, 0x79); addToMapW(0x59, 0x00, 0xA5); addToMapW(0x59, 0x00, 0xDD); addToMapW(0x59, 0x00, 0xFD); addToMapW(0x59, 0x00, 0xFF); addToMapW(0x59, 0x01, 0x76); addToMapW(0x59, 0x01, 0x77); addToMapW(0x59, 0x01, 0x78); addToMapW(0x59, 0xFF, 0x39); addToMapW(0x59, 0xFF, 0x59); addToMapW(0x5a, 0x00, 0x5A); addToMapW(0x5a, 0x00, 0x7A); addToMapW(0x5a, 0x01, 0x79); addToMapW(0x5a, 0x01, 0x7A); addToMapW(0x5a, 0x01, 0x7B); addToMapW(0x5a, 0x01, 0x7C); addToMapW(0x5a, 0x01, 0x7D); addToMapW(0x5a, 0x01, 0x7E); addToMapW(0x5a, 0x01, 0xB6); addToMapW(0x5a, 0x21, 0x24); addToMapW(0x5a, 0x21, 0x28); addToMapW(0x5a, 0xFF, 0x3A); addToMapW(0x5a, 0xFF, 0x5A); addToMapW(0x5b, 0x00, 0x5B); addToMapW(0x5b, 0x30, 0x1A); addToMapW(0x5b, 0xFF, 0x3B); addToMapW(0x5c, 0x00, 0x5C); addToMapW(0x5c, 0x00, 0xA5); addToMapW(0x5c, 0x22, 0x16); addToMapW(0x5c, 0xFF, 0x3C); addToMapW(0x5d, 0x00, 0x5D); addToMapW(0x5d, 0x30, 0x1B); addToMapW(0x5d, 0xFF, 0x3D); addToMapW(0x5e, 0x00, 0x5E); addToMapW(0x5e, 0x02, 0xC4); addToMapW(0x5e, 0x02, 0xC6); addToMapW(0x5e, 0x02, 0xC7); addToMapW(0x5e, 0x02, 0xD8); addToMapW(0x5e, 0x03, 0x02); addToMapW(0x5e, 0x03, 0x06); addToMapW(0x5e, 0x03, 0x0C); addToMapW(0x5e, 0x23, 0x03); addToMapW(0x5e, 0xFF, 0x3E); addToMapW(0x5f, 0x00, 0x5F); addToMapW(0x5f, 0x00, 0xAF); addToMapW(0x5f, 0x00, 0xBE); addToMapW(0x5f, 0x00, 0xDE); addToMapW(0x5f, 0x00, 0xFE); addToMapW(0x5f, 0x02, 0xCD); addToMapW(0x5f, 0x03, 0x31); addToMapW(0x5f, 0x03, 0x32); addToMapW(0x5f, 0x20, 0x17); addToMapW(0x5f, 0x30, 0xFC); addToMapW(0x5f, 0xFF, 0x3F); addToMapW(0x60, 0x00, 0x60); addToMapW(0x60, 0x02, 0xCB); addToMapW(0x60, 0x03, 0x00); addToMapW(0x60, 0x20, 0x18); addToMapW(0x60, 0x20, 0x35); addToMapW(0x60, 0xFF, 0x40); addToMapW(0x7b, 0x00, 0x7B); addToMapW(0x7b, 0xFF, 0x5B); addToMapW(0x7c, 0x00, 0x7C); addToMapW(0x7c, 0x00, 0xA6); addToMapW(0x7c, 0x01, 0xC0); addToMapW(0x7c, 0x22, 0x23); addToMapW(0x7c, 0x27, 0x58); addToMapW(0x7c, 0xFF, 0x5C); addToMapW(0x7d, 0x00, 0x7D); addToMapW(0x7d, 0x30, 0x1B); addToMapW(0x7d, 0xFF, 0x5D); addToMapW(0x7e, 0x00, 0x7E); addToMapW(0x7e, 0x02, 0xDC); addToMapW(0x7e, 0x03, 0x03); addToMapW(0x7e, 0x22, 0x3C); addToMapW(0x7e, 0x22, 0x48); addToMapW(0x7e, 0xFF, 0x5E); addToMapW(0x7f, 0x00, 0x7F); addToMapW(0x7f, 0x23, 0x02); addToMapW(0x7f, 0x26, 0x60); addToMapW(0x7f, 0x26, 0x63); addToMapW(0x7f, 0x26, 0x65); addToMapW(0x7f, 0x26, 0x66); addToMapW(0x80, 0x00, 0x80); addToMapW(0x80, 0x00, 0xC7); addToMapW(0x80, 0x00, 0xE7); addToMapW(0x80, 0x01, 0x06); addToMapW(0x80, 0x01, 0x07); addToMapW(0x80, 0x03, 0x91); addToMapW(0x80, 0x03, 0xB1); addToMapW(0x80, 0x04, 0x10); addToMapW(0x80, 0x04, 0x30); addToMapW(0x80, 0x05, 0xD0); addToMapW(0x80, 0x20, 0xAC); addToMapW(0x81, 0x00, 0x81); addToMapW(0x81, 0x03, 0x92); addToMapW(0x81, 0x03, 0xB2); addToMapW(0x81, 0x04, 0x02); addToMapW(0x81, 0x04, 0x11); addToMapW(0x81, 0x04, 0x31); addToMapW(0x81, 0x04, 0x52); addToMapW(0x81, 0x05, 0xD1); addToMapW(0x82, 0x00, 0x82); addToMapW(0x82, 0x03, 0x93); addToMapW(0x82, 0x03, 0xB3); addToMapW(0x82, 0x04, 0x12); addToMapW(0x82, 0x04, 0x32); addToMapW(0x82, 0x05, 0xD2); addToMapW(0x82, 0x20, 0x1A); addToMapW(0x83, 0x00, 0x83); addToMapW(0x83, 0x03, 0x94); addToMapW(0x83, 0x03, 0xB4); addToMapW(0x83, 0x04, 0x03); addToMapW(0x83, 0x04, 0x13); addToMapW(0x83, 0x04, 0x33); addToMapW(0x83, 0x04, 0x53); addToMapW(0x83, 0x05, 0xD3); addToMapW(0x84, 0x00, 0x84); addToMapW(0x84, 0x03, 0x95); addToMapW(0x84, 0x03, 0xB5); addToMapW(0x84, 0x04, 0x14); addToMapW(0x84, 0x04, 0x34); addToMapW(0x84, 0x05, 0xD4); addToMapW(0x84, 0x20, 0x1E); addToMapW(0x85, 0x03, 0x96); addToMapW(0x85, 0x03, 0xB6); addToMapW(0x85, 0x04, 0x01); addToMapW(0x85, 0x04, 0x15); addToMapW(0x85, 0x04, 0x35); addToMapW(0x85, 0x04, 0x51); addToMapW(0x85, 0x05, 0xD5); addToMapW(0x85, 0x20, 0x26); addToMapW(0x86, 0x00, 0x86); addToMapW(0x86, 0x03, 0x97); addToMapW(0x86, 0x03, 0xB7); addToMapW(0x86, 0x04, 0x16); addToMapW(0x86, 0x04, 0x36); addToMapW(0x86, 0x05, 0xD6); addToMapW(0x86, 0x20, 0x20); addToMapW(0x87, 0x00, 0x87); addToMapW(0x87, 0x03, 0x98); addToMapW(0x87, 0x03, 0xB8); addToMapW(0x87, 0x04, 0x04); addToMapW(0x87, 0x04, 0x17); addToMapW(0x87, 0x04, 0x37); addToMapW(0x87, 0x04, 0x54); addToMapW(0x87, 0x05, 0xD7); addToMapW(0x87, 0x20, 0x21); addToMapW(0x88, 0x00, 0x88); addToMapW(0x88, 0x02, 0xC6); addToMapW(0x88, 0x03, 0x99); addToMapW(0x88, 0x03, 0xB9); addToMapW(0x88, 0x04, 0x18); addToMapW(0x88, 0x04, 0x38); addToMapW(0x88, 0x05, 0xD8); addToMapW(0x89, 0x00, 0x89); addToMapW(0x89, 0x03, 0x9A); addToMapW(0x89, 0x03, 0xBA); addToMapW(0x89, 0x04, 0x05); addToMapW(0x89, 0x04, 0x19); addToMapW(0x89, 0x04, 0x39); addToMapW(0x89, 0x04, 0x55); addToMapW(0x89, 0x05, 0xD9); addToMapW(0x89, 0x20, 0x30); addToMapW(0x8a, 0x00, 0x8A); addToMapW(0x8a, 0x01, 0x50); addToMapW(0x8a, 0x01, 0x51); addToMapW(0x8a, 0x01, 0x56); addToMapW(0x8a, 0x01, 0x57); addToMapW(0x8a, 0x03, 0x9B); addToMapW(0x8a, 0x03, 0xBB); addToMapW(0x8a, 0x04, 0x1A); addToMapW(0x8a, 0x04, 0x3A); addToMapW(0x8a, 0x05, 0xDA); addToMapW(0x8b, 0x00, 0x8B); addToMapW(0x8b, 0x03, 0x9C); addToMapW(0x8b, 0x03, 0xBC); addToMapW(0x8b, 0x04, 0x06); addToMapW(0x8b, 0x04, 0x1B); addToMapW(0x8b, 0x04, 0x3B); addToMapW(0x8b, 0x04, 0x56); addToMapW(0x8b, 0x05, 0xDB); addToMapW(0x8b, 0x20, 0x39); addToMapW(0x8c, 0x00, 0x8C); addToMapW(0x8c, 0x01, 0x52); addToMapW(0x8c, 0x01, 0x53); addToMapW(0x8c, 0x03, 0x9D); addToMapW(0x8c, 0x03, 0xBD); addToMapW(0x8c, 0x04, 0x1C); addToMapW(0x8c, 0x04, 0x3C); addToMapW(0x8c, 0x05, 0xDC); addToMapW(0x8d, 0x00, 0x8D); addToMapW(0x8d, 0x01, 0x31); addToMapW(0x8d, 0x01, 0x79); addToMapW(0x8d, 0x01, 0x7A); addToMapW(0x8d, 0x03, 0x9E); addToMapW(0x8d, 0x03, 0xBE); addToMapW(0x8d, 0x04, 0x07); addToMapW(0x8d, 0x04, 0x1D); addToMapW(0x8d, 0x04, 0x3D); addToMapW(0x8d, 0x04, 0x57); addToMapW(0x8d, 0x05, 0xDD); addToMapW(0x8e, 0x00, 0x8E); addToMapW(0x8e, 0x00, 0xC4); addToMapW(0x8e, 0x00, 0xE4); addToMapW(0x8e, 0x03, 0x9F); addToMapW(0x8e, 0x03, 0xBF); addToMapW(0x8e, 0x04, 0x1E); addToMapW(0x8e, 0x04, 0x3E); addToMapW(0x8e, 0x05, 0xDE); addToMapW(0x8f, 0x00, 0x8F); addToMapW(0x8f, 0x00, 0xC5); addToMapW(0x8f, 0x00, 0xE5); addToMapW(0x8f, 0x01, 0x06); addToMapW(0x8f, 0x01, 0x07); addToMapW(0x8f, 0x03, 0xA0); addToMapW(0x8f, 0x03, 0xC0); addToMapW(0x8f, 0x04, 0x08); addToMapW(0x8f, 0x04, 0x1F); addToMapW(0x8f, 0x04, 0x3F); addToMapW(0x8f, 0x04, 0x58); addToMapW(0x8f, 0x05, 0xDF); addToMapW(0x8f, 0x21, 0x2B); addToMapW(0x90, 0x00, 0x90); addToMapW(0x90, 0x00, 0xC9); addToMapW(0x90, 0x00, 0xE9); addToMapW(0x90, 0x03, 0xA1); addToMapW(0x90, 0x03, 0xC1); addToMapW(0x90, 0x04, 0x20); addToMapW(0x90, 0x04, 0x40); addToMapW(0x90, 0x05, 0xE0); addToMapW(0x91, 0x01, 0x39); addToMapW(0x91, 0x01, 0x3A); addToMapW(0x91, 0x03, 0xA3); addToMapW(0x91, 0x03, 0xC2); addToMapW(0x91, 0x03, 0xC3); addToMapW(0x91, 0x04, 0x09); addToMapW(0x91, 0x04, 0x21); addToMapW(0x91, 0x04, 0x41); addToMapW(0x91, 0x04, 0x59); addToMapW(0x91, 0x05, 0xE1); addToMapW(0x91, 0x06, 0x51); addToMapW(0x91, 0x20, 0x18); addToMapW(0x91, 0xFE, 0x7C); addToMapW(0x91, 0xFE, 0x7D); addToMapW(0x92, 0x00, 0xC6); addToMapW(0x92, 0x00, 0xE6); addToMapW(0x92, 0x03, 0xA4); addToMapW(0x92, 0x03, 0xC4); addToMapW(0x92, 0x04, 0x22); addToMapW(0x92, 0x04, 0x42); addToMapW(0x92, 0x05, 0xE2); addToMapW(0x92, 0x06, 0x52); addToMapW(0x92, 0x20, 0x19); addToMapW(0x92, 0xFE, 0x7E); addToMapW(0x92, 0xFE, 0x7F); addToMapW(0x93, 0x03, 0xA5); addToMapW(0x93, 0x03, 0xC5); addToMapW(0x93, 0x04, 0x0A); addToMapW(0x93, 0x04, 0x23); addToMapW(0x93, 0x04, 0x43); addToMapW(0x93, 0x04, 0x5A); addToMapW(0x93, 0x05, 0xE3); addToMapW(0x93, 0x20, 0x1C); addToMapW(0x94, 0x00, 0xA4); addToMapW(0x94, 0x03, 0xA6); addToMapW(0x94, 0x03, 0xC6); addToMapW(0x94, 0x04, 0x24); addToMapW(0x94, 0x04, 0x44); addToMapW(0x94, 0x05, 0xE4); addToMapW(0x94, 0x20, 0x1D); addToMapW(0x95, 0x01, 0x22); addToMapW(0x95, 0x01, 0x23); addToMapW(0x95, 0x01, 0x3D); addToMapW(0x95, 0x01, 0x3E); addToMapW(0x95, 0x03, 0xA7); addToMapW(0x95, 0x03, 0xC7); addToMapW(0x95, 0x04, 0x0B); addToMapW(0x95, 0x04, 0x25); addToMapW(0x95, 0x04, 0x45); addToMapW(0x95, 0x04, 0x5B); addToMapW(0x95, 0x05, 0xE5); addToMapW(0x95, 0x06, 0x40); addToMapW(0x95, 0x20, 0x22); addToMapW(0x96, 0x00, 0xA2); addToMapW(0x96, 0x03, 0xA8); addToMapW(0x96, 0x03, 0xC8); addToMapW(0x96, 0x04, 0x26); addToMapW(0x96, 0x04, 0x46); addToMapW(0x96, 0x05, 0xE6); addToMapW(0x96, 0x20, 0x13); addToMapW(0x97, 0x00, 0xB5); addToMapW(0x97, 0x01, 0x5A); addToMapW(0x97, 0x01, 0x5B); addToMapW(0x97, 0x03, 0xA9); addToMapW(0x97, 0x03, 0xC9); addToMapW(0x97, 0x04, 0x0C); addToMapW(0x97, 0x04, 0x27); addToMapW(0x97, 0x04, 0x47); addToMapW(0x97, 0x04, 0x5C); addToMapW(0x97, 0x05, 0xE7); addToMapW(0x97, 0x20, 0x14); addToMapW(0x98, 0x00, 0x98); addToMapW(0x98, 0x01, 0x30); addToMapW(0x98, 0x02, 0xDC); addToMapW(0x98, 0x04, 0x28); addToMapW(0x98, 0x04, 0x48); addToMapW(0x98, 0x05, 0xE8); addToMapW(0x98, 0x06, 0x21); addToMapW(0x98, 0xFE, 0x80); addToMapW(0x99, 0x00, 0x99); addToMapW(0x99, 0x00, 0xD6); addToMapW(0x99, 0x00, 0xF6); addToMapW(0x99, 0x04, 0x0E); addToMapW(0x99, 0x04, 0x29); addToMapW(0x99, 0x04, 0x49); addToMapW(0x99, 0x04, 0x5E); addToMapW(0x99, 0x05, 0xE9); addToMapW(0x99, 0x06, 0x22); addToMapW(0x99, 0x21, 0x22); addToMapW(0x99, 0xFE, 0x81); addToMapW(0x99, 0xFE, 0x82); addToMapW(0x9a, 0x00, 0x9A); addToMapW(0x9a, 0x00, 0xDC); addToMapW(0x9a, 0x00, 0xFC); addToMapW(0x9a, 0x04, 0x2A); addToMapW(0x9a, 0x04, 0x4A); addToMapW(0x9a, 0x05, 0xEA); addToMapW(0x9a, 0x06, 0x23); addToMapW(0x9a, 0xFE, 0x83); addToMapW(0x9a, 0xFE, 0x84); addToMapW(0x9b, 0x00, 0x9B); addToMapW(0x9b, 0x00, 0xA2); addToMapW(0x9b, 0x01, 0x64); addToMapW(0x9b, 0x01, 0x65); addToMapW(0x9b, 0x04, 0x0F); addToMapW(0x9b, 0x04, 0x2B); addToMapW(0x9b, 0x04, 0x4B); addToMapW(0x9b, 0x04, 0x5F); addToMapW(0x9b, 0x06, 0x24); addToMapW(0x9b, 0x20, 0x3A); addToMapW(0x9b, 0xFE, 0x85); addToMapW(0x9b, 0xFE, 0x86); addToMapW(0x9c, 0x00, 0x9C); addToMapW(0x9c, 0x00, 0xA3); addToMapW(0x9c, 0x04, 0x2C); addToMapW(0x9c, 0x04, 0x4C); addToMapW(0x9c, 0x20, 0xA4); addToMapW(0x9d, 0x00, 0x9D); addToMapW(0x9d, 0x00, 0xA5); addToMapW(0x9d, 0x00, 0xD8); addToMapW(0x9d, 0x00, 0xF8); addToMapW(0x9d, 0x01, 0x41); addToMapW(0x9d, 0x01, 0x42); addToMapW(0x9d, 0x02, 0x78); addToMapW(0x9d, 0x03, 0x98); addToMapW(0x9d, 0x04, 0x2D); addToMapW(0x9d, 0x04, 0x2E); addToMapW(0x9d, 0x04, 0x4D); addToMapW(0x9d, 0x04, 0x4E); addToMapW(0x9d, 0x06, 0x25); addToMapW(0x9d, 0x22, 0x05); addToMapW(0x9d, 0xFE, 0x87); addToMapW(0x9d, 0xFE, 0x88); addToMapW(0x9e, 0x00, 0x9E); addToMapW(0x9e, 0x00, 0xD7); addToMapW(0x9e, 0x01, 0x5E); addToMapW(0x9e, 0x01, 0x5F); addToMapW(0x9e, 0x04, 0x2E); addToMapW(0x9e, 0x04, 0x4E); addToMapW(0x9e, 0x06, 0x26); addToMapW(0x9e, 0x20, 0xA7); addToMapW(0x9e, 0xFE, 0x89); addToMapW(0x9e, 0xFE, 0x8A); addToMapW(0x9e, 0xFE, 0x8B); addToMapW(0x9e, 0xFE, 0x8C); addToMapW(0x9f, 0x00, 0x9F); addToMapW(0x9f, 0x00, 0xA4); addToMapW(0x9f, 0x00, 0xFF); addToMapW(0x9f, 0x01, 0x78); addToMapW(0x9f, 0x01, 0x91); addToMapW(0x9f, 0x01, 0x92); addToMapW(0x9f, 0x04, 0x2A); addToMapW(0x9f, 0x04, 0x2F); addToMapW(0x9f, 0x04, 0x4A); addToMapW(0x9f, 0x04, 0x4F); addToMapW(0x9f, 0x06, 0x27); addToMapW(0x9f, 0xFE, 0x8D); addToMapW(0x9f, 0xFE, 0x8E); addToMapW(0xa0, 0x00, 0xA0); addToMapW(0xa0, 0x01, 0x00); addToMapW(0xa0, 0x01, 0x01); addToMapW(0xa0, 0x06, 0x28); addToMapW(0xa0, 0xF8, 0xF0); addToMapW(0xa0, 0xFE, 0x8F); addToMapW(0xa0, 0xFE, 0x90); addToMapW(0xa0, 0xFE, 0x91); addToMapW(0xa0, 0xFE, 0x92); addToMapW(0xa1, 0x00, 0xA1); addToMapW(0xa1, 0x01, 0x2A); addToMapW(0xa1, 0x01, 0x2B); addToMapW(0xa1, 0x04, 0x10); addToMapW(0xa1, 0x04, 0x30); addToMapW(0xa1, 0x06, 0x29); addToMapW(0xa1, 0x0E, 0x01); addToMapW(0xa1, 0xFE, 0x93); addToMapW(0xa1, 0xFE, 0x94); addToMapW(0xa1, 0xFF, 0x61); addToMapW(0xa2, 0x00, 0xA2); addToMapW(0xa2, 0x06, 0x2A); addToMapW(0xa2, 0x0E, 0x02); addToMapW(0xa2, 0xFE, 0x95); addToMapW(0xa2, 0xFE, 0x96); addToMapW(0xa2, 0xFE, 0x97); addToMapW(0xa2, 0xFE, 0x98); addToMapW(0xa2, 0xFF, 0x62); addToMapW(0xa3, 0x00, 0xA3); addToMapW(0xa3, 0x01, 0x7B); addToMapW(0xa3, 0x01, 0x7C); addToMapW(0xa3, 0x04, 0x11); addToMapW(0xa3, 0x04, 0x31); addToMapW(0xa3, 0x06, 0x2B); addToMapW(0xa3, 0x0E, 0x03); addToMapW(0xa3, 0xFE, 0x99); addToMapW(0xa3, 0xFE, 0x9A); addToMapW(0xa3, 0xFE, 0x9B); addToMapW(0xa3, 0xFE, 0x9C); addToMapW(0xa3, 0xFF, 0x63); addToMapW(0xa4, 0x00, 0xA4); addToMapW(0xa4, 0x01, 0x04); addToMapW(0xa4, 0x01, 0x05); addToMapW(0xa4, 0x06, 0x2C); addToMapW(0xa4, 0x0E, 0x04); addToMapW(0xa4, 0xFE, 0x9D); addToMapW(0xa4, 0xFE, 0x9E); addToMapW(0xa4, 0xFE, 0x9F); addToMapW(0xa4, 0xFE, 0xA0); addToMapW(0xa4, 0xFF, 0x64); addToMapW(0xa5, 0x00, 0xA5); addToMapW(0xa5, 0x00, 0xD1); addToMapW(0xa5, 0x00, 0xF1); addToMapW(0xa5, 0x04, 0x26); addToMapW(0xa5, 0x04, 0x46); addToMapW(0xa5, 0x06, 0x2D); addToMapW(0xa5, 0x0E, 0x05); addToMapW(0xa5, 0xFE, 0xA1); addToMapW(0xa5, 0xFE, 0xA2); addToMapW(0xa5, 0xFE, 0xA3); addToMapW(0xa5, 0xFE, 0xA4); addToMapW(0xa5, 0xFF, 0x65); addToMapW(0xa6, 0x00, 0xA6); addToMapW(0xa6, 0x00, 0xAA); addToMapW(0xa6, 0x01, 0x1E); addToMapW(0xa6, 0x01, 0x1F); addToMapW(0xa6, 0x01, 0x7D); addToMapW(0xa6, 0x01, 0x7E); addToMapW(0xa6, 0x06, 0x2E); addToMapW(0xa6, 0x0E, 0x06); addToMapW(0xa6, 0x20, 0x1D); addToMapW(0xa6, 0xFE, 0xA5); addToMapW(0xa6, 0xFE, 0xA6); addToMapW(0xa6, 0xFE, 0xA7); addToMapW(0xa6, 0xFE, 0xA8); addToMapW(0xa6, 0xFF, 0x66); addToMapW(0xa7, 0x00, 0xA6); addToMapW(0xa7, 0x00, 0xA7); addToMapW(0xa7, 0x00, 0xBA); addToMapW(0xa7, 0x04, 0x14); addToMapW(0xa7, 0x04, 0x34); addToMapW(0xa7, 0x06, 0x2F); addToMapW(0xa7, 0x0E, 0x07); addToMapW(0xa7, 0xFE, 0xA9); addToMapW(0xa7, 0xFE, 0xAA); addToMapW(0xa7, 0xFF, 0x67); addToMapW(0xa8, 0x00, 0xA8); addToMapW(0xa8, 0x00, 0xA9); addToMapW(0xa8, 0x00, 0xBF); addToMapW(0xa8, 0x01, 0x18); addToMapW(0xa8, 0x01, 0x19); addToMapW(0xa8, 0x06, 0x30); addToMapW(0xa8, 0x0E, 0x08); addToMapW(0xa8, 0xFE, 0xAB); addToMapW(0xa8, 0xFE, 0xAC); addToMapW(0xa8, 0xFF, 0x68); addToMapW(0xa9, 0x00, 0xA9); addToMapW(0xa9, 0x00, 0xAE); addToMapW(0xa9, 0x04, 0x15); addToMapW(0xa9, 0x04, 0x35); addToMapW(0xa9, 0x06, 0x31); addToMapW(0xa9, 0x0E, 0x09); addToMapW(0xa9, 0x23, 0x10); addToMapW(0xa9, 0xFE, 0xAD); addToMapW(0xa9, 0xFE, 0xAE); addToMapW(0xa9, 0xFF, 0x69); addToMapW(0xaa, 0x00, 0xAA); addToMapW(0xaa, 0x00, 0xAC); addToMapW(0xaa, 0x06, 0x32); addToMapW(0xaa, 0x0E, 0x0A); addToMapW(0xaa, 0x23, 0x10); addToMapW(0xaa, 0xFE, 0xAF); addToMapW(0xaa, 0xFE, 0xB0); addToMapW(0xaa, 0xFF, 0x6A); addToMapW(0xab, 0x00, 0xAB); addToMapW(0xab, 0x00, 0xBD); addToMapW(0xab, 0x04, 0x24); addToMapW(0xab, 0x04, 0x44); addToMapW(0xab, 0x06, 0x33); addToMapW(0xab, 0x0E, 0x0B); addToMapW(0xab, 0xFE, 0xB1); addToMapW(0xab, 0xFE, 0xB2); addToMapW(0xab, 0xFE, 0xB3); addToMapW(0xab, 0xFE, 0xB4); addToMapW(0xab, 0xFF, 0x6B); addToMapW(0xac, 0x00, 0xAC); addToMapW(0xac, 0x00, 0xBC); addToMapW(0xac, 0x01, 0x0C); addToMapW(0xac, 0x01, 0x0D); addToMapW(0xac, 0x06, 0x34); addToMapW(0xac, 0x0E, 0x0C); addToMapW(0xac, 0xFE, 0xB5); addToMapW(0xac, 0xFE, 0xB6); addToMapW(0xac, 0xFE, 0xB7); addToMapW(0xac, 0xFE, 0xB8); addToMapW(0xac, 0xFF, 0x6C); addToMapW(0xad, 0x00, 0xA1); addToMapW(0xad, 0x00, 0xAD); addToMapW(0xad, 0x01, 0x41); addToMapW(0xad, 0x01, 0x42); addToMapW(0xad, 0x04, 0x13); addToMapW(0xad, 0x04, 0x33); addToMapW(0xad, 0x06, 0x35); addToMapW(0xad, 0x0E, 0x0D); addToMapW(0xad, 0xFE, 0xB9); addToMapW(0xad, 0xFE, 0xBA); addToMapW(0xad, 0xFE, 0xBB); addToMapW(0xad, 0xFE, 0xBC); addToMapW(0xad, 0xFF, 0x6D); addToMapW(0xae, 0x00, 0xAB); addToMapW(0xae, 0x00, 0xAE); addToMapW(0xae, 0x0E, 0x0E); addToMapW(0xae, 0x22, 0x6A); addToMapW(0xae, 0x30, 0x0A); addToMapW(0xae, 0xFF, 0x6E); addToMapW(0xaf, 0x00, 0xAF); addToMapW(0xaf, 0x00, 0xBB); addToMapW(0xaf, 0x0E, 0x0F); addToMapW(0xaf, 0x22, 0x6B); addToMapW(0xaf, 0x30, 0x0B); addToMapW(0xaf, 0xFF, 0x6F); addToMapW(0xb0, 0x00, 0xB0); addToMapW(0xb0, 0x0E, 0x10); addToMapW(0xb0, 0x25, 0x91); addToMapW(0xb0, 0xFF, 0x70); addToMapW(0xb1, 0x00, 0xB1); addToMapW(0xb1, 0x0E, 0x11); addToMapW(0xb1, 0x25, 0x92); addToMapW(0xb1, 0xFF, 0x71); addToMapW(0xb2, 0x00, 0xB2); addToMapW(0xb2, 0x0E, 0x12); addToMapW(0xb2, 0x25, 0x93); addToMapW(0xb2, 0xFF, 0x72); addToMapW(0xb3, 0x00, 0xA6); addToMapW(0xb3, 0x00, 0xB3); addToMapW(0xb3, 0x01, 0xC0); addToMapW(0xb3, 0x0E, 0x13); addToMapW(0xb3, 0x22, 0x23); addToMapW(0xb3, 0x25, 0x02); addToMapW(0xb3, 0x27, 0x58); addToMapW(0xb3, 0xFF, 0x73); addToMapW(0xb4, 0x00, 0xB4); addToMapW(0xb4, 0x0E, 0x14); addToMapW(0xb4, 0x25, 0x24); addToMapW(0xb4, 0xFF, 0x74); addToMapW(0xb5, 0x00, 0xB5); addToMapW(0xb5, 0x00, 0xC1); addToMapW(0xb5, 0x00, 0xE1); addToMapW(0xb5, 0x01, 0x04); addToMapW(0xb5, 0x01, 0x05); addToMapW(0xb5, 0x0E, 0x15); addToMapW(0xb5, 0x25, 0x61); addToMapW(0xb5, 0xFF, 0x75); addToMapW(0xb6, 0x00, 0xB6); addToMapW(0xb6, 0x00, 0xC2); addToMapW(0xb6, 0x00, 0xE2); addToMapW(0xb6, 0x01, 0x0C); addToMapW(0xb6, 0x01, 0x0D); addToMapW(0xb6, 0x04, 0x25); addToMapW(0xb6, 0x04, 0x45); addToMapW(0xb6, 0x0E, 0x16); addToMapW(0xb6, 0x25, 0x62); addToMapW(0xb6, 0xFF, 0x76); addToMapW(0xb7, 0x00, 0xB7); addToMapW(0xb7, 0x00, 0xC0); addToMapW(0xb7, 0x00, 0xE0); addToMapW(0xb7, 0x01, 0x18); addToMapW(0xb7, 0x01, 0x19); addToMapW(0xb7, 0x01, 0x1A); addToMapW(0xb7, 0x01, 0x1B); addToMapW(0xb7, 0x0E, 0x17); addToMapW(0xb7, 0x25, 0x56); addToMapW(0xb7, 0xFF, 0x77); addToMapW(0xb8, 0x00, 0xA9); addToMapW(0xb8, 0x00, 0xB8); addToMapW(0xb8, 0x01, 0x16); addToMapW(0xb8, 0x01, 0x17); addToMapW(0xb8, 0x01, 0x5E); addToMapW(0xb8, 0x01, 0x5F); addToMapW(0xb8, 0x04, 0x18); addToMapW(0xb8, 0x04, 0x38); addToMapW(0xb8, 0x0E, 0x18); addToMapW(0xb8, 0x25, 0x55); addToMapW(0xb8, 0xFF, 0x78); addToMapW(0xb9, 0x00, 0xB9); addToMapW(0xb9, 0x0E, 0x19); addToMapW(0xb9, 0x25, 0x61); addToMapW(0xb9, 0x25, 0x62); addToMapW(0xb9, 0x25, 0x63); addToMapW(0xb9, 0xFF, 0x79); addToMapW(0xba, 0x00, 0xBA); addToMapW(0xba, 0x0E, 0x1A); addToMapW(0xba, 0x25, 0x51); addToMapW(0xba, 0xFF, 0x7A); addToMapW(0xbb, 0x00, 0xBB); addToMapW(0xbb, 0x0E, 0x1B); addToMapW(0xbb, 0x25, 0x55); addToMapW(0xbb, 0x25, 0x56); addToMapW(0xbb, 0x25, 0x57); addToMapW(0xbb, 0xFF, 0x7B); addToMapW(0xbc, 0x00, 0xBC); addToMapW(0xbc, 0x0E, 0x1C); addToMapW(0xbc, 0x25, 0x5B); addToMapW(0xbc, 0x25, 0x5C); addToMapW(0xbc, 0x25, 0x5D); addToMapW(0xbc, 0xFF, 0x7C); addToMapW(0xbd, 0x00, 0xA2); addToMapW(0xbd, 0x00, 0xBD); addToMapW(0xbd, 0x01, 0x2E); addToMapW(0xbd, 0x01, 0x2F); addToMapW(0xbd, 0x01, 0x7B); addToMapW(0xbd, 0x01, 0x7C); addToMapW(0xbd, 0x0E, 0x1D); addToMapW(0xbd, 0x25, 0x5C); addToMapW(0xbd, 0xFF, 0x7D); addToMapW(0xbe, 0x00, 0xA5); addToMapW(0xbe, 0x00, 0xBE); addToMapW(0xbe, 0x01, 0x60); addToMapW(0xbe, 0x01, 0x61); addToMapW(0xbe, 0x04, 0x19); addToMapW(0xbe, 0x04, 0x39); addToMapW(0xbe, 0x0E, 0x1E); addToMapW(0xbe, 0x25, 0x5B); addToMapW(0xbe, 0xFF, 0x7E); addToMapW(0xbf, 0x00, 0xAC); addToMapW(0xbf, 0x00, 0xBF); addToMapW(0xbf, 0x0E, 0x1F); addToMapW(0xbf, 0x25, 0x10); addToMapW(0xbf, 0xFF, 0x7F); addToMapW(0xc0, 0x00, 0xC0); addToMapW(0xc0, 0x00, 0xE0); addToMapW(0xc0, 0x0E, 0x20); addToMapW(0xc0, 0x25, 0x14); addToMapW(0xc0, 0xFF, 0x80); addToMapW(0xc1, 0x00, 0xC1); addToMapW(0xc1, 0x00, 0xE1); addToMapW(0xc1, 0x0E, 0x21); addToMapW(0xc1, 0x25, 0x34); addToMapW(0xc1, 0xFF, 0x81); addToMapW(0xc2, 0x00, 0xC2); addToMapW(0xc2, 0x00, 0xE2); addToMapW(0xc2, 0x0E, 0x22); addToMapW(0xc2, 0x25, 0x2C); addToMapW(0xc2, 0xFF, 0x82); addToMapW(0xc3, 0x01, 0x02); addToMapW(0xc3, 0x01, 0x03); addToMapW(0xc3, 0x0E, 0x23); addToMapW(0xc3, 0x25, 0x1C); addToMapW(0xc3, 0xFF, 0x83); addToMapW(0xc4, 0x00, 0xAF); addToMapW(0xc4, 0x00, 0xC4); addToMapW(0xc4, 0x00, 0xE4); addToMapW(0xc4, 0x02, 0xC9); addToMapW(0xc4, 0x03, 0x04); addToMapW(0xc4, 0x03, 0x05); addToMapW(0xc4, 0x0E, 0x24); addToMapW(0xc4, 0x25, 0x00); addToMapW(0xc4, 0xFF, 0x84); addToMapW(0xc5, 0x00, 0xC5); addToMapW(0xc5, 0x00, 0xE5); addToMapW(0xc5, 0x0E, 0x25); addToMapW(0xc5, 0x20, 0x20); addToMapW(0xc5, 0x20, 0x21); addToMapW(0xc5, 0x25, 0x3C); addToMapW(0xc5, 0xFF, 0x85); addToMapW(0xc6, 0x00, 0xC6); addToMapW(0xc6, 0x00, 0xE6); addToMapW(0xc6, 0x01, 0x02); addToMapW(0xc6, 0x01, 0x03); addToMapW(0xc6, 0x01, 0x72); addToMapW(0xc6, 0x01, 0x73); addToMapW(0xc6, 0x0E, 0x26); addToMapW(0xc6, 0x25, 0x5E); addToMapW(0xc6, 0xFF, 0x86); addToMapW(0xc7, 0x00, 0xC3); addToMapW(0xc7, 0x00, 0xC7); addToMapW(0xc7, 0x00, 0xE3); addToMapW(0xc7, 0x00, 0xE7); addToMapW(0xc7, 0x01, 0x6A); addToMapW(0xc7, 0x01, 0x6B); addToMapW(0xc7, 0x04, 0x1A); addToMapW(0xc7, 0x04, 0x3A); addToMapW(0xc7, 0x0E, 0x27); addToMapW(0xc7, 0x25, 0x5F); addToMapW(0xc7, 0xFF, 0x87); addToMapW(0xc8, 0x00, 0xC8); addToMapW(0xc8, 0x00, 0xE8); addToMapW(0xc8, 0x0E, 0x28); addToMapW(0xc8, 0x25, 0x58); addToMapW(0xc8, 0x25, 0x59); addToMapW(0xc8, 0x25, 0x5A); addToMapW(0xc8, 0xFF, 0x88); addToMapW(0xc9, 0x00, 0xC9); addToMapW(0xc9, 0x00, 0xE9); addToMapW(0xc9, 0x0E, 0x29); addToMapW(0xc9, 0x25, 0x52); addToMapW(0xc9, 0x25, 0x53); addToMapW(0xc9, 0x25, 0x54); addToMapW(0xc9, 0xFF, 0x89); addToMapW(0xca, 0x00, 0xCA); addToMapW(0xca, 0x00, 0xEA); addToMapW(0xca, 0x0E, 0x2A); addToMapW(0xca, 0x25, 0x67); addToMapW(0xca, 0x25, 0x68); addToMapW(0xca, 0x25, 0x69); addToMapW(0xca, 0xFF, 0x8A); addToMapW(0xcb, 0x00, 0xCB); addToMapW(0xcb, 0x00, 0xEB); addToMapW(0xcb, 0x0E, 0x2B); addToMapW(0xcb, 0x25, 0x64); addToMapW(0xcb, 0x25, 0x65); addToMapW(0xcb, 0x25, 0x66); addToMapW(0xcb, 0xFF, 0x8B); addToMapW(0xcc, 0x03, 0x00); addToMapW(0xcc, 0x0E, 0x2C); addToMapW(0xcc, 0x25, 0x5E); addToMapW(0xcc, 0x25, 0x5F); addToMapW(0xcc, 0x25, 0x60); addToMapW(0xcc, 0xFF, 0x8C); addToMapW(0xcd, 0x00, 0xCD); addToMapW(0xcd, 0x00, 0xED); addToMapW(0xcd, 0x0E, 0x2D); addToMapW(0xcd, 0x25, 0x50); addToMapW(0xcd, 0xFF, 0x8D); addToMapW(0xce, 0x00, 0xCE); addToMapW(0xce, 0x00, 0xEE); addToMapW(0xce, 0x0E, 0x2E); addToMapW(0xce, 0x20, 0x21); addToMapW(0xce, 0x25, 0x6A); addToMapW(0xce, 0x25, 0x6B); addToMapW(0xce, 0x25, 0x6C); addToMapW(0xce, 0xFF, 0x8E); addToMapW(0xcf, 0x00, 0xA4); addToMapW(0xcf, 0x00, 0xCF); addToMapW(0xcf, 0x00, 0xEF); addToMapW(0xcf, 0x01, 0x7D); addToMapW(0xcf, 0x01, 0x7E); addToMapW(0xcf, 0x0E, 0x2F); addToMapW(0xcf, 0x25, 0x67); addToMapW(0xcf, 0xFF, 0x8F); addToMapW(0xd0, 0x00, 0xBA); addToMapW(0xd0, 0x01, 0x10); addToMapW(0xd0, 0x01, 0x11); addToMapW(0xd0, 0x0E, 0x30); addToMapW(0xd0, 0x25, 0x68); addToMapW(0xd0, 0xFF, 0x90); addToMapW(0xd1, 0x00, 0xAA); addToMapW(0xd1, 0x00, 0xD0); addToMapW(0xd1, 0x00, 0xD1); addToMapW(0xd1, 0x00, 0xF0); addToMapW(0xd1, 0x00, 0xF1); addToMapW(0xd1, 0x01, 0x10); addToMapW(0xd1, 0x01, 0x11); addToMapW(0xd1, 0x01, 0x89); addToMapW(0xd1, 0x04, 0x1B); addToMapW(0xd1, 0x04, 0x3B); addToMapW(0xd1, 0x0E, 0x31); addToMapW(0xd1, 0x25, 0x64); addToMapW(0xd1, 0xFF, 0x91); addToMapW(0xd2, 0x00, 0xCA); addToMapW(0xd2, 0x00, 0xEA); addToMapW(0xd2, 0x01, 0x0E); addToMapW(0xd2, 0x01, 0x0F); addToMapW(0xd2, 0x03, 0x09); addToMapW(0xd2, 0x0E, 0x32); addToMapW(0xd2, 0x25, 0x65); addToMapW(0xd2, 0xFF, 0x92); addToMapW(0xd3, 0x00, 0xCB); addToMapW(0xd3, 0x00, 0xD3); addToMapW(0xd3, 0x00, 0xEB); addToMapW(0xd3, 0x00, 0xF3); addToMapW(0xd3, 0x04, 0x1C); addToMapW(0xd3, 0x04, 0x3C); addToMapW(0xd3, 0x0E, 0x33); addToMapW(0xd3, 0x25, 0x59); addToMapW(0xd3, 0xFF, 0x93); addToMapW(0xd4, 0x00, 0xC8); addToMapW(0xd4, 0x00, 0xD4); addToMapW(0xd4, 0x00, 0xE8); addToMapW(0xd4, 0x00, 0xF4); addToMapW(0xd4, 0x0E, 0x34); addToMapW(0xd4, 0x25, 0x58); addToMapW(0xd4, 0xFF, 0x94); addToMapW(0xd5, 0x01, 0x31); addToMapW(0xd5, 0x01, 0x47); addToMapW(0xd5, 0x01, 0x48); addToMapW(0xd5, 0x01, 0xA0); addToMapW(0xd5, 0x01, 0xA1); addToMapW(0xd5, 0x04, 0x1D); addToMapW(0xd5, 0x04, 0x3D); addToMapW(0xd5, 0x0E, 0x35); addToMapW(0xd5, 0x25, 0x52); addToMapW(0xd5, 0xF8, 0xBB); addToMapW(0xd5, 0xFF, 0x95); addToMapW(0xd6, 0x00, 0xCD); addToMapW(0xd6, 0x00, 0xD6); addToMapW(0xd6, 0x00, 0xED); addToMapW(0xd6, 0x00, 0xF6); addToMapW(0xd6, 0x0E, 0x36); addToMapW(0xd6, 0x25, 0x53); addToMapW(0xd6, 0xFF, 0x96); addToMapW(0xd7, 0x00, 0xCE); addToMapW(0xd7, 0x00, 0xD7); addToMapW(0xd7, 0x00, 0xEE); addToMapW(0xd7, 0x04, 0x1E); addToMapW(0xd7, 0x04, 0x3E); addToMapW(0xd7, 0x0E, 0x37); addToMapW(0xd7, 0x25, 0x6B); addToMapW(0xd7, 0xFF, 0x97); addToMapW(0xd8, 0x00, 0xCF); addToMapW(0xd8, 0x00, 0xD8); addToMapW(0xd8, 0x00, 0xEF); addToMapW(0xd8, 0x00, 0xF8); addToMapW(0xd8, 0x0E, 0x38); addToMapW(0xd8, 0x20, 0x21); addToMapW(0xd8, 0x25, 0x6A); addToMapW(0xd8, 0xFF, 0x98); addToMapW(0xd9, 0x00, 0xD9); addToMapW(0xd9, 0x00, 0xF9); addToMapW(0xd9, 0x0E, 0x39); addToMapW(0xd9, 0x25, 0x18); addToMapW(0xd9, 0xFF, 0x99); addToMapW(0xda, 0x00, 0xDA); addToMapW(0xda, 0x00, 0xFA); addToMapW(0xda, 0x0E, 0x3A); addToMapW(0xda, 0x25, 0x0C); addToMapW(0xda, 0xFF, 0x9A); addToMapW(0xdb, 0x00, 0xDB); addToMapW(0xdb, 0x00, 0xFB); addToMapW(0xdb, 0x25, 0x88); addToMapW(0xdb, 0x25, 0x8C); addToMapW(0xdb, 0x25, 0x90); addToMapW(0xdb, 0xF8, 0xC1); addToMapW(0xdb, 0xFF, 0x9B); addToMapW(0xdc, 0x00, 0xDC); addToMapW(0xdc, 0x00, 0xFC); addToMapW(0xdc, 0x25, 0x84); addToMapW(0xdc, 0xF8, 0xC2); addToMapW(0xdc, 0xFF, 0x9C); addToMapW(0xdd, 0x00, 0xA6); addToMapW(0xdd, 0x01, 0x62); addToMapW(0xdd, 0x01, 0x63); addToMapW(0xdd, 0x01, 0xAF); addToMapW(0xdd, 0x01, 0xB0); addToMapW(0xdd, 0x04, 0x1F); addToMapW(0xdd, 0x04, 0x3F); addToMapW(0xdd, 0x25, 0x8C); addToMapW(0xdd, 0xF8, 0xC3); addToMapW(0xdd, 0xFF, 0x9D); addToMapW(0xde, 0x00, 0xCC); addToMapW(0xde, 0x00, 0xEC); addToMapW(0xde, 0x01, 0x6E); addToMapW(0xde, 0x01, 0x6F); addToMapW(0xde, 0x03, 0x03); addToMapW(0xde, 0x25, 0x90); addToMapW(0xde, 0xF8, 0xC4); addToMapW(0xde, 0xFF, 0x9E); addToMapW(0xdf, 0x00, 0xDF); addToMapW(0xdf, 0x0E, 0x3F); addToMapW(0xdf, 0x25, 0x80); addToMapW(0xdf, 0xFF, 0x9F); addToMapW(0xe0, 0x00, 0xD3); addToMapW(0xe0, 0x00, 0xF3); addToMapW(0xe0, 0x03, 0x91); addToMapW(0xe0, 0x03, 0xB1); addToMapW(0xe0, 0x04, 0x2F); addToMapW(0xe0, 0x04, 0x4F); addToMapW(0xe0, 0x06, 0x36); addToMapW(0xe0, 0x0E, 0x40); addToMapW(0xe0, 0xFE, 0xBD); addToMapW(0xe0, 0xFE, 0xBE); addToMapW(0xe0, 0xFE, 0xBF); addToMapW(0xe0, 0xFE, 0xC0); addToMapW(0xe1, 0x00, 0xDF); addToMapW(0xe1, 0x03, 0xB2); addToMapW(0xe1, 0x06, 0x37); addToMapW(0xe1, 0x0E, 0x41); addToMapW(0xe1, 0xFE, 0xC1); addToMapW(0xe1, 0xFE, 0xC2); addToMapW(0xe1, 0xFE, 0xC3); addToMapW(0xe1, 0xFE, 0xC4); addToMapW(0xe2, 0x00, 0xD4); addToMapW(0xe2, 0x00, 0xF4); addToMapW(0xe2, 0x01, 0x4C); addToMapW(0xe2, 0x01, 0x4D); addToMapW(0xe2, 0x03, 0x93); addToMapW(0xe2, 0x04, 0x20); addToMapW(0xe2, 0x04, 0x40); addToMapW(0xe2, 0x06, 0x38); addToMapW(0xe2, 0x0E, 0x42); addToMapW(0xe2, 0xFE, 0xC5); addToMapW(0xe2, 0xFE, 0xC6); addToMapW(0xe2, 0xFE, 0xC7); addToMapW(0xe2, 0xFE, 0xC8); addToMapW(0xe3, 0x00, 0xD2); addToMapW(0xe3, 0x00, 0xF2); addToMapW(0xe3, 0x01, 0x43); addToMapW(0xe3, 0x01, 0x44); addToMapW(0xe3, 0x03, 0xA0); addToMapW(0xe3, 0x03, 0xC0); addToMapW(0xe3, 0x06, 0x39); addToMapW(0xe3, 0x0E, 0x43); addToMapW(0xe3, 0xFE, 0xC9); addToMapW(0xe3, 0xFE, 0xCA); addToMapW(0xe3, 0xFE, 0xCB); addToMapW(0xe3, 0xFE, 0xCC); addToMapW(0xe4, 0x01, 0xA9); addToMapW(0xe4, 0x03, 0xA3); addToMapW(0xe4, 0x03, 0xC3); addToMapW(0xe4, 0x04, 0x21); addToMapW(0xe4, 0x04, 0x41); addToMapW(0xe4, 0x06, 0x3A); addToMapW(0xe4, 0x0E, 0x44); addToMapW(0xe4, 0x22, 0x11); addToMapW(0xe4, 0xFE, 0xCD); addToMapW(0xe4, 0xFE, 0xCE); addToMapW(0xe4, 0xFE, 0xCF); addToMapW(0xe4, 0xFE, 0xD0); addToMapW(0xe5, 0x00, 0xD5); addToMapW(0xe5, 0x00, 0xF5); addToMapW(0xe5, 0x06, 0x41); addToMapW(0xe5, 0x0E, 0x45); addToMapW(0xe5, 0xFE, 0xD1); addToMapW(0xe5, 0xFE, 0xD2); addToMapW(0xe5, 0xFE, 0xD3); addToMapW(0xe5, 0xFE, 0xD4); addToMapW(0xe6, 0x00, 0xB5); addToMapW(0xe6, 0x01, 0x60); addToMapW(0xe6, 0x01, 0x61); addToMapW(0xe6, 0x03, 0xBC); addToMapW(0xe6, 0x04, 0x22); addToMapW(0xe6, 0x04, 0x42); addToMapW(0xe6, 0x0E, 0x46); addToMapW(0xe7, 0x03, 0xA4); addToMapW(0xe7, 0x03, 0xC4); addToMapW(0xe7, 0x06, 0x42); addToMapW(0xe7, 0x0E, 0x47); addToMapW(0xe7, 0xF8, 0xBC); addToMapW(0xe7, 0xFE, 0xD5); addToMapW(0xe7, 0xFE, 0xD6); addToMapW(0xe7, 0xFE, 0xD7); addToMapW(0xe7, 0xFE, 0xD8); addToMapW(0xe8, 0x00, 0xD7); addToMapW(0xe8, 0x00, 0xDE); addToMapW(0xe8, 0x00, 0xFE); addToMapW(0xe8, 0x01, 0x36); addToMapW(0xe8, 0x01, 0x37); addToMapW(0xe8, 0x01, 0x54); addToMapW(0xe8, 0x01, 0x55); addToMapW(0xe8, 0x02, 0x78); addToMapW(0xe8, 0x03, 0xA6); addToMapW(0xe8, 0x03, 0xC6); addToMapW(0xe8, 0x04, 0x23); addToMapW(0xe8, 0x04, 0x43); addToMapW(0xe8, 0x06, 0x43); addToMapW(0xe8, 0x0E, 0x48); addToMapW(0xe8, 0x22, 0x05); addToMapW(0xe8, 0xFE, 0xD9); addToMapW(0xe8, 0xFE, 0xDA); addToMapW(0xe8, 0xFE, 0xDB); addToMapW(0xe8, 0xFE, 0xDC); addToMapW(0xe9, 0x00, 0xDA); addToMapW(0xe9, 0x00, 0xFA); addToMapW(0xe9, 0x03, 0x98); addToMapW(0xe9, 0x06, 0x44); addToMapW(0xe9, 0x0E, 0x49); addToMapW(0xe9, 0xFE, 0xDD); addToMapW(0xe9, 0xFE, 0xDE); addToMapW(0xe9, 0xFE, 0xDF); addToMapW(0xe9, 0xFE, 0xE0); addToMapW(0xea, 0x00, 0xDB); addToMapW(0xea, 0x00, 0xFB); addToMapW(0xea, 0x01, 0x3B); addToMapW(0xea, 0x01, 0x3C); addToMapW(0xea, 0x03, 0x86); addToMapW(0xea, 0x03, 0xA9); addToMapW(0xea, 0x03, 0xAC); addToMapW(0xea, 0x04, 0x16); addToMapW(0xea, 0x04, 0x36); addToMapW(0xea, 0x06, 0x45); addToMapW(0xea, 0x0E, 0x4A); addToMapW(0xea, 0x21, 0x26); addToMapW(0xea, 0xFE, 0xE1); addToMapW(0xea, 0xFE, 0xE2); addToMapW(0xea, 0xFE, 0xE3); addToMapW(0xea, 0xFE, 0xE4); addToMapW(0xeb, 0x00, 0xD9); addToMapW(0xeb, 0x00, 0xF9); addToMapW(0xeb, 0x01, 0x70); addToMapW(0xeb, 0x01, 0x71); addToMapW(0xeb, 0x03, 0x88); addToMapW(0xeb, 0x03, 0x94); addToMapW(0xeb, 0x03, 0xAD); addToMapW(0xeb, 0x03, 0xB4); addToMapW(0xeb, 0x06, 0x46); addToMapW(0xeb, 0x0E, 0x4B); addToMapW(0xeb, 0xFE, 0xE5); addToMapW(0xeb, 0xFE, 0xE6); addToMapW(0xeb, 0xFE, 0xE7); addToMapW(0xeb, 0xFE, 0xE8); addToMapW(0xec, 0x03, 0x01); addToMapW(0xec, 0x03, 0x89); addToMapW(0xec, 0x03, 0xAE); addToMapW(0xec, 0x04, 0x12); addToMapW(0xec, 0x04, 0x32); addToMapW(0xec, 0x06, 0x47); addToMapW(0xec, 0x0E, 0x4C); addToMapW(0xec, 0x22, 0x1E); addToMapW(0xec, 0xFE, 0xE9); addToMapW(0xec, 0xFE, 0xEA); addToMapW(0xec, 0xFE, 0xEB); addToMapW(0xec, 0xFE, 0xEC); addToMapW(0xed, 0x00, 0xDD); addToMapW(0xed, 0x00, 0xFD); addToMapW(0xed, 0x01, 0x12); addToMapW(0xed, 0x01, 0x13); addToMapW(0xed, 0x03, 0x8A); addToMapW(0xed, 0x03, 0xAF); addToMapW(0xed, 0x06, 0x48); addToMapW(0xed, 0x0E, 0x4D); addToMapW(0xed, 0xFE, 0xED); addToMapW(0xed, 0xFE, 0xEE); addToMapW(0xee, 0x00, 0xAF); addToMapW(0xee, 0x01, 0x45); addToMapW(0xee, 0x01, 0x46); addToMapW(0xee, 0x03, 0x04); addToMapW(0xee, 0x03, 0x05); addToMapW(0xee, 0x03, 0x8C); addToMapW(0xee, 0x03, 0x95); addToMapW(0xee, 0x03, 0xB5); addToMapW(0xee, 0x03, 0xCC); addToMapW(0xee, 0x04, 0x2C); addToMapW(0xee, 0x04, 0x4C); addToMapW(0xee, 0x06, 0x49); addToMapW(0xee, 0x0E, 0x4E); addToMapW(0xee, 0xFE, 0xEF); addToMapW(0xee, 0xFE, 0xF0); addToMapW(0xef, 0x00, 0xB4); addToMapW(0xef, 0x02, 0xB9); addToMapW(0xef, 0x02, 0xCA); addToMapW(0xef, 0x03, 0x01); addToMapW(0xef, 0x03, 0x8E); addToMapW(0xef, 0x03, 0xCD); addToMapW(0xef, 0x06, 0x4A); addToMapW(0xef, 0x0E, 0x4F); addToMapW(0xef, 0x20, 0x19); addToMapW(0xef, 0x20, 0x32); addToMapW(0xef, 0x20, 0x35); addToMapW(0xef, 0x21, 0x16); addToMapW(0xef, 0x22, 0x29); addToMapW(0xef, 0xFE, 0xF1); addToMapW(0xef, 0xFE, 0xF2); addToMapW(0xef, 0xFE, 0xF3); addToMapW(0xef, 0xFE, 0xF4); addToMapW(0xf0, 0x00, 0xAD); addToMapW(0xf0, 0x03, 0x8F); addToMapW(0xf0, 0x03, 0xCE); addToMapW(0xf0, 0x04, 0x01); addToMapW(0xf0, 0x04, 0x51); addToMapW(0xf0, 0x0E, 0x50); addToMapW(0xf0, 0x22, 0x61); addToMapW(0xf1, 0x00, 0xB1); addToMapW(0xf1, 0x02, 0xDD); addToMapW(0xf1, 0x06, 0x4B); addToMapW(0xf1, 0x0E, 0x51); addToMapW(0xf1, 0x22, 0x13); addToMapW(0xf1, 0xFE, 0x70); addToMapW(0xf1, 0xFE, 0x71); addToMapW(0xf2, 0x02, 0xDB); addToMapW(0xf2, 0x03, 0x23); addToMapW(0xf2, 0x04, 0x04); addToMapW(0xf2, 0x04, 0x2B); addToMapW(0xf2, 0x04, 0x4B); addToMapW(0xf2, 0x04, 0x54); addToMapW(0xf2, 0x06, 0x4C); addToMapW(0xf2, 0x0E, 0x52); addToMapW(0xf2, 0x20, 0x17); addToMapW(0xf2, 0x20, 0x1C); addToMapW(0xf2, 0x22, 0x65); addToMapW(0xf2, 0xF8, 0xBD); addToMapW(0xf2, 0xFE, 0x72); addToMapW(0xf3, 0x00, 0xBE); addToMapW(0xf3, 0x02, 0xC7); addToMapW(0xf3, 0x03, 0x0C); addToMapW(0xf3, 0x06, 0x4D); addToMapW(0xf3, 0x0E, 0x53); addToMapW(0xf3, 0x22, 0x64); addToMapW(0xf3, 0xFE, 0x74); addToMapW(0xf4, 0x00, 0xB6); addToMapW(0xf4, 0x02, 0xD8); addToMapW(0xf4, 0x03, 0x06); addToMapW(0xf4, 0x03, 0xAA); addToMapW(0xf4, 0x03, 0xCA); addToMapW(0xf4, 0x04, 0x07); addToMapW(0xf4, 0x04, 0x17); addToMapW(0xf4, 0x04, 0x37); addToMapW(0xf4, 0x04, 0x57); addToMapW(0xf4, 0x06, 0x4E); addToMapW(0xf4, 0x0E, 0x54); addToMapW(0xf4, 0x23, 0x20); addToMapW(0xf4, 0xFE, 0x76); addToMapW(0xf4, 0xFE, 0x77); addToMapW(0xf5, 0x00, 0xA7); addToMapW(0xf5, 0x03, 0xAB); addToMapW(0xf5, 0x03, 0xCB); addToMapW(0xf5, 0x06, 0x4F); addToMapW(0xf5, 0x0E, 0x55); addToMapW(0xf5, 0x23, 0x21); addToMapW(0xf5, 0xFE, 0x78); addToMapW(0xf5, 0xFE, 0x79); addToMapW(0xf6, 0x00, 0xF7); addToMapW(0xf6, 0x04, 0x0E); addToMapW(0xf6, 0x04, 0x28); addToMapW(0xf6, 0x04, 0x48); addToMapW(0xf6, 0x04, 0x5E); addToMapW(0xf6, 0x06, 0x50); addToMapW(0xf6, 0x0E, 0x56); addToMapW(0xf6, 0xFE, 0x7A); addToMapW(0xf6, 0xFE, 0x7B); addToMapW(0xf7, 0x00, 0xB8); addToMapW(0xf7, 0x00, 0xF7); addToMapW(0xf7, 0x02, 0xDB); addToMapW(0xf7, 0x03, 0x27); addToMapW(0xf7, 0x0E, 0x57); addToMapW(0xf7, 0x20, 0x1E); addToMapW(0xf7, 0x22, 0x48); addToMapW(0xf8, 0x00, 0xB0); addToMapW(0xf8, 0x02, 0xDA); addToMapW(0xf8, 0x03, 0x0A); addToMapW(0xf8, 0x04, 0x2D); addToMapW(0xf8, 0x04, 0x4D); addToMapW(0xf8, 0x0E, 0x58); addToMapW(0xf8, 0x20, 0x70); addToMapW(0xf8, 0x22, 0x18); addToMapW(0xf9, 0x00, 0xA8); addToMapW(0xf9, 0x02, 0xDD); addToMapW(0xf9, 0x03, 0x08); addToMapW(0xf9, 0x0E, 0x59); addToMapW(0xf9, 0x22, 0x19); addToMapW(0xfa, 0x00, 0xB7); addToMapW(0xfa, 0x02, 0xD9); addToMapW(0xfa, 0x03, 0x07); addToMapW(0xfa, 0x04, 0x29); addToMapW(0xfa, 0x04, 0x49); addToMapW(0xfa, 0x0E, 0x5A); addToMapW(0xfa, 0x20, 0x24); addToMapW(0xfa, 0x22, 0xC5); addToMapW(0xfa, 0x30, 0xFB); addToMapW(0xfb, 0x00, 0xB9); addToMapW(0xfb, 0x0E, 0x5B); addToMapW(0xfb, 0x20, 0x81); addToMapW(0xfb, 0x22, 0x1A); addToMapW(0xfb, 0x27, 0x13); addToMapW(0xfc, 0x00, 0xB3); addToMapW(0xfc, 0x01, 0x58); addToMapW(0xfc, 0x01, 0x59); addToMapW(0xfc, 0x04, 0x27); addToMapW(0xfc, 0x04, 0x47); addToMapW(0xfc, 0x20, 0x7F); addToMapW(0xfc, 0x20, 0x83); addToMapW(0xfc, 0x21, 0x16); addToMapW(0xfc, 0xF8, 0xC5); addToMapW(0xfd, 0x00, 0xA4); addToMapW(0xfd, 0x00, 0xA7); addToMapW(0xfd, 0x00, 0xB2); addToMapW(0xfd, 0x20, 0x82); addToMapW(0xfd, 0xF8, 0xC6); addToMapW(0xfd, 0xF8, 0xF1); addToMapW(0xfe, 0x20, 0xAB); addToMapW(0xfe, 0x25, 0xA0); addToMapW(0xfe, 0xF8, 0xC7); addToMapW(0xfe, 0xF8, 0xF2); addToMapW(0xff, 0x00, 0xA0); addToMapW(0xff, 0xF8, 0xC8); addToMapW(0xff, 0xF8, 0xF3); } rcracki-mt-0.7.0/rcracki_mt/COPYING0000640000175000017500000004325412043323152016230 0ustar dookiedookie GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Lesser General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. rcracki-mt-0.7.0/INSTALLING.txt0000640000175000017500000000023112043324160015250 0ustar dookiedookiePlease follow the INSTALLING.txt instructions in rcracki_mt (for cli cpu/gpu). Please follow the INSTALLING.txt instructions in rcracki_mt-gui for gui. rcracki-mt-0.7.0/COPYING0000640000175000017500000004325412043323152014112 0ustar dookiedookie GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Lesser General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License.