rsa_test.cc

#include <vereign/crypto/rand.hh>
#include <vereign/ncrypt/rsa.hh>

#include <vereign/core/scope_guard.hh>
#include <vereign/ncrypt/unique_ptr.hh>
#include <vereign/bytes/view_dump.hh>

#include <catch2/catch.hpp>
#include <iostream>

using namespace vereign;

TEST_CASE("ncrypt::rsa::OpenStorageProvider", "[vereign/ncrypt/rsa][vereign/ncrypt]") {
  auto provider = ncrypt::rsa::OpenStorageProvider();
  CHECK(provider.Get() != 0);
}

TEST_CASE("ncrypt::CreateKey", "[vereign/ncrypt/rsa][vereign/ncrypt]") {
  const auto test_key = std::string{"vereign_test_key"};

  SECTION("when the key does not exists, it must create a new key") {
    auto provider = ncrypt::rsa::OpenStorageProvider();

    // cleanup
    auto key = ncrypt::rsa::LoadKey(provider.Get(), test_key);
    if (key) {
      ncrypt::rsa::DeleteKey(key.Get());
    }

    auto new_key = ncrypt::rsa::CreateKey(provider.Get(), 2048, test_key, {});
    CHECK(new_key.Get() != 0);

    key = ncrypt::rsa::LoadKey(provider.Get(), test_key);
    CHECK(key.Get() != 0);

    // cleanup
    ncrypt::rsa::DeleteKey(key.Get());
  }

  SECTION("when the key already exists, it must fail with NTE_EXISTS") {
    auto provider = ncrypt::rsa::OpenStorageProvider();

    // cleanup
    auto key = ncrypt::rsa::LoadKey(provider.Get(), test_key);
    if (key) {
      ncrypt::rsa::DeleteKey(key.Get());
    }

    auto new_key = ncrypt::rsa::CreateKey(provider.Get(), 2048, test_key, {});
    CHECK(new_key.Get() != 0);

    CHECK_THROWS_WITH(
      ncrypt::rsa::CreateKey(provider.Get(), 2048, test_key, {}),
      "creating rsa key failed: NTE_EXISTS"
    );

    key = ncrypt::rsa::LoadKey(provider.Get(), test_key);
    CHECK(key.Get() != 0);

    // cleanup
    ncrypt::rsa::DeleteKey(key.Get());
  }
}

TEST_CASE("ncrypt::rsa::LoadKey", "[vereign/ncrypt/rsa][vereign/ncrypt]") {
  const auto test_key = std::string{"vereign_test_key"};

  SECTION("when the key exists, it must load the key") {
    auto provider = ncrypt::rsa::OpenStorageProvider();

    // cleanup
    auto key = ncrypt::rsa::LoadKey(provider.Get(), test_key);
    if (key) {
      ncrypt::rsa::DeleteKey(key.Get());
    }

    auto new_key = ncrypt::rsa::CreateKey(provider.Get(), 2048, test_key, {});
    CHECK(new_key.Get() != 0);

    key = ncrypt::rsa::LoadKey(provider.Get(), test_key);
    CHECK(key.Get() != 0);

    // cleanup
    ncrypt::rsa::DeleteKey(key.Get());
  }

  SECTION("when the key does not exists, it must fail") {
    auto provider = ncrypt::rsa::OpenStorageProvider();

    // cleanup
    auto key = ncrypt::rsa::LoadKey(provider.Get(), test_key);
    if (key) {
      ncrypt::rsa::DeleteKey(key.Get());
    }

    key = ncrypt::rsa::LoadKey(provider.Get(), test_key);
    CHECK(key.Get() == 0);
  }
}

TEST_CASE("ncrypt::rsa::DeleteKey", "[vereign/ncrypt/rsa][vereign/ncrypt]") {
  const auto test_key = std::string{"vereign_test_key"};

  SECTION("when the key exists, it must delete the key") {
    auto provider = ncrypt::rsa::OpenStorageProvider();

    // cleanup
    auto key = ncrypt::rsa::LoadKey(provider.Get(), test_key);
    if (key) {
      ncrypt::rsa::DeleteKey(key.Get());
    }

    auto new_key = ncrypt::rsa::CreateKey(provider.Get(), 2048, test_key, {});
    CHECK(new_key.Get() != 0);

    ncrypt::rsa::DeleteKey(new_key.Get());

    key = ncrypt::rsa::LoadKey(provider.Get(), test_key);
    CHECK(key.Get() == 0);
  }

  SECTION("when the key does not exists, it must fail") {
    auto provider = ncrypt::rsa::OpenStorageProvider();

    // cleanup
    auto key = ncrypt::rsa::LoadKey(provider.Get(), test_key);
    if (key) {
      ncrypt::rsa::DeleteKey(key.Get());
    }

    auto new_key = ncrypt::rsa::CreateKey(provider.Get(), 2048, test_key, {});
    CHECK(new_key.Get() != 0);

    key = ncrypt::rsa::LoadKey(provider.Get(), test_key);
    CHECK(key.Get() != 0);

    ncrypt::rsa::DeleteKey(new_key.Get());

    CHECK_THROWS_WITH(
      ncrypt::rsa::DeleteKey(key.Get()),
      "deleting key failed: NTE_BAD_KEYSET"
    );
  }
}

TEST_CASE("ncrypt::rsa PublicKeyEncrypt/PrivateKeyDecrypt", "[vereign/ncrypt/rsa][vereign/ncrypt]") {
  const auto test_key = std::string{"vereign_test_key"};
  auto provider = ncrypt::rsa::OpenStorageProvider();
  auto key = ncrypt::rsa::LoadKey(provider.Get(), test_key);
  if (key) {
    ncrypt::rsa::DeleteKey(key.Get());
  }

  key = ncrypt::rsa::CreateKey(provider.Get(), 2048, test_key, {});
  REQUIRE(key.Get() != 0);
  auto delete_key = core::ScopeGuard([&key] { ncrypt::rsa::DeleteKey(key.Get()); });

  SECTION("small input") {
    const std::string input{"foo bar"};
    bytes::Buffer encrypted;

    ncrypt::rsa::PublicKeyEncrypt(key.Get(), bytes::View(input), encrypted);

    bytes::Buffer decrypted;
    ncrypt::rsa::PrivateKeyDecrypt(key.Get(), encrypted.View(), decrypted);

    CHECK(decrypted.View() == bytes::View(input));
  }

  SECTION("zero input") {
    const std::string input;
    bytes::Buffer encrypted;

    CHECK_THROWS_WITH(
      ncrypt::rsa::PublicKeyEncrypt(key.Get(), bytes::View(input), encrypted),
      "encryption failed: NTE_NULL_REFERENCE_POINTER"
    );

    bytes::Buffer decrypted;
    CHECK_THROWS_WITH(
      ncrypt::rsa::PrivateKeyDecrypt(key.Get(), encrypted.View(), decrypted),
      "decryption failed: NTE_NULL_REFERENCE_POINTER"
    );
  }

  SECTION("max size input") {
    bytes::Buffer input{214};
    crypto::Rand(input);
    bytes::Buffer encrypted;

    ncrypt::rsa::PublicKeyEncrypt(key.Get(), input.View(), encrypted);

    bytes::Buffer decrypted;
    ncrypt::rsa::PrivateKeyDecrypt(key.Get(), encrypted.View(), decrypted);

    CHECK(decrypted.View() == input.View());
  }

  SECTION("invalid big input") {
    bytes::Buffer input{215};
    crypto::Rand(input);
    bytes::Buffer encrypted;

    CHECK_THROWS_WITH(
      ncrypt::rsa::PublicKeyEncrypt(key.Get(), input.View(), encrypted),
      "encryption failed: NTE_INVALID_PARAMETER"
    );

    CHECK(encrypted.Size() == 0);
  }
}