void levelAction(KeyType key, bool encode, std::istream & in, std::ostream & out) { Crypt<CypherType,Group,Pack> c; c.setKey(key); if (encode){ c.encode(in,out); }else{ c.decode(in,out); } }
//******************************************************************** // // Method: decrypt // Parameter: QString* cipher, read input from techniqueComboBox_2, input key // // Purpose: use Cyper to decrypt, return plaintext // //******************************************************************** QString* MainWindow::decrypt(QString* cipher) { Crypt c (cipher,&(ui->keyTextField_2->text()),format); switch (ui->techniqueComboBox_2->currentIndex()) { case 0: //Caesar c.caesar(DECRYPT); break; case 1: //Vigenère c.vigenere(DECRYPT); break; default: ui->keyTipLabel_2->setText("Decryption failed"); } return cipher; }
//******************************************************************** // // Method: encrypt // Parameter: QString* plain, read input from techniqueComboBox, input key // // Purpose: use Cyper to encrypt, return ciphertext // //******************************************************************** QString* MainWindow::encrypt(QString* plain) { Crypt c (plain,&(ui->keyTextField->text()),format); switch (ui->techniqueComboBox->currentIndex()) { case 0: //Caesar c.caesar(ENCRYPT); break; case 1: //Vigenère c.vigenere(ENCRYPT); break; default: ui->keyTipLabel->setText("Encryption failed"); } return plain; }
void Settings::refresh() { // Read ini file this->iniPath = AppFunc::getAppSavePath() + QLatin1String("/vpn.ini"); QSettings sett (this->iniPath, QSettings::IniFormat); // Die Settings einlesen this->noBallonMessage = (sett.value(QLatin1String("connect/noballon"), QLatin1String("0")).toString() == QLatin1String("1") ? true : false); this->popUpDialogValue = (sett.value(QLatin1String("connect/popup"), QLatin1String("1")).toString() == QLatin1String("1") ? true : false); this->showSplashScreenValue = (sett.value(QLatin1String("connect/splash"), QLatin1String("1")).toString() == QLatin1String("1") ? true : false); this->autoReconnect = (sett.value(QLatin1String("connect/autoreconnect"), QLatin1String("0")).toString() == QLatin1String("1") ? true : false); this->useNoInteract = (sett.value(QLatin1String("connect/nointeract"), QLatin1String("0")).toString() == QLatin1String("1") ? true : false); // Start config this->startCommandConfig = (sett.value(QLatin1String("start/auto"), QLatin1String("0")).toString() == QLatin1String("1") ? true : false); this->commandConfigPath = sett.value(QLatin1String("start/path"), QLatin1String("")).toString(); this->delayConfigVal = sett.value(QLatin1String("start/delay"), QLatin1String("0")).toString(); this->cryptKey = sett.value(QLatin1String("self/key"), QLatin1String("")).toString(); if (!this->cryptKey.isEmpty()) { Crypt crypt; this->cryptKey = QString(crypt.cryptToPlainTextExt(this->cryptKey.toAscii())); } else { // Neuen Key erzeugen qsrand(QDateTime::currentDateTime().toTime_t()); QString _t1 (QString::number((qrand() % 1500) + 1)); QString _t2 (QString::number((qrand() % 2500) + 1)); QString key (QLatin1String("S3m!BHF") + _t1 + QLatin1String("83$%§kd") + _t2 + QString::number(QDateTime::currentDateTime().toTime_t()) + _t1); Crypt crypt; key = QString(crypt.cryptPlainTextExt(key.toAscii())); sett.setValue(QLatin1String("self/key"), key); this->cryptKey = key; } }
int main(int argc, char** argv) { cmdline_parser parser; //Initialise the parser if (!parser.process_cmdline(argc, argv)) { //Try parse cmdline args cerr << "Couldn't process command line arguments" << endl; } if (parser.should_print_help()) { //Print help if requested parser.print_help(std::cout); } string encodable = ""; //The string that holds the text to run ciphers on string inputFileName = parser.get_input_filename(); string outputFileName = parser.get_output_filename(); cout << "Output file in use: " << outputFileName << endl; if (!parser.should_get_user_input()) { cout << "Input file in use: " << inputFileName << endl; string temp; ifstream inpFileStream; inpFileStream.open(inputFileName); if (inpFileStream.is_open()) { while (!inpFileStream.eof()) { //Read from file into string encodable getline(inpFileStream, temp); encodable += temp; } } inpFileStream.close(); } else { cout << "Please enter the text you want to pass to the cipher: "; getline (cin, encodable); } boost::to_upper(encodable); string returnStr = ""; if (parser.using_caesar()) { int key = parser.get_caesar_key(); if (parser.should_pack()) { //Will return "Not implemented" if (parser.should_group()) { if (parser.should_encode()) { Crypt<caesar, packing, grouping> crypt; returnStr = crypt.encode(encodable, key); } else { Crypt<caesar, packing, grouping> crypt; returnStr = crypt.decode(encodable, key); } } else { if (parser.should_encode()) { Crypt<caesar, packing, no_grouping> crypt; returnStr = crypt.encode(encodable, key); } else { Crypt<caesar, packing, no_grouping> crypt; returnStr = crypt.decode(encodable, key); } } } else { if (parser.should_group()) { if (parser.should_encode()) { Crypt<caesar, no_packing, grouping> crypt; returnStr = crypt.encode(encodable, key); } else { Crypt<caesar, no_packing, grouping> crypt; returnStr = crypt.decode(encodable, key); } } else { if (parser.should_encode()) { Crypt<caesar, no_packing, no_grouping> crypt; returnStr = crypt.encode(encodable, key); } else { Crypt<caesar, no_packing, no_grouping> crypt; returnStr = crypt.decode(encodable, key); } } } } else if (parser.using_vigenere()) { string key = parser.get_vigenere_key(); if (parser.should_pack()) { //Will return "Not implemented" if (parser.should_group()) { if (parser.should_encode()) { Crypt<vigenere, packing, grouping> crypt; returnStr = crypt.encode(encodable, key); } else { Crypt<vigenere, packing, grouping> crypt; returnStr = crypt.decode(encodable, key); } } else { if (parser.should_encode()) { Crypt<vigenere, packing, no_grouping> crypt; returnStr = crypt.encode(encodable, key); } else { Crypt<vigenere, packing, no_grouping> crypt; returnStr = crypt.decode(encodable, key); } } } else { if (parser.should_group()) { if (parser.should_encode()) { Crypt<vigenere, no_packing, grouping> crypt; returnStr = crypt.encode(encodable, key); } else { Crypt<vigenere, no_packing, grouping> crypt; returnStr = crypt.decode(encodable, key); } } else { if (parser.should_encode()) { Crypt<vigenere, no_packing, no_grouping> crypt; returnStr = crypt.encode(encodable, key); } else { Crypt<vigenere, no_packing, no_grouping> crypt; returnStr = crypt.decode(encodable, key); } } } } else if (parser.using_XOR()) { int32_t key = parser.get_XOR_key(); if (parser.should_pack()) { //Will return "Not implemented" if (parser.should_group()) { if (parser.should_encode()) { Crypt<XOR, packing, grouping> crypt; returnStr = crypt.encode(encodable, key); } else { Crypt<XOR, packing, grouping> crypt; returnStr = crypt.decode(encodable, key); } } else { if (parser.should_encode()) { Crypt<XOR, packing, no_grouping> crypt; returnStr = crypt.encode(encodable, key); } else { Crypt<XOR, packing, no_grouping> crypt; returnStr = crypt.decode(encodable, key); } } } else { if (parser.should_group()) { if (parser.should_encode()) { Crypt<XOR, no_packing, grouping> crypt; returnStr = crypt.encode(encodable, key); } else { Crypt<XOR, no_packing, grouping> crypt; returnStr = crypt.decode(encodable, key); } } else { if (parser.should_encode()) { Crypt<XOR, no_packing, no_grouping> crypt; returnStr = crypt.encode(encodable, key); } else { Crypt<XOR, no_packing, no_grouping> crypt; returnStr = crypt.decode(encodable, key); } } } } ofstream outFileStream; outFileStream.open(outputFileName); outFileStream << returnStr; // Crypt<caesar, no_packing, no_grouping> cnn; // std::cout << cnn.encode("I AM IN LOVE WITH A FARTY SOUND", 1000) << std::endl; // std::cout << cnn.decode("U MY UZ XAHQ IUFT M RMDFK EAGZP", 1000) << std::endl << std::endl; // // Crypt<caesar, no_packing, grouping> cng; // std::cout << cng.encode("I AM IN LOVE WITH A FARTY SOUND", 1000) << std::endl; // std::cout << cng.decode("UMYUZXAHQIUFTMR MDFKE AGZP", 1000) << std::endl << std::endl; // // Crypt<vigenere, no_packing, no_grouping> vnn; // std::cout << vnn.encode("I AM IN LOVE WITH A FARTY SOUND", "LEMON") << std::endl; // std::cout << vnn.decode("T EY WA WSHS JTXT O SLVFM FZYZR", "LEMON") << std::endl << std::endl; // // Crypt<vigenere, no_packing, grouping> vng; // std::cout << vng.encode("I AM IN LOVE WITH A FARTY SOUND", "LEMON") << std::endl; // std::cout << vng.decode("TEYWA WSHSJ TXTOS LVFMF ZYZR", "LEMON") << std::endl << std::endl; // // Crypt<XOR, no_packing, no_grouping> xnn; // std::cout << xnn.encode("MATTHEWWOODISACUNT", 1) << std::endl; // std::cout << xnn.decode("LATTIEWWNODIRACUOT", 1) << std::endl << std::endl; // // Crypt<XOR, no_packing, grouping> xng; // std::cout << xng.encode("MATTHEWW OODISA C**T", 1) << std::endl; // std::cout << xng.decode("LATTI EWVOO EISAB UNU", 1) << std::endl << std::endl; return 0; }
int main(int argc, char** argv) { /*******************************************************************************************************/ /*******************************************************************************************************/ if(argc < 2) { cout << "Program is used to encode/decode files using AES alghoritm.\n" \ "-c [filename]\tEncrypt file.\n" \ "-d [filename]\tDecrypt file.\n" \ "-o [filename]\tOutput file.\n" \ "-p [filename]\tPlay encrypted *.wav file.\n"; return 0; } const char* password; string keystore_path; string input_file_name; string output_file_name; int mode = 0; for(int i=1; i<argc; i++) { if(strcmp(argv[i], "-c") == 0) { // Encryption input_file_name = argv[i+1]; mode = ENCRYPTION_MODE; i++; } else if(strcmp(argv[i], "-d") == 0) { // Decrytpion input_file_name = argv[i+1]; mode = DECRYPTION_MODE; i++; } else if(strcmp(argv[i], "-p") == 0) { // Decrytpion input_file_name = argv[i+1]; mode = PLAY_MODE; i++; } else if(strcmp(argv[i], "-o") == 0) { // Output file name output_file_name = string(argv[i+1]); i++; } else { cout << "Unknown parameter \"" << argv[i] << endl; return 1; } } try { cout << "Enter secred PIN: "; Crypt config; string pin = string(config.get_password()); if(pin.length() != 4) return 1; if(pin[0] != '5' || pin[1] != '5' || pin[2] != '5' || pin[3] != '5') return 1; config.set_key(config_key); config.enable_decrypt_mode_memory("config.ini", AUDIOBUFFER_SIZE); config.decrypt_memory(0, AUDIOBUFFER_SIZE); int i = 0; for(i=0; i< AUDIOBUFFER_SIZE; i++) { if(config.buffer[i] == 13) { config.buffer[i] = 0; config.buffer[i+1] = 0; break; } } for(int j=i+2; i< AUDIOBUFFER_SIZE; j++) { if(config.buffer[j] == 13) { config.buffer[j] = 0; config.buffer[j+1] = 0; break; } } keystore_path = string((const char*)config.buffer); password = (const char*) (config.buffer+i+2); } catch(...) { cout << "Unknown problem occured\n" << endl; return 1; } try { Crypt c; c.get_key_from_keystore(keystore_path.c_str(), password); if(mode == ENCRYPTION_MODE) { c.enable_encrypt_mode(input_file_name.c_str(), output_file_name.c_str(), BUFFER_SIZE); for(int i=0; c.in.last_character != 0 || i == 0; i += BUFFER_SIZE) { c.encrypt(i, BUFFER_SIZE); } } else if(mode == DECRYPTION_MODE) { c.enable_decrypt_mode(input_file_name.c_str(), output_file_name.c_str(), BUFFER_SIZE); for(int i=10; c.in.last_character != 0 || i == 0; i += BUFFER_SIZE) { c.encrypt(i, BUFFER_SIZE); } } else if(mode == PLAY_MODE) { BufferPlayer b_p(c); c.enable_decrypt_mode_memory(input_file_name.c_str(), AUDIOBUFFER_SIZE); cout << "Type number between [0 ; 100] to change slider position (percentage)\n"; cout << "You can type replay, stop, continue, exit\n"; b_p.play(); string cmd = ""; cin >> cmd; while(cmd != "exit") { if(cmd == "replay") { b_p.replay(); } else if(cmd == "stop") { b_p.stop(); } else if(cmd == "continue") { b_p.continue_playing(); } else { int time = atoi(cmd.c_str()); b_p.change_time(time); } cin >> cmd; } b_p.exit(); } else { cout << "Problem with -d/-c option. Please contact with author." << endl; } }
void ImportConfig::on_cmdImport_clicked() { if (!m_ui->txtExistingOvpn->text().isEmpty()) { // Import existing file QString configName (m_ui->txtExistingOvpn->text().replace(".ovpn", "")); configName = configName.right(configName.size() - configName.lastIndexOf("/") - 1); // Anderer name als Dateiname if (m_ui->rbSaveAsName->isChecked()) { if (!m_ui->txtNewName->text().isEmpty()) { configName = m_ui->txtNewName->text(); } } QString pathToConfig (m_ui->txtExistingOvpn->text()); // Copy config to local app data and rename it, if an other name is specified // Only in service mode! if(!Settings::getInstance()->getIsPortableClient()) { // If file is available copy it // First create folder QString newConfigFolderPath (QString("%1/config/%2") .arg(AppFunc::getAppSavePath()) .arg(configName)); QDir newConfigFolderPathDirectory (newConfigFolderPath); if (newConfigFolderPathDirectory.exists(newConfigFolderPath)){ // A config with this name is already existing Message::error(QObject::tr("A configuration with this name is already existing!")); // return; } // Create path newConfigFolderPathDirectory.mkpath(newConfigFolderPath); // Now copy Files QString newConfigPath (QString("%1/%2.ovpn") .arg(newConfigFolderPath) .arg(configName)); QFile::copy(pathToConfig, newConfigPath); // QString sourceDirectory (pathToConfig.left(pathToConfig.lastIndexOf("/"))); // // Override old path pathToConfig = newConfigPath; // Ca auto copyConfigFile = [&](const QString &key) { auto keyValue = (ConfigValues::instance()->valueFromConfigKey(pathToConfig, key)); if(!keyValue.isEmpty()) { QString sourcePath (QString("%1/%2") .arg(sourceDirectory) .arg(keyValue)); QString destName (keyValue); if (ConfigValues::instance()->isGivenPathAbsolute(keyValue)) { // Yes, override path sourcePath = keyValue; // Get the file name from path destName = ConfigValues::instance()->fileNameOfAbsolutePath(keyValue); // Change value in config ConfigValues::instance()->changeKeyValueInConfig(pathToConfig, key, QString("\"%1\"") .arg(destName)); } // Copy QFile::copy(sourcePath, QString("%1/%2") .arg(newConfigFolderPath) .arg(destName)); } }; for(const auto &key : keys) { copyConfigFile(key); } } Preferences::instance()->addNewConfigToDatabase(configName, pathToConfig); Preferences::instance()->refreshConfigList(); Preferences::instance()->setConnectionStatus(); Preferences::instance()->setIcon(); // Fertig Message::information(QObject::tr("Import successfully ended!"), QObject::tr("Import Configuration")); Preferences::instance()->refreshDialog(); this->close(); } else { // Import crypt file if (m_ui->txtPassword->text().isEmpty()) { Message::error(QObject::tr("No password specified!"), QObject::tr("Import Configuration")); return; } if (!m_ui->txtImportPath->text().isEmpty()) { if (m_ui->rbSaveAsName->isChecked() && m_ui->txtNewName->text().isEmpty()) { Message::error(QObject::tr("No import name specified!"), QObject::tr("Import Configuration")); return; } // Portale oder install QString dirPath; QString configName; if (!m_ui->rbSaveAsName->isChecked()) { configName = m_ui->txtImportPath->text().right(m_ui->txtImportPath->text().size() - m_ui->txtImportPath->text().lastIndexOf("/") -1); configName = configName.left(configName.size()-6); } else { configName = m_ui->txtNewName->text().trimmed(); } dirPath = AppFunc::getAppSavePath() + QString ("/config/") + configName; // Verzeichnis da? QDir dirobj (dirPath); if (!dirobj.exists(dirPath)){ //Verzeichnis existiert nicht // Pfad erstellen if (!dirobj.mkpath(dirPath)) { // Pfad konnte nicht erstellt werden Message::error(QObject::tr("Unable to create directory!"), QObject::tr("Import Configuration")); return; } } else { // Verzeichnis existiert Message::error(QObject::tr("A diretory with this name already exists!"), QObject::tr("Import Configuration")); return; } // Datei ins neue Verzeichnis kopieren //QFile importFileCrypt (m_ui->txtImportPath->text()); QString packFile = dirPath + QString("/") + configName + QString(".zip"); // Erstmal entschlüsseln if(QFile::exists(packFile)) { QFile::remove(packFile); } // Die Daten einlesen { QFile crypted (m_ui->txtImportPath->text()); if (crypted.open(QIODevice::ReadOnly)) { // Nun das Ziel öfffnen QFile targetFile (packFile); if (targetFile.open(QIODevice::WriteOnly | QIODevice::Truncate)) { // Alles offen, kann losgehen QByteArray data = crypted.readAll(); Crypt crypt; crypt.setSecretKey(m_ui->txtPassword->text()); targetFile.write(crypt.cryptToPlainTextExt(data)); targetFile.waitForBytesWritten(3000); targetFile.flush(); targetFile.waitForBytesWritten(3000); // Alles Ok targetFile.close(); crypted.close(); } } else { Message::error(QObject::tr("Can't open crypted file")); return; } } // Nun die Datei entpacken if (!Zip::extract(packFile, dirPath)) { Message::error(QObject::tr("Can't open zip file")); return; } // Nun ist alles entpackt, das Ziparchiv nun löschen QFile configZip (packFile); if (!configZip.remove()) { Message::error(configZip.errorString(), QObject::tr("Import Configuration")); } QString saveName; QString savePath; QString ovpnFilePath = m_ui->txtImportPath->text().right(m_ui->txtImportPath->text().size() - m_ui->txtImportPath->text().lastIndexOf("/") -1); saveName = ovpnFilePath.left(ovpnFilePath.size()-6); savePath = dirPath + QString("/") + ovpnFilePath.left(ovpnFilePath.size()-6) + QString(".ovpn"); if (m_ui->rbSaveAsName->isChecked()) { // ovpn umbennen QFile ovpnFile (savePath); if (ovpnFile.exists()) { // umbenennen ovpnFile.rename(dirPath + QString("/") + configName + QString(".ovpn")); saveName = configName; } } savePath = dirPath + QString("/") + saveName + QString(".ovpn"); QFile ovpnFile (dirPath + QString("/") + configName + QString(".ovpn")); if (!ovpnFile.exists()) { Message::error(QObject::tr("Import failed! Removing empty directory."), QObject::tr("Import Configuration")); dirobj.rmdir(dirPath); } else { Preferences::instance()->addNewConfigToDatabase(saveName, savePath.replace("\\", "/")); Preferences::instance()->refreshConfigList(); Preferences::instance()->setConnectionStatus(); Message::information(QObject::tr("Import successfully ended!"), QObject::tr("Import Configuration")); Preferences::instance()->refreshDialog(); Preferences::instance()->setIcon(); this->close(); } } else { Message::error(QObject::tr("No import file selected!"), QObject::tr("Import Configuration")); } } }