validation-state.hpp

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2013-2020 Regents of the University of California.
 *
 * This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
 *
 * ndn-cxx library is free software: you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License as published by the Free Software
 * Foundation, either version 3 of the License, or (at your option) any later version.
 *
 * ndn-cxx library 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 Lesser General Public License for more details.
 *
 * You should have received copies of the GNU General Public License and GNU Lesser
 * General Public License along with ndn-cxx, e.g., in COPYING.md file.  If not, see
 * <http://www.gnu.org/licenses/>.
 *
 * See AUTHORS.md for complete list of ndn-cxx authors and contributors.
 */

#ifndef NDN_SECURITY_VALIDATION_STATE_HPP
#define NDN_SECURITY_VALIDATION_STATE_HPP

#include "ndn-cxx/detail/tag-host.hpp"
#include "ndn-cxx/security/certificate.hpp"
#include "ndn-cxx/security/signing-info.hpp"
#include "ndn-cxx/security/validation-callback.hpp"
#include "ndn-cxx/util/signal.hpp"

#include <list>
#include <unordered_set>
#include <boost/logic/tribool.hpp>

namespace ndn {
namespace security {
inline namespace v2 {

class Validator;

class ValidationState : public TagHost, noncopyable
{
public:
  ValidationState();

  virtual
  ~ValidationState();

  boost::logic::tribool
  getOutcome() const
  {
    return m_outcome;
  }

  virtual void
  fail(const ValidationError& error) = 0;

  size_t
  getDepth() const;

  bool
  hasSeenCertificateName(const Name& certName);

  void
  addCertificate(const Certificate& cert);

private: // Interface intended to be used only by Validator class
  virtual void
  verifyOriginalPacket(const Certificate& trustedCert) = 0;

  virtual void
  bypassValidation() = 0;

  const Certificate*
  verifyCertificateChain(const Certificate& trustedCert);

protected:
  boost::logic::tribool m_outcome;

private:
  std::unordered_set<Name> m_seenCertificateNames;

  std::list<v2::Certificate> m_certificateChain;

  friend class Validator;
};

class DataValidationState final : public ValidationState
{
public:
  DataValidationState(const Data& data,
                      const DataValidationSuccessCallback& successCb,
                      const DataValidationFailureCallback& failureCb);

  ~DataValidationState() final;

  void
  fail(const ValidationError& error) final;

  const Data&
  getOriginalData() const;

private:
  void
  verifyOriginalPacket(const Certificate& trustedCert) final;

  void
  bypassValidation() final;

private:
  Data m_data;
  DataValidationSuccessCallback m_successCb;
  DataValidationFailureCallback m_failureCb;
};

class InterestValidationState final : public ValidationState
{
public:
  InterestValidationState(const Interest& interest,
                          const InterestValidationSuccessCallback& successCb,
                          const InterestValidationFailureCallback& failureCb);

  ~InterestValidationState() final;

  void
  fail(const ValidationError& error) final;

  const Interest&
  getOriginalInterest() const;

public:
  util::Signal<InterestValidationState, Interest> afterSuccess;

private:
  void
  verifyOriginalPacket(const Certificate& trustedCert) final;

  void
  bypassValidation() final;

private:
  Interest m_interest;
  InterestValidationSuccessCallback m_successCb;
  InterestValidationFailureCallback m_failureCb;
};

using SignedInterestFormatTag = SimpleTag<SignedInterestFormat, 1002>;

} // inline namespace v2
} // namespace security
} // namespace ndn

#endif // NDN_SECURITY_VALIDATION_STATE_HPP