certificate.hpp

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil -*- */
#ifndef NDN_CERTIFICATE_HPP
#define NDN_CERTIFICATE_HPP

#include "../../data.hpp"
#include "../../common.hpp"
#include "../../sha256-with-rsa-signature.hpp"

#include "certificate-subject-description.hpp"
#include "certificate-extension.hpp"
#include "public-key.hpp"

namespace ndn {

typedef std::vector<CertificateSubjectDescription> SubjectDescriptionList;
typedef std::vector<CertificateExtension> ExtensionList;

class Certificate : public Data {
public:
  Certificate();

  Certificate(const Data& data);

  virtual
  ~Certificate();

  void
  encode();

  virtual void
  wireDecode
    (const Blob& input,
     WireFormat& wireFormat = *WireFormat::getDefaultWireFormat());

  void
  addSubjectDescription(const CertificateSubjectDescription& description) { subjectDescriptionList_.push_back(description); }

  const SubjectDescriptionList&
  getSubjectDescriptionList() const { return subjectDescriptionList_; }

  SubjectDescriptionList&
  getSubjectDescriptionList() { return subjectDescriptionList_; }

  void
  addExtension(const CertificateExtension& extension) { extensionList_.push_back(extension); }

  const ExtensionList&
  getExtensionList() const { return extensionList_; }

  ExtensionList&
  getExtensionList() { return extensionList_; }

  void
  setNotBefore(const MillisecondsSince1970& notBefore) { notBefore_ = notBefore; }

  MillisecondsSince1970&
  getNotBefore() { return notBefore_; }

  const MillisecondsSince1970&
  getNotBefore() const { return notBefore_; }

  void
  setNotAfter(const MillisecondsSince1970& notAfter) { notAfter_ = notAfter; }

  MillisecondsSince1970&
  getNotAfter() { return notAfter_; }

  const MillisecondsSince1970&
  getNotAfter() const { return notAfter_; }

  void
  setPublicKeyInfo(const PublicKey& key) { key_ = key; }

  PublicKey&
  getPublicKeyInfo() { return key_; }

  const PublicKey&
  getPublicKeyInfo() const { return key_; }

  const Blob&
  getPublicKeyDer() const;

  bool
  isTooEarly() const;

  bool
  isTooLate() const;

  bool
  isInValidityPeriod(MillisecondsSince1970 time) const
  {
    // Debug: Generalize this from Sha256WithRsaSignature.
    return dynamic_cast<const Sha256WithRsaSignature *>
      (getSignature())->getValidityPeriod().isValid(time);
  }

  void
  printCertificate(std::ostream& os) const;

  void
  printCertificate() const;

protected:
  void
  decode();

  SubjectDescriptionList subjectDescriptionList_;
  MillisecondsSince1970 notBefore_;
  MillisecondsSince1970 notAfter_;
  PublicKey key_;
  ExtensionList extensionList_;

private:
  ptr_lib::shared_ptr<DerNode>
  toDer();
};

}

#endif