patch-2.4.22 linux-2.4.22/crypto/tcrypt.c
Next file: linux-2.4.22/crypto/tcrypt.h
Previous file: linux-2.4.22/crypto/sha512.c
Back to the patch index
Back to the overall index
- Lines: 2419
- Date:
2003-08-25 04:44:40.000000000 -0700
- Orig file:
linux-2.4.21/crypto/tcrypt.c
- Orig date:
1969-12-31 16:00:00.000000000 -0800
diff -urN linux-2.4.21/crypto/tcrypt.c linux-2.4.22/crypto/tcrypt.c
@@ -0,0 +1,2418 @@
+/*
+ * Quick & dirty crypto testing module.
+ *
+ * This will only exist until we have a better testing mechanism
+ * (e.g. a char device).
+ *
+ * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
+ * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ */
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/string.h>
+#include <linux/mm.h>
+#include <linux/slab.h>
+#include <asm/scatterlist.h>
+#include <linux/string.h>
+#include <linux/crypto.h>
+#include <linux/highmem.h>
+#include "tcrypt.h"
+
+/*
+ * Need to kmalloc() memory for testing kmap().
+ */
+#define TVMEMSIZE 4096
+#define XBUFSIZE 32768
+
+/*
+ * Indexes into the xbuf to simulate cross-page access.
+ */
+#define IDX1 37
+#define IDX2 32400
+#define IDX3 1
+#define IDX4 8193
+#define IDX5 22222
+#define IDX6 17101
+#define IDX7 27333
+#define IDX8 3000
+
+static int mode = 0;
+static char *xbuf;
+static char *tvmem;
+
+static char *check[] = {
+ "des", "md5", "des3_ede", "rot13", "sha1", "sha256", "blowfish",
+ "twofish", "serpent", "sha384", "sha512", "md4", "aes", "deflate",
+ NULL
+};
+
+static void
+hexdump(unsigned char *buf, unsigned int len)
+{
+ while (len--)
+ printk("%02x", *buf++);
+
+ printk("\n");
+}
+
+static void
+test_md5(void)
+{
+ char *p;
+ unsigned int i;
+ struct scatterlist sg[2];
+ char result[128];
+ struct crypto_tfm *tfm;
+ struct md5_testvec *md5_tv;
+ unsigned int tsize;
+
+ printk("\ntesting md5\n");
+
+ tsize = sizeof (md5_tv_template);
+ if (tsize > TVMEMSIZE) {
+ printk("template (%u) too big for tvmem (%u)\n", tsize,
+ TVMEMSIZE);
+ return;
+ }
+
+ memcpy(tvmem, md5_tv_template, tsize);
+ md5_tv = (void *) tvmem;
+
+ tfm = crypto_alloc_tfm("md5", 0);
+ if (tfm == NULL) {
+ printk("failed to load transform for md5\n");
+ return;
+ }
+
+ for (i = 0; i < MD5_TEST_VECTORS; i++) {
+ printk("test %u:\n", i + 1);
+ memset(result, 0, sizeof (result));
+
+ p = md5_tv[i].plaintext;
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = strlen(md5_tv[i].plaintext);
+
+ crypto_digest_init(tfm);
+ crypto_digest_update(tfm, sg, 1);
+ crypto_digest_final(tfm, result);
+
+ hexdump(result, crypto_tfm_alg_digestsize(tfm));
+ printk("%s\n",
+ memcmp(result, md5_tv[i].digest,
+ crypto_tfm_alg_digestsize(tfm)) ? "fail" :
+ "pass");
+ }
+
+ printk("\ntesting md5 across pages\n");
+
+ /* setup the dummy buffer first */
+ memset(xbuf, 0, XBUFSIZE);
+ memcpy(&xbuf[IDX1], "abcdefghijklm", 13);
+ memcpy(&xbuf[IDX2], "nopqrstuvwxyz", 13);
+
+ p = &xbuf[IDX1];
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = 13;
+
+ p = &xbuf[IDX2];
+ sg[1].page = virt_to_page(p);
+ sg[1].offset = ((long) p & ~PAGE_MASK);
+ sg[1].length = 13;
+
+ memset(result, 0, sizeof (result));
+ crypto_digest_digest(tfm, sg, 2, result);
+ hexdump(result, crypto_tfm_alg_digestsize(tfm));
+
+ printk("%s\n",
+ memcmp(result, md5_tv[4].digest,
+ crypto_tfm_alg_digestsize(tfm)) ? "fail" : "pass");
+ crypto_free_tfm(tfm);
+}
+
+#ifdef CONFIG_CRYPTO_HMAC
+static void
+test_hmac_md5(void)
+{
+ char *p;
+ unsigned int i, klen;
+ struct scatterlist sg[2];
+ char result[128];
+ struct crypto_tfm *tfm;
+ struct hmac_md5_testvec *hmac_md5_tv;
+ unsigned int tsize;
+
+ tfm = crypto_alloc_tfm("md5", 0);
+ if (tfm == NULL) {
+ printk("failed to load transform for md5\n");
+ return;
+ }
+
+ printk("\ntesting hmac_md5\n");
+
+ tsize = sizeof (hmac_md5_tv_template);
+ if (tsize > TVMEMSIZE) {
+ printk("template (%u) too big for tvmem (%u)\n", tsize,
+ TVMEMSIZE);
+ goto out;
+ }
+
+ memcpy(tvmem, hmac_md5_tv_template, tsize);
+ hmac_md5_tv = (void *) tvmem;
+
+ for (i = 0; i < HMAC_MD5_TEST_VECTORS; i++) {
+ printk("test %u:\n", i + 1);
+ memset(result, 0, sizeof (result));
+
+ p = hmac_md5_tv[i].plaintext;
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = strlen(hmac_md5_tv[i].plaintext);
+
+ klen = strlen(hmac_md5_tv[i].key);
+ crypto_hmac(tfm, hmac_md5_tv[i].key, &klen, sg, 1, result);
+
+ hexdump(result, crypto_tfm_alg_digestsize(tfm));
+ printk("%s\n",
+ memcmp(result, hmac_md5_tv[i].digest,
+ crypto_tfm_alg_digestsize(tfm)) ? "fail" :
+ "pass");
+ }
+
+ printk("\ntesting hmac_md5 across pages\n");
+
+ memset(xbuf, 0, XBUFSIZE);
+
+ memcpy(&xbuf[IDX1], "what do ya want ", 16);
+ memcpy(&xbuf[IDX2], "for nothing?", 12);
+
+ p = &xbuf[IDX1];
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = 16;
+
+ p = &xbuf[IDX2];
+ sg[1].page = virt_to_page(p);
+ sg[1].offset = ((long) p & ~PAGE_MASK);
+ sg[1].length = 12;
+
+ memset(result, 0, sizeof (result));
+ klen = strlen(hmac_md5_tv[7].key);
+ crypto_hmac(tfm, hmac_md5_tv[7].key, &klen, sg, 2, result);
+ hexdump(result, crypto_tfm_alg_digestsize(tfm));
+
+ printk("%s\n",
+ memcmp(result, hmac_md5_tv[7].digest,
+ crypto_tfm_alg_digestsize(tfm)) ? "fail" : "pass");
+out:
+ crypto_free_tfm(tfm);
+}
+
+static void
+test_hmac_sha1(void)
+{
+ char *p;
+ unsigned int i, klen;
+ struct crypto_tfm *tfm;
+ struct hmac_sha1_testvec *hmac_sha1_tv;
+ struct scatterlist sg[2];
+ unsigned int tsize;
+ char result[SHA1_DIGEST_SIZE];
+
+ tfm = crypto_alloc_tfm("sha1", 0);
+ if (tfm == NULL) {
+ printk("failed to load transform for sha1\n");
+ return;
+ }
+
+ printk("\ntesting hmac_sha1\n");
+
+ tsize = sizeof (hmac_sha1_tv_template);
+ if (tsize > TVMEMSIZE) {
+ printk("template (%u) too big for tvmem (%u)\n", tsize,
+ TVMEMSIZE);
+ goto out;
+ }
+
+ memcpy(tvmem, hmac_sha1_tv_template, tsize);
+ hmac_sha1_tv = (void *) tvmem;
+
+ for (i = 0; i < HMAC_SHA1_TEST_VECTORS; i++) {
+ printk("test %u:\n", i + 1);
+ memset(result, 0, sizeof (result));
+
+ p = hmac_sha1_tv[i].plaintext;
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = strlen(hmac_sha1_tv[i].plaintext);
+
+ klen = strlen(hmac_sha1_tv[i].key);
+
+ crypto_hmac(tfm, hmac_sha1_tv[i].key, &klen, sg, 1, result);
+
+ hexdump(result, sizeof (result));
+ printk("%s\n",
+ memcmp(result, hmac_sha1_tv[i].digest,
+ crypto_tfm_alg_digestsize(tfm)) ? "fail" :
+ "pass");
+ }
+
+ printk("\ntesting hmac_sha1 across pages\n");
+
+ /* setup the dummy buffer first */
+ memset(xbuf, 0, XBUFSIZE);
+
+ memcpy(&xbuf[IDX1], "what do ya want ", 16);
+ memcpy(&xbuf[IDX2], "for nothing?", 12);
+
+ p = &xbuf[IDX1];
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = 16;
+
+ p = &xbuf[IDX2];
+ sg[1].page = virt_to_page(p);
+ sg[1].offset = ((long) p & ~PAGE_MASK);
+ sg[1].length = 12;
+
+ memset(result, 0, sizeof (result));
+ klen = strlen(hmac_sha1_tv[7].key);
+ crypto_hmac(tfm, hmac_sha1_tv[7].key, &klen, sg, 2, result);
+ hexdump(result, crypto_tfm_alg_digestsize(tfm));
+
+ printk("%s\n",
+ memcmp(result, hmac_sha1_tv[7].digest,
+ crypto_tfm_alg_digestsize(tfm)) ? "fail" : "pass");
+out:
+ crypto_free_tfm(tfm);
+}
+
+static void
+test_hmac_sha256(void)
+{
+ char *p;
+ unsigned int i, klen;
+ struct crypto_tfm *tfm;
+ struct hmac_sha256_testvec *hmac_sha256_tv;
+ struct scatterlist sg[2];
+ unsigned int tsize;
+ char result[SHA256_DIGEST_SIZE];
+
+ tfm = crypto_alloc_tfm("sha256", 0);
+ if (tfm == NULL) {
+ printk("failed to load transform for sha256\n");
+ return;
+ }
+
+ printk("\ntesting hmac_sha256\n");
+
+ tsize = sizeof (hmac_sha256_tv_template);
+ if (tsize > TVMEMSIZE) {
+ printk("template (%u) too big for tvmem (%u)\n", tsize,
+ TVMEMSIZE);
+ goto out;
+ }
+
+ memcpy(tvmem, hmac_sha256_tv_template, tsize);
+ hmac_sha256_tv = (void *) tvmem;
+
+ for (i = 0; i < HMAC_SHA256_TEST_VECTORS; i++) {
+ printk("test %u:\n", i + 1);
+ memset(result, 0, sizeof (result));
+
+ p = hmac_sha256_tv[i].plaintext;
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = strlen(hmac_sha256_tv[i].plaintext);
+
+ klen = strlen(hmac_sha256_tv[i].key);
+
+ hexdump(hmac_sha256_tv[i].key, strlen(hmac_sha256_tv[i].key));
+ crypto_hmac(tfm, hmac_sha256_tv[i].key, &klen, sg, 1, result);
+ hexdump(result, crypto_tfm_alg_digestsize(tfm));
+ printk("%s\n",
+ memcmp(result, hmac_sha256_tv[i].digest,
+ crypto_tfm_alg_digestsize(tfm)) ? "fail" : "pass");
+ }
+
+out:
+ crypto_free_tfm(tfm);
+}
+
+#endif /* CONFIG_CRYPTO_HMAC */
+
+static void
+test_md4(void)
+{
+ char *p;
+ unsigned int i;
+ struct scatterlist sg[1];
+ char result[128];
+ struct crypto_tfm *tfm;
+ struct md4_testvec *md4_tv;
+ unsigned int tsize;
+
+ printk("\ntesting md4\n");
+
+ tsize = sizeof (md4_tv_template);
+ if (tsize > TVMEMSIZE) {
+ printk("template (%u) too big for tvmem (%u)\n", tsize,
+ TVMEMSIZE);
+ return;
+ }
+
+ memcpy(tvmem, md4_tv_template, tsize);
+ md4_tv = (void *) tvmem;
+
+ tfm = crypto_alloc_tfm("md4", 0);
+ if (tfm == NULL) {
+ printk("failed to load transform for md4\n");
+ return;
+ }
+
+ for (i = 0; i < MD4_TEST_VECTORS; i++) {
+ printk("test %u:\n", i + 1);
+ memset(result, 0, sizeof (result));
+
+ p = md4_tv[i].plaintext;
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = strlen(md4_tv[i].plaintext);
+
+ crypto_digest_digest(tfm, sg, 1, result);
+
+ hexdump(result, crypto_tfm_alg_digestsize(tfm));
+ printk("%s\n",
+ memcmp(result, md4_tv[i].digest,
+ crypto_tfm_alg_digestsize(tfm)) ? "fail" :
+ "pass");
+ }
+
+ crypto_free_tfm(tfm);
+}
+
+static void
+test_sha1(void)
+{
+ char *p;
+ unsigned int i;
+ struct crypto_tfm *tfm;
+ struct sha1_testvec *sha1_tv;
+ struct scatterlist sg[2];
+ unsigned int tsize;
+ char result[SHA1_DIGEST_SIZE];
+
+ printk("\ntesting sha1\n");
+
+ tsize = sizeof (sha1_tv_template);
+ if (tsize > TVMEMSIZE) {
+ printk("template (%u) too big for tvmem (%u)\n", tsize,
+ TVMEMSIZE);
+ return;
+ }
+
+ memcpy(tvmem, sha1_tv_template, tsize);
+ sha1_tv = (void *) tvmem;
+
+ tfm = crypto_alloc_tfm("sha1", 0);
+ if (tfm == NULL) {
+ printk("failed to load transform for sha1\n");
+ return;
+ }
+
+ for (i = 0; i < SHA1_TEST_VECTORS; i++) {
+ printk("test %u:\n", i + 1);
+ memset(result, 0, sizeof (result));
+
+ p = sha1_tv[i].plaintext;
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = strlen(sha1_tv[i].plaintext);
+
+ crypto_digest_init(tfm);
+ crypto_digest_update(tfm, sg, 1);
+ crypto_digest_final(tfm, result);
+
+ hexdump(result, crypto_tfm_alg_digestsize(tfm));
+ printk("%s\n",
+ memcmp(result, sha1_tv[i].digest,
+ crypto_tfm_alg_digestsize(tfm)) ? "fail" :
+ "pass");
+ }
+
+ printk("\ntesting sha1 across pages\n");
+
+ /* setup the dummy buffer first */
+ memset(xbuf, 0, XBUFSIZE);
+ memcpy(&xbuf[IDX1], "abcdbcdecdefdefgefghfghighij", 28);
+ memcpy(&xbuf[IDX2], "hijkijkljklmklmnlmnomnopnopq", 28);
+
+ p = &xbuf[IDX1];
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = 28;
+
+ p = &xbuf[IDX2];
+ sg[1].page = virt_to_page(p);
+ sg[1].offset = ((long) p & ~PAGE_MASK);
+ sg[1].length = 28;
+
+ memset(result, 0, sizeof (result));
+ crypto_digest_digest(tfm, sg, 2, result);
+ hexdump(result, crypto_tfm_alg_digestsize(tfm));
+ printk("%s\n",
+ memcmp(result, sha1_tv[1].digest,
+ crypto_tfm_alg_digestsize(tfm)) ? "fail" : "pass");
+ crypto_free_tfm(tfm);
+}
+
+static void
+test_sha256(void)
+{
+ char *p;
+ unsigned int i;
+ struct crypto_tfm *tfm;
+ struct sha256_testvec *sha256_tv;
+ struct scatterlist sg[2];
+ unsigned int tsize;
+ char result[SHA256_DIGEST_SIZE];
+
+ printk("\ntesting sha256\n");
+
+ tsize = sizeof (sha256_tv_template);
+ if (tsize > TVMEMSIZE) {
+ printk("template (%u) too big for tvmem (%u)\n", tsize,
+ TVMEMSIZE);
+ return;
+ }
+
+ memcpy(tvmem, sha256_tv_template, tsize);
+ sha256_tv = (void *) tvmem;
+
+ tfm = crypto_alloc_tfm("sha256", 0);
+ if (tfm == NULL) {
+ printk("failed to load transform for sha256\n");
+ return;
+ }
+
+ for (i = 0; i < SHA256_TEST_VECTORS; i++) {
+ printk("test %u:\n", i + 1);
+ memset(result, 0, sizeof (result));
+
+ p = sha256_tv[i].plaintext;
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = strlen(sha256_tv[i].plaintext);
+
+ crypto_digest_init(tfm);
+ crypto_digest_update(tfm, sg, 1);
+ crypto_digest_final(tfm, result);
+
+ hexdump(result, crypto_tfm_alg_digestsize(tfm));
+ printk("%s\n",
+ memcmp(result, sha256_tv[i].digest,
+ crypto_tfm_alg_digestsize(tfm)) ? "fail" :
+ "pass");
+ }
+
+ printk("\ntesting sha256 across pages\n");
+
+ /* setup the dummy buffer first */
+ memset(xbuf, 0, XBUFSIZE);
+ memcpy(&xbuf[IDX1], "abcdbcdecdefdefgefghfghighij", 28);
+ memcpy(&xbuf[IDX2], "hijkijkljklmklmnlmnomnopnopq", 28);
+
+ p = &xbuf[IDX1];
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = 28;
+
+ p = &xbuf[IDX2];
+ sg[1].page = virt_to_page(p);
+ sg[1].offset = ((long) p & ~PAGE_MASK);
+ sg[1].length = 28;
+
+ memset(result, 0, sizeof (result));
+ crypto_digest_digest(tfm, sg, 2, result);
+ hexdump(result, crypto_tfm_alg_digestsize(tfm));
+ printk("%s\n",
+ memcmp(result, sha256_tv[1].digest,
+ crypto_tfm_alg_digestsize(tfm)) ? "fail" : "pass");
+
+ crypto_free_tfm(tfm);
+}
+
+static void
+test_sha384(void)
+{
+ char *p;
+ unsigned int i;
+ struct crypto_tfm *tfm;
+ struct sha384_testvec *sha384_tv;
+ struct scatterlist sg[2];
+ unsigned int tsize;
+ char result[SHA384_DIGEST_SIZE];
+
+ printk("\ntesting sha384\n");
+
+ tsize = sizeof (sha384_tv_template);
+ if (tsize > TVMEMSIZE) {
+ printk("template (%u) too big for tvmem (%u)\n", tsize,
+ TVMEMSIZE);
+ return;
+ }
+
+ memcpy(tvmem, sha384_tv_template, tsize);
+ sha384_tv = (void *) tvmem;
+
+ tfm = crypto_alloc_tfm("sha384", 0);
+ if (tfm == NULL) {
+ printk("failed to load transform for sha384\n");
+ return;
+ }
+
+ for (i = 0; i < SHA384_TEST_VECTORS; i++) {
+ printk("test %u:\n", i + 1);
+ memset(result, 0, sizeof (result));
+
+ p = sha384_tv[i].plaintext;
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = strlen(sha384_tv[i].plaintext);
+
+ crypto_digest_init(tfm);
+ crypto_digest_update(tfm, sg, 1);
+ crypto_digest_final(tfm, result);
+
+ hexdump(result, crypto_tfm_alg_digestsize(tfm));
+ printk("%s\n",
+ memcmp(result, sha384_tv[i].digest,
+ crypto_tfm_alg_digestsize(tfm)) ? "fail" :
+ "pass");
+ }
+
+ crypto_free_tfm(tfm);
+}
+
+static void
+test_sha512(void)
+{
+ char *p;
+ unsigned int i;
+ struct crypto_tfm *tfm;
+ struct sha512_testvec *sha512_tv;
+ struct scatterlist sg[2];
+ unsigned int tsize;
+ char result[SHA512_DIGEST_SIZE];
+
+ printk("\ntesting sha512\n");
+
+ tsize = sizeof (sha512_tv_template);
+ if (tsize > TVMEMSIZE) {
+ printk("template (%u) too big for tvmem (%u)\n", tsize,
+ TVMEMSIZE);
+ return;
+ }
+
+ memcpy(tvmem, sha512_tv_template, tsize);
+ sha512_tv = (void *) tvmem;
+
+ tfm = crypto_alloc_tfm("sha512", 0);
+ if (tfm == NULL) {
+ printk("failed to load transform for sha512\n");
+ return;
+ }
+
+ for (i = 0; i < SHA512_TEST_VECTORS; i++) {
+ printk("test %u:\n", i + 1);
+ memset(result, 0, sizeof (result));
+
+ p = sha512_tv[i].plaintext;
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = strlen(sha512_tv[i].plaintext);
+
+ crypto_digest_init(tfm);
+ crypto_digest_update(tfm, sg, 1);
+ crypto_digest_final(tfm, result);
+
+ hexdump(result, crypto_tfm_alg_digestsize(tfm));
+ printk("%s\n",
+ memcmp(result, sha512_tv[i].digest,
+ crypto_tfm_alg_digestsize(tfm)) ? "fail" :
+ "pass");
+ }
+
+ crypto_free_tfm(tfm);
+}
+
+void
+test_des(void)
+{
+ unsigned int ret, i, len;
+ unsigned int tsize;
+ char *p, *q;
+ struct crypto_tfm *tfm;
+ char *key;
+ char res[8];
+ struct des_tv *des_tv;
+ struct scatterlist sg[8];
+
+ printk("\ntesting des encryption\n");
+
+ tsize = sizeof (des_enc_tv_template);
+ if (tsize > TVMEMSIZE) {
+ printk("template (%u) too big for tvmem (%u)\n", tsize,
+ TVMEMSIZE);
+ return;
+ }
+
+ memcpy(tvmem, des_enc_tv_template, tsize);
+ des_tv = (void *) tvmem;
+
+ tfm = crypto_alloc_tfm("des", 0);
+ if (tfm == NULL) {
+ printk("failed to load transform for des (default ecb)\n");
+ return;
+ }
+
+ for (i = 0; i < DES_ENC_TEST_VECTORS; i++) {
+ printk("test %u:\n", i + 1);
+
+ key = des_tv[i].key;
+ tfm->crt_flags |= CRYPTO_TFM_REQ_WEAK_KEY;
+
+ ret = crypto_cipher_setkey(tfm, key, 8);
+ if (ret) {
+ printk("setkey() failed flags=%x\n", tfm->crt_flags);
+
+ if (!des_tv[i].fail)
+ goto out;
+ }
+
+ len = des_tv[i].len;
+
+ p = des_tv[i].plaintext;
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = len;
+ ret = crypto_cipher_encrypt(tfm, sg, sg, len);
+ if (ret) {
+ printk("encrypt() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ q = kmap(sg[0].page) + sg[0].offset;
+ hexdump(q, len);
+
+ printk("%s\n",
+ memcmp(q, des_tv[i].result, len) ? "fail" : "pass");
+
+ }
+
+ printk("\ntesting des ecb encryption across pages\n");
+
+ i = 5;
+ key = des_tv[i].key;
+ tfm->crt_flags = 0;
+
+ hexdump(key, 8);
+
+ ret = crypto_cipher_setkey(tfm, key, 8);
+ if (ret) {
+ printk("setkey() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ /* setup the dummy buffer first */
+ memset(xbuf, 0, sizeof (xbuf));
+ memcpy(&xbuf[IDX1], des_tv[i].plaintext, 8);
+ memcpy(&xbuf[IDX2], des_tv[i].plaintext + 8, 8);
+
+ p = &xbuf[IDX1];
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = 8;
+
+ p = &xbuf[IDX2];
+ sg[1].page = virt_to_page(p);
+ sg[1].offset = ((long) p & ~PAGE_MASK);
+ sg[1].length = 8;
+
+ ret = crypto_cipher_encrypt(tfm, sg, sg, 16);
+ if (ret) {
+ printk("encrypt() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ printk("page 1\n");
+ q = kmap(sg[0].page) + sg[0].offset;
+ hexdump(q, 8);
+ printk("%s\n", memcmp(q, des_tv[i].result, 8) ? "fail" : "pass");
+
+ printk("page 2\n");
+ q = kmap(sg[1].page) + sg[1].offset;
+ hexdump(q, 8);
+ printk("%s\n", memcmp(q, des_tv[i].result + 8, 8) ? "fail" : "pass");
+
+ printk("\ntesting des ecb encryption chunking scenario A\n");
+
+ /*
+ * Scenario A:
+ *
+ * F1 F2 F3
+ * [8 + 6] [2 + 8] [8]
+ * ^^^^^^ ^
+ * a b c
+ *
+ * Chunking should begin at a, then end with b, and
+ * continue encrypting at an offset of 2 until c.
+ *
+ */
+ i = 7;
+
+ key = des_tv[i].key;
+ tfm->crt_flags = 0;
+
+ ret = crypto_cipher_setkey(tfm, key, 8);
+ if (ret) {
+ printk("setkey() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ /* setup the dummy buffer first */
+ memset(xbuf, 0, sizeof (xbuf));
+
+ /* Frag 1: 8 + 6 */
+ memcpy(&xbuf[IDX3], des_tv[i].plaintext, 14);
+
+ /* Frag 2: 2 + 8 */
+ memcpy(&xbuf[IDX4], des_tv[i].plaintext + 14, 10);
+
+ /* Frag 3: 8 */
+ memcpy(&xbuf[IDX5], des_tv[i].plaintext + 24, 8);
+
+ p = &xbuf[IDX3];
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = 14;
+
+ p = &xbuf[IDX4];
+ sg[1].page = virt_to_page(p);
+ sg[1].offset = ((long) p & ~PAGE_MASK);
+ sg[1].length = 10;
+
+ p = &xbuf[IDX5];
+ sg[2].page = virt_to_page(p);
+ sg[2].offset = ((long) p & ~PAGE_MASK);
+ sg[2].length = 8;
+
+ ret = crypto_cipher_encrypt(tfm, sg, sg, 32);
+
+ if (ret) {
+ printk("decrypt() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ printk("page 1\n");
+ q = kmap(sg[0].page) + sg[0].offset;
+ hexdump(q, 14);
+ printk("%s\n", memcmp(q, des_tv[i].result, 14) ? "fail" : "pass");
+
+ printk("page 2\n");
+ q = kmap(sg[1].page) + sg[1].offset;
+ hexdump(q, 10);
+ printk("%s\n", memcmp(q, des_tv[i].result + 14, 10) ? "fail" : "pass");
+
+ printk("page 3\n");
+ q = kmap(sg[2].page) + sg[2].offset;
+ hexdump(q, 8);
+ printk("%s\n", memcmp(q, des_tv[i].result + 24, 8) ? "fail" : "pass");
+
+ printk("\ntesting des ecb encryption chunking scenario B\n");
+
+ /*
+ * Scenario B:
+ *
+ * F1 F2 F3 F4
+ * [2] [1] [3] [2 + 8 + 8]
+ */
+ i = 7;
+
+ key = des_tv[i].key;
+ tfm->crt_flags = 0;
+
+ ret = crypto_cipher_setkey(tfm, key, 8);
+ if (ret) {
+ printk("setkey() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ /* setup the dummy buffer first */
+ memset(xbuf, 0, sizeof (xbuf));
+
+ /* Frag 1: 2 */
+ memcpy(&xbuf[IDX3], des_tv[i].plaintext, 2);
+
+ /* Frag 2: 1 */
+ memcpy(&xbuf[IDX4], des_tv[i].plaintext + 2, 1);
+
+ /* Frag 3: 3 */
+ memcpy(&xbuf[IDX5], des_tv[i].plaintext + 3, 3);
+
+ /* Frag 4: 2 + 8 + 8 */
+ memcpy(&xbuf[IDX6], des_tv[i].plaintext + 6, 18);
+
+ p = &xbuf[IDX3];
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = 2;
+
+ p = &xbuf[IDX4];
+ sg[1].page = virt_to_page(p);
+ sg[1].offset = ((long) p & ~PAGE_MASK);
+ sg[1].length = 1;
+
+ p = &xbuf[IDX5];
+ sg[2].page = virt_to_page(p);
+ sg[2].offset = ((long) p & ~PAGE_MASK);
+ sg[2].length = 3;
+
+ p = &xbuf[IDX6];
+ sg[3].page = virt_to_page(p);
+ sg[3].offset = ((long) p & ~PAGE_MASK);
+ sg[3].length = 18;
+
+ ret = crypto_cipher_encrypt(tfm, sg, sg, 24);
+
+ if (ret) {
+ printk("encrypt() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ printk("page 1\n");
+ q = kmap(sg[0].page) + sg[0].offset;
+ hexdump(q, 2);
+ printk("%s\n", memcmp(q, des_tv[i].result, 2) ? "fail" : "pass");
+
+ printk("page 2\n");
+ q = kmap(sg[1].page) + sg[1].offset;
+ hexdump(q, 1);
+ printk("%s\n", memcmp(q, des_tv[i].result + 2, 1) ? "fail" : "pass");
+
+ printk("page 3\n");
+ q = kmap(sg[2].page) + sg[2].offset;
+ hexdump(q, 3);
+ printk("%s\n", memcmp(q, des_tv[i].result + 3, 3) ? "fail" : "pass");
+
+ printk("page 4\n");
+ q = kmap(sg[3].page) + sg[3].offset;
+ hexdump(q, 18);
+ printk("%s\n", memcmp(q, des_tv[i].result + 6, 18) ? "fail" : "pass");
+
+ printk("\ntesting des ecb encryption chunking scenario C\n");
+
+ /*
+ * Scenario B:
+ *
+ * F1 F2 F3 F4 F5
+ * [2] [2] [2] [2] [8]
+ */
+ i = 7;
+
+ key = des_tv[i].key;
+ tfm->crt_flags = 0;
+
+ ret = crypto_cipher_setkey(tfm, key, 8);
+ if (ret) {
+ printk("setkey() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ /* setup the dummy buffer first */
+ memset(xbuf, 0, sizeof (xbuf));
+
+ /* Frag 1: 2 */
+ memcpy(&xbuf[IDX3], des_tv[i].plaintext, 2);
+
+ /* Frag 2: 2 */
+ memcpy(&xbuf[IDX4], des_tv[i].plaintext + 2, 2);
+
+ /* Frag 3: 2 */
+ memcpy(&xbuf[IDX5], des_tv[i].plaintext + 4, 2);
+
+ /* Frag 4: 2 */
+ memcpy(&xbuf[IDX6], des_tv[i].plaintext + 6, 2);
+
+ /* Frag 5: 8 */
+ memcpy(&xbuf[IDX7], des_tv[i].plaintext + 8, 8);
+
+ p = &xbuf[IDX3];
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = 2;
+
+ p = &xbuf[IDX4];
+ sg[1].page = virt_to_page(p);
+ sg[1].offset = ((long) p & ~PAGE_MASK);
+ sg[1].length = 2;
+
+ p = &xbuf[IDX5];
+ sg[2].page = virt_to_page(p);
+ sg[2].offset = ((long) p & ~PAGE_MASK);
+ sg[2].length = 2;
+
+ p = &xbuf[IDX6];
+ sg[3].page = virt_to_page(p);
+ sg[3].offset = ((long) p & ~PAGE_MASK);
+ sg[3].length = 2;
+
+ p = &xbuf[IDX7];
+ sg[4].page = virt_to_page(p);
+ sg[4].offset = ((long) p & ~PAGE_MASK);
+ sg[4].length = 8;
+
+ ret = crypto_cipher_encrypt(tfm, sg, sg, 16);
+
+ if (ret) {
+ printk("encrypt() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ printk("page 1\n");
+ q = kmap(sg[0].page) + sg[0].offset;
+ hexdump(q, 2);
+ printk("%s\n", memcmp(q, des_tv[i].result, 2) ? "fail" : "pass");
+
+ printk("page 2\n");
+ q = kmap(sg[1].page) + sg[1].offset;
+ hexdump(q, 2);
+ printk("%s\n", memcmp(q, des_tv[i].result + 2, 2) ? "fail" : "pass");
+
+ printk("page 3\n");
+ q = kmap(sg[2].page) + sg[2].offset;
+ hexdump(q, 2);
+ printk("%s\n", memcmp(q, des_tv[i].result + 4, 2) ? "fail" : "pass");
+
+ printk("page 4\n");
+ q = kmap(sg[3].page) + sg[3].offset;
+ hexdump(q, 2);
+ printk("%s\n", memcmp(q, des_tv[i].result + 6, 2) ? "fail" : "pass");
+
+ printk("page 5\n");
+ q = kmap(sg[4].page) + sg[4].offset;
+ hexdump(q, 8);
+ printk("%s\n", memcmp(q, des_tv[i].result + 8, 8) ? "fail" : "pass");
+
+ printk("\ntesting des ecb encryption chunking scenario D\n");
+
+ /*
+ * Scenario D, torture test, one byte per frag.
+ */
+ i = 7;
+ key = des_tv[i].key;
+ tfm->crt_flags = 0;
+
+ ret = crypto_cipher_setkey(tfm, key, 8);
+ if (ret) {
+ printk("setkey() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ /* setup the dummy buffer first */
+ memset(xbuf, 0, XBUFSIZE);
+
+ xbuf[IDX1] = des_tv[i].plaintext[0];
+ xbuf[IDX2] = des_tv[i].plaintext[1];
+ xbuf[IDX3] = des_tv[i].plaintext[2];
+ xbuf[IDX4] = des_tv[i].plaintext[3];
+ xbuf[IDX5] = des_tv[i].plaintext[4];
+ xbuf[IDX6] = des_tv[i].plaintext[5];
+ xbuf[IDX7] = des_tv[i].plaintext[6];
+ xbuf[IDX8] = des_tv[i].plaintext[7];
+
+ p = &xbuf[IDX1];
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = 1;
+
+ p = &xbuf[IDX2];
+ sg[1].page = virt_to_page(p);
+ sg[1].offset = ((long) p & ~PAGE_MASK);
+ sg[1].length = 1;
+
+ p = &xbuf[IDX3];
+ sg[2].page = virt_to_page(p);
+ sg[2].offset = ((long) p & ~PAGE_MASK);
+ sg[2].length = 1;
+
+ p = &xbuf[IDX4];
+ sg[3].page = virt_to_page(p);
+ sg[3].offset = ((long) p & ~PAGE_MASK);
+ sg[3].length = 1;
+
+ p = &xbuf[IDX5];
+ sg[4].page = virt_to_page(p);
+ sg[4].offset = ((long) p & ~PAGE_MASK);
+ sg[4].length = 1;
+
+ p = &xbuf[IDX6];
+ sg[5].page = virt_to_page(p);
+ sg[5].offset = ((long) p & ~PAGE_MASK);
+ sg[5].length = 1;
+
+ p = &xbuf[IDX7];
+ sg[6].page = virt_to_page(p);
+ sg[6].offset = ((long) p & ~PAGE_MASK);
+ sg[6].length = 1;
+
+ p = &xbuf[IDX8];
+ sg[7].page = virt_to_page(p);
+ sg[7].offset = ((long) p & ~PAGE_MASK);
+ sg[7].length = 1;
+
+ ret = crypto_cipher_encrypt(tfm, sg, sg, 8);
+ if (ret) {
+ printk("encrypt() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ for (i = 0; i < 8; i++)
+ res[i] = *(char *) (kmap(sg[i].page) + sg[i].offset);
+
+ hexdump(res, 8);
+ printk("%s\n", memcmp(res, des_tv[7].result, 8) ? "fail" : "pass");
+
+ printk("\ntesting des decryption\n");
+
+ tsize = sizeof (des_dec_tv_template);
+ if (tsize > TVMEMSIZE) {
+ printk("template (%u) too big for tvmem (%u)\n", tsize,
+ TVMEMSIZE);
+ return;
+ }
+ memcpy(tvmem, des_dec_tv_template, tsize);
+ des_tv = (void *) tvmem;
+
+ for (i = 0; i < DES_DEC_TEST_VECTORS; i++) {
+ printk("test %u:\n", i + 1);
+
+ key = des_tv[i].key;
+
+ tfm->crt_flags = 0;
+ ret = crypto_cipher_setkey(tfm, key, 8);
+ if (ret) {
+ printk("setkey() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ len = des_tv[i].len;
+
+ p = des_tv[i].plaintext;
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = len;
+
+ ret = crypto_cipher_decrypt(tfm, sg, sg, sg[0].length);
+ if (ret) {
+ printk("des_decrypt() failed flags=%x\n",
+ tfm->crt_flags);
+ goto out;
+ }
+
+ q = kmap(sg[0].page) + sg[0].offset;
+ hexdump(q, len);
+
+ printk("%s\n",
+ memcmp(q, des_tv[i].result, len) ? "fail" : "pass");
+
+ }
+
+ printk("\ntesting des ecb decryption across pages\n");
+
+ i = 6;
+
+ key = des_tv[i].key;
+ tfm->crt_flags = 0;
+
+ ret = crypto_cipher_setkey(tfm, key, 8);
+ if (ret) {
+ printk("setkey() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ /* setup the dummy buffer first */
+ memset(xbuf, 0, sizeof (xbuf));
+ memcpy(&xbuf[IDX1], des_tv[i].plaintext, 8);
+ memcpy(&xbuf[IDX2], des_tv[i].plaintext + 8, 8);
+
+ p = &xbuf[IDX1];
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = 8;
+
+ p = &xbuf[IDX2];
+ sg[1].page = virt_to_page(p);
+ sg[1].offset = ((long) p & ~PAGE_MASK);
+ sg[1].length = 8;
+
+ ret = crypto_cipher_decrypt(tfm, sg, sg, 16);
+ if (ret) {
+ printk("decrypt() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ printk("page 1\n");
+ q = kmap(sg[0].page) + sg[0].offset;
+ hexdump(q, 8);
+ printk("%s\n", memcmp(q, des_tv[i].result, 8) ? "fail" : "pass");
+
+ printk("page 2\n");
+ q = kmap(sg[1].page) + sg[1].offset;
+ hexdump(q, 8);
+ printk("%s\n", memcmp(q, des_tv[i].result + 8, 8) ? "fail" : "pass");
+
+ /*
+ * Scenario E:
+ *
+ * F1 F2 F3
+ * [3] [5 + 7] [1]
+ *
+ */
+ printk("\ntesting des ecb decryption chunking scenario E\n");
+ i = 2;
+
+ key = des_tv[i].key;
+ tfm->crt_flags = 0;
+
+ ret = crypto_cipher_setkey(tfm, key, 8);
+ if (ret) {
+ printk("setkey() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ /* setup the dummy buffer first */
+ memset(xbuf, 0, sizeof (xbuf));
+
+ memcpy(&xbuf[IDX1], des_tv[i].plaintext, 3);
+ memcpy(&xbuf[IDX2], des_tv[i].plaintext + 3, 12);
+ memcpy(&xbuf[IDX3], des_tv[i].plaintext + 15, 1);
+
+ p = &xbuf[IDX1];
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = 3;
+
+ p = &xbuf[IDX2];
+ sg[1].page = virt_to_page(p);
+ sg[1].offset = ((long) p & ~PAGE_MASK);
+ sg[1].length = 12;
+
+ p = &xbuf[IDX3];
+ sg[2].page = virt_to_page(p);
+ sg[2].offset = ((long) p & ~PAGE_MASK);
+ sg[2].length = 1;
+
+ ret = crypto_cipher_decrypt(tfm, sg, sg, 16);
+
+ if (ret) {
+ printk("decrypt() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ printk("page 1\n");
+ q = kmap(sg[0].page) + sg[0].offset;
+ hexdump(q, 3);
+ printk("%s\n", memcmp(q, des_tv[i].result, 3) ? "fail" : "pass");
+
+ printk("page 2\n");
+ q = kmap(sg[1].page) + sg[1].offset;
+ hexdump(q, 12);
+ printk("%s\n", memcmp(q, des_tv[i].result + 3, 12) ? "fail" : "pass");
+
+ printk("page 3\n");
+ q = kmap(sg[2].page) + sg[2].offset;
+ hexdump(q, 1);
+ printk("%s\n", memcmp(q, des_tv[i].result + 15, 1) ? "fail" : "pass");
+
+ crypto_free_tfm(tfm);
+
+ tfm = crypto_alloc_tfm("des", CRYPTO_TFM_MODE_CBC);
+ if (tfm == NULL) {
+ printk("failed to load transform for des cbc\n");
+ return;
+ }
+
+ printk("\ntesting des cbc encryption\n");
+
+ tsize = sizeof (des_cbc_enc_tv_template);
+ if (tsize > TVMEMSIZE) {
+ printk("template (%u) too big for tvmem (%u)\n", tsize,
+ TVMEMSIZE);
+ return;
+ }
+ memcpy(tvmem, des_cbc_enc_tv_template, tsize);
+ des_tv = (void *) tvmem;
+
+ crypto_cipher_set_iv(tfm, des_tv[i].iv, crypto_tfm_alg_ivsize(tfm));
+ crypto_cipher_get_iv(tfm, res, crypto_tfm_alg_ivsize(tfm));
+
+ if (memcmp(res, des_tv[i].iv, sizeof(res))) {
+ printk("crypto_cipher_[set|get]_iv() failed\n");
+ goto out;
+ }
+
+ for (i = 0; i < DES_CBC_ENC_TEST_VECTORS; i++) {
+ printk("test %u:\n", i + 1);
+
+ key = des_tv[i].key;
+
+ ret = crypto_cipher_setkey(tfm, key, 8);
+ if (ret) {
+ printk("setkey() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ len = des_tv[i].len;
+ p = des_tv[i].plaintext;
+
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = len;
+
+ crypto_cipher_set_iv(tfm, des_tv[i].iv,
+ crypto_tfm_alg_ivsize(tfm));
+
+ ret = crypto_cipher_encrypt(tfm, sg, sg, len);
+ if (ret) {
+ printk("des_cbc_encrypt() failed flags=%x\n",
+ tfm->crt_flags);
+ goto out;
+ }
+
+ q = kmap(sg[0].page) + sg[0].offset;
+ hexdump(q, len);
+
+ printk("%s\n",
+ memcmp(q, des_tv[i].result, len) ? "fail" : "pass");
+ }
+
+ crypto_free_tfm(tfm);
+
+ /*
+ * Scenario F:
+ *
+ * F1 F2
+ * [8 + 5] [3 + 8]
+ *
+ */
+ printk("\ntesting des cbc encryption chunking scenario F\n");
+ i = 4;
+
+ tfm = crypto_alloc_tfm("des", CRYPTO_TFM_MODE_CBC);
+ if (tfm == NULL) {
+ printk("failed to load transform for CRYPTO_ALG_DES_CCB\n");
+ return;
+ }
+
+ tfm->crt_flags = 0;
+ key = des_tv[i].key;
+
+ ret = crypto_cipher_setkey(tfm, key, 8);
+ if (ret) {
+ printk("setkey() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ /* setup the dummy buffer first */
+ memset(xbuf, 0, sizeof (xbuf));
+
+ memcpy(&xbuf[IDX1], des_tv[i].plaintext, 13);
+ memcpy(&xbuf[IDX2], des_tv[i].plaintext + 13, 11);
+
+ p = &xbuf[IDX1];
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = 13;
+
+ p = &xbuf[IDX2];
+ sg[1].page = virt_to_page(p);
+ sg[1].offset = ((long) p & ~PAGE_MASK);
+ sg[1].length = 11;
+
+ crypto_cipher_set_iv(tfm, des_tv[i].iv, crypto_tfm_alg_ivsize(tfm));
+
+ ret = crypto_cipher_encrypt(tfm, sg, sg, 24);
+ if (ret) {
+ printk("des_cbc_decrypt() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ printk("page 1\n");
+ q = kmap(sg[0].page) + sg[0].offset;
+ hexdump(q, 13);
+ printk("%s\n", memcmp(q, des_tv[i].result, 13) ? "fail" : "pass");
+
+ printk("page 2\n");
+ q = kmap(sg[1].page) + sg[1].offset;
+ hexdump(q, 11);
+ printk("%s\n", memcmp(q, des_tv[i].result + 13, 11) ? "fail" : "pass");
+
+ tsize = sizeof (des_cbc_dec_tv_template);
+ if (tsize > TVMEMSIZE) {
+ printk("template (%u) too big for tvmem (%u)\n", tsize,
+ TVMEMSIZE);
+ return;
+ }
+ memcpy(tvmem, des_cbc_dec_tv_template, tsize);
+ des_tv = (void *) tvmem;
+
+ printk("\ntesting des cbc decryption\n");
+
+ for (i = 0; i < DES_CBC_DEC_TEST_VECTORS; i++) {
+ printk("test %u:\n", i + 1);
+
+ tfm->crt_flags = 0;
+ key = des_tv[i].key;
+
+ ret = crypto_cipher_setkey(tfm, key, 8);
+ if (ret) {
+ printk("setkey() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ len = des_tv[i].len;
+ p = des_tv[i].plaintext;
+
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = len;
+
+ crypto_cipher_set_iv(tfm, des_tv[i].iv,
+ crypto_tfm_alg_blocksize(tfm));
+
+ ret = crypto_cipher_decrypt(tfm, sg, sg, len);
+ if (ret) {
+ printk("des_cbc_decrypt() failed flags=%x\n",
+ tfm->crt_flags);
+ goto out;
+ }
+
+ hexdump(tfm->crt_cipher.cit_iv, 8);
+
+ q = kmap(sg[0].page) + sg[0].offset;
+ hexdump(q, len);
+
+ printk("%s\n",
+ memcmp(q, des_tv[i].result, len) ? "fail" : "pass");
+ }
+
+ /*
+ * Scenario G:
+ *
+ * F1 F2
+ * [4] [4]
+ *
+ */
+ printk("\ntesting des cbc decryption chunking scenario G\n");
+ i = 3;
+
+ tfm->crt_flags = 0;
+ key = des_tv[i].key;
+
+ ret = crypto_cipher_setkey(tfm, key, 8);
+ if (ret) {
+ printk("setkey() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ /* setup the dummy buffer first */
+ memset(xbuf, 0, sizeof (xbuf));
+ memcpy(&xbuf[IDX1], des_tv[i].plaintext, 4);
+ memcpy(&xbuf[IDX2], des_tv[i].plaintext + 4, 4);
+
+ p = &xbuf[IDX1];
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = 4;
+
+ p = &xbuf[IDX2];
+ sg[1].page = virt_to_page(p);
+ sg[1].offset = ((long) p & ~PAGE_MASK);
+ sg[1].length = 4;
+
+ crypto_cipher_set_iv(tfm, des_tv[i].iv, crypto_tfm_alg_ivsize(tfm));
+
+ ret = crypto_cipher_decrypt(tfm, sg, sg, 8);
+ if (ret) {
+ printk("des_cbc_decrypt() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ printk("page 1\n");
+ q = kmap(sg[0].page) + sg[0].offset;
+ hexdump(q, 4);
+ printk("%s\n", memcmp(q, des_tv[i].result, 4) ? "fail" : "pass");
+
+ printk("page 2\n");
+ q = kmap(sg[1].page) + sg[1].offset;
+ hexdump(q, 4);
+ printk("%s\n", memcmp(q, des_tv[i].result + 4, 4) ? "fail" : "pass");
+
+ out:
+ crypto_free_tfm(tfm);
+}
+
+void
+test_des3_ede(void)
+{
+ unsigned int ret, i, len;
+ unsigned int tsize;
+ char *p, *q;
+ struct crypto_tfm *tfm;
+ char *key;
+ /*char res[8]; */
+ struct des_tv *des_tv;
+ struct scatterlist sg[8];
+
+ printk("\ntesting des3 ede encryption\n");
+
+ tsize = sizeof (des3_ede_enc_tv_template);
+ if (tsize > TVMEMSIZE) {
+ printk("template (%u) too big for tvmem (%u)\n", tsize,
+ TVMEMSIZE);
+ return;
+ }
+
+ memcpy(tvmem, des3_ede_enc_tv_template, tsize);
+ des_tv = (void *) tvmem;
+
+ tfm = crypto_alloc_tfm("des3_ede", CRYPTO_TFM_MODE_ECB);
+ if (tfm == NULL) {
+ printk("failed to load transform for 3des ecb\n");
+ return;
+ }
+
+ for (i = 0; i < DES3_EDE_ENC_TEST_VECTORS; i++) {
+ printk("test %u:\n", i + 1);
+
+ key = des_tv[i].key;
+ ret = crypto_cipher_setkey(tfm, key, 24);
+ if (ret) {
+ printk("setkey() failed flags=%x\n", tfm->crt_flags);
+
+ if (!des_tv[i].fail)
+ goto out;
+ }
+
+ len = des_tv[i].len;
+
+ p = des_tv[i].plaintext;
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = len;
+ ret = crypto_cipher_encrypt(tfm, sg, sg, len);
+ if (ret) {
+ printk("encrypt() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ q = kmap(sg[0].page) + sg[0].offset;
+ hexdump(q, len);
+
+ printk("%s\n",
+ memcmp(q, des_tv[i].result, len) ? "fail" : "pass");
+ }
+
+ printk("\ntesting des3 ede decryption\n");
+
+ tsize = sizeof (des3_ede_dec_tv_template);
+ if (tsize > TVMEMSIZE) {
+ printk("template (%u) too big for tvmem (%u)\n", tsize,
+ TVMEMSIZE);
+ return;
+ }
+
+ memcpy(tvmem, des3_ede_dec_tv_template, tsize);
+ des_tv = (void *) tvmem;
+
+ for (i = 0; i < DES3_EDE_DEC_TEST_VECTORS; i++) {
+ printk("test %u:\n", i + 1);
+
+ key = des_tv[i].key;
+ ret = crypto_cipher_setkey(tfm, key, 24);
+ if (ret) {
+ printk("setkey() failed flags=%x\n", tfm->crt_flags);
+
+ if (!des_tv[i].fail)
+ goto out;
+ }
+
+ len = des_tv[i].len;
+
+ p = des_tv[i].plaintext;
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = len;
+ ret = crypto_cipher_decrypt(tfm, sg, sg, len);
+ if (ret) {
+ printk("decrypt() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ q = kmap(sg[0].page) + sg[0].offset;
+ hexdump(q, len);
+
+ printk("%s\n",
+ memcmp(q, des_tv[i].result, len) ? "fail" : "pass");
+ }
+
+ out:
+ crypto_free_tfm(tfm);
+}
+
+void
+test_blowfish(void)
+{
+ unsigned int ret, i;
+ unsigned int tsize;
+ char *p, *q;
+ struct crypto_tfm *tfm;
+ char *key;
+ struct bf_tv *bf_tv;
+ struct scatterlist sg[1];
+
+ printk("\ntesting blowfish encryption\n");
+
+ tsize = sizeof (bf_enc_tv_template);
+ if (tsize > TVMEMSIZE) {
+ printk("template (%u) too big for tvmem (%u)\n", tsize,
+ TVMEMSIZE);
+ return;
+ }
+
+ memcpy(tvmem, bf_enc_tv_template, tsize);
+ bf_tv = (void *) tvmem;
+
+ tfm = crypto_alloc_tfm("blowfish", 0);
+ if (tfm == NULL) {
+ printk("failed to load transform for blowfish (default ecb)\n");
+ return;
+ }
+
+ for (i = 0; i < BF_ENC_TEST_VECTORS; i++) {
+ printk("test %u (%d bit key):\n",
+ i + 1, bf_tv[i].keylen * 8);
+ key = bf_tv[i].key;
+
+ ret = crypto_cipher_setkey(tfm, key, bf_tv[i].keylen);
+ if (ret) {
+ printk("setkey() failed flags=%x\n", tfm->crt_flags);
+
+ if (!bf_tv[i].fail)
+ goto out;
+ }
+
+ p = bf_tv[i].plaintext;
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = bf_tv[i].plen;
+ ret = crypto_cipher_encrypt(tfm, sg, sg, sg[0].length);
+ if (ret) {
+ printk("encrypt() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ q = kmap(sg[0].page) + sg[0].offset;
+ hexdump(q, bf_tv[i].rlen);
+
+ printk("%s\n", memcmp(q, bf_tv[i].result, bf_tv[i].rlen) ?
+ "fail" : "pass");
+ }
+
+ printk("\ntesting blowfish decryption\n");
+
+ tsize = sizeof (bf_dec_tv_template);
+ if (tsize > TVMEMSIZE) {
+ printk("template (%u) too big for tvmem (%u)\n", tsize,
+ TVMEMSIZE);
+ return;
+ }
+
+ memcpy(tvmem, bf_dec_tv_template, tsize);
+ bf_tv = (void *) tvmem;
+
+ for (i = 0; i < BF_DEC_TEST_VECTORS; i++) {
+ printk("test %u (%d bit key):\n",
+ i + 1, bf_tv[i].keylen * 8);
+ key = bf_tv[i].key;
+
+ ret = crypto_cipher_setkey(tfm, key, bf_tv[i].keylen);
+ if (ret) {
+ printk("setkey() failed flags=%x\n", tfm->crt_flags);
+
+ if (!bf_tv[i].fail)
+ goto out;
+ }
+
+ p = bf_tv[i].plaintext;
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = bf_tv[i].plen;
+ ret = crypto_cipher_decrypt(tfm, sg, sg, sg[0].length);
+ if (ret) {
+ printk("decrypt() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ q = kmap(sg[0].page) + sg[0].offset;
+ hexdump(q, bf_tv[i].rlen);
+
+ printk("%s\n", memcmp(q, bf_tv[i].result, bf_tv[i].rlen) ?
+ "fail" : "pass");
+ }
+
+ crypto_free_tfm(tfm);
+
+ tfm = crypto_alloc_tfm("blowfish", CRYPTO_TFM_MODE_CBC);
+ if (tfm == NULL) {
+ printk("failed to load transform for blowfish cbc\n");
+ return;
+ }
+
+ printk("\ntesting blowfish cbc encryption\n");
+
+ tsize = sizeof (bf_cbc_enc_tv_template);
+ if (tsize > TVMEMSIZE) {
+ printk("template (%u) too big for tvmem (%u)\n", tsize,
+ TVMEMSIZE);
+ goto out;
+ }
+ memcpy(tvmem, bf_cbc_enc_tv_template, tsize);
+ bf_tv = (void *) tvmem;
+
+ for (i = 0; i < BF_CBC_ENC_TEST_VECTORS; i++) {
+ printk("test %u (%d bit key):\n",
+ i + 1, bf_tv[i].keylen * 8);
+
+ key = bf_tv[i].key;
+
+ ret = crypto_cipher_setkey(tfm, key, bf_tv[i].keylen);
+ if (ret) {
+ printk("setkey() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ p = bf_tv[i].plaintext;
+
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = bf_tv[i].plen;
+
+ crypto_cipher_set_iv(tfm, bf_tv[i].iv,
+ crypto_tfm_alg_ivsize(tfm));
+
+ ret = crypto_cipher_encrypt(tfm, sg, sg, sg[0].length);
+ if (ret) {
+ printk("blowfish_cbc_encrypt() failed flags=%x\n",
+ tfm->crt_flags);
+ goto out;
+ }
+
+ q = kmap(sg[0].page) + sg[0].offset;
+ hexdump(q, bf_tv[i].rlen);
+
+ printk("%s\n", memcmp(q, bf_tv[i].result, bf_tv[i].rlen)
+ ? "fail" : "pass");
+ }
+
+ printk("\ntesting blowfish cbc decryption\n");
+
+ tsize = sizeof (bf_cbc_dec_tv_template);
+ if (tsize > TVMEMSIZE) {
+ printk("template (%u) too big for tvmem (%u)\n", tsize,
+ TVMEMSIZE);
+ goto out;
+ }
+ memcpy(tvmem, bf_cbc_dec_tv_template, tsize);
+ bf_tv = (void *) tvmem;
+
+ for (i = 0; i < BF_CBC_ENC_TEST_VECTORS; i++) {
+ printk("test %u (%d bit key):\n",
+ i + 1, bf_tv[i].keylen * 8);
+ key = bf_tv[i].key;
+
+ ret = crypto_cipher_setkey(tfm, key, bf_tv[i].keylen);
+ if (ret) {
+ printk("setkey() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ p = bf_tv[i].plaintext;
+
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = bf_tv[i].plen;
+
+ crypto_cipher_set_iv(tfm, bf_tv[i].iv,
+ crypto_tfm_alg_ivsize(tfm));
+
+ ret = crypto_cipher_decrypt(tfm, sg, sg, sg[0].length);
+ if (ret) {
+ printk("blowfish_cbc_decrypt() failed flags=%x\n",
+ tfm->crt_flags);
+ goto out;
+ }
+
+ q = kmap(sg[0].page) + sg[0].offset;
+ hexdump(q, bf_tv[i].rlen);
+
+ printk("%s\n", memcmp(q, bf_tv[i].result, bf_tv[i].rlen)
+ ? "fail" : "pass");
+ }
+
+out:
+ crypto_free_tfm(tfm);
+}
+
+
+void
+test_twofish(void)
+{
+ unsigned int ret, i;
+ unsigned int tsize;
+ char *p, *q;
+ struct crypto_tfm *tfm;
+ char *key;
+ struct tf_tv *tf_tv;
+ struct scatterlist sg[1];
+
+ printk("\ntesting twofish encryption\n");
+
+ tsize = sizeof (tf_enc_tv_template);
+ if (tsize > TVMEMSIZE) {
+ printk("template (%u) too big for tvmem (%u)\n", tsize,
+ TVMEMSIZE);
+ return;
+ }
+
+ memcpy(tvmem, tf_enc_tv_template, tsize);
+ tf_tv = (void *) tvmem;
+
+ tfm = crypto_alloc_tfm("twofish", 0);
+ if (tfm == NULL) {
+ printk("failed to load transform for blowfish (default ecb)\n");
+ return;
+ }
+
+ for (i = 0; i < TF_ENC_TEST_VECTORS; i++) {
+ printk("test %u (%d bit key):\n",
+ i + 1, tf_tv[i].keylen * 8);
+ key = tf_tv[i].key;
+
+ ret = crypto_cipher_setkey(tfm, key, tf_tv[i].keylen);
+ if (ret) {
+ printk("setkey() failed flags=%x\n", tfm->crt_flags);
+
+ if (!tf_tv[i].fail)
+ goto out;
+ }
+
+ p = tf_tv[i].plaintext;
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = tf_tv[i].plen;
+ ret = crypto_cipher_encrypt(tfm, sg, sg, sg[0].length);
+ if (ret) {
+ printk("encrypt() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ q = kmap(sg[0].page) + sg[0].offset;
+ hexdump(q, tf_tv[i].rlen);
+
+ printk("%s\n", memcmp(q, tf_tv[i].result, tf_tv[i].rlen) ?
+ "fail" : "pass");
+ }
+
+ printk("\ntesting twofish decryption\n");
+
+ tsize = sizeof (tf_dec_tv_template);
+ if (tsize > TVMEMSIZE) {
+ printk("template (%u) too big for tvmem (%u)\n", tsize,
+ TVMEMSIZE);
+ return;
+ }
+
+ memcpy(tvmem, tf_dec_tv_template, tsize);
+ tf_tv = (void *) tvmem;
+
+ for (i = 0; i < TF_DEC_TEST_VECTORS; i++) {
+ printk("test %u (%d bit key):\n",
+ i + 1, tf_tv[i].keylen * 8);
+ key = tf_tv[i].key;
+
+ ret = crypto_cipher_setkey(tfm, key, tf_tv[i].keylen);
+ if (ret) {
+ printk("setkey() failed flags=%x\n", tfm->crt_flags);
+
+ if (!tf_tv[i].fail)
+ goto out;
+ }
+
+ p = tf_tv[i].plaintext;
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = tf_tv[i].plen;
+ ret = crypto_cipher_decrypt(tfm, sg, sg, sg[0].length);
+ if (ret) {
+ printk("decrypt() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ q = kmap(sg[0].page) + sg[0].offset;
+ hexdump(q, tf_tv[i].rlen);
+
+ printk("%s\n", memcmp(q, tf_tv[i].result, tf_tv[i].rlen) ?
+ "fail" : "pass");
+ }
+
+ crypto_free_tfm(tfm);
+
+ tfm = crypto_alloc_tfm("twofish", CRYPTO_TFM_MODE_CBC);
+ if (tfm == NULL) {
+ printk("failed to load transform for twofish cbc\n");
+ return;
+ }
+
+ printk("\ntesting twofish cbc encryption\n");
+
+ tsize = sizeof (tf_cbc_enc_tv_template);
+ if (tsize > TVMEMSIZE) {
+ printk("template (%u) too big for tvmem (%u)\n", tsize,
+ TVMEMSIZE);
+ goto out;
+ }
+ memcpy(tvmem, tf_cbc_enc_tv_template, tsize);
+ tf_tv = (void *) tvmem;
+
+ for (i = 0; i < TF_CBC_ENC_TEST_VECTORS; i++) {
+ printk("test %u (%d bit key):\n",
+ i + 1, tf_tv[i].keylen * 8);
+
+ key = tf_tv[i].key;
+
+ ret = crypto_cipher_setkey(tfm, key, tf_tv[i].keylen);
+ if (ret) {
+ printk("setkey() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ p = tf_tv[i].plaintext;
+
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = tf_tv[i].plen;
+
+ crypto_cipher_set_iv(tfm, tf_tv[i].iv,
+ crypto_tfm_alg_ivsize(tfm));
+
+ ret = crypto_cipher_encrypt(tfm, sg, sg, sg[0].length);
+ if (ret) {
+ printk("blowfish_cbc_encrypt() failed flags=%x\n",
+ tfm->crt_flags);
+ goto out;
+ }
+
+ q = kmap(sg[0].page) + sg[0].offset;
+ hexdump(q, tf_tv[i].rlen);
+
+ printk("%s\n", memcmp(q, tf_tv[i].result, tf_tv[i].rlen)
+ ? "fail" : "pass");
+ }
+
+ printk("\ntesting twofish cbc decryption\n");
+
+ tsize = sizeof (tf_cbc_dec_tv_template);
+ if (tsize > TVMEMSIZE) {
+ printk("template (%u) too big for tvmem (%u)\n", tsize,
+ TVMEMSIZE);
+ goto out;
+ }
+ memcpy(tvmem, tf_cbc_dec_tv_template, tsize);
+ tf_tv = (void *) tvmem;
+
+ for (i = 0; i < TF_CBC_DEC_TEST_VECTORS; i++) {
+ printk("test %u (%d bit key):\n",
+ i + 1, tf_tv[i].keylen * 8);
+
+ key = tf_tv[i].key;
+
+ ret = crypto_cipher_setkey(tfm, key, tf_tv[i].keylen);
+ if (ret) {
+ printk("setkey() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ p = tf_tv[i].plaintext;
+
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = tf_tv[i].plen;
+
+ crypto_cipher_set_iv(tfm, tf_tv[i].iv,
+ crypto_tfm_alg_ivsize(tfm));
+
+ ret = crypto_cipher_decrypt(tfm, sg, sg, sg[0].length);
+ if (ret) {
+ printk("blowfish_cbc_decrypt() failed flags=%x\n",
+ tfm->crt_flags);
+ goto out;
+ }
+
+ q = kmap(sg[0].page) + sg[0].offset;
+ hexdump(q, tf_tv[i].rlen);
+
+ printk("%s\n", memcmp(q, tf_tv[i].result, tf_tv[i].rlen)
+ ? "fail" : "pass");
+ }
+
+out:
+ crypto_free_tfm(tfm);
+}
+
+void
+test_serpent(void)
+{
+ unsigned int ret, i, tsize;
+ u8 *p, *q, *key;
+ struct crypto_tfm *tfm;
+ struct serpent_tv *serp_tv;
+ struct scatterlist sg[1];
+
+ printk("\ntesting serpent encryption\n");
+
+ tfm = crypto_alloc_tfm("serpent", 0);
+ if (tfm == NULL) {
+ printk("failed to load transform for serpent (default ecb)\n");
+ return;
+ }
+
+ tsize = sizeof (serpent_enc_tv_template);
+ if (tsize > TVMEMSIZE) {
+ printk("template (%u) too big for tvmem (%u)\n", tsize,
+ TVMEMSIZE);
+ return;
+ }
+
+ memcpy(tvmem, serpent_enc_tv_template, tsize);
+ serp_tv = (void *) tvmem;
+ for (i = 0; i < SERPENT_ENC_TEST_VECTORS; i++) {
+ printk("test %u (%d bit key):\n", i + 1, serp_tv[i].keylen * 8);
+ key = serp_tv[i].key;
+
+ ret = crypto_cipher_setkey(tfm, key, serp_tv[i].keylen);
+ if (ret) {
+ printk("setkey() failed flags=%x\n", tfm->crt_flags);
+
+ if (!serp_tv[i].fail)
+ goto out;
+ }
+
+ p = serp_tv[i].plaintext;
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = sizeof(serp_tv[i].plaintext);
+ ret = crypto_cipher_encrypt(tfm, sg, sg, sg[0].length);
+ if (ret) {
+ printk("encrypt() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ q = kmap(sg[0].page) + sg[0].offset;
+ hexdump(q, sizeof(serp_tv[i].result));
+
+ printk("%s\n", memcmp(q, serp_tv[i].result,
+ sizeof(serp_tv[i].result)) ? "fail" : "pass");
+ }
+
+ printk("\ntesting serpent decryption\n");
+
+ tsize = sizeof (serpent_dec_tv_template);
+ if (tsize > TVMEMSIZE) {
+ printk("template (%u) too big for tvmem (%u)\n", tsize,
+ TVMEMSIZE);
+ return;
+ }
+
+ memcpy(tvmem, serpent_dec_tv_template, tsize);
+ serp_tv = (void *) tvmem;
+ for (i = 0; i < SERPENT_DEC_TEST_VECTORS; i++) {
+ printk("test %u (%d bit key):\n", i + 1, serp_tv[i].keylen * 8);
+ key = serp_tv[i].key;
+
+ ret = crypto_cipher_setkey(tfm, key, serp_tv[i].keylen);
+ if (ret) {
+ printk("setkey() failed flags=%x\n", tfm->crt_flags);
+
+ if (!serp_tv[i].fail)
+ goto out;
+ }
+
+ p = serp_tv[i].plaintext;
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = sizeof(serp_tv[i].plaintext);
+ ret = crypto_cipher_decrypt(tfm, sg, sg, sg[0].length);
+ if (ret) {
+ printk("decrypt() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ q = kmap(sg[0].page) + sg[0].offset;
+ hexdump(q, sizeof(serp_tv[i].result));
+
+ printk("%s\n", memcmp(q, serp_tv[i].result,
+ sizeof(serp_tv[i].result)) ? "fail" : "pass");
+ }
+
+out:
+ crypto_free_tfm(tfm);
+}
+
+void
+test_aes(void)
+{
+ unsigned int ret, i;
+ unsigned int tsize;
+ char *p, *q;
+ struct crypto_tfm *tfm;
+ char *key;
+ struct aes_tv *aes_tv;
+ struct scatterlist sg[1];
+
+ printk("\ntesting aes encryption\n");
+
+ tsize = sizeof (aes_enc_tv_template);
+ if (tsize > TVMEMSIZE) {
+ printk("template (%u) too big for tvmem (%u)\n", tsize,
+ TVMEMSIZE);
+ return;
+ }
+
+ memcpy(tvmem, aes_enc_tv_template, tsize);
+ aes_tv = (void *) tvmem;
+
+ tfm = crypto_alloc_tfm("aes", 0);
+ if (tfm == NULL) {
+ printk("failed to load transform for aes (default ecb)\n");
+ return;
+ }
+
+ for (i = 0; i < AES_ENC_TEST_VECTORS; i++) {
+ printk("test %u (%d bit key):\n",
+ i + 1, aes_tv[i].keylen * 8);
+ key = aes_tv[i].key;
+
+ ret = crypto_cipher_setkey(tfm, key, aes_tv[i].keylen);
+ if (ret) {
+ printk("setkey() failed flags=%x\n", tfm->crt_flags);
+
+ if (!aes_tv[i].fail)
+ goto out;
+ }
+
+ p = aes_tv[i].plaintext;
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = aes_tv[i].plen;
+ ret = crypto_cipher_encrypt(tfm, sg, sg, sg[0].length);
+ if (ret) {
+ printk("encrypt() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ q = kmap(sg[0].page) + sg[0].offset;
+ hexdump(q, aes_tv[i].rlen);
+
+ printk("%s\n", memcmp(q, aes_tv[i].result, aes_tv[i].rlen) ?
+ "fail" : "pass");
+ }
+
+ printk("\ntesting aes decryption\n");
+
+ tsize = sizeof (aes_dec_tv_template);
+ if (tsize > TVMEMSIZE) {
+ printk("template (%u) too big for tvmem (%u)\n", tsize,
+ TVMEMSIZE);
+ return;
+ }
+
+ memcpy(tvmem, aes_dec_tv_template, tsize);
+ aes_tv = (void *) tvmem;
+
+ for (i = 0; i < AES_DEC_TEST_VECTORS; i++) {
+ printk("test %u (%d bit key):\n",
+ i + 1, aes_tv[i].keylen * 8);
+ key = aes_tv[i].key;
+
+ ret = crypto_cipher_setkey(tfm, key, aes_tv[i].keylen);
+ if (ret) {
+ printk("setkey() failed flags=%x\n", tfm->crt_flags);
+
+ if (!aes_tv[i].fail)
+ goto out;
+ }
+
+ p = aes_tv[i].plaintext;
+ sg[0].page = virt_to_page(p);
+ sg[0].offset = ((long) p & ~PAGE_MASK);
+ sg[0].length = aes_tv[i].plen;
+ ret = crypto_cipher_decrypt(tfm, sg, sg, sg[0].length);
+ if (ret) {
+ printk("decrypt() failed flags=%x\n", tfm->crt_flags);
+ goto out;
+ }
+
+ q = kmap(sg[0].page) + sg[0].offset;
+ hexdump(q, aes_tv[i].rlen);
+
+ printk("%s\n", memcmp(q, aes_tv[i].result, aes_tv[i].rlen) ?
+ "fail" : "pass");
+ }
+
+out:
+ crypto_free_tfm(tfm);
+}
+
+static void
+test_deflate(void)
+{
+ unsigned int i;
+ char result[COMP_BUF_SIZE];
+ struct crypto_tfm *tfm;
+ struct comp_testvec *tv;
+ unsigned int tsize;
+
+ printk("\ntesting deflate compression\n");
+
+ tsize = sizeof (deflate_comp_tv_template);
+ if (tsize > TVMEMSIZE) {
+ printk("template (%u) too big for tvmem (%u)\n", tsize,
+ TVMEMSIZE);
+ return;
+ }
+
+ memcpy(tvmem, deflate_comp_tv_template, tsize);
+ tv = (void *) tvmem;
+
+ tfm = crypto_alloc_tfm("deflate", 0);
+ if (tfm == NULL) {
+ printk("failed to load transform for deflate\n");
+ return;
+ }
+
+ for (i = 0; i < DEFLATE_COMP_TEST_VECTORS; i++) {
+ int ilen, ret, dlen = COMP_BUF_SIZE;
+
+ printk("test %u:\n", i + 1);
+ memset(result, 0, sizeof (result));
+
+ ilen = tv[i].inlen;
+ ret = crypto_comp_compress(tfm, tv[i].input,
+ ilen, result, &dlen);
+ if (ret) {
+ printk("fail: ret=%d\n", ret);
+ continue;
+ }
+ hexdump(result, dlen);
+ printk("%s (ratio %d:%d)\n",
+ memcmp(result, tv[i].output, dlen) ? "fail" : "pass",
+ ilen, dlen);
+ }
+
+ printk("\ntesting deflate decompression\n");
+
+ tsize = sizeof (deflate_decomp_tv_template);
+ if (tsize > TVMEMSIZE) {
+ printk("template (%u) too big for tvmem (%u)\n", tsize,
+ TVMEMSIZE);
+ goto out;
+ }
+
+ memcpy(tvmem, deflate_decomp_tv_template, tsize);
+ tv = (void *) tvmem;
+
+ for (i = 0; i < DEFLATE_DECOMP_TEST_VECTORS; i++) {
+ int ilen, ret, dlen = COMP_BUF_SIZE;
+
+ printk("test %u:\n", i + 1);
+ memset(result, 0, sizeof (result));
+
+ ilen = tv[i].inlen;
+ ret = crypto_comp_decompress(tfm, tv[i].input,
+ ilen, result, &dlen);
+ if (ret) {
+ printk("fail: ret=%d\n", ret);
+ continue;
+ }
+ hexdump(result, dlen);
+ printk("%s (ratio %d:%d)\n",
+ memcmp(result, tv[i].output, dlen) ? "fail" : "pass",
+ ilen, dlen);
+ }
+out:
+ crypto_free_tfm(tfm);
+}
+
+static void
+test_available(void)
+{
+ char **name = check;
+
+ while (*name) {
+ printk("alg %s ", *name);
+ printk((crypto_alg_available(*name, 0)) ?
+ "found\n" : "not found\n");
+ name++;
+ }
+}
+
+static void
+do_test(void)
+{
+ switch (mode) {
+
+ case 0:
+ test_md5();
+ test_sha1();
+ test_des();
+ test_des3_ede();
+ test_md4();
+ test_sha256();
+ test_blowfish();
+ test_twofish();
+ test_serpent();
+ test_aes();
+ test_sha384();
+ test_sha512();
+ test_deflate();
+#ifdef CONFIG_CRYPTO_HMAC
+ test_hmac_md5();
+ test_hmac_sha1();
+ test_hmac_sha256();
+#endif
+ break;
+
+ case 1:
+ test_md5();
+ break;
+
+ case 2:
+ test_sha1();
+ break;
+
+ case 3:
+ test_des();
+ break;
+
+ case 4:
+ test_des3_ede();
+ break;
+
+ case 5:
+ test_md4();
+ break;
+
+ case 6:
+ test_sha256();
+ break;
+
+ case 7:
+ test_blowfish();
+ break;
+
+ case 8:
+ test_twofish();
+ break;
+
+ case 9:
+ test_serpent();
+ break;
+
+ case 10:
+ test_aes();
+ break;
+
+ case 11:
+ test_sha384();
+ break;
+
+ case 12:
+ test_sha512();
+ break;
+
+ case 13:
+ test_deflate();
+ break;
+
+#ifdef CONFIG_CRYPTO_HMAC
+ case 100:
+ test_hmac_md5();
+ break;
+
+ case 101:
+ test_hmac_sha1();
+ break;
+
+ case 102:
+ test_hmac_sha256();
+ break;
+
+#endif
+
+ case 1000:
+ test_available();
+ break;
+
+ default:
+ /* useful for debugging */
+ printk("not testing anything\n");
+ break;
+ }
+}
+
+static int __init
+init(void)
+{
+ tvmem = kmalloc(TVMEMSIZE, GFP_KERNEL);
+ if (tvmem == NULL)
+ return -ENOMEM;
+
+ xbuf = kmalloc(XBUFSIZE, GFP_KERNEL);
+ if (xbuf == NULL) {
+ kfree(tvmem);
+ return -ENOMEM;
+ }
+
+ do_test();
+
+ kfree(xbuf);
+ kfree(tvmem);
+ return 0;
+}
+
+module_init(init);
+
+MODULE_PARM(mode, "i");
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Quick & dirty crypto testing module");
+MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");
FUNET's LINUX-ADM group, linux-adm@nic.funet.fi
TCL-scripts by Sam Shen (who was at: slshen@lbl.gov)