aboutsummaryrefslogtreecommitdiffstats
path: root/src/cmd
diff options
context:
space:
mode:
Diffstat (limited to 'src/cmd')
-rw-r--r--src/cmd/apps.h6
-rw-r--r--src/cmd/credentials.h5
-rw-r--r--src/cmd/dl_group.cpp85
-rw-r--r--src/cmd/hash.cpp1
-rw-r--r--src/cmd/implementation/speed.h30
-rw-r--r--src/cmd/implementation/speed_prime.cpp96
-rw-r--r--src/cmd/implementation/speed_public_key.cpp (renamed from src/cmd/speed_pk.cpp)66
-rw-r--r--src/cmd/implementation/speed_transform.cpp67
-rw-r--r--src/cmd/implementation/timer.cpp (renamed from src/cmd/timer.cpp)0
-rw-r--r--src/cmd/implementation/timer.h (renamed from src/cmd/timer.h)0
-rw-r--r--src/cmd/mce.cpp117
-rw-r--r--src/cmd/pkcs8.cpp77
-rw-r--r--src/cmd/prime.cpp48
-rw-r--r--src/cmd/speed.cpp116
-rw-r--r--src/cmd/speed.h16
-rw-r--r--src/cmd/tls_client.cpp5
-rw-r--r--src/cmd/tls_server.cpp4
17 files changed, 606 insertions, 133 deletions
diff --git a/src/cmd/apps.h b/src/cmd/apps.h
index bcb860fb4..d56fab5ad 100644
--- a/src/cmd/apps.h
+++ b/src/cmd/apps.h
@@ -68,3 +68,9 @@ class AppRegistrations
};
#define REGISTER_APP(nm) AppRegistrations::AppRegistration g_ ## nm ## _registration(#nm, nm)
+
+#if defined(BOTAN_TARGET_OS_IS_WINDOWS) || defined(BOTAN_TARGET_OS_IS_MINGW)
+ #undef BOTAN_TARGET_OS_HAS_SOCKETS
+#else
+ #define BOTAN_TARGET_OS_HAS_SOCKETS
+#endif
diff --git a/src/cmd/credentials.h b/src/cmd/credentials.h
index f7109e1a3..06349657d 100644
--- a/src/cmd/credentials.h
+++ b/src/cmd/credentials.h
@@ -10,11 +10,6 @@
#include <botan/pkcs8.h>
#include <botan/credentials_manager.h>
#include <botan/x509self.h>
-#include <botan/rsa.h>
-#include <botan/dsa.h>
-#include <botan/srp6.h>
-#include <botan/srp6_files.h>
-#include <botan/ecdsa.h>
#include <iostream>
#include <fstream>
#include <memory>
diff --git a/src/cmd/dl_group.cpp b/src/cmd/dl_group.cpp
new file mode 100644
index 000000000..2db65ded2
--- /dev/null
+++ b/src/cmd/dl_group.cpp
@@ -0,0 +1,85 @@
+/*
+* (C) 2015 Jack Lloyd
+*
+* Botan is released under the Simplified BSD License (see license.txt)
+*/
+
+#include "apps.h"
+
+#if defined(BOTAN_HAS_DL_GROUP)
+
+#include <botan/dl_group.h>
+#include <fstream>
+
+namespace {
+
+std::string read_file_contents(const std::string& filename)
+ {
+ std::ifstream in(filename.c_str());
+ if(!in.good())
+ throw std::runtime_error("Failure reading " + filename);
+
+ std::vector<std::string> contents;
+ size_t total_size = 0;
+ while(in.good())
+ {
+ std::string line;
+ std::getline(in, line);
+ total_size += line.size();
+ contents.push_back(std::move(line));
+ }
+
+ std::string res;
+ contents.reserve(total_size);
+ for(auto&& line : contents)
+ res += line;
+ return res;
+ }
+
+int dl_group(int argc, char* argv[])
+ {
+ if(argc < 2)
+ {
+ std::cout << "Usage: " << argv[0] << " [create bits|info file]" << std::endl;
+ return 1;
+ }
+
+ const std::string cmd = argv[1];
+
+ if(cmd == "create")
+ {
+ AutoSeeded_RNG rng;
+ const size_t bits = to_u32bit(argv[2]);
+
+ const DL_Group::PrimeType prime_type = DL_Group::Strong;
+ //const DL_Group::PrimeType prime_type = DL_Group::Prime_Subgroup;
+
+ DL_Group grp(rng, prime_type, bits);
+
+ std::cout << grp.PEM_encode(DL_Group::DSA_PARAMETERS);
+ }
+ else if(cmd == "info")
+ {
+ DL_Group grp;
+ std::string pem = read_file_contents(argv[2]);
+ std::cout << pem << "\n";
+
+ std::cout << "DL_Group " << grp.get_p().bits() << " bits\n";
+ std::cout << "p=" << grp.get_p() << "\n";
+ std::cout << "q=" << grp.get_q() << "\n";
+ std::cout << "g=" << grp.get_g() << "\n";
+ }
+ else
+ {
+ std::cout << "ERROR: Unknown command\n";
+ return 1;
+ }
+
+ return 0;
+ }
+
+REGISTER_APP(dl_group);
+
+}
+
+#endif
diff --git a/src/cmd/hash.cpp b/src/cmd/hash.cpp
index fdeaa465d..7755bb4a5 100644
--- a/src/cmd/hash.cpp
+++ b/src/cmd/hash.cpp
@@ -8,7 +8,6 @@
#if defined(BOTAN_HAS_CODEC_FILTERS)
-#include <botan/lookup.h>
#include <botan/filters.h>
#include <iostream>
#include <fstream>
diff --git a/src/cmd/implementation/speed.h b/src/cmd/implementation/speed.h
new file mode 100644
index 000000000..3cfd0ef61
--- /dev/null
+++ b/src/cmd/implementation/speed.h
@@ -0,0 +1,30 @@
+/*
+* (C) 2014 Jack Lloyd
+* (C) 2015 Simon Warta (Kullo GmbH)
+*
+* Botan is released under the Simplified BSD License (see license.txt)
+*/
+
+#ifndef BOTAN_CHECK_BENCHMARK_H__
+#define BOTAN_CHECK_BENCHMARK_H__
+
+#include <botan/rng.h>
+#include <string>
+#include <chrono>
+
+void benchmark_public_key(Botan::RandomNumberGenerator& rng,
+ const std::string& algo,
+ const std::string& provider,
+ double seconds);
+
+std::map<std::string, double> benchmark_is_prime(Botan::RandomNumberGenerator &rng,
+ const std::chrono::milliseconds runtime);
+
+std::map<std::string, double> benchmark_random_prime(Botan::RandomNumberGenerator &rng,
+ const std::chrono::milliseconds runtime);
+
+bool benchmark_transform(Botan::RandomNumberGenerator& rng, const std::string& algo_name,
+ const std::chrono::milliseconds runtime);
+
+
+#endif
diff --git a/src/cmd/implementation/speed_prime.cpp b/src/cmd/implementation/speed_prime.cpp
new file mode 100644
index 000000000..a7a344bef
--- /dev/null
+++ b/src/cmd/implementation/speed_prime.cpp
@@ -0,0 +1,96 @@
+/*
+* (C) 2015 Simon Warta (Kullo GmbH)
+*
+* Botan is released under the Simplified BSD License (see license.txt)
+*/
+
+#include "speed.h"
+
+using namespace Botan;
+
+#if defined(BOTAN_HAS_NUMBERTHEORY)
+
+#include <botan/numthry.h>
+#include <chrono>
+
+namespace {
+const size_t RSA_EXP = 65537;
+const size_t RSA_BITS = 2048;
+
+const auto SAMPLE_DATA = std::vector<BigInt>{
+ BigInt("147572674850319649408425528388978190129147580193826207917614581140087181349813950149403694089438460074197915858493514824951402666113125007396293585089750170962882245605820159076002066981429137353341175732273168874025070408827561035943771554301600092787967626039381375658829078877390735440179859333066156895363"),
+ BigInt("147572674850319649408425528388978190129147580193826207917614581140087181349813950149403694089438460074197915858493514824951402666113125007396293585089750170962882245605820159076002066981429137353341175732273168874025070408827561035943771554301600092787967626039381375658829078877390735440179859333066156895377"),
+ BigInt("147572674850319649408425528388978190129147580193826207917614581140087181349813950149403694089438460074197915858493514824951402666113125007396293585089750170962882245605820159076002066981429137353341175732273168874025070408827561035943771554301600092787967626039381375658829078877390735440179859333066156895381"),
+ BigInt("147572674850319649408425528388978190129147580193826207917614581140087181349813950149403694089438460074197915858493514824951402666113125007396293585089750170962882245605820159076002066981429137353341175732273168874025070408827561035943771554301600092787967626039381375658829078877390735440179859333066156895389"),
+ BigInt("147572674850319649408425528388978190129147580193826207917614581140087181349813950149403694089438460074197915858493514824951402666113125007396293585089750170962882245605820159076002066981429137353341175732273168874025070408827561035943771554301600092787967626039381375658829078877390735440179859333066156895399"),
+ BigInt("147572674850319649408425528388978190129147580193826207917614581140087181349813950149403694089438460074197915858493514824951402666113125007396293585089750170962882245605820159076002066981429137353341175732273168874025070408827561035943771554301600092787967626039381375658829078877390735440179859333066156895401"),
+ BigInt("147572674850319649408425528388978190129147580193826207917614581140087181349813950149403694089438460074197915858493514824951402666113125007396293585089750170962882245605820159076002066981429137353341175732273168874025070408827561035943771554301600092787967626039381375658829078877390735440179859333066156895431"),
+ BigInt("147572674850319649408425528388978190129147580193826207917614581140087181349813950149403694089438460074197915858493514824951402666113125007396293585089750170962882245605820159076002066981429137353341175732273168874025070408827561035943771554301600092787967626039381375658829078877390735440179859333066156895441"),
+ BigInt("147572674850319649408425528388978190129147580193826207917614581140087181349813950149403694089438460074197915858493514824951402666113125007396293585089750170962882245605820159076002066981429137353341175732273168874025070408827561035943771554301600092787967626039381375658829078877390735440179859333066156895461"),
+ BigInt("147572674850319649408425528388978190129147580193826207917614581140087181349813950149403694089438460074197915858493514824951402666113125007396293585089750170962882245605820159076002066981429137353341175732273168874025070408827561035943771554301600092787967626039381375658829078877390735440179859333066156895471"),
+ };
+}
+
+#endif // BOTAN_HAS_NUMBERTHEORY
+
+std::map<std::string, double> benchmark_is_prime(RandomNumberGenerator& rng,
+ const std::chrono::milliseconds runtime)
+ {
+ std::map<std::string, double> speeds;
+
+#if defined(BOTAN_HAS_NUMBERTHEORY)
+
+ std::chrono::nanoseconds time_used(0);
+ size_t reps = 0;
+
+ auto start = std::chrono::high_resolution_clock::now();
+
+ while(time_used < runtime)
+ {
+ // main work
+ for (const BigInt &p : SAMPLE_DATA)
+ {
+ is_prime(p, rng, 64, true);
+ }
+
+ ++reps;
+ time_used = std::chrono::high_resolution_clock::now() - start;
+ }
+
+ const double seconds_used = static_cast<double>(time_used.count()) / 1000000000;
+ speeds["base"] = reps / seconds_used; // ie, return ops per second
+
+#endif // BOTAN_HAS_NUMBERTHEORY
+
+ return speeds;
+ }
+
+std::map<std::string, double> benchmark_random_prime(RandomNumberGenerator& rng,
+ const std::chrono::milliseconds runtime)
+ {
+ std::map<std::string, double> speeds;
+
+#if defined(BOTAN_HAS_NUMBERTHEORY)
+
+ std::chrono::nanoseconds time_used(0);
+ size_t reps = 0;
+
+ auto start = std::chrono::high_resolution_clock::now();
+
+ while(time_used < runtime)
+ {
+ // main work
+ random_prime(rng, (RSA_BITS + 1) / 2, RSA_EXP);
+
+ ++reps;
+ time_used = std::chrono::high_resolution_clock::now() - start;
+ }
+
+ const double seconds_used = static_cast<double>(time_used.count()) / 1000000000;
+ speeds["base"] = reps / seconds_used; // ie, return ops per second
+
+#endif // BOTAN_HAS_NUMBERTHEORY
+
+ return speeds;
+ }
+
diff --git a/src/cmd/speed_pk.cpp b/src/cmd/implementation/speed_public_key.cpp
index 035b9a3af..2ff49bd15 100644
--- a/src/cmd/speed_pk.cpp
+++ b/src/cmd/implementation/speed_public_key.cpp
@@ -4,7 +4,7 @@
* Botan is released under the Simplified BSD License (see license.txt)
*/
-#include "apps.h"
+#include "../apps.h"
#if defined(BOTAN_HAS_PUBLIC_KEY_CRYPTO)
@@ -82,12 +82,15 @@ using namespace Botan;
namespace {
const char* ec_domains[] = {
- "secp160r2",
- "secp192r1",
- "secp224r1",
+ // "secp160r2",
+ // "secp192r1",
+ // "secp224r1",
"secp256r1",
"secp384r1",
"secp521r1",
+ //"brainpool256r1",
+ //"brainpool384r1",
+ //"brainpool512r1",
nullptr
};
@@ -159,6 +162,8 @@ void benchmark_sig_ver(PK_Verifier& ver, PK_Signer& sig,
message.resize(48);
rng.randomize(&message[0], message.size());
}
+ else
+ message[0]++;
sig_timer.start();
signature = sig.sign_message(message, rng);
@@ -197,7 +202,8 @@ void benchmark_sig_ver(PK_Verifier& ver, PK_Signer& sig,
*/
#if defined(BOTAN_HAS_RSA)
-void benchmark_rsa(RandomNumberGenerator& rng,
+void benchmark_rsa(const std::string& provider,
+ RandomNumberGenerator& rng,
double seconds,
Benchmark_Report& report)
{
@@ -208,8 +214,8 @@ void benchmark_rsa(RandomNumberGenerator& rng,
{
size_t keylen = keylens[i];
- //const std::string sig_padding = "EMSA4(SHA-1)";
- //const std::string enc_padding = "EME1(SHA-1)";
+ //const std::string sig_padding = "PSSR(SHA-256)";
+ //const std::string enc_padding = "OAEP(SHA-1)";
const std::string sig_padding = "EMSA-PKCS1-v1_5(SHA-1)";
const std::string enc_padding = "EME-PKCS1-v1_5";
@@ -238,14 +244,14 @@ void benchmark_rsa(RandomNumberGenerator& rng,
while(verify_timer.seconds() < seconds ||
sig_timer.seconds() < seconds)
{
- PK_Encryptor_EME enc(key, enc_padding);
- PK_Decryptor_EME dec(key, enc_padding);
+ PK_Encryptor_EME enc(key, enc_padding, provider);
+ PK_Decryptor_EME dec(key, enc_padding, provider);
benchmark_enc_dec(enc, dec, enc_timer, dec_timer,
rng, 10000, seconds);
- PK_Signer sig(key, sig_padding);
- PK_Verifier ver(key, sig_padding);
+ PK_Signer sig(key, sig_padding, IEEE_1363, provider);
+ PK_Verifier ver(key, sig_padding, IEEE_1363, provider);
benchmark_sig_ver(ver, sig, verify_timer,
sig_timer, rng, 10000, seconds);
@@ -313,7 +319,8 @@ void benchmark_rw(RandomNumberGenerator& rng,
#if defined(BOTAN_HAS_ECDSA)
-void benchmark_ecdsa(RandomNumberGenerator& rng,
+void benchmark_ecdsa(const std::string& provider,
+ RandomNumberGenerator& rng,
double seconds,
Benchmark_Report& report)
{
@@ -343,14 +350,14 @@ void benchmark_ecdsa(RandomNumberGenerator& rng,
ECDSA_PrivateKey key(rng, params);
keygen_timer.stop();
- PK_Signer sig(key, padding, IEEE_1363);
- PK_Verifier ver(key, padding);
+ PK_Signer sig(key, padding, IEEE_1363, provider);
+ PK_Verifier ver(key, padding, IEEE_1363, provider);
benchmark_sig_ver(ver, sig, verify_timer,
sig_timer, rng, 1000, seconds);
}
- const std::string nm = "ECDSA-" + std::to_string(pbits);
+ const std::string nm = std::string("ECDSA ") + ec_domains[j];
report.report(nm, keygen_timer);
report.report(nm, verify_timer);
@@ -729,20 +736,21 @@ void benchmark_mce(RandomNumberGenerator& rng,
Benchmark_Report& report)
{
const std::vector<std::pair<size_t, size_t>> params = {
- { 1024, 35 },
- { 2048, 50 },
- { 2960, 56 },
+ { 1632, 33 },
+ { 2480, 45 },
+ { 2960, 57 },
+ { 3408, 67 },
+ { 4264, 95 },
{ 6624, 115 }
};
const std::string algo_name = "McEliece";
- const std::string padding = "Raw";
for(auto& param : params)
{
Timer keygen_timer("keygen");
- Timer enc_timer(padding + " encrypt");
- Timer dec_timer(padding + " decrypt");
+ Timer enc_timer("encrypt");
+ Timer dec_timer("decrypt");
keygen_timer.start();
McEliece_PrivateKey priv_key(rng, param.first, param.second);
@@ -771,9 +779,9 @@ void benchmark_mce(RandomNumberGenerator& rng,
std::to_string(param.second);
std::ostringstream keysize_report;
- keysize_report << "(size " << pub_key.x509_subject_public_key().size() << " pub "
- << priv_key.pkcs8_private_key().size() << " priv "
- << pub_key.estimated_strength() << " work factor)";
+ keysize_report << "(work factor " << pub_key.estimated_strength() << ", "
+ << "pub bytes " << pub_key.x509_subject_public_key().size() << " "
+ << "priv bytes " << priv_key.pkcs8_private_key().size() << ")";
report.report(nm + " " + keysize_report.str(), keygen_timer);
report.report(nm, enc_timer);
@@ -784,8 +792,10 @@ void benchmark_mce(RandomNumberGenerator& rng,
}
-void bench_pk(RandomNumberGenerator& rng,
- const std::string& algo, double seconds)
+void benchmark_public_key(RandomNumberGenerator& rng,
+ const std::string& algo,
+ const std::string& provider,
+ double seconds)
{
/*
There is some strangeness going on here. It looks like algorithms
@@ -817,7 +827,7 @@ void bench_pk(RandomNumberGenerator& rng,
#if defined(BOTAN_HAS_RSA)
if(algo == "All" || algo == "RSA")
- benchmark_rsa(rng, seconds, report);
+ benchmark_rsa(provider, rng, seconds, report);
#endif
#if defined(BOTAN_HAS_DSA)
@@ -827,7 +837,7 @@ void bench_pk(RandomNumberGenerator& rng,
#if defined(BOTAN_HAS_ECDSA)
if(algo == "All" || algo == "ECDSA")
- benchmark_ecdsa(rng, seconds, report);
+ benchmark_ecdsa(provider, rng, seconds, report);
#endif
#if defined(BOTAN_HAS_ECDH)
diff --git a/src/cmd/implementation/speed_transform.cpp b/src/cmd/implementation/speed_transform.cpp
new file mode 100644
index 000000000..2db5cdd70
--- /dev/null
+++ b/src/cmd/implementation/speed_transform.cpp
@@ -0,0 +1,67 @@
+/*
+* (C) 2009 Jack Lloyd
+*
+* Botan is released under the Simplified BSD License (see license.txt)
+*/
+
+#include "speed.h"
+
+#include <iostream>
+#include <iomanip>
+
+#include <botan/cipher_mode.h>
+#include <botan/transform.h>
+
+using namespace Botan;
+
+namespace {
+void benchmark_transform(std::unique_ptr<Transform> tf,
+ RandomNumberGenerator& rng,
+ const std::chrono::milliseconds runtime)
+ {
+ for(size_t buf_size : { 16, 64, 256, 1024, 8192 })
+ {
+ secure_vector<byte> buffer(buf_size);
+
+ std::chrono::nanoseconds time_used(0);
+
+ tf->start(rng.random_vec(tf->default_nonce_length()));
+
+ auto start = std::chrono::high_resolution_clock::now();
+
+ secure_vector<byte> buf(buf_size);
+ size_t reps = 0;
+ while(time_used < runtime)
+ {
+ tf->update(buf);
+ buf.resize(buf_size);
+ ++reps;
+ time_used = std::chrono::high_resolution_clock::now() - start;
+ }
+
+ const u64bit nsec_used = std::chrono::duration_cast<std::chrono::nanoseconds>(time_used).count();
+
+ const double seconds_used = static_cast<double>(nsec_used) / 1000000000;
+
+ const double Mbps = ((reps / seconds_used) * buf_size) / 1024 / 1024;
+
+ std::cout << tf->name() << " " << std::setprecision(4) << Mbps
+ << " MiB / sec with " << buf_size << " byte blocks" << std::endl;
+ }
+ }
+}
+
+bool benchmark_transform(RandomNumberGenerator& rng, const std::string& algo_name,
+ const std::chrono::milliseconds runtime)
+ {
+ std::unique_ptr<Transform> tf;
+ tf.reset(get_cipher_mode(algo_name, ENCRYPTION));
+ if(!tf)
+ return false;
+
+ if(Keyed_Transform* keyed = dynamic_cast<Keyed_Transform*>(tf.get()))
+ keyed->set_key(rng.random_vec(keyed->key_spec().maximum_keylength()));
+
+ benchmark_transform(std::move(tf), rng, runtime);
+ return true;
+ }
diff --git a/src/cmd/timer.cpp b/src/cmd/implementation/timer.cpp
index 14e55316b..14e55316b 100644
--- a/src/cmd/timer.cpp
+++ b/src/cmd/implementation/timer.cpp
diff --git a/src/cmd/timer.h b/src/cmd/implementation/timer.h
index ac5bd5cef..ac5bd5cef 100644
--- a/src/cmd/timer.h
+++ b/src/cmd/implementation/timer.h
diff --git a/src/cmd/mce.cpp b/src/cmd/mce.cpp
new file mode 100644
index 000000000..3b33df661
--- /dev/null
+++ b/src/cmd/mce.cpp
@@ -0,0 +1,117 @@
+#include "apps.h"
+
+#if defined(BOTAN_HAS_MCELIECE)
+
+#include <botan/mceliece.h>
+#include <botan/mceies.h>
+#include <botan/pkcs8.h>
+#include <fstream>
+
+namespace {
+
+int mce(int argc, char* argv[])
+ {
+ if(argc < 4)
+ {
+ std::cout << "Usage: " << argv[0] << " [keygen n t pass|keybits n t|encrypt file key|decrypt file key pass]\n";
+ return 1;
+ }
+
+ const std::string cmd = argv[1];
+
+ AutoSeeded_RNG rng;
+
+ if(cmd == "keygen")
+ {
+ const size_t n = std::stol(argv[2]);
+ const size_t t = std::stol(argv[3]);
+ const std::string pass = argv[4];
+
+ McEliece_PrivateKey pk(rng, n, t);
+
+ bool ok = pk.check_key(rng, true);
+
+ if(!ok)
+ {
+ std::cout << "Keygen failed self-test\n";
+ return 2;
+ }
+
+ /*
+ secure_vector<byte> priv = PKCS8::BER_encode(pk);
+ std::vector<byte> pub = X509::BER_encode(pk);
+ std::cout << priv.size()/1024.0 << " " << pub.size()/1024.0 << "\n";
+ */
+
+ std::ofstream pub_file("mce.pub");
+ pub_file << X509::PEM_encode(pk);
+ pub_file.close();
+
+ std::ofstream priv_file("mce.priv");
+ priv_file << PKCS8::PEM_encode(pk, rng, pass);
+ priv_file.close();
+ }
+ else if(cmd == "keybits")
+ {
+ const size_t n = std::stol(argv[2]);
+ const size_t t = std::stol(argv[3]);
+ std::cout << "McEliece key with params (" << n << "," << t << ") has "
+ << mceliece_work_factor(n, t) << " bit security\n";
+ }
+ else if(cmd == "encrypt")
+ {
+ std::unique_ptr<Public_Key> p8(X509::load_key(argv[3]));
+ const McEliece_PublicKey* key = dynamic_cast<McEliece_PublicKey*>(p8.get());
+
+ if(!key)
+ {
+ throw std::runtime_error("Loading McEliece public key failed");
+ }
+
+ const std::string input_path = argv[2];
+ std::ifstream in(input_path, std::ios::binary);
+ std::string pt((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
+
+ secure_vector<byte> ct = mceies_encrypt(*key,
+ reinterpret_cast<const byte*>(pt.data()),
+ pt.size(),
+ nullptr, 0, rng, "AES-128/GCM");
+
+ std::cout << pt.size() << " -> " << ct.size() << "\n";
+
+ std::ofstream out(std::string(input_path) + ".ct", std::ios::binary);
+ out.write(reinterpret_cast<const char*>(ct.data()), ct.size());
+ out.close();
+ }
+ else if(cmd == "decrypt")
+ {
+ const std::string key_file = argv[3];
+ const std::string pass = argv[4];
+ std::unique_ptr<Private_Key> p8(PKCS8::load_key(key_file, rng, pass));
+ const McEliece_PrivateKey* key = dynamic_cast<McEliece_PrivateKey*>(p8.get());
+
+ if(!key)
+ {
+ throw std::runtime_error("Loading McEliece private key failed");
+ }
+
+ std::ifstream in(argv[2], std::ios::binary);
+ std::string ct((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
+
+ secure_vector<byte> pt = mceies_decrypt(*key,
+ reinterpret_cast<const byte*>(ct.data()),
+ ct.size(),
+ nullptr, 0, "AES-128/GCM");
+
+ std::ofstream out("mce.plaintext", std::ios::binary);
+ out.write(reinterpret_cast<const char*>(pt.data()), pt.size());
+ out.close();
+ }
+ return 0;
+ }
+
+}
+
+REGISTER_APP(mce);
+
+#endif
diff --git a/src/cmd/pkcs8.cpp b/src/cmd/pkcs8.cpp
new file mode 100644
index 000000000..19af70eb1
--- /dev/null
+++ b/src/cmd/pkcs8.cpp
@@ -0,0 +1,77 @@
+/*
+* (C) 2015 René Korthaus
+*
+* Botan is released under the Simplified BSD License (see license.txt)
+*/
+
+#include "apps.h"
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <memory>
+#include <chrono>
+
+#if defined(BOTAN_HAS_PUBLIC_KEY_CRYPTO)
+#include <botan/pk_keys.h>
+#include <botan/pkcs8.h>
+#include <botan/x509_key.h>
+
+using namespace Botan;
+
+namespace {
+
+int pkcs8(int argc, char* argv[])
+ {
+ BOTAN_UNUSED(argc);
+ OptionParser opts("in=|out=|passin=|passout=|pbe=|pubout");
+ opts.parse(argv);
+
+ const std::string passin = opts.value_or_else("passin", "");
+ const std::string passout = opts.value_or_else("passout", "");
+ const std::string pbe = opts.value_or_else("pbe", "");
+
+ if(argc < 3)
+ {
+ opts.help( std::cout, "pkcs8" );
+ return 1;
+ }
+
+ try
+ {
+ std::ofstream out_key(opts.value("out"));
+
+ if (!out_key)
+ {
+ std::cout << "Couldn't write key" << std::endl;
+ return 1;
+ }
+
+ AutoSeeded_RNG rng;
+ std::unique_ptr<Private_Key> key(PKCS8::load_key(opts.value("in"), rng, passin));
+
+ if(opts.is_set("pubout"))
+ {
+ out_key << X509::PEM_encode(*key);
+ }
+ else
+ {
+ if(passout.empty())
+ out_key << PKCS8::PEM_encode(*key);
+ else
+ out_key << PKCS8::PEM_encode(*key, rng, passout, std::chrono::milliseconds(300), pbe);
+ }
+ }
+ catch(std::exception& e)
+ {
+ std::cout << "Exception caught: " << e.what() << std::endl;
+ return 2;
+ }
+
+ return 0;
+ }
+
+REGISTER_APP(pkcs8);
+
+}
+
+#endif
diff --git a/src/cmd/prime.cpp b/src/cmd/prime.cpp
new file mode 100644
index 000000000..61f535dd7
--- /dev/null
+++ b/src/cmd/prime.cpp
@@ -0,0 +1,48 @@
+/*
+* (C) 2015 Jack Lloyd
+*
+* Botan is released under the Simplified BSD License (see license.txt)
+*/
+
+#include "apps.h"
+
+#if defined(BOTAN_HAS_NUMBERTHEORY)
+
+#include <botan/numthry.h>
+
+#include <algorithm>
+#include <iostream>
+
+namespace {
+
+int prime(int argc, char* argv[])
+ {
+ if(argc < 2)
+ {
+ std::cout << "Usage: " << argv[0] << " bits count" << std::endl;
+ return 1;
+ }
+
+ AutoSeeded_RNG rng;
+ const size_t bits = to_u32bit(argv[1]);
+ const size_t cnt = argv[2] != nullptr ? to_u32bit(argv[2]) : 1;
+
+ for(size_t i = 0; i != cnt; ++i)
+ {
+ const BigInt p = random_prime(rng, bits);
+ std::cout << p << "\n";
+
+ if(p.bits() != bits)
+ {
+ std::cout << "Result not exactly requested bit size, got " << p.bits() << "\n";
+ }
+ }
+
+ return 0;
+ }
+
+}
+
+REGISTER_APP(prime);
+
+#endif
diff --git a/src/cmd/speed.cpp b/src/cmd/speed.cpp
index eea3a7c60..990c6a364 100644
--- a/src/cmd/speed.cpp
+++ b/src/cmd/speed.cpp
@@ -8,27 +8,17 @@
#if defined(BOTAN_HAS_RUNTIME_BENCHMARKING)
-#include "speed.h"
+#include "implementation/speed.h"
+
#include <iostream>
#include <iomanip>
#include <botan/benchmark.h>
#include <botan/auto_rng.h>
-#include <botan/cipher_mode.h>
-#include <botan/parsing.h>
-#include <botan/symkey.h>
-#include <botan/transform.h>
-#include <botan/hex.h>
-
-#include <chrono>
-
-typedef std::chrono::high_resolution_clock benchmark_clock;
-
using namespace Botan;
namespace {
-
const std::vector<std::string> default_benchmark_list = {
/* Block ciphers */
"AES-128",
@@ -90,7 +80,11 @@ const std::vector<std::string> default_benchmark_list = {
/* MACs */
"CMAC(AES-128)",
- "HMAC(SHA-1)"
+ "HMAC(SHA-1)",
+
+ /* Misc */
+ "is_prime",
+ "random_prime"
};
void report_results(const std::string& algo,
@@ -123,84 +117,50 @@ void report_results(const std::string& algo,
std::cout.flags(flags);
}
-void time_transform(std::unique_ptr<Transform> tf,
- RandomNumberGenerator& rng)
+void bench_algo(const std::string& algo,
+ const std::string& provider,
+ RandomNumberGenerator& rng,
+ double seconds,
+ size_t buf_size)
{
- const std::chrono::seconds runtime(2);
-
- for(size_t buf_size : { 16, 64, 256, 1024, 8192 })
- {
- secure_vector<byte> buffer(buf_size);
-
- std::chrono::nanoseconds time_used(0);
-
- tf->start(rng.random_vec(tf->default_nonce_length()));
-
- auto start = std::chrono::high_resolution_clock::now();
-
- secure_vector<byte> buf(buf_size);
- size_t reps = 0;
- while(time_used < runtime)
- {
- tf->update(buf);
- buf.resize(buf_size);
- ++reps;
- time_used = std::chrono::high_resolution_clock::now() - start;
- }
-
- const u64bit nsec_used = std::chrono::duration_cast<std::chrono::nanoseconds>(time_used).count();
-
- const double seconds_used = static_cast<double>(nsec_used) / 1000000000;
+ std::chrono::milliseconds runtime(
+ static_cast<std::chrono::milliseconds::rep>(seconds * 1000));
- const double Mbps = ((reps / seconds_used) * buf_size) / 1024 / 1024;
-
- std::cout << tf->name() << " " << std::setprecision(4) << Mbps
- << " MiB / sec with " << buf_size << " byte blocks" << std::endl;
- }
- }
-
-bool time_transform(const std::string& algo, RandomNumberGenerator& rng)
+ if (algo == "random_prime")
{
- std::unique_ptr<Transform> tf;
- tf.reset(get_cipher_mode(algo, ENCRYPTION));
- if(!tf)
- return false;
-
- if(Keyed_Transform* keyed = dynamic_cast<Keyed_Transform*>(tf.get()))
- keyed->set_key(rng.random_vec(keyed->key_spec().maximum_keylength()));
-
- time_transform(std::move(tf), rng);
- return true;
+ auto speeds = benchmark_random_prime(rng, runtime);
+ report_results(algo, speeds);
+ return;
}
-void bench_algo(const std::string& algo,
- RandomNumberGenerator& rng,
- double seconds,
- size_t buf_size)
+ if (algo == "is_prime")
{
- std::chrono::milliseconds ms(
- static_cast<std::chrono::milliseconds::rep>(seconds * 1000));
+ auto speeds = benchmark_is_prime(rng, runtime);
+ report_results(algo, speeds);
+ return;
+ }
- if(time_transform(algo, rng))
+ // This does report itself
+ if (benchmark_transform(rng, algo, runtime))
return;
- std::map<std::string, double> speeds = algorithm_benchmark(algo, rng, ms, buf_size);
-
- if(!speeds.empty())
+ try
{
+ auto speeds = algorithm_benchmark(algo, rng, runtime, buf_size);
report_results(algo, speeds);
- return;
}
-
-#if defined(BOTAN_HAS_PUBLIC_KEY_CRYPTO)
- bench_pk(rng, algo, seconds);
-#endif
+ catch (No_Provider_Found)
+ {
+ #if defined(BOTAN_HAS_PUBLIC_KEY_CRYPTO)
+ benchmark_public_key(rng, algo, provider, seconds);
+ #endif
+ }
}
int speed(int argc, char* argv[])
{
BOTAN_UNUSED(argc);
- OptionParser opts("seconds=|buf-size=");
+ OptionParser opts("seconds=|buf-size=|provider=");
opts.parse(argv);
double seconds = .5;
@@ -226,7 +186,9 @@ int speed(int argc, char* argv[])
}
}
- auto args = opts.arguments();
+ const std::string provider = opts.value_if_set("provider");
+
+ std::vector<std::string> args = opts.arguments();
if(args.empty())
args = default_benchmark_list;
@@ -240,7 +202,9 @@ int speed(int argc, char* argv[])
AutoSeeded_RNG rng;
for(auto alg: args)
- bench_algo(alg, rng, seconds, buf_size);
+ {
+ bench_algo(alg, provider, rng, seconds, buf_size);
+ }
return 0;
}
diff --git a/src/cmd/speed.h b/src/cmd/speed.h
deleted file mode 100644
index 5f3918a3f..000000000
--- a/src/cmd/speed.h
+++ /dev/null
@@ -1,16 +0,0 @@
-/*
-* (C) 2014 Jack Lloyd
-*
-* Botan is released under the Simplified BSD License (see license.txt)
-*/
-
-#ifndef BOTAN_CHECK_BENCHMARK_H__
-#define BOTAN_CHECK_BENCHMARK_H__
-
-#include <botan/rng.h>
-#include <string>
-
-void bench_pk(Botan::RandomNumberGenerator& rng,
- const std::string& algo, double seconds);
-
-#endif
diff --git a/src/cmd/tls_client.cpp b/src/cmd/tls_client.cpp
index a5da299c6..f9d32ea6c 100644
--- a/src/cmd/tls_client.cpp
+++ b/src/cmd/tls_client.cpp
@@ -6,10 +6,7 @@
#include "apps.h"
-#if defined(BOTAN_HAS_TLS) \
- && defined(BOTAN_HAS_DSA) \
- && !defined(BOTAN_TARGET_OS_IS_WINDOWS) \
- && !defined(BOTAN_TARGET_OS_IS_MINGW)
+#if defined(BOTAN_HAS_TLS) && defined(BOTAN_TARGET_OS_HAS_SOCKETS)
#include <botan/tls_client.h>
#include <botan/pkcs8.h>
diff --git a/src/cmd/tls_server.cpp b/src/cmd/tls_server.cpp
index 744ab5544..cd95cf0d6 100644
--- a/src/cmd/tls_server.cpp
+++ b/src/cmd/tls_server.cpp
@@ -7,9 +7,7 @@
#include "apps.h"
-#if defined(BOTAN_HAS_TLS) && defined(BOTAN_HAS_DSA) \
- && !defined(BOTAN_TARGET_OS_IS_WINDOWS) \
- && !defined(BOTAN_TARGET_OS_IS_MINGW)
+#if defined(BOTAN_HAS_TLS) && defined(BOTAN_TARGET_OS_HAS_SOCKETS)
#include <botan/tls_server.h>
#include <botan/hex.h>
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-24 17:47:49 +0000