/*

* 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 STSSignatureFactory

 *

*/

#include <x509cert.h>

#include <openssl/evp.h>

#include "javajniutils.h"

#include "stssignaturefactory.h"

#include "stsrsasignature.h"

#include "stsdsasignature.h"

#include "stsconstants.h"

#include "logger.h"

namespace java

{

namespace satsa

{

STSSignature* STSSignatureFactory::CreateSignature(JNIEnv* aJni,

        const jstring aAlgorithm, int* errCode)

{

    LOG(ESATSA, EInfo, "STSSignatureFactory::CreateSignature+");

    std::wstring padding;

    std::wstring algorithm;

    //convert the jstring to native string

    std::wstring sigstr;

    try

    {

        sigstr = java::util::JniUtils::jstringToWstring(aJni, aAlgorithm);

    }

    catch (...)

    {

        ELOG(ESATSA, "CreateSignature: caught exception. Return error code");

        *errCode = KSTSErrNoSuchAlgorithm;

        return NULL;

    }

    // Algorithm is a form of <padding>with<algorithm>

    int index = sigstr.find(STSSignatureSeparator);

    // String must contain 'with'

    if (index == wstring::npos)

    {

        ELOG(ESATSA, "CreateSignature: No Such Algorithm");

        *errCode = KSTSErrNoSuchAlgorithm;

        return NULL;

    }

    // Get padding part

    padding.assign(sigstr, 0, index);

    // Skip 'with'

    index += STSSignatureSeparatorLength;

    // Get algorithm part

    algorithm.assign(sigstr, index, wstring::npos);

    // return null if there isn't padding or algorithm

    if (padding.length() <= 0 || algorithm.length() <= 0)

    {

        ELOG(ESATSA, "CreateSignature:there isn't padding or algorithm ");

        *errCode = KSTSErrNoSuchAlgorithm;

        return NULL;

    }

    // With signatures padding name "SHA1" must be used and Message digest

    // algorithm name is "SHA-1".

    if (padding == STSDigestSHA1Signature)

    {

        padding.assign(STSDigestSHA1);

    }

    STSSignature* signature = NULL;

    OpenSSL_add_all_digests();

    if (algorithm == STSAlgorithmDSA)

    {

        signature = STSDSASignature::Create(padding, errCode);

    }

    else if (algorithm == STSAlgorithmRSA)

    {

        signature = STSRSASignature::Create(padding, errCode);

    }

    else

    {

        // Algorithm is not supported

        ELOG(ESATSA, "CreateSignature:algorithm is not supported ");

        *errCode = KSTSErrNoSuchAlgorithm;

        return NULL;

    }

    if (*errCode == 0)

    {

        //no errors, return the signature object

        return signature;

    }

    else

    {

        ELOG(ESATSA, "STSSignatureFactory::CreateSignature:Error, return NULL");

        return NULL;

    }

}

jboolean STSSignatureFactory::IsSupportedAlgorithm(JNIEnv* aJni,

        const jstring aAlgorithm)

{

    LOG(ESATSA, EInfo, "STSSignatureFactory::IsSupportedAlgorithm+");

    //convert the jstring to native string

    std::wstring algorithm;

    try

    {

        algorithm = java::util::JniUtils::jstringToWstring(aJni, aAlgorithm);

    }

    catch (...)

    {

        ELOG(ESATSA, "IsSupportedAlgorithm:caught exception. Return error code");

        return false;

    }

    // RSA and DSA algorithms are supported.

    if (algorithm == STSAlgorithmRSA || algorithm == STSAlgorithmDSA)

    {

        return true;

    }

    else

    {

        ELOG(ESATSA, "IsSupportedAlgorithm:Algorithm is not supported");

        return false;

    }

}

jint STSSignatureFactory::IsValidKey(JNIEnv* aJni, const jstring aAlgorithm,

                                     const jstring aKeyFormat, const jbyteArray aKeyEncoded)

{

    LOG(ESATSA, EInfo, "STSSignatureFactory::IsValidKey+");

    std::wstring algorithm;

    try

    {

        algorithm = java::util::JniUtils::jstringToWstring(aJni, aAlgorithm);

    }

    catch (...)

    {

        ELOG(ESATSA, "IsValidKey: caught exception. Return error code");

        return KSTSErrNotSupported;

    }

    // only X.509 keyformat is supported

    std::wstring format;

    try

    {

        format = java::util::JniUtils::jstringToWstring(aJni, aKeyFormat);

    }

    catch (...)

    {

        ELOG(ESATSA, "IsValidKey: caught exception. Return error code");

        return KSTSErrNotSupported;

    }

    if (format != STSKeyFormatX509)

    {

        ELOG(ESATSA, "IsValidKey:Key Format Not Supported");

        return KSTSErrNotSupported;

    }

    // check the algorithm from the subject public info.

    //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);

    //check if RSA

    RSA* iRSA = NULL;

    iRSA = d2i_RSA_PUBKEY(&iRSA, &key, (long) key_length);

    if (iRSA == NULL)

    {

        //check for DSA

        DSA* iDSA = NULL;

        iDSA = d2i_DSA_PUBKEY(&iDSA, &key, (long) key_length);

        if (iDSA == NULL)

        {

            //Not RSA or DSA

            ELOG(ESATSA, "STSSignatureFactory::IsValidKey: Neither RSA nor DSA");

            return KSTSErrNotSupported;

        }

        else

        {

            //Check if algorithm is DSA as Key is for DSA

            if (algorithm == STSAlgorithmDSA)

            {

                return 0;

            }

            else

            {

                ELOG(ESATSA, "IsValidKey: DSA not supported");

                return KSTSErrNotSupported;

            }

        }

    }

    else

    {

        //Key is for RSA check the algorithm whether its RSA

        if (algorithm == STSAlgorithmRSA)

        {

            return 0;

        }

        else

        {

            ELOG(ESATSA, "IsValidKey: RSA not supported");

            return KSTSErrNotSupported;

        }

    }

}

} // namespace satsa

} // namespace java