Forward port of IGE mode. (aa6d1a0c) · Commits · CYBER - Cyber Security / TS 103 523 MSP / TLMSP / TLMSP OpenSSL

CHANGES

+3 −0

Original line number	Diff line number	Diff line
		@@ -379,6 +379,9 @@

		Changes between 0.9.8b and 0.9.8c [xx XXX xxxx]

		*) Add AES IGE and biIGE modes.
		[Ben Laurie]

		*) Change the Unix randomness entropy gathering to use poll() when
		possible instead of select(), since the latter has some
		undesirable limitations.

crypto/aes/Makefile

+4 −2

Original line number	Diff line number	Diff line
		@@ -23,8 +23,10 @@ TEST=
		APPS=

		LIB=$(TOP)/libcrypto.a
		LIBSRC=aes_core.c aes_misc.c aes_ecb.c aes_cbc.c aes_cfb.c aes_ofb.c aes_ctr.c
		LIBOBJ=aes_misc.o aes_ecb.o aes_cfb.o aes_ofb.o aes_ctr.o $(AES_ASM_OBJ)
		LIBSRC=aes_core.c aes_misc.c aes_ecb.c aes_cbc.c aes_cfb.c aes_ofb.c \
		aes_ctr.c aes_ige.c
		LIBOBJ=aes_misc.o aes_ecb.o aes_cfb.o aes_ofb.o aes_ctr.o aes_ige.o \
		$(AES_ASM_OBJ)

		SRC= $(LIBSRC)

crypto/aes/aes.h

+9 −0

Original line number	Diff line number	Diff line
		@@ -118,6 +118,15 @@ void AES_ctr128_encrypt(const unsigned char in, unsigned char out,
		unsigned char ivec[AES_BLOCK_SIZE],
		unsigned char ecount_buf[AES_BLOCK_SIZE],
		unsigned int *num);
		/* NB: the IV is _two_ blocks long */
		void AES_ige_encrypt(const unsigned char in, unsigned char out,
		const unsigned long length, const AES_KEY *key,
		unsigned char *ivec, const int enc);
		/* NB: the IV is _four_ blocks long */
		void AES_bi_ige_encrypt(const unsigned char in, unsigned char out,
		const unsigned long length, const AES_KEY *key,
		const AES_KEY key2, const unsigned char ivec,
		const int enc);


		#ifdef __cplusplus

crypto/aes/aes_ige.c

0 → 100644

+283 −0

Original line number	Diff line number	Diff line
		/* crypto/aes/aes_ige.c -- mode:C; c-file-style: "eay" -- */
		/* ====================================================================
		* Copyright (c) 2006 The OpenSSL Project. All rights reserved.
		*
		* Redistribution and use in source and binary forms, with or without
		* modification, are permitted provided that the following conditions
		* are met:
		*
		* 1. Redistributions of source code must retain the above copyright
		* notice, this list of conditions and the following disclaimer.
		*
		* 2. Redistributions in binary form must reproduce the above copyright
		* notice, this list of conditions and the following disclaimer in
		* the documentation and/or other materials provided with the
		* distribution.
		*
		* 3. All advertising materials mentioning features or use of this
		* software must display the following acknowledgment:
		* "This product includes software developed by the OpenSSL Project
		* for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
		*
		* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
		* endorse or promote products derived from this software without
		* prior written permission. For written permission, please contact
		* openssl-core@openssl.org.
		*
		* 5. Products derived from this software may not be called "OpenSSL"
		* nor may "OpenSSL" appear in their names without prior written
		* permission of the OpenSSL Project.
		*
		* 6. Redistributions of any form whatsoever must retain the following
		* acknowledgment:
		* "This product includes software developed by the OpenSSL Project
		* for use in the OpenSSL Toolkit (http://www.openssl.org/)"
		*
		* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
		* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
		* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
		* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
		* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
		* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
		* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
		* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
		* OF THE POSSIBILITY OF SUCH DAMAGE.
		* ====================================================================
		*
		*/

		#include <assert.h>

		#include <openssl/aes.h>
		#include "aes_locl.h"

		/*
		static void hexdump(FILE f,const char title,const unsigned char *s,int l)
		{
		int n=0;

		fprintf(f,"%s",title);
		for( ; n < l ; ++n)
		{
		if((n%16) == 0)
		fprintf(f,"\n%04x",n);
		fprintf(f," %02x",s[n]);
		}
		fprintf(f,"\n");
		}
		*/

		/* N.B. The IV for this mode is _twice_ the block size */

		void AES_ige_encrypt(const unsigned char in, unsigned char out,
		const unsigned long length, const AES_KEY *key,
		unsigned char *ivec, const int enc)
		{
		unsigned long n;
		unsigned long len = length;
		unsigned char tmp[AES_BLOCK_SIZE];
		unsigned char tmp2[AES_BLOCK_SIZE];
		unsigned char prev[AES_BLOCK_SIZE];
		const unsigned char *iv = ivec;
		const unsigned char *iv2 = ivec + AES_BLOCK_SIZE;

		assert(in && out && key && ivec);
		assert((AES_ENCRYPT == enc)\|\|(AES_DECRYPT == enc));
		assert((length%AES_BLOCK_SIZE) == 0);

		if (AES_ENCRYPT == enc)
		{
		/* XXX: Do a separate case for when in != out (strictly should
		check for overlap, too) */
		while (len >= AES_BLOCK_SIZE)
		{
		// hexdump(stdout, "in", in, AES_BLOCK_SIZE);
		// hexdump(stdout, "iv", iv, AES_BLOCK_SIZE);
		for(n=0 ; n < AES_BLOCK_SIZE ; ++n)
		out[n] = in[n] ^ iv[n];
		// hexdump(stdout, "in ^ iv", out, AES_BLOCK_SIZE);
		AES_encrypt(out, out, key);
		// hexdump(stdout,"enc", out, AES_BLOCK_SIZE);
		// hexdump(stdout,"iv2", iv2, AES_BLOCK_SIZE);
		for(n=0 ; n < AES_BLOCK_SIZE ; ++n)
		out[n] ^= iv2[n];
		// hexdump(stdout,"out", out, AES_BLOCK_SIZE);
		iv = out;
		memcpy(prev, in, AES_BLOCK_SIZE);
		iv2 = prev;
		len -= AES_BLOCK_SIZE;
		in += AES_BLOCK_SIZE;
		out += AES_BLOCK_SIZE;
		}
		memcpy(ivec, iv, AES_BLOCK_SIZE);
		memcpy(ivec + AES_BLOCK_SIZE, iv2, AES_BLOCK_SIZE);
		}
		else
		{
		while (len >= AES_BLOCK_SIZE)
		{
		memcpy(tmp, in, AES_BLOCK_SIZE);
		memcpy(tmp2, in, AES_BLOCK_SIZE);
		// hexdump(stdout, "in", in, AES_BLOCK_SIZE);
		// hexdump(stdout, "iv2", iv2, AES_BLOCK_SIZE);
		for(n=0 ; n < AES_BLOCK_SIZE ; ++n)
		tmp[n] ^= iv2[n];
		// hexdump(stdout, "in ^ iv2", tmp, AES_BLOCK_SIZE);
		AES_decrypt(tmp, out, key);
		// hexdump(stdout, "dec", out, AES_BLOCK_SIZE);
		// hexdump(stdout, "iv", ivec, AES_BLOCK_SIZE);
		for(n=0 ; n < AES_BLOCK_SIZE ; ++n)
		out[n] ^= ivec[n];
		// hexdump(stdout, "out", out, AES_BLOCK_SIZE);
		memcpy(ivec, tmp2, AES_BLOCK_SIZE);
		iv2 = out;
		len -= AES_BLOCK_SIZE;
		in += AES_BLOCK_SIZE;
		out += AES_BLOCK_SIZE;
		}
		memcpy(ivec + AES_BLOCK_SIZE, iv2, AES_BLOCK_SIZE);
		}
		}

		/*
		* Note that its effectively impossible to do biIGE in anything other
		* than a single pass, so no provision is made for chaining.
		*/

		/* N.B. The IV for this mode is _four times_ the block size */

		void AES_bi_ige_encrypt(const unsigned char in, unsigned char out,
		const unsigned long length, const AES_KEY *key,
		const AES_KEY key2, const unsigned char ivec,
		const int enc)
		{
		unsigned long n;
		unsigned long len = length;
		unsigned char tmp[AES_BLOCK_SIZE];
		unsigned char tmp2[AES_BLOCK_SIZE];
		unsigned char tmp3[AES_BLOCK_SIZE];
		unsigned char prev[AES_BLOCK_SIZE];
		const unsigned char *iv;
		const unsigned char *iv2;

		assert(in && out && key && ivec);
		assert((AES_ENCRYPT == enc)\|\|(AES_DECRYPT == enc));
		assert((length%AES_BLOCK_SIZE) == 0);

		if (AES_ENCRYPT == enc)
		{
		/* XXX: Do a separate case for when in != out (strictly should
		check for overlap, too) */

		/* First the forward pass */
		iv = ivec;
		iv2 = ivec + AES_BLOCK_SIZE;
		while (len >= AES_BLOCK_SIZE)
		{
		// hexdump(stdout, "in", in, AES_BLOCK_SIZE);
		// hexdump(stdout, "iv", iv, AES_BLOCK_SIZE);
		for(n=0 ; n < AES_BLOCK_SIZE ; ++n)
		out[n] = in[n] ^ iv[n];
		// hexdump(stdout, "in ^ iv", out, AES_BLOCK_SIZE);
		AES_encrypt(out, out, key);
		// hexdump(stdout,"enc", out, AES_BLOCK_SIZE);
		// hexdump(stdout,"iv2", iv2, AES_BLOCK_SIZE);
		for(n=0 ; n < AES_BLOCK_SIZE ; ++n)
		out[n] ^= iv2[n];
		// hexdump(stdout,"out", out, AES_BLOCK_SIZE);
		iv = out;
		memcpy(prev, in, AES_BLOCK_SIZE);
		iv2 = prev;
		len -= AES_BLOCK_SIZE;
		in += AES_BLOCK_SIZE;
		out += AES_BLOCK_SIZE;
		}

		/* And now backwards */
		iv = ivec + AES_BLOCK_SIZE*2;
		iv2 = ivec + AES_BLOCK_SIZE*3;
		len = length;
		while(len >= AES_BLOCK_SIZE)
		{
		out -= AES_BLOCK_SIZE;
		// hexdump(stdout, "intermediate", out, AES_BLOCK_SIZE);
		// hexdump(stdout, "iv", iv, AES_BLOCK_SIZE);
		// XXX: reduce copies by alternating between buffers
		memcpy(tmp, out, AES_BLOCK_SIZE);
		for(n=0 ; n < AES_BLOCK_SIZE ; ++n)
		out[n] ^= iv[n];
		// hexdump(stdout, "out ^ iv", out, AES_BLOCK_SIZE);
		AES_encrypt(out, out, key);
		// hexdump(stdout,"enc", out, AES_BLOCK_SIZE);
		// hexdump(stdout,"iv2", iv2, AES_BLOCK_SIZE);
		for(n=0 ; n < AES_BLOCK_SIZE ; ++n)
		out[n] ^= iv2[n];
		// hexdump(stdout,"out", out, AES_BLOCK_SIZE);
		iv = out;
		memcpy(prev, tmp, AES_BLOCK_SIZE);
		iv2 = prev;
		len -= AES_BLOCK_SIZE;
		}
		}
		else
		{
		/* First backwards */
		iv = ivec + AES_BLOCK_SIZE*2;
		iv2 = ivec + AES_BLOCK_SIZE*3;
		in += length;
		out += length;
		while (len >= AES_BLOCK_SIZE)
		{
		in -= AES_BLOCK_SIZE;
		out -= AES_BLOCK_SIZE;
		memcpy(tmp, in, AES_BLOCK_SIZE);
		memcpy(tmp2, in, AES_BLOCK_SIZE);
		// hexdump(stdout, "in", in, AES_BLOCK_SIZE);
		// hexdump(stdout, "iv2", iv2, AES_BLOCK_SIZE);
		for(n=0 ; n < AES_BLOCK_SIZE ; ++n)
		tmp[n] ^= iv2[n];
		// hexdump(stdout, "in ^ iv2", tmp, AES_BLOCK_SIZE);
		AES_decrypt(tmp, out, key);
		// hexdump(stdout, "dec", out, AES_BLOCK_SIZE);
		// hexdump(stdout, "iv", iv, AES_BLOCK_SIZE);
		for(n=0 ; n < AES_BLOCK_SIZE ; ++n)
		out[n] ^= iv[n];
		// hexdump(stdout, "out", out, AES_BLOCK_SIZE);
		memcpy(tmp3, tmp2, AES_BLOCK_SIZE);
		iv = tmp3;
		iv2 = out;
		len -= AES_BLOCK_SIZE;
		}

		/* And now forwards */
		iv = ivec;
		iv2 = ivec + AES_BLOCK_SIZE;
		len = length;
		while (len >= AES_BLOCK_SIZE)
		{
		memcpy(tmp, out, AES_BLOCK_SIZE);
		memcpy(tmp2, out, AES_BLOCK_SIZE);
		// hexdump(stdout, "intermediate", out, AES_BLOCK_SIZE);
		// hexdump(stdout, "iv2", iv2, AES_BLOCK_SIZE);
		for(n=0 ; n < AES_BLOCK_SIZE ; ++n)
		tmp[n] ^= iv2[n];
		// hexdump(stdout, "out ^ iv2", tmp, AES_BLOCK_SIZE);
		AES_decrypt(tmp, out, key);
		// hexdump(stdout, "dec", out, AES_BLOCK_SIZE);
		// hexdump(stdout, "iv", ivec, AES_BLOCK_SIZE);
		for(n=0 ; n < AES_BLOCK_SIZE ; ++n)
		out[n] ^= iv[n];
		// hexdump(stdout, "out", out, AES_BLOCK_SIZE);
		memcpy(tmp3, tmp2, AES_BLOCK_SIZE);
		iv = tmp3;
		iv2 = out;
		len -= AES_BLOCK_SIZE;
		in += AES_BLOCK_SIZE;
		out += AES_BLOCK_SIZE;
		}

		}
		}

test/Makefile

+12 −4

Original line number	Diff line number	Diff line
		@@ -59,6 +59,7 @@ SSLTEST= ssltest
		RSATEST= rsa_test
		ENGINETEST= enginetest
		EVPTEST= evp_test
		IGETEST= igetest

		TESTS= alltests

		@@ -69,7 +70,7 @@ EXE= $(BNTEST)$(EXE_EXT) $(ECTEST)$(EXE_EXT) $(ECDSATEST)$(EXE_EXT) $(ECDHTEST)
		$(MDC2TEST)$(EXE_EXT) $(RMDTEST)$(EXE_EXT) \
		$(RANDTEST)$(EXE_EXT) $(DHTEST)$(EXE_EXT) $(ENGINETEST)$(EXE_EXT) \
		$(BFTEST)$(EXE_EXT) $(CASTTEST)$(EXE_EXT) $(SSLTEST)$(EXE_EXT) $(EXPTEST)$(EXE_EXT) $(DSATEST)$(EXE_EXT) $(RSATEST)$(EXE_EXT) \
		$(EVPTEST)$(EXE_EXT)
		$(EVPTEST)$(EXE_EXT) $(IGETEST)$(EXE_EXT)

		# $(METHTEST)$(EXE_EXT)

		@@ -81,7 +82,7 @@ OBJ= $(BNTEST).o $(ECTEST).o $(ECDSATEST).o $(ECDHTEST).o $(IDEATEST).o \
		$(MDC2TEST).o $(RMDTEST).o \
		$(RANDTEST).o $(DHTEST).o $(ENGINETEST).o $(CASTTEST).o \
		$(BFTEST).o $(SSLTEST).o $(DSATEST).o $(EXPTEST).o $(RSATEST).o \
		$(EVPTEST).o
		$(EVPTEST).o $(IGETEST).o
		SRC= $(BNTEST).c $(ECTEST).c $(ECDSATEST).c $(ECDHTEST).c $(IDEATEST).c \
		$(MD2TEST).c $(MD4TEST).c $(MD5TEST).c \
		$(HMACTEST).c $(WPTEST).c \
		@@ -89,7 +90,7 @@ SRC= $(BNTEST).c $(ECTEST).c $(ECDSATEST).c $(ECDHTEST).c $(IDEATEST).c \
		$(DESTEST).c $(SHATEST).c $(SHA1TEST).c $(MDC2TEST).c $(RMDTEST).c \
		$(RANDTEST).c $(DHTEST).c $(ENGINETEST).c $(CASTTEST).c \
		$(BFTEST).c $(SSLTEST).c $(DSATEST).c $(EXPTEST).c $(RSATEST).c \
		$(EVPTEST).c
		$(EVPTEST).c $(IGETEST).c

		EXHEADER=
		HEADER= $(EXHEADER)
		@@ -131,7 +132,7 @@ alltests: \
		test_rand test_bn test_ec test_ecdsa test_ecdh \
		test_enc test_x509 test_rsa test_crl test_sid \
		test_gen test_req test_pkcs7 test_verify test_dh test_dsa \
		test_ss test_ca test_engine test_evp test_ssl test_tsa
		test_ss test_ca test_engine test_evp test_ssl test_tsa test_ige

		test_evp:
		../util/shlib_wrap.sh ./$(EVPTEST) evptests.txt
		@@ -293,6 +294,10 @@ test_tsa:
		sh ./testtsa; \
		fi

		test_ige: $(IGETEST)
		@echo "Test IGE mode"
		../util/shlib_wrap.sh ./$(IGETEST)

		lint:
		lint -DLINT $(INCLUDES) $(SRC)>fluff

		@@ -424,6 +429,9 @@ $(ECDSATEST)$(EXE_EXT): $(ECDSATEST).o $(DLIBCRYPTO)
		$(ECDHTEST)$(EXE_EXT): $(ECDHTEST).o $(DLIBCRYPTO)
		@target=$(ECDHTEST); $(BUILD_CMD)

		$(IGETEST)$(EXE_EXT): $(IGETEST).o $(DLIBCRYPTO)
		@target=$(IGETEST); $(BUILD_CMD)

		#$(AESTEST).o: $(AESTEST).c
		# $(CC) -c $(CFLAGS) -DINTERMEDIATE_VALUE_KAT -DTRACE_KAT_MCT $(AESTEST).c