src/blfwk/AESKey.h

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

#include <string.h>
#include <iostream>
#include "Random.h"

typedef uint8_t aes128_key_t[16];

class AESKeyBase
{
public:
    void _readFromStream(std::istream &stream, unsigned bytes, uint8_t *buffer) const;

    void _writeToStream(std::ostream &stream, unsigned bytes, const uint8_t *buffer) const;
};

template <int S>
class AESKey : public AESKeyBase
{
public:
    typedef uint8_t key_t[S / 8];

public:
    AESKey() { memset(m_key, 0, sizeof(m_key)); }
    AESKey(const key_t &key) { memcpy(m_key, &key, sizeof(m_key)); }
    // \brief Constructor taking a key value pointer.
    AESKey(const key_t *key) { memcpy(m_key, key, sizeof(m_key)); }
    AESKey(std::istream &stream) { readFromStream(stream); }
    AESKey(const AESKey<S> &other) { memcpy(m_key, other.m_key, sizeof(m_key)); }
    ~AESKey() { memset(m_key, 0, sizeof(m_key)); }
    void randomize()
    {
        RandomNumberGenerator rng;
        rng.generateBlock(m_key, sizeof(m_key));
    }

    void readFromStream(std::istream &stream) { _readFromStream(stream, S / 8, reinterpret_cast<uint8_t *>(&m_key)); }
    void writeToStream(std::ostream &stream) const
    {
        _writeToStream(stream, S / 8, reinterpret_cast<const uint8_t *>(&m_key));
    }


    inline const key_t &getKey() const { return m_key; }
    inline void getKey(key_t *key) const { memcpy(key, m_key, sizeof(m_key)); }
    inline void setKey(const key_t &key) { memcpy(m_key, &key, sizeof(m_key)); }
    inline void setKey(const key_t *key) { memcpy(m_key, key, sizeof(m_key)); }
    inline void setKey(const AESKey<S> &key) { memcpy(m_key, key.m_key, sizeof(m_key)); }


    const AESKey<S> &operator=(const AESKey<S> &key)
    {
        setKey(key);
        return *this;
    }
    const AESKey<S> &operator=(const key_t &key)
    {
        setKey(key);
        return *this;
    }
    const AESKey<S> &operator=(const key_t *key)
    {
        setKey(key);
        return *this;
    }

    operator const key_t &() const { return m_key; }
    operator const key_t *() const { return m_key; }
    friend std::ostream &operator<<(std::ostream &os, const AESKey<S> &key)
    {
        key.writeToStream(os);
        return os;
    }


protected:
    key_t m_key; 
};

typedef AESKey<128> AES128Key;

#endif // _AESKey_h_