validation-state.hpp

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2013-2023 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_CXX_SECURITY_VALIDATION_STATE_HPP
#define NDN_CXX_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/signal.hpp"
 
#include <list>
#include <unordered_set>
#include <boost/logic/tribool.hpp>
 
namespace ndn::security {
 
class Validator;
 
class ValidationState : public TagHost, noncopyable
{
public:
  virtual
  ~ValidationState();
 
  boost::logic::tribool
  getOutcome() const noexcept
  {
    return m_outcome;
  }
 
  virtual void
  fail(const ValidationError& error) = 0;
 
  size_t
  getDepth() const noexcept
  {
    return m_certificateChain.size();
  }
 
  bool
  hasSeenCertificateName(const Name& certName);
 
  void
  addCertificate(const Certificate& cert);
 
private: // Interface intended to be used only by Validator class
  virtual void
  verifyOriginalPacket(const std::optional<Certificate>& trustedCert) = 0;
 
  virtual void
  bypassValidation() = 0;
 
  const Certificate*
  verifyCertificateChain(const Certificate& trustedCert);
 
protected:
  boost::logic::tribool m_outcome{boost::logic::indeterminate};
 
private:
  std::unordered_set<Name> m_seenCertificateNames;
 
  std::list<Certificate> m_certificateChain;
 
  friend 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
  {
    return m_data;
  }
 
private:
  void
  verifyOriginalPacket(const std::optional<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
  {
    return m_interest;
  }
 
public:
  signal::Signal<InterestValidationState, Interest> afterSuccess;
 
private:
  void
  verifyOriginalPacket(const std::optional<Certificate>& trustedCert) final;
 
  void
  bypassValidation() final;
 
private:
  Interest m_interest;
  InterestValidationSuccessCallback m_successCb;
  InterestValidationFailureCallback m_failureCb;
};
 
using SignedInterestFormatTag = SimpleTag<SignedInterestFormat, 1002>;
 
} // namespace ndn::security
 
#endif // NDN_CXX_SECURITY_VALIDATION_STATE_HPP