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


#pragma once

// SOL9
// 2009/02/03
// 2009/03/03

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

namespace SOL {

class KeyPair :public CryptKey {

public:
    /**
     * Constructor
     *
     * @param csp        Reference to CryptServiceProvider 
     * @param keySpec    AT_KEYEXCHANGE or AT_SIGNATURE.
     */
    //2009/03/05 Mofied to call generate method if getUserKey failed in NTE_NO_KEY
    KeyPair(CryptServiceProvider& csp, DWORD keySpec) 
        :CryptKey() {

        if (getUserKey(   
               csp.getProviderHandle(),    
               keySpec    
            ) !=NO_ERROR) {

            DWORD err = GetLastError();
            if (err == NTE_NO_KEY) {
                if (generate(   
                    csp.getProviderHandle(),    
                     keySpec,
                    0) != NO_ERROR) {
                    throw Exception(GetLastError(), 
                        "KeyPair#KeyPair,1,Failed to generate");
                }
            }
            else {
                throw Exception(GetLastError(), 
                    "KeyPair#KeyPair,2,Failed to getUserKey");
            }
        }
    }

public:
    /**
     * Constructor
     *
     * @param csp        Reference to CryptServiceProvider 
     * @param algId        CALG_RSA_SIGN or CALG_RSA_KEYX.
     * @param flags    0 or CRYPT_EXPORTABLE
     */
    KeyPair(CryptServiceProvider& csp, ALG_ID algId, DWORD flags) 
        :CryptKey() {

        if (generate(   
            csp.getProviderHandle(),    
             algId,
            flags    
            ) != NO_ERROR) {

                throw Exception(GetLastError(), 
                    "KeyPair#KeyPair,1,Failed to getUserKey");
        }
    }
public:
    /**
     * Destructor
     */
    ~KeyPair() {
    }



public:
    /**
     */ 
    // 2009/02/28
    int getPublicKey(Bytes& bytes) {
        int rc = NO_ERROR;
        
        unsigned char* key = NULL;
        unsigned int  length = 0;
        if (getPublicKey(&key, &length, 0) == NO_ERROR) {
             bytes.shallowCopy(key, length);
        } else {
            rc = -1;
        }
        return rc;
    }

public:
    int getPublicKey(unsigned char** key, unsigned int* length, DWORD flags=0) {
         int rc = NO_ERROR;
        if (key && length){
            rc = exportKey(PUBLICKEYBLOB, key, length, flags);
        } else {
            rc = -1;
        }
        return rc;
    }

public:
    /**
     */ 
    // 2009/02/28
    int getPrivateKey(Bytes& bytes) {
        int rc = NO_ERROR;
        
        unsigned char* key = NULL;
        unsigned int  length = 0;
        if (getPrivateKey(&key, &length, 0) == NO_ERROR) {
             bytes.shallowCopy(key, length);
        } else {
            rc = -1;
        }
        return rc;
    }

public:
    int getPrivateKey(unsigned char** key, unsigned int* length, DWORD flags=0) {
         int rc = NO_ERROR;
        if (key && length) {
            rc = exportKey(PRIVATEKEYBLOB, key, length, flags);
        } else {
            rc = -1;
        }
        return rc;

    }

};

}