summaryrefslogtreecommitdiffstats
path: root/src/crypto/isa-l/isa-l_crypto/examples/saturation_test/aes_thread.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/crypto/isa-l/isa-l_crypto/examples/saturation_test/aes_thread.c')
-rw-r--r--src/crypto/isa-l/isa-l_crypto/examples/saturation_test/aes_thread.c380
1 files changed, 380 insertions, 0 deletions
diff --git a/src/crypto/isa-l/isa-l_crypto/examples/saturation_test/aes_thread.c b/src/crypto/isa-l/isa-l_crypto/examples/saturation_test/aes_thread.c
new file mode 100644
index 000000000..366fc9bcf
--- /dev/null
+++ b/src/crypto/isa-l/isa-l_crypto/examples/saturation_test/aes_thread.c
@@ -0,0 +1,380 @@
+
+#include <pthread.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "isal_multithread_perf.h"
+
+struct aes_context {
+ int const bits;
+ int (*const preproc)(struct aes_context * pCtx);
+ void (*const processor)(struct aes_context * pCtx, char *plaintext,
+ char *ciphertext, uint64_t len);
+ void (*const postproc)(struct aes_context * pCtx);
+};
+
+#define rounds_buf 2 /* first one is plain text, second is cipher text */
+
+static uint64_t aes_thread_func(int32_t id, struct aes_context *pCtx)
+{
+ uint32_t i = 0, j = 0;
+ char *aes_buf[rounds_buf] = { NULL }; /* aes buf is used to do checksum compute */
+ char *carry_buf[rounds_buf] = { NULL }; /* carry buf is used to do memory movement */
+ uint64_t round = -1;
+ struct timeval start_tv, stop_tv;
+ long long secs = run_secs;
+
+ printfv("Thread %i is started\n", id);
+ /* memory allocate */
+ for (j = 0; j < rounds_buf; j++) {
+ carry_buf[j] = (char *)calloc((size_t)buflen, 1);
+ if (carry_buf[j] == NULL) {
+ printf("calloc failed test aborted\n");
+ goto out;
+ }
+
+ aes_buf[j] = (char *)calloc((size_t)buflen, 1);
+ if (aes_buf[j] == NULL) {
+ printf("calloc failed test aborted\n");
+ goto out;
+ }
+
+ /* Create the random data */
+ for (i = 0; i < buflen; i += 1024) {
+ carry_buf[j][i] = i % 256;
+ aes_buf[j][i] = i % 256;
+ }
+ }
+
+ if (pCtx->preproc(pCtx)) {
+ printf("preproc failed test aborted\n");
+ goto out;
+ }
+
+ /* Thread sync */
+ pthread_mutex_lock(&count_lock);
+ count++;
+ if (count == num_threads) {
+ pthread_cond_broadcast(&count_cond);
+ } else {
+ pthread_cond_wait(&count_cond, &count_lock);
+ }
+ pthread_mutex_unlock(&count_lock);
+
+ printfv("Thread %i is ready\n", id);
+ /* hash func starts to run */
+ round = 0;
+ gettimeofday(&start_tv, 0);
+ gettimeofday(&stop_tv, 0);
+ while (secs > (stop_tv.tv_sec - start_tv.tv_sec)) {
+ /* Pre mem-operation */
+ if (prememcpy)
+ memcpy(aes_buf[0], carry_buf[0], buflen);
+
+ /* Calculate checksum */
+ pCtx->processor(pCtx, aes_buf[0], aes_buf[1], buflen);
+
+ /* Post mem-operation */
+ if (postmemcpy)
+ memcpy(carry_buf[1], aes_buf[1], buflen);
+
+ round++;
+
+ gettimeofday(&stop_tv, 0);
+ }
+ printfv("thread %2i, aes_func rounds %ld\n", id, round);
+
+ out:
+ pCtx->postproc(pCtx);
+
+ for (j = 0; j < rounds_buf; j++) {
+ free(carry_buf[j]);
+ free(aes_buf[j]);
+ }
+
+ return round;
+}
+
+/*
+ * facilities for AES-CBC
+ */
+static unsigned char const ic[] = {
+ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
+ 0x0e, 0x0f
+};
+
+void mk_rand_data(uint8_t * data, uint32_t size)
+{
+ unsigned int i;
+ for (i = 0; i < size; i++) {
+ *data++ = rand();
+ }
+}
+
+/* thread functions for cbc dec */
+struct cbc_context {
+ struct aes_context base;
+ uint8_t *iv;
+ uint8_t key[CBC_256_BITS];
+ struct cbc_key_data *key_data;
+};
+
+static int cbc_dec_pre(struct aes_context *p)
+{
+ struct cbc_context *pCtx = (struct cbc_context *)p;
+ int ret;
+
+ ret = posix_memalign((void **)&pCtx->iv, 16, (CBC_IV_DATA_LEN));
+ ret |= posix_memalign((void **)&pCtx->key_data, 16, (sizeof(*pCtx->key_data)));
+
+ if ((0 != ret) || (NULL == pCtx->iv) || (NULL == pCtx->key_data))
+ return 1;
+
+ mk_rand_data(pCtx->key, sizeof(pCtx->key));
+ memcpy(pCtx->iv, ic, CBC_IV_DATA_LEN);
+ aes_cbc_precomp(pCtx->key, pCtx->base.bits, pCtx->key_data);
+
+ return 0;
+}
+
+static void cbc_dec_post(struct aes_context *p)
+{
+ struct cbc_context *pCtx = (struct cbc_context *)p;
+
+ free(pCtx->iv);
+ free(pCtx->key_data);
+
+ return;
+}
+
+static void cbc_dec_proc(struct aes_context *p, char *plaintext, char *ciphertext,
+ uint64_t len)
+{
+ struct cbc_context *pCtx = (struct cbc_context *)p;
+
+ if (pCtx->base.bits == 128)
+ aes_cbc_dec_128(ciphertext, pCtx->iv, pCtx->key_data->dec_keys, plaintext,
+ len);
+ else if (pCtx->base.bits == 192)
+ aes_cbc_dec_192(ciphertext, pCtx->iv, pCtx->key_data->dec_keys, plaintext,
+ len);
+ else if (pCtx->base.bits == 256)
+ aes_cbc_dec_256(ciphertext, pCtx->iv, pCtx->key_data->dec_keys, plaintext,
+ len);
+ else {
+ printf("unsupported cbc encryption bits %d\n", pCtx->base.bits);
+ exit(1);
+ }
+
+ return;
+}
+
+void *cbc_128_dec_func(void *arg)
+{
+ int32_t id = *((int *)arg);
+ uint64_t round = -1;
+
+ struct cbc_context ctx =
+ { {128, cbc_dec_pre, cbc_dec_proc, cbc_dec_post}, NULL, {0}, NULL };
+
+ round = aes_thread_func(id, &ctx.base);
+
+ pthread_exit((void *)round);
+}
+
+void *cbc_192_dec_func(void *arg)
+{
+ int32_t id = *((int *)arg);
+ uint64_t round = -1;
+
+ struct cbc_context ctx =
+ { {192, cbc_dec_pre, cbc_dec_proc, cbc_dec_post}, NULL, {0}, NULL };
+
+ round = aes_thread_func(id, &ctx.base);
+
+ pthread_exit((void *)round);
+}
+
+void *cbc_256_dec_func(void *arg)
+{
+ int32_t id = *((int *)arg);
+ uint64_t round = -1;
+
+ struct cbc_context ctx =
+ { {256, cbc_dec_pre, cbc_dec_proc, cbc_dec_post}, NULL, {0}, NULL };
+
+ round = aes_thread_func(id, &ctx.base);
+
+ pthread_exit((void *)round);
+}
+
+/*
+ * thread functions for xts enc
+ */
+struct xts_content {
+ struct aes_context base;
+ unsigned char key1[16 * 2];
+ unsigned char key2[16 * 2];
+ unsigned char tinit[16];
+};
+
+static int xts_enc_pre(struct aes_context *p)
+{
+ struct xts_content *pCtx = (struct xts_content *)p;
+
+ mk_rand_data(pCtx->key1, pCtx->base.bits / 8);
+ mk_rand_data(pCtx->key2, pCtx->base.bits / 8);
+ mk_rand_data(pCtx->tinit, sizeof(pCtx->tinit));
+
+ return 0;
+}
+
+static void xts_enc_post(struct aes_context *p)
+{
+ return;
+}
+
+static void xts_enc_proc(struct aes_context *p, char *plaintext, char *ciphertext,
+ uint64_t len)
+{
+ struct xts_content *pCtx = (struct xts_content *)p;
+
+ if (pCtx->base.bits == 128)
+ XTS_AES_128_enc(pCtx->key2, pCtx->key1, pCtx->tinit, len, plaintext,
+ ciphertext);
+ else if (pCtx->base.bits == 256)
+ XTS_AES_256_enc(pCtx->key2, pCtx->key1, pCtx->tinit, len, plaintext,
+ ciphertext);
+ else {
+ printf("unsupported xts encryption bits %d\n", pCtx->base.bits);
+ exit(1);
+ }
+
+ return;
+}
+
+void *xts_128_enc_func(void *arg)
+{
+ int32_t id = *((int *)arg);
+ uint64_t round = -1;
+
+ struct xts_content ctx =
+ { {128, xts_enc_pre, xts_enc_proc, xts_enc_post}, {0}, {0}, {0} };
+
+ round = aes_thread_func(id, &ctx.base);
+
+ pthread_exit((void *)round);
+}
+
+void *xts_256_enc_func(void *arg)
+{
+ int32_t id = *((int *)arg);
+ uint64_t round = -1;
+
+ struct xts_content ctx =
+ { {256, xts_enc_pre, xts_enc_proc, xts_enc_post}, {0}, {0}, {0} };
+
+ round = aes_thread_func(id, &ctx.base);
+
+ pthread_exit((void *)round);
+}
+
+/*
+ * thread functions for gcm enc
+ */
+struct gcm_context {
+ struct aes_context base;
+ uint8_t *key;
+ unsigned char *iv;
+ unsigned char *aad;
+ unsigned char *gcm_tag;
+ struct gcm_key_data gkey;
+ struct gcm_context_data gctx;
+};
+
+static int gcm_enc_pre(struct aes_context *p)
+{
+ uint8_t const IVend[] = GCM_IV_END_MARK;
+
+ struct gcm_context *pCtx = (struct gcm_context *)p;
+
+ pCtx->key = malloc(pCtx->base.bits / 8);
+ pCtx->iv = malloc(GCM_IV_LEN);
+ pCtx->gcm_tag = malloc(MAX_TAG_LEN);
+ pCtx->aad = malloc(AAD_LENGTH);
+
+ mk_rand_data(pCtx->aad, AAD_LENGTH);
+
+ mk_rand_data(pCtx->iv, GCM_IV_LEN);
+ memcpy(&pCtx->iv[GCM_IV_END_START], IVend, sizeof(IVend));
+
+ mk_rand_data(pCtx->key, pCtx->base.bits / 8);
+ if (pCtx->base.bits == 128)
+ aes_gcm_pre_128(pCtx->key, &pCtx->gkey);
+ else
+ aes_gcm_pre_256(pCtx->key, &pCtx->gkey);
+
+ return 0;
+}
+
+static void gcm_enc_post(struct aes_context *p)
+{
+ struct gcm_context *pCtx = (struct gcm_context *)p;
+
+ free(pCtx->key);
+ free(pCtx->iv);
+ free(pCtx->gcm_tag);
+ free(pCtx->aad);
+
+ return;
+}
+
+static void gcm_enc_proc(struct aes_context *p, char *plaintext, char *ciphertext,
+ uint64_t len)
+{
+ struct gcm_context *pCtx = (struct gcm_context *)p;
+
+ if (pCtx->base.bits == 128)
+ aes_gcm_enc_128(&pCtx->gkey, &pCtx->gctx, ciphertext, plaintext, len, pCtx->iv,
+ pCtx->aad, AAD_LENGTH, pCtx->gcm_tag, MAX_TAG_LEN);
+ else if (pCtx->base.bits == 256)
+ aes_gcm_enc_256(&pCtx->gkey, &pCtx->gctx, ciphertext, plaintext, len, pCtx->iv,
+ pCtx->aad, AAD_LENGTH, pCtx->gcm_tag, MAX_TAG_LEN);
+ else {
+ printf("unsupported gcm encryption bits %d\n", pCtx->base.bits);
+ exit(1);
+ }
+
+ return;
+}
+
+void *gcm_128_enc_func(void *arg)
+{
+ int32_t id = *((int *)arg);
+ uint64_t round = -1;
+
+ struct gcm_context ctx =
+ { {128, gcm_enc_pre, gcm_enc_proc, gcm_enc_post}, NULL, NULL, NULL, NULL, {0} };
+
+ round = aes_thread_func(id, &ctx.base);
+
+ pthread_exit((void *)round);
+}
+
+void *gcm_256_enc_func(void *arg)
+{
+ int32_t id = *((int *)arg);
+ uint64_t round = -1;
+
+ struct gcm_context ctx =
+ { {256, gcm_enc_pre, gcm_enc_proc, gcm_enc_post}, NULL, NULL, NULL, NULL, {0} };
+
+ round = aes_thread_func(id, &ctx.base);
+
+ pthread_exit((void *)round);
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-29 22:38:08 +0000