summaryrefslogtreecommitdiff
path: root/main/jni
diff options
context:
space:
mode:
authorArne Schwabe <arne@rfc2549.org>2017-11-26 23:41:50 -0500
committerArne Schwabe <arne@rfc2549.org>2017-11-26 23:51:44 -0500
commit7b0af007a717c72d957ed413bb91ae17da9343a1 (patch)
treeac5a67f74bf75f5d4cc6fc9808e1f25fff1b7f5b /main/jni
parentbfc020a66bad76966b37f1a2be7887c0d9a6dc91 (diff)
New NDK and OpenSSL Speed test
Diffstat (limited to 'main/jni')
-rw-r--r--main/jni/Android.mk4
-rw-r--r--main/jni/Application.mk2
-rw-r--r--main/jni/jbcrypto.cpp3
-rw-r--r--main/jni/sslspeed.c309
4 files changed, 315 insertions, 3 deletions
diff --git a/main/jni/Android.mk b/main/jni/Android.mk
index 828bb8da..ae45c10d 100644
--- a/main/jni/Android.mk
+++ b/main/jni/Android.mk
@@ -52,8 +52,10 @@ LOCAL_PATH := $(JNI_DIR)
include $(CLEAR_VARS)
LOCAL_LDLIBS := -llog -lz
LOCAL_CFLAGS = -DTARGET_ARCH_ABI=\"${TARGET_ARCH_ABI}\"
-LOCAL_SRC_FILES:= jniglue.c scan_ifs.c
+LOCAL_SRC_FILES:= jniglue.c scan_ifs.c sslspeed.c
+LOCAL_C_INCLUDES := openssl/include openssl/crypto openssl openssl/crypto/include
LOCAL_MODULE = opvpnutil
+LOCAL_STATIC_LIBRARIES := libssl_static libcrypto_static
include $(BUILD_SHARED_LIBRARY)
include $(CLEAR_VARS)
diff --git a/main/jni/Application.mk b/main/jni/Application.mk
index 838c2eba..7033ee93 100644
--- a/main/jni/Application.mk
+++ b/main/jni/Application.mk
@@ -2,7 +2,7 @@ ifeq ($(USE_SHORT_COMMANDS),1)
APP_SHORT_COMMANDS := true
endif
-APP_ABI := arm64-v8a armeabi armeabi-v7a x86 x86_64
+APP_ABI := arm64-v8a armeabi-v7a x86 x86_64
APP_PLATFORM := android-14
#APP_STL:=stlport_static
diff --git a/main/jni/jbcrypto.cpp b/main/jni/jbcrypto.cpp
index 810a3bc7..c61ef14f 100644
--- a/main/jni/jbcrypto.cpp
+++ b/main/jni/jbcrypto.cpp
@@ -20,7 +20,8 @@
#include <internal/evp_int.h>
extern "C" {
-jbyteArray Java_de_blinkt_openvpn_core_NativeUtils_rsasign(JNIEnv* env, jclass, jbyteArray from, jint pkeyRef);
+ jbyteArray Java_de_blinkt_openvpn_core_NativeUtils_rsasign(JNIEnv* env, jclass, jbyteArray from, jint pkeyRef);
+ int jniThrowException(JNIEnv* env, const char* className, const char* msg);
}
int jniThrowException(JNIEnv* env, const char* className, const char* msg) {
diff --git a/main/jni/sslspeed.c b/main/jni/sslspeed.c
new file mode 100644
index 00000000..0ce9ede2
--- /dev/null
+++ b/main/jni/sslspeed.c
@@ -0,0 +1,309 @@
+/*
+ * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the OpenSSL license (the "License"). You may not use
+ * this file except in compliance with the License. You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+/* ====================================================================
+ * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
+ *
+ * Portions of the attached software ("Contribution") are developed by
+ * SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project.
+ *
+ * The Contribution is licensed pursuant to the OpenSSL open source
+ * license provided above.
+ *
+ * The ECDH and ECDSA speed test software is originally written by
+ * Sumit Gupta of Sun Microsystems Laboratories.
+ *
+ */
+
+// Modified by Arne Schwabe to give a simple openssl evp speed java api
+
+#include <jni.h>
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <sys/ioctl.h>
+#include <linux/if.h>
+#include <android/log.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+
+#include "jniglue.h"
+#include <android/log.h>
+
+#include <openssl/crypto.h>
+#include <openssl/rand.h>
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <openssl/objects.h>
+#include <openssl/async.h>
+
+
+/* This file just contains code thrown together until it works */
+
+
+#undef SECONDS
+#define SECONDS 3
+#define PRIME_SECONDS 10
+#define RSA_SECONDS 10
+#define DSA_SECONDS 10
+#define ECDSA_SECONDS 10
+#define ECDH_SECONDS 10
+
+
+typedef struct loopargs_st {
+ unsigned char *buf;
+ unsigned char *buf2;
+ unsigned char *buf_malloc;
+ unsigned char *buf2_malloc;
+ unsigned int siglen;
+ EVP_CIPHER_CTX *ctx;
+ HMAC_CTX *hctx;
+} loopargs_t;
+
+#undef BUFSIZE
+#define BUFSIZE (1024*16+1)
+#define MAX_MISALIGNMENT 63
+
+
+#define MAX_BLOCK_SIZE 128
+static unsigned char iv[2 * MAX_BLOCK_SIZE / 8];
+
+#define SIZE_NUM 6
+static const int lengths[SIZE_NUM] = {
+ 16, 64, 256, 1024, 8 * 1024, 16 * 1024
+};
+
+static int testnum;
+
+# define COND(unused_cond) (run && count<0x7fffffff)
+
+static volatile int run = 0;
+
+#ifdef SIGALRM
+# if defined(__STDC__) || defined(sgi) || defined(_AIX)
+# define SIGRETTYPE void
+# else
+# define SIGRETTYPE int
+# endif
+
+
+#define START 0
+#define STOP 1
+#define TM_START 0
+#define TM_STOP 1
+
+# include <sys/times.h>
+
+static int usertime = 1;
+
+double app_tminterval(int stop, int usertime)
+{
+ double ret = 0;
+ struct tms rus;
+ clock_t now = times(&rus);
+ static clock_t tmstart;
+
+ if (usertime)
+ now = rus.tms_utime;
+
+ if (stop == TM_START)
+ tmstart = now;
+ else {
+ long int tck = sysconf(_SC_CLK_TCK);
+ ret = (now - tmstart) / (double)tck;
+ }
+
+ return (ret);
+}
+
+
+
+
+static double Time_F(int s)
+{
+ double ret = app_tminterval(s, usertime);
+ if (s == STOP)
+ alarm(0);
+ return ret;
+}
+
+#endif
+
+
+static long save_count = 0;
+static int decrypt = 0;
+static int EVP_Update_loop(void *args)
+{
+ loopargs_t *tempargs = *(loopargs_t **)args;
+ unsigned char *buf = tempargs->buf;
+ EVP_CIPHER_CTX *ctx = tempargs->ctx;
+ int outl, count;
+
+ if (decrypt)
+ for (count = 0; COND(nb_iter); count++)
+ EVP_DecryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
+ else
+ for (count = 0; COND(nb_iter); count++)
+ EVP_EncryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
+ if (decrypt)
+ EVP_DecryptFinal_ex(ctx, buf, &outl);
+ else
+ EVP_EncryptFinal_ex(ctx, buf, &outl);
+ return count;
+}
+
+static const EVP_MD *evp_md = NULL;
+static int EVP_Digest_loop(void *args)
+{
+ loopargs_t *tempargs = *(loopargs_t **)args;
+ unsigned char *buf = tempargs->buf;
+ unsigned char md[EVP_MAX_MD_SIZE];
+ int count;
+
+ for (count = 0; COND(nb_iter); count++) {
+ if (!EVP_Digest(buf, lengths[testnum], md, NULL, evp_md, NULL))
+ return -1;
+ }
+ return count;
+}
+
+
+static int run_benchmark(int async_jobs,
+ int (*loop_function)(void *), loopargs_t *loopargs)
+{
+ int job_op_count = 0;
+ int total_op_count = 0;
+ int num_inprogress = 0;
+ int error = 0, i = 0, ret = 0;
+ OSSL_ASYNC_FD job_fd = 0;
+ size_t num_job_fds = 0;
+
+ run = 1;
+
+ if (async_jobs == 0) {
+ return loop_function((void *)&loopargs);
+ }
+ return 1234567;
+}
+
+
+static void* stop_run(void* arg)
+{
+ __android_log_write(ANDROID_LOG_DEBUG,"openvpn", "stop run thread started");
+ sleep(3);
+ run=0;
+ __android_log_write(ANDROID_LOG_DEBUG,"openvpn", "stop run thread stopped");
+ return NULL;
+}
+
+ jdoubleArray Java_de_blinkt_openvpn_core_NativeUtils_getOpenSSLSpeed(JNIEnv* env, jclass thiz, jstring algorithm, jint testnumber)
+{
+ static const unsigned char key16[16] = {
+ 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
+ 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
+ };
+ const EVP_CIPHER *evp_cipher = NULL;
+
+ const char* alg = (*env)->GetStringUTFChars( env, algorithm , NULL ) ;
+
+ evp_cipher = EVP_get_cipherbyname(alg);
+ if (evp_cipher == NULL)
+ evp_md = EVP_get_digestbyname(alg);
+ if (evp_cipher == NULL && evp_md == NULL) {
+ // BIO_printf(bio_err, "%s: %s is an unknown cipher or digest\n", prog, opt_arg());
+ //jniThrowException(env, "java/security/NoSuchAlgorithmException", "Algorithm not found");
+ return NULL;
+ }
+
+
+ const char* name;
+
+ loopargs_t *loopargs = NULL;
+ int loopargs_len = 1;
+ int async_jobs=0;
+ loopargs = malloc(loopargs_len * sizeof(loopargs_t));
+ memset(loopargs, 0, loopargs_len * sizeof(loopargs_t));
+
+
+ jdoubleArray ret = (*env)->NewDoubleArray(env, 3);
+
+ if (testnum < 0 || testnum >= SIZE_NUM)
+ return NULL;
+
+ testnum = testnumber;
+
+
+ for (int i = 0; i < loopargs_len; i++) {
+ int misalign=0;
+ loopargs[i].buf_malloc = malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1);
+ loopargs[i].buf2_malloc = malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1);
+ /* Align the start of buffers on a 64 byte boundary */
+ loopargs[i].buf = loopargs[i].buf_malloc + misalign;
+ loopargs[i].buf2 = loopargs[i].buf2_malloc + misalign;
+ }
+
+
+ int count;
+ float d;
+ if (evp_cipher) {
+ name = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
+ /*
+ * -O3 -fschedule-insns messes up an optimization here!
+ * names[D_EVP] somehow becomes NULL
+ */
+
+
+ for (int k = 0; k < loopargs_len; k++) {
+ loopargs[k].ctx = EVP_CIPHER_CTX_new();
+ if (decrypt)
+ EVP_DecryptInit_ex(loopargs[k].ctx, evp_cipher, NULL, key16, iv);
+ else
+ EVP_EncryptInit_ex(loopargs[k].ctx, evp_cipher, NULL, key16, iv);
+ EVP_CIPHER_CTX_set_padding(loopargs[k].ctx, 0);
+ }
+
+ Time_F(START);
+ pthread_t timer_thread;
+
+ if (pthread_create(&timer_thread, NULL, stop_run, NULL))
+ return NULL;
+
+ count = run_benchmark(async_jobs, EVP_Update_loop, loopargs);
+ d = Time_F(STOP);
+ for (int k = 0; k < loopargs_len; k++) {
+ EVP_CIPHER_CTX_free(loopargs[k].ctx);
+ }
+ }
+ if (evp_md) {
+ name = OBJ_nid2ln(EVP_MD_type(evp_md));
+ // print_message(names[D_EVP], save_count, lengths[testnum]);
+
+ pthread_t timer_thread;
+ if (pthread_create(&timer_thread, NULL, stop_run, NULL))
+ return NULL;
+
+ Time_F(START);
+ count = run_benchmark(async_jobs, EVP_Digest_loop, loopargs);
+ d = Time_F(STOP);
+ }
+
+ // Save results in hacky way
+ double results[] = {(double) lengths[testnum], (double) count, d};
+
+
+ (*env)->SetDoubleArrayRegion(env, ret, 0, 3, results);
+ // print_result(D_EVP, testnum, count, d);
+
+
+ return ret;
+}