/*
 * Demo on how to use /dev/crypto device for ciphering.
 *
 * Placed under public domain.
 *
 */
#include <poll.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>

#include <sys/ioctl.h>
#include <crypto/cryptodev.h>

#include "testhelper.h"

#ifdef ENABLE_ASYNC

static int debug = 0;

#define	DATA_SIZE	8*1024
#define	BLOCK_SIZE	16
#define	KEY_SIZE	16

static int
test_crypto(int cfd)
{
	char plaintext_raw[DATA_SIZE + 63], *plaintext;
	char ciphertext_raw[DATA_SIZE + 63], *ciphertext;
	char iv[BLOCK_SIZE];
	char key[KEY_SIZE];

	struct session_op sess;
#ifdef CIOCGSESSINFO
	struct session_info_op siop;
#endif
	struct crypt_op cryp;

	if (debug) printf("running %s\n", __func__);

	memset(&sess, 0, sizeof(sess));
	memset(&cryp, 0, sizeof(cryp));

	memset(key, 0x33,  sizeof(key));
	memset(iv, 0x03,  sizeof(iv));

	/* Get crypto session for AES128 */
	sess.cipher = CRYPTO_AES_CBC;
	sess.keylen = KEY_SIZE;
	sess.key = key;
	if (ioctl(cfd, CIOCGSESSION, &sess)) {
		perror("ioctl(CIOCGSESSION)");
		return 1;
	}

	if (debug) printf("%s: got the session\n", __func__);

#ifdef CIOCGSESSINFO
	siop.ses = sess.ses;
	if (ioctl(cfd, CIOCGSESSINFO, &siop)) {
		perror("ioctl(CIOCGSESSINFO)");
		return 1;
	}
	plaintext = (char *)(((unsigned long)plaintext_raw + siop.alignmask) & ~siop.alignmask);
	ciphertext = (char *)(((unsigned long)ciphertext_raw + siop.alignmask) & ~siop.alignmask);
#else
	plaintext = plaintext_raw;
	ciphertext = ciphertext_raw;
#endif
	memset(plaintext, 0x15, DATA_SIZE);

	/* Encrypt data.in to data.encrypted */
	cryp.ses = sess.ses;
	cryp.len = DATA_SIZE;
	cryp.src = plaintext;
	cryp.dst = ciphertext;
	cryp.iv = iv;
	cryp.op = COP_ENCRYPT;

	DO_OR_DIE(do_async_crypt(cfd, &cryp), 0);
	DO_OR_DIE(do_async_fetch(cfd, &cryp), 0);

	if (debug) printf("%s: data encrypted\n", __func__);

	if (ioctl(cfd, CIOCFSESSION, &sess.ses)) {
		perror("ioctl(CIOCFSESSION)");
		return 1;
	}
	if (debug) printf("%s: session finished\n", __func__);

	if (ioctl(cfd, CIOCGSESSION, &sess)) {
		perror("ioctl(CIOCGSESSION)");
		return 1;
	}
	if (debug) printf("%s: got new session\n", __func__);

	/* Decrypt data.encrypted to data.decrypted */
	cryp.ses = sess.ses;
	cryp.len = DATA_SIZE;
	cryp.src = ciphertext;
	cryp.dst = ciphertext;
	cryp.iv = iv;
	cryp.op = COP_DECRYPT;

	DO_OR_DIE(do_async_crypt(cfd, &cryp), 0);
	DO_OR_DIE(do_async_fetch(cfd, &cryp), 0);

	if (debug) printf("%s: data encrypted\n", __func__);

	/* Verify the result */
	if (memcmp(plaintext, ciphertext, DATA_SIZE) != 0) {
		fprintf(stderr,
			"FAIL: Decrypted data are different from the input data.\n");
		return 1;
	} else if (debug)
		printf("Test passed\n");

	/* Finish crypto session */
	if (ioctl(cfd, CIOCFSESSION, &sess.ses)) {
		perror("ioctl(CIOCFSESSION)");
		return 1;
	}

	return 0;
}

static int test_aes(int cfd)
{
	char plaintext1_raw[BLOCK_SIZE + 63], *plaintext1;
	char ciphertext1[BLOCK_SIZE] = { 0xdf, 0x55, 0x6a, 0x33, 0x43, 0x8d, 0xb8, 0x7b, 0xc4, 0x1b, 0x17, 0x52, 0xc5, 0x5e, 0x5e, 0x49 };
	char iv1[BLOCK_SIZE];
	char key1[KEY_SIZE] = { 0xff, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
	char plaintext2_data[BLOCK_SIZE] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00 };
	char plaintext2_raw[BLOCK_SIZE + 63], *plaintext2;
	char ciphertext2[BLOCK_SIZE] = { 0xb7, 0x97, 0x2b, 0x39, 0x41, 0xc4, 0x4b, 0x90, 0xaf, 0xa7, 0xb2, 0x64, 0xbf, 0xba, 0x73, 0x87 };
	char iv2[BLOCK_SIZE];
	char key2[KEY_SIZE];

	struct session_op sess1, sess2;
#ifdef CIOCGSESSINFO
	struct session_info_op siop1, siop2;
#endif
	struct crypt_op cryp1, cryp2;

	memset(&sess1, 0, sizeof(sess1));
	memset(&sess2, 0, sizeof(sess2));
	memset(&cryp1, 0, sizeof(cryp1));
	memset(&cryp2, 0, sizeof(cryp2));

	/* Get crypto session for AES128 */
	sess1.cipher = CRYPTO_AES_CBC;
	sess1.keylen = KEY_SIZE;
	sess1.key = key1;
	if (ioctl(cfd, CIOCGSESSION, &sess1)) {
		perror("ioctl(CIOCGSESSION)");
		return 1;
	}
#ifdef CIOCGSESSINFO
	siop1.ses = sess1.ses;
	if (ioctl(cfd, CIOCGSESSINFO, &siop1)) {
		perror("ioctl(CIOCGSESSINFO)");
		return 1;
	}
	plaintext1 = (char *)(((unsigned long)plaintext1_raw + siop1.alignmask) & ~siop1.alignmask);
#else
	plaintext1 = plaintext1_raw;
#endif
	memset(plaintext1, 0x0, BLOCK_SIZE);

	memset(iv1, 0x0, sizeof(iv1));
	memset(key2, 0x0, sizeof(key2));

	/* Get second crypto session for AES128 */
	sess2.cipher = CRYPTO_AES_CBC;
	sess2.keylen = KEY_SIZE;
	sess2.key = key2;
	if (ioctl(cfd, CIOCGSESSION, &sess2)) {
		perror("ioctl(CIOCGSESSION)");
		return 1;
	}
#ifdef CIOCGSESSINFO
	siop2.ses = sess2.ses;
	if (ioctl(cfd, CIOCGSESSINFO, &siop2)) {
		perror("ioctl(CIOCGSESSINFO)");
		return 1;
	}
	plaintext2 = (char *)(((unsigned long)plaintext2_raw + siop2.alignmask) & ~siop2.alignmask);
#else
	plaintext2 = plaintext2_raw;
#endif
	memcpy(plaintext2, plaintext2_data, BLOCK_SIZE);

	/* Encrypt data.in to data.encrypted */
	cryp1.ses = sess1.ses;
	cryp1.len = BLOCK_SIZE;
	cryp1.src = plaintext1;
	cryp1.dst = plaintext1;
	cryp1.iv = iv1;
	cryp1.op = COP_ENCRYPT;

	DO_OR_DIE(do_async_crypt(cfd, &cryp1), 0);
	if (debug) printf("cryp1 written out\n");

	memset(iv2, 0x0, sizeof(iv2));

	/* Encrypt data.in to data.encrypted */
	cryp2.ses = sess2.ses;
	cryp2.len = BLOCK_SIZE;
	cryp2.src = plaintext2;
	cryp2.dst = plaintext2;
	cryp2.iv = iv2;
	cryp2.op = COP_ENCRYPT;

	DO_OR_DIE(do_async_crypt(cfd, &cryp2), 0);
	if (debug) printf("cryp2 written out\n");

	DO_OR_DIE(do_async_fetch(cfd, &cryp1), 0);
	DO_OR_DIE(do_async_fetch(cfd, &cryp2), 0);
	if (debug) printf("cryp1 + cryp2 successfully read\n");

	/* Verify the result */
	if (memcmp(plaintext1, ciphertext1, BLOCK_SIZE) != 0) {
		int i;
		fprintf(stderr,
			"FAIL: Decrypted data are different from the input data.\n");
		printf("plaintext:");
		for (i = 0; i < BLOCK_SIZE; i++) {
			if ((i % 30) == 0)
				printf("\n");
			printf("%02x ", plaintext1[i]);
		}
		printf("ciphertext:");
		for (i = 0; i < BLOCK_SIZE; i++) {
			if ((i % 30) == 0)
				printf("\n");
			printf("%02x ", ciphertext1[i]);
		}
		printf("\n");
		return 1;
	} else {
		if (debug) printf("result 1 passed\n");
	}

	/* Test 2 */

	/* Verify the result */
	if (memcmp(plaintext2, ciphertext2, BLOCK_SIZE) != 0) {
		int i;
		fprintf(stderr,
			"FAIL: Decrypted data are different from the input data.\n");
		printf("plaintext:");
		for (i = 0; i < BLOCK_SIZE; i++) {
			if ((i % 30) == 0)
				printf("\n");
			printf("%02x ", plaintext2[i]);
		}
		printf("ciphertext:");
		for (i = 0; i < BLOCK_SIZE; i++) {
			if ((i % 30) == 0)
				printf("\n");
			printf("%02x ", ciphertext2[i]);
		}
		printf("\n");
		return 1;
	} else {
		if (debug) printf("result 2 passed\n");
	}

	if (debug) printf("AES Test passed\n");

	/* Finish crypto session */
	if (ioctl(cfd, CIOCFSESSION, &sess1.ses)) {
		perror("ioctl(CIOCFSESSION)");
		return 1;
	}
	if (ioctl(cfd, CIOCFSESSION, &sess2.ses)) {
		perror("ioctl(CIOCFSESSION)");
		return 1;
	}

	return 0;
}

int
main(int argc, char** argv)
{
	int fd = -1, cfd = -1;
	
	if (argc > 1) debug = 1;

	/* Open the crypto device */
	fd = open("/dev/crypto", O_RDWR, 0);
	if (fd < 0) {
		perror("open(/dev/crypto)");
		return 1;
	}

	/* Clone file descriptor */
	if (ioctl(fd, CRIOGET, &cfd)) {
		perror("ioctl(CRIOGET)");
		return 1;
	}

	/* Set close-on-exec (not really neede here) */
	if (fcntl(cfd, F_SETFD, 1) == -1) {
		perror("fcntl(F_SETFD)");
		return 1;
	}

	/* Run the test itself */
	if (test_aes(cfd))
		return 1;

	if (test_crypto(cfd))
		return 1;

	/* Close cloned descriptor */
	if (close(cfd)) {
		perror("close(cfd)");
		return 1;
	}

	/* Close the original descriptor */
	if (close(fd)) {
		perror("close(fd)");
		return 1;
	}

	return 0;
}
#else
int
main(int argc, char** argv)
{
	return (0);
}
#endif