signing-info.hpp

Go to the documentation of this file.

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

#include "../name.hpp"
#include "../signature-info.hpp"
#include "pib/identity.hpp"
#include "pib/key.hpp"
#include "security-common.hpp"

namespace ndn {
namespace security {

class SigningInfo
{
public:
  class Error : public std::runtime_error
  {
  public:
    explicit
    Error(const std::string& what)
      : std::runtime_error(what)
    {
    }
  };

  enum SignerType {
    SIGNER_TYPE_NULL = 0,
    SIGNER_TYPE_ID = 1,
    SIGNER_TYPE_KEY = 2,
    SIGNER_TYPE_CERT = 3,
    SIGNER_TYPE_SHA256 = 4,
  };

public:
  explicit
  SigningInfo(SignerType signerType = SIGNER_TYPE_NULL,
              const Name& signerName = getEmptyName(),
              const SignatureInfo& signatureInfo = getEmptySignatureInfo());

  explicit
  SigningInfo(const Identity& identity);

  explicit
  SigningInfo(const Key& key);

  explicit
  SigningInfo(const std::string& signingStr);

  SigningInfo&
  setSigningIdentity(const Name& identity);

  SigningInfo&
  setSigningKeyName(const Name& keyName);

  SigningInfo&
  setSigningCertName(const Name& certificateName);

  SigningInfo&
  setSha256Signing();

  SigningInfo&
  setPibIdentity(const Identity& identity);

  SigningInfo&
  setPibKey(const Key& key);

  SignerType
  getSignerType() const
  {
    return m_type;
  }

  const Name&
  getSignerName() const
  {
    return m_name;
  }

  const Identity&
  getPibIdentity() const
  {
    BOOST_ASSERT(m_type == SIGNER_TYPE_ID);
    return m_identity;
  }

  const Key&
  getPibKey() const
  {
    BOOST_ASSERT(m_type == SIGNER_TYPE_KEY);
    return m_key;
  }

  SigningInfo&
  setDigestAlgorithm(const DigestAlgorithm& algorithm)
  {
    m_digestAlgorithm = algorithm;
    return *this;
  }

  DigestAlgorithm
  getDigestAlgorithm() const
  {
    return m_digestAlgorithm;
  }

  SigningInfo&
  setSignatureInfo(const SignatureInfo& signatureInfo);

  const SignatureInfo&
  getSignatureInfo() const
  {
    return m_info;
  }

public:
  static const Name&
  getEmptyName();

  static const SignatureInfo&
  getEmptySignatureInfo();

  static const Name&
  getDigestSha256Identity();

  bool
  operator==(const SigningInfo& rhs) const;

  bool
  operator!=(const SigningInfo& rhs) const
  {
    return !(*this == rhs);
  }

private:
  SignerType m_type;
  Name m_name;
  Identity m_identity;
  Key m_key;
  DigestAlgorithm m_digestAlgorithm;
  SignatureInfo m_info;
};

std::ostream&
operator<<(std::ostream& os, const SigningInfo& si);

} // namespace security
} // namespace ndn

#endif // NDN_SECURITY_SIGNING_INFO_HPP