verifier.h

Go to the documentation of this file.

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the Apache 2.0 License.
#pragma once
 
#include "ccf/crypto/ec_public_key.h"
#include "ccf/crypto/jwk.h"
#include "ccf/crypto/pem.h"
#include "ccf/crypto/rsa_public_key.h"
#include "ccf/ds/nonstd.h"
 
#include <chrono>
 
namespace ccf::crypto
{
  class Verifier
  {
  protected:
    std::variant<ccf::crypto::RSAPublicKeyPtr, ccf::crypto::ECPublicKeyPtr>
      public_key;
 
  public:
    Verifier() = default;
    virtual ~Verifier() = default;
 
    virtual std::vector<uint8_t> cert_der() = 0;
    virtual Pem cert_pem() = 0;
 
    [[nodiscard]] virtual bool verify(
      const uint8_t* contents,
      size_t contents_size,
      const uint8_t* sig,
      size_t sig_size,
      MDType md_type = MDType::NONE) const;
 
    [[nodiscard]] virtual bool verify(
      std::span<const uint8_t> contents,
      std::span<const uint8_t> sig,
      MDType md_type = MDType::NONE) const
    {
      return verify(
        contents.data(), contents.size(), sig.data(), sig.size(), md_type);
    }
 
    [[nodiscard]] virtual bool verify(
      const std::vector<uint8_t>& contents,
      const std::vector<uint8_t>& signature,
      MDType md_type = MDType::NONE) const
    {
      return verify(
        contents.data(),
        contents.size(),
        signature.data(),
        signature.size(),
        md_type);
    }
 
    virtual bool verify_hash(
      const uint8_t* hash,
      size_t hash_size,
      const uint8_t* sig,
      size_t sig_size,
      MDType md_type = MDType::NONE);
 
    virtual bool verify_hash(
      const std::vector<uint8_t>& hash,
      const std::vector<uint8_t>& signature,
      MDType md_type = MDType::NONE)
    {
      return verify_hash(
        hash.data(), hash.size(), signature.data(), signature.size(), md_type);
    }
 
    template <size_t SIZE>
    bool verify_hash(
      const std::array<uint8_t, SIZE>& hash,
      const std::vector<uint8_t>& signature,
      MDType md_type = MDType::NONE)
    {
      return verify_hash(
        hash.data(), hash.size(), signature.data(), signature.size(), md_type);
    }
 
    [[nodiscard]] virtual Pem public_key_pem() const;
 
    [[nodiscard]] virtual std::vector<uint8_t> public_key_der() const;
 
    [[nodiscard]] virtual bool verify_certificate(
      const std::vector<const Pem*>& trusted_certs,
      const std::vector<const Pem*>& chain = {},
      bool ignore_time = false) = 0;
 
    [[nodiscard]] virtual bool is_self_signed() const = 0;
 
    [[nodiscard]] virtual std::string serial_number() const = 0;
 
    [[nodiscard]] virtual std::pair<std::string, std::string> validity_period()
      const = 0;
 
    [[nodiscard]] virtual size_t remaining_seconds(
      const ccf::nonstd::SystemClock::time_point& now) const = 0;
 
    [[nodiscard]] virtual double remaining_percentage(
      const ccf::nonstd::SystemClock::time_point& now) const = 0;
 
    [[nodiscard]] virtual std::string subject() const = 0;
  };
 
  using VerifierPtr = std::shared_ptr<Verifier>;
  using VerifierUniquePtr = std::unique_ptr<Verifier>;
 
  VerifierUniquePtr make_unique_verifier(const std::vector<uint8_t>& cert);
 
  VerifierPtr make_verifier(const std::vector<uint8_t>& cert);
 
  VerifierUniquePtr make_unique_verifier(const Pem& pem);
 
  VerifierPtr make_verifier(const Pem& pem);
 
  ccf::crypto::Pem cert_der_to_pem(const std::vector<uint8_t>& der);
  std::vector<uint8_t> cert_pem_to_der(const Pem& pem);
 
  std::vector<uint8_t> public_key_der_from_cert(
    const std::vector<uint8_t>& der);
 
  ccf::crypto::Pem public_key_pem_from_cert(const std::vector<uint8_t>& der);
 
  std::string get_subject_name(const Pem& cert);
}