/*
 * SymmetricKey.h 
 * Copyright (c) 2011 Antillia.com TOSHIYUKI ARAI. ALL RIGHTS RESERVED. 
 */


// SOL9
// 2009/02/03

#pragma once

#include <sol/crypt/CryptServiceProvider.h>

#include <sol/crypt/CryptKey.h>
#include <sol/crypt/CryptHash.h>

/**
  try {
    CryptServiceProvider csp;

    SymmetricKey aes256Ecb(csp, CALG_AES_256, CRYPT_MODE_ECB);

  } catch (Exception& ex) {

  }
 */

namespace SOL {

class SymmetricKey: public CryptKey {

public:
    SymmetricKey()
        :CryptKey()
    {
    }

public:
    /**
     * Constructor
     *
     * @param    algId CALG_RC2, CALG_RC4, CALG_DES, CALG_3DES, CALG_AES_128, CALG_AES_192, CALG_AES_256,
     *
     * @param mode CRYPT_MODE_ECB, CRYPT_MODE_CBC, CRYPT_MODE_FCB
     *
     * Usage:
        CryptoServiceProvider csp;
        SymmetricKey aesKey128(csp, CALG_AES_128, DCRYPT_MODE_ECB)
        SymmetricKey rc2Key;
        rc2Key.create(csp, CALG_RC2, 0);
     */
    SymmetricKey(CryptServiceProvider &csp,
        ALG_ID algId, DWORD mode=0)
    :CryptKey() {
        //
        generate(csp, algId, mode);
    }

public:
    /**
     * Constructor
     *
     * @param    algId CALG_RC2, CALG_RC4, CALG_DES, CALG_3DES, CALG_AES_128, CALG_AES_192, CALG_AES_256,
     *
     * @param mode CRYPT_MODE_ECB, CRYPT_MODE_CBC, CRYPT_MODE_FCB
     *
     */
    SymmetricKey(CryptServiceProvider &csp,
        CryptHash& hash,
        ALG_ID algId, DWORD mode=0)
    :CryptKey() {
        //
        derive(csp, hash, algId, mode);
    }


public:
    /*
     * Generate a key from the parameters given.
     *
     * @param    algId CALG_RC2, CALG_RC4, CALG_DES, CALG_3DES, CALG_AES_128, CALG_AES_192, CALG_AES_256,
     *
     * @param mode CRYPT_MODE_ECB, CRYPT_MODE_CBC, CRYPT_MODE_FCB
     *
     */
    int generate(CryptServiceProvider &csp,
        ALG_ID algId, DWORD mode=0){
        int rc = NO_ERROR;
        if ((rc = CryptKey::generate(csp.getProviderHandle(), 
                algId, CRYPT_EXPORTABLE)) !=NO_ERROR) {

                throw Exception(GetLastError(), 
                        "SymmetricKey::generate,1,Failed to genKey.");
        }

        if (mode !=0) {
            if ((rc=setKeyParam(KP_MODE, (unsigned char*)mode,  0)) !=NO_ERROR) {

                throw Exception(GetLastError(),
                    "SymmetricKey::generate,1,Failed to setKeyParam.");
            }
        }
        return rc;
    }
public:
    /*
     * Derive a key from the parameters given.
     *
     * @param    algId CALG_RC2, CALG_RC4, CALG_DES, CALG_3DES, CALG_AES_128, CALG_AES_192, CALG_AES_256,
     *
     * @param mode CRYPT_MODE_ECB, CRYPT_MODE_CBC, CRYPT_MODE_FCB
     *
     */

    int derive(CryptServiceProvider &csp,
            CryptHash& hash,
            ALG_ID algId, DWORD mode=0) {
        int rc = NO_ERROR;
        if ((rc = CryptKey::derive(csp.getProviderHandle(), 
                algId, hash.getHashHandle(), CRYPT_EXPORTABLE
                )) !=NO_ERROR) {
                throw Exception(GetLastError(), 
                        "SymmetricKey::generate,1,Failed to genKey.");
        }

        if (mode !=0) {
            if ((rc = setKeyParam(KP_MODE, (unsigned char*)mode,  0)) !=NO_ERROR) {

                throw Exception(GetLastError(),
                    "SymmetricKey::generate,1,Failed to setKeyParam.");
            }
        }
        return rc;
    }

public:
    ~SymmetricKey() {
    }

public:
    int setIV(unsigned char* iv, unsigned int size) {
        int rc = 0;
        if (iv != NULL && size >0) {
            if (!setKeyParam(
                   KP_IV,
                   iv,
                0)) {
                 rc = GetLastError();
            }
        }
        return rc;
    }

public:
    int getIV(unsigned char** iv, unsigned int* size) {
        int rc = 0;
        //  Get the length of the new initialization vector.
        DWORD dwCount = 0;
        if (getKeyParam(KP_IV, 
                    NULL,     
                &dwCount, 0))  {

            *size = dwCount;

            // Get the IV, itself
            unsigned char* data = new unsigned char[dwCount];
            if (getKeyParam(KP_IV, 
                data, 
                &dwCount, 0)) {

                *iv = data;
            } else {
                delete [] data;
                rc = GetLastError();
            }
        } else {
            rc = GetLastError();
        }
        return rc;
    }
};

}