Skip to contentSkip to conversation

Twofish cipher - x86_64 assembler

PATCH In review Joachim Fritschi 5 participants 17 messages Jun 4, 2006 – Jun 20, 2006 Crypto API

lore
Share & tools
lore
#0 lore raw

PATCH 4/4 Twofish cipher - x86_64 assembler

This patch adds the twofish x86_64 assembler routine.

Changes since last version:
- The keysetup is now handled by the twofish_common.c (see patch 1 )
- The last round of the encrypt/decrypt routines where optimized saving 5 instructions.

Correctness was verified with the tcrypt module and automated test scripts.

diff -uprN linux-2.6.17-rc5.twofish3/arch/x86_64/crypto/Makefile linux-2.6.17-rc5.twofish4/arch/x86_64/crypto/Makefile
--- linux-2.6.17-rc5.twofish3/arch/x86_64/crypto/Makefile 2006-05-30
19:58:05.172677025 +0200
+++ linux-2.6.17-rc5.twofish4/arch/x86_64/crypto/Makefile 2006-05-31
11:56:48.239053258 +0200
@@ -5,5 +5,8 @@
#

obj-$(CONFIG_CRYPTO_AES_X86_64) += aes-x86_64.o
+obj-$(CONFIG_CRYPTO_TWOFISH_X86_64) += twofish-x86_64.o

aes-x86_64-y := aes-x86_64-asm.o aes.o
+twofish-x86_64-y := twofish-x86_64-asm.o
twofish.o ../../../crypto/twofish_common.o
+
diff -uprN linux-2.6.17-rc5.twofish3/arch/x86_64/crypto/twofish.c linux-2.6.17-rc5.twofish4/arch/x86_64/crypto/twofish.c
--- linux-2.6.17-rc5.twofish3/arch/x86_64/crypto/twofish.c 1970-01-01
01:00:00.000000000 +0100
+++ linux-2.6.17-rc5.twofish4/arch/x86_64/crypto/twofish.c 2006-05-31
11:55:51.492767729 +0200
@@ -0,0 +1,86 @@
+/*
+ * Glue Code for optimized x86_64 assembler version of TWOFISH
+ *
+ * Originally Twofish for GPG
+ * By Matthew Skala <[email protected]>, July 26, 1998
+ * 256-bit key length added March 20, 1999
+ * Some modifications to reduce the text size by Werner Koch, April, 1998
+ * Ported to the kerneli patch by Marc Mutz <[email protected]>
+ * Ported to CryptoAPI by Colin Slater <[email protected]>
+ *
+ * The original author has disclaimed all copyright interest in this
+ * code and thus put it in the public domain. The subsequent authors
+ * have put this under the GNU General Public License.
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ *
+ * This code is a "clean room" implementation, written from the paper
+ * _Twofish: A 128-Bit Block Cipher_ by Bruce Schneier, John Kelsey,
+ * Doug Whiting, David Wagner, Chris Hall, and Niels Ferguson, available
+ * through http://www.counterpane.com/twofish.html
+ *
+ * For background information on multiplication in finite fields, used for
+ * the matrix operations in the key schedule, see the book _Contemporary
+ * Abstract Algebra_ by Joseph A. Gallian, especially chapter 22 in the
+ * Third Edition.
+ */
+
+#include <asm/byteorder.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/types.h>
+#include <linux/errno.h>
+#include <linux/crypto.h>
+#include <linux/bitops.h>
+#include <crypto/twofish.h>
+
+asmlinkage void twofish_enc_blk(void *ctx, u8 *dst, const u8 *src); +
+asmlinkage void twofish_dec_blk(void *ctx, u8 *dst, const u8 *src); +
+static struct crypto_alg alg = {

+	.cra_name           =   "twofish",
+	.cra_driver_name    =	"twofish-x86_64",
+	.cra_priority       =	200,
+	.cra_flags          =   CRYPTO_ALG_TYPE_CIPHER,
+	.cra_blocksize      =   TF_BLOCK_SIZE,
+	.cra_ctxsize        =   sizeof(struct twofish_ctx),
+	.cra_alignmask      =	3,
+	.cra_module         =   THIS_MODULE,
+	.cra_list           =   LIST_HEAD_INIT(alg.cra_list),
+	.cra_u              =   { .cipher = {
+	.cia_min_keysize    =   TF_MIN_KEY_SIZE,
+	.cia_max_keysize    =   TF_MAX_KEY_SIZE,
+	.cia_setkey         =   twofish_setkey,
+	.cia_encrypt        =   twofish_enc_blk,
+	.cia_decrypt        =   twofish_dec_blk } }

+};
+
+static int __init init(void)
+{
+ return crypto_register_alg(&alg);
+}
+
+static void __exit fini(void)
+{
+ crypto_unregister_alg(&alg);
+}
+
+module_init(init);
+module_exit(fini);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION ("Twofish Cipher Algorithm, x86_64 asm optimized"); diff -uprN linux-2.6.17-rc5.twofish3/arch/x86_64/crypto/twofish-x86_64-asm.S linux-2.6.17-rc5.twofish4/arch/x86_64/crypto/twofish-x86_64-asm.S --- linux-2.6.17-rc5.twofish3/arch/x86_64/crypto/twofish-x86_64-asm.S

1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.17-rc5.twofish4/arch/x86_64/crypto/twofish-x86_64-asm.S	
2006-05-31 11:58:05.204726048 +0200
@@ -0,0 +1,400 @@
+	/***************************************************************************
+	*   Copyright (C) 2006 by Joachim Fritschi, <[email protected]>        *
+	*                                                                         *
+	*   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.                                   *
+	*                                                                         *
+	*   This program is distributed in the hope that it will be useful,       *
+	*   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+	*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+	*   GNU General Public License for more details.                          *
+	*                                                                         *
+	*   You should have received a copy of the GNU General Public License     *
+	*   along with this program; if not, write to the                         *
+	*   Free Software Foundation, Inc.,                                       *
+	*   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *

+ ***************************************************************************/
+
+.file "twofish-x86_64-asm.S"
+.text
+
+#define a_offset 0
+#define b_offset 4
+#define c_offset 8
+#define d_offset 12
+
+/* Structure of the crypto context struct*/
+
+#define s0 0 /* S0 Array 256 Words each */
+#define s1 1024 /* S1 Array */
+#define s2 2048 /* S2 Array */
+#define s3 3072 /* S3 Array */
+#define w 4096 /* 8 whitening keys (word) */
+#define k 4128 /* key 1-32 ( word ) */
+
+/* Defining a few register aliases for better reading */ +

+#define R0     %rax
+#define R0D    %eax
+#define R0W    %ax
+#define R0B    %al
+#define R0H    %ah
+
+#define R1     %rbx
+#define R1D    %ebx
+#define R1W    %bx
+#define R1B    %bl
+#define R1H    %bh
+
+#define R2     %rcx
+#define R2D    %ecx
+#define R2W    %cx
+#define R2B    %cl
+#define R2H    %ch
+
+#define R3     %rdx
+#define R3D    %edx
+#define R3W    %dx
+#define R3B    %dl
+#define R3H    %dh
+
+#define R4     %rsi
+#define R4D    %esi
+#define R4W    %six
+#define R4B    %sil
+
+#define R5     %rdi
+#define R5D    %edi
+#define R5W    %dix
+#define R5B    %dil
+
+#define R6     %rsp
+#define R6D    %esp
+#define R6W    %spx
+#define R6B    %spl
+
+#define R7     %rbp
+#define R7D    %ebp
+#define R7W    %bpx
+#define R7B    %bpl
+
+#define R8     %r8
+#define R8D    %r8d
+#define R8W    %r8w
+#define R8B    %r8b
+
+#define R9     %r9
+#define R9D    %r9d
+#define R9W    %r9w
+#define R9B    %r9b
+
+#define R10     %r10
+#define R10D    %r10d
+#define R10W    %r10w
+#define R10B    %r10b
+
+#define R11     %r11
+#define R11D    %r11d
+#define R11W    %r11w
+#define R11B    %r11b
+
+#define R12     %r12
+#define R12D    %r12d
+#define R12W    %r12w
+#define R12B    %r12b
+
+#define R13     %r13
+#define R13D    %r13d
+#define R13W    %r13w
+#define R13B    %r13b
+
+#define R14     %r14
+#define R14D    %r14d
+#define R14W    %r14w
+#define R14B    %r14b
+
+#define R15     %r15
+#define R15D    %r15d
+#define R15W    %r15w
+#define R15B    %r15b

+
+
+
+/* performs input whitening */
+#define input_whitening(src,context,offset)\
+ xor w+offset(context), src;\
+
+/* performs input whitening */
+#define output_whitening(src,context,offset)\
+ xor w+16+offset(context),src;\
+
+/* load sbox values */
+#define load_s(context,sbox,index,dst)\
+ xor sbox(context,index,4),dst ## D;\
+
+/* load both round keys */
+#define load_round_key(dsta,dstb,context,round)\
+ mov k+round(context),dsta ## D;\
+ mov k+4+round(context),dstb ## D;
+
+
+#define encrypt_round(a,b,olda,oldb,newa,newb,ctx,round,tmp1,tmp2,key1,key2); \
+ xor tmp1,tmp1;\
+ load_round_key(key1,key2,ctx,round);\
+ movzx a ## B,newa;\
+ movzx a ## H,newb ## D;\
+ ror $16,a ## D;\
+ load_s(ctx,s0,newa,tmp1);\
+ load_s(ctx,s1,newb,tmp1);\
+ movzx a ## B,newa;\
+ movzx a ## H,newb ## D;\
+ load_s(ctx,s2,newa,tmp1);\
+ load_s(ctx,s3,newb,tmp1);\
+ ror $16,a ## D;\
+ xor tmp2,tmp2;\
+ movzx b ## B,newa;\
+ movzx b ## H,newb ## D;\
+ ror $16,b ## D;\
+ load_s(ctx,s1,newa,tmp2);\
+ load_s(ctx,s2,newb,tmp2);\
+ movzx b ## B,newa;\
+ movzx b ## H,newb ## D;\
+ load_s(ctx,s3,newa,tmp2);\
+ load_s(ctx,s0,newb,tmp2);\
+ ror $15,b ## D;\
+ add tmp2 ## D,tmp1 ## D;\
+ add tmp1 ## D,tmp2 ## D;\
+ add tmp1 ## D,key1 ## D;\
+ add tmp2 ## D,key2 ## D;\
+ mov olda ## D,newa ## D;\
+ mov oldb ## D,newb ## D;\
+ mov a ## D,olda ## D;\
+ mov b ## D,oldb ## D;\
+ xor key1 ## D,newa ## D;\
+ xor key2 ## D,newb ## D;\
+ ror $1,newa ## D
+
+/* Last Round can ignore saving a,b for the next round */
+
+#define encrypt_last_round(a,b,olda,oldb,newa,newb,ctx,round,tmp1,tmp2,key1,key2);\
+ xor tmp1,tmp1;\
+ load_round_key(key1,key2,ctx,round);\
+ movzx a ## B,newa;\
+ movzx a ## H,newb ## D;\
+ ror $16,a ## D;\
+ load_s(ctx,s0,newa,tmp1);\
+ load_s(ctx,s1,newb,tmp1);\
+ movzx a ## B,newa;\
+ movzx a ## H,newb ## D;\
+ load_s(ctx,s2,newa,tmp1);\
+ load_s(ctx,s3,newb,tmp1);\
+ xor tmp2,tmp2;\
+ movzx b ## B,newa;\
+ movzx b ## H,newb ## D;\
+ ror $16,b ## D;\
+ load_s(ctx,s1,newa,tmp2);\
+ load_s(ctx,s2,newb,tmp2);\
+ movzx b ## B,newa;\
+ movzx b ## H,newb ## D;\
+ load_s(ctx,s3,newa,tmp2);\
+ load_s(ctx,s0,newb,tmp2);\
+ add tmp2 ## D,tmp1 ## D;\
+ add tmp1 ## D,tmp2 ## D;\
+ add tmp1 ## D,key1 ## D;\
+ add tmp2 ## D,key2 ## D;\
+ mov olda ## D,newa ## D;\
+ mov oldb ## D,newb ## D;\
+ xor key1 ## D,newa ## D;\
+ xor key2 ## D,newb ## D;\
+ ror $1,newa ## D
+
+#define decrypt_round(a,b,olda,oldb,newa,newb,ctx,round,tmp1,tmp2,key1,key2); \
+ xor tmp1,tmp1;\
+ load_round_key(key1,key2,ctx,round);\
+ movzx a ## B,newa;\
+ movzx a ## H,newb ## D;\
+ ror $16,a ## D;\
+ load_s(ctx,s0,newa,tmp1);\
+ load_s(ctx,s1,newb,tmp1);\
+ movzx a ## B,newa;\
+ movzx a ## H,newb ## D;\
+ load_s(ctx,s2,newa,tmp1);\
+ load_s(ctx,s3,newb,tmp1);\
+ ror $15,a ## D;\
+ xor tmp2,tmp2;\
+ movzx b ## B,newa;\
+ movzx b ## H,newb ## D;\
+ ror $16,b ## D;\
+ load_s(ctx,s1,newa,tmp2);\
+ load_s(ctx,s2,newb,tmp2);\
+ movzx b ## B,newa;\
+ movzx b ## H,newb ## D;\
+ load_s(ctx,s3,newa,tmp2);\
+ load_s(ctx,s0,newb,tmp2);\
+ ror $16,b ## D;\
+ add tmp2 ## D,tmp1 ## D;\
+ add tmp1 ## D,tmp2 ## D;\
+ add tmp1 ## D,key1 ## D;\
+ add tmp2 ## D,key2 ## D;\
+ mov olda ## D,newa ## D;\
+ mov oldb ## D,newb ## D;\
+ mov a ## D,olda ## D;\
+ mov b ## D,oldb ## D;\
+ xor key1 ## D,newa ## D;\
+ xor key2 ## D,newb ## D;\
+ ror $1,newb ## D
+
+/* Last Round can ignore saving a,b for the next round */
+
+#define decrypt_last_round(a,b,olda,oldb,newa,newb,ctx,round,tmp1,tmp2,key1,key2);\
+ xor tmp1,tmp1;\
+ load_round_key(key1,key2,ctx,round);\
+ movzx a ## B,newa;\
+ movzx a ## H,newb ## D;\
+ ror $16,a ## D;\
+ load_s(ctx,s0,newa,tmp1);\
+ load_s(ctx,s1,newb,tmp1);\
+ movzx a ## B,newa;\
+ movzx a ## H,newb ## D;\
+ load_s(ctx,s2,newa,tmp1);\
+ load_s(ctx,s3,newb,tmp1);\
+ xor tmp2,tmp2;\
+ movzx b ## B,newa;\
+ movzx b ## H,newb ## D;\
+ ror $16,b ## D;\
+ load_s(ctx,s1,newa,tmp2);\
+ load_s(ctx,s2,newb,tmp2);\
+ movzx b ## B,newa;\
+ movzx b ## H,newb ## D;\
+ load_s(ctx,s3,newa,tmp2);\
+ load_s(ctx,s0,newb,tmp2);\
+ add tmp2 ## D,tmp1 ## D;\
+ add tmp1 ## D,tmp2 ## D;\
+ add tmp1 ## D,key1 ## D;\
+ add tmp2 ## D,key2 ## D;\
+ mov olda ## D,newa ## D;\
+ mov oldb ## D,newb ## D;\
+ xor key1 ## D,newa ## D;\
+ xor key2 ## D,newb ## D;\
+ ror $1,newb ## D
+
+
+
+
+.align 8
+.global twofish_enc_blk
+.global twofish_dec_blk
+
+
+
+twofish_enc_blk:
+ pushq R1
+ pushq R12
+ pushq R13
+
+ /* r5 contains the crypto ctx adress */
+ /* r4 contains the output adress */
+ /* r3 contains the input adress */
+
+ movq (R3),R1
+ movq 8(R3),R9
+ input_whitening(R1,R5,a_offset)
+ input_whitening(R9,R5,c_offset)
+ mov R1D,R0D
+ shr $32,R1
+ mov R9D,R8D
+ shr $32,R9
+ rol $1,R9D
+
+ encrypt_round(R0,R1,R8,R9,R2,R3,R5,0,R10,R11,R12,R13);
+ encrypt_round(R2,R3,R8,R9,R0,R1,R5,8,R10,R11,R12,R13);
+ encrypt_round(R0,R1,R8,R9,R2,R3,R5,2*8,R10,R11,R12,R13);
+ encrypt_round(R2,R3,R8,R9,R0,R1,R5,3*8,R10,R11,R12,R13);
+ encrypt_round(R0,R1,R8,R9,R2,R3,R5,4*8,R10,R11,R12,R13);
+ encrypt_round(R2,R3,R8,R9,R0,R1,R5,5*8,R10,R11,R12,R13);
+ encrypt_round(R0,R1,R8,R9,R2,R3,R5,6*8,R10,R11,R12,R13);
+ encrypt_round(R2,R3,R8,R9,R0,R1,R5,7*8,R10,R11,R12,R13);
+ encrypt_round(R0,R1,R8,R9,R2,R3,R5,8*8,R10,R11,R12,R13);
+ encrypt_round(R2,R3,R8,R9,R0,R1,R5,9*8,R10,R11,R12,R13);
+ encrypt_round(R0,R1,R8,R9,R2,R3,R5,10*8,R10,R11,R12,R13);
+ encrypt_round(R2,R3,R8,R9,R0,R1,R5,11*8,R10,R11,R12,R13);
+ encrypt_round(R0,R1,R8,R9,R2,R3,R5,12*8,R10,R11,R12,R13);
+ encrypt_round(R2,R3,R8,R9,R0,R1,R5,13*8,R10,R11,R12,R13);
+ encrypt_round(R0,R1,R8,R9,R2,R3,R5,14*8,R10,R11,R12,R13);
+
+ mov R3,R13
+ shl $32,R13
+ xor R2,R13
+ output_whitening(R13,R5,a_offset)
+ movq R13,(R4)
+
+ encrypt_last_round(R2,R3,R8,R9,R0,R1,R5,15*8,R10,R11,R12,R13);
+
+
+ shl $32,R1
+ xor R0,R1
+
+ output_whitening(R1,R5,c_offset)
+ movq R1,8(R4)
+
+ popq R13
+ popq R12
+ popq R1
+ movq $1,%rax
+ ret
+
+twofish_dec_blk:
+ pushq R1
+ pushq R12
+ pushq R13
+
+ /* r5 contains the crypto ctx adress */
+ /* r4 contains the output adress */
+ /* r3 contains the input adress */
+
+ movq (R3),R1
+ movq 8(R3),R9
+ output_whitening(R1,R5,a_offset)
+ output_whitening(R9,R5,c_offset)
+ mov R1D,R0D
+ shr $32,R1
+ mov R9D,R8D
+ shr $32,R9
+ rol $1,R8D
+
+ decrypt_round(R0,R1,R8,R9,R2,R3,R5,15*8,R10,R11,R12,R13);
+ decrypt_round(R2,R3,R8,R9,R0,R1,R5,14*8,R10,R11,R12,R13);
+ decrypt_round(R0,R1,R8,R9,R2,R3,R5,13*8,R10,R11,R12,R13);
+ decrypt_round(R2,R3,R8,R9,R0,R1,R5,12*8,R10,R11,R12,R13);
+ decrypt_round(R0,R1,R8,R9,R2,R3,R5,11*8,R10,R11,R12,R13);
+ decrypt_round(R2,R3,R8,R9,R0,R1,R5,10*8,R10,R11,R12,R13);
+ decrypt_round(R0,R1,R8,R9,R2,R3,R5,9*8,R10,R11,R12,R13);
+ decrypt_round(R2,R3,R8,R9,R0,R1,R5,8*8,R10,R11,R12,R13);
+ decrypt_round(R0,R1,R8,R9,R2,R3,R5,7*8,R10,R11,R12,R13);
+ decrypt_round(R2,R3,R8,R9,R0,R1,R5,6*8,R10,R11,R12,R13);
+ decrypt_round(R0,R1,R8,R9,R2,R3,R5,5*8,R10,R11,R12,R13);
+ decrypt_round(R2,R3,R8,R9,R0,R1,R5,4*8,R10,R11,R12,R13);
+ decrypt_round(R0,R1,R8,R9,R2,R3,R5,3*8,R10,R11,R12,R13);
+ decrypt_round(R2,R3,R8,R9,R0,R1,R5,2*8,R10,R11,R12,R13);
+ decrypt_round(R0,R1,R8,R9,R2,R3,R5,8,R10,R11,R12,R13);
+
+ mov R3,R13
+ shl $32,R13
+ xor R2,R13
+ input_whitening(R13,R5,a_offset)
+ movq R13,(R4)
+
+ decrypt_last_round(R2,R3,R8,R9,R0,R1,R5,0,R10,R11,R12,R13);
+
+ shl $32,R1
+ xor R0,R1
+ input_whitening(R1,R5,c_offset)
+ movq R1,8(R4)
+
+ popq R13
+ popq R12
+ popq R1
+ movq $1,%rax
+ ret
diff -uprN linux-2.6.17-rc5.twofish3/crypto/Kconfig linux-2.6.17-rc5.twofish4/crypto/Kconfig
--- linux-2.6.17-rc5.twofish3/crypto/Kconfig 2006-05-30 20:00:47.841035197
+0200
+++ linux-2.6.17-rc5.twofish4/crypto/Kconfig 2006-05-31 11:52:43.234447029
+0200
@@ -156,6 +156,20 @@ config CRYPTO_TWOFISH_586
See also:
<http://www.schneier.com/twofish.html>

+config CRYPTO_TWOFISH_X86_64

+        tristate "Twofish cipher algorithm (x86_64)"
+        depends on CRYPTO && ((X86 || UML_X86) && 64BIT)
+        help
+          Twofish cipher algorithm (x86_64).
+
+          Twofish was submitted as an AES (Advanced Encryption Standard)
+          candidate cipher by researchers at CounterPane Systems.  It is a
+          16 round block cipher supporting key sizes of 128, 192, and 256
+          bits.

+
+ See also:
+ <http://www.schneier.com/twofish.html>
+
config CRYPTO_SERPENT
tristate "Serpent cipher algorithm"
depends on CRYPTO

#1 lore raw
Quoted 8 lines · Joachim Fritschi

This patch adds the twofish x86_64 assembler routine.

Changes since last version:
- The keysetup is now handled by the twofish_common.c (see patch 1 )
- The last round of the encrypt/decrypt routines where optimized saving 5 instructions.

Correctness was verified with the tcrypt module and automated test scripts.

Do you have some benchmark numbers that show that it's actually worth it?

Quoted 1 line

+/* Defining a few register aliases for better reading */

Maybe you can read it now better, but for everybody else it is extremly confusing. It would be better if you just used the original register names.

-andi

#2 lore raw
Quoted 7 lines · Andi Kleen
Quoted 3 lines · Joachim Fritschi

This patch adds the twofish x86_64 assembler routine.

+/* Defining a few register aliases for better reading */

Maybe you can read it now better, but for everybody else it is extremly confusing. It would be better if you just used the original register names.

I'd agree if you said this code could benefit from further readability improvements. But you're arguing against one.

Too bad AMD kept the old register names when defining AMD64..

Signature · 1 line
  Dag Arne
#3 lore raw
Quoted 6 lines · Dag Arne Osvik
Quoted 5 lines · Andi Kleen
Quoted 3 lines · Joachim Fritschi

This patch adds the twofish x86_64 assembler routine.

+/* Defining a few register aliases for better reading */

Quoted 8 lines
Quoted 3 lines

Maybe you can read it now better, but for everybody else it is extremly confusing. It would be better if you just used the original register names.

I'd agree if you said this code could benefit from further readability improvements. But you're arguing against one.

Too bad AMD kept the old register names when defining AMD64..

I'd agree that the original register names would only complicate things.

Can you give me any hint what to improve or maybe provide a suggestion on how to improve the overall readabilty.

Thanks,

Joachim

#4 lore raw
Quoted 12 lines · Joachim Fritschi
Quoted 11 lines · Dag Arne Osvik
Quoted 7 lines · Andi Kleen
Quoted 3 lines · Joachim Fritschi

This patch adds the twofish x86_64 assembler routine.

+/* Defining a few register aliases for better reading */

Maybe you can read it now better, but for everybody else it is extremly confusing. It would be better if you just used the original register names.

I'd agree if you said this code could benefit from further readability improvements. But you're arguing against one.

Quoted 6 lines
Quoted 1 line

Too bad AMD kept the old register names when defining AMD64..

I'd agree that the original register names would only complicate things.

Can you give me any hint what to improve or maybe provide a suggestion on how to improve the overall readabilty.

It looks better on second reading, but I have some comments:

Remove load_s - it's needless and (slightly) confusing There are some cases of missing ## D
Why semicolon after closing parenthesis in macro definitions? Try to align operands in columns
It would be nice to have some explanation of macro parameter names

Btw, why do you keep zeroing tmp registers when you don't need to? 32-bit ops zero the top half of the destination register.

Here's an example of a modified macro (modulo linewrapping by my mail client):

#define

encrypt_round(a,b,olda,oldb,newa,newb,ctx,round,tmp1,tmp2,key1,key2) \
        load_round_key(key1,key2,ctx,round);\
        movzx   a ## B,         newa ## D;\
        movzx   a ## H,         newb ## D;\
        ror     $16,            a    ## D;\
        xor     s0(ctx,newa,4), tmp1 ## D;\
        xor     s1(ctx,newb,4), tmp1 ## D;\
        movzx   a ## B,         newa ## D;\
        movzx   a ## H,         newb ## D;\
        xor     s2(ctx,newa,4), tmp1 ## D;\
        xor     s3(ctx,newb,4), tmp1 ## D;\
        ror     $16,            a    ## D;\
        movzx   b ## B,         newa ## D;\
        movzx   b ## H,         newb ## D;\
        ror     $16,            b    ## D;\
        xor     s1(ctx,newa,4), tmp2 ## D;\
        xor     s2(ctx,newb,4), tmp2 ## D;\
        movzx   b ## B,         newa ## D;\
        movzx   b ## H,         newb ## D;\
        xor     s3(ctx,newa,4), tmp2 ## D;\
        xor     s0(ctx,newb,4), tmp2 ## D;\
        ror     $15,            b    ## D;\
        add     tmp2 ## D,      tmp1 ## D;\
        add     tmp1 ## D,      tmp2 ## D;\
        add     tmp1 ## D,      key1 ## D;\
        add     tmp2 ## D,      key2 ## D;\
        mov     olda ## D,      newa ## D;\
        mov     oldb ## D,      newb ## D;\
        mov     a    ## D,      olda ## D;\
        mov     b    ## D,      oldb ## D;\
        xor     key1 ## D,      newa ## D;\
        xor     key2 ## D,      newb ## D;\
        ror     $1,             newa ## D

At least a little bit more readable, right?

Signature · 1 line
  Dag Arne
#5 lore raw
Quoted 21 lines · Dag Arne Osvik
Quoted 9 lines · Joachim Fritschi
Quoted 8 lines · Dag Arne Osvik
Quoted 7 lines · Andi Kleen
Quoted 3 lines · Joachim Fritschi

This patch adds the twofish x86_64 assembler routine.

+/* Defining a few register aliases for better reading */

Maybe you can read it now better, but for everybody else it is extremly confusing. It would be better if you just used the original register names.

Quoted 8 lines
Quoted 4 lines

I'd agree if you said this code could benefit from further readability improvements. But you're arguing against one.

Too bad AMD kept the old register names when defining AMD64..

I'd agree that the original register names would only complicate things.

Can you give me any hint what to improve or maybe provide a suggestion on how to improve the overall readabilty.

It looks better on second reading, but I have some comments:

Quoted 8 lines

Remove load_s - it's needless and (slightly) confusing There are some cases of missing ## D
Why semicolon after closing parenthesis in macro definitions? Try to align operands in columns
It would be nice to have some explanation of macro parameter names

Btw, why do you keep zeroing tmp registers when you don't need to? 32-bit ops zero the top half of the destination register.

Sorry.. that zeroing was of course due to load_s only doing xor..

Quoted 11 lines

Here's an example of a modified macro (modulo linewrapping by my mail client):

#define

encrypt_round(a,b,olda,oldb,newa,newb,ctx,round,tmp1,tmp2,key1,key2) \
        load_round_key(key1,key2,ctx,round);\
        movzx   a ## B,         newa ## D;\
        movzx   a ## H,         newb ## D;\
        ror     $16,            a    ## D;\
        xor     s0(ctx,newa,4), tmp1 ## D;\

^^^ change to mov

Quoted 10 lines
        xor     s1(ctx,newb,4), tmp1 ## D;\
        movzx   a ## B,         newa ## D;\
        movzx   a ## H,         newb ## D;\
        xor     s2(ctx,newa,4), tmp1 ## D;\
        xor     s3(ctx,newb,4), tmp1 ## D;\
        ror     $16,            a    ## D;\
        movzx   b ## B,         newa ## D;\
        movzx   b ## H,         newb ## D;\
        ror     $16,            b    ## D;\
        xor     s1(ctx,newa,4), tmp2 ## D;\

^^^ change to mov

Quoted 20 lines
        xor     s2(ctx,newb,4), tmp2 ## D;\
        movzx   b ## B,         newa ## D;\
        movzx   b ## H,         newb ## D;\
        xor     s3(ctx,newa,4), tmp2 ## D;\
        xor     s0(ctx,newb,4), tmp2 ## D;\
        ror     $15,            b    ## D;\
        add     tmp2 ## D,      tmp1 ## D;\
        add     tmp1 ## D,      tmp2 ## D;\
        add     tmp1 ## D,      key1 ## D;\
        add     tmp2 ## D,      key2 ## D;\
        mov     olda ## D,      newa ## D;\
        mov     oldb ## D,      newb ## D;\
        mov     a    ## D,      olda ## D;\
        mov     b    ## D,      oldb ## D;\
        xor     key1 ## D,      newa ## D;\
        xor     key2 ## D,      newb ## D;\
        ror     $1,             newa ## D

At least a little bit more readable, right?

Signature · 1 line
  Dag Arne
#6 lore raw
In reply to Dag Arne Osvik
Quoted 7 lines · Dag Arne Osvik
Quoted 2 lines · Joachim Fritschi

Can you give me any hint what to improve or maybe provide a suggestion on how to improve the overall readabilty.

It looks better on second reading, but I have some comments:

Remove load_s - it's needless and (slightly) confusing

Done

Quoted 1 line

There are some cases of missing ## D

Oops, fixed.

Quoted 1 line

Why semicolon after closing parenthesis in macro definitions?

Braindamage on my part.

Quoted 1 line

Try to align operands in columns

Done

Quoted 1 line

It would be nice to have some explanation of macro parameter names

Done for the non trivial stuff

Quoted 2 lines

Btw, why do you keep zeroing tmp registers when you don't need to? 32-bit ops zero the top half of the destination register.

Again braindamage :). Fixed it according to your suggestions.

Thanks for the comments. Will post a new patches in a few minutes.

-Joachim

#7 lore raw
In reply to Andi Kleen
Quoted 8 lines · Andi Kleen
Quoted 7 lines · Joachim Fritschi

This patch adds the twofish x86_64 assembler routine.

Changes since last version:
- The keysetup is now handled by the twofish_common.c (see patch 1 )
- The last round of the encrypt/decrypt routines where optimized saving 5 instructions.

Quoted 5 lines
Quoted 2 lines

Correctness was verified with the tcrypt module and automated test scripts.

Do you have some benchmark numbers that show that it's actually worth it?

Here are the outputs from the tcrypt speedtests. They haven't changed much since the last patch:

http://homepages.tu-darmstadt.de/~fritschi/twofish/tcrypt-speed-c-i586.txt
http://homepages.tu-darmstadt.de/~fritschi/twofish/tcrypt-speed-asm-i586.txt
http://homepages.tu-darmstadt.de/~fritschi/twofish/tcrypt-speed-c-x86_64.txt
http://homepages.tu-darmstadt.de/~fritschi/twofish/tcrypt-speed-asm-x86_64.txt

Summary for cycles used for CBC encrypt decrypt (256bit / 8k blocks) assembler vs. generic-c:

i586 encrypt:   - 17%
i568 decrypt:   -24%
x86_64 encrypt: -22%
x86_64 decrypt: -17%

The numbers vary a bit with different blocksizes / keylength and per test.

I also did some filesystem benchmarks (bonnie++) with various ciphers. Most write tests maxed out my drives writing to disk. But at least for the read speed you can see some notable performance improvements:
(Note: The x86 and x86_64 numbers are not comparable since the tests were done on different machines)

http://homepages.tu-darmstadt.de/~fritschi/twofish/output_20060531_160442_x86.html

Summary:
Sequential read speed improved between 25-32%
Sequential write speed improved at least 15% but the disk maxed out Twofish 256 is a little bit faster than AES 128

http://homepages.tu-darmstadt.de/~fritschi/twofish/output_20060601_113747_x86_64.html

Summary:
Sequential read speed improved 13%
Seqential write speed maxed out the drives

Quoted 4 lines
Quoted 1 line

+/* Defining a few register aliases for better reading */

Maybe you can read it now better, but for everybody else it is extremly confusing. It would be better if you just used the original register names.

The problem with the registers is that the original naming is really crappy in the first place. The lower registers use the old x86 naming scheme plus some extensions but the upper registers are totally different. Since i use a lot of the lower / higher 8bit and 32 bit parts it would be virtually impossible to write simple macros with this naming scheme because there would be no easy way to switch from a (unknown) register to its 8bit subregister or the 32bit in a macro. While there might be some way to do this, i have not found any example in the kernel or any other source code.
As an explanation i can only add that i looked at the aes assembler implementation and used it as a example. I know refering to bad coding style in the kernel is no excuse for more bad coding but it seems to me that it is the only way to deal with the insane original register naming. Imho using the original names would only complicate the macros and complicate understanding the algorithm itself. For the algorithm itself the the actual registers are simply irrelevant . It calls no other functions or uses any syscalls. It only uses them as storage. That way reffering to them in a numbered order with a suffix for 8/16/32bit was an easy way to improve readability and easier programming.
There might be some way to further improve readability but i have not found any other way. I'm open to suggestions :)

Regards,

Joachim

#8 lore raw
Quoted 7 lines · Joachim Fritschi

Here are the outputs from the tcrypt speedtests. They haven't changed much since the last patch:

http://homepages.tu-darmstadt.de/~fritschi/twofish/tcrypt-speed-c-i586.txt
http://homepages.tu-darmstadt.de/~fritschi/twofish/tcrypt-speed-asm-i586.txt
http://homepages.tu-darmstadt.de/~fritschi/twofish/tcrypt-speed-c-x86_64.txt
http://homepages.tu-darmstadt.de/~fritschi/twofish/tcrypt-speed-asm-x86_64.txt

when you quote anything related to cpu performance on an x86 processor it's absolutely essential to indicate which cpu it is... basically vendor_id, cpu family, and model from /proc/cpuinfo. (for example the entire p4 family has incredible model-to-model variation on things like shifts and extensions.)

Quoted 4 lines
Quoted 4 lines
Quoted 1 line

+/* Defining a few register aliases for better reading */

Maybe you can read it now better, but for everybody else it is extremly confusing. It would be better if you just used the original register names.

i'd change the comment to:

/* define a few register aliases to simplify macro substitution */

because as you mention, it's totally impossible to write the macros otherwise. (i've used the same trick myself a bunch of times.)

-dean

#9 lore raw
Quoted 13 lines · dean gaudet
Quoted 11 lines · Joachim Fritschi

Here are the outputs from the tcrypt speedtests. They haven't changed much since the last patch:

http://homepages.tu-darmstadt.de/~fritschi/twofish/tcrypt-speed-c-i586.tx
t
http://homepages.tu-darmstadt.de/~fritschi/twofish/tcrypt-speed-asm-i586.
txt
http://homepages.tu-darmstadt.de/~fritschi/twofish/tcrypt-speed-c-x86_64.
txt
http://homepages.tu-darmstadt.de/~fritschi/twofish/tcrypt-speed-asm-x86_6
4.txt

Quoted 5 lines

when you quote anything related to cpu performance on an x86 processor it's absolutely essential to indicate which cpu it is... basically vendor_id, cpu family, and model from /proc/cpuinfo. (for example the entire p4 family has incredible model-to-model variation on things like shifts and extensions.)

x86_64 benchmarks where done on a:
vendor_id : AuthenticAMD
cpu family : 15
model : 35
model name : AMD Athlon(tm) 64 X2 Dual Core Processor 4400+
stepping : 2
cpu MHz : 2200.000
cache size : 1024 KB
SMP was disabled

x86 benchmarks where done on a:
vendor_id : AuthenticAMD
cpu family : 6
model : 8
model name : AMD Athlon(tm) XP 2400+
stepping : 1
cpu MHz : 1991.695
cache size : 256 KB

Quoted 6 lines
Quoted 5 lines
Quoted 5 lines
Quoted 1 line

+/* Defining a few register aliases for better reading */

Maybe you can read it now better, but for everybody else it is extremly confusing. It would be better if you just used the original register names.

Quoted 6 lines

i'd change the comment to:

/* define a few register aliases to simplify macro substitution */

because as you mention, it's totally impossible to write the macros otherwise. (i've used the same trick myself a bunch of times.)

Sounds ok to me. It was the main reason to use these aliases. For me it also improves readability but as author my view is probably a bit distorted ;)

Joachim

#10 lore raw
In reply to Joachim Fritschi
Quoted 9 lines · Joachim Fritschi
Quoted 8 lines · Andi Kleen
Quoted 7 lines · Joachim Fritschi

This patch adds the twofish x86_64 assembler routine.

Changes since last version:
- The keysetup is now handled by the twofish_common.c (see patch 1 )
- The last round of the encrypt/decrypt routines where optimized saving 5 instructions.

Quoted 8 lines
Quoted 5 lines
Quoted 2 lines

Correctness was verified with the tcrypt module and automated test scripts.

Do you have some benchmark numbers that show that it's actually worth it?

Here are the outputs from the tcrypt speedtests. They haven't changed much since the last patch:

Ok thanks. I've tried to apply the patches, but can't because they're word wrapped. Can you please resend and do a test send to yourself first, checking that the patch can be really applied.

Quoted 2 lines

There might be some way to further improve readability but i have not found any other way. I'm open to suggestions :)

Sounds reasonable. Best you just fix the comment to say that this convention is needed for the macros.

-Andi

#11 lore raw
Quoted 16 lines · Andi Kleen
Quoted 15 lines · Joachim Fritschi
Quoted 13 lines · Andi Kleen
Quoted 9 lines · Joachim Fritschi

This patch adds the twofish x86_64 assembler routine.

Changes since last version:
- The keysetup is now handled by the twofish_common.c (see patch 1 )
- The last round of the encrypt/decrypt routines where optimized saving 5 instructions.

Correctness was verified with the tcrypt module and automated test scripts.

Do you have some benchmark numbers that show that it's actually worth it?

Quoted 6 lines
Quoted 2 lines

Here are the outputs from the tcrypt speedtests. They haven't changed much since the last patch:

Ok thanks. I've tried to apply the patches, but can't because they're word wrapped. Can you please resend and do a test send to yourself first, checking that the patch can be really applied.

Sorry i will send new patches, also including the fixes that were suggested by Dag.

-Joachim

#12 lore raw
In reply to Joachim Fritschi
Quoted 8 lines · Joachim Fritschi

This patch adds the twofish x86_64 assembler routine.

Changes since last version:
- The keysetup is now handled by the twofish_common.c (see patch 1 )
- The last round of the encrypt/decrypt routines where optimized saving 5 instructions.

Correctness was verified with the tcrypt module and automated test scripts.

My first mail was wordwrapped. This one should be unwrapped and working. It also includes some readability fixes, additional comments and a little code cleanup.

arch/x86_64/crypto/Makefile +3 -0
diff -uprN linux-2.6.17-rc5.twofish3/arch/x86_64/crypto/Makefile linux-2.6.17-rc5.twofish4/arch/x86_64/crypto/Makefile
@@ -5,5 +5,8 @@
 #
 
 obj-$(CONFIG_CRYPTO_AES_X86_64) += aes-x86_64.o
+obj-$(CONFIG_CRYPTO_TWOFISH_X86_64) += twofish-x86_64.o
 
 aes-x86_64-y := aes-x86_64-asm.o aes.o
+twofish-x86_64-y := twofish-x86_64-asm.o twofish.o ../../../crypto/twofish_common.o
+
arch/x86_64/crypto/twofish.c +86 -0

86 lines not on this page · raw message

arch/x86_64/crypto/twofish-x86_64-asm.S +406 -0

406 lines not on this page · raw message

crypto/Kconfig +14 -0
diff -uprN linux-2.6.17-rc5.twofish3/crypto/Kconfig linux-2.6.17-rc5.twofish4/crypto/Kconfig
@@ -156,6 +156,20 @@ config CRYPTO_TWOFISH_586
 	  See also:
 	  <http://www.schneier.com/twofish.html>
 
+config CRYPTO_TWOFISH_X86_64
+        tristate "Twofish cipher algorithm (x86_64)"
+        depends on CRYPTO && ((X86 || UML_X86) && 64BIT)
+        help
+          Twofish cipher algorithm (x86_64).
+
+          Twofish was submitted as an AES (Advanced Encryption Standard)
+          candidate cipher by researchers at CounterPane Systems.  It is a
+          16 round block cipher supporting key sizes of 128, 192, and 256
+          bits.
+
+          See also:
+          <http://www.schneier.com/twofish.html>
+
 config CRYPTO_SERPENT
 	tristate "Serpent cipher algorithm"
 	depends on CRYPTO
#13 lore raw
In reply to Joachim Fritschi

Update patch for the x86_64 twofish assembler implementation.

Changes since last version:
-Updated to the new twofish_common setup
-Complete rewrite of the code according to the feedback i recieved (thanks [email protected])

The patch passed the trycpt tests and automated filesystem tests. This rewrite resulted in some nice perfomance increase over my last patch.

Short summary of the tcrypt benchmarks:

Twofish Assembler vs. Twofish C (256bit 8kb block CBC)
encrypt: -27% Cycles
decrypt: -23% Cycles

Twofish Assembler vs. AES Assembler (128bit 8kb block CBC)
encrypt: +18% Cycles
decrypt: +15% Cycles

Twofish Assembler vs. AES Assembler (256bit 8kb block CBC)
encrypt: -9% Cycles
decrypt: -8% Cycles

Full Output:
http://homepages.tu-darmstadt.de/~fritschi/twofish/tcrypt-speed-twofish-c-x86_64.txt
http://homepages.tu-darmstadt.de/~fritschi/twofish/tcrypt-speed-twofish-asm-x86_64.txt
http://homepages.tu-darmstadt.de/~fritschi/twofish/tcrypt-speed-aes-asm-x86_64.txt

Here is another bonnie++ benchmark with encrypted filesystems. Most runs maxed out the hd. It should give some idea what the module can do for encrypted filesystem performance even though you can't see the full numbers.

http://homepages.tu-darmstadt.de/~fritschi/twofish/output_20060610_130806_x86_64.html

arch/x86_64/crypto/Makefile +3 -0
diff -uprN linux-2.6.17-rc5.twofish3/arch/x86_64/crypto/Makefile linux-2.6.17-rc5.twofish4/arch/x86_64/crypto/Makefile
@@ -5,5 +5,8 @@
 # 
 
 obj-$(CONFIG_CRYPTO_AES_X86_64) += aes-x86_64.o
+obj-$(CONFIG_CRYPTO_TWOFISH_X86_64) += twofish-x86_64.o
 
 aes-x86_64-y := aes-x86_64-asm.o aes.o
+twofish-x86_64-y := twofish-x86_64-asm.o twofish.o
+
arch/x86_64/crypto/twofish.c +86 -0

86 lines not on this page · raw message

arch/x86_64/crypto/twofish-x86_64-asm.S +397 -0

397 lines not on this page · raw message

crypto/Kconfig +15 -0
diff -uprN linux-2.6.17-rc5.twofish3/crypto/Kconfig linux-2.6.17-rc5.twofish4/crypto/Kconfig
@@ -165,6 +165,21 @@ config CRYPTO_TWOFISH_586
 	  See also:
 	  <http://www.schneier.com/twofish.html>
 
+config CRYPTO_TWOFISH_X86_64
+        tristate "Twofish cipher algorithm (x86_64)"
+        depends on CRYPTO && ((X86 || UML_X86) && 64BIT)
+        select CRYPTO_TWOFISH_COMMON
+	help
+          Twofish cipher algorithm (x86_64).
+
+          Twofish was submitted as an AES (Advanced Encryption Standard)
+          candidate cipher by researchers at CounterPane Systems.  It is a
+          16 round block cipher supporting key sizes of 128, 192, and 256
+          bits.
+
+          See also:
+          <http://www.schneier.com/twofish.html>
+
 config CRYPTO_SERPENT
 	tristate "Serpent cipher algorithm"
 	depends on CRYPTO
#14 lore raw
In reply to Joachim Fritschi

After recieving some more feedback from [email protected], i have revised my patch a bit and done some cosmetic changes. The first_round macros are now eliminated reducing the patchsize.

Correctness was verified with the tcrypt module and automated test scripts.

arch/x86_64/crypto/Makefile +3 -0
diff -uprN linux-2.6.17-rc5.twofish3/arch/x86_64/crypto/Makefile linux-2.6.17-rc5.twofish4/arch/x86_64/crypto/Makefile
@@ -5,5 +5,8 @@
 # 
 
 obj-$(CONFIG_CRYPTO_AES_X86_64) += aes-x86_64.o
+obj-$(CONFIG_CRYPTO_TWOFISH_X86_64) += twofish-x86_64.o
 
 aes-x86_64-y := aes-x86_64-asm.o aes.o
+twofish-x86_64-y := twofish-x86_64-asm.o twofish.o
+
arch/x86_64/crypto/twofish.c +86 -0

86 lines not on this page · raw message

arch/x86_64/crypto/twofish-x86_64-asm.S +321 -0

321 lines not on this page · raw message

crypto/Kconfig +15 -0
diff -uprN linux-2.6.17-rc5.twofish3/crypto/Kconfig linux-2.6.17-rc5.twofish4/crypto/Kconfig
@@ -165,6 +165,21 @@ config CRYPTO_TWOFISH_586
 	  See also:
 	  <http://www.schneier.com/twofish.html>
 
+config CRYPTO_TWOFISH_X86_64
+        tristate "Twofish cipher algorithm (x86_64)"
+        depends on CRYPTO && ((X86 || UML_X86) && 64BIT)
+        select CRYPTO_TWOFISH_COMMON
+	help
+          Twofish cipher algorithm (x86_64).
+
+          Twofish was submitted as an AES (Advanced Encryption Standard)
+          candidate cipher by researchers at CounterPane Systems.  It is a
+          16 round block cipher supporting key sizes of 128, 192, and 256
+          bits.
+
+          See also:
+          <http://www.schneier.com/twofish.html>
+
 config CRYPTO_SERPENT
 	tristate "Serpent cipher algorithm"
 	depends on CRYPTO
#15 lore raw
In reply to Joachim Fritschi

This patch is now based on the cryptodev tree using the new cryptoapi (crypto tfm
instead of the crypto ctx as parameter).

The module passed the tcrypt tests and testscripts.

 arch/x86_64/crypto/Makefile             |    3 
 arch/x86_64/crypto/twofish-x86_64-asm.S |  324 +++++++++++++++++++++++++++++++
 arch/x86_64/crypto/twofish.c            |   86 ++++++++
 crypto/Kconfig                          |   15 +
 4 files changed, 428 insertions(+), 0 deletions(-)
arch/x86_64/crypto/Makefile +3 -0
index 426d20f..15b538a 100644
@@ -5,5 +5,8 @@ # Arch-specific CryptoAPI modules.
 # 
 
 obj-$(CONFIG_CRYPTO_AES_X86_64) += aes-x86_64.o
+obj-$(CONFIG_CRYPTO_TWOFISH_X86_64) += twofish-x86_64.o
 
 aes-x86_64-y := aes-x86_64-asm.o aes.o
+twofish-x86_64-y := twofish-x86_64-asm.o twofish.o
+
arch/x86_64/crypto/twofish-x86_64-asm.S new file +324 -0

324 lines not on this page · raw message

arch/x86_64/crypto/twofish.c new file +86 -0

86 lines not on this page · raw message

crypto/Kconfig +15 -0
index 28b203b..990054d 100644
@@ -165,6 +165,21 @@ config CRYPTO_TWOFISH_586
 	  See also:
 	  <http://www.schneier.com/twofish.html>
 
+config CRYPTO_TWOFISH_X86_64
+	tristate "Twofish cipher algorithm (x86_64)"
+	depends on CRYPTO && ((X86 || UML_X86) && 64BIT)
+	select CRYPTO_TWOFISH_COMMON
+	help
+	  Twofish cipher algorithm (x86_64).
+
+	  Twofish was submitted as an AES (Advanced Encryption Standard)
+	  candidate cipher by researchers at CounterPane Systems.  It is a
+	  16 round block cipher supporting key sizes of 128, 192, and 256
+	  bits.
+
+	  See also:
+	  <http://www.schneier.com/twofish.html>
+
 config CRYPTO_SERPENT
 	tristate "Serpent cipher algorithm"
 	depends on CRYPTO
maintainer
#16 lore raw
Quoted 6 lines · Joachim Fritschi

This patch is now based on the cryptodev tree using the new cryptoapi (crypto tfm
instead of the crypto ctx as parameter).

The module passed the tcrypt tests and testscripts.

Thanks Joachim. I've applied all four patches. I had to add wrappers around the twofish assembly routines because asmlinkage may differ from the normal C calling convention. It should get optimised away to just a jump if the conventions are identical.

BTW Andi, I think it might be better to have the x86-64 patch sit in the cryptodev tree rather than x86-64 because it won't even compile without the previous patches. If you really want to, I can leave out the x86-64 one in particular for you to merge after the others go upstream.

Cheers,

Signature · 4 lines
Visit Openswan at http://www.openswan.org/
Email: Herbert Xu ~{PmV>HI~} <[email protected]>
Home Page: http://gondor.apana.org.au/~herbert/
PGP Key: http://gondor.apana.org.au/~herbert/pubkey.txt