[CRYPTO]: White space and coding style clean up in tcrypt

Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/crypto/tcrypt.c b/crypto/tcrypt.c
index 92b0352c8e92f6cadc8d1db3e8ab56d34663b50c..5a95b4a14c2bdba0e01fb491688cd5e9be74db6d 100644 (file)
--- a/crypto/tcrypt.c
+++ b/crypto/tcrypt.c
@@ -1,4 +1,4 @@
-/* 
+/*
  * Quick & dirty crypto testing module.
  *
  * This will only exist until we have a better testing mechanism
@@ -9,7 +9,7 @@
  *
  * 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) 
+ * Software Foundation; either version 2 of the License, or (at your option)
  * any later version.
  *
  * 14 - 09 - 2003 
@@ -61,13 +61,12 @@ static char *tvmem;
 
 static char *check[] = {
        "des", "md5", "des3_ede", "rot13", "sha1", "sha256", "blowfish",
-       "twofish", "serpent", "sha384", "sha512", "md4", "aes", "cast6", 
-       "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea", 
+       "twofish", "serpent", "sha384", "sha512", "md4", "aes", "cast6",
+       "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
        "khazad", "wp512", "wp384", "wp256", "tnepres", NULL
 };
 
-static void
-hexdump(unsigned char *buf, unsigned int len)
+static void hexdump(unsigned char *buf, unsigned int len)
 {
        while (len--)
                printk("%02x", *buf++);
@@ -75,29 +74,29 @@ hexdump(unsigned char *buf, unsigned int len)
        printk("\n");
 }
 
-static void 
-test_hash (char * algo, struct hash_testvec * template, unsigned int tcount)
+static void test_hash(char *algo, struct hash_testvec *template,
+                     unsigned int tcount)
 {
-       char *p; 
-        unsigned int i, j, k, temp;
-        struct scatterlist sg[8];
-        char result[64];
-        struct crypto_tfm *tfm;
-        struct hash_testvec *hash_tv;
-        unsigned int tsize;
-        
-        printk("\ntesting %s\n", algo);
-
-       tsize = sizeof (struct hash_testvec);
+       char *p;
+       unsigned int i, j, k, temp;
+       struct scatterlist sg[8];
+       char result[64];
+       struct crypto_tfm *tfm;
+       struct hash_testvec *hash_tv;
+       unsigned int tsize;
+
+       printk("\ntesting %s\n", algo);
+
+       tsize = sizeof(struct hash_testvec);
        tsize *= tcount;
-       
+
        if (tsize > TVMEMSIZE) {
                printk("template (%u) too big for tvmem (%u)\n", tsize, TVMEMSIZE);
                return;
        }
 
        memcpy(tvmem, template, tsize);
-       hash_tv = (void *) tvmem;
+       hash_tv = (void *)tvmem;
        tfm = crypto_alloc_tfm(algo, 0);
        if (tfm == NULL) {
                printk("failed to load transform for %s\n", algo);
@@ -105,70 +104,71 @@ test_hash (char * algo, struct hash_testvec * template, unsigned int tcount)
        }
 
        for (i = 0; i < tcount; i++) {
-               printk ("test %u:\n", i + 1);
-               memset (result, 0, 64);
+               printk("test %u:\n", i + 1);
+               memset(result, 0, 64);
 
                p = hash_tv[i].plaintext;
-               sg[0].page = virt_to_page (p);
-               sg[0].offset = offset_in_page (p);
+               sg[0].page = virt_to_page(p);
+               sg[0].offset = offset_in_page(p);
                sg[0].length = hash_tv[i].psize;
 
-               crypto_digest_init (tfm);
+               crypto_digest_init(tfm);
                if (tfm->crt_u.digest.dit_setkey) {
-                       crypto_digest_setkey (tfm, hash_tv[i].key,
-                                             hash_tv[i].ksize);
+                       crypto_digest_setkey(tfm, hash_tv[i].key,
+                                            hash_tv[i].ksize);
                }
-               crypto_digest_update (tfm, sg, 1);
-               crypto_digest_final (tfm, result);
+               crypto_digest_update(tfm, sg, 1);
+               crypto_digest_final(tfm, result);
 
-               hexdump (result, crypto_tfm_alg_digestsize (tfm));
+               hexdump(result, crypto_tfm_alg_digestsize(tfm));
                printk("%s\n",
-                       memcmp(result, hash_tv[i].digest,
-                               crypto_tfm_alg_digestsize(tfm)) ? "fail" :
-                       "pass");
+                      memcmp(result, hash_tv[i].digest,
+                             crypto_tfm_alg_digestsize(tfm)) ?
+                      "fail" : "pass");
        }
 
-       printk ("testing %s across pages\n", algo);
+       printk("testing %s across pages\n", algo);
 
        /* setup the dummy buffer first */
-        memset(xbuf, 0, XBUFSIZE);
+       memset(xbuf, 0, XBUFSIZE);
 
        j = 0;
        for (i = 0; i < tcount; i++) {
                if (hash_tv[i].np) {
                        j++;
-                       printk ("test %u:\n", j);
-                       memset (result, 0, 64);
+                       printk("test %u:\n", j);
+                       memset(result, 0, 64);
 
                        temp = 0;
                        for (k = 0; k < hash_tv[i].np; k++) {
-                               memcpy (&xbuf[IDX[k]], hash_tv[i].plaintext + temp, 
-                                               hash_tv[i].tap[k]);     
+                               memcpy(&xbuf[IDX[k]],
+                                      hash_tv[i].plaintext + temp,
+                                      hash_tv[i].tap[k]);
                                temp += hash_tv[i].tap[k];
                                p = &xbuf[IDX[k]];
-                               sg[k].page = virt_to_page (p);
-                               sg[k].offset = offset_in_page (p);
+                               sg[k].page = virt_to_page(p);
+                               sg[k].offset = offset_in_page(p);
                                sg[k].length = hash_tv[i].tap[k];
                        }
 
-                       crypto_digest_digest (tfm, sg, hash_tv[i].np, result);
-                       
-                       hexdump (result, crypto_tfm_alg_digestsize (tfm));
+                       crypto_digest_digest(tfm, sg, hash_tv[i].np, result);
+
+                       hexdump(result, crypto_tfm_alg_digestsize(tfm));
                        printk("%s\n",
-                               memcmp(result, hash_tv[i].digest,
-                                       crypto_tfm_alg_digestsize(tfm)) ? "fail" :
-                               "pass");
+                              memcmp(result, hash_tv[i].digest,
+                                     crypto_tfm_alg_digestsize(tfm)) ?
+                              "fail" : "pass");
                }
        }
-       
-       crypto_free_tfm (tfm);
+
+       crypto_free_tfm(tfm);
 }
 
 
 #ifdef CONFIG_CRYPTO_HMAC
 
-static void
-test_hmac(char *algo, struct hmac_testvec * template, unsigned int tcount)
+static void test_hmac(char *algo, struct hmac_testvec *template,
+                     unsigned int tcount)
 {
        char *p;
        unsigned int i, j, k, temp;
@@ -185,8 +185,8 @@ test_hmac(char *algo, struct hmac_testvec * template, unsigned int tcount)
        }
 
        printk("\ntesting hmac_%s\n", algo);
-       
-       tsize = sizeof (struct hmac_testvec);
+
+       tsize = sizeof(struct hmac_testvec);
        tsize *= tcount;
        if (tsize > TVMEMSIZE) {
                printk("template (%u) too big for tvmem (%u)\n", tsize,
@@ -195,7 +195,7 @@ test_hmac(char *algo, struct hmac_testvec * template, unsigned int tcount)
        }
 
        memcpy(tvmem, template, tsize);
-       hmac_tv = (void *) tvmem;
+       hmac_tv = (void *)tvmem;
 
        for (i = 0; i < tcount; i++) {
                printk("test %u:\n", i + 1);
@@ -219,34 +219,35 @@ test_hmac(char *algo, struct hmac_testvec * template, unsigned int tcount)
        printk("\ntesting hmac_%s across pages\n", algo);
 
        memset(xbuf, 0, XBUFSIZE);
-       
+
        j = 0;
        for (i = 0; i < tcount; i++) {
                if (hmac_tv[i].np) {
                        j++;
-                       printk ("test %u:\n",j);
-                       memset (result, 0, 64);
+                       printk("test %u:\n",j);
+                       memset(result, 0, 64);
 
                        temp = 0;
                        klen = hmac_tv[i].ksize;
                        for (k = 0; k < hmac_tv[i].np; k++) {
-                               memcpy (&xbuf[IDX[k]], hmac_tv[i].plaintext + temp, 
-                                               hmac_tv[i].tap[k]);     
+                               memcpy(&xbuf[IDX[k]],
+                                      hmac_tv[i].plaintext + temp,
+                                      hmac_tv[i].tap[k]);
                                temp += hmac_tv[i].tap[k];
                                p = &xbuf[IDX[k]];
-                               sg[k].page = virt_to_page (p);
-                               sg[k].offset = offset_in_page (p);
+                               sg[k].page = virt_to_page(p);
+                               sg[k].offset = offset_in_page(p);
                                sg[k].length = hmac_tv[i].tap[k];
                        }
 
-                       crypto_hmac(tfm, hmac_tv[i].key, &klen, sg, hmac_tv[i].np, 
-                                       result);
+                       crypto_hmac(tfm, hmac_tv[i].key, &klen, sg,
+                                   hmac_tv[i].np, result);
                        hexdump(result, crypto_tfm_alg_digestsize(tfm));
-                       
+
                        printk("%s\n",
-                               memcmp(result, hmac_tv[i].digest,
-                                       crypto_tfm_alg_digestsize(tfm)) ? "fail" : 
-                               "pass");
+                              memcmp(result, hmac_tv[i].digest,
+                                     crypto_tfm_alg_digestsize(tfm)) ?
+                              "fail" : "pass");
                }
        }
 out:
@@ -255,8 +256,8 @@ out:
 
 #endif /* CONFIG_CRYPTO_HMAC */
 
-static void
-test_cipher(char * algo, int mode, int enc, struct cipher_testvec * template, unsigned int tcount)
+static void test_cipher(char *algo, int mode, int enc,
+                       struct cipher_testvec *template, unsigned int tcount)
 {
        unsigned int ret, i, j, k, temp;
        unsigned int tsize;
@@ -270,17 +271,17 @@ test_cipher(char * algo, int mode, int enc, struct cipher_testvec * template, un
        if (enc == ENCRYPT)
                strncpy(e, "encryption", 11);
        else
-               strncpy(e, "decryption", 11);
+               strncpy(e, "decryption", 11);
        if (mode == MODE_ECB)
-               strncpy(m, "ECB", 4);
+               strncpy(m, "ECB", 4);
        else
-               strncpy(m, "CBC", 4);
+               strncpy(m, "CBC", 4);
 
-       printk("\ntesting %s %s %s \n", algo, m, e);
+       printk("\ntesting %s %s %s\n", algo, m, e);
 
-       tsize = sizeof (struct cipher_testvec); 
+       tsize = sizeof (struct cipher_testvec);
        tsize *= tcount;
-       
+
        if (tsize > TVMEMSIZE) {
                printk("template (%u) too big for tvmem (%u)\n", tsize,
                       TVMEMSIZE);
@@ -288,112 +289,113 @@ test_cipher(char * algo, int mode, int enc, struct cipher_testvec * template, un
        }
 
        memcpy(tvmem, template, tsize);
-       cipher_tv = (void *) tvmem;
+       cipher_tv = (void *)tvmem;
+
+       if (mode)
+               tfm = crypto_alloc_tfm(algo, 0);
+       else
+               tfm = crypto_alloc_tfm(algo, CRYPTO_TFM_MODE_CBC);
 
-       if (mode) 
-               tfm = crypto_alloc_tfm (algo, 0);
-       else 
-               tfm = crypto_alloc_tfm (algo, CRYPTO_TFM_MODE_CBC);
-       
        if (tfm == NULL) {
                printk("failed to load transform for %s %s\n", algo, m);
                return;
        }
-       
+
        j = 0;
        for (i = 0; i < tcount; i++) {
                if (!(cipher_tv[i].np)) {
-                       j++;    
+                       j++;
                        printk("test %u (%d bit key):\n",
                        j, cipher_tv[i].klen * 8);
 
                        tfm->crt_flags = 0;
-                       if (cipher_tv[i].wk) 
+                       if (cipher_tv[i].wk)
                                tfm->crt_flags |= CRYPTO_TFM_REQ_WEAK_KEY;
                        key = cipher_tv[i].key;
-       
+
                        ret = crypto_cipher_setkey(tfm, key, cipher_tv[i].klen);
                        if (ret) {
                                printk("setkey() failed flags=%x\n", tfm->crt_flags);
-       
+
                                if (!cipher_tv[i].fail)
                                        goto out;
-                       }       
+                       }
 
                        p = cipher_tv[i].input;
                        sg[0].page = virt_to_page(p);
                        sg[0].offset = offset_in_page(p);
                        sg[0].length = cipher_tv[i].ilen;
-       
+
                        if (!mode) {
                                crypto_cipher_set_iv(tfm, cipher_tv[i].iv,
-                                       crypto_tfm_alg_ivsize (tfm));
+                                       crypto_tfm_alg_ivsize(tfm));
                        }
-               
+
                        if (enc)
                                ret = crypto_cipher_encrypt(tfm, sg, sg, cipher_tv[i].ilen);
                        else
                                ret = crypto_cipher_decrypt(tfm, sg, sg, cipher_tv[i].ilen);
-                       
-                               
+
+
                        if (ret) {
                                printk("%s () failed flags=%x\n", e, tfm->crt_flags);
                                goto out;
-                       }       
-       
+                       }
+
                        q = kmap(sg[0].page) + sg[0].offset;
                        hexdump(q, cipher_tv[i].rlen);
-       
-                       printk("%s\n", 
-                               memcmp(q, cipher_tv[i].result, cipher_tv[i].rlen) ? "fail" : 
-                       "pass");
+
+                       printk("%s\n",
+                              memcmp(q, cipher_tv[i].result,
+                                     cipher_tv[i].rlen) ? "fail" : "pass");
                }
        }
-       
-       printk("\ntesting %s %s %s across pages (chunking) \n", algo, m, e);
+
+       printk("\ntesting %s %s %s across pages (chunking)\n", algo, m, e);
        memset(xbuf, 0, XBUFSIZE);
-       
+
        j = 0;
        for (i = 0; i < tcount; i++) {
                if (cipher_tv[i].np) {
-                       j++;                            
+                       j++;
                        printk("test %u (%d bit key):\n",
                        j, cipher_tv[i].klen * 8);
 
-                       tfm->crt_flags = 0;                     
-                       if (cipher_tv[i].wk) 
+                       tfm->crt_flags = 0;
+                       if (cipher_tv[i].wk)
                                tfm->crt_flags |= CRYPTO_TFM_REQ_WEAK_KEY;
                        key = cipher_tv[i].key;
-                       
-                       ret = crypto_cipher_setkey(tfm, key, cipher_tv[i].klen);                
+
+                       ret = crypto_cipher_setkey(tfm, key, cipher_tv[i].klen);
                        if (ret) {
                                printk("setkey() failed flags=%x\n", tfm->crt_flags);
-                               
+
                                if (!cipher_tv[i].fail)
                                        goto out;
                        }
 
                        temp = 0;
                        for (k = 0; k < cipher_tv[i].np; k++) {
-                               memcpy (&xbuf[IDX[k]], cipher_tv[i].input + temp, 
-                                               cipher_tv[i].tap[k]);   
+                               memcpy(&xbuf[IDX[k]],
+                                      cipher_tv[i].input + temp,
+                                      cipher_tv[i].tap[k]);
                                temp += cipher_tv[i].tap[k];
                                p = &xbuf[IDX[k]];
-                               sg[k].page = virt_to_page (p);
-                               sg[k].offset = offset_in_page (p);
+                               sg[k].page = virt_to_page(p);
+                               sg[k].offset = offset_in_page(p);
                                sg[k].length = cipher_tv[i].tap[k];
                        }
-                       
+
                        if (!mode) {
                                crypto_cipher_set_iv(tfm, cipher_tv[i].iv,
-                                               crypto_tfm_alg_ivsize (tfm));
+                                               crypto_tfm_alg_ivsize(tfm));
                        }
-                       
+
                        if (enc)
                                ret = crypto_cipher_encrypt(tfm, sg, sg, cipher_tv[i].ilen);
                        else
                                ret = crypto_cipher_decrypt(tfm, sg, sg, cipher_tv[i].ilen);
-                       
+
                        if (ret) {
                                printk("%s () failed flags=%x\n", e, tfm->crt_flags);
                                goto out;
@@ -404,9 +406,9 @@ test_cipher(char * algo, int mode, int enc, struct cipher_testvec * template, un
                                printk("page %u\n", k);
                                q = kmap(sg[k].page) + sg[k].offset;
                                hexdump(q, cipher_tv[i].tap[k]);
-                               printk("%s\n", 
-                                       memcmp(q, cipher_tv[i].result + temp, 
-                                               cipher_tv[i].tap[k]) ? "fail" : 
+                               printk("%s\n",
+                                       memcmp(q, cipher_tv[i].result + temp,
+                                               cipher_tv[i].tap[k]) ? "fail" :
                                        "pass");
                                temp += cipher_tv[i].tap[k];
                        }
@@ -417,8 +419,7 @@ out:
        crypto_free_tfm(tfm);
 }
 
-static void
-test_deflate(void)
+static void test_deflate(void)
 {
        unsigned int i;
        char result[COMP_BUF_SIZE];
@@ -436,7 +437,7 @@ test_deflate(void)
        }
 
        memcpy(tvmem, deflate_comp_tv_template, tsize);
-       tv = (void *) tvmem;
+       tv = (void *)tvmem;
 
        tfm = crypto_alloc_tfm("deflate", 0);
        if (tfm == NULL) {
@@ -446,7 +447,7 @@ test_deflate(void)
 
        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));
 
@@ -473,11 +474,11 @@ test_deflate(void)
        }
 
        memcpy(tvmem, deflate_decomp_tv_template, tsize);
-       tv = (void *) tvmem;
+       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));
 
@@ -497,8 +498,7 @@ out:
        crypto_free_tfm(tfm);
 }
 
-static void
-test_crc32c(void)
+static void test_crc32c(void)
 {
 #define NUMVEC 6
 #define VECSIZE 40
@@ -511,7 +511,7 @@ test_crc32c(void)
                0xd579c862, 0xba979ad0, 0x2b29d913
        };
        static u32 tot_vec_results = 0x24c5d375;
-       
+
        struct scatterlist sg[NUMVEC];
        struct crypto_tfm *tfm;
        char *fmtdata = "testing crc32c initialized to %08x: %s\n";
@@ -525,18 +525,18 @@ test_crc32c(void)
                printk("failed to load transform for crc32c\n");
                return;
        }
-       
+
        crypto_digest_init(tfm);
        crypto_digest_final(tfm, (u8*)&crc);
        printk(fmtdata, crc, (crc == 0) ? "pass" : "ERROR");
-       
+
        /*
         * stuff test_vec with known values, simple incrementing
         * byte values.
         */
        b = 0;
        for (i = 0; i < NUMVEC; i++) {
-               for (j = 0; j < VECSIZE; j++) 
+               for (j = 0; j < VECSIZE; j++)
                        test_vec[i][j] = ++b;
                sg[i].page = virt_to_page(test_vec[i]);
                sg[i].offset = offset_in_page(test_vec[i]);
@@ -548,11 +548,11 @@ test_crc32c(void)
        crypto_digest_final(tfm, (u8*)&crc);
        printk("testing crc32c setkey returns %08x : %s\n", crc, (crc == (SEEDTESTVAL ^ ~(u32)0)) ?
               "pass" : "ERROR");
-       
+
        printk("testing crc32c using update/final:\n");
 
        pass = 1;                   /* assume all is well */
-       
+
        for (i = 0; i < NUMVEC; i++) {
                seed = ~(u32)0;
                (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32));
@@ -591,66 +591,64 @@ test_crc32c(void)
                printk(" %08x:BAD, wanted %08x\n", crc, tot_vec_results);
                pass = 0;
        }
-       
+
        printk("\n%s\n", pass ? "pass" : "ERROR");
 
        crypto_free_tfm(tfm);
        printk("crc32c test complete\n");
 }
 
-static void
-test_available(void)
+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)
+static void do_test(void)
 {
        switch (mode) {
 
        case 0:
                test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
-               
+
                test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
-               
+
                //DES
                test_cipher ("des", MODE_ECB, ENCRYPT, des_enc_tv_template, DES_ENC_TEST_VECTORS);
-                test_cipher ("des", MODE_ECB, DECRYPT, des_dec_tv_template, DES_DEC_TEST_VECTORS);
-                test_cipher ("des", MODE_CBC, ENCRYPT, des_cbc_enc_tv_template, DES_CBC_ENC_TEST_VECTORS);
-                test_cipher ("des", MODE_CBC, DECRYPT, des_cbc_dec_tv_template, DES_CBC_DEC_TEST_VECTORS);
-       
+               test_cipher ("des", MODE_ECB, DECRYPT, des_dec_tv_template, DES_DEC_TEST_VECTORS);
+               test_cipher ("des", MODE_CBC, ENCRYPT, des_cbc_enc_tv_template, DES_CBC_ENC_TEST_VECTORS);
+               test_cipher ("des", MODE_CBC, DECRYPT, des_cbc_dec_tv_template, DES_CBC_DEC_TEST_VECTORS);
+
                //DES3_EDE
                test_cipher ("des3_ede", MODE_ECB, ENCRYPT, des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS);
-                test_cipher ("des3_ede", MODE_ECB, DECRYPT, des3_ede_dec_tv_template, DES3_EDE_DEC_TEST_VECTORS);
-               
+               test_cipher ("des3_ede", MODE_ECB, DECRYPT, des3_ede_dec_tv_template, DES3_EDE_DEC_TEST_VECTORS);
+
                test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
-               
+
                test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
-               
+
                //BLOWFISH
                test_cipher ("blowfish", MODE_ECB, ENCRYPT, bf_enc_tv_template, BF_ENC_TEST_VECTORS);
                test_cipher ("blowfish", MODE_ECB, DECRYPT, bf_dec_tv_template, BF_DEC_TEST_VECTORS);
                test_cipher ("blowfish", MODE_CBC, ENCRYPT, bf_cbc_enc_tv_template, BF_CBC_ENC_TEST_VECTORS);
                test_cipher ("blowfish", MODE_CBC, DECRYPT, bf_cbc_dec_tv_template, BF_CBC_DEC_TEST_VECTORS);
-               
+
                //TWOFISH
                test_cipher ("twofish", MODE_ECB, ENCRYPT, tf_enc_tv_template, TF_ENC_TEST_VECTORS);
                test_cipher ("twofish", MODE_ECB, DECRYPT, tf_dec_tv_template, TF_DEC_TEST_VECTORS);
                test_cipher ("twofish", MODE_CBC, ENCRYPT, tf_cbc_enc_tv_template, TF_CBC_ENC_TEST_VECTORS);
                test_cipher ("twofish", MODE_CBC, DECRYPT, tf_cbc_dec_tv_template, TF_CBC_DEC_TEST_VECTORS);
-               
+
                //SERPENT
                test_cipher ("serpent", MODE_ECB, ENCRYPT, serpent_enc_tv_template, SERPENT_ENC_TEST_VECTORS);
                test_cipher ("serpent", MODE_ECB, DECRYPT, serpent_dec_tv_template, SERPENT_DEC_TEST_VECTORS);
-               
+
                //TNEPRES
                test_cipher ("tnepres", MODE_ECB, ENCRYPT, tnepres_enc_tv_template, TNEPRES_ENC_TEST_VECTORS);
                test_cipher ("tnepres", MODE_ECB, DECRYPT, tnepres_dec_tv_template, TNEPRES_DEC_TEST_VECTORS);
@@ -662,7 +660,7 @@ do_test(void)
                //CAST5
                test_cipher ("cast5", MODE_ECB, ENCRYPT, cast5_enc_tv_template, CAST5_ENC_TEST_VECTORS);
                test_cipher ("cast5", MODE_ECB, DECRYPT, cast5_dec_tv_template, CAST5_DEC_TEST_VECTORS);
-               
+
                //CAST6
                test_cipher ("cast6", MODE_ECB, ENCRYPT, cast6_enc_tv_template, CAST6_ENC_TEST_VECTORS);
                test_cipher ("cast6", MODE_ECB, DECRYPT, cast6_dec_tv_template, CAST6_DEC_TEST_VECTORS);
@@ -702,9 +700,9 @@ do_test(void)
                test_crc32c();
 #ifdef CONFIG_CRYPTO_HMAC
                test_hmac("md5", hmac_md5_tv_template, HMAC_MD5_TEST_VECTORS);
-               test_hmac("sha1", hmac_sha1_tv_template, HMAC_SHA1_TEST_VECTORS);               
+               test_hmac("sha1", hmac_sha1_tv_template, HMAC_SHA1_TEST_VECTORS);
                test_hmac("sha256", hmac_sha256_tv_template, HMAC_SHA256_TEST_VECTORS);
-#endif         
+#endif
 
                test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
                break;
@@ -726,17 +724,17 @@ do_test(void)
 
        case 4:
                test_cipher ("des3_ede", MODE_ECB, ENCRYPT, des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS);
-                test_cipher ("des3_ede", MODE_ECB, DECRYPT, des3_ede_dec_tv_template, DES3_EDE_DEC_TEST_VECTORS);
+               test_cipher ("des3_ede", MODE_ECB, DECRYPT, des3_ede_dec_tv_template, DES3_EDE_DEC_TEST_VECTORS);
                break;
 
        case 5:
                test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
                break;
-               
+
        case 6:
                test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
                break;
-       
+
        case 7:
                test_cipher ("blowfish", MODE_ECB, ENCRYPT, bf_enc_tv_template, BF_ENC_TEST_VECTORS);
                test_cipher ("blowfish", MODE_ECB, DECRYPT, bf_dec_tv_template, BF_DEC_TEST_VECTORS);
@@ -750,7 +748,7 @@ do_test(void)
                test_cipher ("twofish", MODE_CBC, ENCRYPT, tf_cbc_enc_tv_template, TF_CBC_ENC_TEST_VECTORS);
                test_cipher ("twofish", MODE_CBC, DECRYPT, tf_cbc_dec_tv_template, TF_CBC_DEC_TEST_VECTORS);
                break;
-               
+
        case 9:
                test_cipher ("serpent", MODE_ECB, ENCRYPT, serpent_enc_tv_template, SERPENT_ENC_TEST_VECTORS);
                test_cipher ("serpent", MODE_ECB, DECRYPT, serpent_dec_tv_template, SERPENT_DEC_TEST_VECTORS);
@@ -758,13 +756,13 @@ do_test(void)
 
        case 10:
                test_cipher ("aes", MODE_ECB, ENCRYPT, aes_enc_tv_template, AES_ENC_TEST_VECTORS);
-               test_cipher ("aes", MODE_ECB, DECRYPT, aes_dec_tv_template, AES_DEC_TEST_VECTORS);      
+               test_cipher ("aes", MODE_ECB, DECRYPT, aes_dec_tv_template, AES_DEC_TEST_VECTORS);
                break;
 
        case 11:
                test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
                break;
-               
+
        case 12:
                test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
                break;
@@ -852,11 +850,11 @@ do_test(void)
        case 100:
                test_hmac("md5", hmac_md5_tv_template, HMAC_MD5_TEST_VECTORS);
                break;
-               
+
        case 101:
-               test_hmac("sha1", hmac_sha1_tv_template, HMAC_SHA1_TEST_VECTORS);               
+               test_hmac("sha1", hmac_sha1_tv_template, HMAC_SHA1_TEST_VECTORS);
                break;
-       
+
        case 102:
                test_hmac("sha256", hmac_sha256_tv_template, HMAC_SHA256_TEST_VECTORS);
                break;
@@ -866,7 +864,7 @@ do_test(void)
        case 1000:
                test_available();
                break;
-               
+
        default:
                /* useful for debugging */
                printk("not testing anything\n");
@@ -874,8 +872,7 @@ do_test(void)
        }
 }
 
-static int __init
-init(void)
+static int __init init(void)
 {
        tvmem = kmalloc(TVMEMSIZE, GFP_KERNEL);
        if (tvmem == NULL)

diff --git a/crypto/tcrypt.h b/crypto/tcrypt.h
index a3097afae5932b052cd92803fe3687b29e5d4ab8..72d40704042f5097460afdecd9807fd75de88041 100644 (file)
--- a/crypto/tcrypt.h
+++ b/crypto/tcrypt.h
@@ -9,7 +9,7 @@
  *
  * 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) 
+ * Software Foundation; either version 2 of the License, or (at your option)
  * any later version.
  *
  * 14 - 09 - 2003 Changes by Kartikey Mahendra Bhatt
@@ -29,19 +29,19 @@ struct hash_testvec {
        unsigned char psize;
        char digest[MAX_DIGEST_SIZE];
        unsigned char np;
-       unsigned char tap[MAX_TAP];             
+       unsigned char tap[MAX_TAP];
        char key[128]; /* only used with keyed hash algorithms */
        unsigned char ksize;
 };
 
-struct hmac_testvec {  
+struct hmac_testvec {
        char key[128];
        unsigned char ksize;
        char plaintext[128];
        unsigned char psize;
        char digest[MAX_DIGEST_SIZE];
        unsigned char np;
-       unsigned char tap[MAX_TAP];             
+       unsigned char tap[MAX_TAP];
 };
 
 struct cipher_testvec {
@@ -55,7 +55,7 @@ struct cipher_testvec {
        char result[48];
        unsigned char rlen;
        int np;
-       unsigned char tap[MAX_TAP];     
+       unsigned char tap[MAX_TAP];
 };
 
 /*
@@ -155,7 +155,7 @@ static struct hash_testvec md5_tv_template[] = {
 #define SHA1_TEST_VECTORS      2
 
 static struct hash_testvec sha1_tv_template[] = {
-       { 
+       {
                .plaintext = "abc",
                .psize  = 3,
                .digest = { 0xa9, 0x99, 0x3e, 0x36, 0x47, 0x06, 0x81, 0x6a, 0xba, 0x3e,
@@ -175,8 +175,8 @@ static struct hash_testvec sha1_tv_template[] = {
  */
 #define SHA256_TEST_VECTORS    2
 
-static struct hash_testvec sha256_tv_template[] = {    
-       { 
+static struct hash_testvec sha256_tv_template[] = {
+       {
                .plaintext = "abc",
                .psize  = 3,
                .digest = { 0xba, 0x78, 0x16, 0xbf, 0x8f, 0x01, 0xcf, 0xea,
@@ -201,7 +201,7 @@ static struct hash_testvec sha256_tv_template[] = {
 #define SHA384_TEST_VECTORS    4
 
 static struct hash_testvec sha384_tv_template[] = {
-       { 
+       {
                .plaintext= "abc",
                .psize  = 3,
                .digest = { 0xcb, 0x00, 0x75, 0x3f, 0x45, 0xa3, 0x5e, 0x8b,
@@ -221,7 +221,7 @@ static struct hash_testvec sha384_tv_template[] = {
                            0x5f, 0xe9, 0x5b, 0x1f, 0xe3, 0xc8, 0x45, 0x2b},
        }, {
                .plaintext = "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn"
-                            "hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu",
+                            "hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu",
                .psize  = 112,
                .digest = { 0x09, 0x33, 0x0c, 0x33, 0xf7, 0x11, 0x47, 0xe8,
                            0x3d, 0x19, 0x2f, 0xc7, 0x82, 0xcd, 0x1b, 0x47,
@@ -250,7 +250,7 @@ static struct hash_testvec sha384_tv_template[] = {
 #define SHA512_TEST_VECTORS    4
 
 static struct hash_testvec sha512_tv_template[] = {
-       { 
+       {
                .plaintext = "abc",
                .psize  = 3,
                .digest = { 0xdd, 0xaf, 0x35, 0xa1, 0x93, 0x61, 0x7a, 0xba,
@@ -303,14 +303,14 @@ static struct hash_testvec sha512_tv_template[] = {
 
 
 /*
- * WHIRLPOOL test vectors from Whirlpool package 
+ * WHIRLPOOL test vectors from Whirlpool package
  * by Vincent Rijmen and Paulo S. L. M. Barreto as part of the NESSIE
  * submission
  */
 #define WP512_TEST_VECTORS     8
 
 static struct hash_testvec wp512_tv_template[] = {
-       { 
+       {
                .plaintext = "",
                .psize  = 0,
                .digest = { 0x19, 0xFA, 0x61, 0xD7, 0x55, 0x22, 0xA4, 0x66,
@@ -348,13 +348,13 @@ static struct hash_testvec wp512_tv_template[] = {
        }, {
                .plaintext = "message digest",
                .psize  = 14,
-               .digest = { 0x37, 0x8C, 0x84, 0xA4, 0x12, 0x6E, 0x2D, 0xC6, 
-                           0xE5, 0x6D, 0xCC, 0x74, 0x58, 0x37, 0x7A, 0xAC, 
-                           0x83, 0x8D, 0x00, 0x03, 0x22, 0x30, 0xF5, 0x3C, 
-                           0xE1, 0xF5, 0x70, 0x0C, 0x0F, 0xFB, 0x4D, 0x3B, 
-                           0x84, 0x21, 0x55, 0x76, 0x59, 0xEF, 0x55, 0xC1, 
-                           0x06, 0xB4, 0xB5, 0x2A, 0xC5, 0xA4, 0xAA, 0xA6, 
-                           0x92, 0xED, 0x92, 0x00, 0x52, 0x83, 0x8F, 0x33, 
+               .digest = { 0x37, 0x8C, 0x84, 0xA4, 0x12, 0x6E, 0x2D, 0xC6,
+                           0xE5, 0x6D, 0xCC, 0x74, 0x58, 0x37, 0x7A, 0xAC,
+                           0x83, 0x8D, 0x00, 0x03, 0x22, 0x30, 0xF5, 0x3C,
+                           0xE1, 0xF5, 0x70, 0x0C, 0x0F, 0xFB, 0x4D, 0x3B,
+                           0x84, 0x21, 0x55, 0x76, 0x59, 0xEF, 0x55, 0xC1,
+                           0x06, 0xB4, 0xB5, 0x2A, 0xC5, 0xA4, 0xAA, 0xA6,
+                           0x92, 0xED, 0x92, 0x00, 0x52, 0x83, 0x8F, 0x33,
                            0x62, 0xE8, 0x6D, 0xBD, 0x37, 0xA8, 0x90, 0x3E },
        }, {
                .plaintext = "abcdefghijklmnopqrstuvwxyz",
@@ -394,7 +394,7 @@ static struct hash_testvec wp512_tv_template[] = {
        }, {
                .plaintext = "abcdbcdecdefdefgefghfghighijhijk",
                .psize  = 32,
-               .digest = { 0x2A, 0x98, 0x7E, 0xA4, 0x0F, 0x91, 0x70, 0x61, 
+               .digest = { 0x2A, 0x98, 0x7E, 0xA4, 0x0F, 0x91, 0x70, 0x61,
                            0xF5, 0xD6, 0xF0, 0xA0, 0xE4, 0x64, 0x4F, 0x48,
                            0x8A, 0x7A, 0x5A, 0x52, 0xDE, 0xEE, 0x65, 0x62,
                            0x07, 0xC5, 0x62, 0xF9, 0x88, 0xE9, 0x5C, 0x69,
@@ -408,7 +408,7 @@ static struct hash_testvec wp512_tv_template[] = {
 #define WP384_TEST_VECTORS     8
 
 static struct hash_testvec wp384_tv_template[] = {
-       { 
+       {
                .plaintext = "",
                .psize  = 0,
                .digest = { 0x19, 0xFA, 0x61, 0xD7, 0x55, 0x22, 0xA4, 0x66,
@@ -440,11 +440,11 @@ static struct hash_testvec wp384_tv_template[] = {
        }, {
                .plaintext = "message digest",
                .psize  = 14,
-               .digest = { 0x37, 0x8C, 0x84, 0xA4, 0x12, 0x6E, 0x2D, 0xC6, 
-                           0xE5, 0x6D, 0xCC, 0x74, 0x58, 0x37, 0x7A, 0xAC, 
-                           0x83, 0x8D, 0x00, 0x03, 0x22, 0x30, 0xF5, 0x3C, 
-                           0xE1, 0xF5, 0x70, 0x0C, 0x0F, 0xFB, 0x4D, 0x3B, 
-                           0x84, 0x21, 0x55, 0x76, 0x59, 0xEF, 0x55, 0xC1, 
+               .digest = { 0x37, 0x8C, 0x84, 0xA4, 0x12, 0x6E, 0x2D, 0xC6,
+                           0xE5, 0x6D, 0xCC, 0x74, 0x58, 0x37, 0x7A, 0xAC,
+                           0x83, 0x8D, 0x00, 0x03, 0x22, 0x30, 0xF5, 0x3C,
+                           0xE1, 0xF5, 0x70, 0x0C, 0x0F, 0xFB, 0x4D, 0x3B,
+                           0x84, 0x21, 0x55, 0x76, 0x59, 0xEF, 0x55, 0xC1,
                            0x06, 0xB4, 0xB5, 0x2A, 0xC5, 0xA4, 0xAA, 0xA6 },
        }, {
                .plaintext = "abcdefghijklmnopqrstuvwxyz",
@@ -478,7 +478,7 @@ static struct hash_testvec wp384_tv_template[] = {
        }, {
                .plaintext = "abcdbcdecdefdefgefghfghighijhijk",
                .psize  = 32,
-               .digest = { 0x2A, 0x98, 0x7E, 0xA4, 0x0F, 0x91, 0x70, 0x61, 
+               .digest = { 0x2A, 0x98, 0x7E, 0xA4, 0x0F, 0x91, 0x70, 0x61,
                            0xF5, 0xD6, 0xF0, 0xA0, 0xE4, 0x64, 0x4F, 0x48,
                            0x8A, 0x7A, 0x5A, 0x52, 0xDE, 0xEE, 0x65, 0x62,
                            0x07, 0xC5, 0x62, 0xF9, 0x88, 0xE9, 0x5C, 0x69,
@@ -490,7 +490,7 @@ static struct hash_testvec wp384_tv_template[] = {
 #define WP256_TEST_VECTORS     8
 
 static struct hash_testvec wp256_tv_template[] = {
-       { 
+       {
                .plaintext = "",
                .psize  = 0,
                .digest = { 0x19, 0xFA, 0x61, 0xD7, 0x55, 0x22, 0xA4, 0x66,
@@ -516,9 +516,9 @@ static struct hash_testvec wp256_tv_template[] = {
        }, {
                .plaintext = "message digest",
                .psize  = 14,
-               .digest = { 0x37, 0x8C, 0x84, 0xA4, 0x12, 0x6E, 0x2D, 0xC6, 
-                           0xE5, 0x6D, 0xCC, 0x74, 0x58, 0x37, 0x7A, 0xAC, 
-                           0x83, 0x8D, 0x00, 0x03, 0x22, 0x30, 0xF5, 0x3C, 
+               .digest = { 0x37, 0x8C, 0x84, 0xA4, 0x12, 0x6E, 0x2D, 0xC6,
+                           0xE5, 0x6D, 0xCC, 0x74, 0x58, 0x37, 0x7A, 0xAC,
+                           0x83, 0x8D, 0x00, 0x03, 0x22, 0x30, 0xF5, 0x3C,
                            0xE1, 0xF5, 0x70, 0x0C, 0x0F, 0xFB, 0x4D, 0x3B },
        }, {
                .plaintext = "abcdefghijklmnopqrstuvwxyz",
@@ -546,7 +546,7 @@ static struct hash_testvec wp256_tv_template[] = {
        }, {
                .plaintext = "abcdbcdecdefdefgefghfghighijhijk",
                .psize  = 32,
-               .digest = { 0x2A, 0x98, 0x7E, 0xA4, 0x0F, 0x91, 0x70, 0x61, 
+               .digest = { 0x2A, 0x98, 0x7E, 0xA4, 0x0F, 0x91, 0x70, 0x61,
                            0xF5, 0xD6, 0xF0, 0xA0, 0xE4, 0x64, 0x4F, 0x48,
                            0x8A, 0x7A, 0x5A, 0x52, 0xDE, 0xEE, 0x65, 0x62,
                            0x07, 0xC5, 0x62, 0xF9, 0x88, 0xE9, 0x5C, 0x69 },
@@ -554,7 +554,7 @@ static struct hash_testvec wp256_tv_template[] = {
 };
 
 /*
- * TIGER test vectors from Tiger website 
+ * TIGER test vectors from Tiger website
  */
 #define TGR192_TEST_VECTORS    6
 
@@ -693,7 +693,7 @@ static struct hash_testvec tgr128_tv_template[] = {
 #define HMAC_MD5_TEST_VECTORS  7
 
 static struct hmac_testvec hmac_md5_tv_template[] =
-{      
+{
        {
                .key    = { [0 ... 15] =  0x0b },
                .ksize  = 16,
@@ -756,7 +756,7 @@ static struct hmac_testvec hmac_md5_tv_template[] =
  */
 #define HMAC_SHA1_TEST_VECTORS 7
 
-static struct hmac_testvec hmac_sha1_tv_template[] = { 
+static struct hmac_testvec hmac_sha1_tv_template[] = {
        {
                .key    = { [0 ... 19] = 0x0b },
                .ksize  = 20,
@@ -766,11 +766,11 @@ static struct hmac_testvec hmac_sha1_tv_template[] = {
                            0xe2, 0x8b, 0xc0, 0xb6, 0xfb, 0x37, 0x8c, 0x8e, 0xf1,
                            0x46, 0xbe },
        }, {
-               .key    = { 'J', 'e', 'f', 'e' },               
+               .key    = { 'J', 'e', 'f', 'e' },
                .ksize  = 4,
                .plaintext = "what do ya want for nothing?",
                .psize  = 28,
-               .digest = { 0xef, 0xfc, 0xdf, 0x6a, 0xe5, 0xeb, 0x2f, 0xa2, 0xd2, 0x74, 
+               .digest = { 0xef, 0xfc, 0xdf, 0x6a, 0xe5, 0xeb, 0x2f, 0xa2, 0xd2, 0x74,
                            0x16, 0xd5, 0xf1, 0x84, 0xdf, 0x9c, 0x25, 0x9a, 0x7c, 0x79 },
                .np     = 2,
                .tap    = { 14, 14 }
@@ -779,30 +779,30 @@ static struct hmac_testvec hmac_sha1_tv_template[] = {
                .ksize  = 20,
                .plaintext = { [0 ... 49] = 0xdd },
                .psize  = 50,
-               .digest = { 0x12, 0x5d, 0x73, 0x42, 0xb9, 0xac, 0x11, 0xcd, 0x91, 0xa3, 
+               .digest = { 0x12, 0x5d, 0x73, 0x42, 0xb9, 0xac, 0x11, 0xcd, 0x91, 0xa3,
                            0x9a, 0xf4, 0x8a, 0xa1, 0x7b, 0x4f, 0x63, 0xf1, 0x75, 0xd3 },
        }, {
                .key    = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
-                           0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 
+                           0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
                            0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19 },
                .ksize  = 25,
                .plaintext = { [0 ... 49] = 0xcd },
                .psize  = 50,
-               .digest = { 0x4c, 0x90, 0x07, 0xf4, 0x02, 0x62, 0x50, 0xc6, 0xbc, 0x84, 
+               .digest = { 0x4c, 0x90, 0x07, 0xf4, 0x02, 0x62, 0x50, 0xc6, 0xbc, 0x84,
                            0x14, 0xf9, 0xbf, 0x50, 0xc8, 0x6c, 0x2d, 0x72, 0x35, 0xda },
        }, {
                .key    = { [0 ... 19] = 0x0c },
                .ksize  = 20,
                .plaintext = "Test With Truncation",
                .psize  = 20,
-               .digest = { 0x4c, 0x1a, 0x03, 0x42, 0x4b, 0x55, 0xe0, 0x7f, 0xe7, 0xf2, 
+               .digest = { 0x4c, 0x1a, 0x03, 0x42, 0x4b, 0x55, 0xe0, 0x7f, 0xe7, 0xf2,
                            0x7b, 0xe1, 0xd5, 0x8b, 0xb9, 0x32, 0x4a, 0x9a, 0x5a, 0x04 },
        }, {
                .key    = { [0 ... 79] = 0xaa },
                .ksize  = 80,
                .plaintext = "Test Using Larger Than Block-Size Key - Hash Key First",
                .psize  = 54,
-               .digest = { 0xaa, 0x4a, 0xe5, 0xe1, 0x52, 0x72, 0xd0, 0x0e, 0x95, 0x70, 
+               .digest = { 0xaa, 0x4a, 0xe5, 0xe1, 0x52, 0x72, 0xd0, 0x0e, 0x95, 0x70,
                            0x56, 0x37, 0xce, 0x8a, 0x3b, 0x55, 0xed, 0x40, 0x21, 0x12 },
        }, {
                .key    = { [0 ... 79] = 0xaa },
@@ -810,7 +810,7 @@ static struct hmac_testvec hmac_sha1_tv_template[] = {
                .plaintext = "Test Using Larger Than Block-Size Key and Larger Than One "
                             "Block-Size Data",
                .psize  = 73,
-               .digest = { 0xe8, 0xe9, 0x9d, 0x0f, 0x45, 0x23, 0x7d, 0x78, 0x6d, 0x6b, 
+               .digest = { 0xe8, 0xe9, 0x9d, 0x0f, 0x45, 0x23, 0x7d, 0x78, 0x6d, 0x6b,
                            0xba, 0xa7, 0x96, 0x5c, 0x78, 0x08, 0xbb, 0xff, 0x1a, 0x91 },
        },
 };
@@ -1011,7 +1011,7 @@ static struct cipher_testvec des_enc_tv_template[] = {
                            0xf7, 0x9c, 0x89, 0x2a, 0x33, 0x8f, 0x4a, 0x8b },
                .rlen   = 32,
                .np     = 3,
-               .tap    = { 14, 10, 8 } 
+               .tap    = { 14, 10, 8 }
        }, {
                .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
                .klen   = 8,
@@ -1024,7 +1024,7 @@ static struct cipher_testvec des_enc_tv_template[] = {
                            0xb4, 0x99, 0x26, 0xf7, 0x1f, 0xe1, 0xd4, 0x90 },
                .rlen   = 24,
                .np     = 4,
-               .tap    = { 2, 1, 3, 18 } 
+               .tap    = { 2, 1, 3, 18 }
        }, {
                .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
                .klen   = 8,
@@ -1035,7 +1035,7 @@ static struct cipher_testvec des_enc_tv_template[] = {
                            0xf7, 0x9c, 0x89, 0x2a, 0x33, 0x8f, 0x4a, 0x8b },
                .rlen   = 16,
                .np     = 5,
-               .tap    = { 2, 2, 2, 2, 8 } 
+               .tap    = { 2, 2, 2, 2, 8 }
        }, {
                .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
                .klen   = 8,
@@ -1044,7 +1044,7 @@ static struct cipher_testvec des_enc_tv_template[] = {
                .result = { 0xc9, 0x57, 0x44, 0x25, 0x6a, 0x5e, 0xd3, 0x1d },
                .rlen   = 8,
                .np     = 8,
-               .tap    = { 1, 1, 1, 1, 1, 1, 1, 1 } 
+               .tap    = { 1, 1, 1, 1, 1, 1, 1, 1 }
        },
 };
 
@@ -1057,7 +1057,7 @@ static struct cipher_testvec des_dec_tv_template[] = {
                .result = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xe7 },
                .rlen   = 8,
        }, { /* Sbox test from NBS */
-               .key    = { 0x7c, 0xa1, 0x10, 0x45, 0x4a, 0x1a, 0x6e, 0x57 },           
+               .key    = { 0x7c, 0xa1, 0x10, 0x45, 0x4a, 0x1a, 0x6e, 0x57 },
                .klen   = 8,
                .input  = { 0x69, 0x0f, 0x5b, 0x0d, 0x9a, 0x26, 0x93, 0x9b },
                .ilen   = 8,
@@ -1092,19 +1092,19 @@ static struct cipher_testvec des_cbc_enc_tv_template[] = {
        { /* From OpenSSL */
                .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef},
                .klen   = 8,
-               .iv     = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10},            
-               .input  = { 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20, 
-                           0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74, 
-                           0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20 }, 
+               .iv     = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10},
+               .input  = { 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20,
+                           0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74,
+                           0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20 },
                .ilen   = 24,
-               .result = { 0xcc, 0xd1, 0x73, 0xff, 0xab, 0x20, 0x39, 0xf4, 
-                           0xac, 0xd8, 0xae, 0xfd, 0xdf, 0xd8, 0xa1, 0xeb, 
-                           0x46, 0x8e, 0x91, 0x15, 0x78, 0x88, 0xba, 0x68 }, 
+               .result = { 0xcc, 0xd1, 0x73, 0xff, 0xab, 0x20, 0x39, 0xf4,
+                           0xac, 0xd8, 0xae, 0xfd, 0xdf, 0xd8, 0xa1, 0xeb,
+                           0x46, 0x8e, 0x91, 0x15, 0x78, 0x88, 0xba, 0x68 },
                .rlen   = 24,
        }, { /* FIPS Pub 81 */
                .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
                .klen   = 8,
-               .iv     = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef },           
+               .iv     = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef },
                .input  = { 0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74 },
                .ilen   = 8,
                .result = { 0xe5, 0xc7, 0xcd, 0xde, 0x87, 0x2b, 0xf2, 0x7c },
@@ -1117,7 +1117,7 @@ static struct cipher_testvec des_cbc_enc_tv_template[] = {
                .ilen   = 8,
                .result = { 0x43, 0xe9, 0x34, 0x00, 0x8c, 0x38, 0x9c, 0x0f },
                .rlen   = 8,
-       }, {    
+       }, {
                .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
                .klen   = 8,
                .iv     = { 0x43, 0xe9, 0x34, 0x00, 0x8c, 0x38, 0x9c, 0x0f },
@@ -1125,18 +1125,18 @@ static struct cipher_testvec des_cbc_enc_tv_template[] = {
                .ilen   = 8,
                .result = { 0x68, 0x37, 0x88, 0x49, 0x9a, 0x7c, 0x05, 0xf6 },
                .rlen   = 8,
-       }, { /* Copy of openssl vector for chunk testing */     
+       }, { /* Copy of openssl vector for chunk testing */
             /* From OpenSSL */
                .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef},
                .klen   = 8,
-               .iv     = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10},            
-               .input  = { 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20, 
-                           0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74, 
-                           0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20 }, 
+               .iv     = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10},
+               .input  = { 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20,
+                           0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74,
+                           0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20 },
                .ilen   = 24,
-               .result = { 0xcc, 0xd1, 0x73, 0xff, 0xab, 0x20, 0x39, 0xf4, 
-                           0xac, 0xd8, 0xae, 0xfd, 0xdf, 0xd8, 0xa1, 0xeb, 
-                           0x46, 0x8e, 0x91, 0x15, 0x78, 0x88, 0xba, 0x68 }, 
+               .result = { 0xcc, 0xd1, 0x73, 0xff, 0xab, 0x20, 0x39, 0xf4,
+                           0xac, 0xd8, 0xae, 0xfd, 0xdf, 0xd8, 0xa1, 0xeb,
+                           0x46, 0x8e, 0x91, 0x15, 0x78, 0x88, 0xba, 0x68 },
                .rlen   = 24,
                .np     = 2,
                .tap    = { 13, 11 }
@@ -1155,24 +1155,24 @@ static struct cipher_testvec des_cbc_dec_tv_template[] = {
        }, {
                .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
                .klen   = 8,
-               .iv     = { 0xe5, 0xc7, 0xcd, 0xde, 0x87, 0x2b, 0xf2, 0x7c },           
+               .iv     = { 0xe5, 0xc7, 0xcd, 0xde, 0x87, 0x2b, 0xf2, 0x7c },
                .input  = { 0x43, 0xe9, 0x34, 0x00, 0x8c, 0x38, 0x9c, 0x0f },
                .ilen   = 8,
-               .result = { 0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20 }, 
+               .result = { 0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20 },
                .rlen   = 8,
        }, {
                .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
                .klen   = 8,
                .iv     = { 0x43, 0xe9, 0x34, 0x00, 0x8c, 0x38, 0x9c, 0x0f },
-               .input  = { 0x68, 0x37, 0x88, 0x49, 0x9a, 0x7c, 0x05, 0xf6 }, 
+               .input  = { 0x68, 0x37, 0x88, 0x49, 0x9a, 0x7c, 0x05, 0xf6 },
                .ilen   = 8,
                .result = { 0x66, 0x6f, 0x72, 0x20, 0x61, 0x6c, 0x6c, 0x20 },
                .rlen   = 8,
-       }, { /* Copy of above, for chunk testing */     
+       }, { /* Copy of above, for chunk testing */
                .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
                .klen   = 8,
                .iv     = { 0x43, 0xe9, 0x34, 0x00, 0x8c, 0x38, 0x9c, 0x0f },
-               .input  = { 0x68, 0x37, 0x88, 0x49, 0x9a, 0x7c, 0x05, 0xf6 }, 
+               .input  = { 0x68, 0x37, 0x88, 0x49, 0x9a, 0x7c, 0x05, 0xf6 },
                .ilen   = 8,
                .result = { 0x66, 0x6f, 0x72, 0x20, 0x61, 0x6c, 0x6c, 0x20 },
                .rlen   = 8,
@@ -1276,7 +1276,7 @@ static struct cipher_testvec bf_enc_tv_template[] = {
                .ilen   = 8,
                .result = { 0xe8, 0x7a, 0x24, 0x4e, 0x2c, 0xc8, 0x5e, 0x82 },
                .rlen   = 8,
-       }, { /* Vary the keylength... */        
+       }, { /* Vary the keylength... */
                .key    = { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87,
                            0x78, 0x69, 0x5a, 0x4b, 0x3c, 0x2d, 0x1e, 0x0f },
                .klen   = 16,
@@ -1297,9 +1297,9 @@ static struct cipher_testvec bf_enc_tv_template[] = {
                .key    = { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87,
                            0x78, 0x69, 0x5a, 0x4b, 0x3c, 0x2d, 0x1e, 0x0f,
                            0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
-                           0x04, 0x68, 0x91, 0x04, 0xc2, 0xfd, 0x3b, 0x2f, 
-                           0x58, 0x40, 0x23, 0x64, 0x1a, 0xba, 0x61, 0x76, 
-                           0x1f, 0x1f, 0x1f, 0x1f, 0x0e, 0x0e, 0x0e, 0x0e, 
+                           0x04, 0x68, 0x91, 0x04, 0xc2, 0xfd, 0x3b, 0x2f,
+                           0x58, 0x40, 0x23, 0x64, 0x1a, 0xba, 0x61, 0x76,
+                           0x1f, 0x1f, 0x1f, 0x1f, 0x0e, 0x0e, 0x0e, 0x0e,
                            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff },
                .klen   = 56,
                .input  = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 },
@@ -1331,7 +1331,7 @@ static struct cipher_testvec bf_dec_tv_template[] = {
                .ilen   = 8,
                .result = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 },
                .rlen   = 8,
-       }, { /* Vary the keylength... */        
+       }, { /* Vary the keylength... */
                .key    = { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87,
                            0x78, 0x69, 0x5a, 0x4b, 0x3c, 0x2d, 0x1e, 0x0f },
                .klen   = 16,
@@ -1352,9 +1352,9 @@ static struct cipher_testvec bf_dec_tv_template[] = {
                .key    = { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87,
                            0x78, 0x69, 0x5a, 0x4b, 0x3c, 0x2d, 0x1e, 0x0f,
                            0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
-                           0x04, 0x68, 0x91, 0x04, 0xc2, 0xfd, 0x3b, 0x2f, 
-                           0x58, 0x40, 0x23, 0x64, 0x1a, 0xba, 0x61, 0x76, 
-                           0x1f, 0x1f, 0x1f, 0x1f, 0x0e, 0x0e, 0x0e, 0x0e, 
+                           0x04, 0x68, 0x91, 0x04, 0xc2, 0xfd, 0x3b, 0x2f,
+                           0x58, 0x40, 0x23, 0x64, 0x1a, 0xba, 0x61, 0x76,
+                           0x1f, 0x1f, 0x1f, 0x1f, 0x0e, 0x0e, 0x0e, 0x0e,
                            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff },
                .klen   = 56,
                .input  = { 0xc0, 0x45, 0x04, 0x01, 0x2e, 0x4e, 0x1f, 0x53 },
@@ -1369,7 +1369,7 @@ static struct cipher_testvec bf_cbc_enc_tv_template[] = {
                .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
                            0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87 },
                .klen   = 16,
-               .iv     = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 },           
+               .iv     = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 },
                .input  = { 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20,
                            0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74,
                            0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20,
@@ -1388,7 +1388,7 @@ static struct cipher_testvec bf_cbc_dec_tv_template[] = {
                .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
                            0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87 },
                .klen   = 16,
-               .iv     = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 },           
+               .iv     = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 },
                .input  = { 0x6b, 0x77, 0xb4, 0xd6, 0x30, 0x06, 0xde, 0xe6,
                            0x05, 0xb1, 0x56, 0xe2, 0x74, 0x03, 0x97, 0x93,
                            0x58, 0xde, 0xb9, 0xe7, 0x15, 0x46, 0x16, 0xd9,
@@ -1490,7 +1490,7 @@ static struct cipher_testvec tf_cbc_enc_tv_template[] = {
                .key    = { [0 ... 15] = 0x00 },
                .klen   = 16,
                .iv     = { 0x9f, 0x58, 0x9f, 0x5c, 0xf6, 0x12, 0x2c, 0x32,
-                           0xb6, 0xbf, 0xec, 0x2f, 0x2a, 0xe8, 0xc3, 0x5a },           
+                           0xb6, 0xbf, 0xec, 0x2f, 0x2a, 0xe8, 0xc3, 0x5a },
                .input  = { [0 ... 15] = 0x00 },
                .ilen   = 16,
                .result = { 0xd4, 0x91, 0xdb, 0x16, 0xe7, 0xb1, 0xc3, 0x9e,
@@ -1528,7 +1528,7 @@ static struct cipher_testvec tf_cbc_dec_tv_template[] = {
                .klen   = 16,
                .iv     = { [0 ... 15] = 0x00 },
                .input  = { 0x9f, 0x58, 0x9f, 0x5c, 0xf6, 0x12, 0x2c, 0x32,
-                           0xb6, 0xbf, 0xec, 0x2f, 0x2a, 0xe8, 0xc3, 0x5a },             
+                           0xb6, 0xbf, 0xec, 0x2f, 0x2a, 0xe8, 0xc3, 0x5a },
                .ilen   = 16,
                .result = { [0 ... 15] = 0x00 },
                .rlen   = 16,
@@ -1578,8 +1578,7 @@ static struct cipher_testvec tf_cbc_dec_tv_template[] = {
 #define TNEPRES_ENC_TEST_VECTORS       4
 #define TNEPRES_DEC_TEST_VECTORS       4
 
-static struct cipher_testvec serpent_enc_tv_template[] = 
-{
+static struct cipher_testvec serpent_enc_tv_template[] = {
        {
                .input  = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
                            0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
@@ -1620,8 +1619,7 @@ static struct cipher_testvec serpent_enc_tv_template[] =
        },
 };
 
-static struct cipher_testvec tnepres_enc_tv_template[] = 
-{
+static struct cipher_testvec tnepres_enc_tv_template[] = {
        { /* KeySize=128, PT=0, I=1 */
                .input  = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
@@ -1629,7 +1627,7 @@ static struct cipher_testvec tnepres_enc_tv_template[] =
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
                .klen   = 16,
                .ilen   = 16,
-               .result = { 0x49, 0xaf, 0xbf, 0xad, 0x9d, 0x5a, 0x34, 0x05, 
+               .result = { 0x49, 0xaf, 0xbf, 0xad, 0x9d, 0x5a, 0x34, 0x05,
                            0x2c, 0xd8, 0xff, 0xa5, 0x98, 0x6b, 0xd2, 0xdd },
                .rlen   = 16,
        }, { /* KeySize=192, PT=0, I=1 */
@@ -1640,7 +1638,7 @@ static struct cipher_testvec tnepres_enc_tv_template[] =
                .input  = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
                .ilen   = 16,
-               .result = { 0xe7, 0x8e, 0x54, 0x02, 0xc7, 0x19, 0x55, 0x68, 
+               .result = { 0xe7, 0x8e, 0x54, 0x02, 0xc7, 0x19, 0x55, 0x68,
                            0xac, 0x36, 0x78, 0xf7, 0xa3, 0xf6, 0x0c, 0x66 },
                .rlen   = 16,
        }, { /* KeySize=256, PT=0, I=1 */
@@ -1652,7 +1650,7 @@ static struct cipher_testvec tnepres_enc_tv_template[] =
                .input  = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
                .ilen   = 16,
-               .result = { 0xab, 0xed, 0x96, 0xe7, 0x66, 0xbf, 0x28, 0xcb, 
+               .result = { 0xab, 0xed, 0x96, 0xe7, 0x66, 0xbf, 0x28, 0xcb,
                            0xc0, 0xeb, 0xd2, 0x1a, 0x82, 0xef, 0x08, 0x19 },
                .rlen   = 16,
        }, { /* KeySize=256, I=257 */
@@ -1664,15 +1662,14 @@ static struct cipher_testvec tnepres_enc_tv_template[] =
                .input  = { 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08,
                            0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00 },
                .ilen   = 16,
-               .result = { 0x5c, 0xe7, 0x1c, 0x70, 0xd2, 0x88, 0x2e, 0x5b, 
+               .result = { 0x5c, 0xe7, 0x1c, 0x70, 0xd2, 0x88, 0x2e, 0x5b,
                            0xb8, 0x32, 0xe4, 0x33, 0xf8, 0x9f, 0x26, 0xde },
                .rlen   = 16,
        },
 };
 
 
-static struct cipher_testvec serpent_dec_tv_template[] = 
-{
+static struct cipher_testvec serpent_dec_tv_template[] = {
        {
                .input  = { 0x12, 0x07, 0xfc, 0xce, 0x9b, 0xd0, 0xd6, 0x47,
                            0x6a, 0xe9, 0x8f, 0xbe, 0xd1, 0x43, 0xa0, 0xe2 },
@@ -1713,8 +1710,7 @@ static struct cipher_testvec serpent_dec_tv_template[] =
        },
 };
 
-static struct cipher_testvec tnepres_dec_tv_template[] =
-{
+static struct cipher_testvec tnepres_dec_tv_template[] = {
        {
                .input  = { 0x41, 0xcc, 0x6b, 0x31, 0x59, 0x31, 0x45, 0x97,
                            0x6d, 0x6f, 0xbb, 0x38, 0x4b, 0x37, 0x21, 0x28 },
@@ -1726,7 +1722,7 @@ static struct cipher_testvec tnepres_dec_tv_template[] =
                .key    = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
                            0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
                .klen   = 16,
-               .input  = { 0xea, 0xf4, 0xd7, 0xfc, 0xd8, 0x01, 0x34, 0x47, 
+               .input  = { 0xea, 0xf4, 0xd7, 0xfc, 0xd8, 0x01, 0x34, 0x47,
                            0x81, 0x45, 0x0b, 0xfa, 0x0c, 0xd6, 0xad, 0x6e },
                .ilen   = 16,
                .result = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
@@ -1738,7 +1734,7 @@ static struct cipher_testvec tnepres_dec_tv_template[] =
                            0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
                            0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f },
                .klen   = 32,
-               .input  = { 0x64, 0xa9, 0x1a, 0x37, 0xed, 0x9f, 0xe7, 0x49, 
+               .input  = { 0x64, 0xa9, 0x1a, 0x37, 0xed, 0x9f, 0xe7, 0x49,
                            0xa8, 0x4e, 0x76, 0xd6, 0xf5, 0x0d, 0x78, 0xee },
                .ilen   = 16,
                .result = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
@@ -1747,7 +1743,7 @@ static struct cipher_testvec tnepres_dec_tv_template[] =
        }, { /* KeySize=128, I=121 */
                .key    = { [15] = 0x80 },
                .klen   = 16,
-               .input  = { 0x3d, 0xda, 0xbf, 0xc0, 0x06, 0xda, 0xab, 0x06, 
+               .input  = { 0x3d, 0xda, 0xbf, 0xc0, 0x06, 0xda, 0xab, 0x06,
                            0x46, 0x2a, 0xf4, 0xef, 0x81, 0x54, 0x4e, 0x26 },
                .ilen   = 16,
                .result = { [0 ... 15] = 0x00 },
@@ -1760,58 +1756,56 @@ static struct cipher_testvec tnepres_dec_tv_template[] =
 #define CAST6_ENC_TEST_VECTORS 3
 #define CAST6_DEC_TEST_VECTORS  3
 
-static struct cipher_testvec cast6_enc_tv_template[] = 
-{
+static struct cipher_testvec cast6_enc_tv_template[] = {
        {
-               .key    = { 0x23, 0x42, 0xbb, 0x9e, 0xfa, 0x38, 0x54, 0x2c, 
+               .key    = { 0x23, 0x42, 0xbb, 0x9e, 0xfa, 0x38, 0x54, 0x2c,
                            0x0a, 0xf7, 0x56, 0x47, 0xf2, 0x9f, 0x61, 0x5d },
                .klen   = 16,
                .input  = { [0 ... 15] = 0x00 },
                .ilen   = 16,
-               .result = { 0xc8, 0x42, 0xa0, 0x89, 0x72, 0xb4, 0x3d, 0x20, 
+               .result = { 0xc8, 0x42, 0xa0, 0x89, 0x72, 0xb4, 0x3d, 0x20,
                            0x83, 0x6c, 0x91, 0xd1, 0xb7, 0x53, 0x0f, 0x6b },
                .rlen   = 16,
        }, {
-               .key    = { 0x23, 0x42, 0xbb, 0x9e, 0xfa, 0x38, 0x54, 0x2c, 
-                           0xbe, 0xd0, 0xac, 0x83, 0x94, 0x0a, 0xc2, 0x98, 
+               .key    = { 0x23, 0x42, 0xbb, 0x9e, 0xfa, 0x38, 0x54, 0x2c,
+                           0xbe, 0xd0, 0xac, 0x83, 0x94, 0x0a, 0xc2, 0x98,
                            0xba, 0xc7, 0x7a, 0x77, 0x17, 0x94, 0x28, 0x63 },
                .klen   = 24,
                .input  = { [0 ... 15] = 0x00 },
                .ilen   = 16,
-               .result = { 0x1b, 0x38, 0x6c, 0x02, 0x10, 0xdc, 0xad, 0xcb, 
+               .result = { 0x1b, 0x38, 0x6c, 0x02, 0x10, 0xdc, 0xad, 0xcb,
                            0xdd, 0x0e, 0x41, 0xaa, 0x08, 0xa7, 0xa7, 0xe8 },
                .rlen   = 16,
        }, {
                .key    = { 0x23, 0x42, 0xbb, 0x9e, 0xfa, 0x38, 0x54, 0x2c,
                            0xbe, 0xd0, 0xac, 0x83, 0x94, 0x0a, 0xc2, 0x98,
                            0x8d, 0x7c, 0x47, 0xce, 0x26, 0x49, 0x08, 0x46,
-                           0x1c, 0xc1, 0xb5, 0x13, 0x7a, 0xe6, 0xb6, 0x04 },                             
+                           0x1c, 0xc1, 0xb5, 0x13, 0x7a, 0xe6, 0xb6, 0x04 },
                .klen   = 32,
                .input  = { [0 ... 15] = 0x00 },
                .ilen   = 16,
-               .result = { 0x4f, 0x6a, 0x20, 0x38, 0x28, 0x68, 0x97, 0xb9, 
+               .result = { 0x4f, 0x6a, 0x20, 0x38, 0x28, 0x68, 0x97, 0xb9,
                            0xc9, 0x87, 0x01, 0x36, 0x55, 0x33, 0x17, 0xfa },
                .rlen   = 16,
        },
 };
 
-static struct cipher_testvec cast6_dec_tv_template[] = 
-{
+static struct cipher_testvec cast6_dec_tv_template[] = {
        {
-               .key    = { 0x23, 0x42, 0xbb, 0x9e, 0xfa, 0x38, 0x54, 0x2c, 
+               .key    = { 0x23, 0x42, 0xbb, 0x9e, 0xfa, 0x38, 0x54, 0x2c,
                            0x0a, 0xf7, 0x56, 0x47, 0xf2, 0x9f, 0x61, 0x5d },
                .klen   = 16,
-               .input  = { 0xc8, 0x42, 0xa0, 0x89, 0x72, 0xb4, 0x3d, 0x20, 
+               .input  = { 0xc8, 0x42, 0xa0, 0x89, 0x72, 0xb4, 0x3d, 0x20,
                            0x83, 0x6c, 0x91, 0xd1, 0xb7, 0x53, 0x0f, 0x6b },
                .ilen   = 16,
                .result = { [0 ... 15] = 0x00 },
                .rlen   = 16,
        }, {
-               .key    = { 0x23, 0x42, 0xbb, 0x9e, 0xfa, 0x38, 0x54, 0x2c, 
-                           0xbe, 0xd0, 0xac, 0x83, 0x94, 0x0a, 0xc2, 0x98, 
+               .key    = { 0x23, 0x42, 0xbb, 0x9e, 0xfa, 0x38, 0x54, 0x2c,
+                           0xbe, 0xd0, 0xac, 0x83, 0x94, 0x0a, 0xc2, 0x98,
                            0xba, 0xc7, 0x7a, 0x77, 0x17, 0x94, 0x28, 0x63 },
                .klen   = 24,
-               .input  = { 0x1b, 0x38, 0x6c, 0x02, 0x10, 0xdc, 0xad, 0xcb, 
+               .input  = { 0x1b, 0x38, 0x6c, 0x02, 0x10, 0xdc, 0xad, 0xcb,
                            0xdd, 0x0e, 0x41, 0xaa, 0x08, 0xa7, 0xa7, 0xe8 },
                .ilen   = 16,
                .result = { [0 ... 15] = 0x00 },
@@ -1820,9 +1814,9 @@ static struct cipher_testvec cast6_dec_tv_template[] =
                .key    = { 0x23, 0x42, 0xbb, 0x9e, 0xfa, 0x38, 0x54, 0x2c,
                            0xbe, 0xd0, 0xac, 0x83, 0x94, 0x0a, 0xc2, 0x98,
                            0x8d, 0x7c, 0x47, 0xce, 0x26, 0x49, 0x08, 0x46,
-                           0x1c, 0xc1, 0xb5, 0x13, 0x7a, 0xe6, 0xb6, 0x04 },                             
+                           0x1c, 0xc1, 0xb5, 0x13, 0x7a, 0xe6, 0xb6, 0x04 },
                .klen   = 32,
-               .input  = { 0x4f, 0x6a, 0x20, 0x38, 0x28, 0x68, 0x97, 0xb9, 
+               .input  = { 0x4f, 0x6a, 0x20, 0x38, 0x28, 0x68, 0x97, 0xb9,
                            0xc9, 0x87, 0x01, 0x36, 0x55, 0x33, 0x17, 0xfa },
                .ilen   = 16,
                .result = { [0 ... 15] = 0x00 },
@@ -1837,9 +1831,9 @@ static struct cipher_testvec cast6_dec_tv_template[] =
 #define AES_ENC_TEST_VECTORS 3
 #define AES_DEC_TEST_VECTORS 3
 
-static struct cipher_testvec aes_enc_tv_template[] = { 
+static struct cipher_testvec aes_enc_tv_template[] = {
        { /* From FIPS-197 */
-               .key    = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 
+               .key    = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
                            0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
                .klen   = 16,
                .input  = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
@@ -1853,7 +1847,7 @@ static struct cipher_testvec aes_enc_tv_template[] = {
                            0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
                            0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17 },
                .klen   = 24,
-               .input  = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 
+               .input  = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
                            0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff },
                .ilen   = 16,
                .result = { 0xdd, 0xa9, 0x7c, 0xa4, 0x86, 0x4c, 0xdf, 0xe0,
@@ -1865,7 +1859,7 @@ static struct cipher_testvec aes_enc_tv_template[] = {
                            0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
                            0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f },
                .klen   = 32,
-               .input  = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 
+               .input  = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
                            0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff },
                .ilen   = 16,
                .result = { 0x8e, 0xa2, 0xb7, 0xca, 0x51, 0x67, 0x45, 0xbf,
@@ -1874,9 +1868,9 @@ static struct cipher_testvec aes_enc_tv_template[] = {
        },
 };
 
-static struct cipher_testvec aes_dec_tv_template[] = { 
+static struct cipher_testvec aes_dec_tv_template[] = {
        { /* From FIPS-197 */
-               .key    = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 
+               .key    = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
                            0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
                .klen   = 16,
                .input  = { 0x69, 0xc4, 0xe0, 0xd8, 0x6a, 0x7b, 0x04, 0x30,
@@ -1893,8 +1887,8 @@ static struct cipher_testvec aes_dec_tv_template[] = {
                .input  = { 0xdd, 0xa9, 0x7c, 0xa4, 0x86, 0x4c, 0xdf, 0xe0,
                            0x6e, 0xaf, 0x70, 0xa0, 0xec, 0x0d, 0x71, 0x91 },
                .ilen   = 16,
-               .result = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 
-                           0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff },  
+               .result = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
+                           0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff },
                .rlen   = 16,
        }, {
                .key    = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
@@ -1905,7 +1899,7 @@ static struct cipher_testvec aes_dec_tv_template[] = {
                .input  = { 0x8e, 0xa2, 0xb7, 0xca, 0x51, 0x67, 0x45, 0xbf,
                            0xea, 0xfc, 0x49, 0x90, 0x4b, 0x49, 0x60, 0x89 },
                .ilen   = 16,
-               .result = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 
+               .result = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
                            0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff },
                .rlen   = 16,
        },
@@ -1915,8 +1909,7 @@ static struct cipher_testvec aes_dec_tv_template[] = {
 #define CAST5_ENC_TEST_VECTORS 3
 #define CAST5_DEC_TEST_VECTORS 3
 
-static struct cipher_testvec cast5_enc_tv_template[] =
-{
+static struct cipher_testvec cast5_enc_tv_template[] = {
        {
                .key    = { 0x01, 0x23, 0x45, 0x67, 0x12, 0x34, 0x56, 0x78,
                            0x23, 0x45, 0x67, 0x89, 0x34, 0x56, 0x78, 0x9a },
@@ -1943,8 +1936,7 @@ static struct cipher_testvec cast5_enc_tv_template[] =
        },
 };
 
-static struct cipher_testvec cast5_dec_tv_template[] =
-{
+static struct cipher_testvec cast5_dec_tv_template[] = {
        {
                .key    = { 0x01, 0x23, 0x45, 0x67, 0x12, 0x34, 0x56, 0x78,
                            0x23, 0x45, 0x67, 0x89, 0x34, 0x56, 0x78, 0x9a },
@@ -1971,14 +1963,13 @@ static struct cipher_testvec cast5_dec_tv_template[] =
        },
 };
 
-/* 
- * ARC4 test vectors from OpenSSL 
+/*
+ * ARC4 test vectors from OpenSSL
  */
 #define ARC4_ENC_TEST_VECTORS  7
 #define ARC4_DEC_TEST_VECTORS  7
 
-static struct cipher_testvec arc4_enc_tv_template[] =
-{
+static struct cipher_testvec arc4_enc_tv_template[] = {
        {
                .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
                .klen   = 8,
@@ -2044,8 +2035,7 @@ static struct cipher_testvec arc4_enc_tv_template[] =
        },
 };
 
-static struct cipher_testvec arc4_dec_tv_template[] =
-{
+static struct cipher_testvec arc4_dec_tv_template[] = {
        {
                .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
                .klen   = 8,
@@ -2111,14 +2101,13 @@ static struct cipher_testvec arc4_dec_tv_template[] =
        },
 };
 
-/* 
+/*
  * TEA test vectors
  */
 #define TEA_ENC_TEST_VECTORS   4
 #define TEA_DEC_TEST_VECTORS   4
 
-static struct cipher_testvec tea_enc_tv_template[] =
-{
+static struct cipher_testvec tea_enc_tv_template[] = {
        {
                .key    = { [0 ... 15] = 0x00 },
                .klen   = 16,
@@ -2138,31 +2127,30 @@ static struct cipher_testvec tea_enc_tv_template[] =
                .key    = { 0x09, 0x65, 0x43, 0x11, 0x66, 0x44, 0x39, 0x25,
                            0x51, 0x3a, 0x16, 0x10, 0x0a, 0x08, 0x12, 0x6e },
                .klen   = 16,
-               .input  = { 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x5f, 0x74, 
+               .input  = { 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x5f, 0x74,
                            0x65, 0x73, 0x74, 0x5f, 0x76, 0x65, 0x63, 0x74 },
                .ilen   = 16,
-               .result = { 0xbe, 0x7a, 0xbb, 0x81, 0x95, 0x2d, 0x1f, 0x1e, 
+               .result = { 0xbe, 0x7a, 0xbb, 0x81, 0x95, 0x2d, 0x1f, 0x1e,
                            0xdd, 0x89, 0xa1, 0x25, 0x04, 0x21, 0xdf, 0x95 },
                .rlen   = 16,
        }, {
                .key    = { 0x4d, 0x76, 0x32, 0x17, 0x05, 0x3f, 0x75, 0x2c,
                            0x5d, 0x04, 0x16, 0x36, 0x15, 0x72, 0x63, 0x2f },
                .klen   = 16,
-               .input  = { 0x54, 0x65, 0x61, 0x20, 0x69, 0x73, 0x20, 0x67, 
-                           0x6f, 0x6f, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 
-                           0x79, 0x6f, 0x75, 0x21, 0x21, 0x21, 0x20, 0x72, 
+               .input  = { 0x54, 0x65, 0x61, 0x20, 0x69, 0x73, 0x20, 0x67,
+                           0x6f, 0x6f, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20,
+                           0x79, 0x6f, 0x75, 0x21, 0x21, 0x21, 0x20, 0x72,
                            0x65, 0x61, 0x6c, 0x6c, 0x79, 0x21, 0x21, 0x21 },
                .ilen   = 32,
-               .result = { 0xe0, 0x4d, 0x5d, 0x3c, 0xb7, 0x8c, 0x36, 0x47, 
-                           0x94, 0x18, 0x95, 0x91, 0xa9, 0xfc, 0x49, 0xf8, 
-                           0x44, 0xd1, 0x2d, 0xc2, 0x99, 0xb8, 0x08, 0x2a, 
+               .result = { 0xe0, 0x4d, 0x5d, 0x3c, 0xb7, 0x8c, 0x36, 0x47,
+                           0x94, 0x18, 0x95, 0x91, 0xa9, 0xfc, 0x49, 0xf8,
+                           0x44, 0xd1, 0x2d, 0xc2, 0x99, 0xb8, 0x08, 0x2a,
                            0x07, 0x89, 0x73, 0xc2, 0x45, 0x92, 0xc6, 0x90 },
                .rlen   = 32,
        }
 };
 
-static struct cipher_testvec tea_dec_tv_template[] =
-{
+static struct cipher_testvec tea_dec_tv_template[] = {
        {
                .key    = { [0 ... 15] = 0x00 },
                .klen   = 16,
@@ -2183,9 +2171,9 @@ static struct cipher_testvec tea_dec_tv_template[] =
                            0x51, 0x3a, 0x16, 0x10, 0x0a, 0x08, 0x12, 0x6e },
                .klen   = 16,
                .input  = { 0xbe, 0x7a, 0xbb, 0x81, 0x95, 0x2d, 0x1f, 0x1e,
-                            0xdd, 0x89, 0xa1, 0x25, 0x04, 0x21, 0xdf, 0x95 },
-                .ilen   = 16,
-               .result = { 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x5f, 0x74, 
+                           0xdd, 0x89, 0xa1, 0x25, 0x04, 0x21, 0xdf, 0x95 },
+               .ilen   = 16,
+               .result = { 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x5f, 0x74,
                            0x65, 0x73, 0x74, 0x5f, 0x76, 0x65, 0x63, 0x74 },
                .rlen   = 16,
        }, {
@@ -2193,26 +2181,25 @@ static struct cipher_testvec tea_dec_tv_template[] =
                            0x5d, 0x04, 0x16, 0x36, 0x15, 0x72, 0x63, 0x2f },
                .klen   = 16,
                .input  = { 0xe0, 0x4d, 0x5d, 0x3c, 0xb7, 0x8c, 0x36, 0x47,
-                            0x94, 0x18, 0x95, 0x91, 0xa9, 0xfc, 0x49, 0xf8,
-                            0x44, 0xd1, 0x2d, 0xc2, 0x99, 0xb8, 0x08, 0x2a,
-                            0x07, 0x89, 0x73, 0xc2, 0x45, 0x92, 0xc6, 0x90 },
+                           0x94, 0x18, 0x95, 0x91, 0xa9, 0xfc, 0x49, 0xf8,
+                           0x44, 0xd1, 0x2d, 0xc2, 0x99, 0xb8, 0x08, 0x2a,
+                           0x07, 0x89, 0x73, 0xc2, 0x45, 0x92, 0xc6, 0x90 },
                .ilen   = 32,
-               .result = { 0x54, 0x65, 0x61, 0x20, 0x69, 0x73, 0x20, 0x67, 
-                           0x6f, 0x6f, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 
-                           0x79, 0x6f, 0x75, 0x21, 0x21, 0x21, 0x20, 0x72, 
+               .result = { 0x54, 0x65, 0x61, 0x20, 0x69, 0x73, 0x20, 0x67,
+                           0x6f, 0x6f, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20,
+                           0x79, 0x6f, 0x75, 0x21, 0x21, 0x21, 0x20, 0x72,
                            0x65, 0x61, 0x6c, 0x6c, 0x79, 0x21, 0x21, 0x21 },
                .rlen   = 32,
        }
 };
 
-/* 
- * XTEA test vectors 
+/*
+ * XTEA test vectors
  */
 #define XTEA_ENC_TEST_VECTORS  4
 #define XTEA_DEC_TEST_VECTORS  4
 
-static struct cipher_testvec xtea_enc_tv_template[] =
-{
+static struct cipher_testvec xtea_enc_tv_template[] = {
        {
                .key    = { [0 ... 15] = 0x00 },
                .klen   = 16,
@@ -2232,31 +2219,30 @@ static struct cipher_testvec xtea_enc_tv_template[] =
                .key    = { 0x09, 0x65, 0x43, 0x11, 0x66, 0x44, 0x39, 0x25,
                            0x51, 0x3a, 0x16, 0x10, 0x0a, 0x08, 0x12, 0x6e },
                .klen   = 16,
-               .input  = { 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x5f, 0x74, 
+               .input  = { 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x5f, 0x74,
                            0x65, 0x73, 0x74, 0x5f, 0x76, 0x65, 0x63, 0x74 },
                .ilen   = 16,
-               .result = { 0xe2, 0x04, 0xdb, 0xf2, 0x89, 0x85, 0x9e, 0xea, 
+               .result = { 0xe2, 0x04, 0xdb, 0xf2, 0x89, 0x85, 0x9e, 0xea,
                            0x61, 0x35, 0xaa, 0xed, 0xb5, 0xcb, 0x71, 0x2c },
                .rlen   = 16,
        }, {
                .key    = { 0x4d, 0x76, 0x32, 0x17, 0x05, 0x3f, 0x75, 0x2c,
                            0x5d, 0x04, 0x16, 0x36, 0x15, 0x72, 0x63, 0x2f },
                .klen   = 16,
-               .input  = { 0x54, 0x65, 0x61, 0x20, 0x69, 0x73, 0x20, 0x67, 
-                           0x6f, 0x6f, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 
-                           0x79, 0x6f, 0x75, 0x21, 0x21, 0x21, 0x20, 0x72, 
+               .input  = { 0x54, 0x65, 0x61, 0x20, 0x69, 0x73, 0x20, 0x67,
+                           0x6f, 0x6f, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20,
+                           0x79, 0x6f, 0x75, 0x21, 0x21, 0x21, 0x20, 0x72,
                            0x65, 0x61, 0x6c, 0x6c, 0x79, 0x21, 0x21, 0x21 },
                .ilen   = 32,
-               .result = { 0x0b, 0x03, 0xcd, 0x8a, 0xbe, 0x95, 0xfd, 0xb1, 
-                           0xc1, 0x44, 0x91, 0x0b, 0xa5, 0xc9, 0x1b, 0xb4, 
-                           0xa9, 0xda, 0x1e, 0x9e, 0xb1, 0x3e, 0x2a, 0x8f, 
+               .result = { 0x0b, 0x03, 0xcd, 0x8a, 0xbe, 0x95, 0xfd, 0xb1,
+                           0xc1, 0x44, 0x91, 0x0b, 0xa5, 0xc9, 0x1b, 0xb4,
+                           0xa9, 0xda, 0x1e, 0x9e, 0xb1, 0x3e, 0x2a, 0x8f,
                            0xea, 0xa5, 0x6a, 0x85, 0xd1, 0xf4, 0xa8, 0xa5 },
                .rlen   = 32,
        }
 };
 
-static struct cipher_testvec xtea_dec_tv_template[] =
-{
+static struct cipher_testvec xtea_dec_tv_template[] = {
        {
                .key    = { [0 ... 15] = 0x00 },
                .klen   = 16,
@@ -2276,24 +2262,24 @@ static struct cipher_testvec xtea_dec_tv_template[] =
                .key    = { 0x09, 0x65, 0x43, 0x11, 0x66, 0x44, 0x39, 0x25,
                            0x51, 0x3a, 0x16, 0x10, 0x0a, 0x08, 0x12, 0x6e },
                .klen   = 16,
-               .input  = { 0xe2, 0x04, 0xdb, 0xf2, 0x89, 0x85, 0x9e, 0xea, 
+               .input  = { 0xe2, 0x04, 0xdb, 0xf2, 0x89, 0x85, 0x9e, 0xea,
                            0x61, 0x35, 0xaa, 0xed, 0xb5, 0xcb, 0x71, 0x2c },
                .ilen   = 16,
-               .result = { 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x5f, 0x74, 
+               .result = { 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x5f, 0x74,
                            0x65, 0x73, 0x74, 0x5f, 0x76, 0x65, 0x63, 0x74 },
                .rlen   = 16,
        }, {
                .key    = { 0x4d, 0x76, 0x32, 0x17, 0x05, 0x3f, 0x75, 0x2c,
                            0x5d, 0x04, 0x16, 0x36, 0x15, 0x72, 0x63, 0x2f },
                .klen   = 16,
-               .input  = { 0x0b, 0x03, 0xcd, 0x8a, 0xbe, 0x95, 0xfd, 0xb1, 
-                           0xc1, 0x44, 0x91, 0x0b, 0xa5, 0xc9, 0x1b, 0xb4, 
-                           0xa9, 0xda, 0x1e, 0x9e, 0xb1, 0x3e, 0x2a, 0x8f, 
+               .input  = { 0x0b, 0x03, 0xcd, 0x8a, 0xbe, 0x95, 0xfd, 0xb1,
+                           0xc1, 0x44, 0x91, 0x0b, 0xa5, 0xc9, 0x1b, 0xb4,
+                           0xa9, 0xda, 0x1e, 0x9e, 0xb1, 0x3e, 0x2a, 0x8f,
                            0xea, 0xa5, 0x6a, 0x85, 0xd1, 0xf4, 0xa8, 0xa5 },
                .ilen   = 32,
-               .result = { 0x54, 0x65, 0x61, 0x20, 0x69, 0x73, 0x20, 0x67, 
-                           0x6f, 0x6f, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 
-                           0x79, 0x6f, 0x75, 0x21, 0x21, 0x21, 0x20, 0x72, 
+               .result = { 0x54, 0x65, 0x61, 0x20, 0x69, 0x73, 0x20, 0x67,
+                           0x6f, 0x6f, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20,
+                           0x79, 0x6f, 0x75, 0x21, 0x21, 0x21, 0x20, 0x72,
                            0x65, 0x61, 0x6c, 0x6c, 0x79, 0x21, 0x21, 0x21 },
                .rlen   = 32,
        }
@@ -2305,9 +2291,9 @@ static struct cipher_testvec xtea_dec_tv_template[] =
 #define KHAZAD_ENC_TEST_VECTORS 5
 #define KHAZAD_DEC_TEST_VECTORS 5
 
-static struct cipher_testvec khazad_enc_tv_template[] = { 
-       { 
-               .key    = { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+static struct cipher_testvec khazad_enc_tv_template[] = {
+       {
+               .key    = { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
                .klen   = 16,
                .input  = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
@@ -2351,9 +2337,9 @@ static struct cipher_testvec khazad_enc_tv_template[] = {
        },
 };
 
-static struct cipher_testvec khazad_dec_tv_template[] = { 
+static struct cipher_testvec khazad_dec_tv_template[] = {
        {
-               .key    = { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+               .key    = { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
                .klen   = 16,
                .input  = { 0X49, 0Xa4, 0Xce, 0X32, 0Xac, 0X19, 0X0e, 0X3f },
@@ -2697,8 +2683,7 @@ static struct comp_testvec deflate_decomp_tv_template[] = {
  */
 #define MICHAEL_MIC_TEST_VECTORS 6
 
-static struct hash_testvec michael_mic_tv_template[] =
-{
+static struct hash_testvec michael_mic_tv_template[] = {
        {
                .key = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
                .ksize = 8,