Skip to contentSkip to conversation

crypto: Speck support

PATCH New Eric Biggers 2 participants 12 messages Feb 8, 2018 – Feb 12, 2018

Subsystems (4)
lore
Share & tools
lore
#0 lore raw

cover crypto: Speck support

Hello,

This series adds Speck support to the crypto API, including the Speck128 and Speck64 variants. Speck is a lightweight block cipher that can be much faster than AES on processors that don't have AES instructions.

We are planning to offer Speck-XTS (probably Speck128/256-XTS) as an option for dm-crypt and fscrypt on Android, for low-end mobile devices with older CPUs such as ARMv7 which don't have the Cryptography Extensions. Currently, such devices are unencrypted because AES is not fast enough, even when the NEON bit-sliced implementation of AES is used. Other AES alternatives such as Blowfish, Twofish, Camellia, Cast6, and Serpent aren't fast enough either; it seems that only a modern ARX cipher can provide sufficient performance on these devices.

This is a replacement for our original proposal
(https://patchwork.kernel.org/patch/10101451/) which was to offer ChaCha20 for these devices. However, the use of a stream cipher for disk/file encryption with no space to store nonces would have been much more insecure than we thought initially, given that it would be used on top of flash storage as well as potentially on top of F2FS, neither of which is guaranteed to overwrite data in-place.

Speck has been somewhat controversial due to its origin. Nevertheless, it has a straightforward design (it's an ARX cipher), and it appears to be the leading software-optimized lightweight block cipher currently, with the most cryptanalysis. It's also easy to implement without side channels, unlike AES. Moreover, we only intend Speck to be used when the status quo is no encryption, due to AES not being fast enough.

We've also considered a novel length-preserving encryption mode based on ChaCha20 and Poly1305. While theoretically attractive, such a mode would be a brand new crypto construction and would be more complicated and difficult to implement efficiently in comparison to Speck-XTS.

Thus, patch 1 adds a generic implementation of Speck, and the following patches add a 32-bit ARM NEON implementation of Speck-XTS. The NEON-accelerated implementation is much faster than the generic implementation and therefore is the implementation that would primarily be used in practice on the devices we are targeting.

There is no AArch64 implementation added, since such CPUs are likely to have the Cryptography Extensions, allowing the use of AES.

Eric Biggers (5):
crypto: add support for the Speck block cipher
crypto: speck - export common helpers
crypto: arm/speck: add NEON-accelerated implementation of Speck-XTS
crypto: speck - add test vectors for Speck128-XTS
crypto: speck - add test vectors for Speck64-XTS

 arch/arm/crypto/Kconfig           |    6 +
 arch/arm/crypto/Makefile          |    2 +
 arch/arm/crypto/speck-neon-core.S |  431 +++++++++++
 arch/arm/crypto/speck-neon-glue.c |  290 ++++++++
 crypto/Kconfig                    |   14 +
 crypto/Makefile                   |    1 +
 crypto/speck.c                    |  302 ++++++++
 crypto/testmgr.c                  |   36 +
 crypto/testmgr.h                  | 1478 +++++++++++++++++++++++++++++++++++++
 include/crypto/speck.h            |   62 ++
 10 files changed, 2622 insertions(+)
 create mode 100644 arch/arm/crypto/speck-neon-core.S
 create mode 100644 arch/arm/crypto/speck-neon-glue.c
 create mode 100644 crypto/speck.c
 create mode 100644 include/crypto/speck.h
Signature · 1 line
2.16.0.rc1.238.g530d649a79-goog
#1 lore raw

PATCH 1/5 crypto: add support for the Speck block cipher

Add a generic implementation of Speck, including the Speck128 and Speck64 variants. Speck is a lightweight block cipher that can be much faster than AES on processors that don't have AES instructions.

We are planning to offer Speck-XTS (probably Speck128/256-XTS) as an option for dm-crypt and fscrypt on Android, for low-end mobile devices with older CPUs such as ARMv7 which don't have the Cryptography Extensions. Currently, such devices are unencrypted because AES is not fast enough, even when the NEON bit-sliced implementation of AES is used. Other AES alternatives such as Blowfish, Twofish, Camellia, Cast6, and Serpent aren't fast enough either; it seems that only a modern ARX cipher can provide sufficient performance on these devices.

This is a replacement for our original proposal
(https://patchwork.kernel.org/patch/10101451/) which was to offer ChaCha20 for these devices. However, the use of a stream cipher for disk/file encryption with no space to store nonces would have been much more insecure than we thought initially, given that it would be used on top of flash storage as well as potentially on top of F2FS, neither of which is guaranteed to overwrite data in-place.

Speck has been somewhat controversial due to its origin. Nevertheless, it has a straightforward design (it's an ARX cipher), and it appears to be the leading software-optimized lightweight block cipher currently, with the most cryptanalysis. It's also easy to implement without side channels, unlike AES. Moreover, we only intend Speck to be used when the status quo is no encryption, due to AES not being fast enough.

We've also considered a novel length-preserving encryption mode based on ChaCha20 and Poly1305. While theoretically attractive, such a mode would be a brand new crypto construction and would be more complicated and difficult to implement efficiently in comparison to Speck-XTS.

---
 crypto/Kconfig   |  14 +++
 crypto/Makefile  |   1 +
 crypto/speck.c   | 294 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 crypto/testmgr.c |  18 ++++
 crypto/testmgr.h | 120 +++++++++++++++++++++++
 5 files changed, 447 insertions(+)
 create mode 100644 crypto/speck.c
crypto/Kconfig +14 -0
index b75264b09a46..558eff07b799 100644
@@ -1508,6 +1508,20 @@ config CRYPTO_SERPENT_AVX2_X86_64
 	  See also:
 	  <http://www.cl.cam.ac.uk/~rja14/serpent.html>
 
+config CRYPTO_SPECK
+	tristate "Speck cipher algorithm"
+	select CRYPTO_ALGAPI
+	help
+	  Speck is a lightweight block cipher that is tuned for optimal
+	  performance in software (rather than hardware).
+
+	  Speck may not be as secure as AES, and should only be used on systems
+	  where AES is not fast enough.
+
+	  See also: <https://eprint.iacr.org/2013/404.pdf>
+
+	  If unsure, say N.
+
 config CRYPTO_TEA
 	tristate "TEA, XTEA and XETA cipher algorithms"
 	select CRYPTO_ALGAPI
crypto/Makefile +1 -0
index cdbc03b35510..ba6019471447 100644
@@ -110,6 +110,7 @@ obj-$(CONFIG_CRYPTO_TEA) += tea.o
 obj-$(CONFIG_CRYPTO_KHAZAD) += khazad.o
 obj-$(CONFIG_CRYPTO_ANUBIS) += anubis.o
 obj-$(CONFIG_CRYPTO_SEED) += seed.o
+obj-$(CONFIG_CRYPTO_SPECK) += speck.o
 obj-$(CONFIG_CRYPTO_SALSA20) += salsa20_generic.o
 obj-$(CONFIG_CRYPTO_CHACHA20) += chacha20_generic.o
 obj-$(CONFIG_CRYPTO_POLY1305) += poly1305_generic.o
crypto/speck.c new file +294 -0

294 lines not on this page · raw message

crypto/testmgr.c +18 -0
index d5e23a142a04..d5be42149e29 100644
@@ -3000,6 +3000,24 @@ static const struct alg_test_desc alg_test_descs[] = {
 				.dec = __VECS(serpent_dec_tv_template)
 			}
 		}
+	}, {
+		.alg = "ecb(speck128)",
+		.test = alg_test_skcipher,
+		.suite = {
+			.cipher = {
+				.enc = __VECS(speck128_enc_tv_template),
+				.dec = __VECS(speck128_dec_tv_template),
+			}
+		}
+	}, {
+		.alg = "ecb(speck64)",
+		.test = alg_test_skcipher,
+		.suite = {
+			.cipher = {
+				.enc = __VECS(speck64_enc_tv_template),
+				.dec = __VECS(speck64_dec_tv_template),
+			}
+		}
 	}, {
 		.alg = "ecb(tea)",
 		.test = alg_test_skcipher,
crypto/testmgr.h +120 -0

126 lines not on this page · raw message

Signature · 1 line
2.16.0.rc1.238.g530d649a79-goog
#2 lore raw

PATCH 2/5 crypto: speck - export common helpers

In reply to Eric Biggers

Export the Speck constants and transform context and the ->setkey(), ->encrypt(), and ->decrypt() functions so that they can be reused by the ARM NEON implementation of Speck-XTS. The generic key expansion code will be reused because it is not performance-critical and is not vectorizable, while the generic encryption and decryption functions are needed as fallbacks and for the XTS tweak encryption.

---
 crypto/speck.c         | 90 +++++++++++++++++++++++++++-----------------------
 include/crypto/speck.h | 62 ++++++++++++++++++++++++++++++++++
 2 files changed, 111 insertions(+), 41 deletions(-)
 create mode 100644 include/crypto/speck.h
crypto/speck.c +49 -41
index 89860688bf00..c78c8a782b0c 100644
@@ -19,6 +19,7 @@
  */
 
 #include <asm/unaligned.h>
+#include <crypto/speck.h>
 #include <linux/bitops.h>
 #include <linux/crypto.h>
 #include <linux/init.h>
@@ -26,22 +27,6 @@
 
 /* Speck128 */
 
-#define SPECK128_BLOCK_SIZE	16
-
-#define SPECK128_128_KEY_SIZE	16
-#define SPECK128_128_NROUNDS	32
-
-#define SPECK128_192_KEY_SIZE	24
-#define SPECK128_192_NROUNDS	33
-
-#define SPECK128_256_KEY_SIZE	32
-#define SPECK128_256_NROUNDS	34
-
-struct speck128_tfm_ctx {
-	u64 round_keys[SPECK128_256_NROUNDS];
-	int nrounds;
-};
-
 static __always_inline void speck128_round(u64 *x, u64 *y, u64 k)
 {
 	*x = ror64(*x, 8);
@@ -60,9 +45,9 @@ static __always_inline void speck128_unround(u64 *x, u64 *y, u64 k)
 	*x = rol64(*x, 8);
 }
 
-static void speck128_encrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
+void crypto_speck128_encrypt(const struct speck128_tfm_ctx *ctx,
+			     u8 *out, const u8 *in)
 {
-	const struct speck128_tfm_ctx *ctx = crypto_tfm_ctx(tfm);
 	u64 x = get_unaligned_le64(in + 0);
 	u64 y = get_unaligned_le64(in + 8);
 	int i;
@@ -73,10 +58,16 @@ static void speck128_encrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
 	put_unaligned_le64(x, out + 0);
 	put_unaligned_le64(y, out + 8);
 }
+EXPORT_SYMBOL_GPL(crypto_speck128_encrypt);
 
-static void speck128_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
+static void speck128_encrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
+{
+	crypto_speck128_encrypt(crypto_tfm_ctx(tfm), out, in);
+}
+
+void crypto_speck128_decrypt(const struct speck128_tfm_ctx *ctx,
+			     u8 *out, const u8 *in)
 {
-	const struct speck128_tfm_ctx *ctx = crypto_tfm_ctx(tfm);
 	u64 x = get_unaligned_le64(in + 0);
 	u64 y = get_unaligned_le64(in + 8);
 	int i;
@@ -87,11 +78,16 @@ static void speck128_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
 	put_unaligned_le64(x, out + 0);
 	put_unaligned_le64(y, out + 8);
 }
+EXPORT_SYMBOL_GPL(crypto_speck128_decrypt);
 
-static int speck128_setkey(struct crypto_tfm *tfm, const u8 *key,
+static void speck128_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
+{
+	crypto_speck128_decrypt(crypto_tfm_ctx(tfm), out, in);
+}
+
+int crypto_speck128_setkey(struct speck128_tfm_ctx *ctx, const u8 *key,
 			   unsigned int keylen)
 {
-	struct speck128_tfm_ctx *ctx = crypto_tfm_ctx(tfm);
 	u64 l[3];
 	u64 k;
 	int i;
@@ -133,21 +129,15 @@ static int speck128_setkey(struct crypto_tfm *tfm, const u8 *key,
 
 	return 0;
 }
+EXPORT_SYMBOL_GPL(crypto_speck128_setkey);
 
-/* Speck64 */
-
-#define SPECK64_BLOCK_SIZE	8
-
-#define SPECK64_96_KEY_SIZE	12
-#define SPECK64_96_NROUNDS	26
-
-#define SPECK64_128_KEY_SIZE	16
-#define SPECK64_128_NROUNDS	27
+static int speck128_setkey(struct crypto_tfm *tfm, const u8 *key,
+			   unsigned int keylen)
+{
+	return crypto_speck128_setkey(crypto_tfm_ctx(tfm), key, keylen);
+}
 
-struct speck64_tfm_ctx {
-	u32 round_keys[SPECK64_128_NROUNDS];
-	int nrounds;
-};
+/* Speck64 */
 
 static __always_inline void speck64_round(u32 *x, u32 *y, u32 k)
 {
@@ -167,9 +157,9 @@ static __always_inline void speck64_unround(u32 *x, u32 *y, u32 k)
 	*x = rol32(*x, 8);
 }
 
-static void speck64_encrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
+void crypto_speck64_encrypt(const struct speck64_tfm_ctx *ctx,
+			    u8 *out, const u8 *in)
 {
-	const struct speck64_tfm_ctx *ctx = crypto_tfm_ctx(tfm);
 	u32 x = get_unaligned_le32(in + 0);
 	u32 y = get_unaligned_le32(in + 4);
 	int i;
@@ -180,10 +170,16 @@ static void speck64_encrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
 	put_unaligned_le32(x, out + 0);
 	put_unaligned_le32(y, out + 4);
 }
+EXPORT_SYMBOL_GPL(crypto_speck64_encrypt);
 
-static void speck64_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
+static void speck64_encrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
+{
+	crypto_speck64_encrypt(crypto_tfm_ctx(tfm), out, in);
+}
+
+void crypto_speck64_decrypt(const struct speck64_tfm_ctx *ctx,
+			    u8 *out, const u8 *in)
 {
-	const struct speck64_tfm_ctx *ctx = crypto_tfm_ctx(tfm);
 	u32 x = get_unaligned_le32(in + 0);
 	u32 y = get_unaligned_le32(in + 4);
 	int i;
@@ -194,11 +190,16 @@ static void speck64_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
 	put_unaligned_le32(x, out + 0);
 	put_unaligned_le32(y, out + 4);
 }
+EXPORT_SYMBOL_GPL(crypto_speck64_decrypt);
 
-static int speck64_setkey(struct crypto_tfm *tfm, const u8 *key,
+static void speck64_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
+{
+	crypto_speck64_decrypt(crypto_tfm_ctx(tfm), out, in);
+}
+
+int crypto_speck64_setkey(struct speck64_tfm_ctx *ctx, const u8 *key,
 			  unsigned int keylen)
 {
-	struct speck64_tfm_ctx *ctx = crypto_tfm_ctx(tfm);
 	u32 l[3];
 	u32 k;
 	int i;
@@ -231,6 +232,13 @@ static int speck64_setkey(struct crypto_tfm *tfm, const u8 *key,
 
 	return 0;
 }
+EXPORT_SYMBOL_GPL(crypto_speck64_setkey);
+
+static int speck64_setkey(struct crypto_tfm *tfm, const u8 *key,
+			  unsigned int keylen)
+{
+	return crypto_speck64_setkey(crypto_tfm_ctx(tfm), key, keylen);
+}
 
 /* Algorithm definitions */
 
include/crypto/speck.h new file +62 -0

62 lines not on this page · raw message

Signature · 1 line
2.16.0.rc1.238.g530d649a79-goog
#3 lore raw

PATCH 3/5 crypto: arm/speck: add NEON-accelerated implementation of Speck-XTS

In reply to Eric Biggers

Add an ARM NEON-accelerated implementation of Speck-XTS. It operates on 128-byte chunks at a time, i.e. 8 blocks for Speck128 or 16 blocks for Speck64. Each 128-byte chunk goes through XTS preprocessing, then is encrypted/decrypted (doing one cipher round for all the blocks, then the next round, etc.), then goes through XTS postprocessing.

The performance depends on the processor but generally is 2-3 times faster than the generic code. For example, on an ARMv7 processor we observe the following performance with Speck128/128-XTS:

    xts-speck128-neon:     Encryption 103.2 MB/s, Decryption 103.3 MB/s
    xts(speck128-generic): Encryption  28.9 MB/s, Decryption  37.1 MB/s

In comparison to AES-128-XTS without the cryptographic extensions:

    xts-aes-neonbs:        Encryption  50.7 MB/s, Decryption  45.4 MB/s
    xts(aes-asm):          Encryption  37.9 MB/s, Decryption  36.4 MB/s
    xts(aes-generic):      Encryption  24.7 MB/s, Decryption  24.6 MB/s

Speck64/128-XTS is even faster:

    xts-speck64-neon:      Encryption 125.5 MB/s, Decryption 126.1 MB/s

Note that as with the generic code, only the Speck128 and Speck64 variants are supported. Also, for now only the XTS mode of operation is supported, to target the disk and file encryption use cases. The NEON code also only handles the portion of the data that is evenly divisible into 128-byte chunks, with any remainder handled by a C fallback. Of course, other modes of operation could be added later if needed, and/or the NEON code could be updated to handle other buffer sizes.

The XTS specification is only defined for AES which has a 128-bit block size, so for the GF(2^64) math needed for Speck64-XTS we use the reducing polynomial 'x^64 + x^4 + x^3 + x + 1' given by the original XEX paper. Of course, when possible users should use Speck128-XTS, but even that may be too slow on some processors; Speck64-XTS can be faster.

---
 arch/arm/crypto/Kconfig           |   6 +
 arch/arm/crypto/Makefile          |   2 +
 arch/arm/crypto/speck-neon-core.S | 431 ++++++++++++++++++++++++++++++++++++++
 arch/arm/crypto/speck-neon-glue.c | 290 +++++++++++++++++++++++++
 4 files changed, 729 insertions(+)
 create mode 100644 arch/arm/crypto/speck-neon-core.S
 create mode 100644 arch/arm/crypto/speck-neon-glue.c
arch/arm/crypto/Kconfig +6 -0
index b8e69fe282b8..925d1364727a 100644
@@ -121,4 +121,10 @@ config CRYPTO_CHACHA20_NEON
 	select CRYPTO_BLKCIPHER
 	select CRYPTO_CHACHA20
 
+config CRYPTO_SPECK_NEON
+	tristate "NEON accelerated Speck cipher algorithms"
+	depends on KERNEL_MODE_NEON
+	select CRYPTO_BLKCIPHER
+	select CRYPTO_SPECK
+
 endif
arch/arm/crypto/Makefile +2 -0
index 30ef8e291271..a758107c5525 100644
@@ -10,6 +10,7 @@ obj-$(CONFIG_CRYPTO_SHA1_ARM_NEON) += sha1-arm-neon.o
 obj-$(CONFIG_CRYPTO_SHA256_ARM) += sha256-arm.o
 obj-$(CONFIG_CRYPTO_SHA512_ARM) += sha512-arm.o
 obj-$(CONFIG_CRYPTO_CHACHA20_NEON) += chacha20-neon.o
+obj-$(CONFIG_CRYPTO_SPECK_NEON) += speck-neon.o
 
 ce-obj-$(CONFIG_CRYPTO_AES_ARM_CE) += aes-arm-ce.o
 ce-obj-$(CONFIG_CRYPTO_SHA1_ARM_CE) += sha1-arm-ce.o
@@ -53,6 +54,7 @@ ghash-arm-ce-y	:= ghash-ce-core.o ghash-ce-glue.o
 crct10dif-arm-ce-y	:= crct10dif-ce-core.o crct10dif-ce-glue.o
 crc32-arm-ce-y:= crc32-ce-core.o crc32-ce-glue.o
 chacha20-neon-y := chacha20-neon-core.o chacha20-neon-glue.o
+speck-neon-y := speck-neon-core.o speck-neon-glue.o
 
 quiet_cmd_perl = PERL    $@
       cmd_perl = $(PERL) $(<) > $(@)
arch/arm/crypto/speck-neon-core.S new file +431 -0

431 lines not on this page · raw message

arch/arm/crypto/speck-neon-glue.c new file +290 -0

290 lines not on this page · raw message

Signature · 1 line
2.16.0.rc1.238.g530d649a79-goog
#4 lore raw

PATCH 4/5 crypto: speck - add test vectors for Speck128-XTS

In reply to Eric Biggers

Add test vectors for Speck128-XTS, generated in userspace using C code. The inputs were borrowed from the AES-XTS test vectors.

Both xts(speck128-generic) and xts-speck128-neon pass these tests.

---
 crypto/testmgr.c |   9 +
 crypto/testmgr.h | 687 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 696 insertions(+)
crypto/testmgr.c +9 -0
index d5be42149e29..6583c11f0f0b 100644
@@ -3575,6 +3575,15 @@ static const struct alg_test_desc alg_test_descs[] = {
 				.dec = __VECS(serpent_xts_dec_tv_template)
 			}
 		}
+	}, {
+		.alg = "xts(speck128)",
+		.test = alg_test_skcipher,
+		.suite = {
+			.cipher = {
+				.enc = __VECS(speck128_xts_enc_tv_template),
+				.dec = __VECS(speck128_xts_dec_tv_template),
+			}
+		}
 	}, {
 		.alg = "xts(twofish)",
 		.test = alg_test_skcipher,
crypto/testmgr.h +687 -0

693 lines not on this page · raw message

Signature · 1 line
2.16.0.rc1.238.g530d649a79-goog
#5 lore raw

PATCH 5/5 crypto: speck - add test vectors for Speck64-XTS

In reply to Eric Biggers

Add test vectors for Speck64-XTS, generated in userspace using C code. The inputs were borrowed from the AES-XTS test vectors, with key lengths adjusted.

xts-speck64-neon passes these tests. However, they aren't currently applicable for the generic XTS template, as that only supports a 128-bit block size.

---
 crypto/testmgr.c |   9 +
 crypto/testmgr.h | 671 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 680 insertions(+)
crypto/testmgr.c +9 -0
index 6583c11f0f0b..4b5fce3910f8 100644
@@ -3584,6 +3584,15 @@ static const struct alg_test_desc alg_test_descs[] = {
 				.dec = __VECS(speck128_xts_dec_tv_template),
 			}
 		}
+	}, {
+		.alg = "xts(speck64)",
+		.test = alg_test_skcipher,
+		.suite = {
+			.cipher = {
+				.enc = __VECS(speck64_xts_enc_tv_template),
+				.dec = __VECS(speck64_xts_dec_tv_template),
+			}
+		}
 	}, {
 		.alg = "xts(twofish)",
 		.test = alg_test_skcipher,
crypto/testmgr.h +671 -0

677 lines not on this page · raw message

Signature · 1 line
2.16.0.rc1.238.g530d649a79-goog
#6 lore raw

cover crypto: Speck support

In reply to Eric Biggers
Quoted 35 lines · Eric Biggers

Hello,

This series adds Speck support to the crypto API, including the Speck128 and Speck64 variants. Speck is a lightweight block cipher that can be much faster than AES on processors that don't have AES instructions.

We are planning to offer Speck-XTS (probably Speck128/256-XTS) as an option for dm-crypt and fscrypt on Android, for low-end mobile devices with older CPUs such as ARMv7 which don't have the Cryptography Extensions. Currently, such devices are unencrypted because AES is not fast enough, even when the NEON bit-sliced implementation of AES is used. Other AES alternatives such as Blowfish, Twofish, Camellia, Cast6, and Serpent aren't fast enough either; it seems that only a modern ARX cipher can provide sufficient performance on these devices.

This is a replacement for our original proposal
(https://patchwork.kernel.org/patch/10101451/) which was to offer ChaCha20 for these devices. However, the use of a stream cipher for disk/file encryption with no space to store nonces would have been much more insecure than we thought initially, given that it would be used on top of flash storage as well as potentially on top of F2FS, neither of which is guaranteed to overwrite data in-place.

Speck has been somewhat controversial due to its origin. Nevertheless, it has a straightforward design (it's an ARX cipher), and it appears to be the leading software-optimized lightweight block cipher currently, with the most cryptanalysis. It's also easy to implement without side channels, unlike AES. Moreover, we only intend Speck to be used when the status quo is no encryption, due to AES not being fast enough.

We've also considered a novel length-preserving encryption mode based on ChaCha20 and Poly1305. While theoretically attractive, such a mode would be a brand new crypto construction and would be more complicated and difficult to implement efficiently in comparison to Speck-XTS.

Quoted 8 lines

Thus, patch 1 adds a generic implementation of Speck, and the following patches add a 32-bit ARM NEON implementation of Speck-XTS. The NEON-accelerated implementation is much faster than the generic implementation and therefore is the implementation that would primarily be used in practice on the devices we are targeting.

There is no AArch64 implementation added, since such CPUs are likely to have the Cryptography Extensions, allowing the use of AES.

+1 on SPECK.

Its a nice cipher that runs fast. It is nice because the security engineering and parameter selection is well specified, and you can push the margins as low as you like. It does not guess at security parameters like some of the other ciphers used in dm-crypt.

On a modern Core-i5 6th gen I've seen numbers as low as ... SPECK-64/128 runs around 2.1 cpb, and SPECK-128/256 runs around 2.4 cpb.

I've already done some work for a US contractor who wanted/needed SPECK for a possible NASA contract. NASA is looking at SPECK for some satellite comms.

Jeff

#7 lore raw

cover crypto: Speck support

Quoted 52 lines · Jeffrey Walton
Quoted 35 lines · Eric Biggers

Hello,

This series adds Speck support to the crypto API, including the Speck128 and Speck64 variants. Speck is a lightweight block cipher that can be much faster than AES on processors that don't have AES instructions.

We are planning to offer Speck-XTS (probably Speck128/256-XTS) as an option for dm-crypt and fscrypt on Android, for low-end mobile devices with older CPUs such as ARMv7 which don't have the Cryptography Extensions. Currently, such devices are unencrypted because AES is not fast enough, even when the NEON bit-sliced implementation of AES is used. Other AES alternatives such as Blowfish, Twofish, Camellia, Cast6, and Serpent aren't fast enough either; it seems that only a modern ARX cipher can provide sufficient performance on these devices.

This is a replacement for our original proposal
(https://patchwork.kernel.org/patch/10101451/) which was to offer ChaCha20 for these devices. However, the use of a stream cipher for disk/file encryption with no space to store nonces would have been much more insecure than we thought initially, given that it would be used on top of flash storage as well as potentially on top of F2FS, neither of which is guaranteed to overwrite data in-place.

Speck has been somewhat controversial due to its origin. Nevertheless, it has a straightforward design (it's an ARX cipher), and it appears to be the leading software-optimized lightweight block cipher currently, with the most cryptanalysis. It's also easy to implement without side channels, unlike AES. Moreover, we only intend Speck to be used when the status quo is no encryption, due to AES not being fast enough.

We've also considered a novel length-preserving encryption mode based on ChaCha20 and Poly1305. While theoretically attractive, such a mode would be a brand new crypto construction and would be more complicated and difficult to implement efficiently in comparison to Speck-XTS.

Quoted 8 lines

Thus, patch 1 adds a generic implementation of Speck, and the following patches add a 32-bit ARM NEON implementation of Speck-XTS. The NEON-accelerated implementation is much faster than the generic implementation and therefore is the implementation that would primarily be used in practice on the devices we are targeting.

There is no AArch64 implementation added, since such CPUs are likely to have the Cryptography Extensions, allowing the use of AES.

+1 on SPECK.

Its a nice cipher that runs fast. It is nice because the security engineering and parameter selection is well specified, and you can push the margins as low as you like. It does not guess at security parameters like some of the other ciphers used in dm-crypt.

Quoted 8 lines

On a modern Core-i5 6th gen I've seen numbers as low as ... SPECK-64/128 runs around 2.1 cpb, and SPECK-128/256 runs around 2.4 cpb.

I've already done some work for a US contractor who wanted/needed SPECK for a possible NASA contract. NASA is looking at SPECK for some satellite comms.

Hi Jeffrey,

I see you wrote the SPECK implementation in Crypto++, and you are treating the words as big endian.

Do you have a reference for this being the "correct" order? Unfortunately the authors of the cipher failed to mention the byte order in their paper. And they gave the test vectors as words, so the test vectors don't clarify it either.

I had assumed little endian words, but now I am having second thoughts... And to confuse things further, it seems that some implementations (including the authors own implementation for the SUPERCOP benchmark toolkit [1]) even consider the words themselves in the order (y, x) rather than the more intuitive (x, y).

[1] https://github.com/iadgov/simon-speck-supercop/blob/master/crypto_stream/speck128128ctr/ref/stream.c

In fact, even the reference code from the paper treats pt[0] as y and pt[1] as x, where 'pt' is a u64 array -- although that being said, it's not shown how the actual bytes should be translated to/from those u64 arrays.

I'd really like to avoid people having to add additional versions of SPECK later for the different byte and word orders...

- Eric

#8 lore raw

cover crypto: Speck support

Quoted 52 lines · Eric Biggers
Quoted 31 lines · Jeffrey Walton
Quoted 30 lines · Eric Biggers

Hello,

This series adds Speck support to the crypto API, including the Speck128 and Speck64 variants. Speck is a lightweight block cipher that can be much faster than AES on processors that don't have AES instructions.

We are planning to offer Speck-XTS (probably Speck128/256-XTS) as an option for dm-crypt and fscrypt on Android, for low-end mobile devices with older CPUs such as ARMv7 which don't have the Cryptography Extensions. Currently, such devices are unencrypted because AES is not fast enough, even when the NEON bit-sliced implementation of AES is used. Other AES alternatives such as Blowfish, Twofish, Camellia, Cast6, and Serpent aren't fast enough either; it seems that only a modern ARX cipher can provide sufficient performance on these devices.

This is a replacement for our original proposal
(https://patchwork.kernel.org/patch/10101451/) which was to offer ChaCha20 for these devices. However, the use of a stream cipher for disk/file encryption with no space to store nonces would have been much more insecure than we thought initially, given that it would be used on top of flash storage as well as potentially on top of F2FS, neither of which is guaranteed to overwrite data in-place.

...
Thus, patch 1 adds a generic implementation of Speck, and the following patches add a 32-bit ARM NEON implementation of Speck-XTS. The NEON-accelerated implementation is much faster than the generic implementation and therefore is the implementation that would primarily be used in practice on the devices we are targeting.

Quoted 5 lines
Quoted 2 lines

There is no AArch64 implementation added, since such CPUs are likely to have the Cryptography Extensions, allowing the use of AES.

+1 on SPECK.
...

Hi Jeffrey,

I see you wrote the SPECK implementation in Crypto++, and you are treating the words as big endian.

Do you have a reference for this being the "correct" order? Unfortunately the authors of the cipher failed to mention the byte order in their paper. And they gave the test vectors as words, so the test vectors don't clarify it either.

I had assumed little endian words, but now I am having second thoughts... And to confuse things further, it seems that some implementations (including the authors own implementation for the SUPERCOP benchmark toolkit [1]) even consider the words themselves in the order (y, x) rather than the more intuitive (x, y).

Quoted 8 lines

[1] https://github.com/iadgov/simon-speck-supercop/blob/master/crypto_stream/speck128128ctr/ref/stream.c

In fact, even the reference code from the paper treats pt[0] as y and pt[1] as x, where 'pt' is a u64 array -- although that being said, it's not shown how the actual bytes should be translated to/from those u64 arrays.

I'd really like to avoid people having to add additional versions of SPECK later for the different byte and word orders...

Hi Eric,

Yeah, this was a point of confusion for us as well. After the sidebar conversations I am wondering about the correctness of Crypto++ implementation.

As a first step here is the official test vector for Speck-128(128) from Appendix C, p. 42 (https://eprint.iacr.org/2013/404.pdf):

    Speck128/128
    Key: 0f0e0d0c0b0a0908 0706050403020100
    Plaintext: 6c61766975716520 7469206564616d20
    Ciphertext: a65d985179783265 7860fedf5c570d18

We had some confusion over the presentation. Here is what the Simon and Speck team sent when I asked about it, what gets plugged into the algorithm, and how it gets plugged in:

<BEGIN SNIP PERSONAL EMAIL>

Quoted 50 lines · On Mon, Nov 20, 2017 at 10:50 AM, <[email protected]> wrote:

...
I'll explain the problem you have been having with our test vectors.

The key is:  0x0f0e0d0c0b0a0908 0x0706050403020100
The plaintext is:  6c61766975716520 7469206564616d20
The ciphertext is:  a65d985179783265 7860fedf5c570d18

The problem is essentially one of what goes where and we probably could have done a better job explaining things.

For the key, with two words, K=(K[1],K[0]). With three words K=(K[2],K[1],K[0]), with four words K=(K[3],K[2],K[1],K[0]).

So for the test vector you should have K[0]= 0x0706050403020100, K[1]= 0x0f0e0d0c0b0a0908 which is the opposite of what you have done.

If we put this K into ExpandKey(K,sk) then the first few round keys are:

0706050403020100
37253b31171d0309
f91d89cc90c4085c
c6b1f07852cc7689
...

For the plaintext, P=(P[1],P[0]), i.e., P[1] goes into the left word of the block cipher and P[0] goes into the right word of the block cipher. So you should have m[0]= 7469206564616d20 and m[1]= 6c61766975716520, which is again opposite of what you have. If c[0]=m[0] and c[1]=m[1], then the encrypt function should be called as
Encrypt(c+1,c+0,sk). The resulting ciphertext is (c+1,c+0).

In general, everything goes in as a byte stream (not 64-bit words). In this case, if the 16 bytes of key are 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f then we first need to turn these into two 64-bit words. The first word, K[0] is 0706050403020100 and the second word is K[1]=0f0e0d0c0b0a0908. On x86 processors, if the key bytes are in the array k[] of type uint8_t, then a simple casting should get you K[1] and K[0]. That is, K[0]=((uint64_t *)k)[0] and K[1]=((uint64_t *)k)[1]. The key expansion is run with ExpandKey(K,sk). So that was what we had in mind.

Similarly, if the plaintext "bytes" were: 20 6d 61 64 65 20 69 74 20 65 71 75 69 76 61 6c (which is ascii for " made it equival")
then we first need to turn these into two 64-bit words. The first word is pt[0]=7469206564616d20 and the second word is pt[1]= 6c61766975716520. The Encrypt routine is run as Encrypt(pt[1],pt[0],sk). The resulting ciphertext is (ct[1],ct[0]) which you would turn back into a byte stream in the reverse of what we did. For example, if ct[1]= a65d985179783265 and ct[0]= 7860fedf5c570d18, then if c[] is a byte stream (i.e., of type uint8_t), then we would have c[0]=18, c[1]=0d, c[2]=57, c[3]=5c, etc. This is easy to do on x86 with a cast.

Quoted 3 lines

Let me know if all of this is now clear.

Best regards,

<END SNIP PERSONAL EMAIL>

Finally, here is the Simon and Speck team GitHub. It is the implementation the team submitted to SUPERCOP:
https://github.com/iadgov/simon-speck-supercop . The files of interest are in crypto_stream:

* speck128128ctr/ref/stream.c
* speck128192ctr/ref/stream.c
* speck128256ctr/ref/stream.c
* speck64128ctr/ref/stream.c
* speck6496ctr/ref/stream.c

The reference implementation uses CTR mode rather then ECB mode. After the CTR -> ECB conversion (mostly trivial), and then plugging in the test vectors data (key and message), we could not arrive at the same answer as the published test vector. However, we may have been plugging things in incorrectly. We were able to arrive at test vector results after a minor modification, but it may have been the wrong thing to do (in hindsight). I'll be revisiting this shortly.

Hopefully this should get things started on sorting out the details.

Jeff

#9 lore raw

cover crypto: Speck support

Hi all,

Quoted 20 lines · Jeffrey Walton
Quoted 20 lines

Hi Jeffrey,

I see you wrote the SPECK implementation in Crypto++, and you are treating the words as big endian.

Do you have a reference for this being the "correct" order? Unfortunately the authors of the cipher failed to mention the byte order in their paper. And they gave the test vectors as words, so the test vectors don't clarify it either.

I had assumed little endian words, but now I am having second thoughts... And to confuse things further, it seems that some implementations (including the authors own implementation for the SUPERCOP benchmark toolkit [1]) even consider the words themselves in the order (y, x) rather than the more intuitive (x, y).

[1] https://github.com/iadgov/simon-speck-supercop/blob/master/crypto_stream/speck128128ctr/ref/stream.c

In fact, even the reference code from the paper treats pt[0] as y and pt[1] as x, where 'pt' is a u64 array -- although that being said, it's not shown how the actual bytes should be translated to/from those u64 arrays.

Quoted 9 lines
Quoted 2 lines

I'd really like to avoid people having to add additional versions of SPECK later for the different byte and word orders...

Hi Eric,

Yeah, this was a point of confusion for us as well. After the sidebar conversations I am wondering about the correctness of Crypto++ implementation.

We've received another response from one of the Speck creators (Louis Wingers) that (to summarize) the intended byte order is little endian, and the intended word order is (y, x), i.e. 'y' is at a lower memory address than 'x'. Or
equivalently: the test vectors given in the original paper need to be read as byte arrays from *right-to-left*.

(y, x) is not the intuitive order, but it's not a huge deal. The more important thing is that we don't end up with multiple implementations with different byte and/or word orders.

So, barring any additional confusion, I'll send a revised version of this patchset that flips the word order. Jeff would need to flip both the byte and word orders in his implementation in Crypto++ as well.

- Eric

Quoted 93 lines

As a first step here is the official test vector for Speck-128(128) from Appendix C, p. 42 (https://eprint.iacr.org/2013/404.pdf):

    Speck128/128
    Key: 0f0e0d0c0b0a0908 0706050403020100
    Plaintext: 6c61766975716520 7469206564616d20
    Ciphertext: a65d985179783265 7860fedf5c570d18

We had some confusion over the presentation. Here is what the Simon and Speck team sent when I asked about it, what gets plugged into the algorithm, and how it gets plugged in:

<BEGIN SNIP PERSONAL EMAIL>

Quoted 50 lines · On Mon, Nov 20, 2017 at 10:50 AM, <[email protected]> wrote:

...
I'll explain the problem you have been having with our test vectors.

The key is:  0x0f0e0d0c0b0a0908 0x0706050403020100
The plaintext is:  6c61766975716520 7469206564616d20
The ciphertext is:  a65d985179783265 7860fedf5c570d18

The problem is essentially one of what goes where and we probably could have done a better job explaining things.

For the key, with two words, K=(K[1],K[0]). With three words K=(K[2],K[1],K[0]), with four words K=(K[3],K[2],K[1],K[0]).

So for the test vector you should have K[0]= 0x0706050403020100, K[1]= 0x0f0e0d0c0b0a0908 which is the opposite of what you have done.

If we put this K into ExpandKey(K,sk) then the first few round keys are:

0706050403020100
37253b31171d0309
f91d89cc90c4085c
c6b1f07852cc7689
...

For the plaintext, P=(P[1],P[0]), i.e., P[1] goes into the left word of the block cipher and P[0] goes into the right word of the block cipher. So you should have m[0]= 7469206564616d20 and m[1]= 6c61766975716520, which is again opposite of what you have. If c[0]=m[0] and c[1]=m[1], then the encrypt function should be called as
Encrypt(c+1,c+0,sk). The resulting ciphertext is (c+1,c+0).

In general, everything goes in as a byte stream (not 64-bit words). In this case, if the 16 bytes of key are 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f then we first need to turn these into two 64-bit words. The first word, K[0] is 0706050403020100 and the second word is K[1]=0f0e0d0c0b0a0908. On x86 processors, if the key bytes are in the array k[] of type uint8_t, then a simple casting should get you K[1] and K[0]. That is, K[0]=((uint64_t *)k)[0] and K[1]=((uint64_t *)k)[1]. The key expansion is run with ExpandKey(K,sk). So that was what we had in mind.

Similarly, if the plaintext "bytes" were: 20 6d 61 64 65 20 69 74 20 65 71 75 69 76 61 6c (which is ascii for " made it equival")
then we first need to turn these into two 64-bit words. The first word is pt[0]=7469206564616d20 and the second word is pt[1]= 6c61766975716520. The Encrypt routine is run as Encrypt(pt[1],pt[0],sk). The resulting ciphertext is (ct[1],ct[0]) which you would turn back into a byte stream in the reverse of what we did. For example, if ct[1]= a65d985179783265 and ct[0]= 7860fedf5c570d18, then if c[] is a byte stream (i.e., of type uint8_t), then we would have c[0]=18, c[1]=0d, c[2]=57, c[3]=5c, etc. This is easy to do on x86 with a cast.

Quoted 3 lines

Let me know if all of this is now clear.

Best regards,

<END SNIP PERSONAL EMAIL>

Finally, here is the Simon and Speck team GitHub. It is the implementation the team submitted to SUPERCOP:
https://github.com/iadgov/simon-speck-supercop . The files of interest are in crypto_stream:

* speck128128ctr/ref/stream.c
* speck128192ctr/ref/stream.c
* speck128256ctr/ref/stream.c
* speck64128ctr/ref/stream.c
* speck6496ctr/ref/stream.c

The reference implementation uses CTR mode rather then ECB mode. After the CTR -> ECB conversion (mostly trivial), and then plugging in the test vectors data (key and message), we could not arrive at the same answer as the published test vector. However, we may have been plugging things in incorrectly. We were able to arrive at test vector results after a minor modification, but it may have been the wrong thing to do (in hindsight). I'll be revisiting this shortly.

Hopefully this should get things started on sorting out the details.

Jeff

#10 lore raw

cover crypto: Speck support

Quoted 39 lines · Eric Biggers

Hi all,

Quoted 20 lines · Jeffrey Walton
Quoted 20 lines

Hi Jeffrey,

I see you wrote the SPECK implementation in Crypto++, and you are treating the words as big endian.

Do you have a reference for this being the "correct" order? Unfortunately the authors of the cipher failed to mention the byte order in their paper. And they gave the test vectors as words, so the test vectors don't clarify it either.

I had assumed little endian words, but now I am having second thoughts... And to confuse things further, it seems that some implementations (including the authors own implementation for the SUPERCOP benchmark toolkit [1]) even consider the words themselves in the order (y, x) rather than the more intuitive (x, y).

[1] https://github.com/iadgov/simon-speck-supercop/blob/master/crypto_stream/speck128128ctr/ref/stream.c

In fact, even the reference code from the paper treats pt[0] as y and pt[1] as x, where 'pt' is a u64 array -- although that being said, it's not shown how the actual bytes should be translated to/from those u64 arrays.

Quoted 9 lines
Quoted 2 lines

I'd really like to avoid people having to add additional versions of SPECK later for the different byte and word orders...

Hi Eric,

Yeah, this was a point of confusion for us as well. After the sidebar conversations I am wondering about the correctness of Crypto++ implementation.

We've received another response from one of the Speck creators (Louis Wingers) that (to summarize) the intended byte order is little endian, and the intended word order is (y, x), i.e. 'y' is at a lower memory address than 'x'. Or
equivalently: the test vectors given in the original paper need to be read as byte arrays from *right-to-left*.

Quoted 7 lines

(y, x) is not the intuitive order, but it's not a huge deal. The more important thing is that we don't end up with multiple implementations with different byte and/or word orders.

So, barring any additional confusion, I'll send a revised version of this patchset that flips the word order. Jeff would need to flip both the byte and word orders in his implementation in Crypto++ as well.

Thanks Eric.

Yeah, the (y,x) explains a lot of the confusion, and explains the modification I needed in my GitHub clone of the IAD Team's SUPERCOP to arrive at test vector results. My clone is available at
https://github.com/noloader/simon-speck-supercop.

So let me ask you... Given the Speck-128(128) test vector from Appendix C:

    Key: 0f0e0d0c0b0a0908 0706050403020100
    Plaintext: 6c61766975716520 7469206564616d20
    Ciphertext: a65d985179783265 7860fedf5c570d18

Will the Linux implementation arrive at the published result, or will it arrive at a different result? I guess what I am asking, where is the presentation detail going to be handled?

A related question is, will the kernel be parsing just the key as (y,x), or will all parameters be handled as (y,x)? At this point I believe it only needs to apply to the key but I did not investigate the word swapping in detail because I was chasing the test vector.

Jeff

#11 lore raw

cover crypto: Speck support

Hi Jeff,

Quoted 61 lines · Jeffrey Walton
Quoted 39 lines · Eric Biggers

Hi all,

Quoted 20 lines · Jeffrey Walton
Quoted 20 lines

Hi Jeffrey,

I see you wrote the SPECK implementation in Crypto++, and you are treating the words as big endian.

Do you have a reference for this being the "correct" order? Unfortunately the authors of the cipher failed to mention the byte order in their paper. And they gave the test vectors as words, so the test vectors don't clarify it either.

I had assumed little endian words, but now I am having second thoughts... And to confuse things further, it seems that some implementations (including the authors own implementation for the SUPERCOP benchmark toolkit [1]) even consider the words themselves in the order (y, x) rather than the more intuitive (x, y).

[1] https://github.com/iadgov/simon-speck-supercop/blob/master/crypto_stream/speck128128ctr/ref/stream.c

In fact, even the reference code from the paper treats pt[0] as y and pt[1] as x, where 'pt' is a u64 array -- although that being said, it's not shown how the actual bytes should be translated to/from those u64 arrays.

Quoted 9 lines
Quoted 2 lines

I'd really like to avoid people having to add additional versions of SPECK later for the different byte and word orders...

Hi Eric,

Yeah, this was a point of confusion for us as well. After the sidebar conversations I am wondering about the correctness of Crypto++ implementation.

We've received another response from one of the Speck creators (Louis Wingers) that (to summarize) the intended byte order is little endian, and the intended word order is (y, x), i.e. 'y' is at a lower memory address than 'x'. Or
equivalently: the test vectors given in the original paper need to be read as byte arrays from *right-to-left*.

Quoted 7 lines

(y, x) is not the intuitive order, but it's not a huge deal. The more important thing is that we don't end up with multiple implementations with different byte and/or word orders.

So, barring any additional confusion, I'll send a revised version of this patchset that flips the word order. Jeff would need to flip both the byte and word orders in his implementation in Crypto++ as well.

Thanks Eric.

Yeah, the (y,x) explains a lot of the confusion, and explains the modification I needed in my GitHub clone of the IAD Team's SUPERCOP to arrive at test vector results. My clone is available at
https://github.com/noloader/simon-speck-supercop.

So let me ask you... Given the Speck-128(128) test vector from Appendix C:

    Key: 0f0e0d0c0b0a0908 0706050403020100
    Plaintext: 6c61766975716520 7469206564616d20
    Ciphertext: a65d985179783265 7860fedf5c570d18
Quoted 9 lines

Will the Linux implementation arrive at the published result, or will it arrive at a different result? I guess what I am asking, where is the presentation detail going to be handled?

A related question is, will the kernel be parsing just the key as (y,x), or will all parameters be handled as (y,x)? At this point I believe it only needs to apply to the key but I did not investigate the word swapping in detail because I was chasing the test vector.

The kernel implementation has to operate on byte arrays. But the test vectors in the original paper are given as *words* in the order (x, y) and likewise for the key (i.e. the rightmost word shown becomes the first round key). But based on the clarifications from the Speck team, the actual byte arrays that correspond to the Speck-128/128 test vector would be:

const uint8_t key[16] = "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"; const uint8_t plaintext[16] = "\x20\x6d\x61\x64\x65\x20\x69\x74\x20\x65\x71\x75\x69\x76\x61\x6c"; const uint8_t ciphertext[16] = "\x18\x0d\x57\x5c\xdf\xfe\x60\x78\x65\x32\x78\x79\x51\x98\x5d\xa6";

So equivalently, if we consider the printed test vectors as just listing the bytes (ignoring the whitespace between the words), then they are backwards. That applies to all 3 parts (Key, Plaintext, and Ciphertext).

Note that my patch 1/5 adds the Speck test vectors to testmgr.h so that they are hooked into the Linux kernel's crypto self-tests, so on appropriately-configured kernels it will be automatically verified that the implementation matches the test vectors. The ones in the current version of the patchset have the "wrong" word order though, so I will need to send out a new version with the correct implementation and test vectors.

Thanks,

Eric