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


// SOL9
// 2009/03/24
#pragma once

#include <sol/Object.h>
#include <wincrypt.h>

#include <sol/Bytes.h>

/*
C++
typedef struct _CRYPT_DECRYPT_MESSAGE_PARA {
  DWORD      cbSize;
  DWORD      dwMsgAndCertEncodingType;
  DWORD      cCertStore;
  HCERTSTORE *rghCertStore;
  DWORD      dwFlags;    //Not support in Windows 2000
} CRYPT_DECRYPT_MESSAGE_PARA, *PCRYPT_DECRYPT_MESSAGE_PARA;Members
 */

namespace SOL {

class MessageDecryptor :public Object {

private:

    CRYPT_DECRYPT_MESSAGE_PARA    decryptMessagePara;

    DWORD encodingType;

    DWORD dwFlags;
public:
    /**
     * Constrcutor
     */
    MessageDecryptor(DWORD encType=(PKCS_7_ASN_ENCODING|X509_ASN_ENCODING),
            DWORD flags=CRYPT_MESSAGE_SILENT_KEYSET_FLAG)
    :encodingType(encType),
    dwFlags(flags)
    {
        memset(&decryptMessagePara, 0, sizeof(decryptMessagePara));
    }


public:
    /**
     *
     */
    int decrypt(
        __in HCERTSTORE hCertStore,

        __in Bytes& encryptedMessage,    //Encrypted message to be decrypted
        __out Bytes& decryptedMessage,    //Decrypted message
        __out_opt PCCERT_CONTEXT *ppXchgCert = NULL)
    {
        int rc = NO_ERROR;

        BYTE* decData = NULL;
        DWORD decDataSize = 0;
        if ((rc = decrypt(hCertStore, encryptedMessage.getData(), encryptedMessage.getSize(),
            &decData, &decDataSize)) == NO_ERROR) {
            decryptedMessage.shallowCopy(decData, decDataSize);
        } 
        return rc;
    }

public:
    /**
     *
     */
    int decrypt(
        __in HCERTSTORE hCertStore,

        __in const BYTE* encData,    //Ecrypted message to be decrypted
        __in DWORD  encDataSize,    //Byte size of encrypted message

        __out BYTE** ppDecData,     //Decrypted message
        __out DWORD* pDecDataSize,     //Byte siz of decrypted message 
        __out_opt PCCERT_CONTEXT *ppXchgCert = NULL)

    {
        int rc = NO_ERROR;

        memset(&decryptMessagePara, 0, sizeof(decryptMessagePara));
        decryptMessagePara.cbSize = sizeof(decryptMessagePara);
        decryptMessagePara.dwMsgAndCertEncodingType = this->encodingType;

         decryptMessagePara.cCertStore = 1;

        HCERTSTORE certStoreArray[1];
        certStoreArray[0] = hCertStore;
         decryptMessagePara.rghCertStore = certStoreArray;

        //decryptMessagePara.dwFlags = this->dwFlags;//CRYPT_MESSAGE_SILENT_KEYSET_FLAG 

        DWORD bufferSize = 0;
        if (!CryptDecryptMessage(
                &decryptMessagePara,
                encData,
                encDataSize,
                NULL,
                &bufferSize,
                ppXchgCert)) {

            return GetLastError();
        }

        BYTE* buffer = new BYTE [bufferSize];

        if (CryptDecryptMessage(
                &decryptMessagePara,
                encData,
                encDataSize,
                buffer,
                &bufferSize,
                ppXchgCert)) {
            //OK
            *ppDecData = buffer;
            *pDecDataSize = bufferSize;
        } else {
            delete [] buffer;
            rc = GetLastError();
        }
        return rc;

    }
};

}