iv.hpp

Go to the documentation of this file.

#ifndef NDNPH_KEYCHAIN_IV_HPP
#define NDNPH_KEYCHAIN_IV_HPP
 
#include "../port/random/port.hpp"
#include "../tlv/nni.hpp"
#include "../tlv/value.hpp"
 
namespace ndnph {
 
class AesGcmIvHelper {
public:
  using IvLen = std::integral_constant<size_t, 12>;
 
  using BlockSize = std::integral_constant<size_t, 16>;
 
  bool randomize() {
    m_ok = port::RandomSource::generate(reinterpret_cast<uint8_t*>(&random), sizeof(random));
    return m_ok;
  }
  bool randomize() {…}
 
  bool write(uint8_t room[12]) {
    tlv::NNI8::writeValue(room, random);
    tlv::NNI4::writeValue(room + 8, counter);
    return true;
  }
  bool write(uint8_t room[12]) {…}
 
  bool advance(size_t size) {
    uint64_t nBlocks = divCeil(size, BlockSize::value);
    uint64_t cnt = static_cast<uint64_t>(counter) + nBlocks;
    if (cnt > std::numeric_limits<uint32_t>::max()) {
      m_ok = false;
    }
    counter = static_cast<uint32_t>(cnt);
    return m_ok;
  }
  bool advance(size_t size) {…}
 
  bool check(const uint8_t* iv, size_t size) {
    uint64_t rand = tlv::NNI8::readValue(iv);
    uint32_t cnt = tlv::NNI4::readValue(iv + sizeof(rand));
 
    if (counter == 0) {
      random = rand;
    } else if (random != rand) {
      return false;
    }
 
    if (cnt < counter) {
      return false;
    }
    counter = cnt;
    return advance(size);
  }
  bool check(const uint8_t* iv, size_t size) {…}
 
public:
  uint64_t random = 0;
  uint32_t counter = 0;
 
private:
  bool m_ok = true;
};
class AesGcmIvHelper {…};
 
} // namespace ndnph
 
#endif // NDNPH_KEYCHAIN_IV_HPP