QByteArray CppRsaPublicKeyImpl::Encrypt(const QByteArray &data) const { if(!IsValid()) { return QByteArray(); } RSAES<OAEP<SHA> >::Encryptor encryptor(*m_public_key); int clength = ((data.size() / AES::BLOCKSIZE) + 1) * AES::BLOCKSIZE; int data_start = encryptor.FixedCiphertextLength() + AES::BLOCKSIZE; QByteArray ciphertext(data_start + clength, 0); CryptoRandom rand; QByteArray skey(AES::BLOCKSIZE, 0); rand.GenerateBlock(skey); QByteArray iv(AES::BLOCKSIZE, 0); rand.GenerateBlock(iv); ciphertext.replace(encryptor.FixedCiphertextLength(), iv.size(), iv); CBC_Mode<AES>::Encryption enc; enc.SetKeyWithIV(reinterpret_cast<byte *>(skey.data()), skey.size(), reinterpret_cast<byte *>(iv.data())); StringSource(reinterpret_cast<const byte *>(data.data()), data.size(), true, new StreamTransformationFilter(enc, new ArraySink(reinterpret_cast<byte *>(ciphertext.data() + data_start), clength))); encryptor.Encrypt(GetCppRandom(rand), reinterpret_cast<const byte *>(skey.data()), skey.size(), reinterpret_cast<byte *>(ciphertext.data())); return ciphertext; }
void SendTest(const Sessions &sessions) { qDebug() << "Starting SendTest"; QList<QByteArray> messages; CryptoRandom rand; foreach(const QSharedPointer<BufferSink> &sink, sessions.sinks) { sink->Clear(); } SignalCounter sc; foreach(const QSharedPointer<SignalSink> &ssink, sessions.signal_sinks) { QObject::connect(ssink.data(), SIGNAL(IncomingData(const QByteArray &)), &sc, SLOT(Counter())); } foreach(const ClientPointer &cs, sessions.clients) { QByteArray msg(64, 0); rand.GenerateBlock(msg); messages.append(msg); cs->Send(msg); } RunUntil(sc, sessions.clients.size() * (sessions.clients.size() + sessions.servers.size())); foreach(const QSharedPointer<BufferSink> &sink, sessions.sinks) { ASSERT_EQ(messages.size(), sink->Count()); for(int idx = 0; idx < sink->Count(); idx++) { ASSERT_TRUE(messages.contains(sink->At(idx).second)); } } qDebug() << "Finished SendTest"; }
void DisconnectServer(Sessions &sessions, bool hard) { qDebug() << "Disconnecting server" << hard; int server_count = sessions.servers.count(); CryptoRandom rand; int idx = rand.GetInt(0, server_count); OverlayPointer op_disc = sessions.network.first[idx]; if(hard) { op_disc->Stop(); sessions.servers[idx]->Stop(); // This will need to be adjusted if we support offline servers Time::GetInstance().IncrementVirtualClock(60000); Timer::GetInstance().VirtualRun(); OverlayPointer op(new Overlay(op_disc->GetId(), op_disc->GetLocalEndpoints(), op_disc->GetRemoteEndpoints(), op_disc->GetServerIds())); op->SetSharedPointer(op); sessions.network.first[idx] = op; ServerPointer ss = MakeSession<ServerSession>( op, sessions.private_keys[op->GetId().ToString()], sessions.keys, sessions.create_round); sessions.servers[idx] = ss; ss->SetSink(sessions.sink_multiplexers[idx].data()); op->Start(); ss->Start(); } else { // 1 for the node itself and 1 for at least another peer int disc_count = qMax(2, rand.GetInt(0, server_count)); QHash<int, bool> disced; disced[idx] = true; while(disced.size() < disc_count) { int to_disc = rand.GetInt(0, server_count); if(disced.contains(to_disc)) { continue; } disced[to_disc] = true; Id remote = sessions.network.first[to_disc]->GetId(); op_disc->GetConnectionTable().GetConnection(remote)->Disconnect(); } } qDebug() << "Disconnecting done"; StartRound(sessions); qDebug() << "Round started after disconnection"; }
TEST(Web, Directory) { QString dirname(QString::number(Random::GetInstance().GetInt())); while(QDir::temp().exists(dirname)) { dirname = QString::number(Random::GetInstance().GetInt()); } QDir::temp().mkdir(dirname); QString dirpath = QDir::tempPath() + "/" + dirname; CryptoRandom rand; QByteArray data(1000, 0); QList<QString> files; for(int i = 0; i < 5; i++) { files.append(QString::number(Random::GetInstance().GetInt())); QString filepath = dirpath + "/" + files.last(); QFile file(filepath); rand.GenerateBlock(data); ASSERT_TRUE(file.open(QIODevice::WriteOnly)); ASSERT_EQ(file.write(data), data.size()); file.close(); } WebServer webserver(QUrl("tcp://127.0.0.1:" + QString::number(TEST_PORT))); QSharedPointer<GetDirectoryService> dirserv(new GetDirectoryService(dirpath)); ASSERT_TRUE(webserver.AddRoute(QHttpRequest::HTTP_GET, "/dir", dirserv)); webserver.Start(); QNetworkAccessManager manager; QNetworkRequest request; request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded"); foreach(const QString &filename, files) { request.setUrl("http://127.0.0.1:" + QString::number(TEST_PORT) + "/dir?file=" + filename); QScopedPointer<QNetworkReply> reply(manager.get(request)); WaitCallback<QNetworkReply>(reply.data(), &QNetworkReply::isFinished); ASSERT_TRUE(reply->isFinished()); QByteArray response = reply->readAll(); QFile file(dirpath + "/" + filename); file.open(QIODevice::ReadOnly); QByteArray data = file.readAll(); ASSERT_EQ(response.size(), data.size()); ASSERT_EQ(response, data); file.remove(); }
virtual QByteArray GenerateXorMessage(int idx) { if(_bad == -1) { _bad = Random::GetInstance().GetInt(0, GetShuffleSink().Count()); } QByteArray msg = BulkRound::GenerateXorMessage(idx); if(GetDescriptors().size() != _bad + 1) { return msg; } SetTriggered(); CryptoRandom rng; msg.resize(rng.GetInt(0, msg.size())); rng.GenerateBlock(msg); return msg; }
TEST(Base64, basic) { CryptoRandom rand; QByteArray data(50, 0); for(int idx = 0; idx < 50; idx++) { rand.GenerateBlock(data); QByteArray base64 = ToUrlSafeBase64(data); QByteArray unbase64 = FromUrlSafeBase64(base64); ASSERT_EQ(data, unbase64); if(base64.contains('-') || base64.contains('_')) { continue; } QByteArray reg_base64 = data.toBase64(); ASSERT_EQ(base64, reg_base64); ASSERT_EQ(data, QByteArray::fromBase64(base64)); } }
TEST(Crypto, LRSTest) { DsaPrivateKey base_key; Integer generator = base_key.GetGenerator(); Integer subgroup = base_key.GetSubgroupOrder(); Integer modulus = base_key.GetModulus(); QVector<DsaPrivateKey> private_keys; QVector<DsaPublicKey> public_keys; int keys = 10; for(int idx = 0; idx < keys; idx++) { private_keys.append(DsaPrivateKey(modulus, subgroup, generator)); public_keys.append(DsaPublicKey(modulus, subgroup, generator, private_keys.last().GetPublicElement())); } CryptoRandom rng; QByteArray context(1024, 0); rng.GenerateBlock(context); QVector<QSharedPointer<LRSPrivateKey> > lrss; LRSPublicKey lrp(public_keys, context); for(int idx = 0; idx < keys; idx++) { lrss.append(QSharedPointer<LRSPrivateKey>( new LRSPrivateKey(private_keys[idx], public_keys, context))); } QByteArray msg(1500, 0); rng.GenerateBlock(msg); foreach(const QSharedPointer<LRSPrivateKey> &lrs, lrss) { QByteArray signature = lrs->Sign(msg); lrp.Verify(msg, signature); EXPECT_TRUE(lrp.VerifyKey(*(lrs.data()))); }