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


// SOL9
// 2009/03/13

#pragma once

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

#include <sol/Bytes.h>

namespace SOL {


class MessageSigner :public Object {

private:
    CRYPT_SIGN_MESSAGE_PARA  signParam;

private:
    DWORD encodingType;
     const char* hashAlgorithm;

public:
    /**
     * Constructor
     */
    MessageSigner(DWORD encType=(PKCS_7_ASN_ENCODING|X509_ASN_ENCODING),
            const char* objId=szOID_RSA_MD5)
        :encodingType(encType),
        hashAlgorithm(objId)
    {
        memset(&signParam, 0, sizeof(signParam));
        signParam.cbSize = sizeof(signParam);
    }


public:
    /**
     * Destructor
     */
    ~MessageSigner()
    {
    }


public:
    int sign(__in PCCERT_CONTEXT certContext, 
             __in Bytes& message,
             __out Bytes& signedMessage)
    {
        int rc = NO_ERROR;

        unsigned char* enc = NULL;
        size_t         encSize = 0;
        if ((rc = sign(certContext, message.getData(), message.getSize(),
            &enc,
            &encSize)) !=NO_ERROR) {
            signedMessage.shallowCopy(enc, encSize);
        }
        return rc;
    }
    
public:
    /**
     * @param certContext    Certificate context to be used to sign
     * @param message        BYTES array to be signed.
     * @param messageSize    BYTES length of message.
     * @param signedMessage    Pointe to Pointer to BYTE to return signed bytes.
     * @param signedMessageSize Pointer to size_t to return the size of signed bytes.
     */
    int sign(__in PCCERT_CONTEXT certContext, 
            __in const BYTE* message, 
            __in size_t messageSize,
            __out BYTE** signedMessage,
            __out size_t* signedMessageSize) {

        int rc = NO_ERROR;

        const BYTE* messageArray[1] = {message};    
        DWORD messageSizeArray[1]   = {messageSize};


        signParam.cbSize = sizeof(signParam);
        signParam.dwMsgEncodingType = encodingType;        //
        signParam.pSigningCert = certContext;
        signParam.HashAlgorithm.pszObjId = (char*)hashAlgorithm;//szOID_RSA_MD5;
        signParam.HashAlgorithm.Parameters.cbData = NULL;
        signParam.cMsgCert = 1;
        signParam.rgpMsgCert = &certContext;
        /*
        signParam.cAuthAttr = 0;
        signParam.dwInnerContentType = 0;
        signParam.cMsgCrl = 0;
        signParam.cUnauthAttr = 0;
        signParam.dwFlags = 0;
        signParam.pvHashAuxInfo = NULL;
        signParam.rgAuthAttr = NULL;
        */

        DWORD bufferSize = 0;

        if (CryptSignMessage(
                &signParam,            // signature parameters
                FALSE,                 // not detached
                1,                     // number of messages
                messageArray,          // messages to be signed
                messageSizeArray,      // size of messages
                NULL,                  // buffer for signed message
                &bufferSize) == TRUE ) {
            //OK

        } else {
            //Failed
            return GetLastError();
        }

        BYTE* buffer = new BYTE[bufferSize];
    
        if (CryptSignMessage(
                &signParam, 
            FALSE,
            1,    
            messageArray,
            messageSizeArray,
            buffer,
                &bufferSize) == TRUE) {

            //OK
            *signedMessage = buffer;
            *signedMessageSize = bufferSize;
        } else {
            //Failed
            delete [] buffer;
            return GetLastError();
        }
        return rc;
    }
};

}