blob: c9ed28cdc6e873de60113c7eb1a4f4af8ba5544f [file] [log] [blame]
Alexander Afanasyevc169a812014-05-20 20:37:29 -04001/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
Jeff Thompson47c93cf2013-08-09 00:38:48 -07002/**
Alexander Afanasyev34a37632015-01-16 17:37:36 -08003 * Copyright (c) 2013-2015 Regents of the University of California.
Alexander Afanasyevdfa52c42014-04-24 21:10:11 -07004 *
5 * This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
Alexander Afanasyevdfa52c42014-04-24 21:10:11 -07006 *
Alexander Afanasyevc169a812014-05-20 20:37:29 -04007 * ndn-cxx library is free software: you can redistribute it and/or modify it under the
8 * terms of the GNU Lesser General Public License as published by the Free Software
9 * Foundation, either version 3 of the License, or (at your option) any later version.
10 *
11 * ndn-cxx library is distributed in the hope that it will be useful, but WITHOUT ANY
12 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
13 * PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
14 *
15 * You should have received copies of the GNU General Public License and GNU Lesser
16 * General Public License along with ndn-cxx, e.g., in COPYING.md file. If not, see
17 * <http://www.gnu.org/licenses/>.
18 *
19 * See AUTHORS.md for complete list of ndn-cxx authors and contributors.
Alexander Afanasyevdfa52c42014-04-24 21:10:11 -070020 *
21 * @author Yingdi Yu <http://irl.cs.ucla.edu/~yingdi/>
Jeff Thompson47c93cf2013-08-09 00:38:48 -070022 */
23
Yingdi Yufc40d872014-02-18 12:56:04 -080024#ifndef NDN_SECURITY_KEY_CHAIN_HPP
25#define NDN_SECURITY_KEY_CHAIN_HPP
Jeff Thompson47c93cf2013-08-09 00:38:48 -070026
Yingdi Yuf56c68f2014-04-24 21:50:13 -070027#include "sec-public-info.hpp"
28#include "sec-tpm.hpp"
Yingdi Yu7036ce22014-06-19 18:53:37 -070029#include "key-params.hpp"
Yingdi Yuf56c68f2014-04-24 21:50:13 -070030#include "secured-bag.hpp"
Yingdi Yu4f324632014-01-15 18:10:03 -080031#include "signature-sha256-with-rsa.hpp"
Yingdi Yuc8f883c2014-06-20 23:25:22 -070032#include "signature-sha256-with-ecdsa.hpp"
Yingdi Yubf6a2812014-06-17 15:32:11 -070033#include "digest-sha256.hpp"
Yingdi Yu1b0311c2015-06-10 14:58:47 -070034#include "signing-info.hpp"
Yingdi Yuf56c68f2014-04-24 21:50:13 -070035
Yingdi Yu4270f202014-01-28 14:19:16 -080036#include "../interest.hpp"
Yingdi Yu21157162014-02-28 13:02:34 -080037#include "../util/crypto.hpp"
Yingdi Yu0f5fb692014-06-10 12:07:28 -070038#include "../util/random.hpp"
Alexander Afanasyev07113802015-01-15 19:14:36 -080039#include <initializer_list>
Yingdi Yu31b4af22014-01-14 14:13:00 -080040
Jeff Thompson47c93cf2013-08-09 00:38:48 -070041
42namespace ndn {
Yingdi Yu1b0311c2015-06-10 14:58:47 -070043namespace security {
Jeff Thompson47c93cf2013-08-09 00:38:48 -070044
Yingdi Yu1b0311c2015-06-10 14:58:47 -070045/**
46 * @brief The packet signing interface.
47 */
Alexander Afanasyev45a37132014-04-28 16:54:57 -070048class KeyChain : noncopyable
Yingdi Yuf56c68f2014-04-24 21:50:13 -070049{
50public:
51 class Error : public std::runtime_error
52 {
53 public:
54 explicit
55 Error(const std::string& what)
56 : std::runtime_error(what)
57 {
58 }
59 };
60
Yingdi Yu41546342014-11-30 23:37:53 -080061 /**
Yingdi Yu1b0311c2015-06-10 14:58:47 -070062 * @brief Error thrown when the supplied TPM locator to KeyChain constructor does not match
63 * the locator stored in PIB
Yingdi Yu41546342014-11-30 23:37:53 -080064 */
65 class MismatchError : public Error
66 {
67 public:
68 explicit
69 MismatchError(const std::string& what)
70 : Error(what)
71 {
72 }
73 };
Yingdi Yu7036ce22014-06-19 18:53:37 -070074
Alexander Afanasyev07113802015-01-15 19:14:36 -080075 typedef function<unique_ptr<SecPublicInfo> (const std::string&)> PibCreateFunc;
76 typedef function<unique_ptr<SecTpm>(const std::string&)> TpmCreateFunc;
Yingdi Yuf56c68f2014-04-24 21:50:13 -070077
Alexander Afanasyev07113802015-01-15 19:14:36 -080078 /**
79 * @brief Register a new PIB
Alexander Afanasyev34a37632015-01-16 17:37:36 -080080 * @param aliases List of schemes with which this PIB will be associated.
81 * The first alias in the list is considered a canonical name of the PIB instance.
Alexander Afanasyev07113802015-01-15 19:14:36 -080082 */
83 template<class PibType>
84 static void
Alexander Afanasyev34a37632015-01-16 17:37:36 -080085 registerPib(std::initializer_list<std::string> aliases);
Alexander Afanasyev07113802015-01-15 19:14:36 -080086
87 /**
88 * @brief Register a new TPM
Alexander Afanasyev34a37632015-01-16 17:37:36 -080089 * @param aliases List of schemes with which this TPM will be associated
90 * The first alias in the list is considered a canonical name of the TPM instance.
Alexander Afanasyev07113802015-01-15 19:14:36 -080091 */
92 template<class TpmType>
93 static void
Alexander Afanasyev34a37632015-01-16 17:37:36 -080094 registerTpm(std::initializer_list<std::string> aliases);
Alexander Afanasyev07113802015-01-15 19:14:36 -080095
Yingdi Yu1b0311c2015-06-10 14:58:47 -070096 /**
97 * @brief Get default PIB locator
98 */
Yingdi Yu281689a2015-06-13 14:32:32 -070099 static std::string
100 getDefaultPibLocator();
101
Yingdi Yu1b0311c2015-06-10 14:58:47 -0700102 /**
103 * @brief Create a PIB according to @p pibLocator
104 */
Yingdi Yu281689a2015-06-13 14:32:32 -0700105 static unique_ptr<SecPublicInfo>
106 createPib(const std::string& pibLocator);
107
Yingdi Yu1b0311c2015-06-10 14:58:47 -0700108 /**
109 * @brief Get default TPM locator
110 */
Yingdi Yu281689a2015-06-13 14:32:32 -0700111 static std::string
112 getDefaultTpmLocator();
113
Yingdi Yu1b0311c2015-06-10 14:58:47 -0700114 /**
115 * @brief Create a TPM according to @p tpmLocator
116 */
Yingdi Yu281689a2015-06-13 14:32:32 -0700117 static unique_ptr<SecTpm>
118 createTpm(const std::string& tpmLocator);
119
Alexander Afanasyev07113802015-01-15 19:14:36 -0800120 /**
121 * @brief Constructor to create KeyChain with default PIB and TPM
122 *
123 * Default PIB and TPM are platform-dependent and can be overriden system-wide or on
124 * per-use basis.
125 *
126 * @todo Add detailed description about config file behavior here
127 */
128 KeyChain();
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700129
Yingdi Yu41546342014-11-30 23:37:53 -0800130 /**
131 * @brief KeyChain constructor
132 *
133 * @sa http://redmine.named-data.net/issues/2260
134 *
Davide Pesavento18cf81b2015-09-12 23:36:43 +0200135 * @param pibLocator PIB locator
136 * @param tpmLocator TPM locator
Yingdi Yu41546342014-11-30 23:37:53 -0800137 * @param allowReset if true, the PIB will be reset when the supplied tpmLocator
138 * mismatches the one in PIB
139 */
140 KeyChain(const std::string& pibLocator,
141 const std::string& tpmLocator,
142 bool allowReset = false);
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700143
144 virtual
Yingdi Yu5ec0ee32014-06-24 16:26:09 -0700145 ~KeyChain();
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700146
Yingdi Yube4150e2014-02-18 13:02:46 -0800147 /**
Yingdi Yu4b8c6a22014-04-15 23:00:54 -0700148 * @brief Create an identity by creating a pair of Key-Signing-Key (KSK) for this identity and a
149 * self-signed certificate of the KSK.
Yingdi Yube4150e2014-02-18 13:02:46 -0800150 *
Yingdi Yu2abd73f2014-01-08 23:34:11 -0800151 * @param identityName The name of the identity.
Yingdi Yu7036ce22014-06-19 18:53:37 -0700152 * @param params The key parameter if a key needs to be generated for the identity.
Yingdi Yu28fd32f2014-01-28 19:03:03 -0800153 * @return The name of the default certificate of the identity.
Yingdi Yu2abd73f2014-01-08 23:34:11 -0800154 */
Yingdi Yu7036ce22014-06-19 18:53:37 -0700155 Name
156 createIdentity(const Name& identityName, const KeyParams& params = DEFAULT_KEY_PARAMS);
Alexander Afanasyevb78bc4d2014-04-09 21:20:52 -0700157
Yingdi Yu2abd73f2014-01-08 23:34:11 -0800158 /**
Yingdi Yu2e57a582014-02-20 23:34:43 -0800159 * @brief Generate a pair of RSA keys for the specified identity.
160 *
Yingdi Yu2abd73f2014-01-08 23:34:11 -0800161 * @param identityName The name of the identity.
162 * @param isKsk true for generating a Key-Signing-Key (KSK), false for a Data-Signing-Key (KSK).
163 * @param keySize The size of the key.
164 * @return The generated key name.
Yingdi Yu1b0311c2015-06-10 14:58:47 -0700165 * @see generateEcdsaKeyPair
Yingdi Yu2abd73f2014-01-08 23:34:11 -0800166 */
Yingdi Yu41546342014-11-30 23:37:53 -0800167 Name
Yingdi Yuc8f883c2014-06-20 23:25:22 -0700168 generateRsaKeyPair(const Name& identityName, bool isKsk = false, uint32_t keySize = 2048);
Alexander Afanasyevb78bc4d2014-04-09 21:20:52 -0700169
Yingdi Yu1b0311c2015-06-10 14:58:47 -0700170 /**
171 * @brief Generate a pair of ECDSA keys for the specified identity.
172 *
173 * @param identityName The name of the identity.
174 * @param isKsk true for generating a Key-Signing-Key (KSK), false for a Data-Signing-Key (KSK).
175 * @param keySize The size of the key.
176 * @return The generated key name.
177 * @see generateRsaKeyPair
178 */
Yingdi Yu41546342014-11-30 23:37:53 -0800179 Name
Yingdi Yuc8f883c2014-06-20 23:25:22 -0700180 generateEcdsaKeyPair(const Name& identityName, bool isKsk = false, uint32_t keySize = 256);
Yingdi Yu1b0311c2015-06-10 14:58:47 -0700181
Yingdi Yu2abd73f2014-01-08 23:34:11 -0800182 /**
Yingdi Yu4b8c6a22014-04-15 23:00:54 -0700183 * @brief Generate a pair of RSA keys for the specified identity and set it as default key for
184 * the identity.
Yingdi Yu2e57a582014-02-20 23:34:43 -0800185 *
Yingdi Yu2abd73f2014-01-08 23:34:11 -0800186 * @param identityName The name of the identity.
187 * @param isKsk true for generating a Key-Signing-Key (KSK), false for a Data-Signing-Key (KSK).
188 * @param keySize The size of the key.
189 * @return The generated key name.
Yingdi Yu1b0311c2015-06-10 14:58:47 -0700190 * @see generateRsaKeyPair, generateEcdsaKeyPair, generateEcdsaKeyPairAsDefault
Yingdi Yu2abd73f2014-01-08 23:34:11 -0800191 */
Yingdi Yu7036ce22014-06-19 18:53:37 -0700192 Name
Yingdi Yuc8f883c2014-06-20 23:25:22 -0700193 generateRsaKeyPairAsDefault(const Name& identityName, bool isKsk = false,
194 uint32_t keySize = 2048);
195
Yingdi Yu1b0311c2015-06-10 14:58:47 -0700196 /**
197 * @brief Generate a pair of ECDSA keys for the specified identity and set it as default key for
198 * the identity.
199 *
200 * @param identityName The name of the identity.
201 * @param isKsk true for generating a Key-Signing-Key (KSK), false for a Data-Signing-Key (KSK).
202 * @param keySize The size of the key.
203 * @return The generated key name.
204 * @see generateRsaKeyPair, generateEcdsaKeyPair, generateRsaKeyPairAsDefault
205 */
Yingdi Yuc8f883c2014-06-20 23:25:22 -0700206 Name
207 generateEcdsaKeyPairAsDefault(const Name& identityName, bool isKsk, uint32_t keySize = 256);
Jeff Thompson79a2d5d2013-09-27 14:32:23 -0700208
Yingdi Yu2abd73f2014-01-08 23:34:11 -0800209 /**
Yingdi Yuc55680b2014-02-26 12:31:35 -0800210 * @brief prepare an unsigned identity certificate
211 *
Alexander Afanasyev770827c2014-05-13 17:42:55 -0700212 * @param keyName Key name, e.g., `/<identity_name>/ksk-123456`.
Yingdi Yuc55680b2014-02-26 12:31:35 -0800213 * @param signingIdentity The signing identity.
214 * @param notBefore Refer to IdentityCertificate.
215 * @param notAfter Refer to IdentityCertificate.
Alexander Afanasyevb78bc4d2014-04-09 21:20:52 -0700216 * @param subjectDescription Refer to IdentityCertificate.
Yingdi Yu0eb5d722014-06-10 15:06:25 -0700217 * @param certPrefix Prefix before `KEY` component. By default, KeyChain will infer the
218 * certificate name according to the relation between the signingIdentity and
219 * the subject identity. If signingIdentity is a prefix of the subject identity,
220 * `KEY` will be inserted after the signingIdentity, otherwise `KEY` is inserted
221 * after subject identity (i.e., before `ksk-....`).
Yingdi Yuc55680b2014-02-26 12:31:35 -0800222 * @return IdentityCertificate.
223 */
224 shared_ptr<IdentityCertificate>
225 prepareUnsignedIdentityCertificate(const Name& keyName,
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700226 const Name& signingIdentity,
227 const time::system_clock::TimePoint& notBefore,
228 const time::system_clock::TimePoint& notAfter,
Yingdi Yu0eb5d722014-06-10 15:06:25 -0700229 const std::vector<CertificateSubjectDescription>& subjectDescription,
230 const Name& certPrefix = DEFAULT_PREFIX);
231
232 /**
233 * @brief prepare an unsigned identity certificate
234 *
235 * @param keyName Key name, e.g., `/<identity_name>/ksk-123456`.
236 * @param publicKey Public key to sign.
237 * @param signingIdentity The signing identity.
238 * @param notBefore Refer to IdentityCertificate.
239 * @param notAfter Refer to IdentityCertificate.
240 * @param subjectDescription Refer to IdentityCertificate.
241 * @param certPrefix Prefix before `KEY` component. By default, KeyChain will infer the
242 * certificate name according to the relation between the signingIdentity and
243 * the subject identity. If signingIdentity is a prefix of the subject identity,
244 * `KEY` will be inserted after the signingIdentity, otherwise `KEY` is inserted
245 * after subject identity (i.e., before `ksk-....`).
246 * @return IdentityCertificate.
247 */
248 shared_ptr<IdentityCertificate>
249 prepareUnsignedIdentityCertificate(const Name& keyName,
250 const PublicKey& publicKey,
251 const Name& signingIdentity,
252 const time::system_clock::TimePoint& notBefore,
253 const time::system_clock::TimePoint& notAfter,
254 const std::vector<CertificateSubjectDescription>& subjectDescription,
255 const Name& certPrefix = DEFAULT_PREFIX);
Yingdi Yuc55680b2014-02-26 12:31:35 -0800256
257 /**
Yingdi Yu1b0311c2015-06-10 14:58:47 -0700258 * @brief Sign data according to the supplied signing information
Yingdi Yu2e57a582014-02-20 23:34:43 -0800259 *
Yingdi Yu1b0311c2015-06-10 14:58:47 -0700260 * This method uses the supplied signing information @p params to create the SignatureInfo block:
261 * - it selects a private key and its certificate to sign the packet
262 * - sets the KeyLocator field with the certificate name, and
263 * - adds other requested information to the SignatureInfo block).
Yingdi Yu2e57a582014-02-20 23:34:43 -0800264 *
Yingdi Yu1b0311c2015-06-10 14:58:47 -0700265 * After that, the method assigns the created SignatureInfo to the data packets, generate a
266 * signature and sets as part of the SignatureValue block.
267 *
268 * @param data The data to sign
269 * @param params The signing parameters.
270 * @throws Error if signing fails.
271 * @see SigningInfo
Yingdi Yu2abd73f2014-01-08 23:34:11 -0800272 */
Yingdi Yu2abd73f2014-01-08 23:34:11 -0800273 void
Yingdi Yu1b0311c2015-06-10 14:58:47 -0700274 sign(Data& data, const SigningInfo& params = DEFAULT_SIGNING_INFO);
Alexander Afanasyevb78bc4d2014-04-09 21:20:52 -0700275
Jeff Thompson47c93cf2013-08-09 00:38:48 -0700276 /**
Yingdi Yu1b0311c2015-06-10 14:58:47 -0700277 * @brief Sign interest according to the supplied signing information
278 *
279 * This method uses the supplied signing information @p params to create the SignatureInfo block:
280 * - it selects a private key and its certificate to sign the packet
281 * - sets the KeyLocator field with the certificate name, and
282 * - adds other requested information to the SignatureInfo block).
283 *
284 * After that, the method appends the created SignatureInfo to the interest name, generate a
285 * signature and appends it as part of the SignatureValue block to the interest name.
286 *
287 * @param interest The interest to sign
288 * @param params The signing parameters.
289 * @throws Error if signing fails.
290 * @see SigningInfo
291 */
292 void
293 sign(Interest& interest, const SigningInfo& params = DEFAULT_SIGNING_INFO);
294
295 /**
296 * @brief Sign buffer according to the supplied signing information
297 *
298 * @param buffer The buffer to sign
299 * @param bufferLength The buffer size
300 * @param params The signing parameters.
301 * @return a SignatureValue TLV block
302 * @throws Error if signing fails.
303 * @see SigningInfo
304 */
305 Block
306 sign(const uint8_t* buffer, size_t bufferLength, const SigningInfo& params);
307
308 /**
309 * @deprecated use sign sign(T&, const SigningInfo&)
Yingdi Yu2e57a582014-02-20 23:34:43 -0800310 * @brief Sign packet with a particular certificate.
311 *
312 * @param packet The packet to be signed.
313 * @param certificateName The certificate name of the key to use for signing.
314 * @throws SecPublicInfo::Error if certificate does not exist.
Jeff Thompson3c73da42013-08-12 11:19:05 -0700315 */
Yingdi Yu2e57a582014-02-20 23:34:43 -0800316 template<typename T>
Alexander Afanasyevb78bc4d2014-04-09 21:20:52 -0700317 void
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700318 sign(T& packet, const Name& certificateName);
Alexander Afanasyevb78bc4d2014-04-09 21:20:52 -0700319
Jeff Thompson29ce3102013-09-27 11:47:48 -0700320 /**
Yingdi Yu1b0311c2015-06-10 14:58:47 -0700321 * @deprecated Use sign(const uint8_t*, size_t, const SigningInfo&) instead
Yingdi Yu2e57a582014-02-20 23:34:43 -0800322 * @brief Sign the byte array using a particular certificate.
323 *
Jeff Thompsonc01e1782013-10-21 14:08:42 -0700324 * @param buffer The byte array to be signed.
325 * @param bufferLength the length of buffer.
Yingdi Yu2e57a582014-02-20 23:34:43 -0800326 * @param certificateName The certificate name of the signing key.
Jeff Thompsonc01e1782013-10-21 14:08:42 -0700327 * @return The Signature.
Yingdi Yu2e57a582014-02-20 23:34:43 -0800328 * @throws SecPublicInfo::Error if certificate does not exist.
Jeff Thompsonc01e1782013-10-21 14:08:42 -0700329 */
Yingdi Yu2abd73f2014-01-08 23:34:11 -0800330 Signature
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700331 sign(const uint8_t* buffer, size_t bufferLength, const Name& certificateName);
Jeff Thompsonc01e1782013-10-21 14:08:42 -0700332
333 /**
Yingdi Yu1b0311c2015-06-10 14:58:47 -0700334 * @deprecated use sign sign(T&, const SigningInfo&)
Yingdi Yu2e57a582014-02-20 23:34:43 -0800335 * @brief Sign packet using the default certificate of a particular identity.
336 *
Yingdi Yu4b8c6a22014-04-15 23:00:54 -0700337 * If there is no default certificate of that identity, this method will create a self-signed
338 * certificate.
Yingdi Yu2e57a582014-02-20 23:34:43 -0800339 *
340 * @param packet The packet to be signed.
341 * @param identityName The signing identity name.
Jeff Thompson29ce3102013-09-27 11:47:48 -0700342 */
Yingdi Yu2e57a582014-02-20 23:34:43 -0800343 template<typename T>
Alexander Afanasyevb78bc4d2014-04-09 21:20:52 -0700344 void
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700345 signByIdentity(T& packet, const Name& identityName);
Alexander Afanasyevb78bc4d2014-04-09 21:20:52 -0700346
Jeff Thompson3c73da42013-08-12 11:19:05 -0700347 /**
Yingdi Yu1b0311c2015-06-10 14:58:47 -0700348 * @deprecated use sign(const uint8_t*, size_t, const SigningInfo&) instead
Yingdi Yu2e57a582014-02-20 23:34:43 -0800349 * @brief Sign the byte array using the default certificate of a particular identity.
350 *
Jeff Thompsonc01e1782013-10-21 14:08:42 -0700351 * @param buffer The byte array to be signed.
352 * @param bufferLength the length of buffer.
353 * @param identityName The identity name.
354 * @return The Signature.
355 */
Yingdi Yu7036ce22014-06-19 18:53:37 -0700356 Signature
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700357 signByIdentity(const uint8_t* buffer, size_t bufferLength, const Name& identityName);
Jeff Thompsonc01e1782013-10-21 14:08:42 -0700358
359 /**
Yingdi Yu1b0311c2015-06-10 14:58:47 -0700360 * @deprecated use sign(Data&, SigningInfo(SigningInfo::SIGNER_TYPE_SHA256))
Yingdi Yu6ab67812014-11-27 15:00:34 -0800361 * @brief Set Sha256 weak signature for @p data
Yingdi Yu21157162014-02-28 13:02:34 -0800362 */
Yingdi Yu7036ce22014-06-19 18:53:37 -0700363 void
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700364 signWithSha256(Data& data);
Yingdi Yu21157162014-02-28 13:02:34 -0800365
366 /**
Yingdi Yu1b0311c2015-06-10 14:58:47 -0700367 * @deprecated use sign(Interest&, SigningInfo(SigningInfo::SIGNER_TYPE_SHA256))
Yingdi Yu6ab67812014-11-27 15:00:34 -0800368 * @brief Set Sha256 weak signature for @p interest
369 */
370 void
371 signWithSha256(Interest& interest);
372
373 /**
Yingdi Yu2e57a582014-02-20 23:34:43 -0800374 * @brief Generate a self-signed certificate for a public key.
375 *
Alexander Afanasyev770827c2014-05-13 17:42:55 -0700376 * @param keyName The name of the public key
377 * @return The generated certificate, shared_ptr<IdentityCertificate>() if selfSign fails
Yingdi Yu2abd73f2014-01-08 23:34:11 -0800378 */
Yingdi Yu8dceb1d2014-02-18 12:45:10 -0800379 shared_ptr<IdentityCertificate>
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700380 selfSign(const Name& keyName);
Yingdi Yu2abd73f2014-01-08 23:34:11 -0800381
382 /**
Yingdi Yu2e57a582014-02-20 23:34:43 -0800383 * @brief Self-sign the supplied identity certificate.
384 *
385 * @param cert The supplied cert.
386 * @throws SecTpm::Error if the private key does not exist.
Jeff Thompson8efe5ad2013-08-20 17:36:38 -0700387 */
Jeff Thompson2ce8f492013-09-17 18:01:25 -0700388 void
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700389 selfSign(IdentityCertificate& cert);
Yingdi Yu31b4af22014-01-14 14:13:00 -0800390
Yingdi Yu2e57a582014-02-20 23:34:43 -0800391 /**
392 * @brief delete a certificate.
393 *
Yingdi Yu2e57a582014-02-20 23:34:43 -0800394 * @param certificateName The certificate to be deleted.
Yingdi Yu6147ef42014-12-08 17:48:32 -0800395 * @throws KeyChain::Error if certificate cannot be deleted.
Yingdi Yu2e57a582014-02-20 23:34:43 -0800396 */
Yingdi Yu7036ce22014-06-19 18:53:37 -0700397 void
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700398 deleteCertificate(const Name& certificateName);
Yingdi Yu28fd32f2014-01-28 19:03:03 -0800399
Yingdi Yu2e57a582014-02-20 23:34:43 -0800400 /**
401 * @brief delete a key.
402 *
Yingdi Yu2e57a582014-02-20 23:34:43 -0800403 * @param keyName The key to be deleted.
Yingdi Yu6147ef42014-12-08 17:48:32 -0800404 * @throws KeyChain::Error if key cannot be deleted.
Yingdi Yu2e57a582014-02-20 23:34:43 -0800405 */
Yingdi Yu7036ce22014-06-19 18:53:37 -0700406 void
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700407 deleteKey(const Name& keyName);
Yingdi Yu28fd32f2014-01-28 19:03:03 -0800408
Yingdi Yu2e57a582014-02-20 23:34:43 -0800409 /**
410 * @brief delete an identity.
411 *
Yingdi Yu2e57a582014-02-20 23:34:43 -0800412 * @param identity The identity to be deleted.
Yingdi Yu6147ef42014-12-08 17:48:32 -0800413 * @throws KeyChain::Error if identity cannot be deleted.
Yingdi Yu2e57a582014-02-20 23:34:43 -0800414 */
Yingdi Yu7036ce22014-06-19 18:53:37 -0700415 void
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700416 deleteIdentity(const Name& identity);
Yingdi Yu28fd32f2014-01-28 19:03:03 -0800417
Yingdi Yu2e57a582014-02-20 23:34:43 -0800418 /**
419 * @brief export an identity.
420 *
421 * @param identity The identity to export.
422 * @param passwordStr The password to secure the private key.
Yingdi Yu64c3fb42014-02-26 17:30:04 -0800423 * @return The encoded export data.
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700424 * @throws SecPublicInfo::Error if anything goes wrong in exporting.
Yingdi Yu2e57a582014-02-20 23:34:43 -0800425 */
Yingdi Yu64c3fb42014-02-26 17:30:04 -0800426 shared_ptr<SecuredBag>
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700427 exportIdentity(const Name& identity, const std::string& passwordStr);
Yingdi Yu8dceb1d2014-02-18 12:45:10 -0800428
Yingdi Yu2e57a582014-02-20 23:34:43 -0800429 /**
430 * @brief import an identity.
431 *
Yingdi Yu64c3fb42014-02-26 17:30:04 -0800432 * @param securedBag The encoded import data.
Yingdi Yu2e57a582014-02-20 23:34:43 -0800433 * @param passwordStr The password to secure the private key.
434 */
Yingdi Yu8dceb1d2014-02-18 12:45:10 -0800435 void
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700436 importIdentity(const SecuredBag& securedBag, const std::string& passwordStr);
437
438 SecPublicInfo&
439 getPib()
Yingdi Yu8dceb1d2014-02-18 12:45:10 -0800440 {
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700441 return *m_pib;
Yingdi Yu8dceb1d2014-02-18 12:45:10 -0800442 }
443
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700444 const SecPublicInfo&
445 getPib() const
446 {
447 return *m_pib;
448 }
449
450 SecTpm&
451 getTpm()
452 {
453 return *m_tpm;
454 }
455
456 const SecTpm&
457 getTpm() const
458 {
459 return *m_tpm;
460 }
461
462 /*******************************
463 * Wrapper of SecPublicInfo *
464 *******************************/
465 bool
466 doesIdentityExist(const Name& identityName) const
467 {
468 return m_pib->doesIdentityExist(identityName);
469 }
470
471 void
472 addIdentity(const Name& identityName)
473 {
474 return m_pib->addIdentity(identityName);
475 }
476
477 bool
478 doesPublicKeyExist(const Name& keyName) const
479 {
480 return m_pib->doesPublicKeyExist(keyName);
481 }
482
483 void
484 addPublicKey(const Name& keyName, KeyType keyType, const PublicKey& publicKeyDer)
485 {
Yingdi Yu41546342014-11-30 23:37:53 -0800486 return m_pib->addKey(keyName, publicKeyDer);
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700487 }
488
Yingdi Yu7036ce22014-06-19 18:53:37 -0700489 void
490 addKey(const Name& keyName, const PublicKey& publicKeyDer)
491 {
492 return m_pib->addKey(keyName, publicKeyDer);
493 }
494
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700495 shared_ptr<PublicKey>
496 getPublicKey(const Name& keyName) const
497 {
498 return m_pib->getPublicKey(keyName);
499 }
500
501 bool
502 doesCertificateExist(const Name& certificateName) const
503 {
504 return m_pib->doesCertificateExist(certificateName);
505 }
506
507 void
508 addCertificate(const IdentityCertificate& certificate)
509 {
510 return m_pib->addCertificate(certificate);
511 }
512
513 shared_ptr<IdentityCertificate>
514 getCertificate(const Name& certificateName) const
515 {
516 return m_pib->getCertificate(certificateName);
517 }
518
519 Name
520 getDefaultIdentity() const
521 {
522 return m_pib->getDefaultIdentity();
523 }
524
525 Name
526 getDefaultKeyNameForIdentity(const Name& identityName) const
527 {
528 return m_pib->getDefaultKeyNameForIdentity(identityName);
529 }
530
531 Name
532 getDefaultCertificateNameForKey(const Name& keyName) const
533 {
534 return m_pib->getDefaultCertificateNameForKey(keyName);
535 }
536
537 void
538 getAllIdentities(std::vector<Name>& nameList, bool isDefault) const
539 {
540 return m_pib->getAllIdentities(nameList, isDefault);
541 }
542
543 void
544 getAllKeyNames(std::vector<Name>& nameList, bool isDefault) const
545 {
546 return m_pib->getAllKeyNames(nameList, isDefault);
547 }
548
549 void
550 getAllKeyNamesOfIdentity(const Name& identity, std::vector<Name>& nameList, bool isDefault) const
551 {
552 return m_pib->getAllKeyNamesOfIdentity(identity, nameList, isDefault);
553 }
554
555 void
556 getAllCertificateNames(std::vector<Name>& nameList, bool isDefault) const
557 {
558 return m_pib->getAllCertificateNames(nameList, isDefault);
559 }
560
561 void
562 getAllCertificateNamesOfKey(const Name& keyName,
563 std::vector<Name>& nameList,
564 bool isDefault) const
565 {
566 return m_pib->getAllCertificateNamesOfKey(keyName, nameList, isDefault);
567 }
568
569 void
570 deleteCertificateInfo(const Name& certificateName)
571 {
572 return m_pib->deleteCertificateInfo(certificateName);
573 }
574
575 void
576 deletePublicKeyInfo(const Name& keyName)
577 {
578 return m_pib->deletePublicKeyInfo(keyName);
579 }
580
581 void
582 deleteIdentityInfo(const Name& identity)
583 {
584 return m_pib->deleteIdentityInfo(identity);
585 }
586
587 void
588 setDefaultIdentity(const Name& identityName)
589 {
590 return m_pib->setDefaultIdentity(identityName);
591 }
592
593 void
594 setDefaultKeyNameForIdentity(const Name& keyName)
595 {
596 return m_pib->setDefaultKeyNameForIdentity(keyName);
597 }
598
599 void
600 setDefaultCertificateNameForKey(const Name& certificateName)
601 {
602 return m_pib->setDefaultCertificateNameForKey(certificateName);
603 }
604
605 Name
606 getNewKeyName(const Name& identityName, bool useKsk)
607 {
608 return m_pib->getNewKeyName(identityName, useKsk);
609 }
610
611 Name
612 getDefaultCertificateNameForIdentity(const Name& identityName) const
613 {
614 return m_pib->getDefaultCertificateNameForIdentity(identityName);
615 }
616
617 Name
618 getDefaultCertificateName() const
619 {
620 return m_pib->getDefaultCertificateName();
621 }
622
623 void
624 addCertificateAsKeyDefault(const IdentityCertificate& certificate)
625 {
626 return m_pib->addCertificateAsKeyDefault(certificate);
627 }
628
629 void
630 addCertificateAsIdentityDefault(const IdentityCertificate& certificate)
631 {
632 return m_pib->addCertificateAsIdentityDefault(certificate);
633 }
634
635 void
636 addCertificateAsSystemDefault(const IdentityCertificate& certificate)
637 {
638 return m_pib->addCertificateAsSystemDefault(certificate);
639 }
640
641 shared_ptr<IdentityCertificate>
642 getDefaultCertificate() const
643 {
Alexander Afanasyevaab79662014-07-07 17:35:34 -0700644 if (!static_cast<bool>(m_pib->getDefaultCertificate()))
645 const_cast<KeyChain*>(this)->setDefaultCertificateInternal();
646
647 return m_pib->getDefaultCertificate();
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700648 }
649
650 void
651 refreshDefaultCertificate()
652 {
653 return m_pib->refreshDefaultCertificate();
654 }
655
656 /*******************************
657 * Wrapper of SecTpm *
658 *******************************/
659
660 void
661 setTpmPassword(const uint8_t* password, size_t passwordLength)
662 {
663 return m_tpm->setTpmPassword(password, passwordLength);
664 }
665
666 void
667 resetTpmPassword()
668 {
669 return m_tpm->resetTpmPassword();
670 }
671
672 void
673 setInTerminal(bool inTerminal)
674 {
675 return m_tpm->setInTerminal(inTerminal);
676 }
677
678 bool
679 getInTerminal() const
680 {
681 return m_tpm->getInTerminal();
682 }
683
684 bool
685 isLocked() const
686 {
687 return m_tpm->isLocked();
688 }
689
690 bool
691 unlockTpm(const char* password, size_t passwordLength, bool usePassword)
692 {
693 return m_tpm->unlockTpm(password, passwordLength, usePassword);
694 }
695
696 void
Yingdi Yu7036ce22014-06-19 18:53:37 -0700697 generateKeyPairInTpm(const Name& keyName, const KeyParams& params)
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700698 {
Yingdi Yu7036ce22014-06-19 18:53:37 -0700699 return m_tpm->generateKeyPairInTpm(keyName, params);
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700700 }
701
702 void
703 deleteKeyPairInTpm(const Name& keyName)
704 {
705 return m_tpm->deleteKeyPairInTpm(keyName);
706 }
707
708 shared_ptr<PublicKey>
709 getPublicKeyFromTpm(const Name& keyName) const
710 {
711 return m_tpm->getPublicKeyFromTpm(keyName);
712 }
713
714 Block
715 signInTpm(const uint8_t* data, size_t dataLength,
716 const Name& keyName,
717 DigestAlgorithm digestAlgorithm)
718 {
719 return m_tpm->signInTpm(data, dataLength, keyName, digestAlgorithm);
720 }
721
722 ConstBufferPtr
723 decryptInTpm(const uint8_t* data, size_t dataLength, const Name& keyName, bool isSymmetric)
724 {
725 return m_tpm->decryptInTpm(data, dataLength, keyName, isSymmetric);
726 }
727
728 ConstBufferPtr
729 encryptInTpm(const uint8_t* data, size_t dataLength, const Name& keyName, bool isSymmetric)
730 {
731 return m_tpm->encryptInTpm(data, dataLength, keyName, isSymmetric);
732 }
733
734 void
Yingdi Yu7036ce22014-06-19 18:53:37 -0700735 generateSymmetricKeyInTpm(const Name& keyName, const KeyParams& params)
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700736 {
Yingdi Yu7036ce22014-06-19 18:53:37 -0700737 return m_tpm->generateSymmetricKeyInTpm(keyName, params);
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700738 }
739
740 bool
741 doesKeyExistInTpm(const Name& keyName, KeyClass keyClass) const
742 {
743 return m_tpm->doesKeyExistInTpm(keyName, keyClass);
744 }
745
746 bool
747 generateRandomBlock(uint8_t* res, size_t size) const
748 {
749 return m_tpm->generateRandomBlock(res, size);
750 }
751
752 void
753 addAppToAcl(const Name& keyName, KeyClass keyClass, const std::string& appPath, AclType acl)
754 {
755 return m_tpm->addAppToAcl(keyName, keyClass, appPath, acl);
756 }
757
758 ConstBufferPtr
759 exportPrivateKeyPkcs5FromTpm(const Name& keyName, const std::string& password)
760 {
761 return m_tpm->exportPrivateKeyPkcs5FromTpm(keyName, password);
762 }
763
764 bool
765 importPrivateKeyPkcs5IntoTpm(const Name& keyName,
766 const uint8_t* buf, size_t size,
767 const std::string& password)
768 {
769 return m_tpm->importPrivateKeyPkcs5IntoTpm(keyName, buf, size, password);
770 }
Jeff Thompson8efe5ad2013-08-20 17:36:38 -0700771
Yingdi Yu2abd73f2014-01-08 23:34:11 -0800772private:
Yingdi Yu41546342014-11-30 23:37:53 -0800773 void
Alexander Afanasyev07113802015-01-15 19:14:36 -0800774 initialize(const std::string& pibLocatorUri,
775 const std::string& tpmLocatorUri,
Yingdi Yu41546342014-11-30 23:37:53 -0800776 bool needReset);
777
Yingdi Yu2e57a582014-02-20 23:34:43 -0800778 /**
Yingdi Yu1b0311c2015-06-10 14:58:47 -0700779 * @brief Prepare a SignatureInfo TLV according to signing information and return the signing key name
Yingdi Yuc8f883c2014-06-20 23:25:22 -0700780 *
Yingdi Yu1b0311c2015-06-10 14:58:47 -0700781 * @param params The signing parameters.
782 * @return The signing key name and prepared SignatureInfo.
783 * @throw Error when the requested signing method cannot be satisfied.
Yingdi Yuc8f883c2014-06-20 23:25:22 -0700784 */
Yingdi Yu1b0311c2015-06-10 14:58:47 -0700785 std::tuple<Name, SignatureInfo>
786 prepareSignatureInfo(const SigningInfo& params);
787
788 /**
789 * @brief Internal abstraction of packet signing.
790 *
791 * @param packet The packet to sign
792 * @param params The signing parameters.
793 * @throw Error when the signing fails.
794 */
795 template<typename T>
796 void
797 signImpl(T& packet, const SigningInfo& params);
Yingdi Yuc8f883c2014-06-20 23:25:22 -0700798
799 /**
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700800 * @brief Set default certificate if it is not initialized
801 */
802 void
803 setDefaultCertificateInternal();
804
805 /**
Yingdi Yu2e57a582014-02-20 23:34:43 -0800806 * @brief Generate a key pair for the specified identity.
807 *
Yingdi Yu2abd73f2014-01-08 23:34:11 -0800808 * @param identityName The name of the specified identity.
809 * @param isKsk true for generating a Key-Signing-Key (KSK), false for a Data-Signing-Key (KSK).
Yingdi Yu7036ce22014-06-19 18:53:37 -0700810 * @param params The parameter of the key.
Yingdi Yu2abd73f2014-01-08 23:34:11 -0800811 * @return The name of the generated key.
812 */
Yingdi Yu7036ce22014-06-19 18:53:37 -0700813 Name
Yingdi Yu4b8c6a22014-04-15 23:00:54 -0700814 generateKeyPair(const Name& identityName, bool isKsk = false,
Yingdi Yu7036ce22014-06-19 18:53:37 -0700815 const KeyParams& params = DEFAULT_KEY_PARAMS);
Yingdi Yu2abd73f2014-01-08 23:34:11 -0800816
Yingdi Yu8726f652014-01-23 10:35:12 -0800817 /**
Yingdi Yu2e57a582014-02-20 23:34:43 -0800818 * @brief Sign the data using a particular key.
819 *
820 * @param data Reference to the data packet.
821 * @param signature Signature to be added.
Yingdi Yu8726f652014-01-23 10:35:12 -0800822 * @param keyName The name of the signing key.
823 * @param digestAlgorithm the digest algorithm.
824 * @throws Tpm::Error
Alexander Afanasyevb78bc4d2014-04-09 21:20:52 -0700825 */
Yingdi Yu7036ce22014-06-19 18:53:37 -0700826 void
Yingdi Yuc8f883c2014-06-20 23:25:22 -0700827 signPacketWrapper(Data& data, const Signature& signature,
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700828 const Name& keyName, DigestAlgorithm digestAlgorithm);
Yingdi Yu8726f652014-01-23 10:35:12 -0800829
Yingdi Yu2e57a582014-02-20 23:34:43 -0800830 /**
831 * @brief Sign the interest using a particular key.
832 *
833 * @param interest Reference to the interest packet.
834 * @param signature Signature to be added.
835 * @param keyName The name of the signing key.
836 * @param digestAlgorithm the digest algorithm.
837 * @throws Tpm::Error
Alexander Afanasyevb78bc4d2014-04-09 21:20:52 -0700838 */
Yingdi Yu7036ce22014-06-19 18:53:37 -0700839 void
Yingdi Yuc8f883c2014-06-20 23:25:22 -0700840 signPacketWrapper(Interest& interest, const Signature& signature,
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700841 const Name& keyName, DigestAlgorithm digestAlgorithm);
Yingdi Yu2e57a582014-02-20 23:34:43 -0800842
Yingdi Yu1b0311c2015-06-10 14:58:47 -0700843 /**
844 * @brief Generate a SignatureValue block for a buffer @p buf with size @p size using
845 * a key with name @p keyName and digest algorithm @p digestAlgorithm.
846 */
847 Block
848 pureSign(const uint8_t* buf, size_t size, const Name& keyName, DigestAlgorithm digestAlgorithm) const;
849
Alexander Afanasyev07113802015-01-15 19:14:36 -0800850 static void
Alexander Afanasyev34a37632015-01-16 17:37:36 -0800851 registerPibImpl(const std::string& canonicalName,
852 std::initializer_list<std::string> aliases, PibCreateFunc createFunc);
Alexander Afanasyev07113802015-01-15 19:14:36 -0800853
854 static void
Alexander Afanasyev34a37632015-01-16 17:37:36 -0800855 registerTpmImpl(const std::string& canonicalName,
856 std::initializer_list<std::string> aliases, TpmCreateFunc createFunc);
Alexander Afanasyev07113802015-01-15 19:14:36 -0800857
Yingdi Yu41546342014-11-30 23:37:53 -0800858public:
Yingdi Yu1b0311c2015-06-10 14:58:47 -0700859 static tlv::SignatureTypeValue
860 getSignatureType(KeyType keyType, DigestAlgorithm digestAlgorithm);
861
862public:
Yingdi Yu41546342014-11-30 23:37:53 -0800863 static const Name DEFAULT_PREFIX;
Yingdi Yu1b0311c2015-06-10 14:58:47 -0700864 static const SigningInfo DEFAULT_SIGNING_INFO;
865
866 /**
867 * @brief A localhost identity which indicates that signature is generated using SHA-256.
868 * @todo Passing this as identity is not implemented.
869 */
870 static const Name DIGEST_SHA256_IDENTITY;
871
Yingdi Yu41546342014-11-30 23:37:53 -0800872 // RsaKeyParams is set to be default for backward compatibility.
873 static const RsaKeyParams DEFAULT_KEY_PARAMS;
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700874
Yingdi Yu1b0311c2015-06-10 14:58:47 -0700875 typedef std::map<std::string, Block> SignParams;
876
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700877private:
Alexander Afanasyev07113802015-01-15 19:14:36 -0800878 std::unique_ptr<SecPublicInfo> m_pib;
879 std::unique_ptr<SecTpm> m_tpm;
Yingdi Yu0f5fb692014-06-10 12:07:28 -0700880 time::milliseconds m_lastTimestamp;
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700881};
882
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700883template<typename T>
884void
Yingdi Yu1b0311c2015-06-10 14:58:47 -0700885KeyChain::signImpl(T& packet, const SigningInfo& params)
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700886{
Yingdi Yu1b0311c2015-06-10 14:58:47 -0700887 Name keyName;
888 SignatureInfo sigInfo;
889 std::tie(keyName, sigInfo) = prepareSignatureInfo(params);
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700890
Yingdi Yu1b0311c2015-06-10 14:58:47 -0700891 signPacketWrapper(packet, Signature(sigInfo),
892 keyName, params.getDigestAlgorithm());
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700893}
894
895template<typename T>
896void
897KeyChain::sign(T& packet, const Name& certificateName)
898{
Yingdi Yu1b0311c2015-06-10 14:58:47 -0700899 signImpl(packet, SigningInfo(SigningInfo::SIGNER_TYPE_CERT, certificateName));
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700900}
901
902template<typename T>
903void
904KeyChain::signByIdentity(T& packet, const Name& identityName)
905{
Yingdi Yu1b0311c2015-06-10 14:58:47 -0700906 signImpl(packet, SigningInfo(SigningInfo::SIGNER_TYPE_ID, identityName));
Yingdi Yuf56c68f2014-04-24 21:50:13 -0700907}
908
Alexander Afanasyev07113802015-01-15 19:14:36 -0800909template<class PibType>
910inline void
Alexander Afanasyev34a37632015-01-16 17:37:36 -0800911KeyChain::registerPib(std::initializer_list<std::string> aliases)
Alexander Afanasyev07113802015-01-15 19:14:36 -0800912{
Alexander Afanasyev34a37632015-01-16 17:37:36 -0800913 registerPibImpl(*aliases.begin(), aliases, [] (const std::string& locator) {
Alexander Afanasyev07113802015-01-15 19:14:36 -0800914 return unique_ptr<SecPublicInfo>(new PibType(locator));
915 });
916}
917
918template<class TpmType>
919inline void
Alexander Afanasyev34a37632015-01-16 17:37:36 -0800920KeyChain::registerTpm(std::initializer_list<std::string> aliases)
Alexander Afanasyev07113802015-01-15 19:14:36 -0800921{
Alexander Afanasyev34a37632015-01-16 17:37:36 -0800922 registerTpmImpl(*aliases.begin(), aliases, [] (const std::string& locator) {
Alexander Afanasyev07113802015-01-15 19:14:36 -0800923 return unique_ptr<SecTpm>(new TpmType(locator));
924 });
925}
926
927/**
928 * \brief Register SecPib class in ndn-cxx KeyChain
929 *
930 * This macro should be placed once in the implementation file of the
931 * SecPib type within the namespace where the type is declared.
932 */
Alexander Afanasyev34a37632015-01-16 17:37:36 -0800933#define NDN_CXX_KEYCHAIN_REGISTER_PIB(PibType, ...) \
Alexander Afanasyev07113802015-01-15 19:14:36 -0800934static class NdnCxxAuto ## PibType ## PibRegistrationClass \
935{ \
936public: \
937 NdnCxxAuto ## PibType ## PibRegistrationClass() \
938 { \
939 ::ndn::KeyChain::registerPib<PibType>({__VA_ARGS__}); \
940 } \
941} ndnCxxAuto ## PibType ## PibRegistrationVariable
942
943/**
944 * \brief Register SecTpm class in ndn-cxx KeyChain
945 *
946 * This macro should be placed once in the implementation file of the
947 * SecTpm type within the namespace where the type is declared.
948 */
Alexander Afanasyev34a37632015-01-16 17:37:36 -0800949#define NDN_CXX_KEYCHAIN_REGISTER_TPM(TpmType, ...) \
Alexander Afanasyev07113802015-01-15 19:14:36 -0800950static class NdnCxxAuto ## TpmType ## TpmRegistrationClass \
951{ \
952public: \
953 NdnCxxAuto ## TpmType ## TpmRegistrationClass() \
954 { \
955 ::ndn::KeyChain::registerTpm<TpmType>({__VA_ARGS__}); \
956 } \
957} ndnCxxAuto ## TpmType ## TpmRegistrationVariable
958
Yingdi Yu1b0311c2015-06-10 14:58:47 -0700959} // namespace security
960
961using security::KeyChain;
962
Yingdi Yu6ab67812014-11-27 15:00:34 -0800963} // namespace ndn
Jeff Thompson47c93cf2013-08-09 00:38:48 -0700964
Alexander Afanasyev766cea72014-04-24 19:16:42 -0700965#endif // NDN_SECURITY_KEY_CHAIN_HPP