14 #include "../data.hpp"
21 #include <boost/filesystem.hpp>
28 CREATE TABLE IF NOT EXISTS \n \
30 identity_name BLOB NOT NULL, \n \
31 default_identity INTEGER DEFAULT 0, \n \
33 PRIMARY KEY (identity_name) \n \
36 CREATE INDEX identity_index ON Identity(identity_name); \n \
40 CREATE TABLE IF NOT EXISTS \n \
42 identity_name BLOB NOT NULL, \n \
43 key_identifier BLOB NOT NULL, \n \
44 key_type INTEGER, \n \
46 default_key INTEGER DEFAULT 0, \n \
47 active INTEGER DEFAULT 0, \n \
49 PRIMARY KEY (identity_name, key_identifier) \n \
52 CREATE INDEX key_index ON Key(identity_name); \n \
56 CREATE TABLE IF NOT EXISTS \n \
58 cert_name BLOB NOT NULL, \n \
59 cert_issuer BLOB NOT NULL, \n \
60 identity_name BLOB NOT NULL, \n \
61 key_identifier BLOB NOT NULL, \n \
62 not_before TIMESTAMP, \n \
63 not_after TIMESTAMP, \n \
64 certificate_data BLOB NOT NULL, \n \
65 valid_flag INTEGER DEFAULT 1, \n \
66 default_cert INTEGER DEFAULT 0, \n \
68 PRIMARY KEY (cert_name) \n \
71 CREATE INDEX cert_index ON Certificate(cert_name); \n \
72 CREATE INDEX subject ON Certificate(identity_name); \n \
82 void(*destructor)(
void*))
84 return sqlite3_bind_text(statement, index, value.c_str(), value.size(), destructor);
87 SecPublicInfoSqlite3::SecPublicInfoSqlite3()
89 boost::filesystem::path identityDir = boost::filesystem::path(getenv(
"HOME")) /
".ndn";
90 boost::filesystem::create_directories (identityDir);
93 int res = sqlite3_open_v2((identityDir /
"ndnsec-public-info.db").c_str(), &m_database,
94 SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,
95 #ifdef NDN_CPP_DISABLE_SQLITE3_FS_LOCKING
101 if (res != SQLITE_OK)
102 throw Error(
"identity DB cannot be opened/created");
105 sqlite3_stmt* statement;
106 sqlite3_prepare_v2(m_database,
107 "SELECT name FROM sqlite_master WHERE type='table' And name='Identity'",
109 res = sqlite3_step(statement);
111 bool idTableExists =
false;
112 if (res == SQLITE_ROW)
113 idTableExists =
true;
115 sqlite3_finalize(statement);
117 if (!idTableExists) {
118 char* errorMessage = 0;
119 res = sqlite3_exec(m_database,
INIT_ID_TABLE.c_str(), NULL, NULL, &errorMessage);
121 if (res != SQLITE_OK && errorMessage != 0) {
122 sqlite3_free(errorMessage);
127 sqlite3_prepare_v2(m_database,
128 "SELECT name FROM sqlite_master WHERE type='table' And name='Key'",
130 res = sqlite3_step(statement);
132 bool keyTableExists =
false;
133 if (res == SQLITE_ROW)
134 keyTableExists =
true;
136 sqlite3_finalize(statement);
138 if (!keyTableExists) {
139 char* errorMessage = 0;
140 res = sqlite3_exec(m_database,
INIT_KEY_TABLE.c_str(), NULL, NULL, &errorMessage);
142 if (res != SQLITE_OK && errorMessage != 0) {
143 sqlite3_free(errorMessage);
148 sqlite3_prepare_v2(m_database,
149 "SELECT name FROM sqlite_master WHERE type='table' And name='Certificate'",
151 res = sqlite3_step(statement);
153 bool idCertificateTableExists =
false;
154 if (res == SQLITE_ROW)
155 idCertificateTableExists =
true;
157 sqlite3_finalize(statement);
159 if (!idCertificateTableExists) {
160 char* errorMessage = 0;
161 res = sqlite3_exec(m_database,
INIT_CERT_TABLE.c_str(), NULL, NULL, &errorMessage);
163 if (res != SQLITE_OK && errorMessage != 0) {
164 sqlite3_free(errorMessage);
169 SecPublicInfoSqlite3::~SecPublicInfoSqlite3()
174 SecPublicInfoSqlite3::doesIdentityExist(
const Name& identityName)
178 sqlite3_stmt* statement;
179 sqlite3_prepare_v2(m_database,
180 "SELECT count(*) FROM Identity WHERE identity_name=?",
184 int res = sqlite3_step(statement);
186 if (res == SQLITE_ROW) {
187 int countAll = sqlite3_column_int(statement, 0);
192 sqlite3_finalize(statement);
198 SecPublicInfoSqlite3::addIdentity(
const Name& identityName)
200 if (doesIdentityExist(identityName))
203 sqlite3_stmt* statement;
205 sqlite3_prepare_v2(m_database,
206 "INSERT OR REPLACE INTO Identity (identity_name) values (?)",
211 sqlite3_step(statement);
213 sqlite3_finalize(statement);
217 SecPublicInfoSqlite3::revokeIdentity()
224 SecPublicInfoSqlite3::doesPublicKeyExist(
const Name& keyName)
227 throw Error(
"Incorrect key name " + keyName.
toUri());
232 sqlite3_stmt* statement;
233 sqlite3_prepare_v2(m_database,
234 "SELECT count(*) FROM Key WHERE identity_name=? AND key_identifier=?",
240 int res = sqlite3_step(statement);
242 bool keyIdExist =
false;
243 if (res == SQLITE_ROW) {
244 int countAll = sqlite3_column_int(statement, 0);
249 sqlite3_finalize(statement);
255 SecPublicInfoSqlite3::addPublicKey(
const Name& keyName,
262 if (doesPublicKeyExist(keyName))
268 addIdentity(identityName);
270 sqlite3_stmt* statement;
271 sqlite3_prepare_v2(m_database,
272 "INSERT OR REPLACE INTO Key \
273 (identity_name, key_identifier, key_type, public_key) \
274 values (?, ?, ?, ?)",
279 sqlite3_bind_int(statement, 3, (
int)keyType);
280 sqlite3_bind_blob(statement, 4,
282 publicKeyDer.
get().size(),
285 sqlite3_step(statement);
287 sqlite3_finalize(statement);
290 shared_ptr<PublicKey>
291 SecPublicInfoSqlite3::getPublicKey(
const Name& keyName)
295 throw Error(
"SecPublicInfoSqlite3::getPublicKey Empty keyName");
301 sqlite3_stmt* statement;
302 sqlite3_prepare_v2(m_database,
303 "SELECT public_key FROM Key WHERE identity_name=? AND key_identifier=?",
309 int res = sqlite3_step(statement);
311 shared_ptr<PublicKey> result;
312 if (res == SQLITE_ROW)
315 make_shared<PublicKey>(
static_cast<const uint8_t*
>(sqlite3_column_blob(statement, 0)),
316 sqlite3_column_bytes(statement, 0));
317 sqlite3_finalize(statement);
322 sqlite3_finalize(statement);
323 throw Error(
"SecPublicInfoSqlite3::getPublicKey public key does not exist");
328 SecPublicInfoSqlite3::doesCertificateExist(
const Name& certificateName)
330 sqlite3_stmt* statement;
331 sqlite3_prepare_v2(m_database,
332 "SELECT count(*) FROM Certificate WHERE cert_name=?",
337 int res = sqlite3_step(statement);
339 bool certExist =
false;
340 if (res == SQLITE_ROW) {
341 int countAll = sqlite3_column_int(statement, 0);
346 sqlite3_finalize(statement);
406 const Name& certificateName = certificate.
getName();
409 IdentityCertificate::certificateNameToPublicKeyName(certificate.
getName());
414 if (doesCertificateExist(certificateName))
421 sqlite3_stmt* statement;
422 sqlite3_prepare_v2(m_database,
423 "INSERT OR REPLACE INTO Certificate \
424 (cert_name, cert_issuer, identity_name, key_identifier, \
425 not_before, not_after, certificate_data) \
426 values (?, ?, ?, ?, datetime(?, 'unixepoch'), datetime(?, 'unixepoch'), ?)",
440 catch (std::runtime_error& e)
448 sqlite3_bind_int64(statement, 5,
449 static_cast<sqlite3_int64>(
451 sqlite3_bind_int64(statement, 6,
452 static_cast<sqlite3_int64>(
455 sqlite3_bind_blob(statement, 7,
460 sqlite3_step(statement);
462 sqlite3_finalize(statement);
465 shared_ptr<IdentityCertificate>
466 SecPublicInfoSqlite3::getCertificate(
const Name& certificateName)
468 sqlite3_stmt* statement;
470 sqlite3_prepare_v2(m_database,
471 "SELECT certificate_data FROM Certificate WHERE cert_name=?",
476 int res = sqlite3_step(statement);
478 if (res == SQLITE_ROW)
480 shared_ptr<IdentityCertificate> certificate = make_shared<IdentityCertificate>();
481 certificate->wireDecode(
Block(static_cast<const uint8_t*>(sqlite3_column_blob(statement, 0)),
482 sqlite3_column_bytes(statement, 0)));
483 sqlite3_finalize(statement);
488 sqlite3_finalize(statement);
489 throw Error(
"SecPublicInfoSqlite3::getCertificate certificate does not exist");
495 SecPublicInfoSqlite3::getDefaultIdentity()
497 sqlite3_stmt* statement;
498 sqlite3_prepare_v2(m_database,
499 "SELECT identity_name FROM Identity WHERE default_identity=1",
502 int res = sqlite3_step(statement);
504 if (res == SQLITE_ROW)
506 Name identity(
string(reinterpret_cast<const char *>(sqlite3_column_text(statement, 0)),
507 sqlite3_column_bytes(statement, 0)));
508 sqlite3_finalize(statement);
513 sqlite3_finalize(statement);
514 throw Error(
"SecPublicInfoSqlite3::getDefaultIdentity no default identity");
519 SecPublicInfoSqlite3::setDefaultIdentityInternal(
const Name& identityName)
521 addIdentity(identityName);
523 sqlite3_stmt* statement;
526 sqlite3_prepare_v2(m_database,
527 "UPDATE Identity SET default_identity=0 WHERE default_identity=1",
530 while (sqlite3_step(statement) == SQLITE_ROW)
534 sqlite3_finalize(statement);
537 sqlite3_prepare_v2(m_database,
538 "UPDATE Identity SET default_identity=1 WHERE identity_name=?",
543 sqlite3_step(statement);
545 sqlite3_finalize(statement);
549 SecPublicInfoSqlite3::getDefaultKeyNameForIdentity(
const Name& identityName)
551 sqlite3_stmt* statement;
552 sqlite3_prepare_v2(m_database,
553 "SELECT key_identifier FROM Key WHERE identity_name=? AND default_key=1",
558 int res = sqlite3_step(statement);
560 if (res == SQLITE_ROW)
562 Name keyName = identityName;
563 keyName.
append(
string(reinterpret_cast<const char *>(sqlite3_column_text(statement, 0)),
564 sqlite3_column_bytes(statement, 0)));
565 sqlite3_finalize(statement);
570 sqlite3_finalize(statement);
571 throw Error(
"SecPublicInfoSqlite3::getDefaultKeyNameForIdentity key not found");
576 SecPublicInfoSqlite3::setDefaultKeyNameForIdentityInternal(
const Name& keyName)
578 if (!doesPublicKeyExist(keyName))
579 throw Error(
"Key does not exist:" + keyName.
toUri());
584 sqlite3_stmt* statement;
587 sqlite3_prepare_v2(m_database,
588 "UPDATE Key SET default_key=0 WHERE default_key=1 and identity_name=?",
593 while (sqlite3_step(statement) == SQLITE_ROW)
597 sqlite3_finalize(statement);
600 sqlite3_prepare_v2(m_database,
601 "UPDATE Key SET default_key=1 WHERE identity_name=? AND key_identifier=?",
607 sqlite3_step(statement);
609 sqlite3_finalize(statement);
613 SecPublicInfoSqlite3::getDefaultCertificateNameForKey(
const Name& keyName)
616 throw Error(
"SecPublicInfoSqlite3::getDefaultCertificateNameForKey wrong key");
621 sqlite3_stmt* statement;
622 sqlite3_prepare_v2(m_database,
623 "SELECT cert_name FROM Certificate \
624 WHERE identity_name=? AND key_identifier=? AND default_cert=1",
630 int res = sqlite3_step(statement);
632 if (res == SQLITE_ROW)
634 Name certName(
string(reinterpret_cast<const char *>(sqlite3_column_text(statement, 0)),
635 sqlite3_column_bytes(statement, 0)));
636 sqlite3_finalize(statement);
641 sqlite3_finalize(statement);
642 throw Error(
"certificate not found");
647 SecPublicInfoSqlite3::setDefaultCertificateNameForKeyInternal(
const Name& certificateName)
649 if (!doesCertificateExist(certificateName))
650 throw Error(
"certificate does not exist:" + certificateName.
toUri());
652 Name keyName = IdentityCertificate::certificateNameToPublicKeyName(certificateName);
653 string keyId = keyName.get(-1).toEscapedString();
656 sqlite3_stmt* statement;
659 sqlite3_prepare_v2(m_database,
660 "UPDATE Certificate SET default_cert=0 \
661 WHERE default_cert=1 AND identity_name=? AND key_identifier=?",
667 while (sqlite3_step(statement) == SQLITE_ROW)
671 sqlite3_finalize(statement);
674 sqlite3_prepare_v2(m_database,
675 "UPDATE Certificate SET default_cert=1 \
676 WHERE identity_name=? AND key_identifier=? AND cert_name=?",
683 sqlite3_step(statement);
685 sqlite3_finalize(statement);
689 SecPublicInfoSqlite3::getAllIdentities(vector<Name>& nameList,
bool isDefault)
693 sqlite3_prepare_v2(m_database,
694 "SELECT identity_name FROM Identity WHERE default_identity=1",
697 sqlite3_prepare_v2(m_database,
698 "SELECT identity_name FROM Identity WHERE default_identity=0",
701 while (sqlite3_step(stmt) == SQLITE_ROW)
702 nameList.push_back(
Name(
string(reinterpret_cast<const char *>(sqlite3_column_text(stmt, 0)),
703 sqlite3_column_bytes(stmt, 0))));
705 sqlite3_finalize(stmt);
709 SecPublicInfoSqlite3::getAllKeyNames(vector<Name>& nameList,
bool isDefault)
714 sqlite3_prepare_v2(m_database,
715 "SELECT identity_name, key_identifier FROM Key WHERE default_key=1",
718 sqlite3_prepare_v2(m_database,
719 "SELECT identity_name, key_identifier FROM Key WHERE default_key=0",
722 while (sqlite3_step(stmt) == SQLITE_ROW)
724 Name keyName(
string(reinterpret_cast<const char *>(sqlite3_column_text(stmt, 0)),
725 sqlite3_column_bytes(stmt, 0)));
726 keyName.
append(
string(reinterpret_cast<const char *>(sqlite3_column_text(stmt, 1)),
727 sqlite3_column_bytes(stmt, 1)));
728 nameList.push_back(keyName);
730 sqlite3_finalize(stmt);
734 SecPublicInfoSqlite3::getAllKeyNamesOfIdentity(
const Name& identity,
735 vector<Name>& nameList,
741 sqlite3_prepare_v2(m_database,
742 "SELECT key_identifier FROM Key WHERE default_key=1 and identity_name=?",
745 sqlite3_prepare_v2(m_database,
746 "SELECT key_identifier FROM Key WHERE default_key=0 and identity_name=?",
750 identity.
toUri().c_str(),
751 identity.
toUri().size(),
754 while (sqlite3_step(stmt) == SQLITE_ROW)
756 Name keyName(identity);
757 keyName.
append(
string(reinterpret_cast<const char *>(sqlite3_column_text(stmt, 0)),
758 sqlite3_column_bytes(stmt, 0)));
759 nameList.push_back(keyName);
761 sqlite3_finalize(stmt);
765 SecPublicInfoSqlite3::getAllCertificateNames(vector<Name>& nameList,
bool isDefault)
770 sqlite3_prepare_v2(m_database,
771 "SELECT cert_name FROM Certificate WHERE default_cert=1",
774 sqlite3_prepare_v2(m_database,
775 "SELECT cert_name FROM Certificate WHERE default_cert=0",
778 while (sqlite3_step(stmt) == SQLITE_ROW)
779 nameList.push_back(
string(reinterpret_cast<const char *>(sqlite3_column_text(stmt, 0)),
780 sqlite3_column_bytes(stmt, 0)));
782 sqlite3_finalize(stmt);
786 SecPublicInfoSqlite3::getAllCertificateNamesOfKey(
const Name& keyName,
787 vector<Name>& nameList,
795 sqlite3_prepare_v2(m_database,
796 "SELECT cert_name FROM Certificate \
797 WHERE default_cert=1 and identity_name=? and key_identifier=?",
800 sqlite3_prepare_v2(m_database,
801 "SELECT cert_name FROM Certificate \
802 WHERE default_cert=0 and identity_name=? and key_identifier=?",
809 sqlite3_bind_text(stmt, 2, baseKeyName.c_str(), baseKeyName.size(), SQLITE_TRANSIENT);
811 while (sqlite3_step(stmt) == SQLITE_ROW)
812 nameList.push_back(
string(reinterpret_cast<const char *>(sqlite3_column_text(stmt, 0)),
813 sqlite3_column_bytes(stmt, 0)));
815 sqlite3_finalize(stmt);
819 SecPublicInfoSqlite3::deleteCertificateInfo(
const Name& certName)
821 if (certName.
empty())
825 sqlite3_prepare_v2(m_database,
"DELETE FROM Certificate WHERE cert_name=?", -1, &stmt, 0);
828 sqlite3_finalize(stmt);
832 SecPublicInfoSqlite3::deletePublicKeyInfo(
const Name& keyName)
841 sqlite3_prepare_v2(m_database,
842 "DELETE FROM Certificate WHERE identity_name=? and key_identifier=?",
844 sqlite3_bind_text(stmt, 1, identity.c_str(), identity.size (), SQLITE_TRANSIENT);
847 sqlite3_finalize(stmt);
849 sqlite3_prepare_v2(m_database,
850 "DELETE FROM Key WHERE identity_name=? and key_identifier=?",
852 sqlite3_bind_text(stmt, 1, identity.c_str(), identity.size (), SQLITE_TRANSIENT);
855 sqlite3_finalize(stmt);
859 SecPublicInfoSqlite3::deleteIdentityInfo(
const Name& identityName)
861 string identity = identityName.
toUri();
864 sqlite3_prepare_v2(m_database,
"DELETE FROM Certificate WHERE identity_name=?", -1, &stmt, 0);
865 sqlite3_bind_text(stmt, 1, identity.c_str(), identity.size (), SQLITE_TRANSIENT);
867 sqlite3_finalize(stmt);
869 sqlite3_prepare_v2(m_database,
"DELETE FROM Key WHERE identity_name=?", -1, &stmt, 0);
870 sqlite3_bind_text(stmt, 1, identity.c_str(), identity.size (), SQLITE_TRANSIENT);
872 sqlite3_finalize(stmt);
874 sqlite3_prepare_v2(m_database,
"DELETE FROM Identity WHERE identity_name=?", -1, &stmt, 0);
875 sqlite3_bind_text(stmt, 1, identity.c_str(), identity.size (), SQLITE_TRANSIENT);
877 sqlite3_finalize(stmt);
Representing of SHA256-with-RSA signature in a data packet.
time::system_clock::TimePoint & getNotBefore()
time::system_clock::TimePoint & getNotAfter()
void toEscapedString(std::ostream &result) const
Write the value to result, escaping characters according to the NDN URI Scheme.
Name getPrefix(int nComponents) const
Return a new Name with the first nComponents components of this Name.
static const string INIT_KEY_TABLE
Class representing wire element of the NDN packet.
PublicKey & getPublicKeyInfo()
size_t wireEncode(EncodingImpl< T > &block, bool unsignedPortion=false) const
Fast encoding or block size estimation.
const Name & getName() const
std::string toUri() const
Encode this name as a URI.
const Name & getName() const
const KeyLocator & getKeyLocator() const
uint8_t * buf()
Get pointer to the first byte of the buffer (alternative version)
static const string INIT_ID_TABLE
A Name holds an array of Name::Component and represents an NDN name.
const Signature & getSignature() const
const Buffer & get() const
milliseconds toUnixTimestamp(const system_clock::TimePoint &point)
Convert system_clock::TimePoint to UNIX timestamp.
Name & append(const uint8_t *value, size_t valueLength)
Append a new component, copying from value of length valueLength.
bool empty() const
Check if name is emtpy.
static int sqlite3_bind_text(sqlite3_stmt *statement, int index, const string &value, void(*destructor)(void *))
A utility function to call the normal sqlite3_bind_text where the value and length are value...
const Component & get(ssize_t i) const
Get the component at the given index.
static const string INIT_CERT_TABLE