certificate.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "ndn/common.hpp"
#include "ndn/data.hpp"
#include "ndn/name.hpp"
 
namespace ndn {
 
constexpr size_t VALIDITY_TIMESTAMP_SIZE = 15;
 
constexpr size_t CERTIFICATE_MAX_KEY_SIZE = 256;
 
class ValidityPeriod {
public:
    ValidityPeriod() = default;
 
    static Result<ValidityPeriod> fromStrings(std::string_view notBefore,
                                              std::string_view notAfter);
 
    static Result<ValidityPeriod> fromWire(const uint8_t* buf, size_t len,
                                           size_t* bytesRead = nullptr);
 
    Error encode(uint8_t* buf, size_t bufSize, size_t& encodedLen) const;
 
    Error setNotBefore(uint16_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute,
                       uint8_t second);
 
    Error setNotBefore(std::string_view timestamp);
 
    const char* notBefore() const { return notBefore_.data(); }
    Error setNotAfter(uint16_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute,
                      uint8_t second);
 
    Error setNotAfter(std::string_view timestamp);
 
    const char* notAfter() const { return notAfter_.data(); }
    bool isValidAt(std::string_view currentTimestamp) const;
 
    bool equals(const ValidityPeriod& other) const;
 
private:
    std::array<char, VALIDITY_TIMESTAMP_SIZE> notBefore_{};
    std::array<char, VALIDITY_TIMESTAMP_SIZE> notAfter_{};
};
 
class Certificate {
public:
    Certificate() = default;
 
    static Result<Certificate> fromData(const Data& data);
 
    static Result<Certificate> fromWire(const uint8_t* buf, size_t len);
 
    Error toData(Data& data) const;
 
    Error encode(uint8_t* buf, size_t bufSize, size_t& encodedLen) const;
 
    const Name& identityName() const { return identityName_; }
 
    Certificate& setIdentityName(const Name& name);
 
    Error setIdentityName(std::string_view uri);
    const uint8_t* keyId() const { return keyId_.data(); }
 
    size_t keyIdSize() const { return keyIdSize_; }
 
    Error setKeyId(const uint8_t* id, size_t len);
    const uint8_t* issuerId() const { return issuerId_.data(); }
 
    size_t issuerIdSize() const { return issuerIdSize_; }
 
    Error setIssuerId(const uint8_t* id, size_t len);
 
    Error setIssuerId(std::string_view id);
    uint64_t version() const { return version_; }
 
    Certificate& setVersion(uint64_t version);
    const uint8_t* publicKey() const { return publicKey_.data(); }
 
    size_t publicKeySize() const { return publicKeySize_; }
 
    Error setPublicKey(const uint8_t* key, size_t len);
    const ValidityPeriod& validity() const { return validity_; }
 
    ValidityPeriod& validity() { return validity_; }
 
    Certificate& setValidity(const ValidityPeriod& validity);
    SignatureType signatureType() const { return signatureType_; }
 
    Certificate& setSignatureType(SignatureType type);
 
    Error signWithDigestSha256();
 
    Error signWithHmac(const uint8_t* key, size_t keyLen);
 
    bool verifyDigestSha256() const;
 
    bool verifyHmac(const uint8_t* key, size_t keyLen) const;
    Error buildName(Name& name) const;
 
    bool isValidAt(std::string_view timestamp) const;
 
private:
    Error encodeSignedPortion(uint8_t* buf, size_t bufSize, size_t& encodedLen) const;
 
    Name identityName_;                                          
    std::array<uint8_t, 32> keyId_{};                            
    size_t keyIdSize_ = 0;                                       
    std::array<uint8_t, 32> issuerId_{};                         
    size_t issuerIdSize_ = 0;                                    
    uint64_t version_ = 0;                                       
    std::array<uint8_t, CERTIFICATE_MAX_KEY_SIZE> publicKey_{};  
    size_t publicKeySize_ = 0;                                   
    ValidityPeriod validity_;                                    
    SignatureType signatureType_ = SignatureType::DigestSha256;  
    std::array<uint8_t, SIGNATURE_MAX_SIZE> signatureValue_{};   
    size_t signatureSize_ = 0;                                   
};
 
}  // namespace ndn