/*

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

 *

*/

#include "stsrsacipher.h"

#include "stsconstants.h"

#include  <asymmetric.h>

#include <x509cert.h>

#include <hash.h>

#include <asymmetrickeys.h>

#include <asymmetric.h>

#include <asnpkcs.h>

#include <asn1dec.h>

#include "logger.h"

namespace java

{

namespace satsa

{

STSRSACipher::STSRSACipher()

{

    mRSA = NULL;

    mpkey = NULL;

}

STSRSACipher* STSRSACipher::Create(int* errCode)

{

    STSRSACipher* self = new STSRSACipher;

    if (self == NULL)

    {

        *errCode = KSTSErrNoMemory;

        return NULL;

    }

    else

    {

        *errCode = 0;

        return self;

    }

}

STSRSACipher::~STSRSACipher()

{

}

jint STSRSACipher::DoInit(JNIEnv* aJni, const TCipherMode aMode,

                          const jstring /*aKeyAlgorithm*/, const jstring /*aKeyFormat*/,

                          const jbyteArray aKeyEncoded, const jbyteArray aParams)

{

    LOG(ESATSA, EInfo, "STSRSACipher::DoInit+");

    if (aParams)

    {

        ELOG(ESATSA, "STSRSACipher::DoInit:RSA algorithm cannot have parameters");

        // RSA algorithm cannot have parameters

        return KSTSErrArgument;

    }

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

    if (aMode == EEncryptMode)

    {

        LOG(ESATSA, EInfo, "STSRSACipher::DoInit:encryption mode");

        // encryption mode: read the public key from subject public key info

        // decode the encoded key data into a RSA data structure.

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

        if (mRSA == NULL)

        {

            ELOG(ESATSA, "STSRSACipher::DoInit:Failed to get proper data");

            return KSTSErrInvalidKey;

        }

    }

    else

    {

        LOG(ESATSA, EInfo, "STSRSACipher::DoInit:decryption mode");

        // decryption mode: decode the private key in PKCS8 format encoded in

        // ASN1 DER format

        // load the algorithm lookup tables

        OpenSSL_add_all_algorithms();

        // create the BIO pointer

        BIO *bp;

        bp = BIO_new_mem_buf((void *) key, key_length);

        // Decode the PKCS8 key from the der encoded key data

        mpkey = EVP_PKEY_new();

        if (NULL == mpkey)

        {

            ELOG(ESATSA, "STSRSACipher::DoInit:Key is null");

            return KSTSErrNoMemory;

        }

        mpkey = d2i_PKCS8PrivateKey_bio(bp, &mpkey, NULL, NULL);

        if (mpkey == NULL)

        {

            ELOG(ESATSA, "STSRSACipher::DoInit:key is improper");

            return KSTSErrInvalidKey;

        }

        // Create the RSA data structure to be used for decryption

        mRSA = EVP_PKEY_get1_RSA(mpkey);

        if (mRSA == NULL)

        {

            ELOG(ESATSA, "STSRSACipher::DoInit:failed to create rsa data");

            return KSTSErrInvalidKey;

        }

    }

    // Init success and mode can be changed

    mMode = aMode;

    LOG(ESATSA, EInfo, "STSRSACipher::DoInit--");

    return 0;

}

jint STSRSACipher::DoFinal(JNIEnv* aJni, jbyteArray aInput, jint aInputOffset,

                           jint aInputLength, jbyteArray aOutput, jint aOutputOffset)

{

    LOG(ESATSA, EInfo, "STSRSACipher::DoFinal+");

    int output_length = 0;

    if (mRSA == NULL)

    {

        // Init was not called successfully.

        ELOG(ESATSA, "STSRSACipher::DoFinal:Init was not called successfully.");

        return (KSTSErrIllegalState);

    }

    //read the input data to be encrypted/decrypted

    unsigned char* inputBuf = new unsigned char[aInputLength];

    aJni->GetByteArrayRegion(aInput, aInputOffset, aInputLength,

                             (signed char *) inputBuf);

    int max_output_length = RSA_size(mRSA);

    unsigned char* outputBuf = new unsigned char[max_output_length];

    if (mMode == EEncryptMode)

    {

        if (aInputLength > (max_output_length - 11))

        {

            ELOG(ESATSA, "STSRSACipher::DoFinal:Wrong Input length");

            return (KSTSErrIllegalState);

        }

        // encrypt the data

        output_length = RSA_public_encrypt(aInputLength, inputBuf, outputBuf,

                                           mRSA, RSA_PKCS1_PADDING);

        if (output_length > aJni->GetArrayLength(aOutput))

        {

            ELOG(ESATSA, "STSRSACipher::DoFinal:short output buffer");

            return (KSTSErrShortBuffer);

        }

        aJni->SetByteArrayRegion(aOutput, aOutputOffset, output_length,

                                 (signed char *) outputBuf);

    }

    else // Decrypt mode

    {

        // decrypt the data

        output_length = RSA_private_decrypt(aInputLength, inputBuf, outputBuf,

                                            mRSA, RSA_PKCS1_PADDING);

        if (output_length > aJni->GetArrayLength(aOutput))

        {

            ELOG(ESATSA, "STSRSACipher::DoFinal:wrong output length");

            return (KSTSErrShortBuffer);

        }

        // encryption/decryption successfully completed

        aJni->SetByteArrayRegion(aOutput, aOutputOffset, output_length,

                                 (signed char *) outputBuf);

    }

    LOG(ESATSA, EInfo, "STSRSACipher::DoFinal:--");

    return output_length;

}

jint STSRSACipher::Update(JNIEnv* aJni, jbyteArray aInput, jint aInputOffset,

                          jint aInputLength, jbyteArray aOutput, jint aOutputOffset)

{

    LOG(ESATSA, EInfo, "STSRSACipher::Update+");

    int output_length = 0;

    if (mRSA == NULL)

    {

        ELOG(ESATSA, "STSRSACipher::Update:Init was not called successfully.");

        // Init was not called successfully.

        return (KSTSErrIllegalState);

    }

    // read the input data to be encrypted/decrypted

    unsigned char* inputBuf = new unsigned char[aInputLength];

    aJni->GetByteArrayRegion(aInput, aInputOffset, aInputLength,

                             (signed char *) inputBuf);

    int max_output_length = RSA_size(mRSA);

    unsigned char* outputBuf = new unsigned char[max_output_length];

    if (mMode == EEncryptMode)

    {

        if (aInputLength > (max_output_length - 11))

        {

            ELOG(ESATSA, "STSRSACipher::Update:wrong input length.");

            return (KSTSErrIllegalStateInput);

        }

        // encrypt the data

        output_length = RSA_public_encrypt(aInputLength, inputBuf, outputBuf,

                                           mRSA, RSA_PKCS1_PADDING);

        if (output_length > aJni->GetArrayLength(aOutput))

        {

            ELOG(ESATSA, "STSRSACipher::Update:wrong output length");

            return (KSTSErrShortBuffer);

        }

        aJni->SetByteArrayRegion(aOutput, aOutputOffset, output_length,

                                 (signed char *) outputBuf);

    }

    else // Decrypt mode

    {

        // decrypt the data

        output_length = RSA_private_decrypt(aInputLength, inputBuf, outputBuf,

                                            mRSA, RSA_PKCS1_PADDING);

        if (output_length > aJni->GetArrayLength(aOutput))

        {

            return (KSTSErrShortBuffer);

        }

        // encryption/decryption successfully completed

        aJni->SetByteArrayRegion(aOutput, aOutputOffset, output_length,

                                 (signed char *) outputBuf);

    }

    LOG(ESATSA, EInfo, "STSRSACipher::Update--");

    return output_length;

}

} // namespace satsa

} // namespace java