core/leaf.cpp

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/**
 * Copyright (c) 2014-2017, Regents of the University of California
 *
 * This file is part of NDN DeLorean, An Authentication System for Data Archives in
 * Named Data Networking.  See AUTHORS.md for complete list of NDN DeLorean authors
 * and contributors.
 *
 * NDN DeLorean is free software: you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free Software
 * Foundation, either version 3 of the License, or (at your option) any later
 * version.
 *
 * NDN DeLorean is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
 * PARTICULAR PURPOSE.  See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with NDN
 * DeLorean, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "leaf.hpp"
#include "tlv.hpp"
#include <ndn-cxx/security/digest-sha256.hpp>
#include <ndn-cxx/encoding/block-helpers.hpp>
#include <ndn-cxx/util/crypto.hpp>

namespace ndn {
namespace delorean {

const Name Leaf::EMPTY_NAME;
const size_t Leaf::N_LOGGER_LEAF_SUFFIX = 4;
const ssize_t Leaf::OFFSET_LEAF_SEQNO = -2;
const ssize_t Leaf::OFFSET_LEAF_HASH = -1;

Leaf::Leaf()
{
}

Leaf::Leaf(const Name& dataName,
       const Timestamp& timestamp,
       const NonNegativeInteger& dataSeqNo,
       const NonNegativeInteger& signerSeqNo,
       const Name& loggerName)
  : m_dataName(dataName)
  , m_timestamp(timestamp)
  , m_dataSeqNo(dataSeqNo)
  , m_signerSeqNo(signerSeqNo)
  , m_loggerName(loggerName)
{
  if (m_dataSeqNo < m_signerSeqNo)
    throw Error("Leaf: signer seqNo should be less than the data seqNo");
}

void
Leaf::setDataSeqNo(const NonNegativeInteger& dataSeqNo)
{
  if (dataSeqNo < m_signerSeqNo)
    throw Error("Leaf: signer seqNo should be less than the data seqNo");

  m_wire.reset();
  m_dataSeqNo = dataSeqNo;
}

void
Leaf::setDataName(const Name& dataName)
{
  m_wire.reset();
  m_dataName = dataName;
}

void
Leaf::setTimestamp(const Timestamp& timestamp)
{
  m_wire.reset();
  m_timestamp = timestamp;
}

void
Leaf::setSignerSeqNo(const NonNegativeInteger& signerSeqNo)
{
  if (m_dataSeqNo < signerSeqNo)
    throw Error("Leaf: signer seqNo should be less than the data seqNo");

  m_wire.reset();
  m_signerSeqNo = signerSeqNo;
}

void
Leaf::setLoggerName(const Name& loggerName)
{
  m_loggerName = loggerName;
}

ndn::ConstBufferPtr
Leaf::getHash() const
{
  wireEncode();
  return ndn::crypto::sha256(m_wire.wire(), m_wire.size());
}

shared_ptr<Data>
Leaf::encode() const
{
  auto data = make_shared<Data>();

  ndn::ConstBufferPtr hash = getHash();

  // Name
  Name dataName = m_loggerName;
  dataName.appendNumber(m_dataSeqNo).append(hash->buf(), hash->size());
  data->setName(dataName);

  // Content
  data->setContent(wireEncode());

  // Signature
  ndn::DigestSha256 sig;
  data->setSignature(sig);

  Block sigValue(tlv::SignatureValue,
                 ndn::crypto::sha256(data->wireEncode().value(),
                                     data->wireEncode().value_size() -
                                     data->getSignature().getValue().size()));
  data->setSignatureValue(sigValue);

  data->wireEncode();

  return data;
}

void
Leaf::decode(const Data& data)
{
  const Name& dataName = data.getName();

  if (!m_loggerName.isPrefixOf(dataName))
    throw Error("decode: leaf data name does not match logger name");

  if (m_loggerName.size() + N_LOGGER_LEAF_SUFFIX != dataName.size())
    throw Error("decode: leaf data name does not follow the naming convention");

  ndn::ConstBufferPtr leafHash;
  NonNegativeInteger dataSeqNo;
  try {
    leafHash = make_shared<ndn::Buffer>(dataName.get(OFFSET_LEAF_HASH).value(),
                                        dataName.get(OFFSET_LEAF_HASH).value_size());

    dataSeqNo = dataName.get(OFFSET_LEAF_SEQNO).toNumber();
  }
  catch (tlv::Error&) {
    throw Error("decode: logger name encoding error");
  }

  wireDecode(data.getContent().blockFromValue());

  if (*leafHash != *getHash())
    throw Error("decode: inconsistent hash");

  if (m_dataSeqNo != dataSeqNo)
    throw Error("decode: seqNo does not match");
}

template<ndn::encoding::Tag TAG>
size_t
Leaf::wireEncode(ndn::EncodingImpl<TAG>& block) const
{
  size_t totalLength = 0;

  totalLength += prependNonNegativeIntegerBlock(block, tlv::SignerSeqNo, m_signerSeqNo);
  totalLength += prependNonNegativeIntegerBlock(block, tlv::DataSeqNo, m_dataSeqNo);
  totalLength += prependNonNegativeIntegerBlock(block, tlv::Timestamp, m_timestamp);
  totalLength += m_dataName.wireEncode(block);

  totalLength += block.prependVarNumber(totalLength);
  totalLength += block.prependVarNumber(tlv::LoggerLeaf);

  return totalLength;
}

template size_t
Leaf::wireEncode<ndn::encoding::EncoderTag>(ndn::EncodingImpl<ndn::encoding::EncoderTag>&) const;

template size_t
Leaf::wireEncode<ndn::encoding::EstimatorTag>(ndn::EncodingImpl<ndn::encoding::EstimatorTag>&) const;


const Block&
Leaf::wireEncode() const
{
  if (m_wire.hasWire())
    return m_wire;

  ndn::EncodingEstimator estimator;
  size_t estimatedSize = wireEncode(estimator);

  ndn::EncodingBuffer buffer(estimatedSize, 0);
  wireEncode(buffer);

  m_wire = buffer.block();
  return m_wire;
}

void
Leaf::wireDecode(const Block& wire)
{
  if (!wire.hasWire()) {
    throw Error("The supplied block does not contain wire format");
  }

  m_wire = wire;
  m_wire.parse();

  if (m_wire.type() != tlv::LoggerLeaf)
    throw tlv::Error("Unexpected TLV type when decoding logger leaf");

  Block::element_const_iterator it = m_wire.elements_begin();

  // the first block must be dataName
  if (it != m_wire.elements_end() && it->type() == tlv::Name) {
    m_dataName.wireDecode(*it);
    it++;
  }
  else
    throw Error("The first sub-TLV is not Name");

  // the second block must be timestamp
  if (it != m_wire.elements_end() && it->type() == tlv::Timestamp) {
    m_timestamp = readNonNegativeInteger(*it);
    it++;
  }
  else
    throw Error("The second sub-TLV is not Timestamp");

  // the third block must be DataSeqNo
  if (it != m_wire.elements_end() && it->type() == tlv::DataSeqNo) {
    m_dataSeqNo = readNonNegativeInteger(*it);
    it++;
  }
  else
    throw Error("The third sub-TLV is not DataSeqNo");

  // the third block must be SignerSeqNo
  if (it != m_wire.elements_end() && it->type() == tlv::SignerSeqNo) {
    m_signerSeqNo = readNonNegativeInteger(*it);
    it++;
  }
  else
    throw Error("The fourth sub-TLV is not SignerSeqNo");

  if (it != m_wire.elements_end())
    throw Error("No more sub-TLV in LoggerLeaf");
}

} // namespace delorean
} // namespace ndn