/*
* Copyright (c) 2007-2007 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:
*
*/


#include "javasmartcardcertificatesreader.h"
#include "smartcardcryptotokenreader.h"
#include "smartcardcertextrasreader.h"
#include <openssl/x509.h>
#include <openssl/bio.h>

using namespace std;

namespace java
{
namespace security
{

const int SHA_1_DIGEST_LEN = 20;
const int MD5_DIGEST_LEN = 8;

/* forward declarations of local/private methods */
unsigned char * computePublicKeyHash(const HBufC8*);
void computeCertHash(const char *, int, string&);

void JavaSmartCardCertificatesReader::retrieveTrustedCertificates(vector<TrustedCertificate>& aTrustedCerts)
{
    // retrieve the smart card certificates
    SmartCardCryptoTokenReader* smartCardCertsReader = SmartCardCryptoTokenReader::NewL();
    RArray<HBufC8*> smartCardCerts;
    smartCardCertsReader->RetrieveCerts(smartCardCerts);
    delete smartCardCertsReader;
    smartCardCertsReader = NULL;

    // retrieve the smart card certificates trusted usages
    SmartCardCertExtrasReader* smartCardCertsExtrasReader = SmartCardCertExtrasReader::NewL();
    RCPointerArray<HBufC> smartCardCertTrustedUsages;
    for (int i=0; i<smartCardCerts.Count(); i++)
    {
        // compute the SHA1 hash of the public key
        unsigned char * publicKeyHash = computePublicKeyHash(smartCardCerts[i]);
        if (publicKeyHash)
        {
            // retrieve the certificate's extra info
            TPtrC8 ptrPublicKeyHash((TUint8 *)publicKeyHash, SHA_1_DIGEST_LEN);
            smartCardCertsExtrasReader->GetCertTrustedUsages(ptrPublicKeyHash, smartCardCertTrustedUsages);
            // filter the retrieved trusted usages
            vector<string> trustedUsage;
            for (int j=0; j<smartCardCertTrustedUsages.Count(); j++)
            {
                HBufC8 *buf8 = HBufC8::NewMaxL(smartCardCertTrustedUsages[j]->Length());
                buf8->Des().Copy(smartCardCertTrustedUsages[j]->Des());
                string usage((const char *)buf8->Ptr(), buf8->Length());
                delete buf8;
                buf8 = NULL;
                trustedUsage.push_back(usage);
            }
            // format the public key hash as HEX
            string hash = "";
            computeCertHash((const char*)smartCardCerts[i]->Ptr(), smartCardCerts[i]->Length(), hash);
            if (hash.size() > 0)
            {
                // save the certificate together with it's trusted usage
                aTrustedCerts.push_back(TrustedCertificate(string(
                                            (const char*)smartCardCerts[i]->Ptr(),
                                            smartCardCerts[i]->Length()),
                                        hash,
                                        trustedUsage));
            }

            // cleanup
            delete[] publicKeyHash;
            publicKeyHash = NULL;
        }
        delete smartCardCerts[i];
    }
    smartCardCerts.Close();
    smartCardCertTrustedUsages.Close();
    delete smartCardCertsExtrasReader;
    smartCardCertsExtrasReader = NULL;
}

unsigned char * computePublicKeyHash(const HBufC8* smartCardCert)
{
    unsigned char * publicKeyHash = NULL;
    X509 *x509 = NULL;
    BIO *bio;
    bio = BIO_new_mem_buf((void *) smartCardCert->Ptr(), smartCardCert->Length());
    if ((bio))
    {
        BIO_set_close(bio, BIO_CLOSE);
        x509 = d2i_X509_bio(bio,NULL);
        BIO_free(bio);
        if (x509)
        {
            ASN1_BIT_STRING* publicKey = X509_get_X509_PUBKEY(x509)->public_key;
            publicKeyHash = new unsigned char[SHA_1_DIGEST_LEN + 1];
            SHA1(publicKey->data,publicKey->length,publicKeyHash);
            publicKeyHash[SHA_1_DIGEST_LEN] = '\0';
            delete x509;
            x509 = NULL;
        }
    }
    return publicKeyHash;
}


void computeCertHash(const char * cert, int certLen, string& hash)
{
    char computed_hash[MD5_DIGEST_LEN + 1];
    computed_hash[0] = '\0';
    X509 *x509 = NULL;
    BIO *bio;
    bio = BIO_new_mem_buf((void *) cert, certLen);
    if ((bio))
    {
        BIO_set_close(bio, BIO_CLOSE);
        x509 = d2i_X509_bio(bio,NULL);
        BIO_free(bio);
        if (x509)
        {
            sprintf(computed_hash,"%08lX",X509_issuer_name_hash(x509));
            // add the '\0'
            computed_hash[MD5_DIGEST_LEN] = '\0';
            delete x509;
            x509 = NULL;
        }
    }
    hash += string(computed_hash, MD5_DIGEST_LEN);
}

} //end namespace security
} //end namespace java