mifarecommands.hpp

Go to the documentation of this file.

 
#ifndef LOGICALACCESS_MIFARECOMMANDS_HPP
#define LOGICALACCESS_MIFARECOMMANDS_HPP
 
#include <logicalaccess/plugins/cards/mifare/mifareaccessinfo.hpp>
#include <logicalaccess/cards/commands.hpp>
#include <logicalaccess/cards/location.hpp>
 
namespace logicalaccess
{
#define CMD_MIFARE "Mifare"
 
class MifareChip;
 
class LLA_CARDS_MIFARE_API MifareCommands : public Commands
{
  public:
    MifareCommands()
        : Commands(CMD_MIFARE)
    {
    }
 
    explicit MifareCommands(std::string ct)
        : Commands(ct)
    {
    }
 
    virtual ByteVector readSector(int sector, int start_block,
                                  std::shared_ptr<MifareKey> keyA,
                                  std::shared_ptr<MifareKey> keyB,
                                  const MifareAccessInfo::SectorAccessBits &sab,
                                  bool readtrailer = false) final;
 
    virtual void
    writeSector(int sector, int start_block, const ByteVector &buf,
                std::shared_ptr<MifareKey> keyA, std::shared_ptr<MifareKey> keyB,
                const MifareAccessInfo::SectorAccessBits &sab,
                unsigned char userbyte                     = 0x00,
                MifareAccessInfo::SectorAccessBits *newsab = nullptr,
                std::shared_ptr<MifareKey> newkeyA         = std::shared_ptr<MifareKey>(),
                std::shared_ptr<MifareKey> newkeyB = std::shared_ptr<MifareKey>()) final;
 
    virtual ByteVector readSectors(int start_sector, int stop_sector, int start_block,
                                   std::shared_ptr<MifareKey> keyA,
                                   std::shared_ptr<MifareKey> keyB,
                                   const MifareAccessInfo::SectorAccessBits &sab) final;
 
    virtual void writeSectors(
        int start_sector, int stop_sector, int start_block, const ByteVector &buf,
        std::shared_ptr<MifareKey> keyA, std::shared_ptr<MifareKey> keyB,
        const MifareAccessInfo::SectorAccessBits &sab, unsigned char userbyte = 0x00,
        MifareAccessInfo::SectorAccessBits *newsab = nullptr,
        std::shared_ptr<MifareKey> newkeyA         = std::shared_ptr<MifareKey>(),
        std::shared_ptr<MifareKey> newkeyB         = std::shared_ptr<MifareKey>()) final;
 
    unsigned int getSectorFromMAD(long aid, std::shared_ptr<MifareKey> madKeyA);
 
    void setSectorToMAD(long aid, unsigned int sector, std::shared_ptr<MifareKey> madKeyA,
                        std::shared_ptr<MifareKey> madKeyB);
 
    static unsigned char calculateMADCrc(const unsigned char *madbuf, size_t madbuflen);
 
    static unsigned int findReferencedSector(long aid, unsigned char *madbuf,
                                             size_t madbuflen);
 
    void authenticate(std::shared_ptr<Location> location, std::shared_ptr<AccessInfo> ai,
                      bool write = false);
 
    void changeKeys(MifareKeyType keytype, std::shared_ptr<MifareKey> key,
                    std::shared_ptr<MifareKey> newkeyA,
                    std::shared_ptr<MifareKey> newkeyB, unsigned int sector,
                    MifareAccessInfo::SectorAccessBits *newsab,
                    unsigned char userbyte = 0x00);
 
    void changeKeys(std::shared_ptr<MifareKey> newkeyA,
                    std::shared_ptr<MifareKey> newkeyB, unsigned int sector,
                    MifareAccessInfo::SectorAccessBits *newsab,
                    unsigned char userbyte = 0x00);
 
    static MifareKeyType getKeyType(const MifareAccessInfo::SectorAccessBits &sab,
                                    int sector, int block, bool write);
 
    void authenticate(MifareKeyType keyType, std::shared_ptr<MifareKey> key, int sector,
                      int block, bool write);
 
    virtual ByteVector readBinary(unsigned char blockno, size_t len) = 0;
 
    virtual void updateBinary(unsigned char blockno, const ByteVector &buf) = 0;
 
    virtual bool loadKey(unsigned char keyno, MifareKeyType keytype,
                         std::shared_ptr<MifareKey> key, bool vol = false) = 0;
 
    virtual void loadKey(std::shared_ptr<Location> location, MifareKeyType keytype,
                         std::shared_ptr<MifareKey> key) = 0;
 
    virtual void authenticate(unsigned char blockno, unsigned char keyno,
                              MifareKeyType keytype) = 0;
 
    virtual void authenticate(unsigned char blockno,
                              std::shared_ptr<KeyStorage> key_storage,
                              MifareKeyType keytype) = 0;
 
    virtual void increment(uint8_t blockno, uint32_t value) = 0;
 
    virtual void decrement(uint8_t blockno, uint32_t value) = 0;
 
    bool writeValueBlock(uint8_t blockno, int32_t value, uint8_t backup_blockno);
 
    bool readValueBlock(uint8_t blockno, int32_t &value, uint8_t &backup_block);
 
    static unsigned char getNbBlocks(int sector);
 
    static unsigned char getSectorStartBlock(int sector);
 
  protected:
    std::shared_ptr<MifareChip> getMifareChip() const;
};
}
 
#endif