mifareplussl1commands.hpp

Go to the documentation of this file.

 
#ifndef LOGICALACCESS_MIFAREPLUSSL1COMMANDS_HPP
#define LOGICALACCESS_MIFAREPLUSSL1COMMANDS_HPP
 
#include <logicalaccess/cards/aes128key.hpp>
#include <logicalaccess/plugins/cards/mifare/mifarecommands.hpp>
#include <logicalaccess/plugins/cards/mifareplus/lla_cards_mifareplus_api.hpp>
 
namespace logicalaccess
{
#define CMD_MIFAREPLUSSL1 "MifarePlusSL1"
 
class MifarePlusChip;
 
class LLA_CARDS_MIFAREPLUS_API MifarePlusSL1Commands : public MifareCommands
{
  public:
    MifarePlusSL1Commands()
        : MifareCommands(CMD_MIFAREPLUSSL1)
    {
    }
 
    explicit MifarePlusSL1Commands(std::string ct)
        : MifareCommands(ct)
    {
    }
 
    virtual bool AESAuthenticate(std::shared_ptr<AES128Key> key, uint16_t keyslot);
 
    virtual bool AESAuthenticateSL1(std::shared_ptr<AES128Key> key);
 
    virtual bool switchLevel2(std::shared_ptr<AES128Key> key);
 
    virtual bool switchLevel3(std::shared_ptr<AES128Key> key);
 
 
    ByteVector readBinary(unsigned char blockno, size_t len) override;
 
    void updateBinary(unsigned char blockno, const ByteVector &buf) override;
 
    bool loadKey(unsigned char keyno, MifareKeyType keytype,
                 std::shared_ptr<MifareKey> key, bool vol) override;
 
    void loadKey(std::shared_ptr<Location> location, MifareKeyType keytype,
                 std::shared_ptr<MifareKey> key) override;
 
    void authenticate(unsigned char blockno, unsigned char keyno,
                      MifareKeyType keytype) override;
 
    void authenticate(unsigned char blockno, std::shared_ptr<KeyStorage> key_storage,
                      MifareKeyType keytype) override;
 
    void increment(uint8_t blockno, uint32_t value) override;
 
    void decrement(uint8_t blockno, uint32_t value) override;
};
 
template <typename MifareSL1Impl, typename MifareClassicImpl>
class MifarePlusSL1Policy : public MifarePlusSL1Commands
{
  public:
    MifarePlusSL1Policy()
    {
    }
 
    void fixup()
    {
        classic_impl.setChip(getChip());
        classic_impl.setReaderCardAdapter(getReaderCardAdapter());
 
        sl1_impl_.setChip(getChip());
        sl1_impl_.setReaderCardAdapter(getReaderCardAdapter());
    }
 
    bool AESAuthenticateSL1(std::shared_ptr<AES128Key> key) override
    {
        fixup();
        return sl1_impl_.AESAuthenticateSL1(key);
    }
 
    void authenticate(unsigned char blockno, unsigned char keyno,
                      MifareKeyType keytype) override
    {
        fixup();
        classic_impl.authenticate(blockno, keyno, keytype);
    }
 
    ByteVector readBinary(unsigned char blockno, size_t len) override
    {
        fixup();
        return classic_impl.readBinary(blockno, len);
    }
 
    void updateBinary(unsigned char blockno, const ByteVector &buf) override
    {
        fixup();
        classic_impl.updateBinary(blockno, buf);
    }
 
    bool loadKey(unsigned char keyno, MifareKeyType keytype,
                 std::shared_ptr<MifareKey> key, bool vol) override
    {
        fixup();
        return classic_impl.loadKey(keyno, keytype, key, vol);
    }
 
    void loadKey(std::shared_ptr<Location> location, MifareKeyType keytype,
                 std::shared_ptr<MifareKey> key) override
    {
        fixup();
        classic_impl.loadKey(location, keytype, key);
    }
 
    void authenticate(unsigned char blockno, std::shared_ptr<KeyStorage> key_storage,
                      MifareKeyType keytype) override
    {
        fixup();
        classic_impl.authenticate(blockno, key_storage, keytype);
    }
 
    void increment(uint8_t blockno, uint32_t value) override
    {
        fixup();
        classic_impl.increment(blockno, value);
    }
 
    void decrement(uint8_t blockno, uint32_t value) override
    {
        fixup();
        classic_impl.decrement(blockno, value);
    }
 
    MifareSL1Impl sl1_impl_;
    MifareClassicImpl classic_impl;
};
}
 
#endif /* LOGICALACCESS_MIFAREPLUSSL1COMMANDS_HPP */