certificate.hpp

Go to the documentation of this file.

#ifndef NDNPH_KEYCHAIN_CERTIFICATE_HPP
#define NDNPH_KEYCHAIN_CERTIFICATE_HPP
 
#include "../packet/data.hpp"
#include "helper.hpp"
#include "validity-period.hpp"
 
namespace ndnph {
namespace certificate {
 
inline Component
getKeyComponent() {
  static const uint8_t tlv[]{0x08, 0x03, 'K', 'E', 'Y'};
  static const Component comp = Component::constant(tlv, sizeof(tlv));
  return comp;
}
getKeyComponent() {…}
 
inline Component
getIssuerDefault() {
  static const uint8_t tlv[]{0x08, 0x05, 'N', 'D', 'N', 'p', 'h'};
  static const Component comp = Component::constant(tlv, sizeof(tlv));
  return comp;
}
getIssuerDefault() {…}
 
inline Component
getIssuerSelf() {
  static const uint8_t tlv[]{0x08, 0x04, 's', 'e', 'l', 'f'};
  static const Component comp = Component::constant(tlv, sizeof(tlv));
  return comp;
}
getIssuerSelf() {…}
 
inline bool
isKeyName(const Name& name) {
  return name[-2] == getKeyComponent();
}
isKeyName(const Name& name) {…}
 
inline bool
isCertName(const Name& name) {
  return name[-4] == getKeyComponent();
}
isCertName(const Name& name) {…}
 
inline Name
toSubjectName(Region& region, const Name& input, bool mustCopy = false) {
  Name result;
  if (isKeyName(input)) {
    result = input.getPrefix(-2);
  } else if (isCertName(input)) {
    result = input.getPrefix(-4);
  } else {
    result = input;
  }
 
  if (mustCopy) {
    return result.clone(region);
  }
  return result;
}
toSubjectName(Region& region, const Name& input, bool mustCopy = false) {…}
 
inline Name
toKeyName(Region& region, const Name& input, bool mustCopy = false) {
  Name result;
  if (isKeyName(input)) {
    result = input;
  } else if (isCertName(input)) {
    result = input.getPrefix(-2);
  } else {
    return input.append(region, getKeyComponent(), convention::GenericNumber(),
                        convention::RandomValue());
  }
 
  if (mustCopy) {
    return result.clone(region);
  }
  return result;
}
toKeyName(Region& region, const Name& input, bool mustCopy = false) {…}
 
inline Name
toCertName(Region& region, const Name& input, bool mustCopy = false) {
  if (isCertName(input)) {
    if (mustCopy) {
      return input.clone(region);
    }
    return input;
  }
 
  if (isKeyName(input)) {
    return input.append(region, getIssuerDefault(), convention::Version(), convention::TimeValue());
  }
 
  return input.append(region, getKeyComponent(), convention::GenericNumber(),
                      convention::RandomValue(), getIssuerDefault(), convention::Version(),
                      convention::TimeValue());
}
toCertName(Region& region, const Name& input, bool mustCopy = false) {…}
 
inline Name
makeKeyName(Region& region, const Name& input, const Component& keyId) {
  return toSubjectName(region, input).append(region, getKeyComponent(), keyId);
}
makeKeyName(Region& region, const Name& input, const Component& keyId) {…}
 
inline Name
makeCertName(Region& region, const Name& input, const Component& issuerId,
             const Component& version) {
  return toKeyName(region, input).append(region, issuerId, version);
}
makeCertName(Region& region, const Name& input, const Component& issuerId, {…}
 
inline Name
makeCertName(Region& region, const Name& input, const Component& issuerId, uint64_t version = 0) {
  return toKeyName(region, input)
    .append(region, issuerId, convention::Version(), convention::TimeValue(version));
}
makeCertName(Region& region, const Name& input, const Component& issuerId, uint64_t version = 0) {…}
 
inline bool
isCertificate(const Data& data) {
  return data && data.getContentType() == ContentType::Key && isCertName(data.getName());
}
isCertificate(const Data& data) {…}
 
inline Name
getIssuer(const Data& data) {
  const DSigInfo* sigInfo = data.getSigInfo();
  if (sigInfo != nullptr) {
    return sigInfo->name;
  }
  return Name();
}
getIssuer(const Data& data) {…}
 
inline ValidityPeriod
getValidity(const Data& data) {
  ValidityPeriod vp;
 
  const DSigInfo* sigInfo = data.getSigInfo();
  if (sigInfo == nullptr) {
    return vp;
  }
 
  auto decoder = sigInfo->extensions.makeDecoder();
  for (const auto& tlv : decoder) {
    if (vp.decodeFrom(tlv)) {
      return vp;
    }
  }
 
  return ValidityPeriod();
}
getValidity(const Data& data) {…}
 
} // namespace certificate
namespace certificate {…}
namespace detail {
 
template<typename Signer, typename Modify>
Data::Signed
buildCertificate(Region& region, const Name& name, const ValidityPeriod& validity,
                 const Signer& signer, const Modify& modify) {
  auto data = region.create<Data>();
  if (!data) {
    return Data::Signed();
  }
  data.setName(certificate::toCertName(region, name));
  data.setContentType(ContentType::Key);
  data.setFreshnessPeriod(3600000);
 
  DSigInfo si;
  {
    Encoder encoder(region);
    encoder.prepend(validity);
    si.extensions = tlv::Value(encoder);
    encoder.trim();
  }
 
  if (!modify(data)) {
    return Data::Signed();
  }
  return data.sign(signer, std::move(si));
}
buildCertificate(Region& region, const Name& name, const ValidityPeriod& validity, {…}
 
} // namespace detail
} // namespace ndnph
 
#endif // NDNPH_KEYCHAIN_CERTIFICATE_HPP