/*
* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  Implementation of STSRSASIgnature
 *
*/



#include <x509cert.h>
#include <hash.h>
#include <asymmetrickeys.h>
#include <asymmetric.h>
#include "stsconstants.h"
#include "stsrsasignature.h"

#include "javajniutils.h"
#include "logger.h"

namespace java
{
namespace satsa
{

STSRSASignature::STSRSASignature()
{
    mRSAKey = NULL;
    mHashID = NULL;
    mRSA = NULL;
    mpkey = NULL;
}



int STSRSASignature::Construct(const std::wstring aPadding)
{
    LOG(ESATSA, EInfo, "STSRSASignature::Construct+");

    if (aPadding == STSDigestSHA1)
    {
        md = EVP_sha1();
    }
    else if (aPadding == STSDigestMD2)
    {
        md = EVP_md2();
    }
    else if (aPadding == STSDigestMD5)
    {
        md = EVP_md5();
    }
    else
    {
        return KSTSErrArgument;
    }

    if (md == NULL)
    {
        // Algorithm was not found
        return KSTSErrDigest;
    }
    else
    {

        mdctx = new EVP_MD_CTX;
        if (mdctx != NULL)
        {
            EVP_MD_CTX_init(mdctx);
            return 0;
        }
        else
        {
            return KSTSErrDigest;
        }
    }

}



STSRSASignature* STSRSASignature::Create(const std::wstring aPadding,
        int* errCode)
{
    LOG(ESATSA, EInfo, "STSRSASignature::Create+");
    STSRSASignature* self = new STSRSASignature;
    if (self == NULL)
    {
        // object was not created successfully
        *errCode = KSTSErrNoMemory;
        return NULL;
    }
    else
    {
        // Object created, call the second level constructor
        *errCode = self->Construct(aPadding);
        if (*errCode == 0)
        {
            return self;
        }
        else
        {
            delete self;
            return NULL;
        }
    }
}


STSRSASignature::~STSRSASignature()
{
    if (mHashID != NULL)
        delete mHashID;

    if (mRSAKey != NULL)
        delete mRSAKey;

    if (mpkey != NULL)
        EVP_PKEY_free(mpkey);

    if (mRSA != NULL)
        mRSA = NULL;

}

int STSRSASignature::InitVerify(JNIEnv* aJni, jstring aKeyAlgorithm,
                                jstring aKeyFormat, jbyteArray aKeyEncoded)
{
    LOG(ESATSA, EInfo, "STSRSASignature::InitVerify+");
    int retVal = 0;

    // Check key validity

    // Key must be created for used algorithm
    std::wstring key_algorithm;
    try
    {
        key_algorithm = java::util::JniUtils::jstringToWstring(aJni,
                        aKeyAlgorithm);
    }
    catch (...)
    {
        ELOG(ESATSA, "InitVerify: caught exception. Return error code");
        return (KSTSErrInvalidKey);
    }
    ELOG(ESATSA, "STSRSASignature::InitVerify: Check Algorithm");
    if (key_algorithm != STSAlgorithmRSA)
    {
        return (KSTSErrInvalidKey);
    }
    // Format: Only X509 keys are supported
    std::wstring key_format;
    try
    {
        key_format = java::util::JniUtils::jstringToWstring(aJni, aKeyFormat);
    }
    catch (...)
    {
        ELOG(ESATSA, "InitVerify: caught exception. Return error code");
        return (KSTSErrInvalidKey);
    }

    LOG(ESATSA, EInfo, "STSRSASignature::InitVerify: Check key format");
    if (key_format != STSKeyFormatX509)
    {
        return (KSTSErrInvalidKey);
    }

    // Read the encoded key from the jbytearray
    LOG(ESATSA, EInfo, "STSRSASignature::InitVerify:read the encoded key");
    int key_length = aJni->GetArrayLength(aKeyEncoded);
    const unsigned char *key = new unsigned char[key_length];
    aJni->GetByteArrayRegion(aKeyEncoded, 0, key_length, (signed char*) key);

    // decode the encoded key data into a RSA data structure.
    LOG(ESATSA, EInfo,"decode the encoded key data into a RSA data");
    mRSA = d2i_RSA_PUBKEY(&mRSA, &key, (long) key_length);
    if (mRSA == NULL)
    {
        return KSTSErrInvalidKey;
    }

    LOG(ESATSA, EInfo, "STSRSASignature::InitVerify: get mpkey");
    mpkey = EVP_PKEY_new();
    EVP_PKEY_set1_RSA(mpkey, mRSA);

    LOG(ESATSA, EInfo, "STSRSASignature::InitVerify: verify init call");
    retVal = EVP_VerifyInit_ex(mdctx, md, NULL);

    LOG(ESATSA, EInfo, "STSRSASignature::InitVerify---");
    return retVal;

}

int STSRSASignature::Verify(JNIEnv* aJni, jbyteArray aSignature)
{
    LOG(ESATSA, EInfo, "STSRSASignature::Verify++");
    int result;

    if (mpkey == NULL)
    {
        ELOG(ESATSA, "STSRSASignature::Verify: mpkey is null");
        // Not initialized
        return (KSTSErrSignature);
    }
    else if (!mIsUpdated)
    {
        LOG(ESATSA, EInfo, "STSRSASignature::Verify: Not updated");
        return false;
    }
    else if (mdctx == NULL)
    {
        // If data is not updated TCK requires that exception is not thrown and
        // false is returned.
        ELOG(ESATSA, "STSRSASignature::Verify: mdctx is null");
        return false;
    }

    // Read the signature data from the jbytearray
    int siglen = aJni->GetArrayLength(aSignature);
    const unsigned char *sigbuf = new unsigned char[siglen];
    aJni->GetByteArrayRegion(aSignature, 0, siglen, (signed char*) sigbuf);

    result = EVP_VerifyFinal(mdctx, sigbuf, siglen, mpkey);
    mIsUpdated = false;

    // reset the digest
    LOG(ESATSA, EInfo, "STSRSASignature::Verify: reset the digest");
    const EVP_MD* md = NULL;
    md = EVP_MD_CTX_md(mdctx);
    EVP_MD_CTX_init(mdctx);
    EVP_DigestInit_ex(mdctx, md, NULL);

    LOG(ESATSA, EInfo, "Verify: check result and return proper value");
    if (0 == result)
    {
        return false;
    }
    else if (1 == result)
    {
        return true;
    }
    else
    {
        return KSTSErrSignature;
    }
}

int STSRSASignature::Update(JNIEnv* aJni, jbyteArray aData, jint aOffset,
                            jint aLength)
{
    LOG(ESATSA, EInfo, "STSRSASignature::Update++");
    if (mpkey == NULL)
    {
        ELOG(ESATSA, "STSRSASignature::Update: mpkey is null");
        // Not initialized
        return KSTSErrSignature;
    }

    // Read the signature data from the jbytearray
    const unsigned char *data = new unsigned char[aLength];
    aJni->GetByteArrayRegion(aData, aOffset, aLength, (signed char*) data);

    int result = EVP_VerifyUpdate(mdctx, (const void *) data,
                                  (unsigned int) aLength);

    if (!mIsUpdated)
    {
        mIsUpdated = true;
    }
    LOG(ESATSA, EInfo, "STSRSASignature::Update: return result");
    return result;
}

} // namespace satsa
} // namespace java