/*
* 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 STSDSASignature
 *
*/



#include <x509cert.h>
#include <asymmetric.h>

#include "stsconstants.h"
#include "stsdsasignature.h"

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

namespace java
{
namespace satsa
{



STSDSASignature::STSDSASignature():mDSA(0), mpkey(0)
{

}


inline int STSDSASignature::Construct(const std::wstring aPadding)
{
    // Create digest object according to aAlgorithm
    if (aPadding == STSDigestSHA1)
    {
        md = EVP_dss1();
    }
    else if (aPadding == STSDigestMD2)
    {
        md = EVP_md2();
    }
    else if (aPadding == STSDigestMD5)
    {
        md = EVP_md5();
    }
    else
    {
        // Algorithm was not found
        return KSTSErrDigest;
    }
    if (md == NULL)
    {
        return KSTSErrDigest;
    }
    else
    {

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

}


STSDSASignature* STSDSASignature::Create(const std::wstring aPadding,
        int* errCode)
{
    LOG(ESATSA, EInfo, "STSDSASignature::Create+");
    STSDSASignature* self = new STSDSASignature;
    if (self == NULL)
    {
        // object was not created successfully
        ELOG(ESATSA,
             "STSDSASignature::Create: 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;
        }
    }
}


STSDSASignature::~STSDSASignature()
{

    if (0 != mpkey)
    {
        EVP_PKEY_free(mpkey);
    }
    if (0 != mDSA)
    {
        delete mDSA;
        mDSA = 0;
    }

}

int STSDSASignature::InitVerify(JNIEnv* aJni, jstring aKeyAlgorithm,
                                jstring aKeyFormat, jbyteArray aKeyEncoded)
{
    LOG(ESATSA, EInfo, "STSDSASignature::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, "caught exception. Return error code");
        return (KSTSErrInvalidKey);
    }
    if (key_algorithm != STSAlgorithmDSA)
    {
        ELOG(ESATSA, "Invalid Key");
        return (KSTSErrInvalidKey);
    }
    // Format: Only X509 keys are supported
    std::wstring key_format;
    try
    {
        key_format = java::util::JniUtils::jstringToWstring(aJni, aKeyFormat);
    }
    catch (...)
    {
        ELOG(ESATSA, "caught exception. Return error code");
        return (KSTSErrInvalidKey);
    }
    if (key_format != STSKeyFormatX509)
    {
        ELOG(ESATSA, "Wrong Key Format");
        return (KSTSErrInvalidKey);
    }

    // Read the encoded key from the jbytearray
    int key_length = aJni->GetArrayLength(aKeyEncoded);
    const unsigned char *key = new unsigned char[key_length];
    aJni->GetByteArrayRegion(aKeyEncoded, 0, key_length, (signed char*) key);

    mDSA = d2i_DSA_PUBKEY(&mDSA, &key, (long) key_length);
    if (mDSA == NULL)
    {
        ELOG(ESATSA, "Key is not ok");
        return KSTSErrInvalidKey;
    }

    mpkey = EVP_PKEY_new();
    EVP_PKEY_set1_DSA(mpkey, mDSA);

    retVal = EVP_VerifyInit_ex(mdctx, md, NULL);
    LOG(ESATSA, EInfo, "STSDSASignature::InitVerify--");
    return retVal;

}

int STSDSASignature::Verify(JNIEnv* aJni, jbyteArray aSignature)
{
    LOG(ESATSA, EInfo, "STSDSASignature::Verify+");
    int result;
    if (mpkey == NULL)
    {
        // Not initialized
        ELOG(ESATSA, "STSDSASignature::Verify: Key is not initialized");
        return KSTSErrSignature;
    }
    if (!mIsUpdated)
    {
        return false;
    }

    if (mdctx == NULL)
    {
        // If data is not updated TCK requires that exception is not thrown and
        // false is returned.
        ELOG(ESATSA, "STSDSASignature::Verify:Data is not upadted");
        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
    const EVP_MD* md = NULL;
    md = EVP_MD_CTX_md(mdctx);
    EVP_MD_CTX_init(mdctx);
    EVP_DigestInit_ex(mdctx, md, NULL);
    if (0 == result)
    {
        return false;
    }
    else if (1 == result)
    {
        return true;
    }
    else
    {
        return KSTSErrSignature;
    }

}

int STSDSASignature::Update(JNIEnv* aJni, jbyteArray aData, jint aOffset,
                            jint aLength)
{
    LOG(ESATSA, EInfo, "STSDSASignature::Update+");
    if (mpkey == NULL)
    {
        ELOG(ESATSA, "STSDSASignature::Update: Key is not initialized");
        // 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, "STSDSASignature::Update--");
    return result;

}
} // namespace satsa
} // namespace java