Test::Result run_one_test(const std::string& hash_algo, const VarMap& vars) override
{
Test::Result result("TOTP " + hash_algo);
std::unique_ptr<Botan::HashFunction> hash_test = Botan::HashFunction::create(hash_algo);
if(!hash_test)
return {result};
const std::vector<uint8_t> key = get_req_bin(vars, "Key");
const size_t otp = get_req_sz(vars, "OTP");
const size_t digits = get_req_sz(vars, "Digits");
const size_t timestep = get_req_sz(vars, "Timestep");
const std::string timestamp = get_req_str(vars, "Timestamp");
Botan::TOTP totp(key, hash_algo, digits, timestep);
std::chrono::system_clock::time_point time = from_timestring(timestamp);
std::chrono::system_clock::time_point later_time = time + std::chrono::seconds(timestep);
std::chrono::system_clock::time_point too_late = time + std::chrono::seconds(2*timestep);
result.test_eq("TOTP generate", totp.generate_totp(time), otp);
result.test_eq("TOTP verify valid", totp.verify_totp(otp, time, 0), true);
result.test_eq("TOTP verify invalid", totp.verify_totp(otp ^ 1, time, 0), false);
result.test_eq("TOTP verify time slip", totp.verify_totp(otp, later_time, 0), false);
result.test_eq("TOTP verify time slip allowed", totp.verify_totp(otp, later_time, 1), true);
result.test_eq("TOTP verify time slip out of range", totp.verify_totp(otp, too_late, 1), false);
return result;
}
Test::Result PK_KEM_Test::run_one_test(const std::string&, const VarMap& vars)
{
const std::vector<uint8_t> K = get_req_bin(vars, "K");
const std::vector<uint8_t> C0 = get_req_bin(vars, "C0");
const std::vector<uint8_t> salt = get_opt_bin(vars, "Salt");
const std::string kdf = get_req_str(vars, "KDF");
Test::Result result(algo_name() + "/" + kdf + " KEM");
std::unique_ptr<Botan::Private_Key> privkey = load_private_key(vars);
const Botan::Public_Key& pubkey = *privkey;
const size_t desired_key_len = K.size();
std::unique_ptr<Botan::PK_KEM_Encryptor> enc;
try
{
enc.reset(new Botan::PK_KEM_Encryptor(pubkey, Test::rng(), kdf));
}
catch(Botan::Lookup_Error&)
{
result.test_note("Skipping due to missing KDF: " + kdf);
return result;
}
Fixed_Output_RNG fixed_output_rng(get_req_bin(vars, "R"));
Botan::secure_vector<uint8_t> produced_encap_key, shared_key;
enc->encrypt(produced_encap_key,
shared_key,
desired_key_len,
fixed_output_rng,
salt);
result.test_eq("C0 matches", produced_encap_key, C0);
result.test_eq("K matches", shared_key, K);
std::unique_ptr<Botan::PK_KEM_Decryptor> dec;
try
{
dec.reset(new Botan::PK_KEM_Decryptor(*privkey, Test::rng(), kdf));
}
catch(Botan::Lookup_Error& e)
{
result.test_note("Skipping test", e.what());
return result;
}
const Botan::secure_vector<uint8_t> decr_shared_key =
dec->decrypt(C0.data(), C0.size(),
desired_key_len,
salt.data(),
salt.size());
result.test_eq("decrypted K matches", decr_shared_key, K);
return result;
}
std::unique_ptr<Botan::Private_Key> load_private_key(const VarMap& vars) override
{
const std::string group_id = get_req_str(vars, "Group");
const BigInt x = get_req_bn(vars, "X");
Botan::EC_Group group(Botan::OIDS::lookup(group_id));
std::unique_ptr<Botan::Private_Key> key(new Botan::ECDSA_PrivateKey(Test::rng(), group, x));
return key;
}
std::string default_padding(const VarMap& vars) const override
{
return "EMSA1(" + get_req_str(vars, "Hash") + ")";
}
