Программное средство для аудита паролей в информационных системах

find_Layout->addWidget(find_PushButton);

QVBoxLayout *main_Layout=new QVBoxLayout();

main_Layout->addWidget(table_task_status);

main_Layout->addLayout(add_task_Layout);

main_Layout->addWidget(table_hash_password);

main_Layout->addLayout(find_Layout);

QWidget *main_Widget=new QWidget(this);

main_Widget->setLayout(main_Layout);

setCentralWidget(main_Widget);

setWindowTitle(tr("Аудит паролей"));

//setMinimumWidth(1000);

// центрирование главного окна

main_window_Rect=new QRect();

add_task_window_Rect=new QRect();

*main_window_Rect=frameGeometry();

main_window_Rect->moveCenter(QDesktopWidget().availableGeometry().center());

move(main_window_Rect->topLeft());

// класс для работы с хэшами

thread_hash=new Hash();

connect(thread_hash,SIGNAL(complete()),this,SLOT(show_result()));

connect(thread_hash,SIGNAL(find_hash(QString,QString)),this,SLOT(show_find_password(QString,QString)));

connect(thread_hash,SIGNAL(message(QString)),this,SLOT(show_message(QString)));

connect(thread_hash,SIGNAL(start_timer()),timer,SLOT(start()));

// класс для окна "Добавить задачу"

window_add_task=new add_task_window(this);

connect(window_add_task,SIGNAL(ok()),this,SLOT(add_task()));

connect(window_add_task,SIGNAL(cansel()),this,SLOT(hide_add_task_window()));

}

void MainWindow::show_progress()

{

time_from_start++;

timer->start();

quint64 copy_current=thread_hash->current;

if (copy_current>0)

{

status->showMessage(tr("Прошло ")+word.setNum(time_from_start,10)+tr(" c. ")+

tr("Проверено ")+word1.setNum(copy_current,10)+tr(" шт. ")+

tr("Скорость ")+word2.setNum(copy_current-previous_current,10)+tr(" шт/с."));

previous_current=copy_current;

}

}

void MainWindow::show_result()

{

timer->stop();

status->showMessage(tr("Завершено за ")+word.setNum(time_from_start,10)+tr(" c. ")+

tr("Проверено вариантов ")+word1.setNum(thread_hash->current,10)+tr(" шт."));

unlock_button();

}

void MainWindow::show_find_password(const QString &password,const QString &hash)

{

if ((algorithm==type_linux_md5) || (algorithm==type_linux_sha256) || (algorithm==type_linux_sha512) || (algorithm==type_windows_NTLM))

{

for(quint8 i=0;i<table_hash_password->rowCount();i++)

if (table_hash_password->item(i,1)->text()==hash)

{

if (password.isEmpty())

{

QTableWidgetItem *newItem=new QTableWidgetItem(tr("%1").arg(tr("Пароль не установлен")));

newItem->setTextAlignment(Qt::AlignCenter);

newItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);

table_hash_password->setItem(i,3,newItem);

}

else

{

QTableWidgetItem *newItem=new QTableWidgetItem(tr("%1").arg(password));

newItem->setTextAlignment(Qt::AlignCenter);

newItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);

table_hash_password->setItem(i,3,newItem);

}

}

}

else if (algorithm==type_windows_LM)

{

// если пароль не установлен

if (hash=="aad3b435b51404eeaad3b435b51404ee")

{

for(quint8 i=0;i<table_hash_password->rowCount();i++)

if (table_hash_password->item(i,1)->text()==hash)

{

word=tr("Пароль не установлен");

QTableWidgetItem *newItem=new QTableWidgetItem(tr("%1").arg(word));

newItem->setTextAlignment(Qt::AlignCenter);

newItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);

table_hash_password->setItem(i,3,newItem);

}

return ;

}

else

{

// ищем по левым половинкам

for(quint8 i=0;i<table_hash_password->rowCount();i++)

if (table_hash_password->item(i,1)->text().left(16)==hash)

{

QString password_from_table=table_hash_password->item(i,3)->text();

QString hash_from_table=table_hash_password->item(i,1)->text();

// если правая еще не найдена

if (password_from_table.isEmpty())

{

if (hash_from_table.right(16)=="aad3b435b51404ee")

word=password;

else

word=password+"*******";

}

// если правая уже найдена

else

word=password_from_table.replace("*******",password);

QTableWidgetItem *newItem=new QTableWidgetItem(tr("%1").arg(word));

newItem->setTextAlignment(Qt::AlignCenter);

newItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);

table_hash_password->setItem(i,3,newItem);

return ;

}

// ищем по правым половинкам

for(quint8 i=0;i<table_hash_password->rowCount();i++)

if (table_hash_password->item(i,1)->text().right(16)==hash)

{

QString password_from_table=table_hash_password->item(i,3)->text();

if (password_from_table.isEmpty())

word="*******"+password;

else

word=password_from_table.replace("*******",password);

QTableWidgetItem *newItem=new QTableWidgetItem(tr("%1").arg(word));

newItem->setTextAlignment(Qt::AlignCenter);

newItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);

table_hash_password->setItem(i,3,newItem);

return ;

}

}

}

}

void MainWindow::show_message(const QString &message)

{

QTableWidgetItem *newItem=new QTableWidgetItem(tr("%1").arg(message));

newItem->setTextAlignment(Qt::AlignCenter);

newItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);

table_task_status->setItem(number_task,1,newItem);

if (message!=tr("В процессе"))

number_task++;

}

void MainWindow::go()

{

if (table_hash_password->rowCount()!=0)

{

if (table_task_status->rowCount()!=0)

{

clear_tables();

clear_parametrs();

thread_hash->clear_parametrs();

quint8 i=0;

while(i!=table_task_status->rowCount())

{

thread_hash->tasks->append(table_task_status->item(i,2)->text());

i++;

}

i=0;

while(i!=table_hash_password->rowCount())

{

thread_hash->before_hash_vector->append(table_hash_password->item(i,1)->text().toAscii().data());

thread_hash->before_salt_vector->append(table_hash_password->item(i,2)->text().toAscii().data());

thread_hash->login_vector->append(table_hash_password->item(i,0)->text().toAscii().data());

i++;

}

thread_hash->type=algorithm;

thread_hash->start(QThread::TimeCriticalPriority);

lock_button();

}

}

}

void MainWindow::stop()

{

thread_hash->stopped=true;

thread_hash->wait();

}

void MainWindow::closeEvent(QCloseEvent *event)

{

thread_hash->stopped=true;

thread_hash->wait();

event->accept();

}

void MainWindow::clear_parametrs()

{

previous_current=0;

time_from_start=0;

number_task=0;

status->showMessage("");

}

void MainWindow::add_task()

{

QString task;

QString table_task_status_task;

task.clear();

table_task_status_task.clear();

bool yes_or_no=false;

switch(window_add_task->tab->currentIndex())

{

case 0:

if ((!window_add_task->brute_force_alpha_LineEdit->text().isEmpty()) &&

(window_add_task->brute_force_min_length_SpinBox->value()<=window_add_task->brute_force_max_length_SpinBox->value()))

{

task.append("0");

task.append("arg1");

task.append(window_add_task->brute_force_alpha_LineEdit->text());

task.append("arg2");

task.append(word1.setNum(window_add_task->brute_force_min_length_SpinBox->value(),10));

task.append("arg3");

task.append(word1.setNum(window_add_task->brute_force_max_length_SpinBox->value(),10));

task.append("arg4");

table_task_status_task.append(tr("Полный перебор на алфавите \""));

table_task_status_task.append(window_add_task->brute_force_alpha_LineEdit->text());

table_task_status_task.append(tr("\" с длиной пароля от "));

table_task_status_task.append(word1.setNum(window_add_task->brute_force_min_length_SpinBox->value(),10));

table_task_status_task.append(tr(" до "));

table_task_status_task.append(word1.setNum(window_add_task->brute_force_max_length_SpinBox->value(),10));

table_task_status_task.append(tr(" символов"));

yes_or_no=true;

}

break;

case 1:

if ((!window_add_task->brute_force_on_mask_alpha_LineEdit->text().isEmpty()) &&

(!window_add_task->brute_force_on_mask_mask_LineEdit->text().isEmpty()) &&

(window_add_task->brute_force_on_mask_min_on_left_length_SpinBox->value()<=window_add_task->brute_force_on_mask_max_on_left_length_SpinBox->value()) &&

(window_add_task->brute_force_on_mask_min_on_right_length_SpinBox->value()<=window_add_task->brute_force_on_mask_max_on_right_length_SpinBox->value()))

{

task.append("1");

task.append("arg1");

task.append(window_add_task->brute_force_on_mask_alpha_LineEdit->text());

task.append("arg2");

task.append(window_add_task->brute_force_on_mask_mask_LineEdit->text());

task.append("arg3");

task.append(word1.setNum(window_add_task->brute_force_on_mask_min_on_left_length_SpinBox->value(),10));

task.append("arg4");

task.append(word1.setNum(window_add_task->brute_force_on_mask_max_on_left_length_SpinBox->value(),10));

task.append("arg5");

task.append(word1.setNum(window_add_task->brute_force_on_mask_min_on_right_length_SpinBox->value(),10));

task.append("arg6");

task.append(word1.setNum(window_add_task->brute_force_on_mask_max_on_right_length_SpinBox->value(),10));

task.append("arg7");

table_task_status_task.append(tr("Поиск по маске на алфавите \""));

table_task_status_task.append(window_add_task->brute_force_on_mask_alpha_LineEdit->text());

table_task_status_task.append(tr("\" с маской \""));

table_task_status_task.append(window_add_task->brute_force_on_mask_mask_LineEdit->text());

table_task_status_task.append(tr("\", количеством символов слева от маски от "));

table_task_status_task.append(word1.setNum(window_add_task->brute_force_on_mask_min_on_left_length_SpinBox->value(),10));

table_task_status_task.append(tr(" до "));

table_task_status_task.append(word1.setNum(window_add_task->brute_force_on_mask_max_on_left_length_SpinBox->value(),10));

table_task_status_task.append(tr(", количеством символов справа от маски от "));

table_task_status_task.append(word1.setNum(window_add_task->brute_force_on_mask_min_on_right_length_SpinBox->value(),10));

table_task_status_task.append(tr(" до "));

table_task_status_task.append(word1.setNum(window_add_task->brute_force_on_mask_max_on_right_length_SpinBox->value(),10));

yes_or_no=true;

}

break;

case 2:

if (!window_add_task->brute_force_on_dictionary_filename_LineEdit->text().isEmpty())

{

task.append("2");

task.append("arg1");

task.append(window_add_task->brute_force_on_dictionary_filename_LineEdit->text());

task.append("arg2");

table_task_status_task.append(tr("Поиск по словарю \""));

table_task_status_task.append(window_add_task->brute_force_on_dictionary_filename_LineEdit->text());

table_task_status_task.append(tr("\""));

yes_or_no=true;

}

break;

case 3:

if ((!window_add_task->brute_force_on_dictionaries_filename1_LineEdit->text().isEmpty()) &&

(!window_add_task->brute_force_on_dictionaries_filename2_LineEdit->text().isEmpty()))

{

task.append("3");

task.append("arg1");

task.append(window_add_task->brute_force_on_dictionaries_filename1_LineEdit->text());

task.append("arg2");

task.append(window_add_task->brute_force_on_dictionaries_filename2_LineEdit->text());

task.append("arg3");

table_task_status_task.append(tr("Комбинированный поиск по словарям \""));

table_task_status_task.append(window_add_task->brute_force_on_dictionaries_filename1_LineEdit->text());

table_task_status_task.append(tr("\" и \""));

table_task_status_task.append(window_add_task->brute_force_on_dictionaries_filename2_LineEdit->text());

table_task_status_task.append(tr("\" с конкатенацией исходных вариантов пароля"));

yes_or_no=true;

}

break;

case 4:

if (!window_add_task->brute_force_on_dictionary_gybrid_filename_LineEdit->text().isEmpty())

{

task.append("4");

task.append("arg1");

task.append(window_add_task->brute_force_on_dictionary_gybrid_filename_LineEdit->text());

task.append("arg2");

table_task_status_task.append(tr("Гибридный поиск по словарю \""));

table_task_status_task.append(window_add_task->brute_force_on_dictionary_gybrid_filename_LineEdit->text());

table_task_status_task.append(tr("\""));

yes_or_no=true;

}

break;

case 5:

if ((!window_add_task->brute_force_on_dictionaries_gybrid_filename1_LineEdit->text().isEmpty()) &&

(!window_add_task->brute_force_on_dictionaries_gybrid_filename2_LineEdit->text().isEmpty()))

{

task.append("5");

task.append("arg1");

task.append(window_add_task->brute_force_on_dictionaries_gybrid_filename1_LineEdit->text());

task.append("arg2");

task.append(window_add_task->brute_force_on_dictionaries_gybrid_filename2_LineEdit->text());

task.append("arg3");

table_task_status_task.append(tr("Гибридный поиск по словарям \""));

table_task_status_task.append(window_add_task->brute_force_on_dictionaries_filename1_LineEdit->text());

table_task_status_task.append(tr("\" и \""));

table_task_status_task.append(window_add_task->brute_force_on_dictionaries_filename2_LineEdit->text());

table_task_status_task.append(tr("\" с конкатенацией исходных вариантов пароля"));

yes_or_no=true;

}

break;

}

if (yes_or_no)

{

table_task_status->insertRow(table_task_status->rowCount());

QTableWidgetItem *newItem=new QTableWidgetItem(tr("%1").arg(table_task_status_task));

newItem->setTextAlignment(Qt::AlignCenter);

newItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);

table_task_status->setItem(table_task_status->rowCount()-1,0,newItem);

QTableWidgetItem *newItem1=new QTableWidgetItem(tr("%1").arg(""));

newItem1->setTextAlignment(Qt::AlignCenter);

newItem1->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);

table_task_status->setItem(table_task_status->rowCount()-1,1,newItem1);

QTableWidgetItem *newItem2=new QTableWidgetItem(tr("%1").arg(task));

table_task_status->setItem(table_task_status->rowCount()-1,2,newItem2);

table_task_status->resizeRowsToContents();

hide_add_task_window();

}

}

void MainWindow::del_task()

{

quint8 i=0;

while(i<table_task_status->rowCount())

{

if (table_task_status->isItemSelected(table_task_status->item(i,0)))

{

table_task_status->removeRow(i);

i=0;

continue;

}

i++;

}

}

void MainWindow::lock_button()

{

go_PushButton->setEnabled(false);

add_task_PushButton->setEnabled(false);

del_task_PushButton->setEnabled(false);

change_path_PushButton->setEnabled(false);

find_PushButton->setEnabled(false);

stop_PushButton->setEnabled(true);

}

void MainWindow::unlock_button()

{

go_PushButton->setEnabled(true);

add_task_PushButton->setEnabled(true);

del_task_PushButton->setEnabled(true);

change_path_PushButton->setEnabled(true);

find_PushButton->setEnabled(true);

stop_PushButton->setEnabled(false);

}

void MainWindow::clear_tables()

{

quint8 i=0;

while(i!=table_task_status->rowCount())

{

QTableWidgetItem *newItem=new QTableWidgetItem(tr("%1").arg(""));

newItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);

table_task_status->setItem(i,1,newItem);

i++;

}

i=0;

while(i!=table_hash_password->rowCount())

{

QTableWidgetItem *newItem=new QTableWidgetItem(tr("%1").arg(""));

newItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);

table_hash_password->setItem(i,3,newItem);

i++;

}

}

void MainWindow::change_path()

{

if (!path_LineEdit->text().isEmpty())

{

if ((path=QFileDialog::getExistingDirectory(this,tr("Открыть директорию")))!=NULL)

path_LineEdit->setText(path);

}

}

void MainWindow::find_system()

{

status->showMessage("");

algorithm=100;

// удаляем старые записи в таблицах

while(table_hash_password->rowCount())

table_hash_password->removeRow(0);

while(table_task_status->rowCount())

table_task_status->removeRow(0);

if (!path_LineEdit->text().isEmpty())

{

path=path_LineEdit->text();

if (QFile(path+"etc/passwd").exists())

{

get_info_from_linux();

// определяем алгоритм хэширования

if (table_hash_password->item(0,2)->text().left(2)=="$1")

algorithm=type_linux_md5;

else if (table_hash_password->item(0,2)->text().left(2)=="$5")

algorithm=type_linux_sha256;

else if (table_hash_password->item(0,2)->text().left(2)=="$6")

algorithm=type_linux_sha512;

auto_task();

// забиваем пароли пустыми ячейками

for(quint8 i=0;i<table_hash_password->rowCount();i++)

{

QTableWidgetItem *newItem=new QTableWidgetItem(tr("%1").arg(""));

newItem->setTextAlignment(Qt::AlignCenter);

newItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);

table_hash_password->setItem(i,3,newItem);

}

add_task_PushButton->setEnabled(true);

del_task_PushButton->setEnabled(true);

go_PushButton->setEnabled(true);

}

else if (QFile(path+"/WINDOWS/").exists())

{

get_info_from_windows();

auto_task();

for(quint8 i=0;i<table_hash_password->rowCount();i++)

{

QTableWidgetItem *newItem=new QTableWidgetItem(tr("%1").arg(""));

newItem->setTextAlignment(Qt::AlignCenter);

newItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);

table_hash_password->setItem(i,3,newItem);

}

add_task_PushButton->setEnabled(true);

del_task_PushButton->setEnabled(true);

go_PushButton->setEnabled(true);

}

else

status->showMessage(tr("Информационная система не найдена"));

}

// выводим в статусную строку информацию о найденной информационной системе

if (algorithm==type_linux_md5)

status->showMessage(tr("Тип хэш-функции - md5(Unix)"));

else if (algorithm==type_linux_sha256)

status->showMessage(tr("Тип хэш-функции - sha256(Unix)"));

else if (algorithm==type_linux_sha512)

status->showMessage(tr("Тип хэш-функции - sha512(Unix)"));

else if (algorithm==type_windows_LM)

status->showMessage(tr("Тип хэш-функции - LM"));

else if (algorithm==type_windows_NTLM)

status->showMessage(tr("Тип хэш-функции - NTLM"));

}

void MainWindow::get_info_from_linux()

{

QFile file(path+"etc/passwd");

// открываем файл /etc/passwd

if (!file.open(QIODevice::ReadOnly | QIODevice::Text))

{

status->showMessage(tr("Не хватает прав доступа для файла ")+path+tr("etc/passwd"));

return ;

}

else

{

char buf[1024];

qint8 lineLength_from_passwd;

qint8 lineLength_from_shadow;

// считываем построчно из файла /etc/passwd

while((lineLength_from_passwd=file.readLine(buf,sizeof(buf)))!=-1)

{

// проверяем используется ли теневое хранение паролей

QString line_from_passwd=QByteArray(buf,lineLength_from_passwd).simplified();

reg.setPattern(":.*:");

line_from_passwd.indexOf(reg);

QString hash_from_passwd=reg.capturedTexts().at(0);

hash_from_passwd.remove(0,1);

hash_from_passwd.chop(1);

QString login_from_passwd=line_from_passwd.left(line_from_passwd.indexOf(":"));

// если используется теневое хранение

if (hash_from_passwd=="x")

{

// открываем файл /etc/shadow

QFile file1(path+"etc/shadow");

if (!file1.open(QIODevice::ReadOnly | QIODevice::Text))

status->showMessage(tr("Не хватает прав доступа для файла ")+path+tr("etc/shadow"));

else

{

// считываем из файла /etc/shadow

while((lineLength_from_shadow=file1.readLine(buf,sizeof(buf)))!=-1)

{

QString line_from_shadow=QByteArray(buf,lineLength_from_shadow).simplified();

QString login_from_shadow=line_from_shadow.left(line_from_shadow.indexOf(":"));

// если имена совпали

if (login_from_passwd==login_from_shadow)

{

reg.setPattern(":.*:");

line_from_shadow.indexOf(reg);

QString hash_from_shadow=reg.capturedTexts().at(0);

hash_from_shadow.remove(0,1);

hash_from_shadow.chop(1);

// если учетка не отключена и не заблокирована, пароль задан

if ((hash_from_shadow!="*") && (hash_from_shadow!="!") && (hash_from_shadow!="NP") && (hash_from_shadow!="LK") && (hash_from_shadow!="!!"))

{

table_hash_password->insertRow(table_hash_password->rowCount());

QTableWidgetItem *newItem=new QTableWidgetItem(tr("%1").arg(login_from_shadow));

newItem->setTextAlignment(Qt::AlignCenter);

newItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);

table_hash_password->setItem(table_hash_password->rowCount()-1,0,newItem);

QTableWidgetItem *newItem1=new QTableWidgetItem(tr("%1").arg(hash_from_shadow));

newItem1->setTextAlignment(Qt::AlignCenter);

newItem1->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);

table_hash_password->setItem(table_hash_password->rowCount()-1,1,newItem1);

QTableWidgetItem *newItem2=new QTableWidgetItem(tr("%1").arg(find_salt(hash_from_shadow)));

newItem2->setTextAlignment(Qt::AlignCenter);

newItem2->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);

table_hash_password->setItem(table_hash_password->rowCount()-1,2,newItem2);

}

break;

}

}

file1.close();

}

}

// иначе если учетка не отключена

else if ((hash_from_passwd!="*") && (hash_from_passwd!="!") && (hash_from_passwd!="NP") && (hash_from_passwd!="LK") && (hash_from_passwd!="!!"))

{

table_hash_password->insertRow(table_hash_password->rowCount());

QTableWidgetItem *newItem=new QTableWidgetItem(tr("%1").arg(login_from_passwd));

newItem->setTextAlignment(Qt::AlignCenter);

newItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);

table_hash_password->setItem(table_hash_password->rowCount()-1,0,newItem);

QTableWidgetItem *newItem1=new QTableWidgetItem(tr("%1").arg(hash_from_passwd));

newItem1->setTextAlignment(Qt::AlignCenter);

newItem1->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);

table_hash_password->setItem(table_hash_password->rowCount()-1,1,newItem1);

QTableWidgetItem *newItem2=new QTableWidgetItem(tr("%1").arg(hash_from_passwd));

newItem2->setTextAlignment(Qt::AlignCenter);

newItem2->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);

table_hash_password->setItem(table_hash_password->rowCount()-1,2,newItem2);

}

}

file.close();

}

}

void MainWindow::get_info_from_windows()

{

QProcess *script=new QProcess(this);

QString program="/usr/bin/bkhive";

QStringList arguments;

arguments<<path+"/WINDOWS/system32/config/system"<<QDir::current().path()+"/test.txt";

script->start(program,arguments);

script->waitForFinished();

if (script->exitStatus()==QProcess::NormalExit)

{

arguments.clear();

script->close();

program="/usr/bin/samdump2";

arguments<<path+"/WINDOWS/system32/config/SAM"<<QDir::current().path()+"/test.txt";

script->start(program,arguments);

script->waitForFinished();

QFile(QDir::current().path()+"/test.txt").remove();

if (script->exitStatus()==QProcess::NormalExit)

{

QTextCodec::setCodecForCStrings(QTextCodec::codecForName("windows1251"));

QString info_from_SAM=script->readAllStandardOutput().simplified();

QList<QString> tags=info_from_SAM.split(':');

QString tag;

bool use_LM=true;

// проверяем используются ли LM хэши

for(quint16 i=0;i<tags.count()-1;i+=6)

{

if ((tags.at(i+2).isEmpty()) || (tags.at(i+2)=="aad3b435b51404eeaad3b435b51404ee"))

{

use_LM=false;

break;

}

}

if (use_LM)

algorithm=type_windows_LM;

else

algorithm=type_windows_NTLM;

//use_LM=true; // убрать

//algorithm=type_windows_LM;

for(quint16 i=0;i<tags.count()-1;i+=6)

{

table_hash_password->insertRow(table_hash_password->rowCount());

tag=tags.at(i);

QTableWidgetItem *newItem=new QTableWidgetItem(tr("%1").arg(tag));

newItem->setTextAlignment(Qt::AlignCenter);

//newItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);

table_hash_password->setItem(table_hash_password->rowCount()-1,0,newItem);

if (use_LM)

tag=tags.at(i+2);

else

tag=tags.at(i+3);

QTableWidgetItem *newItem1=new QTableWidgetItem(tr("%1").arg(tag));

newItem1->setTextAlignment(Qt::AlignCenter);

//newItem1->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);

table_hash_password->setItem(table_hash_password->rowCount()-1,1,newItem1);

if (use_LM)

tag=tags.at(i+3);

else

tag=tags.at(i+2);

QTableWidgetItem *newItem2=new QTableWidgetItem(tr("%1").arg(tag));

newItem2->setTextAlignment(Qt::AlignCenter);

//newItem2->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);

table_hash_password->setItem(table_hash_password->rowCount()-1,2,newItem2);

}

}

else

status->showMessage(tr("Ошибка при получении bootkey"));

}

else

status->showMessage(tr("Ошибка при получении хэшей"));

}

QString MainWindow::find_salt(const QString &hash)

{

reg.setPattern("\\$.*\\$");

hash.indexOf(reg);

QString type_alg;

type_alg=reg.capturedTexts().at(0);

if ((type_alg=="$1$") || (type_alg=="$5$") || (type_alg=="$6$"))

return hash.left(hash.lastIndexOf("$")+1);

else

return "";

}

void MainWindow::add_task_linux_md5()

{

QString task;

QString table_task_status_task;

task.clear();

table_task_status_task.clear();

/*

*/

QTableWidgetItem *newItem=new QTableWidgetItem(tr("%1").arg(table_task_status_task));

newItem->setTextAlignment(Qt::AlignCenter);

newItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);

table_task_status->setItem(table_task_status->rowCount()-1,0,newItem);

QTableWidgetItem *newItem1=new QTableWidgetItem(tr("%1").arg(""));

newItem1->setTextAlignment(Qt::AlignCenter);

newItem1->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);

table_task_status->setItem(table_task_status->rowCount()-1,1,newItem1);

QTableWidgetItem *newItem2=new QTableWidgetItem(tr("%1").arg(task));

table_task_status->setItem(table_task_status->rowCount()-1,2,newItem2);

table_task_status->resizeRowsToContents();

}

void MainWindow::add_task_linux_sha256()

{

QString task;

QString table_task_status_task;

task.clear();

table_task_status_task.clear();

/*

*/

QTableWidgetItem *newItem=new QTableWidgetItem(tr("%1").arg(table_task_status_task));

newItem->setTextAlignment(Qt::AlignCenter);

newItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);

table_task_status->setItem(table_task_status->rowCount()-1,0,newItem);

QTableWidgetItem *newItem1=new QTableWidgetItem(tr("%1").arg(""));

newItem1->setTextAlignment(Qt::AlignCenter);

newItem1->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);

table_task_status->setItem(table_task_status->rowCount()-1,1,newItem1);

QTableWidgetItem *newItem2=new QTableWidgetItem(tr("%1").arg(task));

table_task_status->setItem(table_task_status->rowCount()-1,2,newItem2);

table_task_status->resizeRowsToContents();

}

void MainWindow::add_task_linux_sha512()

{

QString task;

QString table_task_status_task;

task.clear();

table_task_status_task.clear();

/*

*/

QTableWidgetItem *newItem=new QTableWidgetItem(tr("%1").arg(table_task_status_task));

newItem->setTextAlignment(Qt::AlignCenter);

newItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);

table_task_status->setItem(table_task_status->rowCount()-1,0,newItem);

QTableWidgetItem *newItem1=new QTableWidgetItem(tr("%1").arg(""));

newItem1->setTextAlignment(Qt::AlignCenter);

newItem1->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);

table_task_status->setItem(table_task_status->rowCount()-1,1,newItem1);

QTableWidgetItem *newItem2=new QTableWidgetItem(tr("%1").arg(task));

table_task_status->setItem(table_task_status->rowCount()-1,2,newItem2);

table_task_status->resizeRowsToContents();

}

void MainWindow::add_task_windows_LM()

{

QString task;

QString table_task_status_task;

task.clear();

table_task_status_task.clear();

// предварительный анализ

task.append("6");

table_task_status_task.append(tr("Предварительный анализ"));

table_task_status->insertRow(table_task_status->rowCount());

QTableWidgetItem *newItem=new QTableWidgetItem(tr("%1").arg(table_task_status_task));

newItem->setTextAlignment(Qt::AlignCenter);

newItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);

table_task_status->setItem(table_task_status->rowCount()-1,0,newItem);

QTableWidgetItem *newItem1=new QTableWidgetItem(tr("%1").arg(""));

newItem1->setTextAlignment(Qt::AlignCenter);

newItem1->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);

table_task_status->setItem(table_task_status->rowCount()-1,1,newItem1);

QTableWidgetItem *newItem2=new QTableWidgetItem(tr("%1").arg(task));

table_task_status->setItem(table_task_status->rowCount()-1,2,newItem2);

table_task_status->resizeRowsToContents();

}

void MainWindow::add_task_windows_NTLM()

{

QString task;

QString table_task_status_task;

task.clear();

table_task_status_task.clear();

// предварительный анализ

task.append("6");

table_task_status_task.append(tr("Предварительный анализ"));

table_task_status->insertRow(table_task_status->rowCount());

QTableWidgetItem *newItem=new QTableWidgetItem(tr("%1").arg(table_task_status_task));

newItem->setTextAlignment(Qt::AlignCenter);

newItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);

table_task_status->setItem(table_task_status->rowCount()-1,0,newItem);

QTableWidgetItem *newItem1=new QTableWidgetItem(tr("%1").arg(""));

newItem1->setTextAlignment(Qt::AlignCenter);

newItem1->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);

table_task_status->setItem(table_task_status->rowCount()-1,1,newItem1);

QTableWidgetItem *newItem2=new QTableWidgetItem(tr("%1").arg(task));

table_task_status->setItem(table_task_status->rowCount()-1,2,newItem2);

task.clear();

table_task_status_task.clear();

// перебор на 0-9

task.append("0");

task.append("arg1");

task.append("0123456789");

task.append("arg2");

task.append(word1.setNum(1,10));

task.append("arg3");

task.append(word1.setNum(8,10));

task.append("arg4");

table_task_status_task.append(tr("Полный перебор на алфавите \""));

table_task_status_task.append("0123456789");

table_task_status_task.append(tr("\" с длиной пароля от "));

table_task_status_task.append(word1.setNum(1,10));

table_task_status_task.append(tr(" до "));

table_task_status_task.append(word1.setNum(8,10));

table_task_status_task.append(tr(" символов"));

table_task_status->insertRow(table_task_status->rowCount());

QTableWidgetItem *newItem3=new QTableWidgetItem(tr("%1").arg(table_task_status_task));

newItem3->setTextAlignment(Qt::AlignCenter);

newItem3->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);

table_task_status->setItem(table_task_status->rowCount()-1,0,newItem3);

QTableWidgetItem *newItem4=new QTableWidgetItem(tr("%1").arg(""));

newItem4->setTextAlignment(Qt::AlignCenter);

newItem4->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);

table_task_status->setItem(table_task_status->rowCount()-1,1,newItem4);

QTableWidgetItem *newItem5=new QTableWidgetItem(tr("%1").arg(task));

table_task_status->setItem(table_task_status->rowCount()-1,2,newItem5);

table_task_status->resizeRowsToContents();

}

void MainWindow::auto_task()

{

switch(algorithm)

{

case type_linux_md5:

add_task_linux_md5();

break;

case type_windows_LM:

add_task_windows_LM();

break;

case type_windows_NTLM:

add_task_windows_NTLM();

break;

case type_linux_sha256:

add_task_linux_sha256();

break;

case type_linux_sha512:

add_task_linux_sha512();

break;

}

}

void MainWindow::show_add_task_window()

{

window_add_task->show();

}

void MainWindow::hide_add_task_window()

{

window_add_task->hide();

}

add_task_window.h

#ifndef ADD_TASK_WINDOW_H

#define ADD_TASK_WINDOW_H

#include <QDialog>

QT_BEGIN_NAMESPACE

class QGroupBox;

class QLabel;

class QLineEdit;

class QSpinBox;

class QTabWidget;

QT_END_NAMESPACE

class add_task_window : public QDialog

{

Q_OBJECT

public:

add_task_window(QWidget *parent=0);

QTabWidget *tab;

QGroupBox *brute_force_GroupBox;

QLineEdit *brute_force_alpha_LineEdit;

QSpinBox *brute_force_min_length_SpinBox,

*brute_force_max_length_SpinBox;

QPushButton *brute_force_add_PushButton;

QLabel *label1,*label3,*label4;

QGroupBox *brute_force_on_mask_GroupBox;

QLineEdit *brute_force_on_mask_alpha_LineEdit,

*brute_force_on_mask_mask_LineEdit;

QSpinBox *brute_force_on_mask_min_on_left_length_SpinBox,

*brute_force_on_mask_max_on_left_length_SpinBox,

*brute_force_on_mask_min_on_right_length_SpinBox,

*brute_force_on_mask_max_on_right_length_SpinBox;

QPushButton *brute_force_on_mask_add_PushButton;

QLabel *label5,*label7,*label8,*label9,*label10,*label11;

QGroupBox *brute_force_on_dictionary_GroupBox;

QLineEdit *brute_force_on_dictionary_filename_LineEdit;

QPushButton *brute_force_on_dictionary_filename_PushButton;

QLabel *label12;

QGroupBox *brute_force_on_dictionaries_GroupBox;

QLineEdit *brute_force_on_dictionaries_filename1_LineEdit,

*brute_force_on_dictionaries_filename2_LineEdit;

QPushButton *brute_force_on_dictionaries_filename1_PushButton,

*brute_force_on_dictionaries_filename2_PushButton;

QLabel *label14,*label15;

QGroupBox *brute_force_on_dictionary_gybrid_GroupBox;

QLineEdit *brute_force_on_dictionary_gybrid_filename_LineEdit;

QPushButton *brute_force_on_dictionary_gybrid_filename_PushButton;

QLabel *label17;

QGroupBox *brute_force_on_dictionaries_gybrid_GroupBox;

QLineEdit *brute_force_on_dictionaries_gybrid_filename1_LineEdit,

*brute_force_on_dictionaries_gybrid_filename2_LineEdit;

QPushButton *brute_force_on_dictionaries_gybrid_filename1_PushButton,

*brute_force_on_dictionaries_gybrid_filename2_PushButton;

QLabel *label19,*label20;

signals:

void ok();

void cansel();

private slots:

void add_file_1();

void add_file_2();

void add_file_3();

void add_file_4();

void add_file_5();

void add_file_6();

void add_file();

private:

QPushButton *ok_PushButton,

*cansel_PushButton;

};

#endif

add_task_window.cpp

#include <QtGui>

#include "add_task_window.h"

add_task_window::add_task_window(QWidget *parent):QDialog(parent)

{

ok_PushButton=new QPushButton(this);

ok_PushButton->setText(tr("Добавить"));

connect(ok_PushButton,SIGNAL(clicked()),this,SIGNAL(ok()));

cansel_PushButton=new QPushButton(this);

cansel_PushButton->setText(tr("Отменить"));

connect(cansel_PushButton,SIGNAL(clicked()),this,SIGNAL(cansel()));

brute_force_GroupBox=new QGroupBox(this);

brute_force_alpha_LineEdit=new QLineEdit(this);

brute_force_alpha_LineEdit->setAlignment(Qt::AlignRight);

brute_force_alpha_LineEdit->setText("abcdefghijklmnopqrstuvwxyz0123456789");

brute_force_min_length_SpinBox=new QSpinBox(this);

brute_force_min_length_SpinBox->setMinimum(1);

brute_force_max_length_SpinBox=new QSpinBox(this);

brute_force_max_length_SpinBox->setMinimum(1);

brute_force_max_length_SpinBox->setValue(5);

label1=new QLabel(this);

label1->setText(tr("Алфавит"));

label3=new QLabel(this);

label3->setText(tr("Минимальная длина пароля"));

label4=new QLabel(this);

label4->setText(tr("Максимальная длина пароля"));

QHBoxLayout *brute_force_alpha_Layout=new QHBoxLayout();

brute_force_alpha_Layout->addWidget(label1);

brute_force_alpha_Layout->addWidget(brute_force_alpha_LineEdit);

QHBoxLayout *brute_force_min_length_Layout=new QHBoxLayout();

brute_force_min_length_Layout->addWidget(label3);

brute_force_min_length_Layout->addStretch();

brute_force_min_length_Layout->addWidget(brute_force_min_length_SpinBox);

QHBoxLayout *brute_force_max_length_Layout=new QHBoxLayout();

brute_force_max_length_Layout->addWidget(label4);

brute_force_max_length_Layout->addStretch();

brute_force_max_length_Layout->addWidget(brute_force_max_length_SpinBox);

QVBoxLayout *brute_force_Layout=new QVBoxLayout();

brute_force_Layout->addLayout(brute_force_alpha_Layout);

brute_force_Layout->addLayout(brute_force_min_length_Layout);

brute_force_Layout->addLayout(brute_force_max_length_Layout);

brute_force_Layout->addStretch();

brute_force_GroupBox->setLayout(brute_force_Layout);

brute_force_on_mask_GroupBox=new QGroupBox(this);

brute_force_on_mask_alpha_LineEdit=new QLineEdit(this);

brute_force_on_mask_alpha_LineEdit->setAlignment(Qt::AlignRight);

brute_force_on_mask_mask_LineEdit=new QLineEdit(this);

brute_force_on_mask_mask_LineEdit->setAlignment(Qt::AlignRight);

brute_force_on_mask_min_on_left_length_SpinBox=new QSpinBox(this);

brute_force_on_mask_min_on_left_length_SpinBox->setMinimum(0);

brute_force_on_mask_max_on_left_length_SpinBox=new QSpinBox(this);

brute_force_on_mask_max_on_left_length_SpinBox->setMinimum(0);

brute_force_on_mask_min_on_right_length_SpinBox=new QSpinBox(this);

brute_force_on_mask_min_on_right_length_SpinBox->setMinimum(0);

brute_force_on_mask_max_on_right_length_SpinBox=new QSpinBox(this);

brute_force_on_mask_max_on_right_length_SpinBox->setMinimum(0);

label5=new QLabel(this);

label5->setText(tr("Алфавит"));

label7=new QLabel(this);

label7->setText(tr("Маска"));

label8=new QLabel(this);

label8->setText(tr("Минимальный набор символов слева"));

label9=new QLabel(this);

label9->setText(tr("Максимальный набор символов слева"));

label10=new QLabel(this);

label10->setText(tr("Минимальный набор символов справа"));

label11=new QLabel(this);

label11->setText(tr("Максимальный набор символов справа"));

QHBoxLayout *brute_force_on_mask_alpha_Layout=new QHBoxLayout();

brute_force_on_mask_alpha_Layout->addWidget(label5);

brute_force_on_mask_alpha_Layout->addWidget(brute_force_on_mask_alpha_LineEdit);

QHBoxLayout *brute_force_on_mask_mask_Layout=new QHBoxLayout();

brute_force_on_mask_mask_Layout->addWidget(label7);

brute_force_on_mask_mask_Layout->addWidget(brute_force_on_mask_mask_LineEdit);

QHBoxLayout *brute_force_on_mask_min_on_left_length_Layout=new QHBoxLayout();

brute_force_on_mask_min_on_left_length_Layout->addWidget(label8);

brute_force_on_mask_min_on_left_length_Layout->addStretch();

brute_force_on_mask_min_on_left_length_Layout->addWidget(brute_force_on_mask_min_on_left_length_SpinBox);

QHBoxLayout *brute_force_on_mask_max_on_left_length_Layout=new QHBoxLayout();

brute_force_on_mask_max_on_left_length_Layout->addWidget(label9);

brute_force_on_mask_max_on_left_length_Layout->addStretch();

brute_force_on_mask_max_on_left_length_Layout->addWidget(brute_force_on_mask_max_on_left_length_SpinBox);

QHBoxLayout *brute_force_on_mask_min_on_right_length_Layout=new QHBoxLayout();

brute_force_on_mask_min_on_right_length_Layout->addWidget(label10);

brute_force_on_mask_min_on_right_length_Layout->addStretch();

brute_force_on_mask_min_on_right_length_Layout->addWidget(brute_force_on_mask_min_on_right_length_SpinBox);

QHBoxLayout *brute_force_on_mask_max_on_right_length_Layout=new QHBoxLayout();

brute_force_on_mask_max_on_right_length_Layout->addWidget(label11);

brute_force_on_mask_max_on_right_length_Layout->addStretch();

brute_force_on_mask_max_on_right_length_Layout->addWidget(brute_force_on_mask_max_on_right_length_SpinBox);

QVBoxLayout *brute_force_on_mask_Layout=new QVBoxLayout();

brute_force_on_mask_Layout->addLayout(brute_force_on_mask_alpha_Layout);

brute_force_on_mask_Layout->addLayout(brute_force_on_mask_mask_Layout);

brute_force_on_mask_Layout->addLayout(brute_force_on_mask_min_on_left_length_Layout);

brute_force_on_mask_Layout->addLayout(brute_force_on_mask_max_on_left_length_Layout);

brute_force_on_mask_Layout->addLayout(brute_force_on_mask_min_on_right_length_Layout);

brute_force_on_mask_Layout->addLayout(brute_force_on_mask_max_on_right_length_Layout);

brute_force_on_mask_Layout->addStretch();

brute_force_on_mask_GroupBox->setLayout(brute_force_on_mask_Layout);

brute_force_on_dictionary_GroupBox=new QGroupBox(this);

brute_force_on_dictionary_filename_LineEdit=new QLineEdit(this);

brute_force_on_dictionary_filename_LineEdit->setAlignment(Qt::AlignRight);

brute_force_on_dictionary_filename_PushButton=new QPushButton(this);

brute_force_on_dictionary_filename_PushButton->setText(tr("Обзор"));

connect(brute_force_on_dictionary_filename_PushButton,SIGNAL(clicked()),this,SLOT(add_file_1()));

label12=new QLabel(this);

label12->setText(tr("Файл словаря"));

QHBoxLayout *brute_force_on_dictionary_filename_Layout=new QHBoxLayout();

brute_force_on_dictionary_filename_Layout->addWidget(label12);

brute_force_on_dictionary_filename_Layout->addWidget(brute_force_on_dictionary_filename_LineEdit);

brute_force_on_dictionary_filename_Layout->addWidget(brute_force_on_dictionary_filename_PushButton);

QVBoxLayout *brute_force_on_dictionary_Layout=new QVBoxLayout();

brute_force_on_dictionary_Layout->addLayout(brute_force_on_dictionary_filename_Layout);

brute_force_on_dictionary_Layout->addStretch();

brute_force_on_dictionary_GroupBox->setLayout(brute_force_on_dictionary_Layout);

brute_force_on_dictionaries_GroupBox=new QGroupBox(this);

brute_force_on_dictionaries_filename1_LineEdit=new QLineEdit(this);

brute_force_on_dictionaries_filename1_LineEdit->setAlignment(Qt::AlignRight);

brute_force_on_dictionaries_filename2_LineEdit=new QLineEdit(this);

brute_force_on_dictionaries_filename2_LineEdit->setAlignment(Qt::AlignRight);

brute_force_on_dictionaries_filename1_PushButton=new QPushButton(this);

brute_force_on_dictionaries_filename1_PushButton->setText(tr("Обзор"));

connect(brute_force_on_dictionaries_filename1_PushButton,SIGNAL(clicked()),this,SLOT(add_file_2()));

brute_force_on_dictionaries_filename2_PushButton=new QPushButton(this);

brute_force_on_dictionaries_filename2_PushButton->setText(tr("Обзор"));

connect(brute_force_on_dictionaries_filename2_PushButton,SIGNAL(clicked()),this,SLOT(add_file_3()));

label14=new QLabel(this);

label14->setText(tr("Файл словаря"));

label15=new QLabel(this);

label15->setText(tr("Файл словаря"));

QHBoxLayout *brute_force_on_dictionaries_filename1_Layout=new QHBoxLayout();

brute_force_on_dictionaries_filename1_Layout->addWidget(label14);

brute_force_on_dictionaries_filename1_Layout->addWidget(brute_force_on_dictionaries_filename1_LineEdit);

brute_force_on_dictionaries_filename1_Layout->addWidget(brute_force_on_dictionaries_filename1_PushButton);

QHBoxLayout *brute_force_on_dictionaries_filename2_Layout=new QHBoxLayout();

brute_force_on_dictionaries_filename2_Layout->addWidget(label15);

brute_force_on_dictionaries_filename2_Layout->addWidget(brute_force_on_dictionaries_filename2_LineEdit);

brute_force_on_dictionaries_filename2_Layout->addWidget(brute_force_on_dictionaries_filename2_PushButton);

QVBoxLayout *brute_force_on_dictionaries_Layout=new QVBoxLayout();

brute_force_on_dictionaries_Layout->addLayout(brute_force_on_dictionaries_filename1_Layout);

brute_force_on_dictionaries_Layout->addLayout(brute_force_on_dictionaries_filename2_Layout);

brute_force_on_dictionaries_Layout->addStretch();

brute_force_on_dictionaries_GroupBox->setLayout(brute_force_on_dictionaries_Layout);

brute_force_on_dictionary_gybrid_GroupBox=new QGroupBox(this);

brute_force_on_dictionary_gybrid_filename_LineEdit=new QLineEdit(this);

brute_force_on_dictionary_gybrid_filename_LineEdit->setAlignment(Qt::AlignRight);

brute_force_on_dictionary_gybrid_filename_PushButton=new QPushButton(this);

brute_force_on_dictionary_gybrid_filename_PushButton->setText(tr("Обзор"));

connect(brute_force_on_dictionary_gybrid_filename_PushButton,SIGNAL(clicked()),this,SLOT(add_file_4()));

label17=new QLabel(this);

label17->setText(tr("Файл словаря"));

QHBoxLayout *brute_force_on_dictionary_gybrid_filename_Layout=new QHBoxLayout();

brute_force_on_dictionary_gybrid_filename_Layout->addWidget(label17);

brute_force_on_dictionary_gybrid_filename_Layout->addWidget(brute_force_on_dictionary_gybrid_filename_LineEdit);

brute_force_on_dictionary_gybrid_filename_Layout->addWidget(brute_force_on_dictionary_gybrid_filename_PushButton);

QVBoxLayout *brute_force_on_dictionary_gybrid_Layout=new QVBoxLayout();

brute_force_on_dictionary_gybrid_Layout->addLayout(brute_force_on_dictionary_gybrid_filename_Layout);

brute_force_on_dictionary_gybrid_Layout->addStretch();

brute_force_on_dictionary_gybrid_GroupBox->setLayout(brute_force_on_dictionary_gybrid_Layout);

brute_force_on_dictionaries_gybrid_GroupBox=new QGroupBox(this);

brute_force_on_dictionaries_gybrid_filename1_LineEdit=new QLineEdit(this);

brute_force_on_dictionaries_gybrid_filename1_LineEdit->setAlignment(Qt::AlignRight);

brute_force_on_dictionaries_gybrid_filename2_LineEdit=new QLineEdit(this);

brute_force_on_dictionaries_gybrid_filename2_LineEdit->setAlignment(Qt::AlignRight);

brute_force_on_dictionaries_gybrid_filename1_PushButton=new QPushButton(this);

brute_force_on_dictionaries_gybrid_filename1_PushButton->setText(tr("Обзор"));

connect(brute_force_on_dictionaries_gybrid_filename1_PushButton,SIGNAL(clicked()),this,SLOT(add_file_5()));

brute_force_on_dictionaries_gybrid_filename2_PushButton=new QPushButton(this);

brute_force_on_dictionaries_gybrid_filename2_PushButton->setText(tr("Обзор"));

connect(brute_force_on_dictionaries_gybrid_filename2_PushButton,SIGNAL(clicked()),this,SLOT(add_file_6()));

label19=new QLabel(this);

label19->setText(tr("Файл словаря"));

label20=new QLabel(this);

label20->setText(tr("Файл словаря"));

QHBoxLayout *brute_force_on_dictionaries_gybrid_filename1_Layout=new QHBoxLayout();

brute_force_on_dictionaries_gybrid_filename1_Layout->addWidget(label19);

brute_force_on_dictionaries_gybrid_filename1_Layout->addWidget(brute_force_on_dictionaries_gybrid_filename1_LineEdit);

brute_force_on_dictionaries_gybrid_filename1_Layout->addWidget(brute_force_on_dictionaries_gybrid_filename1_PushButton);

QHBoxLayout *brute_force_on_dictionaries_gybrid_filename2_Layout=new QHBoxLayout();

brute_force_on_dictionaries_gybrid_filename2_Layout->addWidget(label20);

brute_force_on_dictionaries_gybrid_filename2_Layout->addWidget(brute_force_on_dictionaries_gybrid_filename2_LineEdit);

brute_force_on_dictionaries_gybrid_filename2_Layout->addWidget(brute_force_on_dictionaries_gybrid_filename2_PushButton);

QVBoxLayout *brute_force_on_dictionaries_gybrid_Layout=new QVBoxLayout();

brute_force_on_dictionaries_gybrid_Layout->addLayout(brute_force_on_dictionaries_gybrid_filename1_Layout);

brute_force_on_dictionaries_gybrid_Layout->addLayout(brute_force_on_dictionaries_gybrid_filename2_Layout);

brute_force_on_dictionaries_gybrid_Layout->addStretch();

brute_force_on_dictionaries_gybrid_GroupBox->setLayout(brute_force_on_dictionaries_gybrid_Layout);

tab=new QTabWidget(this);

tab->insertTab(0,brute_force_GroupBox,tr("Полный перебор"));

tab->insertTab(1,brute_force_on_mask_GroupBox,tr("Поиск по маске"));

tab->insertTab(2,brute_force_on_dictionary_GroupBox,tr("Поиск по словарю"));

tab->insertTab(3,brute_force_on_dictionaries_GroupBox,tr("Комбинированный поиск по словарям"));

tab->insertTab(4,brute_force_on_dictionary_gybrid_GroupBox,tr("Гибридный поиск по словарю"));

tab->insertTab(5,brute_force_on_dictionaries_gybrid_GroupBox,tr("Гибридный поиск по словарям"));

QHBoxLayout *bottom_Layout=new QHBoxLayout();

bottom_Layout->addStretch();

bottom_Layout->addWidget(ok_PushButton);

bottom_Layout->addWidget(cansel_PushButton);

QVBoxLayout *main_Layout=new QVBoxLayout();

main_Layout->addWidget(tab);

main_Layout->addLayout(bottom_Layout);

// добавляем компоновку окну поиска

setLayout(main_Layout);

//setFixedWidth(800);

setWindowTitle(tr("Добавить задачу"));

}

void add_task_window::add_file_1()

{

QString filename;

if ((filename=QFileDialog::getOpenFileName(this,tr("Открыть словарь")))!=NULL)

brute_force_on_dictionary_filename_LineEdit->setText(filename);

}

void add_task_window::add_file_2()

{

QString filename;

if ((filename=QFileDialog::getOpenFileName(this,tr("Открыть словарь")))!=NULL)

brute_force_on_dictionaries_filename1_LineEdit->setText(filename);

}

void add_task_window::add_file_3()

{

QString filename;

if ((filename=QFileDialog::getOpenFileName(this,tr("Открыть словарь")))!=NULL)

brute_force_on_dictionaries_filename2_LineEdit->setText(filename);

}

void add_task_window::add_file_4()

{

QString filename;

if ((filename=QFileDialog::getOpenFileName(this,tr("Открыть словарь")))!=NULL)

brute_force_on_dictionary_gybrid_filename_LineEdit->setText(filename);

}

void add_task_window::add_file_5()

{

QString filename;

if ((filename=QFileDialog::getOpenFileName(this,tr("Открыть словарь")))!=NULL)

brute_force_on_dictionaries_gybrid_filename1_LineEdit->setText(filename);

}

void add_task_window::add_file_6()

{

QString filename;

if ((filename=QFileDialog::getOpenFileName(this,tr("Открыть словарь")))!=NULL)

brute_force_on_dictionaries_gybrid_filename2_LineEdit->setText(filename);

}

void add_task_window::add_file()

{

}

hash.h

#ifndef HASH_H

#define HASH_H

#include <QThread>

#include <QtCrypto>

#include <math.h>

QT_BEGIN_NAMESPACE

class QCryptographicHash;

QT_END_NAMESPACE

class Hash : public QThread

{

Q_OBJECT

public:

Hash();

volatile bool stopped;

volatile quint64 current,total;

quint8 type;

QVector<QByteArray> *before_hash_vector,

*before_salt_vector,

*login_vector;

QVector<unsigned int> *NTLM1;

QVector<unsigned int> *NTLM2;

QVector<unsigned int> *NTLM3;

QVector<unsigned int> *NTLM4;

QVector<QByteArray> *left_half_LM_password;

QVector<QByteArray> *right_half_LM_password;

quint8 count_hash;

QStringList *tasks;

QCA::Cipher *algorithm_DES;

bool check_hash(const char *);

bool variant_for_before_check(char *);

bool variant_for_hybrid(char *);

char* LM_hash(const char *);

unsigned int* NTLM_hash(const char *);

bool brute_force(const char *,const quint8 &,const quint8 &);

bool brute_force_on_mask(const char *,const char *,const quint8 &,const quint8 &,const quint8 &,const quint8 &);

bool brute_force_on_dictionary(const QString &);

bool brute_force_on_dictionaries(const QString &,const QString &);

bool brute_force_on_dictionary_gybrid(const QString &);

bool brute_force_on_dictionaries_gybrid(const QString &,const QString &);

bool before_check();

void clear_parametrs();

signals:

void complete();

void find_hash(const QString &,const QString &);

void message(const QString &);

void start_timer();

void comlete_task();

protected:

void run();

};

#endif

hash.cpp

#include <QtCore>

#include <QtCrypto>

#include <unistd.h>

#include "hash.h"

// NTLM константы

#define INIT_A 0x67452301

#define INIT_B 0xefcdab89

#define INIT_C 0x98badcfe

#define INIT_D 0x10325476

#define SQRT_2 0x5a827999

#define SQRT_3 0x6ed9eba1

// LM константы

#define LINE "KGS!@#$%"

// DES константы

enum algorithm

{

type_linux_md5=3,

type_windows_LM=4,

type_windows_NTLM=5,

type_linux_sha256=6,

type_linux_sha512=7,

};

enum help

{

buffer_size=128,

};

Hash::Hash()

{

// вектор хэшей

before_hash_vector=new QVector<QByteArray>();

before_hash_vector->clear();

// вектор солей

before_salt_vector=new QVector<QByteArray>();

before_salt_vector->clear();

// логины пользователей

login_vector=new QVector<QByteArray>();

login_vector->clear();

// задачи

tasks=new QStringList();

tasks->clear();

// NTLM

NTLM1=new QVector<unsigned int>();

NTLM1->clear();

NTLM2=new QVector<unsigned int>();

NTLM2->clear();

NTLM3=new QVector<unsigned int>();

NTLM3->clear();

NTLM4=new QVector<unsigned int>();

NTLM4->clear();

// LM

left_half_LM_password=new QVector<QByteArray>();

left_half_LM_password->clear();

right_half_LM_password=new QVector<QByteArray>();

right_half_LM_password->clear();

// алгоритм DES

algorithm_DES=new QCA::Cipher(QString("des"),QCA::Cipher::ECB,QCA::Cipher::NoPadding,QCA::Encode,QByteArray("qwerty"));

}

void Hash::run()

{

emit start_timer();

if (type==type_windows_NTLM)

{

// преобразуем NTLM

for(quint8 i=0;i<before_hash_vector->size();i++)

{

QByteArray hash=before_hash_vector->at(i);

for(quint8 j=0;j<4;j++)

{

unsigned int summ=0;

bool ok;

summ+=hash.mid(0+8*j,2).toUInt(&ok,16);

summ+=hash.mid(2+8*j,2).toUInt(&ok,16)*256;

summ+=hash.mid(4+8*j,2).toUInt(&ok,16)*256*256;

summ+=hash.mid(6+8*j,2).toUInt(&ok,16)*256*256*256;

if (j==0)

NTLM1->append(summ);

else if (j==1)

NTLM2->append(summ);

else if (j==2)

NTLM3->append(summ);

else

NTLM4->append(summ);

}

count_hash++;

}

}

else if (type==type_windows_LM)