/*

 * Copyright (c) 2005, 2018, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

//=--------------------------------------------------------------------------=

// security.cpp    by Stanley Man-Kit Ho

//=--------------------------------------------------------------------------=

//

#include <jni.h>

#include "jni_util.h"

#include <stdlib.h>

#include <string.h>

#include <windows.h>

#include <BaseTsd.h>

#include <wincrypt.h>

#include <stdio.h>

#include <memory>

#include "sun_security_mscapi_CKey.h"

#include "sun_security_mscapi_CKeyStore.h"

#include "sun_security_mscapi_PRNG.h"

#include "sun_security_mscapi_CRSACipher.h"

#include "sun_security_mscapi_CKeyPairGenerator_RSA.h"

#include "sun_security_mscapi_CPublicKey.h"

#include "sun_security_mscapi_CPublicKey_CRSAPublicKey.h"

#include "sun_security_mscapi_CSignature.h"

#include "sun_security_mscapi_CSignature_RSA.h"

#define OID_EKU_ANY         "2.5.29.37.0"

#define CERTIFICATE_PARSING_EXCEPTION \

                            "java/security/cert/CertificateParsingException"

#define INVALID_KEY_EXCEPTION \

                            "java/security/InvalidKeyException"

#define KEY_EXCEPTION       "java/security/KeyException"

#define KEYSTORE_EXCEPTION  "java/security/KeyStoreException"

#define PROVIDER_EXCEPTION  "java/security/ProviderException"

#define SIGNATURE_EXCEPTION "java/security/SignatureException"

#define OUT_OF_MEMORY_ERROR "java/lang/OutOfMemoryError"

#define SS_CHECK(Status) \

        if (Status != ERROR_SUCCESS) { \

            ThrowException(env, SIGNATURE_EXCEPTION, Status); \

            __leave; \

        }

#define PP(fmt, ...) \

        if (trace) { \

            fprintf(stdout, "MSCAPI (%ld): ", __LINE__); \

            fprintf(stdout, fmt, ##__VA_ARGS__); \

            fprintf(stdout, "\n"); \

            fflush(stdout); \

        }

extern "C" {

char* trace = getenv("CAPI_TRACE");

/*

 * Declare library specific JNI_Onload entry if static build

 */

DEF_STATIC_JNI_OnLoad

void showProperty(NCRYPT_HANDLE hKey);

void dump(LPSTR title, PBYTE data, DWORD len)

{

    if (trace) {

        printf("==== %s ====\n", title);

        for (DWORD i = 0; i < len; i+=16) {

            printf("%04x: ", i);

            for (int j = 0; j < 16; j++) {

                if (j == 8) {

                    printf("  ");

                }

                if (i + j < len) {

                    printf("%02X ", *(data + i + j) & 0xff);

                } else {

                    printf("   ");

                }

            }

            for (int j = 0; j < 16; j++) {

                if (i + j < len) {

                    int k = *(data + i + j) & 0xff;

                    if (k < 32 || k > 127) printf(".");

                    else printf("%c", (char)k);

                }

            }

            printf("\n");

        }

        fflush(stdout);

    }

}

/*

 * Throws an arbitrary Java exception with the given message.

 */

void ThrowExceptionWithMessage(JNIEnv *env, const char *exceptionName,

                               const char *szMessage)

{

    jclass exceptionClazz = env->FindClass(exceptionName);

    if (exceptionClazz != NULL) {

        env->ThrowNew(exceptionClazz, szMessage);

    }

}

/*

 * Throws an arbitrary Java exception.

 * The exception message is a Windows system error message.

 */

void ThrowException(JNIEnv *env, const char *exceptionName, DWORD dwError)

{

    char szMessage[1024];

    szMessage[0] = '\0';

    DWORD res = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwError,

        NULL, szMessage, sizeof(szMessage), NULL);

    if (res == 0) {

        strcpy(szMessage, "Unknown error");

    }

    ThrowExceptionWithMessage(env, exceptionName, szMessage);

}

/*

 * Overloaded 'operator new[]' variant, which will raise Java's

 * OutOfMemoryError in the case of a failure.

 */

void* operator new[](std::size_t size, JNIEnv *env)

{

    void* buf = ::operator new[](size, std::nothrow);

    if (buf == NULL) {

        ThrowExceptionWithMessage(env, OUT_OF_MEMORY_ERROR,

                "Native memory allocation failed");

    }

    return buf;

}

/*

 * Maps the name of a hash algorithm to an algorithm identifier.

 */

ALG_ID MapHashAlgorithm(JNIEnv *env, jstring jHashAlgorithm) {

    const char* pszHashAlgorithm = NULL;

    ALG_ID algId = 0;

    if ((pszHashAlgorithm = env->GetStringUTFChars(jHashAlgorithm, NULL))

        == NULL) {

        return algId;

    }

    if ((strcmp("SHA", pszHashAlgorithm) == 0) ||

        (strcmp("SHA1", pszHashAlgorithm) == 0) ||

        (strcmp("SHA-1", pszHashAlgorithm) == 0)) {

        algId = CALG_SHA1;

    } else if (strcmp("SHA1+MD5", pszHashAlgorithm) == 0) {

        algId = CALG_SSL3_SHAMD5; // a 36-byte concatenation of SHA-1 and MD5

    } else if (strcmp("SHA-256", pszHashAlgorithm) == 0) {

        algId = CALG_SHA_256;

    } else if (strcmp("SHA-384", pszHashAlgorithm) == 0) {

        algId = CALG_SHA_384;

    } else if (strcmp("SHA-512", pszHashAlgorithm) == 0) {

        algId = CALG_SHA_512;

    } else if (strcmp("MD5", pszHashAlgorithm) == 0) {

        algId = CALG_MD5;

    } else if (strcmp("MD2", pszHashAlgorithm) == 0) {

        algId = CALG_MD2;

    }

    if (pszHashAlgorithm)

        env->ReleaseStringUTFChars(jHashAlgorithm, pszHashAlgorithm);

   return algId;

}

/*

 * Maps the name of a hash algorithm to a CNG Algorithm Identifier.

 */

LPCWSTR MapHashIdentifier(JNIEnv *env, jstring jHashAlgorithm) {

    const char* pszHashAlgorithm = NULL;

    LPCWSTR id = NULL;

    if ((pszHashAlgorithm = env->GetStringUTFChars(jHashAlgorithm, NULL))

            == NULL) {

        return id;

    }

    if ((strcmp("SHA", pszHashAlgorithm) == 0) ||

        (strcmp("SHA1", pszHashAlgorithm) == 0) ||

        (strcmp("SHA-1", pszHashAlgorithm) == 0)) {

        id = BCRYPT_SHA1_ALGORITHM;

    } else if (strcmp("SHA-256", pszHashAlgorithm) == 0) {

        id = BCRYPT_SHA256_ALGORITHM;

    } else if (strcmp("SHA-384", pszHashAlgorithm) == 0) {

        id = BCRYPT_SHA384_ALGORITHM;

    } else if (strcmp("SHA-512", pszHashAlgorithm) == 0) {

        id = BCRYPT_SHA512_ALGORITHM;

    }

    if (pszHashAlgorithm)

        env->ReleaseStringUTFChars(jHashAlgorithm, pszHashAlgorithm);

    return id;

}

/*

 * Returns a certificate chain context given a certificate context and key

 * usage identifier.

 */

bool GetCertificateChain(LPSTR lpszKeyUsageIdentifier, PCCERT_CONTEXT pCertContext, PCCERT_CHAIN_CONTEXT* ppChainContext)

{

    CERT_ENHKEY_USAGE        EnhkeyUsage;

    CERT_USAGE_MATCH         CertUsage;

    CERT_CHAIN_PARA          ChainPara;

    DWORD                    dwFlags = 0;

    LPSTR                    szUsageIdentifierArray[1];

    szUsageIdentifierArray[0] = lpszKeyUsageIdentifier;

    EnhkeyUsage.cUsageIdentifier = 1;

    EnhkeyUsage.rgpszUsageIdentifier = szUsageIdentifierArray;

    CertUsage.dwType = USAGE_MATCH_TYPE_AND;

    CertUsage.Usage  = EnhkeyUsage;

    ChainPara.cbSize = sizeof(CERT_CHAIN_PARA);

    ChainPara.RequestedUsage=CertUsage;

    // Build a chain using CertGetCertificateChain

    // and the certificate retrieved.

    return (::CertGetCertificateChain(NULL,     // use the default chain engine

                pCertContext,   // pointer to the end certificate

                NULL,           // use the default time

                NULL,           // search no additional stores

                &ChainPara,     // use AND logic and enhanced key usage

                                //  as indicated in the ChainPara

                                //  data structure

                dwFlags,

                NULL,           // currently reserved

                ppChainContext) == TRUE);       // return a pointer to the chain created

}

/////////////////////////////////////////////////////////////////////////////

//

/*

 * Class:     sun_security_mscapi_PRNG

 * Method:    getContext

 * Signature: ()J

 */

JNIEXPORT jlong JNICALL Java_sun_security_mscapi_PRNG_getContext

        (JNIEnv *env, jclass clazz) {

    HCRYPTPROV hCryptProv = NULL;

    if(::CryptAcquireContext( //deprecated

       &hCryptProv,

       NULL,

       NULL,

       PROV_RSA_FULL,

       CRYPT_VERIFYCONTEXT) == FALSE)

    {

        ThrowException(env, PROVIDER_EXCEPTION, GetLastError());

    }

    return hCryptProv;

}

/*

 * Class:     sun_security_mscapi_PRNG

 * Method:    releaseContext

 * Signature: (J)V

 */

JNIEXPORT void JNICALL Java_sun_security_mscapi_PRNG_releaseContext

        (JNIEnv *env, jclass clazz, jlong ctxt) {

    if (ctxt) {

        ::CryptReleaseContext((HCRYPTPROV)ctxt, 0); //deprecated

    }

}

/*

 * Class:     sun_security_mscapi_PRNG

 * Method:    generateSeed

 * Signature: (JI[B)[B

 */

JNIEXPORT jbyteArray JNICALL Java_sun_security_mscapi_PRNG_generateSeed

  (JNIEnv *env, jclass clazz, jlong ctxt, jint length, jbyteArray seed)

{

    HCRYPTPROV hCryptProv = (HCRYPTPROV)ctxt;

    jbyte*     reseedBytes = NULL;

    jbyte*     seedBytes = NULL;

    jbyteArray result = NULL;

    __try

    {

        /*

         * If length is negative then use the supplied seed to re-seed the

         * generator and return null.

         * If length is non-zero then generate a new seed according to the

         * requested length and return the new seed.

         * If length is zero then overwrite the supplied seed with a new

         * seed of the same length and return the seed.

         */

        if (length < 0) {

            length = env->GetArrayLength(seed);

            if ((reseedBytes = env->GetByteArrayElements(seed, 0)) == NULL) {

                __leave;

            }

            if (::CryptGenRandom( //deprecated

                hCryptProv,

                length,

                (BYTE *) reseedBytes) == FALSE) {

                ThrowException(env, PROVIDER_EXCEPTION, GetLastError());

                __leave;

            }

            result = NULL;

        } else {

            if (length > 0) {

                seed = env->NewByteArray(length);

                if (seed == NULL) {

                    __leave;

                }

            } else {

                length = env->GetArrayLength(seed);

            }

            if ((seedBytes = env->GetByteArrayElements(seed, 0)) == NULL) {

                __leave;

            }

            if (::CryptGenRandom( //deprecated

                hCryptProv,

                length,

                (BYTE *) seedBytes) == FALSE) {

                ThrowException(env, PROVIDER_EXCEPTION, GetLastError());

                __leave;

            }

            result = seed; // seed will be updated when seedBytes gets released

        }

    }

    __finally

    {

        //--------------------------------------------------------------------

        // Clean up.

        if (reseedBytes)

            env->ReleaseByteArrayElements(seed, reseedBytes, JNI_ABORT);

        if (seedBytes)

            env->ReleaseByteArrayElements(seed, seedBytes, 0); // update orig

    }

    return result;

}

/*

 * Class:     sun_security_mscapi_CKeyStore

 * Method:    loadKeysOrCertificateChains

 * Signature: (Ljava/lang/String;)V

 */

JNIEXPORT void JNICALL Java_sun_security_mscapi_CKeyStore_loadKeysOrCertificateChains

  (JNIEnv *env, jobject obj, jstring jCertStoreName)

{

    /**

     * Certificate in cert store has enhanced key usage extension

     * property (or EKU property) that is not part of the certificate itself. To determine

     * if the certificate should be returned, both the enhanced key usage in certificate

     * extension block and the extension property stored along with the certificate in

     * certificate store should be examined. Otherwise, we won't be able to determine

     * the proper key usage from the Java side because the information is not stored as

     * part of the encoded certificate.

     */

    const char* pszCertStoreName = NULL;

    HCERTSTORE hCertStore = NULL;

    PCCERT_CONTEXT pCertContext = NULL;

    char* pszNameString = NULL; // certificate's friendly name

    DWORD cchNameString = 0;

    __try

    {

        // Open a system certificate store.

        if ((pszCertStoreName = env->GetStringUTFChars(jCertStoreName, NULL))

            == NULL) {

            __leave;

        }

        if ((hCertStore = ::CertOpenSystemStore(NULL, pszCertStoreName))

            == NULL) {

            ThrowException(env, KEYSTORE_EXCEPTION, GetLastError());

            __leave;

        }

        // Determine clazz and method ID to generate certificate

        jclass clazzArrayList = env->FindClass("java/util/ArrayList");

        if (clazzArrayList == NULL) {

            __leave;

        }

        jmethodID mNewArrayList = env->GetMethodID(clazzArrayList, "<init>", "()V");

        if (mNewArrayList == NULL) {

            __leave;

        }

        jclass clazzOfThis = env->GetObjectClass(obj);

        if (clazzOfThis == NULL) {

            __leave;

        }

        jmethodID mGenCert = env->GetMethodID(clazzOfThis,

                                              "generateCertificate",

                                              "([BLjava/util/Collection;)V");

        if (mGenCert == NULL) {

            __leave;

        }

        // Determine method ID to generate certificate chain

        jmethodID mGenCertChain = env->GetMethodID(clazzOfThis,

                                                   "generateCertificateChain",

                                                   "(Ljava/lang/String;Ljava/util/Collection;)V");

        if (mGenCertChain == NULL) {

            __leave;

        }

        // Determine method ID to generate RSA certificate chain

        jmethodID mGenKeyAndCertChain = env->GetMethodID(clazzOfThis,

                                                   "generateKeyAndCertificateChain",

                                                   "(ZLjava/lang/String;JJILjava/util/Collection;)V");

        if (mGenKeyAndCertChain == NULL) {

            __leave;

        }

        // Use CertEnumCertificatesInStore to get the certificates

        // from the open store. pCertContext must be reset to

        // NULL to retrieve the first certificate in the store.

        while (pCertContext = ::CertEnumCertificatesInStore(hCertStore, pCertContext))

        {

            PP("--------------------------");

            // Check if private key available - client authentication certificate

            // must have private key available.

            HCRYPTPROV hCryptProv = NULL;

            DWORD dwKeySpec = 0;

            HCRYPTKEY hUserKey = NULL;

            BOOL bCallerFreeProv = FALSE;

            BOOL bHasNoPrivateKey = FALSE;

            DWORD dwPublicKeyLength = 0;

            // First, probe it silently

            if (::CryptAcquireCertificatePrivateKey(pCertContext,

                    CRYPT_ACQUIRE_ALLOW_NCRYPT_KEY_FLAG | CRYPT_ACQUIRE_SILENT_FLAG, NULL,

                    &hCryptProv, &dwKeySpec, &bCallerFreeProv) == FALSE

                && GetLastError() != NTE_SILENT_CONTEXT)

            {

                PP("bHasNoPrivateKey = TRUE!");

                bHasNoPrivateKey = TRUE;

            }

            else

            {

                if (bCallerFreeProv == TRUE) {

                    ::CryptReleaseContext(hCryptProv, NULL); // deprecated

                    bCallerFreeProv = FALSE;

                }

                // Second, acquire the key normally (not silently)

                if (::CryptAcquireCertificatePrivateKey(pCertContext, CRYPT_ACQUIRE_ALLOW_NCRYPT_KEY_FLAG, NULL,

                        &hCryptProv, &dwKeySpec, &bCallerFreeProv) == FALSE)

                {

                    PP("bHasNoPrivateKey = TRUE!!");

                    bHasNoPrivateKey = TRUE;

                }

                else

                {