Keyblob.h

/*
* File: Keyblob.h
*
* Copyright (c) Freescale Semiconductor, Inc. All rights reserved.
* See included license file for license details.
*/
#if !defined(_Keyblob_h_)
#define _Keyblob_h_

#include "smart_ptr.h"
#include "OptionContext.h"
#include "DataTarget.h"
#include "AESKey.h"
#include "AESCounter.h"

#define kKeyblobOptionNameStart "start"
#define kKeyblobOptionNameEnd "end"
#define kKeyblobOptionNameKey "key"
#define kKeyblobOptionNameCounter "counter"

namespace elftosb
{
class Keyblob
{
public:
    typedef std::vector<OptionContext *> option_vector_t; 

    enum _encryption_constants
    {
        k_encryptBlockSize = 16, 
        k_qspiAlignlength =
            512 
    };

public:
    Keyblob()
        : m_id(0)
        , m_options(0)
    {
    }
    Keyblob(uint32_t identifier)
        : m_id(identifier)
        , m_options(0)
    {
    }
    virtual ~Keyblob() {}
    static uint32_t getKekSizeBytes() { return kKekSizeBytes; }
    void setIdentifier(uint32_t identifier) { m_id = identifier; }
    uint32_t getIdentifier() const { return m_id; }
    inline void addOptions(OptionContext *context) { m_options.push_back(context); }
    inline option_vector_t *getOptions() { return &m_options; }
    uint8_t *createWrappedKeyblobData(uint8_t *kek, uint32_t *byteCount);

    bool encryptMatchingRange(uint32_t start, uint32_t len, uint8_t *data);

protected:
    enum _keywrap_constants
    {
        kKeySizeBits = 128,            
        kExpandedKekSizeInts = 64,     
        kNumKeyBlobs = 4,              
        kKeyBlobSizeBytes = 64,        
        kOutputLineSize = 16,          
        kRegionAddrMask = (0x400 - 1), 
        kFlagMask = 0x07,              
        kKeyFlags = 0x03,              
        kAesKeySizeBytes = 16,         
        kCtrSizeBytes = 8,             
        kKekSizeBytes = 16,            
        kNumKeyChars = 32,             
        kNumCtrChars = 16,             
        kCrc32SizeBytes = 32           
    };

    typedef struct KeyBlob
    {
        unsigned char key[kAesKeySizeBytes]; // 16 bytes, 128-bits, KEY[A15...A00]
        unsigned char ctr[kCtrSizeBytes];    // 8 bytes, 64-bits, CTR[C7...C0]
        unsigned int srtaddr;                // region start, STRADDR[31 - 10]
        unsigned int endaddr;                // region end, ENDADDR[31 - 10]
        // end of 32-byte area covered by CRC
        unsigned int zero_fill;      // zeros
        unsigned int key_blob_crc32; // crc32 over 1st 32-bytes
        // end of 40 byte (5*64-bit) key blob data
        unsigned char expanded_wrap_data[8]; // 8 bytes, used for wrap expanded data
        // end of 48 byte (6*64-bit) wrap data
        unsigned char unused_filler[16]; // unused fill to 64 bytes
    } keyblob_t;

    void populateKeyBlob(keyblob_t *blob, uint32_t start, uint32_t end, const char *keyHex, const char *counterHex);
    void encrypt(uint32_t length, uint8_t *data, AESKey<128> *key, AESCounter<128> *counter);
    bool getOptionValues(OptionContext &opt, const char **key, const char **ctr, uint32_t *start, uint32_t *end);

    uint32_t m_id;             
    option_vector_t m_options; 
};

}; // namespace elftosb

#endif // _Keyblob_h_