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())));
}
