sig-info.hpp

Go to the documentation of this file.

#ifndef NDNPH_PACKET_SIG_INFO_HPP
#define NDNPH_PACKET_SIG_INFO_HPP
 
#include "../port/random/port.hpp"
#include "../port/unixtime/port.hpp"
#include "../tlv/ev-decoder.hpp"
#include "name.hpp"
 
namespace ndnph {
 
class SigInfo {
public:
  bool decodeFrom(const Decoder::Tlv& input) {
    return EvDecoder::decodeEx(
      input, {TT::ISigInfo, TT::DSigInfo},
      [this, &input](const Decoder::Tlv& d, int& currentOrder) {
        if (currentOrder < 1000) {
          extensions = tlv::Value(d.tlv, input.value + input.length);
          currentOrder = 1000;
        }
        return true;
      },
      EvDecoder::DefaultIsCritical(), EvDecoder::defNni<TT::SigType, tlv::NNI, 1>(&sigType),
      EvDecoder::def<TT::KeyLocator, false, 2>([this](const Decoder::Tlv& d) {
        return EvDecoder::decode(d, {}, EvDecoder::def<TT::Name>(&name));
      }));
  }
  bool decodeFrom(const Decoder::Tlv& input) {…}
 
protected:
  ~SigInfo() = default;
 
  void encodeImpl(uint32_t type, Encoder& encoder) const {
    encoder.prependTlv(
      type, tlv::NniElement<>(TT::SigType, sigType),
      [this](Encoder& encoder) {
        if (name.size() > 0) {
          encoder.prependTlv(TT::KeyLocator, name);
        }
      },
      extensions);
  }
  void encodeImpl(uint32_t type, Encoder& encoder) const  {…}
 
public:
  Name name;
  tlv::Value extensions;
  uint8_t sigType = 0;
};
class SigInfo {…};
 
class ISigInfo : public SigInfo {
public:
  void encodeTo(Encoder& encoder) const {
    return encodeImpl(TT::ISigInfo, encoder);
  }
  void encodeTo(Encoder& encoder) const  {…}
};
class ISigInfo : public SigInfo {…};
 
class DSigInfo : public SigInfo {
public:
  void encodeTo(Encoder& encoder) const {
    return encodeImpl(TT::DSigInfo, encoder);
  }
  void encodeTo(Encoder& encoder) const  {…}
};
class DSigInfo : public SigInfo {…};
 
namespace isig {
 
class Fields {
public:
  bool decode(const ISigInfo& si) {
    return EvDecoder::decodeValue(si.extensions.makeDecoder(), EvDecoder::def<TT::SigNonce>(&nonce),
                                  EvDecoder::defNni<TT::SigTime>(&timestamp),
                                  EvDecoder::defNni<TT::SigSeqNum>(&seqNum));
  }
  bool decode(const ISigInfo& si) {…}
 
public:
  tlv::Value nonce;
  uint64_t timestamp = 0;
  uint64_t seqNum = 0;
};
class Fields {…};
 
namespace detail {
 
template<int order>
class Skip {
public:
  using Order = std::integral_constant<int, order>;
 
  class EncodeValue {
  public:
    void encodeTo(Encoder&) const {}
  };
  class EncodeValue {…};
 
  EncodeValue create() {
    return EncodeValue();
  }
  EncodeValue create() {…}
 
  bool check(const Fields&) const {
    return true;
  }
  bool check(const Fields&) const  {…}
 
  void save(const Fields&) {}
};
class Skip {…};
 
} // namespace detail
namespace detail {…}
 
template<int nonceLength = 8, int nTrackedNonces = 16>
class Nonce {
public:
  using Order = std::integral_constant<int, 1>;
  static_assert(nonceLength > 0, "");
  static_assert(nTrackedNonces > 0, "");
 
  class Value : public std::array<uint8_t, nonceLength> {
  public:
    Value() = default;
 
    explicit Value(tlv::Value input)
      : valid(input.size() == nonceLength) {
      if (valid) {
        std::copy(input.begin(), input.end(), this->begin());
      }
    }
    explicit Value(tlv::Value input) {…}
 
    void encodeTo(Encoder& encoder) const {
      if (!valid) {
        encoder.setError();
        return;
      }
      encoder.prependTlv(TT::SigNonce, tlv::Value(this->data(), this->size()));
    }
    void encodeTo(Encoder& encoder) const  {…}
 
    bool operator==(const Value& other) const {
      return valid && other.valid && std::equal(this->begin(), this->end(), other.begin());
    }
    bool operator==(const Value& other) const  {…}
 
  public:
    bool valid = false;
  };
  class Value : public std::array<uint8_t, nonceLength> {…};
 
  Value create() {
    Value value;
    do {
      value.valid = port::RandomSource::generate(value.data(), value.size());
      if (!value.valid) {
        return value;
      }
    } while (exists(value));
    append(value);
    return value;
  }
  Value create() {…}
 
  bool check(const Fields& f) const {
    Value value(f.nonce);
    return !exists(value);
  }
  bool check(const Fields& f) const  {…}
 
  void save(const Fields& f) {
    Value value(f.nonce);
    append(value);
  }
  void save(const Fields& f) {…}
 
private:
  bool exists(const Value& value) const {
    return std::find(m_nonces.begin(), m_nonces.end(), value) != m_nonces.end();
  }
 
  void append(const Value& value) {
    NDNPH_ASSERT(value.valid);
    m_nonces[m_pos] = value;
    if (++m_pos == m_nonces.size()) {
      m_pos = 0;
    }
  }
 
private:
  std::array<Value, nTrackedNonces> m_nonces = {};
  size_t m_pos = 0;
};
class Nonce {…};
 
template<int maxClockOffset = 60000>
class Time {
public:
  using Order = std::integral_constant<int, 2>;
 
  tlv::NniElement<> create() {
    uint64_t timestamp = std::max(now(), m_last + 1);
    m_last = timestamp;
    return tlv::NniElement<>(TT::SigTime, timestamp);
  }
  tlv::NniElement<> create() {…}
 
  bool check(const Fields& f) const {
    static_assert(maxClockOffset >= 0, "");
    return f.timestamp > m_last &&
           std::abs(static_cast<int64_t>(now() - f.timestamp)) <= maxClockOffset;
  }
  bool check(const Fields& f) const  {…}
 
  void save(const Fields& f) {
    m_last = std::max(m_last, f.timestamp);
  }
  void save(const Fields& f) {…}
 
private:
  uint64_t now() const {
    // SigTime field uses milliseconds
    return port::UnixTime::now() / 1000;
  }
 
private:
  uint64_t m_last = 0;
};
class Time {…};
 
class SeqNum {
public:
  using Order = std::integral_constant<int, 3>;
 
  explicit SeqNum(uint64_t next = 0)
    : m_next(next) {}
  explicit SeqNum(uint64_t next = 0) {…}
 
  tlv::NniElement<> create() {
    return tlv::NniElement<>(TT::SigSeqNum, m_next++);
  }
  tlv::NniElement<> create() {…}
 
  bool check(const Fields& f) const {
    return f.seqNum >= m_next;
  }
  bool check(const Fields& f) const  {…}
 
  void save(const Fields& f) {
    m_next = std::max(m_next, f.seqNum) + 1;
  }
  void save(const Fields& f) {…}
 
private:
  uint64_t m_next;
};
class SeqNum {…};
 
template<typename R0, typename R1 = detail::Skip<11>, typename R2 = detail::Skip<12>>
class Policy {
public:
  explicit Policy(const R0& r0 = R0(), const R1& r1 = R1(), const R2& r2 = R2())
    : m_r0(r0)
    , m_r1(r1)
    , m_r2(r2) {}
  explicit Policy(const R0& r0 = R0(), const R1& r1 = R1(), const R2& r2 = R2()) {…}
 
  bool create(Region& region, ISigInfo& si) {
    Encoder encoder(region);
    if (!encoder.prepend(m_r0.create(), m_r1.create(), m_r2.create())) {
      encoder.discard();
      return false;
    }
    encoder.trim();
    si.extensions = tlv::Value(encoder);
    return true;
  }
  bool create(Region& region, ISigInfo& si) {…}
 
  bool check(const ISigInfo& si) {
    Fields f;
    if (f.decode(si) && m_r0.check(f) && m_r1.check(f) && m_r2.check(f)) {
      m_r0.save(f);
      m_r1.save(f);
      m_r2.save(f);
      return true;
    }
    return false;
  }
  bool check(const ISigInfo& si) {…}
 
private:
  R0 m_r0;
  R1 m_r1;
  R2 m_r2;
 
  static_assert(R0::Order::value < R1::Order::value, "");
  static_assert(R1::Order::value < R2::Order::value, "");
};
class Policy {…};
 
template<typename... R>
Policy<R...>
makePolicy(R&&... rule) {
  return Policy<R...>(std::forward<R>(rule)...);
}
makePolicy(R&&... rule) {…}
 
} // namespace isig
namespace isig {…}
} // namespace ndnph
 
#endif // NDNPH_PACKET_SIG_INFO_HPP