Botan::Certificate_Store_In_SQL Class Reference

#include <certstor_sql.h>

Inheritance diagram for Botan::Certificate_Store_In_SQL:

Public Member Functions
void	affirm_cert (const X509_Certificate &cert)
	Reverses the revocation for "cert".
std::vector< X509_DN >	all_subjects () const override
bool	certificate_known (const X509_Certificate &cert) const
	Certificate_Store_In_SQL (std::shared_ptr< SQL_Database > db, std::string_view passwd, RandomNumberGenerator &rng, std::string_view table_prefix="")
bool	contains (const X509_Certificate &cert) const override
std::vector< X509_Certificate >	find_all_certs (const X509_DN &subject_dn, const std::vector< uint8_t > &key_id) const override
std::optional< X509_Certificate >	find_cert (const X509_DN &subject_dn, const std::vector< uint8_t > &key_id) const override
std::optional< X509_Certificate >	find_cert_by_issuer_dn_and_serial_number (const X509_DN &issuer_dn, std::span< const uint8_t > serial_number) const override
std::optional< X509_Certificate >	find_cert_by_pubkey_sha1 (const std::vector< uint8_t > &key_hash) const override
std::optional< X509_Certificate >	find_cert_by_raw_subject_dn_sha256 (const std::vector< uint8_t > &subject_hash) const override
std::vector< X509_Certificate >	find_certs_for_key (const Private_Key &key) const
	Returns all certificates for private key "key".
std::optional< X509_CRL >	find_crl_for (const X509_Certificate &issuer) const override
std::shared_ptr< const Private_Key >	find_key (const X509_Certificate &cert) const
	Returns the private key for "cert" or an empty shared_ptr if none was found.
std::vector< X509_CRL >	generate_crls () const
bool	insert_cert (const X509_Certificate &cert)
bool	insert_key (const X509_Certificate &cert, const Private_Key &key)
bool	remove_cert (const X509_Certificate &cert)
void	remove_key (const Private_Key &key)
	Removes "key" from the store.
void	revoke_cert (const X509_Certificate &cert, CRL_Code reason)
	Marks "cert" as revoked with no time specified.
void	revoke_cert (const X509_Certificate &cert, CRL_Code reason, const X509_Time &time)
	Marks "cert" as revoked starting from "time".

Detailed Description

Certificate and private key store backed by an SQL database.

Definition at line 24 of file certstor_sql.h.

Constructor & Destructor Documentation

Certificate_Store_In_SQL()

Botan::Certificate_Store_In_SQL::Certificate_Store_In_SQL ( std::shared_ptr< SQL_Database > db, std::string_view passwd, RandomNumberGenerator & rng, std::string_view table_prefix = "" )

explicit

Create/open a certificate store.

Parameters

db	underlying database storage
passwd	password to encrypt private keys in the database
Random Number Generators	used for encrypting keys
table_prefix	optional prefix for db table names

Definition at line 23 of file certstor_sql.cpp.

                                                                                :
      m_rng(rng),
      m_database(std::move(db)),
      m_db_cert_table(fmt("{}certificates", table_prefix)),
      m_db_keys_table(fmt("{}keys", table_prefix)),
      m_db_crls_table(fmt("{}revoked", table_prefix)),
      m_password(passwd) {
   using DB = SQL_Database;
   const auto blob = DB::Column_Type::Blob;
   const auto integer = DB::Column_Type::Integer;
 
   BOTAN_ARG_CHECK(m_database->is_valid_table_name(m_db_cert_table), "Invalid table name");
   BOTAN_ARG_CHECK(m_database->is_valid_table_name(m_db_keys_table), "Invalid table name");
   BOTAN_ARG_CHECK(m_database->is_valid_table_name(m_db_crls_table), "Invalid table name");
 
   m_database->create_table(DB::Table_Schema(m_db_cert_table,
                                             {
                                                DB::Column("fingerprint", blob).primary_key(),
                                                DB::Column("subject_dn", blob),
                                                DB::Column("key_id", blob),
                                                DB::Column("priv_fingerprint", blob),
                                                DB::Column("certificate", blob).not_null(),
                                             })
                               .if_not_exists());
 
   m_database->create_table(DB::Table_Schema(m_db_keys_table,
                                             {
                                                DB::Column("fingerprint", blob).primary_key(),
                                                DB::Column("key", blob).not_null(),
                                             })
                               .if_not_exists());
 
   m_database->create_table(DB::Table_Schema(m_db_crls_table,
                                             {
                                                DB::Column("fingerprint", blob).primary_key(),
                                                DB::Column("reason", integer).not_null(),
                                                DB::Column("time", integer),
                                             })
                               .if_not_exists());
}

References BOTAN_ARG_CHECK, and Botan::fmt().

Referenced by Botan::Certificate_Store_In_SQLite::Certificate_Store_In_SQLite().

Member Function Documentation

affirm_cert()

void Botan::Certificate_Store_In_SQL::affirm_cert

(

const X509_Certificate &

cert

)

Reverses the revocation for "cert".

Definition at line 295 of file certstor_sql.cpp.

                                                                       {
   auto stmt = m_database->new_statement(fmt("DELETE FROM {} WHERE fingerprint = ?1", m_db_crls_table));
 
   stmt->bind(1, cert.fingerprint("SHA-256"));
   stmt->spin();
}

References Botan::X509_Certificate::fingerprint(), and Botan::fmt().

all_subjects()

std::vector< X509_DN > Botan::Certificate_Store_In_SQL::all_subjects ( ) const

overridevirtual

Returns all subject DNs known to the store instance.

Implements Botan::Certificate_Store.

Definition at line 142 of file certstor_sql.cpp.

                                                                {
   std::vector<X509_DN> ret;
   auto stmt = m_database->select("subject_dn", m_db_cert_table);
 
   while(stmt->step()) {
      BER_Decoder dec(stmt->get_blob(0), BER_Decoder::Limits::DER());
      X509_DN dn;
 
      dn.decode_from(dec);
 
      ret.push_back(dn);
   }
 
   return ret;
}

References Botan::X509_DN::decode_from(), and Botan::BER_Decoder::Limits::DER().

certificate_known()

bool Botan::Certificate_Store::certificate_known ( const X509_Certificate & cert ) const

inherited

Old version of contains

Definition at line 24 of file certstor.cpp.

                                                                            {
   return contains(cert);
}

References contains().

Referenced by find_cert_by_issuer_dn_and_serial_number().

contains()

bool Botan::Certificate_Store_In_SQL::contains ( const X509_Certificate & cert ) const

overridevirtual

Returns

whether this certificate is contained within the store

Parameters

cert	certificate to be searched

Default implementation uses find_all_certs

Reimplemented from Botan::Certificate_Store.

Definition at line 175 of file certstor_sql.cpp.

                                                                          {
   auto stmt = m_database->select("1", m_db_cert_table, "fingerprint = ?1");
   stmt->bind(1, cert.fingerprint("SHA-256"));
   return stmt->step();
}

References Botan::X509_Certificate::fingerprint().

find_all_certs()

std::vector< X509_Certificate > Botan::Certificate_Store_In_SQL::find_all_certs ( const X509_DN & subject_dn, const std::vector< uint8_t > & key_id ) const

overridevirtual

Find all certificates with a given Subject DN. Subject DN and even the key identifier might not be unique.

Implements Botan::Certificate_Store.

Definition at line 91 of file certstor_sql.cpp.

                                                                                                               {
   std::vector<X509_Certificate> certs;
 
   std::shared_ptr<SQL_Database::Statement> stmt;
 
   const std::vector<uint8_t> dn_encoding = subject_dn.BER_encode();
 
   if(key_id.empty()) {
      stmt = m_database->select("certificate", m_db_cert_table, "subject_dn = ?1");
      stmt->bind(1, dn_encoding);
   } else {
      stmt = m_database->select("certificate", m_db_cert_table, "subject_dn = ?1 AND (key_id IS NULL OR key_id = ?2)");
      stmt->bind(1, dn_encoding);
      stmt->bind(2, key_id);
   }
 
   while(stmt->step()) {
      certs.push_back(X509_Certificate(stmt->get_blob(0)));
   }
 
   return certs;
}

References Botan::ASN1_Object::BER_encode().

find_cert()

std::optional< X509_Certificate > Botan::Certificate_Store_In_SQL::find_cert ( const X509_DN & subject_dn, const std::vector< uint8_t > & key_id ) const

overridevirtual

Returns the first certificate with matching subject DN and optional key ID.

Reimplemented from Botan::Certificate_Store.

Definition at line 68 of file certstor_sql.cpp.

                                                                                                            {
   std::shared_ptr<SQL_Database::Statement> stmt;
 
   const std::vector<uint8_t> dn_encoding = subject_dn.BER_encode();
 
   if(key_id.empty()) {
      stmt = m_database->select("certificate", m_db_cert_table, "subject_dn = ?1", 1);
      stmt->bind(1, dn_encoding);
   } else {
      stmt =
         m_database->select("certificate", m_db_cert_table, "subject_dn = ?1 AND (key_id IS NULL OR key_id = ?2)", 1);
      stmt->bind(1, dn_encoding);
      stmt->bind(2, key_id);
   }
 
   while(stmt->step()) {
      return X509_Certificate(stmt->get_blob(0));
   }
 
   return std::optional<X509_Certificate>();
}

References Botan::ASN1_Object::BER_encode().

Referenced by remove_cert().

find_cert_by_issuer_dn_and_serial_number()

std::optional< X509_Certificate > Botan::Certificate_Store_In_SQL::find_cert_by_issuer_dn_and_serial_number ( const X509_DN & issuer_dn, std::span< const uint8_t > serial_number ) const

overridevirtual

Find a certificate by searching for one with a matching issuer DN and serial number. Used for CMS or PKCS#7.

Parameters

issuer_dn	the distinguished name of the issuer
serial_number	the certificate's serial number

Returns

a matching certificate or nullopt otherwise

TODO(Botan4) change this to use X509_Serial_Number

Implements Botan::Certificate_Store.

Definition at line 125 of file certstor_sql.cpp.

                                                     {
   throw Not_Implemented("Certificate_Store_In_SQL::find_cert_by_issuer_dn_and_serial_number");
}

find_cert_by_pubkey_sha1()

std::optional< X509_Certificate > Botan::Certificate_Store_In_SQL::find_cert_by_pubkey_sha1 ( const std::vector< uint8_t > & key_hash ) const

overridevirtual

Find a certificate by searching for one with a matching SHA-1 hash of public key. Used for OCSP.

Parameters

key_hash

SHA-1 hash of the subject's public key

Returns

a matching certificate or nullopt otherwise

Implements Botan::Certificate_Store.

Definition at line 115 of file certstor_sql.cpp.

                                      {
   throw Not_Implemented("Certificate_Store_In_SQL::find_cert_by_pubkey_sha1");
}

find_cert_by_raw_subject_dn_sha256()

std::optional< X509_Certificate > Botan::Certificate_Store_In_SQL::find_cert_by_raw_subject_dn_sha256 ( const std::vector< uint8_t > & subject_hash ) const

overridevirtual

Find a certificate by searching for one with a matching SHA-256 hash of raw subject name. Used for OCSP.

Parameters

subject_hash

SHA-256 hash of the subject's raw name

Returns

a matching certificate or nullopt otherwise

Implements Botan::Certificate_Store.

Definition at line 120 of file certstor_sql.cpp.

                                      {
   throw Not_Implemented("Certificate_Store_In_SQL::find_cert_by_raw_subject_dn_sha256");
}

find_certs_for_key()

std::vector< X509_Certificate > Botan::Certificate_Store_In_SQL::find_certs_for_key

(

const Private_Key &

key

)

const

Returns all certificates for private key "key".

Definition at line 215 of file certstor_sql.cpp.

                                                                                                     {
   auto fprint = key.fingerprint_private("SHA-256");
   auto stmt = m_database->select("certificate", m_db_cert_table, "priv_fingerprint = ?1");
 
   stmt->bind(1, fprint);
 
   std::vector<X509_Certificate> certs;
   while(stmt->step()) {
      certs.push_back(X509_Certificate(stmt->get_blob(0)));
   }
 
   return certs;
}

References Botan::Private_Key::fingerprint_private().

find_crl_for()

std::optional< X509_CRL > Botan::Certificate_Store_In_SQL::find_crl_for ( const X509_Certificate & issuer ) const

overridevirtual

Generates a CRL for all certificates issued by the given issuer.

Reimplemented from Botan::Certificate_Store.

Definition at line 130 of file certstor_sql.cpp.

                                                                                                  {
   const auto all_crls = generate_crls();
 
   for(const auto& crl : all_crls) {
      if(!crl.get_revoked().empty() && crl.issuer_dn() == subject.issuer_dn()) {
         return crl;
      }
   }
 
   return std::optional<X509_CRL>();
}

References generate_crls(), and Botan::X509_Certificate::issuer_dn().

find_key()

std::shared_ptr< const Private_Key > Botan::Certificate_Store_In_SQL::find_key

(

const X509_Certificate &

cert

)

const

Returns the private key for "cert" or an empty shared_ptr if none was found.

Definition at line 195 of file certstor_sql.cpp.

                                                                                                      {
   auto stmt =
      m_database->new_statement(fmt("SELECT key FROM {} JOIN {} ON {}.fingerprint = {}.priv_fingerprint "
                                    "WHERE {}.fingerprint = ?1",
                                    m_db_keys_table,
                                    m_db_cert_table,
                                    m_db_keys_table,
                                    m_db_cert_table,
                                    m_db_cert_table));
   stmt->bind(1, cert.fingerprint("SHA-256"));
 
   std::shared_ptr<const Private_Key> key;
   while(stmt->step()) {
      DataSource_Memory src(stmt->get_blob(0));
      key = PKCS8::load_key(src, m_password);
   }
 
   return key;
}

References Botan::X509_Certificate::fingerprint(), Botan::fmt(), and Botan::PKCS8::load_key().

Referenced by insert_key().

generate_crls()

std::vector< X509_CRL > Botan::Certificate_Store_In_SQL::generate_crls

(

)

const

Generates Certificate Revocation Lists for all certificates marked as revoked. A CRL is returned for each unique issuer DN.

Definition at line 302 of file certstor_sql.cpp.

                                                                  {
   auto stmt =
      m_database->new_statement(fmt("SELECT certificate,reason,time FROM {} JOIN {} ON {}.fingerprint = "
                                    "{}.fingerprint",
                                    m_db_crls_table,
                                    m_db_cert_table,
                                    m_db_cert_table,
                                    m_db_crls_table));
 
   std::map<X509_DN, std::vector<CRL_Entry>> crls;
   while(stmt->step()) {
      auto cert = X509_Certificate(stmt->get_blob(0));
      auto code = static_cast<CRL_Code>(stmt->get_size_t(1));
      auto ent = CRL_Entry(cert, code);
 
      auto i = crls.find(cert.issuer_dn());
      if(i == crls.end()) {
         crls.insert(std::make_pair(cert.issuer_dn(), std::vector<CRL_Entry>({ent})));
      } else {
         i->second.push_back(ent);
      }
   }
 
   const X509_Time t(std::chrono::system_clock::now());
 
   std::vector<X509_CRL> ret;
   ret.reserve(crls.size());
 
   for(const auto& p : crls) {
      ret.push_back(X509_CRL(p.first, t, t, p.second));
   }
 
   return ret;
}

References Botan::CRL_Entry, and Botan::fmt().

Referenced by find_crl_for().

insert_cert()

bool Botan::Certificate_Store_In_SQL::insert_cert

(

const X509_Certificate &

cert

)

Inserts "cert" into the store, returns false if the certificate is already known and true if insertion was successful.

Definition at line 158 of file certstor_sql.cpp.

                                                                       {
   const std::vector<uint8_t> dn_encoding = cert.subject_dn().BER_encode();
   const std::vector<uint8_t> cert_encoding = cert.BER_encode();
 
   auto stmt =
      m_database->upsert(m_db_cert_table, {"fingerprint", "subject_dn", "key_id", "priv_fingerprint", "certificate"});
 
   stmt->bind(1, cert.fingerprint("SHA-256"));
   stmt->bind(2, dn_encoding);
   stmt->bind(3, cert.subject_key_id());
   stmt->bind(4, std::vector<uint8_t>());
   stmt->bind(5, cert_encoding);
   stmt->spin();
 
   return true;
}

References Botan::ASN1_Object::BER_encode(), Botan::X509_Certificate::fingerprint(), Botan::X509_Certificate::subject_dn(), and Botan::X509_Certificate::subject_key_id().

Referenced by insert_key(), revoke_cert(), and revoke_cert().

insert_key()

bool Botan::Certificate_Store_In_SQL::insert_key	(	const X509_Certificate &	cert,
		const Private_Key &	key )

Inserts "key" for "cert" into the store, returns false if the key is already known and true if insertion was successful.

Definition at line 229 of file certstor_sql.cpp.

                                                                                              {
   insert_cert(cert);
 
   if(find_key(cert)) {
      return false;
   }
 
   auto pkcs8 = PKCS8::BER_encode(key, m_rng, m_password);
   auto fprint = key.fingerprint_private("SHA-256");
 
   auto stmt1 = m_database->upsert(m_db_keys_table, {"fingerprint", "key"});
 
   stmt1->bind(1, fprint);
   stmt1->bind(2, pkcs8.data(), pkcs8.size());
   stmt1->spin();
 
   auto stmt2 =
      m_database->new_statement(fmt("UPDATE {} SET priv_fingerprint = ?1 WHERE fingerprint = ?2", m_db_cert_table));
 
   stmt2->bind(1, fprint);
   stmt2->bind(2, cert.fingerprint("SHA-256"));
   stmt2->spin();
 
   return true;
}

References Botan::PKCS8::BER_encode(), find_key(), Botan::X509_Certificate::fingerprint(), Botan::Private_Key::fingerprint_private(), Botan::fmt(), and insert_cert().

remove_cert()

bool Botan::Certificate_Store_In_SQL::remove_cert

(

const X509_Certificate &

cert

)

Removes "cert" from the store. Returns false if the certificate could not be found and true if removal was successful.

Definition at line 181 of file certstor_sql.cpp.

                                                                       {
   if(!find_cert(cert.subject_dn(), cert.subject_key_id())) {
      return false;
   }
 
   auto stmt = m_database->new_statement(fmt("DELETE FROM {} WHERE fingerprint = ?1", m_db_cert_table));
 
   stmt->bind(1, cert.fingerprint("SHA-256"));
   stmt->spin();
 
   return true;
}

References find_cert(), Botan::X509_Certificate::fingerprint(), Botan::fmt(), Botan::X509_Certificate::subject_dn(), and Botan::X509_Certificate::subject_key_id().

remove_key()

void Botan::Certificate_Store_In_SQL::remove_key

(

const Private_Key &

key

)

Removes "key" from the store.

Definition at line 255 of file certstor_sql.cpp.

                                                                {
   auto fprint = key.fingerprint_private("SHA-256");
   auto stmt = m_database->new_statement(fmt("DELETE FROM {} WHERE fingerprint = ?1", m_db_keys_table));
 
   stmt->bind(1, fprint);
   stmt->spin();
}

References Botan::Private_Key::fingerprint_private(), and Botan::fmt().

revoke_cert() [1/2]

void Botan::Certificate_Store_In_SQL::revoke_cert	(	const X509_Certificate &	cert,
		CRL_Code	reason )

Marks "cert" as revoked with no time specified.

Definition at line 283 of file certstor_sql.cpp.

                                                                                      {
   insert_cert(cert);
 
   auto stmt1 = m_database->upsert(m_db_crls_table, {"fingerprint", "reason", "time"});
 
   stmt1->bind(1, cert.fingerprint("SHA-256"));
   stmt1->bind(2, static_cast<uint32_t>(code));
   stmt1->bind_null(3);
 
   stmt1->spin();
}

References Botan::X509_Certificate::fingerprint(), and insert_cert().

revoke_cert() [2/2]

void Botan::Certificate_Store_In_SQL::revoke_cert	(	const X509_Certificate &	cert,
		CRL_Code	reason,
		const X509_Time &	time )

Marks "cert" as revoked starting from "time".

Definition at line 264 of file certstor_sql.cpp.

                                                                                                             {
   // TODO(Botan4) require that time be valid
   insert_cert(cert);
 
   auto stmt1 = m_database->upsert(m_db_crls_table, {"fingerprint", "reason", "time"});
 
   stmt1->bind(1, cert.fingerprint("SHA-256"));
   stmt1->bind(2, static_cast<uint32_t>(code));
 
   if(time.time_is_set()) {
      stmt1->bind(3, time.to_std_timepoint());
   } else {
      stmt1->bind_null(3);
   }
 
   stmt1->spin();
}

References Botan::X509_Certificate::fingerprint(), insert_cert(), Botan::ASN1_Time::time_is_set(), and Botan::ASN1_Time::to_std_timepoint().

---

The documentation for this class was generated from the following files:

• src/lib/x509/certstor_sql/certstor_sql.h
• src/lib/x509/certstor_sql/certstor_sql.cpp