.. _program_listing_file_libspookyaction_include_desfire_protocol.hpp:

Program Listing for File protocol.hpp
=====================================

|exhale_lsh| :ref:`Return to documentation for file <file_libspookyaction_include_desfire_protocol.hpp>` (``libspookyaction/include/desfire/protocol.hpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   //
   // Created by Pietro Saccardi on 02/01/2021.
   //
   
   #ifndef DESFIRE_PROTOCOL_HPP
   #define DESFIRE_PROTOCOL_HPP
   
   #include <desfire/bits.hpp>
   #include <desfire/crypto.hpp>
   #include <desfire/log.h>
   #include <memory>
   #include <mlab/bin_data.hpp>
   
   namespace desfire {
   
       struct block_tag {};
   
       class protocol {
       public:
           virtual void prepare_tx(bin_data &data, std::size_t offset, comm_mode mode) = 0;
   
           virtual bool confirm_rx(bin_data &data, comm_mode mode) = 0;
   
           virtual void init_session(bin_data const &random_data) = 0;
   
           [[nodiscard]] virtual bool is_legacy() const = 0;
   
           virtual ~protocol() = default;
       };
   
       class protocol_dummy final : public protocol {
       public:
           inline void prepare_tx(bin_data &, std::size_t, comm_mode mode) override;
   
           inline bool confirm_rx(bin_data &, comm_mode mode) override;
   
           inline void init_session(bin_data const &) override;
   
           [[nodiscard]] bool is_legacy() const override;
       };
   
       class protocol_legacy final : public protocol {
       public:
           static constexpr std::size_t block_size = 8;
           static constexpr std::size_t mac_size = 4;  
           static constexpr std::size_t crc_size = 2;  
   
           using block_t = mlab::tagged_array<block_tag, block_size>;
           using mac_t = mlab::tagged_array<mac_tag, mac_size>;      
   
           explicit protocol_legacy(std::unique_ptr<crypto> crypto);
   
           void prepare_tx(bin_data &data, std::size_t offset, comm_mode mode) override;
   
           bool confirm_rx(bin_data &data, comm_mode mode) override;
   
           void init_session(bin_data const &random_data) override;
   
           [[nodiscard]] bool is_legacy() const override;
   
       private:
           [[nodiscard]] block_t &get_zeroed_iv();
           [[nodiscard]] crypto &crypto_provider();
   
           mac_t compute_mac(range<bin_data::const_iterator> data);
   
           static bool drop_padding_verify_crc(bin_data &d);
   
           block_t _iv;
           std::unique_ptr<crypto> _crypto;
       };
   
   
       class protocol_default final : public protocol {
       public:
           static constexpr std::size_t mac_size = 8;
           static constexpr std::size_t crc_size = 4;
   
           explicit protocol_default(std::unique_ptr<crypto_with_cmac> crypto);
   
           void prepare_tx(bin_data &data, std::size_t offset, comm_mode mode) override;
   
           bool confirm_rx(bin_data &data, comm_mode mode) override;
   
           void init_session(bin_data const &random_data) override;
           [[nodiscard]] bool is_legacy() const override;
   
       private:
           [[nodiscard]] crypto_with_cmac &crypto_provider();
   
           [[nodiscard]] range<std::uint8_t *> iv();
   
           bool drop_padding_verify_crc(bin_data &d, std::uint8_t status);
   
   
           std::unique_ptr<std::uint8_t[]> _iv;
           std::unique_ptr<crypto_with_cmac> _crypto;
       };
   }// namespace desfire
   
   namespace desfire {
   
       void protocol_dummy::prepare_tx(bin_data &, std::size_t, comm_mode mode) {
           if (mode != comm_mode::plain) {
               DESFIRE_LOGE("Dummy protocol supports only plain comm mode.");
           }
       }
   
       bool protocol_dummy::confirm_rx(bin_data &, comm_mode mode) {
           if (mode != comm_mode::plain) {
               DESFIRE_LOGE("Dummy protocol supports only plain comm mode.");
               return false;
           }
           return true;
       }
   
       void protocol_dummy::init_session(bin_data const &) {}
   
   }// namespace desfire
   
   #endif//DESFIRE_PROTOCOL_HPP