From cb8cf8a4017e61e02d6e0648f68e4a15f2da869f Mon Sep 17 00:00:00 2001 From: garciay Date: Fri, 20 Mar 2020 15:51:01 +0100 Subject: [PATCH] Bug fixed in lib_its_security --- .../org_etsi_its_security/Makefile | 23 + .../org_etsi_its_security.vcxproj | 173 ++++ .../org_etsi_its_security.vcxproj.user | 4 + .../org_etsi_its_security_NativeSecurity.c | 840 ++++++++++++++++++ .../org_etsi_its_security_NativeSecurity.h | 141 +++ 5 files changed, 1181 insertions(+) create mode 100644 tools/itssecurity/org_etsi_its_security/Makefile create mode 100644 tools/itssecurity/org_etsi_its_security/org_etsi_its_security.vcxproj create mode 100644 tools/itssecurity/org_etsi_its_security/org_etsi_its_security.vcxproj.user create mode 100644 tools/itssecurity/org_etsi_its_security/org_etsi_its_security_NativeSecurity.c create mode 100644 tools/itssecurity/org_etsi_its_security/org_etsi_its_security_NativeSecurity.h diff --git a/tools/itssecurity/org_etsi_its_security/Makefile b/tools/itssecurity/org_etsi_its_security/Makefile new file mode 100644 index 000000000..7dd556d52 --- /dev/null +++ b/tools/itssecurity/org_etsi_its_security/Makefile @@ -0,0 +1,23 @@ +PROJECTROOT = .. +BUILDROOT = ../../build +PROJECT = org_etsi_its_security +DEBUG = yes +testdir = + +alibs = $(PROJECT) +solibs = $(PROJECT) + +sources := org_etsi_its_security_NativeSecurity.c +sources-WIN32 := +headers := org_etsi_its_security_NativeSecurity.h + +cflags += -Werror + +packages += openssl + +includes += ../../lib_its_security /usr/lib/jvm/java-11-openjdk-amd64/include /usr/lib/jvm/java-11-openjdk-amd64/include/linux + +libs += $(outdir)/libItsSecurity.a + +include ../../common.mk + diff --git a/tools/itssecurity/org_etsi_its_security/org_etsi_its_security.vcxproj b/tools/itssecurity/org_etsi_its_security/org_etsi_its_security.vcxproj new file mode 100644 index 000000000..d04c044ff --- /dev/null +++ b/tools/itssecurity/org_etsi_its_security/org_etsi_its_security.vcxproj @@ -0,0 +1,173 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + 16.0 + {B5C77DAC-BC05-426F-8E13-E60BD2732A02} + Win32Proj + orgetsiitssecurity + 10.0 + + + + StaticLibrary + true + v142 + Unicode + + + StaticLibrary + false + v142 + true + Unicode + + + DynamicLibrary + true + v142 + Unicode + + + DynamicLibrary + false + v142 + true + Unicode + + + + + + + + + + + + + + + + + + + + + false + + + true + + + true + + + false + + + + NotUsing + Level3 + true + true + true + _Win64;NDEBUG;_LIB;%(PreprocessorDefinitions) + true + + + C:\Program Files\OpenSSL-Win64\include;C:\Program Files\Java\jdk1.8.0_241\include;C:\Program Files\Java\jdk1.8.0_241\include\win32;$(ProjectDir)../lib_its_security;%(AdditionalIncludeDirectories) + + + Windows + true + true + true + $(ProjectDir)..\x64\Release;C:\Program Files\OpenSSL-Win64\lib\VC + lib_its_security.lib;libcrypto64MDd.lib;libssl64MDd.lib;Ws2_32.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies) + + + cp "$(TargetPath)" "$(MSBuildProjectDirectory)\..\..\..\javasrc\nativeLibs\win32\x86_64" + + + + + Use + Level3 + true + WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions) + true + pch.h + + + Windows + true + + + + + NotUsing + Level3 + true + _Win64;_DEBUG;_LIB;%(PreprocessorDefinitions) + true + pch.h + C:\Program Files\OpenSSL-Win64\include;C:\Program Files\Java\jdk1.8.0_241\include;C:\Program Files\Java\jdk1.8.0_241\include\win32;$(ProjectDir)../lib_its_security;%(AdditionalIncludeDirectories) + + + Windows + true + lib_its_security.lib;libcrypto64MDd.lib;libssl64MDd.lib;Ws2_32.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies) + + + $(ProjectDir)..\x64\Debug;C:\Program Files\OpenSSL-Win64\lib\VC + + + + + Use + Level3 + true + true + true + WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions) + true + pch.h + + + Windows + true + true + true + + + + + + Create + Create + Create + Create + + + + + + \ No newline at end of file diff --git a/tools/itssecurity/org_etsi_its_security/org_etsi_its_security.vcxproj.user b/tools/itssecurity/org_etsi_its_security/org_etsi_its_security.vcxproj.user new file mode 100644 index 000000000..88a550947 --- /dev/null +++ b/tools/itssecurity/org_etsi_its_security/org_etsi_its_security.vcxproj.user @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/tools/itssecurity/org_etsi_its_security/org_etsi_its_security_NativeSecurity.c b/tools/itssecurity/org_etsi_its_security/org_etsi_its_security_NativeSecurity.c new file mode 100644 index 000000000..b47d13fd8 --- /dev/null +++ b/tools/itssecurity/org_etsi_its_security/org_etsi_its_security_NativeSecurity.c @@ -0,0 +1,840 @@ +/* system headers */ +#include +#include +#include +#include +//add whatever is needed +#include +#include "org_etsi_its_security_NativeSecurity.h" + +#include "lib_its_security.h" + +//if you use other memory allocation function, please inform me! +#ifdef WIN32 +DLLAPI void* _tt_calloc(size_t, size_t); +#define calloc(NUM, SIZE) _tt_calloc(NUM, SIZE) +DLLAPI void _tt_free(void*); +#define free(PTR) _tt_free(PTR) +#else +#endif //WIN32 + +#ifdef WIN32 +void* _tt_calloc(size_t num, size_t elemSize) { +#if (_MSC_VER >= 1700) // newer than Visual Studio 2012 + size_t size = num * elemSize; + void* res = CoTaskMemAlloc(size); + memset(res, 0, size); + return res; +#else + return HeapAlloc(GetProcessHeap(), HEAP_GENERATE_EXCEPTIONS | HEAP_ZERO_MEMORY, (num) * (elemSize)); +#endif +} + +void _tt_free(void* ptr) { +#if (_MSC_VER >= 1700) // newer than Visual Studio 2012 + CoTaskMemFree(ptr); +#else + HeapFree(GetProcessHeap(), 0, ptr); +#endif +} +#endif //WIN32 + +/* + * Class: org_etsi_its_security_NativeSecurity + * Method: hashWithSha384 + * Signature: ([B)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_etsi_its_security_NativeSecurity_hashWithSha256(JNIEnv* env, jobject jobj, jbyteArray p_toBeHashedData) { + jbyteArray java_hashed_data; + int32_t result; + + // Extract buffers + size_t to_be_hashed_data_length = (*env)->GetArrayLength(env, p_toBeHashedData); + uint8_t* to_be_hashed_data = (uint8_t*)calloc(sizeof(uint8_t), to_be_hashed_data_length); + (*env)->GetByteArrayRegion(env, p_toBeHashedData, 0, (jsize)to_be_hashed_data_length, (jbyte*)to_be_hashed_data); + // Call lib_its_security implementation + uint8_t* hashed_data = NULL; + result = hash_with_sha256(to_be_hashed_data, to_be_hashed_data_length, &hashed_data); + // Prepare return value + java_hashed_data = (*env)->NewByteArray(env, (jsize)32); + if (result == 0) { + (*env)->SetByteArrayRegion(env, java_hashed_data, 0, (jsize)32, (jbyte*)hashed_data); + } + // Free allocated resources + free(hashed_data); + + return java_hashed_data; +} + +/* + * Class: org_etsi_its_security_NativeSecurity + * Method: hashWithSha384 + * Signature: ([B)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_etsi_its_security_NativeSecurity_hashWithSha384(JNIEnv* env, jobject jobj, jbyteArray p_toBeHashedData) { + jbyteArray java_hashed_data; + int32_t result; + + // Extract buffers + size_t to_be_hashed_data_length = (*env)->GetArrayLength(env, p_toBeHashedData); + uint8_t* to_be_hashed_data = (uint8_t*)calloc(sizeof(uint8_t), to_be_hashed_data_length); + (*env)->GetByteArrayRegion(env, p_toBeHashedData, 0, (jsize)to_be_hashed_data_length, (jbyte*)to_be_hashed_data); + // Call lib_its_security implementation + uint8_t* hashed_data = NULL; + result = hash_with_sha384(to_be_hashed_data, to_be_hashed_data_length, &hashed_data); + // Prepare return value + java_hashed_data = (*env)->NewByteArray(env, (jsize)48); + if (result == 0) { + (*env)->SetByteArrayRegion(env, java_hashed_data, 0, (jsize)48, (jbyte*)hashed_data); + } + // Free allocated resources + free(hashed_data); + + return java_hashed_data; +} + +/* + * Class: org_etsi_its_security_NativeSecurity + * Method: hmacWithSha256 + * Signature: ([B[B)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_etsi_its_security_NativeSecurity_hmacWithSha256(JNIEnv* env, jobject jobj, jbyteArray p_secretKey, jbyteArray p_message) { + jbyteArray java_hmac; + int32_t result; + + // Extract buffers + size_t secret_key_length = (*env)->GetArrayLength(env, p_secretKey); + uint8_t* secret_key = (uint8_t*)calloc(sizeof(uint8_t), secret_key_length); + (*env)->GetByteArrayRegion(env, p_secretKey, 0, (jsize)secret_key_length, (jbyte*)secret_key); + size_t message_length = (*env)->GetArrayLength(env, p_message); + uint8_t* message = (uint8_t*)calloc(sizeof(uint8_t), message_length); + (*env)->GetByteArrayRegion(env, p_message, 0, (jsize)message_length, (jbyte*)message); + + // Call lib_its_security implementation + uint8_t* hmac = NULL; + result = hmac_sha256(secret_key, secret_key_length, message, message_length, &hmac); + // Prepare return value + java_hmac = (*env)->NewByteArray(env, (jsize)16); // HMAC with SHA256 of the message resized to 16 bytes + if (result == 0) { + (*env)->SetByteArrayRegion(env, java_hmac, 0, (jsize)16, (jbyte*)hmac); + } + // Free allocated resources + free(secret_key); + free(message); + free(hmac); + + return java_hmac; +} + +/* + * Class: org_etsi_its_security_NativeSecurity + * Method: signWithEcdsaNistp256WithSha256 + * Signature: ([B[B[B)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_etsi_its_security_NativeSecurity_signWithEcdsaNistp256WithSha256 +(JNIEnv* env, jobject jobj, jbyteArray p_to_be_signed_secured_message, jbyteArray p_certificate_issuer, jbyteArray p_private_key) { + jbyteArray java_signature = NULL; + + //fprintf(stderr, ">>> Java_org_etsi_its_security_NativeSecurity_signWithEcdsaNistp256WithSha256\n"); + + // Create intermal context + lib_its_security_context_t* lib_its_security_context = NULL; + int32_t result = initialize(nist_p_256, &lib_its_security_context); + // fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_signWithEcdsaNistp256WithSha256: result=%d\n", result); + if (result == 0) { + // Extract buffers + size_t to_be_signed_secured_message_length = (*env)->GetArrayLength(env, p_to_be_signed_secured_message); + //fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_signWithEcdsaNistp256WithSha256: to_be_signed_secured_message_length=%ld\n", to_be_signed_secured_message_length); + uint8_t* to_be_signed_secured_message = (uint8_t*)calloc(sizeof(uint8_t), to_be_signed_secured_message_length); + (*env)->GetByteArrayRegion(env, p_to_be_signed_secured_message, 0, (jsize)to_be_signed_secured_message_length, (jbyte*)to_be_signed_secured_message); + size_t certificate_issuer_length = 32;//(*env)->GetArrayLength(env, p_certificate_issuer); + //fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_signWithEcdsaNistp256WithSha256: certificate_issuer_length=%ld\n", certificate_issuer_length); + uint8_t* certificate_issuer = (uint8_t*)calloc(sizeof(uint8_t), certificate_issuer_length); + (*env)->GetByteArrayRegion(env, p_certificate_issuer, 0, (jsize)certificate_issuer_length, (jbyte*)certificate_issuer); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_signWithEcdsaNistp256WithSha256: certificate_issuer=%02x%02x%02x%02x%02x%02x\n", *certificate_issuer, *(certificate_issuer + 1), *(certificate_issuer + 2), *(certificate_issuer + 3), *(certificate_issuer + 4), *(certificate_issuer + 5)); + size_t private_key_length = (*env)->GetArrayLength(env, p_private_key); + //fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_signWithEcdsaNistp256WithSha256: private_key_length=%ld\n", private_key_length); + uint8_t* private_key = (uint8_t*)calloc(sizeof(uint8_t), private_key_length); + (*env)->GetByteArrayRegion(env, p_private_key, 0, (jsize)private_key_length, (jbyte*)private_key); + uint8_t* signature = NULL; + result = sign_with_ecdsa_nistp256_with_sha256(lib_its_security_context, to_be_signed_secured_message, to_be_signed_secured_message_length, certificate_issuer, private_key, &signature); + //fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_signWithEcdsaNistp256WithSha256: result=%d\n", result); + if (result == 0) { + // Prepare return value + java_signature = (*env)->NewByteArray(env, (jsize)64); + (*env)->SetByteArrayRegion(env, java_signature, 0, (jsize)64, (jbyte*)signature); + // Free allocated resources + free(signature); + } + free(to_be_signed_secured_message); + free(certificate_issuer); + free(private_key); + uninitialize(&lib_its_security_context); + } + + return java_signature; +} + +/* + * Class: org_etsi_its_security_NativeSecurity + * Method: signWithEcdsaBrainpoolp256r1WithSha256 + * Signature: ([B[B[B)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_etsi_its_security_NativeSecurity_signWithEcdsaBrainpoolp256r1WithSha256 +(JNIEnv* env, jobject jobj, jbyteArray p_to_be_signed_secured_message, jbyteArray p_certificate_issuer, jbyteArray p_private_key) { + jbyteArray java_signature = NULL; + + // Create intermal context + lib_its_security_context_t* lib_its_security_context = NULL; + int32_t result = initialize(brainpool_p_256_r1, &lib_its_security_context); + if (result == 0) { + // Extract buffers + size_t to_be_signed_secured_message_length = (*env)->GetArrayLength(env, p_to_be_signed_secured_message); + uint8_t* to_be_signed_secured_message = (uint8_t*)calloc(sizeof(uint8_t), to_be_signed_secured_message_length); + (*env)->GetByteArrayRegion(env, p_to_be_signed_secured_message, 0, (jsize)to_be_signed_secured_message_length, (jbyte*)to_be_signed_secured_message); + size_t certificate_issuer_length = (*env)->GetArrayLength(env, p_certificate_issuer); + uint8_t* certificate_issuer = (uint8_t*)calloc(sizeof(uint8_t), certificate_issuer_length); + (*env)->GetByteArrayRegion(env, p_certificate_issuer, 0, (jsize)certificate_issuer_length, (jbyte*)certificate_issuer); + size_t private_key_length = (*env)->GetArrayLength(env, p_private_key); + uint8_t* private_key = (uint8_t*)calloc(sizeof(uint8_t), private_key_length); + (*env)->GetByteArrayRegion(env, p_private_key, 0, (jsize)private_key_length, (jbyte*)private_key); + uint8_t* signature = NULL; + result = sign_with_ecdsa_brainpoolp256r1_with_sha256(lib_its_security_context, to_be_signed_secured_message, to_be_signed_secured_message_length, certificate_issuer, private_key, &signature); + if (result == 0) { + // Prepare return value + java_signature = (*env)->NewByteArray(env, (jsize)64); + (*env)->SetByteArrayRegion(env, java_signature, 0, (jsize)64, (jbyte*)signature); + // Free allocated resources + free(signature); + } + free(to_be_signed_secured_message); + free(certificate_issuer); + free(private_key); + uninitialize(&lib_its_security_context); + } + + return java_signature; +} + +/* + * Class: org_etsi_its_security_NativeSecurity + * Method: signWithEcdsaBrainpoolp384r1WithSha384 + * Signature: ([B[B[B)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_etsi_its_security_NativeSecurity_signWithEcdsaBrainpoolp384r1WithSha384 +(JNIEnv* env, jobject jobj, jbyteArray p_to_be_signed_secured_message, jbyteArray p_certificate_issuer, jbyteArray p_private_key) { + jbyteArray java_signature = NULL; + + // Create intermal context + lib_its_security_context_t* lib_its_security_context = NULL; + int32_t result = initialize(brainpool_p_384_r1, &lib_its_security_context); + if (result == 0) { + // Extract buffers + size_t to_be_signed_secured_message_length = (*env)->GetArrayLength(env, p_to_be_signed_secured_message); + uint8_t* to_be_signed_secured_message = (uint8_t*)calloc(sizeof(uint8_t), to_be_signed_secured_message_length); + (*env)->GetByteArrayRegion(env, p_to_be_signed_secured_message, 0, (jsize)to_be_signed_secured_message_length, (jbyte*)to_be_signed_secured_message); + size_t certificate_issuer_length = (*env)->GetArrayLength(env, p_certificate_issuer); + uint8_t* certificate_issuer = (uint8_t*)calloc(sizeof(uint8_t), certificate_issuer_length); + (*env)->GetByteArrayRegion(env, p_certificate_issuer, 0, (jsize)certificate_issuer_length, (jbyte*)certificate_issuer); + size_t private_key_length = (*env)->GetArrayLength(env, p_private_key); + uint8_t* private_key = (uint8_t*)calloc(sizeof(uint8_t), private_key_length); + (*env)->GetByteArrayRegion(env, p_private_key, 0, (jsize)private_key_length, (jbyte*)private_key); + uint8_t* signature = NULL; + result = sign_with_ecdsa_brainpoolp384r1_with_sha384(lib_its_security_context, to_be_signed_secured_message, to_be_signed_secured_message_length, certificate_issuer, private_key, &signature); + if (result == 0) { + // Prepare return value + java_signature = (*env)->NewByteArray(env, (jsize)96); + (*env)->SetByteArrayRegion(env, java_signature, 0, (jsize)96, (jbyte*)signature); + // Free allocated resources + free(signature); + } + free(to_be_signed_secured_message); + free(certificate_issuer); + free(private_key); + uninitialize(&lib_its_security_context); + } + + return java_signature; +} + +/* + * Class: org_etsi_its_security_NativeSecurity + * Method: verifyWithEcdsaNistp256WithSha256 + * Signature: ([B[B[B[BI)I + */ +JNIEXPORT jint JNICALL Java_org_etsi_its_security_NativeSecurity_verifyWithEcdsaNistp256WithSha256 +(JNIEnv* env, jobject jobj, jbyteArray p_to_be_verified_data, jbyteArray p_certificate_issuer, jbyteArray p_signature, jbyteArray p_ecdsaNistp256PublicKeyCompressed, jint p_compressed_mode) { + fprintf(stderr, ">>> Java_org_etsi_its_security_NativeSecurity_verifyWithEcdsaNistp256WithSha256\n"); + + // Create intermal context + lib_its_security_context_t* lib_its_security_context = NULL; + int32_t result = initialize(nist_p_256, &lib_its_security_context); + //fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_verifyWithEcdsaNistp256WithSha256: result=%d\n", result); + if (result == 0) { + // Extract buffers + size_t to_be_verified_data_length = (*env)->GetArrayLength(env, p_to_be_verified_data); + //fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_verifyWithEcdsaNistp256WithSha256: to_be_verified_data_length=%ld\n", to_be_verified_data_length); + uint8_t* to_be_verified_data = (uint8_t*)calloc(sizeof(uint8_t), to_be_verified_data_length); + (*env)->GetByteArrayRegion(env, p_to_be_verified_data, 0, (jsize)to_be_verified_data_length, (jbyte*)to_be_verified_data); + size_t certificate_issuer_length = (*env)->GetArrayLength(env, p_certificate_issuer); + //fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_verifyWithEcdsaNistp256WithSha256: certificate_issuer_length=%ld\n", certificate_issuer_length); + uint8_t* certificate_issuer = (uint8_t*)calloc(sizeof(uint8_t), certificate_issuer_length); + (*env)->GetByteArrayRegion(env, p_certificate_issuer, 0, (jsize)certificate_issuer_length, (jbyte*)certificate_issuer); + size_t signature_length = (*env)->GetArrayLength(env, p_signature); + //fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_verifyWithEcdsaNistp256WithSha256: signature_length=%ld\n", signature_length); + uint8_t* signature = (uint8_t*)calloc(sizeof(uint8_t), signature_length); + (*env)->GetByteArrayRegion(env, p_signature, 0, (jsize)signature_length, (jbyte*)signature); + size_t compressed_key_length = (*env)->GetArrayLength(env, p_ecdsaNistp256PublicKeyCompressed); + //fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_verifyWithEcdsaNistp256WithSha256: compressed_key_length=%ld\n", compressed_key_length); + uint8_t* compressed_key = (uint8_t*)calloc(sizeof(uint8_t), compressed_key_length); + (*env)->GetByteArrayRegion(env, p_ecdsaNistp256PublicKeyCompressed, 0, (jsize)compressed_key_length, (jbyte*)compressed_key); + result = verify_with_ecdsa_nistp256_with_sha256(lib_its_security_context, to_be_verified_data, to_be_verified_data_length, certificate_issuer, signature, compressed_key, (int32_t)p_compressed_mode); + //fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_verifyWithEcdsaNistp256WithSha256: result=%d\n", result); + free(to_be_verified_data); + free(certificate_issuer); + free(signature); + free(compressed_key); + uninitialize(&lib_its_security_context); + } + + return (jint)result; +} + +/* + * Class: org_etsi_its_security_NativeSecurity + * Method: verifyWithEcdsaBrainpoolp256r1WithSha256 + * Signature: ([B[B[B[BI)I + */ +JNIEXPORT jint JNICALL Java_org_etsi_its_security_NativeSecurity_verifyWithEcdsaBrainpoolp256r1WithSha256 +(JNIEnv* env, jobject jobj, jbyteArray p_to_be_verified_data, jbyteArray p_certificate_issuer, jbyteArray p_signature, jbyteArray p_ecdsaNistp256PublicKeyCompressed, jint p_compressed_mode) { + // Create intermal context + lib_its_security_context_t* lib_its_security_context = NULL; + int32_t result = initialize(brainpool_p_256_r1, &lib_its_security_context); + if (result == 0) { + // Extract buffers + size_t to_be_verified_data_length = (*env)->GetArrayLength(env, p_to_be_verified_data); + uint8_t* to_be_verified_data = (uint8_t*)calloc(sizeof(uint8_t), to_be_verified_data_length); + (*env)->GetByteArrayRegion(env, p_to_be_verified_data, 0, (jsize)to_be_verified_data_length, (jbyte*)to_be_verified_data); + size_t certificate_issuer_length = (*env)->GetArrayLength(env, p_certificate_issuer); + uint8_t* certificate_issuer = (uint8_t*)calloc(sizeof(uint8_t), certificate_issuer_length); + (*env)->GetByteArrayRegion(env, p_certificate_issuer, 0, (jsize)certificate_issuer_length, (jbyte*)certificate_issuer); + size_t signature_length = (*env)->GetArrayLength(env, p_signature); + uint8_t* signature = (uint8_t*)calloc(sizeof(uint8_t), signature_length); + (*env)->GetByteArrayRegion(env, p_signature, 0, (jsize)signature_length, (jbyte*)signature); + size_t compressed_key_length = (*env)->GetArrayLength(env, p_ecdsaNistp256PublicKeyCompressed); + uint8_t* compressed_key = (uint8_t*)calloc(sizeof(uint8_t), compressed_key_length); + (*env)->GetByteArrayRegion(env, p_ecdsaNistp256PublicKeyCompressed, 0, (jsize)compressed_key_length, (jbyte*)compressed_key); + result = verify_with_ecdsa_brainpoolp256r1_with_sha256(lib_its_security_context, to_be_verified_data, to_be_verified_data_length, certificate_issuer, signature, compressed_key, (int32_t)p_compressed_mode); + free(to_be_verified_data); + free(certificate_issuer); + free(signature); + free(compressed_key); + uninitialize(&lib_its_security_context); + } + + return (jint)result; +} + +/* + * Class: org_etsi_its_security_NativeSecurity + * Method: fx_verifyWithEcdsaBrainpoolp384r1WithSha384 + * Signature: ([B[B[B[BI)I + */ +JNIEXPORT jint JNICALL Java_org_etsi_its_security_NativeSecurity_verifyWithEcdsaBrainpoolp384r1WithSha384 +(JNIEnv* env, jobject jobj, jbyteArray p_to_be_verified_data, jbyteArray p_certificate_issuer, jbyteArray p_signature, jbyteArray p_ecdsaNistp384PublicKeyCompressed, jint p_compressed_mode) { + // Create intermal context + lib_its_security_context_t* lib_its_security_context = NULL; + int32_t result = initialize(brainpool_p_384_r1, &lib_its_security_context); + if (result == 0) { + // Extract buffers + size_t to_be_verified_data_length = (*env)->GetArrayLength(env, p_to_be_verified_data); + uint8_t* to_be_verified_data = (uint8_t*)calloc(sizeof(uint8_t), to_be_verified_data_length); + (*env)->GetByteArrayRegion(env, p_to_be_verified_data, 0, (jsize)to_be_verified_data_length, (jbyte*)to_be_verified_data); + size_t certificate_issuer_length = (*env)->GetArrayLength(env, p_certificate_issuer); + uint8_t* certificate_issuer = (uint8_t*)calloc(sizeof(uint8_t), certificate_issuer_length); + (*env)->GetByteArrayRegion(env, p_certificate_issuer, 0, (jsize)certificate_issuer_length, (jbyte*)certificate_issuer); + size_t signature_length = (*env)->GetArrayLength(env, p_signature); + uint8_t* signature = (uint8_t*)calloc(sizeof(uint8_t), signature_length); + (*env)->GetByteArrayRegion(env, p_signature, 0, (jsize)signature_length, (jbyte*)signature); + size_t compressed_key_length = (*env)->GetArrayLength(env, p_ecdsaNistp384PublicKeyCompressed); + uint8_t* compressed_key = (uint8_t*)calloc(sizeof(uint8_t), compressed_key_length); + (*env)->GetByteArrayRegion(env, p_ecdsaNistp384PublicKeyCompressed, 0, (jsize)compressed_key_length, (jbyte*)compressed_key); + result = verify_with_ecdsa_brainpoolp384r1_with_sha384(lib_its_security_context, to_be_verified_data, to_be_verified_data_length, certificate_issuer, signature, compressed_key, (int32_t)p_compressed_mode); + free(to_be_verified_data); + free(certificate_issuer); + free(signature); + free(compressed_key); + uninitialize(&lib_its_security_context); + } + + return (jint)result; +} + +/* + * Class: org_etsi_its_security_NativeSecurity + * Method: generate_key_pair + * Signature: (ILjava/nio/ByteBuffer;Ljava/nio/ByteBuffer;Ljava/nio/ByteBuffer;Ljava/nio/ByteBuffer;)I + */ +JNIEXPORT jint JNICALL Java_org_etsi_its_security_NativeSecurity_generate_1key_1pair(JNIEnv* env, jobject jobj, jint p_eccEllipticCurve, jobject p_private_key, jobject p_public_key_x, jobject p_public_key_y, jobject p_public_key_compressed) { + fprintf(stderr, ">>> Java_org_etsi_its_security_NativeSecurity_generate_1key_1pair_1\n"); + + lib_its_security_context_t* lib_its_security_context = NULL; + size_t length = 32; + int32_t result = 0; + switch ((int)p_eccEllipticCurve) { + case 0: // Nist P256 + result = initialize(nist_p_256, &lib_its_security_context); + break; + case 1: // Brainpool P256 r1 + result = initialize(brainpool_p_256_r1, &lib_its_security_context); + break; + case 2: // Brainpool P384 r1 + result = initialize(brainpool_p_384_r1, &lib_its_security_context); + length = 48; + break; + } + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_generate_1key_1pair_1: result=%d\n", result); + if (result == 0) { + uint8_t* private_key = NULL; + uint8_t* public_key_x = NULL; + uint8_t* public_key_y = NULL; + uint8_t* public_key_compressed = NULL; + ecc_compressed_mode_t public_key_compressed_mode; + result = generate_key_pair(lib_its_security_context, &private_key, &public_key_x, &public_key_y, &public_key_compressed, &public_key_compressed_mode); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_generate_1key_1pair_1: result=%d\n", result); + if (result == 0) { + // Copy all keys into Java buffers, assumimng the allocated memory is correct ;) + uint8_t* p = (*env)->GetDirectBufferAddress(env, p_private_key); + for (size_t i = 0; i < length; i++) { + *p++ = *(private_key + i); + } + free(private_key); + p = (*env)->GetDirectBufferAddress(env, p_public_key_x); + for (size_t i = 0; i < length; i++) { + *p++ = *(public_key_x + i); + } + free(public_key_x); + p = (*env)->GetDirectBufferAddress(env, p_public_key_y); + for (size_t i = 0; i < length; i++) { + *p++ = *(public_key_y + i); + } + free(public_key_y); + p = (*env)->GetDirectBufferAddress(env, p_public_key_compressed); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_generate_1key_1pair_1: public_key_compressed_mode=%d\n", public_key_compressed_mode); + *p++ = (public_key_compressed_mode == compressed_y_0) ? 0x02 : 0x03; + for (size_t i = 0; i < length; i++) { + *p++ = *(public_key_compressed + i); + } + free(public_key_compressed); + } + } + uninitialize(&lib_its_security_context); + + return (jint)result; +} + +/* + * Class: org_etsi_its_security_NativeSecurity + * Method: encrypt_with_ecies_nistp256_with_sha256 + * Signature: ([B[B[BLjava/nio/ByteBuffer;Ljava/nio/ByteBuffer;Ljava/nio/ByteBuffer;Ljava/nio/ByteBuffer;Ljava/nio/ByteBuffer;)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_etsi_its_security_NativeSecurity_encrypt_1with_1ecies_1nistp256_1with_1sha256(JNIEnv* env, jobject jobj, jbyteArray p_toBeEncryptedSecuredMessage, jbyteArray p_recipientsPublicKeyCompressed, jbyteArray p_salt, jobject p_public_ephemeral_key_compressed, jobject p_aes_sym_key, jobject p_encrypted_sym_key, jobject p_authentication_vector, jobject p_nonce) { + fprintf(stderr, ">>> Java_org_etsi_its_security_NativeSecurity_encrypt_1with_1ecies_1nistp256_1with_1sha256\n"); + + jbyteArray java_ciphered_message = NULL; + lib_its_security_context_t* lib_its_security_context = NULL; + // Extract the recipient's public keys + size_t compressed_key_length = (*env)->GetArrayLength(env, p_recipientsPublicKeyCompressed); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_encrypt_1with_1ecies_1nistp256_1with_1sha256: compressed_key_length = %zd\n", compressed_key_length); + uint8_t* compressed_key = (uint8_t*)calloc(sizeof(uint8_t), compressed_key_length); + (*env)->GetByteArrayRegion(env, p_recipientsPublicKeyCompressed, 0, (jsize)compressed_key_length, (jbyte*)compressed_key); + ecc_compressed_mode_t compressed_mode = (ecc_compressed_mode_t)(*compressed_key); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_encrypt_1with_1ecies_1nistp256_1with_1sha256: compressed_mode = %d\n", compressed_mode); + int32_t result = initialize_with_public_key(nist_p_256, compressed_key + 1, compressed_mode, &lib_its_security_context); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_encrypt_1with_1ecies_1nistp256_1with_1sha256: result = %d\n", result); + if (result == 0) { + // Extract buffers + size_t plain_text_message_length = (*env)->GetArrayLength(env, p_toBeEncryptedSecuredMessage); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_encrypt_1with_1ecies_1nistp256_1with_1sha256: plain_text_message_length = %zd\n", plain_text_message_length); + uint8_t* plain_text_message = (uint8_t*)calloc(sizeof(uint8_t), plain_text_message_length); + (*env)->GetByteArrayRegion(env, p_toBeEncryptedSecuredMessage, 0, (jsize)plain_text_message_length, (jbyte*)plain_text_message); + size_t salt_length = (*env)->GetArrayLength(env, p_salt); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_encrypt_1with_1ecies_1nistp256_1with_1sha256: salt_length = %zd\n", salt_length); + uint8_t* salt = (uint8_t*)calloc(sizeof(uint8_t), salt_length); + (*env)->GetByteArrayRegion(env, p_salt, 0, (jsize)salt_length, (jbyte*)salt); + uint8_t* ephemeral_key_compressed = NULL; + ecc_compressed_mode_t ephemeral_compressed_mode = compressed_y_0; + uint8_t* aes_sym_key = NULL; + uint8_t* encrypted_sym_key = NULL; + uint8_t* authentication_vector = NULL; + uint8_t* nonce = NULL; + uint8_t* ciphered_message = NULL; + size_t ciphered_message_length = 0; + result = encrypt_with_ecies_nistp256_with_sha256(lib_its_security_context/*recipient's public keys*/, plain_text_message, plain_text_message_length, lib_its_security_context->public_key_c, lib_its_security_context->compressed_mode, salt, salt_length, &ephemeral_key_compressed, &ephemeral_compressed_mode, &aes_sym_key, &encrypted_sym_key, &authentication_vector, &nonce, &ciphered_message, &ciphered_message_length); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_encrypt_1with_1ecies_1nistp256_1with_1sha256: result = %d\n", result); + if (result == 0) { + // Copy encryption information into Java buffers, assumimng the allocated memory is correct ;) + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_encrypt_1with_1ecies_1nistp256_1with_1sha256: ephemeral_compressed_mode = %d\n", ephemeral_compressed_mode); + uint8_t* p = (*env)->GetDirectBufferAddress(env, p_public_ephemeral_key_compressed); + *p++ = (ephemeral_compressed_mode == compressed_y_0) ? 0x02 : 0x03; + for (size_t i = 0; i < 32; i++) { + *p++ = *(ephemeral_key_compressed + i); + } + free(ephemeral_key_compressed); + p = (*env)->GetDirectBufferAddress(env, p_aes_sym_key); + for (size_t i = 0; i < 16; i++) { + *p++ = *(aes_sym_key + i); + } + free(aes_sym_key); + p = (*env)->GetDirectBufferAddress(env, p_encrypted_sym_key); + for (size_t i = 0; i < 16; i++) { + *p++ = *(encrypted_sym_key + i); + } + free(encrypted_sym_key); + p = (*env)->GetDirectBufferAddress(env, p_authentication_vector); + for (size_t i = 0; i < 16; i++) { + *p++ = *(authentication_vector + i); + } + free(authentication_vector); + p = (*env)->GetDirectBufferAddress(env, p_nonce); + for (size_t i = 0; i < 12; i++) { + *p++ = *(nonce + i); + } + free(nonce); + // Prepare return value + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_encrypt_1with_1ecies_1nistp256_1with_1sha256: result = %d\n", (jsize)ciphered_message_length); + java_ciphered_message = (*env)->NewByteArray(env, (jsize)ciphered_message_length); + (*env)->SetByteArrayRegion(env, java_ciphered_message, 0, (jsize)ciphered_message_length, (jbyte*)ciphered_message); + // Free allocated resources + free(ciphered_message); + } + free(compressed_key); + free(plain_text_message); + free(salt); + uninitialize(&lib_its_security_context); + } + + return java_ciphered_message; +} + +/* + * Class: org_etsi_its_security_NativeSecurity + * Method: encrypt_with_ecies_brainpoolp256r1_with_sha256 + * Signature: ([B[B[BLjava/nio/ByteBuffer;Ljava/nio/ByteBuffer;Ljava/nio/ByteBuffer;Ljava/nio/ByteBuffer;Ljava/nio/ByteBuffer;)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_etsi_its_security_NativeSecurity_encrypt_1with_1ecies_1brainpoolp256r1_1with_1sha256(JNIEnv* env, jobject jobj, jbyteArray p_toBeEncryptedSecuredMessage, jbyteArray p_recipientsPublicKeyCompressed, jbyteArray p_salt, jobject p_public_ephemeral_key_compressed, jobject p_aes_sym_key, jobject p_encrypted_sym_key, jobject p_authentication_vector, jobject p_nonce) { + fprintf(stderr, ">>> Java_org_etsi_its_security_NativeSecurity_encrypt_1with_1ecies_1brainpoolp256r1_1with_1sha256\n"); + + jbyteArray java_ciphered_message = NULL; + lib_its_security_context_t* lib_its_security_context = NULL; + // Extract the recipient's public keys + size_t compressed_key_length = (*env)->GetArrayLength(env, p_recipientsPublicKeyCompressed); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_encrypt_1with_1ecies_1brainpoolp256r1_1with_1sha256: compressed_key_length = %zd\n", compressed_key_length); + uint8_t* compressed_key = (uint8_t*)calloc(sizeof(uint8_t), compressed_key_length); + (*env)->GetByteArrayRegion(env, p_recipientsPublicKeyCompressed, 0, (jsize)compressed_key_length, (jbyte*)compressed_key); + ecc_compressed_mode_t compressed_mode = (ecc_compressed_mode_t)(*compressed_key); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_encrypt_1with_1ecies_1brainpoolp256r1_1with_1sha256: compressed_mode = %d\n", compressed_mode); + int32_t result = initialize_with_public_key(brainpool_p_256_r1, compressed_key + 1, compressed_mode, &lib_its_security_context); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_encrypt_1with_1ecies_1brainpoolp256r1_1with_1sha256: result = %d\n", result); + if (result == 0) { + // Extract buffers + size_t plain_text_message_length = (*env)->GetArrayLength(env, p_toBeEncryptedSecuredMessage); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_encrypt_1with_1ecies_1brainpoolp256r1_1with_1sha256: plain_text_message_length = %zd\n", plain_text_message_length); + uint8_t* plain_text_message = (uint8_t*)calloc(sizeof(uint8_t), plain_text_message_length); + (*env)->GetByteArrayRegion(env, p_toBeEncryptedSecuredMessage, 0, (jsize)plain_text_message_length, (jbyte*)plain_text_message); + size_t salt_length = (*env)->GetArrayLength(env, p_salt); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_encrypt_1with_1ecies_1brainpoolp256r1_1with_1sha256: salt_length = %zd\n", salt_length); + uint8_t* salt = (uint8_t*)calloc(sizeof(uint8_t), salt_length); + (*env)->GetByteArrayRegion(env, p_salt, 0, (jsize)salt_length, (jbyte*)salt); + uint8_t* ephemeral_key_compressed = NULL; + ecc_compressed_mode_t ephemeral_compressed_mode = compressed_y_0; + uint8_t* aes_sym_key = NULL; + uint8_t* encrypted_sym_key = NULL; + uint8_t* authentication_vector = NULL; + uint8_t* nonce = NULL; + uint8_t* ciphered_message = NULL; + size_t ciphered_message_length = 0; + result = encrypt_with_ecies_brainpoolp256r1_with_sha256(lib_its_security_context/*recipient's public keys*/, plain_text_message, plain_text_message_length, lib_its_security_context->public_key_c, lib_its_security_context->compressed_mode, salt, salt_length, &ephemeral_key_compressed, &ephemeral_compressed_mode, &aes_sym_key, &encrypted_sym_key, &authentication_vector, &nonce, &ciphered_message, &ciphered_message_length); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_encrypt_1with_1ecies_1brainpoolp256r1_1with_1sha256: result = %d\n", result); + if (result == 0) { + // Copy encryption information into Java buffers, assumimng the allocated memory is correct ;) + uint8_t* p = (*env)->GetDirectBufferAddress(env, p_public_ephemeral_key_compressed); + *p = (ephemeral_compressed_mode == compressed_y_0) ? 0x02 : 0x03; + for (size_t i = 0; i < 32; i++) { + *p++ = *(ephemeral_key_compressed + i); + } + free(ephemeral_key_compressed); + p = (*env)->GetDirectBufferAddress(env, p_aes_sym_key); + for (size_t i = 0; i < 16; i++) { + *p++ = *(aes_sym_key + i); + } + free(aes_sym_key); + p = (*env)->GetDirectBufferAddress(env, p_encrypted_sym_key); + for (size_t i = 0; i < 16; i++) { + *p++ = *(encrypted_sym_key + i); + } + free(encrypted_sym_key); + p = (*env)->GetDirectBufferAddress(env, p_authentication_vector); + for (size_t i = 0; i < 16; i++) { + *p++ = *(authentication_vector + i); + } + free(authentication_vector); + p = (*env)->GetDirectBufferAddress(env, p_nonce); + for (size_t i = 0; i < 12; i++) { + *p++ = *(nonce + i); + } + free(nonce); + // Prepare return value + java_ciphered_message = (*env)->NewByteArray(env, (jsize)ciphered_message_length); + (*env)->SetByteArrayRegion(env, java_ciphered_message, 0, (jsize)ciphered_message_length, (jbyte*)ciphered_message); + // Free allocated resources + free(ciphered_message); + } + free(compressed_key); + free(plain_text_message); + free(salt); + uninitialize(&lib_its_security_context); + } + + return java_ciphered_message; +} +/* + * Class: org_etsi_its_security_NativeSecurity + * Method: decrypt_with_ecies_nistp256_with_sha256 + * Signature: ([B[B[B[B[B[B[BLjava/nio/ByteBuffer;)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_etsi_its_security_NativeSecurity_decrypt_1with_1ecies_1nistp256_1with_1sha256(JNIEnv* env, jobject jobj, jbyteArray p_encryptedSecuredMessage, jbyteArray p_privateEncKey, jbyteArray p_publicEphemeralKeyCompressed, jbyteArray p_encrypted_sym_key, jbyteArray p_authentication_vector, jbyteArray p_nonce, jbyteArray p_salt, jobject p_aes_enc_sym_key) { + fprintf(stderr, ">>> Java_org_etsi_its_security_NativeSecurity_decrypt_1with_1ecies_1nistp256_1with_1sha256\n"); + + jbyteArray java_plain_text_message = NULL; + lib_its_security_context_t* lib_its_security_context = NULL; + // Extract the recipient's private key + size_t recipient_private_key_length = (*env)->GetArrayLength(env, p_privateEncKey); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_decrypt_1with_1ecies_1nistp256_1with_1sha256: recipient_private_key_length = %zd\n", recipient_private_key_length); + uint8_t* recipient_private_key = (uint8_t*)calloc(sizeof(uint8_t), recipient_private_key_length); + (*env)->GetByteArrayRegion(env, p_privateEncKey, 0, (jsize)recipient_private_key_length, (jbyte*)recipient_private_key); + int32_t result = initialize_with_private_key(nist_p_256, recipient_private_key, &lib_its_security_context); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_decrypt_1with_1ecies_1nistp256_1with_1sha256: result = %d\n", result); + if (result == 0) { + // Extract buffers + size_t encrypted_secured_message_length = (*env)->GetArrayLength(env, p_encryptedSecuredMessage); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_decrypt_1with_1ecies_1nistp256_1with_1sha256: encrypted_secured_message_length = %zd\n", encrypted_secured_message_length); + uint8_t* encrypted_secured_message = (uint8_t*)calloc(sizeof(uint8_t), encrypted_secured_message_length); + (*env)->GetByteArrayRegion(env, p_encryptedSecuredMessage, 0, (jsize)encrypted_secured_message_length, (jbyte*)encrypted_secured_message); + size_t ephemeral_key_compressed_length = (*env)->GetArrayLength(env, p_publicEphemeralKeyCompressed); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_decrypt_1with_1ecies_1nistp256_1with_1sha256: compressed_key_length = %zd\n", ephemeral_key_compressed_length); + uint8_t* ephemeral_key_compressed = (uint8_t*)calloc(sizeof(uint8_t), ephemeral_key_compressed_length); + (*env)->GetByteArrayRegion(env, p_publicEphemeralKeyCompressed, 0, (jsize)ephemeral_key_compressed_length, (jbyte*)ephemeral_key_compressed); + ecc_compressed_mode_t ephemeral_compressed_mode = (ecc_compressed_mode_t)(*ephemeral_key_compressed); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_decrypt_1with_1ecies_1nistp256_1with_1sha256: ephemeral_compressed_mode = %d\n", ephemeral_compressed_mode); + size_t encrypted_sym_key_length = (*env)->GetArrayLength(env, p_encrypted_sym_key); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_decrypt_1with_1ecies_1nistp256_1with_1sha256: encrypted_sym_key_length = %zd\n", encrypted_sym_key_length); + uint8_t* encrypted_sym_key = (uint8_t*)calloc(sizeof(uint8_t), encrypted_sym_key_length); + (*env)->GetByteArrayRegion(env, p_encrypted_sym_key, 0, (jsize)encrypted_sym_key_length, (jbyte*)encrypted_sym_key); + size_t authentication_vector_length = (*env)->GetArrayLength(env, p_authentication_vector); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_decrypt_1with_1ecies_1nistp256_1with_1sha256: authentication_vector_length = %zd\n", authentication_vector_length); + uint8_t* authentication_vector = (uint8_t*)calloc(sizeof(uint8_t), authentication_vector_length); + (*env)->GetByteArrayRegion(env, p_authentication_vector, 0, (jsize)authentication_vector_length, (jbyte*)authentication_vector); + size_t nonce_length = (*env)->GetArrayLength(env, p_nonce); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_decrypt_1with_1ecies_1nistp256_1with_1sha256: nonce_length = %zd\n", nonce_length); + uint8_t* nonce = (uint8_t*)calloc(sizeof(uint8_t), nonce_length); + (*env)->GetByteArrayRegion(env, p_nonce, 0, (jsize)nonce_length, (jbyte*)nonce); + size_t salt_length = (*env)->GetArrayLength(env, p_salt); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_decrypt_1with_1ecies_1nistp256_1with_1sha256: salt_length = %zd\n", salt_length); + uint8_t* salt = (uint8_t*)calloc(sizeof(uint8_t), salt_length); + (*env)->GetByteArrayRegion(env, p_salt, 0, (jsize)salt_length, (jbyte*)salt); + size_t plain_text_message_length = 0; + uint8_t* plain_text_message = NULL; + uint8_t* aes_enc_sym_key = NULL; + result = decrypt_with_ecies_nistp256_with_sha256(lib_its_security_context, encrypted_secured_message, encrypted_secured_message_length, lib_its_security_context->private_key, ephemeral_key_compressed + 1, ephemeral_compressed_mode, encrypted_sym_key, authentication_vector, nonce, salt, salt_length, &aes_enc_sym_key, &plain_text_message, &plain_text_message_length); + if (result == 0) { + uint8_t* p = (*env)->GetDirectBufferAddress(env, p_aes_enc_sym_key); + for (size_t i = 0; i < 16; i++) { + *p++ = *(aes_enc_sym_key + i); + } + free(aes_enc_sym_key); + // Prepare return value + java_plain_text_message = (*env)->NewByteArray(env, (jsize)plain_text_message_length); + (*env)->SetByteArrayRegion(env, java_plain_text_message, 0, (jsize)plain_text_message_length, (jbyte*)plain_text_message); + // Free allocated resources + free(plain_text_message); + } + free(recipient_private_key); + free(ephemeral_key_compressed); + free(encrypted_sym_key); + free(authentication_vector); + free(nonce); + free(salt); + uninitialize(&lib_its_security_context); + } + + return java_plain_text_message; +} + +/* + * Class: org_etsi_its_security_NativeSecurity + * Method: decrypt_with_ecies_brainpoolp256r1_with_sha256 + * Signature: ([B[B[B[B[B[B[BLjava/nio/ByteBuffer;)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_etsi_its_security_NativeSecurity_decrypt_1with_1ecies_1brainpoolp256r1_1with_1sha256(JNIEnv* env, jobject jobj, jbyteArray p_encryptedSecuredMessage, jbyteArray p_privateEncKey, jbyteArray p_publicEphemeralKeyCompressed, jbyteArray p_encrypted_sym_key, jbyteArray p_authentication_vector, jbyteArray p_nonce, jbyteArray p_salt, jobject p_aes_enc_sym_key) { + fprintf(stderr, ">>> Java_org_etsi_its_security_NativeSecurity_decrypt_1with_1ecies_1brainpoolp256r1_1with_1sha256\n"); + + jbyteArray java_plain_text_message = NULL; + lib_its_security_context_t* lib_its_security_context = NULL; + // Extract the recipient's private key + size_t recipient_private_key_length = (*env)->GetArrayLength(env, p_privateEncKey); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_decrypt_1with_1ecies_1brainpoolp256r1_1with_1sha256: recipient_private_key_length = %zd\n", recipient_private_key_length); + uint8_t* recipient_private_key = (uint8_t*)calloc(sizeof(uint8_t), recipient_private_key_length); + (*env)->GetByteArrayRegion(env, p_privateEncKey, 0, (jsize)recipient_private_key_length, (jbyte*)recipient_private_key); + int32_t result = initialize_with_private_key(brainpool_p_256_r1, recipient_private_key, &lib_its_security_context); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_decrypt_1with_1ecies_1brainpoolp256r1_1with_1sha256: result = %d\n", result); + if (result == 0) { + // Extract buffers + size_t encrypted_secured_message_length = (*env)->GetArrayLength(env, p_encryptedSecuredMessage); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_decrypt_1with_1ecies_1brainpoolp256r1_1with_1sha256: encrypted_secured_message_length = %zd\n", encrypted_secured_message_length); + uint8_t* encrypted_secured_message = (uint8_t*)calloc(sizeof(uint8_t), encrypted_secured_message_length); + (*env)->GetByteArrayRegion(env, p_encryptedSecuredMessage, 0, (jsize)encrypted_secured_message_length, (jbyte*)encrypted_secured_message); + size_t ephemeral_key_compressed_length = (*env)->GetArrayLength(env, p_publicEphemeralKeyCompressed); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_decrypt_1with_1ecies_1brainpoolp256r1_1with_1sha256: compressed_key_length = %zd\n", ephemeral_key_compressed_length); + uint8_t* ephemeral_key_compressed = (uint8_t*)calloc(sizeof(uint8_t), ephemeral_key_compressed_length); + (*env)->GetByteArrayRegion(env, p_publicEphemeralKeyCompressed, 0, (jsize)ephemeral_key_compressed_length, (jbyte*)ephemeral_key_compressed); + ecc_compressed_mode_t ephemeral_compressed_mode = (ecc_compressed_mode_t)(*ephemeral_key_compressed); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_decrypt_1with_1ecies_1brainpoolp256r1_1with_1sha256: ephemeral_compressed_mode = %d\n", ephemeral_compressed_mode); + size_t encrypted_sym_key_length = (*env)->GetArrayLength(env, p_encrypted_sym_key); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_decrypt_1with_1ecies_1brainpoolp256r1_1with_1sha256: encrypted_sym_key_length = %zd\n", encrypted_sym_key_length); + uint8_t* encrypted_sym_key = (uint8_t*)calloc(sizeof(uint8_t), encrypted_sym_key_length); + (*env)->GetByteArrayRegion(env, p_encrypted_sym_key, 0, (jsize)encrypted_sym_key_length, (jbyte*)encrypted_sym_key); + size_t authentication_vector_length = (*env)->GetArrayLength(env, p_authentication_vector); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_decrypt_1with_1ecies_1brainpoolp256r1_1with_1sha256: authentication_vector_length = %zd\n", authentication_vector_length); + uint8_t* authentication_vector = (uint8_t*)calloc(sizeof(uint8_t), authentication_vector_length); + (*env)->GetByteArrayRegion(env, p_authentication_vector, 0, (jsize)authentication_vector_length, (jbyte*)authentication_vector); + size_t nonce_length = (*env)->GetArrayLength(env, p_nonce); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_decrypt_1with_1ecies_1brainpoolp256r1_1with_1sha256: nonce_length = %zd\n", nonce_length); + uint8_t* nonce = (uint8_t*)calloc(sizeof(uint8_t), nonce_length); + (*env)->GetByteArrayRegion(env, p_nonce, 0, (jsize)nonce_length, (jbyte*)nonce); + size_t salt_length = (*env)->GetArrayLength(env, p_salt); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_decrypt_1with_1ecies_1brainpoolp256r1_1with_1sha256: salt_length = %zd\n", salt_length); + uint8_t* salt = (uint8_t*)calloc(sizeof(uint8_t), salt_length); + (*env)->GetByteArrayRegion(env, p_salt, 0, (jsize)salt_length, (jbyte*)salt); + size_t plain_text_message_length = 0; + uint8_t* plain_text_message = NULL; + uint8_t* aes_enc_sym_key = NULL; + result = decrypt_with_ecies_brainpoolp256r1_with_sha256(lib_its_security_context, encrypted_secured_message, encrypted_secured_message_length, lib_its_security_context->private_key, ephemeral_key_compressed + 1, ephemeral_compressed_mode, encrypted_sym_key, authentication_vector, nonce, salt, salt_length, &aes_enc_sym_key, &plain_text_message, &plain_text_message_length); + if (result == 0) { + uint8_t* p = (*env)->GetDirectBufferAddress(env, p_aes_enc_sym_key); + for (size_t i = 0; i < 16; i++) { + *p++ = *(aes_enc_sym_key + i); + } + free(aes_enc_sym_key); + // Prepare return value + java_plain_text_message = (*env)->NewByteArray(env, (jsize)plain_text_message_length); + (*env)->SetByteArrayRegion(env, java_plain_text_message, 0, (jsize)plain_text_message_length, (jbyte*)plain_text_message); + // Free allocated resources + free(plain_text_message); + } + free(recipient_private_key); + free(ephemeral_key_compressed); + free(encrypted_sym_key); + free(authentication_vector); + free(nonce); + free(salt); + uninitialize(&lib_its_security_context); + } + + return java_plain_text_message; +} + +/* + * Class: org_etsi_its_security_NativeSecurity + * Method: encrypt_aes_128_ccm_test + * Signature: ([B[B[B)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_etsi_its_security_NativeSecurity_encrypt_1aes_1128_1ccm_1test(JNIEnv* env, jobject jobj, jbyteArray p_k, jbyteArray p_n, jbyteArray p_pt) { + fprintf(stderr, ">>> Java_org_etsi_its_security_NativeSecurity_encrypt_1aes_1128_1ccm_1test\n"); + + jbyteArray java_ciphered_message = NULL; + lib_its_security_context_t* lib_its_security_context = NULL; + int32_t result = initialize(nist_p_256, &lib_its_security_context); + if (result == 0) { + lib_its_security_context->encryption_algorithm = aes_128_ccm; + + // Extract buffers + lib_its_security_context->sym_key_length = (*env)->GetArrayLength(env, p_k); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_encrypt_1aes_1128_1ccm_1test: sym_key_length = %zd\n", lib_its_security_context->sym_key_length); + lib_its_security_context->sym_key = (uint8_t*)calloc(sizeof(uint8_t), lib_its_security_context->sym_key_length); + (*env)->GetByteArrayRegion(env, p_k, 0, (jsize)lib_its_security_context->sym_key_length, (jbyte*)lib_its_security_context->sym_key); + lib_its_security_context->nonce_length = (*env)->GetArrayLength(env, p_n); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_encrypt_1aes_1128_1ccm_1test: nonce_length = %zd\n", lib_its_security_context->nonce_length); + lib_its_security_context->nonce = (uint8_t*)calloc(sizeof(uint8_t), lib_its_security_context->nonce_length); + (*env)->GetByteArrayRegion(env, p_n, 0, (jsize)lib_its_security_context->nonce_length, (jbyte*)lib_its_security_context->nonce); + size_t plain_text_message_length = (*env)->GetArrayLength(env, p_pt); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_encrypt_1aes_1128_1ccm_1test: plain_text_message_length = %zd\n", plain_text_message_length); + uint8_t* plain_text_message = (uint8_t*)calloc(sizeof(uint8_t), plain_text_message_length); + (*env)->GetByteArrayRegion(env, p_pt, 0, (jsize)plain_text_message_length, (jbyte*)plain_text_message); + size_t encrypted_secured_message_length = 0; + uint8_t* encrypted_secured_message = NULL; + result = encrypt_(lib_its_security_context, plain_text_message, plain_text_message_length, &encrypted_secured_message, &encrypted_secured_message_length); + if (result == 0) { + // Prepare return value + java_ciphered_message = (*env)->NewByteArray(env, (jsize)encrypted_secured_message_length); + (*env)->SetByteArrayRegion(env, java_ciphered_message, 0, (jsize)encrypted_secured_message_length, (jbyte*)encrypted_secured_message); + // Free allocated resources + free(encrypted_secured_message); + } + // Free allocated resources + free(plain_text_message); + uninitialize(&lib_its_security_context); + } + + return java_ciphered_message; +} + +/* + * Class: org_etsi_its_security_NativeSecurity + * Method: decrypt_aes_128_ccm_test + * Signature: ([B[B[B)[B + */ +JNIEXPORT jbyteArray JNICALL Java_org_etsi_its_security_NativeSecurity_decrypt_1aes_1128_1ccm_1test(JNIEnv* env, jobject jobj, jbyteArray p_k, jbyteArray p_n, jbyteArray p_ct) { + fprintf(stderr, ">>> Java_org_etsi_its_security_NativeSecurity_decrypt_1aes_1128_1ccm_1test\n"); + + jbyteArray java_plain_text_message = NULL; + lib_its_security_context_t* lib_its_security_context = NULL; + int32_t result = initialize(nist_p_256, &lib_its_security_context); + if (result == 0) { + lib_its_security_context->encryption_algorithm = aes_128_ccm; + + // Extract buffers + lib_its_security_context->sym_key_length = (*env)->GetArrayLength(env, p_k); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_decrypt_1aes_1128_1ccm_1test: sym_key_length= %zd\n", lib_its_security_context->sym_key_length); + lib_its_security_context->sym_key = (uint8_t*)calloc(sizeof(uint8_t), lib_its_security_context->sym_key_length); + (*env)->GetByteArrayRegion(env, p_k, 0, (jsize)lib_its_security_context->sym_key_length, (jbyte*)lib_its_security_context->sym_key); + lib_its_security_context->nonce_length = (*env)->GetArrayLength(env, p_n); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_decrypt_1aes_1128_1ccm_1test: nonce_length= %zd\n", lib_its_security_context->nonce_length); + lib_its_security_context->nonce = (uint8_t*)calloc(sizeof(uint8_t), lib_its_security_context->nonce_length); + (*env)->GetByteArrayRegion(env, p_n, 0, (jsize)lib_its_security_context->nonce_length, (jbyte*)lib_its_security_context->nonce); + size_t encrypted_secured_message_length = (*env)->GetArrayLength(env, p_ct) - 16; // Extract the tag from the ciphered message + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_decrypt_1aes_1128_1ccm_1test: encrypted_secured_message_length= %zd\n", encrypted_secured_message_length); + uint8_t* encrypted_secured_message = (uint8_t*)calloc(sizeof(uint8_t), encrypted_secured_message_length); // Extract the ciphered message + (*env)->GetByteArrayRegion(env, p_ct, 0, (jsize)encrypted_secured_message_length, (jbyte*)encrypted_secured_message); + lib_its_security_context->tag_length = 16; // Extract the tag + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_decrypt_1aes_1128_1ccm_1test: tag_length= %zd\n", lib_its_security_context->tag_length); + lib_its_security_context->tag = (uint8_t*)calloc(sizeof(uint8_t), lib_its_security_context->tag_length); + (*env)->GetByteArrayRegion(env, p_ct, encrypted_secured_message_length, (jsize)lib_its_security_context->tag_length, (jbyte*)lib_its_security_context->tag); + size_t plain_text_message_length; + uint8_t* plain_text_message = NULL; + result = decrypt(lib_its_security_context, encrypted_secured_message, encrypted_secured_message_length, &plain_text_message, &plain_text_message_length); + fprintf(stderr, "Java_org_etsi_its_security_NativeSecurity_decrypt_1aes_1128_1ccm_1test: result= %d\n", result); + if (result == 0) { + // Prepare return value + java_plain_text_message = (*env)->NewByteArray(env, (jsize)plain_text_message_length); + (*env)->SetByteArrayRegion(env, java_plain_text_message, 0, (jsize)plain_text_message_length, (jbyte*)plain_text_message); + // Free allocated resources + free(plain_text_message); + } + // Free allocated resources + free(encrypted_secured_message); + uninitialize(&lib_its_security_context); + } + + return java_plain_text_message; +} diff --git a/tools/itssecurity/org_etsi_its_security/org_etsi_its_security_NativeSecurity.h b/tools/itssecurity/org_etsi_its_security/org_etsi_its_security_NativeSecurity.h new file mode 100644 index 000000000..7799fc7fc --- /dev/null +++ b/tools/itssecurity/org_etsi_its_security/org_etsi_its_security_NativeSecurity.h @@ -0,0 +1,141 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_etsi_its_security_NativeSecurity */ + +#ifndef _Included_org_etsi_its_security_NativeSecurity +#define _Included_org_etsi_its_security_NativeSecurity +#ifdef __cplusplus +extern "C" { +#endif + /* + * Class: org_etsi_its_security_NativeSecurity + * Method: hashWithSha256 + * Signature: ([B)[B + */ + JNIEXPORT jbyteArray JNICALL Java_org_etsi_its_security_NativeSecurity_hashWithSha256 + (JNIEnv*, jobject, jbyteArray); + + /* + * Class: org_etsi_its_security_NativeSecurity + * Method: hashWithSha384 + * Signature: ([B)[B + */ + JNIEXPORT jbyteArray JNICALL Java_org_etsi_its_security_NativeSecurity_hashWithSha384 + (JNIEnv*, jobject, jbyteArray); + + /* + * Class: org_etsi_its_security_NativeSecurity + * Method: hmacWithSha256 + * Signature: ([B[B)[B + */ + JNIEXPORT jbyteArray JNICALL Java_org_etsi_its_security_NativeSecurity_hmacWithSha256 + (JNIEnv*, jobject, jbyteArray, jbyteArray); + + /* + * Class: org_etsi_its_security_NativeSecurity + * Method: signWithEcdsaNistp256WithSha256 + * Signature: ([B[B[B)[B + */ + JNIEXPORT jbyteArray JNICALL Java_org_etsi_its_security_NativeSecurity_signWithEcdsaNistp256WithSha256 + (JNIEnv*, jobject, jbyteArray, jbyteArray, jbyteArray); + + /* + * Class: org_etsi_its_security_NativeSecurity + * Method: signWithEcdsaBrainpoolp256r1WithSha256 + * Signature: ([B[B[B)[B + */ + JNIEXPORT jbyteArray JNICALL Java_org_etsi_its_security_NativeSecurity_signWithEcdsaBrainpoolp256r1WithSha256 + (JNIEnv*, jobject, jbyteArray, jbyteArray, jbyteArray); + + /* + * Class: org_etsi_its_security_NativeSecurity + * Method: signWithEcdsaBrainpoolp384r1WithSha384 + * Signature: ([B[B[B)[B + */ + JNIEXPORT jbyteArray JNICALL Java_org_etsi_its_security_NativeSecurity_signWithEcdsaBrainpoolp384r1WithSha384 + (JNIEnv*, jobject, jbyteArray, jbyteArray, jbyteArray); + + /* + * Class: org_etsi_its_security_NativeSecurity + * Method: verifyWithEcdsaNistp256WithSha256 + * Signature: ([B[B[B[BI)I + */ + JNIEXPORT jint JNICALL Java_org_etsi_its_security_NativeSecurity_verifyWithEcdsaNistp256WithSha256 + (JNIEnv*, jobject, jbyteArray, jbyteArray, jbyteArray, jbyteArray, jint); + + /* + * Class: org_etsi_its_security_NativeSecurity + * Method: verifyWithEcdsaBrainpoolp256r1WithSha256 + * Signature: ([B[B[B[BI)I + */ + JNIEXPORT jint JNICALL Java_org_etsi_its_security_NativeSecurity_verifyWithEcdsaBrainpoolp256r1WithSha256 + (JNIEnv*, jobject, jbyteArray, jbyteArray, jbyteArray, jbyteArray, jint); + + /* + * Class: org_etsi_its_security_NativeSecurity + * Method: verifyWithEcdsaBrainpoolp384r1WithSha384 + * Signature: ([B[B[B[BI)I + */ + JNIEXPORT jint JNICALL Java_org_etsi_its_security_NativeSecurity_verifyWithEcdsaBrainpoolp384r1WithSha384 + (JNIEnv*, jobject, jbyteArray, jbyteArray, jbyteArray, jbyteArray, jint); + + /* + * Class: org_etsi_its_security_NativeSecurity + * Method: generate_key_pair + * Signature: (ILjava/nio/ByteBuffer;Ljava/nio/ByteBuffer;Ljava/nio/ByteBuffer;Ljava/nio/ByteBuffer;)I + */ + JNIEXPORT jint JNICALL Java_org_etsi_its_security_NativeSecurity_generate_1key_1pair + (JNIEnv*, jobject, jint, jobject, jobject, jobject, jobject); + + /* + * Class: org_etsi_its_security_NativeSecurity + * Method: encrypt_with_ecies_nistp256_with_sha256 + * Signature: ([B[B[BLjava/nio/ByteBuffer;Ljava/nio/ByteBuffer;Ljava/nio/ByteBuffer;Ljava/nio/ByteBuffer;Ljava/nio/ByteBuffer;)[B + */ + JNIEXPORT jbyteArray JNICALL Java_org_etsi_its_security_NativeSecurity_encrypt_1with_1ecies_1nistp256_1with_1sha256 + (JNIEnv*, jobject, jbyteArray, jbyteArray, jbyteArray, jobject, jobject, jobject, jobject, jobject); + + /* + * Class: org_etsi_its_security_NativeSecurity + * Method: encrypt_with_ecies_brainpoolp256r1_with_sha256 + * Signature: ([B[B[BLjava/nio/ByteBuffer;Ljava/nio/ByteBuffer;Ljava/nio/ByteBuffer;Ljava/nio/ByteBuffer;Ljava/nio/ByteBuffer;)[B + */ + JNIEXPORT jbyteArray JNICALL Java_org_etsi_its_security_NativeSecurity_encrypt_1with_1ecies_1brainpoolp256r1_1with_1sha256 + (JNIEnv*, jobject, jbyteArray, jbyteArray, jbyteArray, jobject, jobject, jobject, jobject, jobject); + + /* + * Class: org_etsi_its_security_NativeSecurity + * Method: decrypt_with_ecies_nistp256_with_sha256 + * Signature: ([B[B[B[B[B[B[BLjava/nio/ByteBuffer;)[B + */ + JNIEXPORT jbyteArray JNICALL Java_org_etsi_its_security_NativeSecurity_decrypt_1with_1ecies_1nistp256_1with_1sha256 + (JNIEnv*, jobject, jbyteArray, jbyteArray, jbyteArray, jbyteArray, jbyteArray, jbyteArray, jbyteArray, jobject); + + /* + * Class: org_etsi_its_security_NativeSecurity + * Method: decrypt_with_ecies_brainpoolp256r1_with_sha256 + * Signature: ([B[B[B[B[B[B[BLjava/nio/ByteBuffer;)[B + */ + JNIEXPORT jbyteArray JNICALL Java_org_etsi_its_security_NativeSecurity_decrypt_1with_1ecies_1brainpoolp256r1_1with_1sha256 + (JNIEnv*, jobject, jbyteArray, jbyteArray, jbyteArray, jbyteArray, jbyteArray, jbyteArray, jbyteArray, jobject); + + /* + * Class: org_etsi_its_security_NativeSecurity + * Method: encrypt_aes_128_ccm_test + * Signature: ([B[B[B)[B + */ + JNIEXPORT jbyteArray JNICALL Java_org_etsi_its_security_NativeSecurity_encrypt_1aes_1128_1ccm_1test + (JNIEnv*, jobject, jbyteArray, jbyteArray, jbyteArray); + + /* + * Class: org_etsi_its_security_NativeSecurity + * Method: decrypt_aes_128_ccm_test + * Signature: ([B[B[B)[B + */ + JNIEXPORT jbyteArray JNICALL Java_org_etsi_its_security_NativeSecurity_decrypt_1aes_1128_1ccm_1test + (JNIEnv*, jobject, jbyteArray, jbyteArray, jbyteArray); + +#ifdef __cplusplus +} +#endif +#endif -- GitLab