Jeff Thompson | 7ca11f2 | 2013-10-04 19:01:30 -0700 | [diff] [blame] | 1 | /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil -*- */ |
| 2 | /** |
| 3 | * Copyright (C) 2013 Regents of the University of California. |
| 4 | * @author: Yingdi Yu <yingdi@cs.ucla.edu> |
| 5 | * See COPYING for copyright and distribution information. |
| 6 | */ |
| 7 | |
Jeff Thompson | b752300 | 2013-10-09 10:25:00 -0700 | [diff] [blame] | 8 | // Only compile if ndn-cpp-config.h defines NDN_CPP_HAVE_SQLITE3. |
Jeff Thompson | 6e22904 | 2013-10-10 11:09:49 -0700 | [diff] [blame^] | 9 | #include <ndn-cpp/ndn-cpp-config.h> |
Jeff Thompson | 1975def | 2013-10-09 17:06:43 -0700 | [diff] [blame] | 10 | #ifdef NDN_CPP_HAVE_SQLITE3 |
Jeff Thompson | 7ca11f2 | 2013-10-04 19:01:30 -0700 | [diff] [blame] | 11 | |
Jeff Thompson | 814d205 | 2013-10-09 18:52:19 -0700 | [diff] [blame] | 12 | #if 1 |
| 13 | #include <stdexcept> |
| 14 | #endif |
Jeff Thompson | 7ca11f2 | 2013-10-04 19:01:30 -0700 | [diff] [blame] | 15 | #include <stdlib.h> |
| 16 | #include <sstream> |
| 17 | #include <fstream> |
| 18 | #include "basic-identity-storage.hpp" |
| 19 | #include "../../util/logging.hpp" |
| 20 | #include "../security-exception.hpp" |
| 21 | #include "ndn-cpp/data.hpp" |
| 22 | |
| 23 | #if 0 |
| 24 | #include "ndn.cxx/fields/signature-sha256-with-rsa.h" |
| 25 | #include "ndn.cxx/regex/regex.h" |
| 26 | #include <boost/filesystem.hpp> |
| 27 | #endif |
| 28 | |
| 29 | INIT_LOGGER("BasicIdentityStorage"); |
| 30 | |
| 31 | using namespace std; |
| 32 | using namespace ndn::ptr_lib; |
| 33 | #if 0 |
| 34 | namespace fs = boost::filesystem; |
| 35 | #endif |
| 36 | |
| 37 | namespace ndn |
| 38 | { |
| 39 | |
| 40 | static const string INIT_ID_TABLE = "\ |
| 41 | CREATE TABLE IF NOT EXISTS \n \ |
| 42 | Identity( \n \ |
| 43 | identity_name BLOB NOT NULL, \n \ |
| 44 | default_identity INTEGER DEFAULT 0, \n \ |
| 45 | \ |
| 46 | PRIMARY KEY (identity_name) \n \ |
| 47 | ); \n \ |
| 48 | \ |
| 49 | CREATE INDEX identity_index ON Identity(identity_name); \n \ |
| 50 | "; |
| 51 | |
| 52 | static const string INIT_KEY_TABLE = "\ |
| 53 | CREATE TABLE IF NOT EXISTS \n \ |
| 54 | Key( \n \ |
| 55 | identity_name BLOB NOT NULL, \n \ |
| 56 | key_identifier BLOB NOT NULL, \n \ |
| 57 | key_type INTEGER, \n \ |
| 58 | public_key BLOB, \n \ |
| 59 | default_key INTEGER DEFAULT 0, \n \ |
| 60 | active INTEGER DEFAULT 0, \n \ |
| 61 | \ |
| 62 | PRIMARY KEY (identity_name, key_identifier) \n \ |
| 63 | ); \n \ |
| 64 | \ |
| 65 | CREATE INDEX key_index ON Key(identity_name); \n \ |
| 66 | "; |
| 67 | |
| 68 | static const string INIT_CERT_TABLE = "\ |
| 69 | CREATE TABLE IF NOT EXISTS \n \ |
| 70 | Certificate( \n \ |
| 71 | cert_name BLOB NOT NULL, \n \ |
| 72 | cert_issuer BLOB NOT NULL, \n \ |
| 73 | identity_name BLOB NOT NULL, \n \ |
| 74 | key_identifier BLOB NOT NULL, \n \ |
| 75 | not_before TIMESTAMP, \n \ |
| 76 | not_after TIMESTAMP, \n \ |
| 77 | certificate_data BLOB NOT NULL, \n \ |
| 78 | valid_flag INTEGER DEFAULT 0, \n \ |
| 79 | default_cert INTEGER DEFAULT 0, \n \ |
| 80 | \ |
| 81 | PRIMARY KEY (cert_name) \n \ |
| 82 | ); \n \ |
| 83 | \ |
| 84 | CREATE INDEX cert_index ON Certificate(cert_name); \n \ |
| 85 | CREATE INDEX subject ON Certificate(identity_name); \n \ |
| 86 | "; |
| 87 | |
| 88 | /** |
| 89 | * A utility function to call the normal sqlite3_bind_text where the value and length are value.c_str() and value.size(). |
| 90 | */ |
| 91 | static int sqlite3_bind_text(sqlite3_stmt* statement, int index, const string& value, void(*destructor)(void*)) |
| 92 | { |
| 93 | return sqlite3_bind_text(statement, index, value.c_str(), value.size(), destructor); |
| 94 | } |
| 95 | |
| 96 | BasicIdentityStorage::BasicIdentityStorage() |
| 97 | { |
| 98 | #if 0 |
| 99 | fs::path identityDir = fs::path(getenv("HOME")) / ".ndn-identity"; |
| 100 | fs::create_directories(identityDir); |
| 101 | |
| 102 | int res = sqlite3_open((identityDir / "identity.db").c_str(), &database_); |
| 103 | |
| 104 | if (res != SQLITE_OK) |
| 105 | { |
| 106 | throw SecurityException("identity DB cannot be opened/created"); |
| 107 | } |
| 108 | #endif |
| 109 | |
| 110 | //Check if Key table exists; |
| 111 | sqlite3_stmt *statement; |
| 112 | sqlite3_prepare_v2(database_, "SELECT name FROM sqlite_master WHERE type='table' And name='Identity'", -1, &statement, 0); |
| 113 | int res = sqlite3_step(statement); |
| 114 | |
| 115 | bool idTableExists = false; |
| 116 | if (res == SQLITE_ROW) |
| 117 | idTableExists = true; |
| 118 | |
| 119 | sqlite3_finalize(statement); |
| 120 | |
| 121 | if (!idTableExists) { |
| 122 | char *errorMessage = 0; |
| 123 | res = sqlite3_exec(database_, INIT_ID_TABLE.c_str(), NULL, NULL, &errorMessage); |
| 124 | |
| 125 | if (res != SQLITE_OK && errorMessage != 0) { |
| 126 | _LOG_TRACE("Init \"error\" in Identity: " << errorMessage); |
| 127 | sqlite3_free(errorMessage); |
| 128 | } |
| 129 | } |
| 130 | |
| 131 | //Check if Key table exists; |
| 132 | sqlite3_prepare_v2(database_, "SELECT name FROM sqlite_master WHERE type='table' And name='Key'", -1, &statement, 0); |
| 133 | res = sqlite3_step(statement); |
| 134 | |
| 135 | bool keyTableExists = false; |
| 136 | if (res == SQLITE_ROW) |
| 137 | keyTableExists = true; |
| 138 | |
| 139 | sqlite3_finalize(statement); |
| 140 | |
| 141 | if (!keyTableExists) { |
| 142 | char *errorMessage = 0; |
| 143 | res = sqlite3_exec(database_, INIT_KEY_TABLE.c_str(), NULL, NULL, &errorMessage); |
| 144 | |
| 145 | if (res != SQLITE_OK && errorMessage != 0) { |
| 146 | _LOG_TRACE("Init \"error\" in KEY: " << errorMessage); |
| 147 | sqlite3_free(errorMessage); |
| 148 | } |
| 149 | } |
| 150 | |
| 151 | //Check if Certificate table exists; |
| 152 | sqlite3_prepare_v2(database_, "SELECT name FROM sqlite_master WHERE type='table' And name='Certificate'", -1, &statement, 0); |
| 153 | res = sqlite3_step(statement); |
| 154 | |
| 155 | bool idCertificateTableExists = false; |
| 156 | if (res == SQLITE_ROW) |
| 157 | idCertificateTableExists = true; |
| 158 | |
| 159 | sqlite3_finalize(statement); |
| 160 | |
| 161 | if (!idCertificateTableExists) { |
| 162 | char *errorMessage = 0; |
| 163 | res = sqlite3_exec(database_, INIT_CERT_TABLE.c_str(), NULL, NULL, &errorMessage); |
| 164 | |
| 165 | if (res != SQLITE_OK && errorMessage != 0) { |
| 166 | _LOG_TRACE("Init \"error\" in ID-CERT: " << errorMessage); |
| 167 | sqlite3_free(errorMessage); |
| 168 | } |
| 169 | } |
| 170 | } |
| 171 | |
| 172 | BasicIdentityStorage::~BasicIdentityStorage() |
| 173 | { |
| 174 | } |
| 175 | |
| 176 | bool |
| 177 | BasicIdentityStorage::doesIdentityExist(const Name& identityName) |
| 178 | { |
| 179 | bool result = false; |
| 180 | |
| 181 | sqlite3_stmt *statement; |
| 182 | sqlite3_prepare_v2(database_, "SELECT count(*) FROM Identity WHERE identity_name=?", -1, &statement, 0); |
| 183 | |
| 184 | sqlite3_bind_text(statement, 1, identityName.toUri(), SQLITE_TRANSIENT); |
| 185 | int res = sqlite3_step(statement); |
| 186 | |
| 187 | if (res == SQLITE_ROW) { |
| 188 | int countAll = sqlite3_column_int(statement, 0); |
| 189 | if (countAll > 0) |
| 190 | result = true; |
| 191 | } |
| 192 | |
| 193 | sqlite3_finalize(statement); |
| 194 | |
| 195 | return result; |
| 196 | } |
| 197 | |
| 198 | void |
| 199 | BasicIdentityStorage::addIdentity(const Name& identityName) |
| 200 | { |
| 201 | if (doesIdentityExist(identityName)) |
| 202 | throw SecurityException("Identity already exists"); |
| 203 | |
| 204 | sqlite3_stmt *statement; |
| 205 | |
| 206 | sqlite3_prepare_v2(database_, "INSERT INTO Identity (identity_name) values (?)", -1, &statement, 0); |
| 207 | |
| 208 | sqlite3_bind_text(statement, 1, identityName.toUri(), SQLITE_TRANSIENT); |
| 209 | |
| 210 | int res = sqlite3_step(statement); |
| 211 | |
| 212 | sqlite3_finalize(statement); |
| 213 | } |
| 214 | |
| 215 | bool |
| 216 | BasicIdentityStorage::revokeIdentity() |
| 217 | { |
| 218 | //TODO: |
| 219 | return false; |
| 220 | } |
| 221 | |
Jeff Thompson | 7ca11f2 | 2013-10-04 19:01:30 -0700 | [diff] [blame] | 222 | Name |
| 223 | BasicIdentityStorage::getNewKeyName(const Name& identityName, bool useKsk) |
| 224 | { |
Jeff Thompson | 1975def | 2013-10-09 17:06:43 -0700 | [diff] [blame] | 225 | #if 0 |
Jeff Thompson | 7ca11f2 | 2013-10-04 19:01:30 -0700 | [diff] [blame] | 226 | TimeInterval ti = time::NowUnixTimestamp(); |
| 227 | ostringstream oss; |
| 228 | oss << ti.total_seconds(); |
| 229 | |
| 230 | string keyIdStr; |
| 231 | |
| 232 | if (useKsk) |
| 233 | keyIdStr = ("KSK-" + oss.str()); |
| 234 | else |
| 235 | keyIdStr = ("DSK-" + oss.str()); |
| 236 | |
| 237 | |
| 238 | Name keyName = Name(identityName).append(keyIdStr); |
| 239 | |
| 240 | if (doesKeyExist(keyName)) |
| 241 | throw SecurityException("Key name already exists"); |
| 242 | |
| 243 | return keyName; |
Jeff Thompson | 1975def | 2013-10-09 17:06:43 -0700 | [diff] [blame] | 244 | #else |
| 245 | throw logic_error("unimplemented"); |
Jeff Thompson | 7ca11f2 | 2013-10-04 19:01:30 -0700 | [diff] [blame] | 246 | #endif |
Jeff Thompson | 1975def | 2013-10-09 17:06:43 -0700 | [diff] [blame] | 247 | } |
Jeff Thompson | 7ca11f2 | 2013-10-04 19:01:30 -0700 | [diff] [blame] | 248 | |
| 249 | bool |
| 250 | BasicIdentityStorage::doesKeyExist(const Name& keyName) |
| 251 | { |
| 252 | string keyId = keyName.get(keyName.size() - 1).toEscapedString(); |
| 253 | Name identityName = keyName.getSubName(0, keyName.size() - 1); |
| 254 | |
| 255 | sqlite3_stmt *statement; |
| 256 | sqlite3_prepare_v2(database_, "SELECT count(*) FROM Key WHERE identity_name=? AND key_identifier=?", -1, &statement, 0); |
| 257 | |
| 258 | sqlite3_bind_text(statement, 1, identityName.toUri(), SQLITE_TRANSIENT); |
| 259 | sqlite3_bind_text(statement, 2, keyId, SQLITE_TRANSIENT); |
| 260 | |
| 261 | int res = sqlite3_step(statement); |
| 262 | |
| 263 | bool keyIdExist = false; |
| 264 | if (res == SQLITE_ROW) { |
| 265 | int countAll = sqlite3_column_int(statement, 0); |
| 266 | if (countAll > 0) |
| 267 | keyIdExist = true; |
| 268 | } |
| 269 | |
| 270 | sqlite3_finalize(statement); |
| 271 | |
| 272 | return keyIdExist; |
| 273 | } |
| 274 | |
| 275 | Name |
| 276 | BasicIdentityStorage::getKeyNameForCertificate(const Name& certificateName) |
| 277 | { |
| 278 | int i = certificateName.size() - 1; |
| 279 | |
| 280 | for (; i >= 0; --i) { |
| 281 | if (certificateName.get(i).toEscapedString() == string("ID-CERT")) |
| 282 | break; |
| 283 | } |
| 284 | |
| 285 | return certificateName.getSubName(0, i); |
| 286 | } |
| 287 | |
| 288 | void |
| 289 | BasicIdentityStorage::addKey(const Name& keyName, KeyType keyType, const Blob& publicKeyDer) |
| 290 | { |
| 291 | string keyId = keyName.get(keyName.size() - 1).toEscapedString(); |
| 292 | Name identityName = keyName.getSubName(0, keyName.size() - 1); |
| 293 | |
| 294 | |
| 295 | if (!doesIdentityExist(identityName)) |
| 296 | addIdentity(identityName); |
| 297 | |
| 298 | if (doesKeyExist(keyName)) |
| 299 | throw SecurityException("a key with the same name already exists!"); |
| 300 | |
| 301 | sqlite3_stmt *statement; |
| 302 | sqlite3_prepare_v2(database_, "INSERT INTO Key (identity_name, key_identifier, key_type, public_key) values (?, ?, ?, ?)", -1, &statement, 0); |
| 303 | |
| 304 | sqlite3_bind_text(statement, 1, identityName.toUri(), SQLITE_TRANSIENT); |
| 305 | sqlite3_bind_text(statement, 2, keyId, SQLITE_TRANSIENT); |
| 306 | sqlite3_bind_int(statement, 3, (int)keyType); |
| 307 | sqlite3_bind_blob(statement, 4, publicKeyDer.buf(), publicKeyDer.size(), SQLITE_TRANSIENT); |
| 308 | |
| 309 | int res = sqlite3_step(statement); |
| 310 | |
| 311 | sqlite3_finalize(statement); |
| 312 | } |
| 313 | |
| 314 | Blob |
| 315 | BasicIdentityStorage::getKey(const Name& keyName) |
| 316 | { |
| 317 | if (!doesKeyExist(keyName)) { |
| 318 | _LOG_DEBUG("keyName does not exist"); |
| 319 | return Blob(); |
| 320 | } |
| 321 | |
| 322 | string keyId = keyName.get(keyName.size() - 1).toEscapedString(); |
| 323 | Name identityName = keyName.getSubName(0, keyName.size() - 1); |
| 324 | |
| 325 | sqlite3_stmt *statement; |
| 326 | sqlite3_prepare_v2(database_, "SELECT public_key FROM Key WHERE identity_name=? AND key_identifier=?", -1, &statement, 0); |
| 327 | |
| 328 | sqlite3_bind_text(statement, 1, identityName.toUri(), SQLITE_TRANSIENT); |
| 329 | sqlite3_bind_text(statement, 2, keyId, SQLITE_TRANSIENT); |
| 330 | |
| 331 | int res = sqlite3_step(statement); |
| 332 | |
| 333 | Blob result; |
| 334 | if (res == SQLITE_ROW) |
| 335 | result = Blob(static_cast<const uint8_t*>(sqlite3_column_blob(statement, 0)), sqlite3_column_bytes(statement, 0)); |
| 336 | |
| 337 | sqlite3_finalize(statement); |
| 338 | |
| 339 | return result; |
| 340 | } |
| 341 | |
| 342 | void |
| 343 | BasicIdentityStorage::activateKey(const Name& keyName) |
| 344 | { |
| 345 | updateKeyStatus(keyName, true); |
| 346 | } |
| 347 | |
| 348 | void |
| 349 | BasicIdentityStorage::deactivateKey(const Name& keyName) |
| 350 | { |
| 351 | updateKeyStatus(keyName, false); |
| 352 | } |
| 353 | |
| 354 | void |
| 355 | BasicIdentityStorage::updateKeyStatus(const Name& keyName, bool isActive) |
| 356 | { |
| 357 | string keyId = keyName.get(keyName.size() - 1).toEscapedString(); |
| 358 | Name identityName = keyName.getSubName(0, keyName.size() - 1); |
| 359 | |
| 360 | sqlite3_stmt *statement; |
| 361 | sqlite3_prepare_v2(database_, "UPDATE Key SET active=? WHERE identity_name=? AND key_identifier=?", -1, &statement, 0); |
| 362 | |
| 363 | sqlite3_bind_int(statement, 1, (isActive ? 1 : 0)); |
| 364 | sqlite3_bind_text(statement, 2, identityName.toUri(), SQLITE_TRANSIENT); |
| 365 | sqlite3_bind_text(statement, 3, keyId, SQLITE_TRANSIENT); |
| 366 | |
| 367 | int res = sqlite3_step(statement); |
| 368 | |
| 369 | sqlite3_finalize(statement); |
| 370 | } |
| 371 | |
| 372 | bool |
| 373 | BasicIdentityStorage::doesCertificateExist(const Name& certificateName) |
| 374 | { |
| 375 | sqlite3_stmt *statement; |
| 376 | sqlite3_prepare_v2(database_, "SELECT count(*) FROM Certificate WHERE cert_name=?", -1, &statement, 0); |
| 377 | |
| 378 | sqlite3_bind_text(statement, 1, certificateName.toUri(), SQLITE_TRANSIENT); |
| 379 | |
| 380 | int res = sqlite3_step(statement); |
| 381 | |
| 382 | bool certExist = false; |
| 383 | if (res == SQLITE_ROW) { |
| 384 | int countAll = sqlite3_column_int(statement, 0); |
| 385 | if (countAll > 0) |
| 386 | certExist = true; |
| 387 | } |
| 388 | |
| 389 | sqlite3_finalize(statement); |
| 390 | |
| 391 | return certExist; |
| 392 | } |
| 393 | |
Jeff Thompson | 7ca11f2 | 2013-10-04 19:01:30 -0700 | [diff] [blame] | 394 | void |
| 395 | BasicIdentityStorage::addAnyCertificate(const Certificate& certificate) |
| 396 | { |
Jeff Thompson | 1975def | 2013-10-09 17:06:43 -0700 | [diff] [blame] | 397 | #if 0 |
Jeff Thompson | 7ca11f2 | 2013-10-04 19:01:30 -0700 | [diff] [blame] | 398 | const Name& certificateName = certificate.getName(); |
| 399 | Name keyName = getKeyNameForCertificate(certificateName); |
| 400 | |
| 401 | string keyId = keyName.get(keyName.size() - 1).toUri(); |
| 402 | Name identityName = keyName.getSubName(0, keyName.size() - 1); |
| 403 | |
| 404 | sqlite3_stmt *statement; |
| 405 | sqlite3_prepare_v2(database_, |
| 406 | "INSERT INTO Certificate (cert_name, cert_issuer, identity_name, key_identifier, not_before, not_after, certificate_data)\ |
| 407 | values (?, ?, ?, ?, datetime(?, 'unixepoch'), datetime(?, 'unixepoch'), ?)", |
| 408 | -1, &statement, 0); |
| 409 | |
| 410 | |
| 411 | _LOG_DEBUG("certName: " << certificateName.toUri().c_str()); |
| 412 | sqlite3_bind_text(statement, 1, certificateName.toUri(), SQLITE_TRANSIENT); |
| 413 | |
| 414 | Ptr<const signature::Sha256WithRsa> signature = boost::dynamic_pointer_cast<const signature::Sha256WithRsa>(certificate.getSignature()); |
| 415 | const Name& signerName = signature->getKeyLocator().getKeyName(); |
| 416 | sqlite3_bind_text(statement, 2, signerName.toUri(), SQLITE_TRANSIENT); |
| 417 | |
| 418 | sqlite3_bind_text(statement, 3, identityName.toUri(), SQLITE_TRANSIENT); |
| 419 | sqlite3_bind_text(statement, 4, keyId, SQLITE_TRANSIENT); |
| 420 | |
| 421 | sqlite3_bind_int64(statement, 5, (sqlite3_int64)(certificate.getNotBefore() - time::UNIX_EPOCH_TIME).total_seconds()); |
| 422 | sqlite3_bind_int64(statement, 6, (sqlite3_int64)(certificate.getNotAfter() - time::UNIX_EPOCH_TIME).total_seconds()); |
| 423 | |
| 424 | Blob certificateEncoding = certificate.wireEncode(); |
| 425 | |
| 426 | sqlite3_bind_blob(statement, 7, certificateEncoding->buf(), certBlob->size(), SQLITE_TRANSIENT); |
| 427 | |
| 428 | int res = sqlite3_step(statement); |
| 429 | |
| 430 | sqlite3_finalize(statement); |
Jeff Thompson | 1975def | 2013-10-09 17:06:43 -0700 | [diff] [blame] | 431 | #else |
| 432 | throw logic_error("unimplemented"); |
| 433 | #endif |
Jeff Thompson | 7ca11f2 | 2013-10-04 19:01:30 -0700 | [diff] [blame] | 434 | } |
| 435 | |
| 436 | void |
| 437 | BasicIdentityStorage::addCertificate(const Certificate& certificate) |
| 438 | { |
Jeff Thompson | 1975def | 2013-10-09 17:06:43 -0700 | [diff] [blame] | 439 | #if 0 |
Jeff Thompson | 7ca11f2 | 2013-10-04 19:01:30 -0700 | [diff] [blame] | 440 | _LOG_DEBUG("1"); |
| 441 | const Name& certificateName = certificate.getName(); |
| 442 | Name keyName = getKeyNameForCertificate(certificateName); |
| 443 | |
| 444 | _LOG_DEBUG("2"); |
| 445 | if (!doesKeyExist(keyName)) |
| 446 | { |
| 447 | _LOG_DEBUG("here wrong"); |
| 448 | throw SecurityException("No corresponding Key record for the certificate!"); |
| 449 | } |
| 450 | |
| 451 | // Check if certificate has already existed! |
| 452 | if (doesCertificateExist(certificateName)) |
| 453 | throw SecurityException("Certificate has already been installed!"); |
| 454 | |
| 455 | _LOG_DEBUG("3"); |
| 456 | string keyId = keyName.get(keyName.size() - 1).toEscapedString(); |
| 457 | Name identity = keyName.getSubName(0, keyName.size() - 1); |
| 458 | |
| 459 | // Check if the public key of certificate is the same as the key record |
| 460 | |
| 461 | Ptr<Blob> keyBlob = getKey(keyName); |
| 462 | |
| 463 | if (keyBlob == NULL or (*keyBlob) != (certificate.getPublicKeyInfo().getKeyBlob())) |
| 464 | throw SecurityException("Certificate does not match the public key!"); |
| 465 | |
| 466 | _LOG_DEBUG("4"); |
| 467 | // Insert the certificate |
| 468 | sqlite3_stmt *statement; |
| 469 | sqlite3_prepare_v2(database_, |
| 470 | "INSERT INTO Certificate (cert_name, cert_issuer, identity_name, key_identifier, not_before, not_after, certificate_data)\ |
| 471 | values (?, ?, ?, ?, datetime(?, 'unixepoch'), datetime(?, 'unixepoch'), ?)", |
| 472 | -1, &statement, 0); |
| 473 | |
| 474 | _LOG_DEBUG("certName: " << certificateName.toUri().c_str()); |
| 475 | sqlite3_bind_text(statement, 1, certificateName.toUri(), SQLITE_TRANSIENT); |
| 476 | |
| 477 | Ptr<const signature::Sha256WithRsa> signature = boost::dynamic_pointer_cast<const signature::Sha256WithRsa>(certificate.getSignature()); |
| 478 | const Name & signerName = signature->getKeyLocator().getKeyName(); |
| 479 | sqlite3_bind_text(statement, 2, signerName.toUri(), SQLITE_TRANSIENT); |
| 480 | |
| 481 | sqlite3_bind_text(statement, 3, identity.toUri(), SQLITE_TRANSIENT); |
| 482 | sqlite3_bind_text(statement, 4, keyId, SQLITE_TRANSIENT); |
| 483 | |
| 484 | sqlite3_bind_int64(statement, 5, (sqlite3_int64)(certificate.getNotBefore() - time::UNIX_EPOCH_TIME).total_seconds()); |
| 485 | sqlite3_bind_int64(statement, 6, (sqlite3_int64)(certificate.getNotAfter() - time::UNIX_EPOCH_TIME).total_seconds()); |
| 486 | |
| 487 | Blob certificateEncoding = certificate.wireEncode(); |
| 488 | |
| 489 | sqlite3_bind_blob(statement, 7, certificateEncoding->buf(), certificateEncoding->size(), SQLITE_TRANSIENT); |
| 490 | |
| 491 | int res = sqlite3_step(statement); |
| 492 | |
| 493 | sqlite3_finalize(statement); |
Jeff Thompson | 1975def | 2013-10-09 17:06:43 -0700 | [diff] [blame] | 494 | #else |
| 495 | throw logic_error("unimplemented"); |
| 496 | #endif |
Jeff Thompson | 7ca11f2 | 2013-10-04 19:01:30 -0700 | [diff] [blame] | 497 | } |
| 498 | |
| 499 | shared_ptr<Certificate> |
| 500 | BasicIdentityStorage::getCertificate(const Name &certificateName, bool allowAny) |
| 501 | { |
Jeff Thompson | 1975def | 2013-10-09 17:06:43 -0700 | [diff] [blame] | 502 | #if 0 |
Jeff Thompson | 7ca11f2 | 2013-10-04 19:01:30 -0700 | [diff] [blame] | 503 | if (doesCertificateExist(certificateName)) { |
| 504 | sqlite3_stmt *statement; |
| 505 | if (!allowAny) { |
| 506 | sqlite3_prepare_v2(database_, |
| 507 | "SELECT certificate_data FROM Certificate \ |
| 508 | WHERE cert_name=? AND not_before<datetime(?, 'unixepoch') AND not_after>datetime(?, 'unixepoch') and valid_flag=1", |
| 509 | -1, &statement, 0); |
| 510 | |
| 511 | sqlite3_bind_text(statement, 1, certificateName.toUri(), SQLITE_TRANSIENT); |
| 512 | sqlite3_bind_int64(statement, 2, (sqlite3_int64)time::NowUnixTimestamp().total_seconds()); |
| 513 | sqlite3_bind_int64(statement, 3, (sqlite3_int64)time::NowUnixTimestamp().total_seconds()); |
| 514 | } |
| 515 | else { |
| 516 | sqlite3_prepare_v2(database_, |
| 517 | "SELECT certificate_data FROM Certificate WHERE cert_name=?", -1, &statement, 0); |
| 518 | |
| 519 | sqlite3_bind_text(statement, 1, certificateName.toUri(), SQLITE_TRANSIENT); |
| 520 | } |
| 521 | |
| 522 | int res = sqlite3_step(statement); |
| 523 | |
| 524 | shared_ptr<Certificate> certificate(new Certificate()); |
| 525 | |
| 526 | if (res == SQLITE_ROW) |
| 527 | certificate->wireDecode(sqlite3_column_blob(statement, 0), sqlite3_column_bytes(statement, 0)); |
| 528 | sqlite3_finalize(statement); |
| 529 | |
| 530 | return certificate; |
| 531 | } |
| 532 | else { |
| 533 | _LOG_DEBUG("Certificate does not exist!"); |
| 534 | return shared_ptr<Certificate>(); |
| 535 | } |
Jeff Thompson | 1975def | 2013-10-09 17:06:43 -0700 | [diff] [blame] | 536 | #else |
| 537 | throw logic_error("unimplemented"); |
Jeff Thompson | 7ca11f2 | 2013-10-04 19:01:30 -0700 | [diff] [blame] | 538 | #endif |
Jeff Thompson | 1975def | 2013-10-09 17:06:43 -0700 | [diff] [blame] | 539 | } |
Jeff Thompson | 7ca11f2 | 2013-10-04 19:01:30 -0700 | [diff] [blame] | 540 | |
| 541 | Name |
| 542 | BasicIdentityStorage::getDefaultIdentity() |
| 543 | { |
| 544 | sqlite3_stmt *statement; |
| 545 | sqlite3_prepare_v2(database_, "SELECT identity_name FROM Identity WHERE default_identity=1", -1, &statement, 0); |
| 546 | |
| 547 | int res = sqlite3_step(statement); |
| 548 | |
| 549 | Name identity; |
| 550 | |
| 551 | if (res == SQLITE_ROW) |
| 552 | identity = Name(string(reinterpret_cast<const char *>(sqlite3_column_text(statement, 0)), sqlite3_column_bytes(statement, 0))); |
| 553 | |
| 554 | sqlite3_finalize(statement); |
| 555 | |
| 556 | return identity; |
| 557 | } |
| 558 | |
| 559 | Name |
| 560 | BasicIdentityStorage::getDefaultKeyNameForIdentity(const Name& identityName) |
| 561 | { |
| 562 | sqlite3_stmt *statement; |
| 563 | sqlite3_prepare_v2(database_, "SELECT key_identifier FROM Key WHERE identity_name=? AND default_key=1", -1, &statement, 0); |
| 564 | |
| 565 | sqlite3_bind_text(statement, 1, identityName.toUri(), SQLITE_TRANSIENT); |
| 566 | |
| 567 | int res = sqlite3_step(statement); |
| 568 | |
| 569 | Name keyName; |
| 570 | |
| 571 | if (res == SQLITE_ROW) |
| 572 | keyName = Name(identityName).append(string(reinterpret_cast<const char *>(sqlite3_column_text(statement, 0)), sqlite3_column_bytes(statement, 0))); |
| 573 | |
| 574 | sqlite3_finalize(statement); |
| 575 | |
| 576 | return keyName; |
| 577 | } |
| 578 | |
| 579 | Name |
| 580 | BasicIdentityStorage::getDefaultCertificateNameForKey(const Name& keyName) |
| 581 | { |
| 582 | string keyId = keyName.get(keyName.size() - 1).toEscapedString(); |
| 583 | Name identityName = keyName.getSubName(0, keyName.size() - 1); |
| 584 | |
| 585 | sqlite3_stmt *statement; |
| 586 | sqlite3_prepare_v2(database_, "SELECT cert_name FROM Certificate WHERE identity_name=? AND key_identifier=? AND default_cert=1", -1, &statement, 0); |
| 587 | |
| 588 | sqlite3_bind_text(statement, 1, identityName.toUri(), SQLITE_TRANSIENT); |
| 589 | sqlite3_bind_text(statement, 2, keyId, SQLITE_TRANSIENT); |
| 590 | |
| 591 | int res = sqlite3_step(statement); |
| 592 | |
| 593 | Name certName; |
| 594 | |
| 595 | if (res == SQLITE_ROW) |
| 596 | certName = Name(string(reinterpret_cast<const char *>(sqlite3_column_text(statement, 0)), sqlite3_column_bytes(statement, 0))); |
| 597 | |
| 598 | sqlite3_finalize(statement); |
| 599 | |
| 600 | return certName; |
| 601 | } |
| 602 | |
| 603 | void |
| 604 | BasicIdentityStorage::setDefaultIdentity(const Name& identityName) |
| 605 | { |
| 606 | sqlite3_stmt *statement; |
| 607 | |
| 608 | //Reset previous default identity |
| 609 | sqlite3_prepare_v2(database_, "UPDATE Identity SET default_identity=0 WHERE default_identity=1", -1, &statement, 0); |
| 610 | |
| 611 | while (sqlite3_step(statement) == SQLITE_ROW) |
| 612 | {} |
| 613 | |
| 614 | sqlite3_finalize(statement); |
| 615 | |
| 616 | //Set current default identity |
| 617 | sqlite3_prepare_v2(database_, "UPDATE Identity SET default_identity=1 WHERE identity_name=?", -1, &statement, 0); |
| 618 | |
| 619 | sqlite3_bind_text(statement, 1, identityName.toUri(), SQLITE_TRANSIENT); |
| 620 | |
| 621 | sqlite3_step(statement); |
| 622 | |
| 623 | sqlite3_finalize(statement); |
| 624 | } |
| 625 | |
| 626 | void |
| 627 | BasicIdentityStorage::setDefaultKeyNameForIdentity(const Name& keyName, const Name& identityNameCheck) |
| 628 | { |
| 629 | string keyId = keyName.get(keyName.size() - 1).toEscapedString(); |
| 630 | Name identityName = keyName.getSubName(0, keyName.size() - 1); |
| 631 | |
| 632 | if (identityNameCheck.size() > 0 && !identityNameCheck.equals(identityName)) |
| 633 | throw SecurityException("Specified identity name does not match the key name"); |
| 634 | |
| 635 | sqlite3_stmt *statement; |
| 636 | |
| 637 | //Reset previous default Key |
| 638 | sqlite3_prepare_v2(database_, "UPDATE Key SET default_key=0 WHERE default_key=1 and identity_name=?", -1, &statement, 0); |
| 639 | |
| 640 | sqlite3_bind_text(statement, 1, identityName.toUri(), SQLITE_TRANSIENT); |
| 641 | |
| 642 | while (sqlite3_step(statement) == SQLITE_ROW) |
| 643 | {} |
| 644 | |
| 645 | sqlite3_finalize(statement); |
| 646 | |
| 647 | //Set current default Key |
| 648 | sqlite3_prepare_v2(database_, "UPDATE Key SET default_key=1 WHERE identity_name=? AND key_identifier=?", -1, &statement, 0); |
| 649 | |
| 650 | sqlite3_bind_text(statement, 1, identityName.toUri(), SQLITE_TRANSIENT); |
| 651 | sqlite3_bind_text(statement, 2, keyId, SQLITE_TRANSIENT); |
| 652 | |
| 653 | sqlite3_step(statement); |
| 654 | |
| 655 | sqlite3_finalize(statement); |
| 656 | } |
| 657 | |
| 658 | void |
| 659 | BasicIdentityStorage::setDefaultCertificateNameForKey(const Name& keyName, const Name& certificateName) |
| 660 | { |
| 661 | string keyId = keyName.get(keyName.size() - 1).toEscapedString(); |
| 662 | Name identityName = keyName.getSubName(0, keyName.size() - 1); |
| 663 | |
| 664 | sqlite3_stmt *statement; |
| 665 | |
| 666 | //Reset previous default Key |
| 667 | sqlite3_prepare_v2(database_, "UPDATE Certificate SET default_cert=0 WHERE default_cert=1 AND identity_name=? AND key_identifier=?", -1, &statement, 0); |
| 668 | |
| 669 | sqlite3_bind_text(statement, 1, identityName.toUri(), SQLITE_TRANSIENT); |
| 670 | sqlite3_bind_text(statement, 2, keyId, SQLITE_TRANSIENT); |
| 671 | |
| 672 | while (sqlite3_step(statement) == SQLITE_ROW) |
| 673 | {} |
| 674 | |
| 675 | sqlite3_finalize(statement); |
| 676 | |
| 677 | //Set current default Key |
| 678 | sqlite3_prepare_v2(database_, "UPDATE Certificate SET default_cert=1 WHERE identity_name=? AND key_identifier=? AND cert_name=?", -1, &statement, 0); |
| 679 | |
| 680 | sqlite3_bind_text(statement, 1, identityName.toUri(), SQLITE_TRANSIENT); |
| 681 | sqlite3_bind_text(statement, 2, keyId, SQLITE_TRANSIENT); |
| 682 | sqlite3_bind_text(statement, 3, certificateName.toUri(), SQLITE_TRANSIENT); |
| 683 | |
| 684 | sqlite3_step(statement); |
| 685 | |
| 686 | sqlite3_finalize(statement); |
| 687 | } |
| 688 | |
| 689 | } |
| 690 | |
Jeff Thompson | b752300 | 2013-10-09 10:25:00 -0700 | [diff] [blame] | 691 | #endif // NDN_CPP_HAVE_SQLITE3 |