void assign_values(int month, int day, int *number_direct_coefficients) { int hour1; double st; /* solar time */ double sd; double alt2_rise, alt2_set; sd = sdec(jdate(month, day)); alt2_rise = f_salt(sd, radians(2.0)); alt2_set = 24 - f_salt(sd, radians(2.0)); for (hour1 = 0; hour1< 24; hour1++){ st = hour1; if (((hour1 - 0.5)<alt2_rise) && ((hour1 + 0.5) > alt2_rise)){ st = alt2_rise; } if (((hour1 - 0.5)<alt2_set) && ((hour1 + 0.5) > alt2_set)){ st = alt2_set; } if (degrees(salt(sd, st)) > 1.999){ direct_pts[*number_direct_coefficients][0] = (float)st; direct_pts[*number_direct_coefficients][1] = (float)degrees(salt(sd, st)); if (direct_pts[*number_direct_coefficients][1] <2.001){ direct_pts[*number_direct_coefficients][1] = 2; } direct_pts[*number_direct_coefficients][2] = (float)degrees(sazi(sd, st)); direct_calendar[month][hour1][0] = direct_pts[*number_direct_coefficients][0]; direct_calendar[month][hour1][1] = direct_pts[*number_direct_coefficients][1]; direct_calendar[month][hour1][2] = direct_pts[*number_direct_coefficients][2]; *number_direct_coefficients = *number_direct_coefficients + 1; } else{ direct_calendar[month][hour1][0] = (float)st; direct_calendar[month][hour1][1] = (float)degrees(salt(sd, st)); direct_calendar[month][hour1][2] = (float)degrees(sazi(sd, st)); } } }
void test4saltImage(int argc,char** argv){ srand( cv::getTickCount() ); cv::Mat image=cv::imread( inputImagePath ); salt(&image,3000); IplImage temp4image=image; alert_win( &temp4image ); }
/** * A fully parametrized symmetric string encryption function * Encrypts using the specified algorithm and CBC+PKCS7. * Format as follows (//TODO ASN.1 Notation required): * Base64 * { * n bytes salt (parameter) * 32 bytes IV * message * } */ string cryptTextUnauthenticated(string& plaintext, string& password, bool decrypt = false, string& algorithm = "Twofish", uint saltSize = 24) { AutoSeeded_RNG rng; string fullAlgorithmName = algorithm + "/CBC/PKCS7"; //Generate a random salt SecureVector<byte> salt(rng, saltSize); //Check whether whe have to decrypt Cipher_Dir direction = ENCRYPTION; if(decrypt) {direction = DECRYPTION;} SymmetricKey key = OctetString(hashRaw("SHA-256", password, salt)); InitializationVector iv(rng, 32); Pipe encryptionPipe(new Chain(get_cipher(fullAlgorithmName, key, iv, direction))); encryptionPipe.start_msg(); encryptionPipe.write(plaintext); encryptionPipe.end_msg(); SecureVector<byte> encryptedData = encryptionPipe.read_all(0); Pipe base64Pipe(new Base64_Encoder); base64Pipe.start_msg (); base64Pipe.write(salt); base64Pipe.write(iv); base64Pipe.write(encryptedData); base64Pipe.end_msg(); return base64Pipe.read_all_as_string (0); }
std::string generate_passhash9(const std::string& pass, RandomNumberGenerator& rng, uint16_t work_factor, uint8_t alg_id) { BOTAN_ARG_CHECK(work_factor > 0 && work_factor < 512, "Invalid Passhash9 work factor"); std::unique_ptr<MessageAuthenticationCode> prf = get_pbkdf_prf(alg_id); if(!prf) throw Invalid_Argument("Passhash9: Algorithm id " + std::to_string(alg_id) + " is not defined"); PKCS5_PBKDF2 kdf(prf.release()); // takes ownership of pointer secure_vector<uint8_t> salt(SALT_BYTES); rng.randomize(salt.data(), salt.size()); const size_t kdf_iterations = WORK_FACTOR_SCALE * work_factor; secure_vector<uint8_t> blob; blob.push_back(alg_id); blob.push_back(get_byte(0, work_factor)); blob.push_back(get_byte(1, work_factor)); blob += salt; blob += kdf.derive_key(PASSHASH9_PBKDF_OUTPUT_LEN, pass, salt.data(), salt.size(), kdf_iterations).bits_of(); return MAGIC_PREFIX + base64_encode(blob); }
int main() { // open the image cv::Mat image= cv::imread("boldt.jpg",1); // image is resized for book printing cv::resize(image, image, cv::Size(), 0.6, 0.6); // call function to add noise salt(image,3000); // display result cv::namedWindow("Image"); cv::imshow("Image",image); // write on disk cv::imwrite("salted.bmp",image); cv::waitKey(); // test second version image= cv::imread("boldt.jpg",0); // image is resized for book printing cv::resize(image, image, cv::Size(), 0.6, 0.6); salt2(image, 500); cv::namedWindow("Image"); cv::imshow("Image",image); cv::waitKey(); return 0; }
bool PasswordModule::GeneratePassHash(const wchar_t *userName, const wchar_t *passWord, std::string &passWordHash) { if (wcsnlen(userName, 51) > 50 || wcsnlen(passWord, 51) > 50) { sLog.Error("PasswordModule", "username or password is simply to long"); return false; } std::wstring salt(userName); Utils::Strings::trim(salt, true, true); // comparable to the ".strip" function in python. Utils::Strings::toLowerCase(salt); int saltLen = (int)salt.size() * 2; uint8 * saltChar = (uint8*)&salt[0]; std::wstring init(passWord); init += salt; int saltInitLen = (int)init.size() * 2; uint8 * saltInitChar = (uint8*)&init[0]; #ifndef WIN32 saltChar = wchar_tToUtf16(saltChar, salt.size()); saltInitChar = wchar_tToUtf16(saltInitChar, init.size()); #endif ShaModule::SHAobject shaObj; ShaModule::sha_init(&shaObj); ShaModule::sha_update(&shaObj, saltInitChar, saltInitLen); int daylySaltLen = SHA_DIGEST_SIZE + saltLen; // allocate buffer for the hashing, this way its only allocated once. uint8 * uDaylySalt = (uint8 *)malloc(daylySaltLen); // first part of the data string uint8 * uDaylySaltPart = &uDaylySalt[SHA_DIGEST_SIZE]; // second part of the data string for (int i = 0; i < 1000; i++) { ShaModule::sha_digest(&shaObj, uDaylySalt); memcpy(uDaylySaltPart, saltChar, saltLen); ShaModule::sha_init(&shaObj); ShaModule::sha_update(&shaObj, uDaylySalt, daylySaltLen); } free(uDaylySalt); ShaModule::sha_final(mDigest, &shaObj); if (passWordHash.size() != 0) passWordHash = ""; passWordHash.append((char*)mDigest, SHA_DIGEST_SIZE); return true; }
void CImageAnalysis::OnBnClickedsaltshow() { Mat image; image= imread("F:\\Lena.bmp",1); salt(image, 10000); namedWindow("image"); imshow("image",image); waitKey(0); }
bool MaItem::load(const QString& filename) { bool res = false; if (!filename.isEmpty()) mFilename = filename; mRelPath.clear(); mRelPath = relPath(); #ifdef _DEBUG // qDebug() << absPath(); #endif // _DEBUG QFile file(absPath()); if (file.open(QIODevice::ReadOnly)) { QTextStream in(&file); in.setCodec("UTF-8"); parseConfigLine(in.readLine()); if (mIsEncrypted) { QByteArray s = in.readAll().toAscii(); _engine->encrypt(s); QString s2(s); int i = s2.indexOf("\n"); if (i > -1) { mCaption = s2.left(i); mNotes = s2.right(s2.length() - i - 1); } } else { mCaption = in.readLine(); mNotes = in.readAll(); } file.close(); res = true; } // Loading the password from the password file: QFile file2(absPathToFilename(kPathwordFilename)); if (file.exists() && file2.open(QIODevice::ReadOnly)) { QTextStream in(&file2); in.setCodec("UTF-8"); QByteArray ba = in.readAll().toAscii(); QByteArray salt(QString(_engine->passwordEncryptionSalt()).toAscii()); _engine->encrypt(ba, _engine->passwordEncryptionKey().toAscii(), salt); mPassword = ba; mPasswordDirty = false; } return res; }
int main(int argc, char ** argv) { cv::Mat img = cv::imread(argv[1]); if(!img.data) return -1; salt(img, 3000); cv::namedWindow("Salted Image"); cv::imshow("Salted Image", img); cv::waitKey(0); return 0; }
int main() { std::string str_winName = "Image"; cv::Mat img = cv::imread("Images/boldt.jpg"); cv::Mat result_img; salt(img, result_img, 3000); cv::namedWindow(str_winName); cv::imshow(str_winName, result_img); cv::waitKey(0); return 1; }
std::string rpc::genSalt() { int size = 32; std::ostringstream ss; std::vector<unsigned char> salt(size, 0); urand.generate(&salt[0], size); for (int i = 0; i < size; i++) ss << std::hex << std::setw(2) << std::setfill('0') << (int)salt[i]; return ss.str(); }
QByteArray Crypto::generateSalt() { const int salt_bytes_count = 5; #ifndef NO_QCA return QCA::Random::randomArray(salt_bytes_count).toByteArray(); #else QByteArray salt(""); for(int i = 0; i < salt_bytes_count; i++) salt.append(char(randInt(0, 255))); return salt; #endif }
void MaItem::save(bool onlyWhenDirty) { if (!onlyWhenDirty || mDirty) { bool encrypt = isListEncrypted(); if (mFilename.isEmpty()) mFilename = mParentItem->nextChildFilename(); QFile file(absPath()); if (file.open(QIODevice::WriteOnly)) { QTextStream out(&file); out.setCodec("UTF-8"); out << configLine(encrypt); out << "\n"; if (encrypt) { QByteArray s(mCaption.toAscii()); s.append("\n"); s.append(mNotes.toAscii()); _engine->encrypt(s); out << s; } else { out << mCaption; out << "\n"; out << mNotes; } file.close(); mDirty = false; } } // Saving the password: if ((!onlyWhenDirty || mPasswordDirty) && !mPassword.isEmpty()) { QFile pwdFile(absPathToFilename(kPathwordFilename)); if (pwdFile.open(QIODevice::WriteOnly)) { QTextStream out(&pwdFile); out.setCodec("UTF-8"); QByteArray ba(mPassword.toAscii()); QByteArray salt(QString(_engine->passwordEncryptionSalt()).toAscii()); _engine->encrypt(ba, _engine->passwordEncryptionKey().toAscii(), salt); out << ba; pwdFile.close(); mPasswordDirty = false; } } }
QString ClientConfiguration::toBackup(QString const& password) const { QByteArray encryptionKey(BACKUP_ENCRYPTION_KEY_BYTES, 0x00); // Generate a Salt QByteArray salt(BACKUP_SALT_BYTES, 0x00); randombytes_buf(salt.data(), BACKUP_SALT_BYTES); // Convert the password into bytes QByteArray password8Bit = password.toUtf8(); // Generate the encryption key for the Backup from the Salt and the Password PKCS5_PBKDF2_HMAC(reinterpret_cast<unsigned char*>(password8Bit.data()), password8Bit.size(), reinterpret_cast<unsigned char*>(salt.data()), BACKUP_SALT_BYTES, BACKUP_KEY_PBKDF_ITERATIONS, BACKUP_ENCRYPTION_KEY_BYTES, reinterpret_cast<unsigned char*>(encryptionKey.data())); QByteArray nonceBytes(crypto_stream_NONCEBYTES, 0x00); // The backup content QByteArray clientId(IdentityHelper::uint64ToIdentityString(getClientIdentity().getContactId()).toLatin1()); if (clientId.size() != BACKUP_IDENTITY_BYTES) { throw InternalErrorException() << QString("Could not build backup - invalid client identity length (%1 vs. %2 Bytes).").arg(clientId.size()).arg(BACKUP_IDENTITY_BYTES).toStdString(); } QByteArray clientSecKey(getClientLongTermKeyPair().getPrivateKey()); if (clientSecKey.size() != PROTO_KEY_LENGTH_BYTES) { throw InternalErrorException() << QString("Could not build backup - invalid client secret key length (%1 vs. %2 Bytes).").arg(clientSecKey.size()).arg(PROTO_KEY_LENGTH_BYTES).toStdString(); } QByteArray backup(salt); backup.append(clientId); backup.append(clientSecKey); // Compute Hash QByteArray controlHash(crypto_hash_sha256_BYTES, 0x00); crypto_hash_sha256(reinterpret_cast<unsigned char*>(controlHash.data()), reinterpret_cast<unsigned char*>(backup.data() + BACKUP_SALT_BYTES), BACKUP_IDENTITY_BYTES + PROTO_KEY_LENGTH_BYTES); backup.append(controlHash.left(BACKUP_HASH_BYTES)); if (backup.size() != (BACKUP_SALT_BYTES + BACKUP_IDENTITY_BYTES + PROTO_KEY_LENGTH_BYTES + BACKUP_HASH_BYTES)) { throw InternalErrorException() << QString("Could not build backup - invalid packet length (%1 vs. %2 Bytes).").arg(clientSecKey.size()).arg(BACKUP_SALT_BYTES + BACKUP_IDENTITY_BYTES + PROTO_KEY_LENGTH_BYTES + BACKUP_HASH_BYTES).toStdString(); } // The Backup is build from SALT + IDENTITY + KEY + HASH crypto_stream_xor(reinterpret_cast<unsigned char*>(backup.data() + BACKUP_SALT_BYTES), reinterpret_cast<unsigned char*>(backup.data() + BACKUP_SALT_BYTES), BACKUP_IDENTITY_BYTES + PROTO_KEY_LENGTH_BYTES + BACKUP_HASH_BYTES, reinterpret_cast<unsigned char*>(nonceBytes.data()), reinterpret_cast<unsigned char*>(encryptionKey.data())); // Encode in Base32 return Base32::encodeBase32Sequence(backup); }
void UserDialog::addUser() { QSqlRecord record; QSqlField id("id", QVariant::Int); QSqlField username("username", QVariant::String); QSqlField email("email", QVariant::String); QSqlField hashedPassword("hashed_password", QVariant::String); QSqlField salt("salt", QVariant::String); QSqlField roleId("role_id", QVariant::Int); id.setAutoValue(true); username.setValue(QVariant(usernameLineEdit->text())); email.setValue(QVariant(emailLineEdit->text())); QString generatedSalt = QUuid::createUuid().toString(); QString generatedHashedPassword = QCryptographicHash::hash(passwordLineEdit->text().toAscii() + generatedSalt.toAscii(), QCryptographicHash::Sha1); hashedPassword.setValue(QVariant(generatedHashedPassword)); salt.setValue(QVariant(generatedSalt)); roleId.setValue(QVariant(getRoleId())); record.append(id); record.append(username); record.append(email); record.append(hashedPassword); record.append(salt); record.append(roleId); if(isFieldInputValid() && !isPasswordEmpty() && !userExists() && userModel->insertRecord(-1, record)) { accept(); } else { userModel->revertAll(); } }
void CEncrypt::CreateOwnerKey() { CryptoPP::RandomPool prng; CryptoPP::SecByteBlock salt(16); CryptoPP::OS_GenerateRandomBlock(false, salt, salt.size()); prng.IncorporateEntropy(salt, salt.size()); memcpy(m_anOwnerKey + 32, salt.data(), salt.size()); CryptoPP::SHA256 hash; hash.Update( (unsigned char*) impl->m_sOwnerPassword.c_str(), impl->m_sOwnerPassword.length()); hash.Update( m_anOwnerKey + 32, 8); hash.Update( m_anUserKey, 48); CryptoPP::SecByteBlock pHashData(hash.DigestSize()); hash.Final(pHashData); if (MakeFileKey3(impl->m_sOwnerPassword, pHashData.data(), pHashData.size(), m_anUserKey, 48)) { memcpy(m_anOwnerKey, pHashData.data(), pHashData.size()); hash.Update( (unsigned char*) impl->m_sOwnerPassword.c_str(), impl->m_sOwnerPassword.length()); hash.Update( m_anOwnerKey + 40, 8); hash.Update( m_anUserKey, 48); CryptoPP::SecByteBlock pHashKeyData(hash.DigestSize()); hash.Final(pHashKeyData); MakeFileKey3(impl->m_sOwnerPassword, pHashKeyData.data(), pHashKeyData.size(), m_anUserKey, 48); unsigned char empty[16] = {}; CryptoPP::AES::Encryption aesEncryption(pHashKeyData.data(), pHashKeyData.size()); CryptoPP::CBC_Mode_ExternalCipher::Encryption cbcEncryption( aesEncryption, empty); CryptoPP::StreamTransformationFilter stfEncryption(cbcEncryption, new CryptoPP::ArraySink( m_anOwnerEncryptKey, 32), CryptoPP::StreamTransformationFilter::NO_PADDING ); stfEncryption.Put2(impl->m_anEncryptionKey, 32, 1, true); stfEncryption.MessageEnd(); } }
SqlConnection::ContainedData SqlConnection::getUserByName(const std::string &username) { sqlite3_stmt * stat; prepareStatement(&stat, PREPARE_SELECT_USER_STATEMENT); sqlite3_bind_text(stat, 1, username.c_str(), username.length() +1, NULL); QMutexLocker l(&mutex); if(sqlite3_step(stat) !=SQLITE_ROW) { sqlite3_finalize(stat); throw SqlException("The user is not in the db"); } ContainedData t; t.id = sqlite3_column_int(stat, 0); char * t1, *t2, *t3; t1 = (char*)sqlite3_column_text(stat,1); t2 = (char*)sqlite3_column_text(stat,2); t3 = (char*)sqlite3_column_text(stat,3); QString name(t1), pass(t2), salt(t3); t.name = name; t.password = pass; t.salt = salt; //free(t1); //free(t2); //free(t3); sqlite3_finalize(stat); return t; }
void PSSR_MEM_Base::ComputeMessageRepresentative(RandomNumberGenerator &rng, const byte *recoverableMessage, size_t recoverableMessageLength, HashTransformation &hash, HashIdentifier hashIdentifier, bool messageEmpty, byte *representative, size_t representativeBitLength) const { assert(representativeBitLength >= MinRepresentativeBitLength(hashIdentifier.second, hash.DigestSize())); const size_t u = hashIdentifier.second + 1; const size_t representativeByteLength = BitsToBytes(representativeBitLength); const size_t digestSize = hash.DigestSize(); const size_t saltSize = SaltLen(digestSize); byte *const h = representative + representativeByteLength - u - digestSize; SecByteBlock digest(digestSize), salt(saltSize); hash.Final(digest); rng.GenerateBlock(salt, saltSize); // compute H = hash of M' byte c[8]; PutWord(false, BIG_ENDIAN_ORDER, c, (word32)SafeRightShift<29>(recoverableMessageLength)); PutWord(false, BIG_ENDIAN_ORDER, c+4, word32(recoverableMessageLength << 3)); hash.Update(c, 8); hash.Update(recoverableMessage, recoverableMessageLength); hash.Update(digest, digestSize); hash.Update(salt, saltSize); hash.Final(h); // compute representative GetMGF().GenerateAndMask(hash, representative, representativeByteLength - u - digestSize, h, digestSize, false); byte *xorStart = representative + representativeByteLength - u - digestSize - salt.size() - recoverableMessageLength - 1; xorStart[0] ^= 1; xorbuf(xorStart + 1, recoverableMessage, recoverableMessageLength); xorbuf(xorStart + 1 + recoverableMessageLength, salt, salt.size()); memcpy(representative + representativeByteLength - u, hashIdentifier.first, hashIdentifier.second); representative[representativeByteLength - 1] = hashIdentifier.second ? 0xcc : 0xbc; if (representativeBitLength % 8 != 0) representative[0] = (byte)Crop(representative[0], representativeBitLength % 8); }
int main(int argc, char *argv[]) { QByteArray key("k04LbM3wLGa97rVm30Kyhas"); QByteArray salt("013oPQLbplrz39g2oJElNyPQ20ms7H5v"); QApplication app(argc, argv); QApplication::setStyle("plastique"); Q_INIT_RESOURCE(marbles); _engine = new MaEngine(); _engine->setEncryptKey(key); _engine->setEncryptSalt(salt); QString applicationDirPath(QCoreApplication::applicationDirPath()); QFileInfo appFileInfo(QCoreApplication::applicationFilePath()); const QString appFileName(appFileInfo.fileName()); QString configPath; #if defined(Q_WS_MAC) int pos = applicationDirPath.indexOf(QObject::tr("/%1.app/Contents/MacOS").arg(appFileName)); if (pos > 0) { applicationDirPath.append("/../Resources"); } #endif // defined(Q_WS_MAC) configPath = QObject::tr("%1/%2.xml").arg(applicationDirPath).arg(appFileName); QFileInfo fi(configPath); if (fi.exists()) _engine->loadConfig(fi.absoluteFilePath()); _mainWindow = new MaMainWindow(); QObject::connect(_engine, SIGNAL(openedStore()), _mainWindow, SLOT(onOpenedStore())); _mainWindow->show(); if (!_engine->lastOpenedStoreLocation().isEmpty()) _engine->openStore(_engine->lastOpenedStoreLocation()); else _mainWindow->onOpenStore(); // _engine->store()->setPassword("skyout"); /* QString text("this is a test string."); QByteArray btext(text.toAscii()); QByteArray key("THIS IS THE KEY"); QByteArray salt; MaStore::encrypt(btext, key, salt); qDebug() << "text (encrypted)" << btext << ", salt=" << salt; MaStore::encrypt(btext, key, salt); qDebug() << "text (clear)" << btext << ", salt=" << salt; return 0; */ int res = app.exec(); _engine->onShuttingDown(); delete _engine; return res; }
//-----------------------------------【main( )函数】------------------------------------------------------------------------------ // 描述:控制台应用程序的入口函数,我们的程序从这里开始 //-------------------------------------------------------------------------------------------------------------------------------- int main(int agrc, char** agrv) { initMain();//初始化 //载入原图 g_srcImage = imread(".\\sourcePicture\\3.bmp"); //添加噪音 if (noice) { salt(g_srcImage); imwrite("./output/noice.bmp", g_gradBmp); } //定义一个Mat类型并给其设定ROI区域 //g_srcImage = g_srcImage(Rect(0, 0, 250, 250)); //判断是否读取成功 if (!g_srcImage.data) { cout << "读取图片srcImage时出错!\n"; return false; } //将原图转换为灰度图 cvtColor(g_srcImage, g_srcGrayImage, CV_BGR2GRAY); ShowHelpText(g_srcGrayImage); //histGram(g_srcGrayImage); Edge edge1; Edge edge(g_srcGrayImage);//传值初始化 edge.Init();//深入初始化 //edge.edgeDection(1,NULL); //创建Canny检测的tracebar namedWindow("Canny检测"); //namedWindow("listk1"); namedWindow("listk1&&listk2"); createTrackbar("参数值:", "Canny检测", &g_cannyLowThreshold, 160, edge.on_Canny); namedWindow("g_mergImg");//, CV_WINDOW_NORMAL //createTrackbar("梯度:", "g_mergImg", &TH, 80, edge.edgeDection); //createTrackbar("相似度:", "g_mergImg", &TH1, 40, edge.edgeDection); //createTrackbar("相似度:", "g_edge[1]", &g_di, 80, edge.listK); edge.edgeDection(); //edge.edgeDection1(); g_srcGrayImage.convertTo(g_srcGrayImage, CV_32F); if (xls) { edge.outXls(g_srcGrayImage, "./output/gray.xls"); //outxlsInt(g_biGrad, "./output/bigrad.xls"); } //cout << g_ltedge << endl; //将原图转换为灰度图 //g_dstImage.convertTo(g_dstImage, CV_8UC1); //namedWindow("dst"); //imshow("dst", g_dstImage); //显示梯度图片 g_srcGrad.convertTo(g_gradBmp, CV_8UC1); imshow("梯度图", g_gradBmp); imwrite("./output/grad.bmp", g_gradBmp); //轮询获取按键信息,若按下Q,程序退出 while ((char(waitKey(1)) != 'q')) {} return 0; }
bool BotanWrapper::EncryptFile(QString Source, QString Destination) { QFileInfo name = Source; QString base = name.baseName(); QString encrypted1 = eoutput + base + ".gg"; QString encrypted2 = toutput + base + ".twofish"; QFile e(encrypted1); QFile t(encrypted2); try { //Setup the key derive functions PKCS5_PBKDF2 pbkdf2(new HMAC(new Keccak_1600)); const u32bit PBKDF2_ITERATIONS = 700000; qDebug() << "create keys"; //Create the KEY and IV KDF* kdf = get_kdf("KDF2(SHA-512)"); AutoSeeded_RNG rng; qDebug() << "create salt"; SecureVector<byte> salt(256); rng.randomize(&salt[0], salt.size()); mSalt = salt; qDebug() << "create master key"; //Create the master key SecureVector<byte> mMaster = pbkdf2.derive_key(128, mPassword.toStdString(), &mSalt[0], mSalt.size(),PBKDF2_ITERATIONS).bits_of(); SymmetricKey mKey = kdf->derive_key(32, mMaster, "salt1"); InitializationVector mIV = kdf->derive_key(16, mMaster, "salt2"); qDebug() << "start encryption"; string inFilename = Source.toStdString(); string outFilename = encrypted1.toStdString(); std::ifstream inFile(inFilename.c_str()); std::ofstream outFile(outFilename.c_str()); Pipe pipe(get_cipher("AES-256/EAX", mKey, mIV,ENCRYPTION),new DataSink_Stream(outFile)); outFile.write((const char*)mSalt.begin(), mSalt.size()); pipe.start_msg(); inFile >> pipe; pipe.end_msg(); outFile.flush(); outFile.close(); inFile.close(); QMessageBox msgBox; /*****************TWOFISH ENCRYPTION********************/ qDebug() << "Twofish"; //Setup the key derive functions PKCS5_PBKDF2 pbkdf3(new HMAC(new Skein_512)); //Create the KEY and IV KDF* kdf2 = get_kdf("KDF2(Whirlpool)"); SecureVector<byte> salt2(256); rng.randomize(&salt2[0], salt2.size()); mSalt2 = salt2; //Create the master key SecureVector<byte> mMaster2 = pbkdf3.derive_key(128, mPassword2.toStdString(), &mSalt2[0], mSalt2.size(),PBKDF2_ITERATIONS).bits_of(); SymmetricKey mKey2 = kdf2->derive_key(32, mMaster2, "salt1"); InitializationVector mIV2 = kdf2->derive_key(16, mMaster2, "salt2"); string inFilename2 = encrypted1.toStdString(); string outFilename2 = encrypted2.toStdString(); std::ifstream inFile2(inFilename2.c_str()); std::ofstream outFile2(outFilename2.c_str()); Pipe pipe2(get_cipher("Twofish/CFB", mKey2, mIV2,ENCRYPTION),new DataSink_Stream(outFile2)); outFile2.write((const char*)mSalt2.begin(), mSalt2.size()); pipe2.start_msg(); inFile2 >> pipe2; pipe2.end_msg(); outFile2.flush(); outFile2.close(); inFile2.close(); /**************************SERPENT ENCRYPTION*****************/ //Create the KEY and IV KDF* kdf3 = get_kdf("KDF2(Tiger)"); SecureVector<byte> salt3(256); rng.randomize(&salt3[0], salt3.size()); mSalt3 = salt3; //Create the master key SecureVector<byte> mMaster3 = pbkdf2.derive_key(128, mPassword3.toStdString(), &mSalt3[0], mSalt3.size(),PBKDF2_ITERATIONS).bits_of(); SymmetricKey mKey3 = kdf3->derive_key(32, mMaster3, "salt1"); InitializationVector mIV3 = kdf3->derive_key(16, mMaster3, "salt2"); string inFilename3 = encrypted2.toStdString(); string outFilename3 = Destination.toStdString(); std::ifstream inFile3(inFilename3.c_str()); std::ofstream outFile3(outFilename3.c_str()); qDebug() << "serpent"; Pipe pipe3(get_cipher("Serpent/CBC/PKCS7", mKey3, mIV3,ENCRYPTION),new DataSink_Stream(outFile3)); outFile3.write((const char*)mSalt3.begin(), mSalt3.size()); pipe3.start_msg(); inFile3 >> pipe3; pipe3.end_msg(); outFile3.flush(); outFile3.close(); inFile3.close(); msgBox.setText("Success!"); msgBox.setInformativeText("File successfully encrypted!"); msgBox.setStandardButtons(QMessageBox::Ok); msgBox.setDefaultButton(QMessageBox::Ok); msgBox.exec(); e.remove(); t.remove(); return true; } catch(...) { return false; } }