From: Marco Gerards <mgerards@xs4all.nl>
To: The development of GRUB 2 <grub-devel@gnu.org>
Cc: Robert Millan <rmh@aybabtu.com>
Subject: Re: Strong Crypto Support for GRUB2
Date: Sat, 10 Nov 2007 18:20:48 +0100 [thread overview]
Message-ID: <878x56f24v.fsf@xs4all.nl> (raw)
In-Reply-To: <20070903205119.0b9a3af2.dn.tlp@gmx.net> (Simon Peter's message of "Mon, 3 Sep 2007 20:51:19 +0200")
Simon Peter <dn.tlp@gmx.net> writes:
Hi,
> attached is the correction patch, to be applied after my previously
> posted patch.
Sorry for the *very* late reply.
>> > > Wasn't the point of using enum to avoid hardcoding these
>> > > numbers? :-)
>> > Woops. I thought you guys were doing the same and that's why I did
>> > it. I reverted that (leaving NONE = 0 intact).
>> Oh, didn't notice that. Then I suppose you're better off keeping the
>> numbers.
>
> No. I only thought they were all over GRUB, but they actually aren't :)
> I removed them.
>
>> Don't forget the ChangeLog entry ;-)
>
> It's in there. :)
>
> Simon
>
> diff -u -r -x CVS -N grub2/ChangeLog grub2-new/ChangeLog
> --- grub2/ChangeLog 2007-08-29 12:39:41.000000000 +0200
> +++ grub2-new/ChangeLog 2007-09-03 20:39:28.000000000 +0200
> @@ -1,3 +1,14 @@
> +2007-09-03 Simon Peter <dn.tlp@gmx.net>
> + * disk/devmapper.c: New file.
> + * include/grub/crypto.h: New file.
> + * conf/common.rmk: Add devmapper.mod and dependency
> + declaratins. Add crypto.mod, aes.mod and rmd160.mod and dependency
> + declarations.
Please look at ChangeLog to see how we described adding modules to
this file in the part. Can you change the changelog entry
accordingly?
> + * include/grub/disk.h: Add GRUB_DISK_DEVICE_CRYPTO_ID.
That should be:
* include/grub/disk.h (grub_disk_dev_id): Add
`GRUB_DISK_DEVICE_CRYPTO_ID'.
> + * crypto/aes.c: New file.
> + * crypto/crypto.c: New file.
> + * crypto/rmd160.c: New file.
> +
> 2007-08-29 Robert Millan <rmh@aybabtu.com>
>
> Patch from Simon Peter <dn.tlp@gmx.net>:
> diff -u -r -x CVS -N grub2/crypto/aes.c grub2-new/crypto/aes.c
Can you add -p in the future? :-)
> --- grub2/crypto/aes.c 2007-09-03 20:40:37.000000000 +0200
> +++ grub2-new/crypto/aes.c 2007-09-03 20:25:06.000000000 +0200
There is no copyright header. Did you write this file? What comes
from another source?
> @@ -42,9 +42,9 @@
> */
> typedef struct
> {
> - unsigned long erk[64]; /*!< encryption round keys */
> - unsigned long drk[64]; /*!< decryption round keys */
> - int nr; /*!< number of rounds */
> + unsigned long erk[64]; /*!< encryption round keys */
> + unsigned long drk[64]; /*!< decryption round keys */
> + int nr; /*!< number of rounds */
> }
> aes_context;
Is this a patch for a patch? Can you send in a completely new patch
as this is hard to review this way? I skipped most code in this
review because of that.
I will try to review this patch anyways, but a sane review won't be
possible without a patch to current CVS.
Please do not use doxygen (or whatever) comments. Please start with a
capital letter in comments and end with a "." followed by two spaces
before ending with "/*" or before starting a new line.
> @@ -90,16 +90,16 @@
> /*
> * Forward S-box & tables
> */
> -static uint8 FSb[256];
> -static uint32 FT0[256];
> -static uint32 FT1[256];
> -static uint32 FT2[256];
> -static uint32 FT3[256];
> +static uint8 FSb[256];
> +static uint32 FT0[256];
> +static uint32 FT1[256];
> +static uint32 FT2[256];
> +static uint32 FT3[256];
Please use grub_uint32_t.
> /*
> * Reverse S-box & tables
> */
> -static uint8 RSb[256];
> +static uint8 RSb[256];
> static uint32 RT0[256];
> static uint32 RT1[256];
> static uint32 RT2[256];
> @@ -118,80 +118,83 @@
> #define XTIME(x) ( ( x << 1 ) ^ ( ( x & 0x80 ) ? 0x1B : 0x00 ) )
> #define MUL(x,y) ( ( x && y ) ? pow[(log[x] + log[y]) % 255] : 0 )
>
> -static void aes_gen_tables( void )
> +static void
> +aes_gen_tables (void)
> {
> - int i;
> - uint8 x, y;
> - uint8 pow[256];
> - uint8 log[256];
> -
> - /*
> - * compute pow and log tables over GF(2^8)
> - */
> - for( i = 0, x = 1; i < 256; i++, x ^= XTIME( x ) )
> + int i;
> + uint8 x, y;
> + uint8 pow[256];
> + uint8 log[256];
> +
> + /*
> + * compute pow and log tables over GF(2^8)
> + */
> + for (i = 0, x = 1; i < 256; i++, x ^= XTIME (x))
> {
> - pow[i] = x;
> - log[x] = i;
> + pow[i] = x;
> + log[x] = i;
> }
>
> - /*
> - * calculate the round constants
> - */
> - for( i = 0, x = 1; i < 10; i++, x = XTIME( x ) )
> + /*
> + * calculate the round constants
> + */
> + for (i = 0, x = 1; i < 10; i++, x = XTIME (x))
> {
> - RCON[i] = (uint32) x << 24;
> + RCON[i] = (uint32) x << 24;
> }
>
> - /*
> - * generate the forward and reverse S-boxes
> - */
> - FSb[0x00] = 0x63;
> - RSb[0x63] = 0x00;
> + /*
> + * generate the forward and reverse S-boxes
> + */
> + FSb[0x00] = 0x63;
> + RSb[0x63] = 0x00;
>
> - for( i = 1; i < 256; i++ )
> + for (i = 1; i < 256; i++)
> {
> - x = pow[255 - log[i]];
> + x = pow[255 - log[i]];
>
> - y = x; y = ( y << 1 ) | ( y >> 7 );
> - x ^= y; y = ( y << 1 ) | ( y >> 7 );
> - x ^= y; y = ( y << 1 ) | ( y >> 7 );
> - x ^= y; y = ( y << 1 ) | ( y >> 7 );
> - x ^= y ^ 0x63;
> + y = x;
> + y = (y << 1) | (y >> 7);
> + x ^= y;
> + y = (y << 1) | (y >> 7);
> + x ^= y;
> + y = (y << 1) | (y >> 7);
> + x ^= y;
> + y = (y << 1) | (y >> 7);
> + x ^= y ^ 0x63;
>
> - FSb[i] = x;
> - RSb[x] = i;
> + FSb[i] = x;
> + RSb[x] = i;
> }
>
> - /*
> - * generate the forward and reverse tables
> - */
> - for( i = 0; i < 256; i++ )
> + /*
> + * generate the forward and reverse tables
> + */
> + for (i = 0; i < 256; i++)
> {
> - x = FSb[i]; y = XTIME( x );
> + x = FSb[i];
> + y = XTIME (x);
>
> - FT0[i] = (uint32) ( x ^ y ) ^
> - ( (uint32) x << 8 ) ^
> - ( (uint32) x << 16 ) ^
> - ( (uint32) y << 24 );
> + FT0[i] = (uint32) (x ^ y) ^
> + ((uint32) x << 8) ^ ((uint32) x << 16) ^ ((uint32) y << 24);
>
> - FT0[i] &= 0xFFFFFFFF;
> + FT0[i] &= 0xFFFFFFFF;
>
> - FT1[i] = ROTR8( FT0[i] );
> - FT2[i] = ROTR8( FT1[i] );
> - FT3[i] = ROTR8( FT2[i] );
> + FT1[i] = ROTR8 (FT0[i]);
> + FT2[i] = ROTR8 (FT1[i]);
> + FT3[i] = ROTR8 (FT2[i]);
>
> - y = RSb[i];
> + y = RSb[i];
>
> - RT0[i] = ( (uint32) MUL( 0x0B, y ) ) ^
> - ( (uint32) MUL( 0x0D, y ) << 8 ) ^
> - ( (uint32) MUL( 0x09, y ) << 16 ) ^
> - ( (uint32) MUL( 0x0E, y ) << 24 );
> + RT0[i] = ((uint32) MUL (0x0B, y)) ^
> + ((uint32) MUL (0x0D, y) << 8) ^
> + ((uint32) MUL (0x09, y) << 16) ^ ((uint32) MUL (0x0E, y) << 24);
>
> - RT0[i] &= 0xFFFFFFFF;
> + RT0[i] &= 0xFFFFFFFF;
>
> - RT1[i] = ROTR8( RT0[i] );
> - RT2[i] = ROTR8( RT1[i] );
> - RT3[i] = ROTR8( RT2[i] );
> + RT1[i] = ROTR8 (RT0[i]);
> + RT2[i] = ROTR8 (RT1[i]);
> + RT3[i] = ROTR8 (RT2[i]);
> }
> }
>
> @@ -199,45 +202,51 @@
>
> /*
> * Forward S-box
> + *
> + * See Figure 7 of FIPS PUB 197. This array is generated by
> + * the algorithm described in Section 5.1.1 of FIPS PUB 197.
> */
> -static const uint8 FSb[256] =
> -{
> - 0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5,
> - 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
> - 0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0,
> - 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
> - 0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC,
> - 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
> - 0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A,
> - 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
> - 0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0,
> - 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
> - 0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B,
> - 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
> - 0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85,
> - 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
> - 0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5,
> - 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
> - 0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17,
> - 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
> - 0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88,
> - 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
> - 0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C,
> - 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
> - 0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9,
> - 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
> - 0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6,
> - 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
> - 0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E,
> - 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
> - 0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94,
> - 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
> - 0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68,
> - 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16
> +static const uint8 FSb[256] = {
> + 0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5,
> + 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
> + 0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0,
> + 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
> + 0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC,
> + 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
> + 0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A,
> + 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
> + 0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0,
> + 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
> + 0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B,
> + 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
> + 0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85,
> + 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
> + 0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5,
> + 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
> + 0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17,
> + 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
> + 0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88,
> + 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
> + 0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C,
> + 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
> + 0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9,
> + 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
> + 0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6,
> + 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
> + 0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E,
> + 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
> + 0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94,
> + 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
> + 0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68,
> + 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16
> };
>
> /*
> * Forward tables
> + *
> + * These are optimization tables, as described for example in:
> + * http://en.wikipedia.org/wiki/Advanced_Encryption_Standard
> + * Section "Optimization of the Cipher".
> */
> #define FT \
> \
> @@ -308,63 +317,73 @@
>
> #define V(a,b,c,d) 0x##a##b##c##d
> static const uint32 FT0[256] = { FT };
> +
> #undef V
>
> #define V(a,b,c,d) 0x##d##a##b##c
> static const uint32 FT1[256] = { FT };
> +
> #undef V
>
> #define V(a,b,c,d) 0x##c##d##a##b
> static const uint32 FT2[256] = { FT };
> +
> #undef V
>
> #define V(a,b,c,d) 0x##b##c##d##a
> static const uint32 FT3[256] = { FT };
> +
> #undef V
>
> #undef FT
>
> /*
> * Reverse S-box
> + *
> + * See Figure 14 of FIPS PUB 197. This array is generated by
> + * the algorithm described in Section 5.3.2 of FIPS PUB 197.
> */
> -static const uint8 RSb[256] =
> -{
> - 0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38,
> - 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
> - 0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87,
> - 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
> - 0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D,
> - 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
> - 0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2,
> - 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
> - 0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16,
> - 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
> - 0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA,
> - 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
> - 0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A,
> - 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
> - 0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02,
> - 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
> - 0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA,
> - 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
> - 0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85,
> - 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
> - 0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89,
> - 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
> - 0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20,
> - 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
> - 0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31,
> - 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
> - 0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D,
> - 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
> - 0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0,
> - 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
> - 0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26,
> - 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D
> +static const uint8 RSb[256] = {
> + 0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38,
> + 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
> + 0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87,
> + 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
> + 0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D,
> + 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
> + 0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2,
> + 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
> + 0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16,
> + 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
> + 0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA,
> + 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
> + 0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A,
> + 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
> + 0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02,
> + 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
> + 0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA,
> + 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
> + 0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85,
> + 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
> + 0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89,
> + 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
> + 0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20,
> + 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
> + 0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31,
> + 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
> + 0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D,
> + 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
> + 0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0,
> + 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
> + 0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26,
> + 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D
> };
>
> /*
> * Reverse tables
> + *
> + * These are optimization tables, as described for example in:
> + * http://en.wikipedia.org/wiki/Advanced_Encryption_Standard
> + * Section "Optimization of the Cipher".
> */
> #define RT \
> \
> @@ -435,18 +454,22 @@
>
> #define V(a,b,c,d) 0x##a##b##c##d
> static const uint32 RT0[256] = { RT };
> +
> #undef V
>
> #define V(a,b,c,d) 0x##d##a##b##c
> static const uint32 RT1[256] = { RT };
> +
> #undef V
>
> #define V(a,b,c,d) 0x##c##d##a##b
> static const uint32 RT2[256] = { RT };
> +
> #undef V
>
> #define V(a,b,c,d) 0x##b##c##d##a
> static const uint32 RT3[256] = { RT };
> +
> #undef V
>
> #undef RT
> @@ -454,14 +477,16 @@
> /*
> * Round constants
> */
> -static const uint32 RCON[10] =
> -{
> - 0x01000000, 0x02000000, 0x04000000, 0x08000000,
> - 0x10000000, 0x20000000, 0x40000000, 0x80000000,
> - 0x1B000000, 0x36000000
> +static const uint32 RCON[10] = {
> + 0x01000000, 0x02000000, 0x04000000, 0x08000000,
> + 0x10000000, 0x20000000, 0x40000000, 0x80000000,
> + 0x1B000000, 0x36000000
> };
>
> -static void aes_gen_tables( void ) {}
> +static void
> +aes_gen_tables (void)
> +{
> +}
>
> #endif
>
> @@ -476,176 +501,184 @@
> /*
> * AES key schedule
> */
> -static void aes_set_key( aes_context *ctx, const uint8 *key, int keysize )
> +static void
> +aes_set_key (aes_context * ctx, const uint8 * key, int keysize)
> {
> - int i;
> - uint32 *RK, *SK;
> - static int ft_init = 0;
> - static int kt_init = 0;
> + int i;
> + uint32 *RK, *SK;
> + static int ft_init = 0;
> + static int kt_init = 0;
>
> - if( ft_init == 0 )
> + if (ft_init == 0)
> {
> - aes_gen_tables();
> + aes_gen_tables ();
>
> - ft_init = 1;
> + ft_init = 1;
> }
>
> - switch( keysize )
> + switch (keysize)
> {
> - case 128: ctx->nr = 10; break;
> - case 192: ctx->nr = 12; break;
> - case 256: ctx->nr = 14; break;
> - default : return;
> + case 128:
> + ctx->nr = 10;
> + break;
> + case 192:
> + ctx->nr = 12;
> + break;
> + case 256:
> + ctx->nr = 14;
> + break;
> + default:
> + return;
> }
>
> - RK = ctx->erk;
> + RK = ctx->erk;
>
> - for( i = 0; i < (keysize >> 5); i++ )
> + for (i = 0; i < (keysize >> 5); i++)
> {
> - GET_UINT32_BE( RK[i], key, i << 2 );
> + GET_UINT32_BE (RK[i], key, i << 2);
> }
>
> - /*
> - * setup encryption round keys
> - */
> - switch( ctx->nr )
> + /*
> + * setup encryption round keys
> + */
> + switch (ctx->nr)
> {
> case 10:
>
> - for( i = 0; i < 10; i++, RK += 4 )
> - {
> - RK[4] = RK[0] ^ RCON[i] ^
> - ( FSb[ (uint8) ( RK[3] >> 16 ) ] << 24 ) ^
> - ( FSb[ (uint8) ( RK[3] >> 8 ) ] << 16 ) ^
> - ( FSb[ (uint8) ( RK[3] ) ] << 8 ) ^
> - ( FSb[ (uint8) ( RK[3] >> 24 ) ] );
> -
> - RK[5] = RK[1] ^ RK[4];
> - RK[6] = RK[2] ^ RK[5];
> - RK[7] = RK[3] ^ RK[6];
> - }
> - break;
> + for (i = 0; i < 10; i++, RK += 4)
> + {
> + RK[4] = RK[0] ^ RCON[i] ^
> + (FSb[(uint8) (RK[3] >> 16)] << 24) ^
> + (FSb[(uint8) (RK[3] >> 8)] << 16) ^
> + (FSb[(uint8) (RK[3])] << 8) ^ (FSb[(uint8) (RK[3] >> 24)]);
> +
> + RK[5] = RK[1] ^ RK[4];
> + RK[6] = RK[2] ^ RK[5];
> + RK[7] = RK[3] ^ RK[6];
> + }
> + break;
>
> case 12:
>
> - for( i = 0; i < 8; i++, RK += 6 )
> - {
> - RK[6] = RK[0] ^ RCON[i] ^
> - ( FSb[ (uint8) ( RK[5] >> 16 ) ] << 24 ) ^
> - ( FSb[ (uint8) ( RK[5] >> 8 ) ] << 16 ) ^
> - ( FSb[ (uint8) ( RK[5] ) ] << 8 ) ^
> - ( FSb[ (uint8) ( RK[5] >> 24 ) ] );
> -
> - RK[7] = RK[1] ^ RK[6];
> - RK[8] = RK[2] ^ RK[7];
> - RK[9] = RK[3] ^ RK[8];
> - RK[10] = RK[4] ^ RK[9];
> - RK[11] = RK[5] ^ RK[10];
> - }
> - break;
> + for (i = 0; i < 8; i++, RK += 6)
> + {
> + RK[6] = RK[0] ^ RCON[i] ^
> + (FSb[(uint8) (RK[5] >> 16)] << 24) ^
> + (FSb[(uint8) (RK[5] >> 8)] << 16) ^
> + (FSb[(uint8) (RK[5])] << 8) ^ (FSb[(uint8) (RK[5] >> 24)]);
> +
> + RK[7] = RK[1] ^ RK[6];
> + RK[8] = RK[2] ^ RK[7];
> + RK[9] = RK[3] ^ RK[8];
> + RK[10] = RK[4] ^ RK[9];
> + RK[11] = RK[5] ^ RK[10];
> + }
> + break;
>
> case 14:
>
> - for( i = 0; i < 7; i++, RK += 8 )
> - {
> - RK[8] = RK[0] ^ RCON[i] ^
> - ( FSb[ (uint8) ( RK[7] >> 16 ) ] << 24 ) ^
> - ( FSb[ (uint8) ( RK[7] >> 8 ) ] << 16 ) ^
> - ( FSb[ (uint8) ( RK[7] ) ] << 8 ) ^
> - ( FSb[ (uint8) ( RK[7] >> 24 ) ] );
> -
> - RK[9] = RK[1] ^ RK[8];
> - RK[10] = RK[2] ^ RK[9];
> - RK[11] = RK[3] ^ RK[10];
> -
> - RK[12] = RK[4] ^
> - ( FSb[ (uint8) ( RK[11] >> 24 ) ] << 24 ) ^
> - ( FSb[ (uint8) ( RK[11] >> 16 ) ] << 16 ) ^
> - ( FSb[ (uint8) ( RK[11] >> 8 ) ] << 8 ) ^
> - ( FSb[ (uint8) ( RK[11] ) ] );
> -
> - RK[13] = RK[5] ^ RK[12];
> - RK[14] = RK[6] ^ RK[13];
> - RK[15] = RK[7] ^ RK[14];
> - }
> - break;
> + for (i = 0; i < 7; i++, RK += 8)
> + {
> + RK[8] = RK[0] ^ RCON[i] ^
> + (FSb[(uint8) (RK[7] >> 16)] << 24) ^
> + (FSb[(uint8) (RK[7] >> 8)] << 16) ^
> + (FSb[(uint8) (RK[7])] << 8) ^ (FSb[(uint8) (RK[7] >> 24)]);
> +
> + RK[9] = RK[1] ^ RK[8];
> + RK[10] = RK[2] ^ RK[9];
> + RK[11] = RK[3] ^ RK[10];
> +
> + RK[12] = RK[4] ^
> + (FSb[(uint8) (RK[11] >> 24)] << 24) ^
> + (FSb[(uint8) (RK[11] >> 16)] << 16) ^
> + (FSb[(uint8) (RK[11] >> 8)] << 8) ^ (FSb[(uint8) (RK[11])]);
> +
> + RK[13] = RK[5] ^ RK[12];
> + RK[14] = RK[6] ^ RK[13];
> + RK[15] = RK[7] ^ RK[14];
> + }
> + break;
>
> default:
>
> - break;
> + break;
> }
>
> - /*
> - * setup decryption round keys
> - */
> - if( kt_init == 0 )
> + /*
> + * setup decryption round keys
> + */
> + if (kt_init == 0)
> {
> - for( i = 0; i < 256; i++ )
> - {
> - KT0[i] = RT0[ FSb[i] ];
> - KT1[i] = RT1[ FSb[i] ];
> - KT2[i] = RT2[ FSb[i] ];
> - KT3[i] = RT3[ FSb[i] ];
> - }
> + for (i = 0; i < 256; i++)
> + {
> + KT0[i] = RT0[FSb[i]];
> + KT1[i] = RT1[FSb[i]];
> + KT2[i] = RT2[FSb[i]];
> + KT3[i] = RT3[FSb[i]];
> + }
>
> - kt_init = 1;
> + kt_init = 1;
> }
>
> - SK = ctx->drk;
> + SK = ctx->drk;
>
> - *SK++ = *RK++;
> - *SK++ = *RK++;
> - *SK++ = *RK++;
> - *SK++ = *RK++;
> + *SK++ = *RK++;
> + *SK++ = *RK++;
> + *SK++ = *RK++;
> + *SK++ = *RK++;
>
> - for( i = 1; i < ctx->nr; i++ )
> + for (i = 1; i < ctx->nr; i++)
> {
> - RK -= 8;
> -
> - *SK++ = KT0[ (uint8) ( *RK >> 24 ) ] ^
> - KT1[ (uint8) ( *RK >> 16 ) ] ^
> - KT2[ (uint8) ( *RK >> 8 ) ] ^
> - KT3[ (uint8) ( *RK ) ]; RK++;
> -
> - *SK++ = KT0[ (uint8) ( *RK >> 24 ) ] ^
> - KT1[ (uint8) ( *RK >> 16 ) ] ^
> - KT2[ (uint8) ( *RK >> 8 ) ] ^
> - KT3[ (uint8) ( *RK ) ]; RK++;
> + RK -= 8;
>
> - *SK++ = KT0[ (uint8) ( *RK >> 24 ) ] ^
> - KT1[ (uint8) ( *RK >> 16 ) ] ^
> - KT2[ (uint8) ( *RK >> 8 ) ] ^
> - KT3[ (uint8) ( *RK ) ]; RK++;
> -
> - *SK++ = KT0[ (uint8) ( *RK >> 24 ) ] ^
> - KT1[ (uint8) ( *RK >> 16 ) ] ^
> - KT2[ (uint8) ( *RK >> 8 ) ] ^
> - KT3[ (uint8) ( *RK ) ]; RK++;
> + *SK++ = KT0[(uint8) (*RK >> 24)] ^
> + KT1[(uint8) (*RK >> 16)] ^
> + KT2[(uint8) (*RK >> 8)] ^ KT3[(uint8) (*RK)];
> + RK++;
> +
> + *SK++ = KT0[(uint8) (*RK >> 24)] ^
> + KT1[(uint8) (*RK >> 16)] ^
> + KT2[(uint8) (*RK >> 8)] ^ KT3[(uint8) (*RK)];
> + RK++;
> +
> + *SK++ = KT0[(uint8) (*RK >> 24)] ^
> + KT1[(uint8) (*RK >> 16)] ^
> + KT2[(uint8) (*RK >> 8)] ^ KT3[(uint8) (*RK)];
> + RK++;
> +
> + *SK++ = KT0[(uint8) (*RK >> 24)] ^
> + KT1[(uint8) (*RK >> 16)] ^
> + KT2[(uint8) (*RK >> 8)] ^ KT3[(uint8) (*RK)];
> + RK++;
> }
>
> - RK -= 8;
> + RK -= 8;
>
> - *SK++ = *RK++;
> - *SK++ = *RK++;
> - *SK++ = *RK++;
> - *SK++ = *RK++;
> + *SK++ = *RK++;
> + *SK++ = *RK++;
> + *SK++ = *RK++;
> + *SK++ = *RK++;
> }
>
> /**
> * AES block encryption (ECB mode)
> */
> -static void aes_encrypt( aes_context *ctx,
> - unsigned char input[16],
> - unsigned char output[16] )
> -{
> - uint32 *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3;
> -
> - RK = ctx->erk;
> -
> - GET_UINT32_BE( X0, input, 0 ); X0 ^= RK[0];
> - GET_UINT32_BE( X1, input, 4 ); X1 ^= RK[1];
> - GET_UINT32_BE( X2, input, 8 ); X2 ^= RK[2];
> - GET_UINT32_BE( X3, input, 12 ); X3 ^= RK[3];
> +static void
> +aes_encrypt (aes_context * ctx,
> + unsigned char input[16], unsigned char output[16])
> +{
> + uint32 *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3;
> +
> + RK = ctx->erk;
> +
> + GET_UINT32_BE (X0, input, 0);
> + X0 ^= RK[0];
> + GET_UINT32_BE (X1, input, 4);
> + X1 ^= RK[1];
> + GET_UINT32_BE (X2, input, 8);
> + X2 ^= RK[2];
> + GET_UINT32_BE (X3, input, 12);
> + X3 ^= RK[3];
>
> #define AES_FROUND(X0,X1,X2,X3,Y0,Y1,Y2,Y3) \
> { \
> @@ -672,71 +705,71 @@
> FT3[ (uint8) ( Y2 ) ]; \
> }
>
> - AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
> - AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
> - AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
> - AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
> - AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
> - AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
> - AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
> - AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
> - AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
> -
> - if( ctx->nr > 10 )
> - {
> - AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
> - AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
> - }
> -
> - if( ctx->nr > 12 )
> - {
> - AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
> - AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
> - }
> -
> - RK += 4;
> -
> - X0 = RK[0] ^ ( FSb[ (uint8) ( Y0 >> 24 ) ] << 24 ) ^
> - ( FSb[ (uint8) ( Y1 >> 16 ) ] << 16 ) ^
> - ( FSb[ (uint8) ( Y2 >> 8 ) ] << 8 ) ^
> - ( FSb[ (uint8) ( Y3 ) ] );
> -
> - X1 = RK[1] ^ ( FSb[ (uint8) ( Y1 >> 24 ) ] << 24 ) ^
> - ( FSb[ (uint8) ( Y2 >> 16 ) ] << 16 ) ^
> - ( FSb[ (uint8) ( Y3 >> 8 ) ] << 8 ) ^
> - ( FSb[ (uint8) ( Y0 ) ] );
> -
> - X2 = RK[2] ^ ( FSb[ (uint8) ( Y2 >> 24 ) ] << 24 ) ^
> - ( FSb[ (uint8) ( Y3 >> 16 ) ] << 16 ) ^
> - ( FSb[ (uint8) ( Y0 >> 8 ) ] << 8 ) ^
> - ( FSb[ (uint8) ( Y1 ) ] );
> -
> - X3 = RK[3] ^ ( FSb[ (uint8) ( Y3 >> 24 ) ] << 24 ) ^
> - ( FSb[ (uint8) ( Y0 >> 16 ) ] << 16 ) ^
> - ( FSb[ (uint8) ( Y1 >> 8 ) ] << 8 ) ^
> - ( FSb[ (uint8) ( Y2 ) ] );
> -
> - PUT_UINT32_BE( X0, output, 0 );
> - PUT_UINT32_BE( X1, output, 4 );
> - PUT_UINT32_BE( X2, output, 8 );
> - PUT_UINT32_BE( X3, output, 12 );
> + AES_FROUND (Y0, Y1, Y2, Y3, X0, X1, X2, X3);
> + AES_FROUND (X0, X1, X2, X3, Y0, Y1, Y2, Y3);
> + AES_FROUND (Y0, Y1, Y2, Y3, X0, X1, X2, X3);
> + AES_FROUND (X0, X1, X2, X3, Y0, Y1, Y2, Y3);
> + AES_FROUND (Y0, Y1, Y2, Y3, X0, X1, X2, X3);
> + AES_FROUND (X0, X1, X2, X3, Y0, Y1, Y2, Y3);
> + AES_FROUND (Y0, Y1, Y2, Y3, X0, X1, X2, X3);
> + AES_FROUND (X0, X1, X2, X3, Y0, Y1, Y2, Y3);
> + AES_FROUND (Y0, Y1, Y2, Y3, X0, X1, X2, X3);
> +
> + if (ctx->nr > 10)
> + {
> + AES_FROUND (X0, X1, X2, X3, Y0, Y1, Y2, Y3);
> + AES_FROUND (Y0, Y1, Y2, Y3, X0, X1, X2, X3);
> + }
> +
> + if (ctx->nr > 12)
> + {
> + AES_FROUND (X0, X1, X2, X3, Y0, Y1, Y2, Y3);
> + AES_FROUND (Y0, Y1, Y2, Y3, X0, X1, X2, X3);
> + }
> +
> + RK += 4;
> +
> + X0 = RK[0] ^ (FSb[(uint8) (Y0 >> 24)] << 24) ^
> + (FSb[(uint8) (Y1 >> 16)] << 16) ^
> + (FSb[(uint8) (Y2 >> 8)] << 8) ^ (FSb[(uint8) (Y3)]);
> +
> + X1 = RK[1] ^ (FSb[(uint8) (Y1 >> 24)] << 24) ^
> + (FSb[(uint8) (Y2 >> 16)] << 16) ^
> + (FSb[(uint8) (Y3 >> 8)] << 8) ^ (FSb[(uint8) (Y0)]);
> +
> + X2 = RK[2] ^ (FSb[(uint8) (Y2 >> 24)] << 24) ^
> + (FSb[(uint8) (Y3 >> 16)] << 16) ^
> + (FSb[(uint8) (Y0 >> 8)] << 8) ^ (FSb[(uint8) (Y1)]);
> +
> + X3 = RK[3] ^ (FSb[(uint8) (Y3 >> 24)] << 24) ^
> + (FSb[(uint8) (Y0 >> 16)] << 16) ^
> + (FSb[(uint8) (Y1 >> 8)] << 8) ^ (FSb[(uint8) (Y2)]);
> +
> + PUT_UINT32_BE (X0, output, 0);
> + PUT_UINT32_BE (X1, output, 4);
> + PUT_UINT32_BE (X2, output, 8);
> + PUT_UINT32_BE (X3, output, 12);
> }
>
> /*
> * AES block decryption (ECB mode)
> */
> -static void aes_decrypt( aes_context *ctx,
> - unsigned char input[16],
> - unsigned char output[16] )
> -{
> - uint32 *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3;
> -
> - RK = ctx->drk;
> -
> - GET_UINT32_BE( X0, input, 0 ); X0 ^= RK[0];
> - GET_UINT32_BE( X1, input, 4 ); X1 ^= RK[1];
> - GET_UINT32_BE( X2, input, 8 ); X2 ^= RK[2];
> - GET_UINT32_BE( X3, input, 12 ); X3 ^= RK[3];
> +static void
> +aes_decrypt (aes_context * ctx,
> + unsigned char input[16], unsigned char output[16])
> +{
> + uint32 *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3;
> +
> + RK = ctx->drk;
> +
> + GET_UINT32_BE (X0, input, 0);
> + X0 ^= RK[0];
> + GET_UINT32_BE (X1, input, 4);
> + X1 ^= RK[1];
> + GET_UINT32_BE (X2, input, 8);
> + X2 ^= RK[2];
> + GET_UINT32_BE (X3, input, 12);
> + X3 ^= RK[3];
>
> #define AES_RROUND(X0,X1,X2,X3,Y0,Y1,Y2,Y3) \
> { \
> @@ -763,106 +796,100 @@
> RT3[ (uint8) ( Y0 ) ]; \
> }
>
> - AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
> - AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
> - AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
> - AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
> - AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
> - AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
> - AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
> - AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
> - AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
> -
> - if( ctx->nr > 10 )
> - {
> - AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
> - AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
> - }
> -
> - if( ctx->nr > 12 )
> - {
> - AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
> - AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
> - }
> -
> - RK += 4;
> -
> - X0 = RK[0] ^ ( RSb[ (uint8) ( Y0 >> 24 ) ] << 24 ) ^
> - ( RSb[ (uint8) ( Y3 >> 16 ) ] << 16 ) ^
> - ( RSb[ (uint8) ( Y2 >> 8 ) ] << 8 ) ^
> - ( RSb[ (uint8) ( Y1 ) ] );
> -
> - X1 = RK[1] ^ ( RSb[ (uint8) ( Y1 >> 24 ) ] << 24 ) ^
> - ( RSb[ (uint8) ( Y0 >> 16 ) ] << 16 ) ^
> - ( RSb[ (uint8) ( Y3 >> 8 ) ] << 8 ) ^
> - ( RSb[ (uint8) ( Y2 ) ] );
> -
> - X2 = RK[2] ^ ( RSb[ (uint8) ( Y2 >> 24 ) ] << 24 ) ^
> - ( RSb[ (uint8) ( Y1 >> 16 ) ] << 16 ) ^
> - ( RSb[ (uint8) ( Y0 >> 8 ) ] << 8 ) ^
> - ( RSb[ (uint8) ( Y3 ) ] );
> -
> - X3 = RK[3] ^ ( RSb[ (uint8) ( Y3 >> 24 ) ] << 24 ) ^
> - ( RSb[ (uint8) ( Y2 >> 16 ) ] << 16 ) ^
> - ( RSb[ (uint8) ( Y1 >> 8 ) ] << 8 ) ^
> - ( RSb[ (uint8) ( Y0 ) ] );
> -
> - PUT_UINT32_BE( X0, output, 0 );
> - PUT_UINT32_BE( X1, output, 4 );
> - PUT_UINT32_BE( X2, output, 8 );
> - PUT_UINT32_BE( X3, output, 12 );
> + AES_RROUND (Y0, Y1, Y2, Y3, X0, X1, X2, X3);
> + AES_RROUND (X0, X1, X2, X3, Y0, Y1, Y2, Y3);
> + AES_RROUND (Y0, Y1, Y2, Y3, X0, X1, X2, X3);
> + AES_RROUND (X0, X1, X2, X3, Y0, Y1, Y2, Y3);
> + AES_RROUND (Y0, Y1, Y2, Y3, X0, X1, X2, X3);
> + AES_RROUND (X0, X1, X2, X3, Y0, Y1, Y2, Y3);
> + AES_RROUND (Y0, Y1, Y2, Y3, X0, X1, X2, X3);
> + AES_RROUND (X0, X1, X2, X3, Y0, Y1, Y2, Y3);
> + AES_RROUND (Y0, Y1, Y2, Y3, X0, X1, X2, X3);
> +
> + if (ctx->nr > 10)
> + {
> + AES_RROUND (X0, X1, X2, X3, Y0, Y1, Y2, Y3);
> + AES_RROUND (Y0, Y1, Y2, Y3, X0, X1, X2, X3);
> + }
> +
> + if (ctx->nr > 12)
> + {
> + AES_RROUND (X0, X1, X2, X3, Y0, Y1, Y2, Y3);
> + AES_RROUND (Y0, Y1, Y2, Y3, X0, X1, X2, X3);
> + }
> +
> + RK += 4;
> +
> + X0 = RK[0] ^ (RSb[(uint8) (Y0 >> 24)] << 24) ^
> + (RSb[(uint8) (Y3 >> 16)] << 16) ^
> + (RSb[(uint8) (Y2 >> 8)] << 8) ^ (RSb[(uint8) (Y1)]);
> +
> + X1 = RK[1] ^ (RSb[(uint8) (Y1 >> 24)] << 24) ^
> + (RSb[(uint8) (Y0 >> 16)] << 16) ^
> + (RSb[(uint8) (Y3 >> 8)] << 8) ^ (RSb[(uint8) (Y2)]);
> +
> + X2 = RK[2] ^ (RSb[(uint8) (Y2 >> 24)] << 24) ^
> + (RSb[(uint8) (Y1 >> 16)] << 16) ^
> + (RSb[(uint8) (Y0 >> 8)] << 8) ^ (RSb[(uint8) (Y3)]);
> +
> + X3 = RK[3] ^ (RSb[(uint8) (Y3 >> 24)] << 24) ^
> + (RSb[(uint8) (Y2 >> 16)] << 16) ^
> + (RSb[(uint8) (Y1 >> 8)] << 8) ^ (RSb[(uint8) (Y0)]);
> +
> + PUT_UINT32_BE (X0, output, 0);
> + PUT_UINT32_BE (X1, output, 4);
> + PUT_UINT32_BE (X2, output, 8);
> + PUT_UINT32_BE (X3, output, 12);
> }
>
> /*
> * AES-CBC buffer encryption
> */
> -static void aes_cbc_encrypt( aes_context *ctx,
> - unsigned char iv[16],
> - unsigned char *input,
> - unsigned char *output,
> - int len )
> +static void
> +aes_cbc_encrypt (aes_context * ctx,
> + unsigned char iv[16],
> + unsigned char *input, unsigned char *output, int len)
> {
> - int i;
> + int i;
>
> - while( len > 0 )
> + while (len > 0)
> {
> - for( i = 0; i < 16; i++ )
> - output[i] = input[i] ^ iv[i];
> + for (i = 0; i < 16; i++)
> + output[i] = input[i] ^ iv[i];
>
> - aes_encrypt( ctx, output, output );
> - grub_memcpy( iv, output, 16 );
> + aes_encrypt (ctx, output, output);
> + grub_memcpy (iv, output, 16);
>
> - input += 16;
> - output += 16;
> - len -= 16;
> + input += 16;
> + output += 16;
> + len -= 16;
> }
> }
>
> /*
> * AES-CBC buffer decryption
> */
> -static void aes_cbc_decrypt( aes_context *ctx,
> - unsigned char iv[16],
> - unsigned char *input,
> - unsigned char *output,
> - int len )
> +static void
> +aes_cbc_decrypt (aes_context * ctx,
> + unsigned char iv[16],
> + unsigned char *input, unsigned char *output, int len)
> {
> - int i;
> - unsigned char temp[16];
> + int i;
> + unsigned char temp[16];
>
> - while( len > 0 )
> + while (len > 0)
> {
> - grub_memcpy( temp, input, 16 );
> - aes_decrypt( ctx, input, output );
> + grub_memcpy (temp, input, 16);
> + aes_decrypt (ctx, input, output);
>
> - for( i = 0; i < 16; i++ )
> - output[i] = output[i] ^ iv[i];
> + for (i = 0; i < 16; i++)
> + output[i] = output[i] ^ iv[i];
>
> - grub_memcpy( iv, temp, 16 );
> + grub_memcpy (iv, temp, 16);
>
> - input += 16;
> - output += 16;
> - len -= 16;
> + input += 16;
> + output += 16;
> + len -= 16;
> }
> }
>
> @@ -875,80 +902,82 @@
> /*
> * AES-ECB test vectors (source: NIST, rijndael-vals.zip)
> */
> -static const uint8 aes_enc_test[3][16] =
> -{
> - { 0xC3, 0x4C, 0x05, 0x2C, 0xC0, 0xDA, 0x8D, 0x73,
> - 0x45, 0x1A, 0xFE, 0x5F, 0x03, 0xBE, 0x29, 0x7F },
> - { 0xF3, 0xF6, 0x75, 0x2A, 0xE8, 0xD7, 0x83, 0x11,
> - 0x38, 0xF0, 0x41, 0x56, 0x06, 0x31, 0xB1, 0x14 },
> - { 0x8B, 0x79, 0xEE, 0xCC, 0x93, 0xA0, 0xEE, 0x5D,
> - 0xFF, 0x30, 0xB4, 0xEA, 0x21, 0x63, 0x6D, 0xA4 }
> +static const uint8 aes_enc_test[3][16] = {
> + {0xC3, 0x4C, 0x05, 0x2C, 0xC0, 0xDA, 0x8D, 0x73,
> + 0x45, 0x1A, 0xFE, 0x5F, 0x03, 0xBE, 0x29, 0x7F},
> + {0xF3, 0xF6, 0x75, 0x2A, 0xE8, 0xD7, 0x83, 0x11,
> + 0x38, 0xF0, 0x41, 0x56, 0x06, 0x31, 0xB1, 0x14},
> + {0x8B, 0x79, 0xEE, 0xCC, 0x93, 0xA0, 0xEE, 0x5D,
> + 0xFF, 0x30, 0xB4, 0xEA, 0x21, 0x63, 0x6D, 0xA4}
> };
> -
> -static const uint8 aes_dec_test[3][16] =
> -{
> - { 0x44, 0x41, 0x6A, 0xC2, 0xD1, 0xF5, 0x3C, 0x58,
> - 0x33, 0x03, 0x91, 0x7E, 0x6B, 0xE9, 0xEB, 0xE0 },
> - { 0x48, 0xE3, 0x1E, 0x9E, 0x25, 0x67, 0x18, 0xF2,
> - 0x92, 0x29, 0x31, 0x9C, 0x19, 0xF1, 0x5B, 0xA4 },
> - { 0x05, 0x8C, 0xCF, 0xFD, 0xBB, 0xCB, 0x38, 0x2D,
> - 0x1F, 0x6F, 0x56, 0x58, 0x5D, 0x8A, 0x4A, 0xDE }
> +
> +static const uint8 aes_dec_test[3][16] = {
> + {0x44, 0x41, 0x6A, 0xC2, 0xD1, 0xF5, 0x3C, 0x58,
> + 0x33, 0x03, 0x91, 0x7E, 0x6B, 0xE9, 0xEB, 0xE0},
> + {0x48, 0xE3, 0x1E, 0x9E, 0x25, 0x67, 0x18, 0xF2,
> + 0x92, 0x29, 0x31, 0x9C, 0x19, 0xF1, 0x5B, 0xA4},
> + {0x05, 0x8C, 0xCF, 0xFD, 0xBB, 0xCB, 0x38, 0x2D,
> + 0x1F, 0x6F, 0x56, 0x58, 0x5D, 0x8A, 0x4A, 0xDE}
> };
>
> /*
> * Checkup routine
> */
> -int aes_self_test( int verbose )
> +int
> +aes_self_test (int verbose)
> {
> - int i, j, u, v;
> - aes_context ctx;
> - unsigned char buf[32];
> + int i, j, u, v;
> + aes_context ctx;
> + unsigned char buf[32];
>
> - for( i = 0; i < 6; i++ )
> + for (i = 0; i < 6; i++)
> {
> - u = i >> 1;
> - v = i & 1;
> -
> - if( verbose != 0 )
> - printf( " AES-ECB-%3d (%s): ", 128 + u * 64,
> - ( v == 0 ) ? "enc" : "dec" );
> -
> - memset( buf, 0, 32 );
> - aes_set_key( &ctx, buf, 128 + u * 64 );
> + u = i >> 1;
> + v = i & 1;
>
> - for( j = 0; j < 10000; j++ )
> - {
> - if( v == 0 ) aes_encrypt( &ctx, buf, buf );
> - if( v == 1 ) aes_decrypt( &ctx, buf, buf );
> - }
> + if (verbose != 0)
> + printf (" AES-ECB-%3d (%s): ", 128 + u * 64,
> + (v == 0) ? "enc" : "dec");
> +
> + memset (buf, 0, 32);
> + aes_set_key (&ctx, buf, 128 + u * 64);
> +
> + for (j = 0; j < 10000; j++)
> + {
> + if (v == 0)
> + aes_encrypt (&ctx, buf, buf);
> + if (v == 1)
> + aes_decrypt (&ctx, buf, buf);
> + }
> +
> + if ((v == 0 && memcmp (buf, aes_enc_test[u], 16) != 0) ||
> + (v == 1 && memcmp (buf, aes_dec_test[u], 16) != 0))
> + {
> + if (verbose != 0)
> + printf ("failed\n");
>
> - if( ( v == 0 && memcmp( buf, aes_enc_test[u], 16 ) != 0 ) ||
> - ( v == 1 && memcmp( buf, aes_dec_test[u], 16 ) != 0 ) )
> - {
> - if( verbose != 0 )
> - printf( "failed\n" );
> + return (1);
> + }
>
> - return( 1 );
> - }
> -
> - if( verbose != 0 )
> - printf( "passed\n" );
> + if (verbose != 0)
> + printf ("passed\n");
Where does printf come from?
> }
>
> - if( verbose != 0 )
> - printf( "\n" );
> + if (verbose != 0)
> + printf ("\n");
>
> - return( 0 );
> + return (0);
> }
> #endif
>
> /*** GNU GRUB2 interface ***/
>
> -static grub_err_t grub_cipher_aes_init(grub_cipher_params_t params)
> +static grub_err_t
> +grub_cipher_aes_init (grub_cipher_params_t params)
> {
> - params->private = grub_malloc(sizeof(aes_context));
> + params->private = grub_malloc (sizeof (aes_context));
>
> - if(!params->private)
> + if (!params->private)
> return grub_errno;
>
> params->keysize = 32;
> @@ -956,57 +985,65 @@
> return 0;
> }
>
> -static grub_err_t grub_cipher_aes_cbc_init(grub_cipher_params_t params)
> +static grub_err_t
> +grub_cipher_aes_cbc_init (grub_cipher_params_t params)
> {
> grub_err_t err;
>
> - if((err = grub_cipher_aes_init(params))) return err;
> - if(!(params->u.cipher.iv = grub_malloc(16))) return grub_errno;
> - grub_memset(params->u.cipher.iv, 0, 16);
> + if ((err = grub_cipher_aes_init (params)))
> + return err;
> + if (!(params->u.cipher.iv = grub_malloc (16)))
> + return grub_errno;
> + grub_memset (params->u.cipher.iv, 0, 16);
> params->u.cipher.iv_length = 16;
> return 0;
> }
>
> -static void grub_cipher_aes_deinit(grub_cipher_params_t params)
> +static void
> +grub_cipher_aes_deinit (grub_cipher_params_t params)
> {
> - grub_free(params->private);
> + grub_free (params->private);
> }
>
> -static void grub_cipher_aes_cbc_deinit(grub_cipher_params_t params)
> +static void
> +grub_cipher_aes_cbc_deinit (grub_cipher_params_t params)
> {
> - grub_free(params->u.cipher.iv);
> - grub_cipher_aes_deinit(params);
> + grub_free (params->u.cipher.iv);
> + grub_cipher_aes_deinit (params);
> }
>
> -static grub_err_t grub_cipher_aes_set_key(grub_cipher_params_t params, const char *key)
> +static grub_err_t
> +grub_cipher_aes_set_key (grub_cipher_params_t params, const char *key)
> {
> - aes_set_key(params->private, (uint8 *)key, params->keysize * 8);
> + aes_set_key (params->private, (uint8 *) key, params->keysize * 8);
> return 0;
> }
>
> -static grub_err_t grub_cipher_aes_decrypt_inplace(grub_cipher_params_t params,
> - char *buf, grub_size_t size)
> +static grub_err_t
> +grub_cipher_aes_decrypt_inplace (grub_cipher_params_t params,
> + char *buf, grub_size_t size)
> {
> grub_size_t i;
>
> - if(size % 16 != 0)
> - return grub_error(GRUB_ERR_BAD_ARGUMENT, "Size must be multiple of 16");
> + if (size % 16 != 0)
> + return grub_error (GRUB_ERR_BAD_ARGUMENT, "Size must be multiple of 16");
>
> - for(i = 0; i < size; i += 16)
> - aes_decrypt(params->private, (unsigned char *)buf + i,
> - (unsigned char *)buf + i);
> + for (i = 0; i < size; i += 16)
> + aes_decrypt (params->private, (unsigned char *) buf + i,
> + (unsigned char *) buf + i);
>
> return 0;
> }
>
> -static grub_err_t grub_cipher_aes_cbc_decrypt_inplace(grub_cipher_params_t params,
> - char *buf, grub_size_t size)
> +static grub_err_t
> +grub_cipher_aes_cbc_decrypt_inplace (grub_cipher_params_t params,
> + char *buf, grub_size_t size)
> {
> - if(params->u.cipher.iv_length != 16)
> - return grub_error(GRUB_ERR_BAD_ARGUMENT, "IV length incorrect");
> + if (params->u.cipher.iv_length != 16)
> + return grub_error (GRUB_ERR_BAD_ARGUMENT, "IV length incorrect");
>
> - aes_cbc_decrypt(params->private, params->u.cipher.iv, (unsigned char *)buf,
> - (unsigned char *)buf, size);
> + aes_cbc_decrypt (params->private, params->u.cipher.iv,
> + (unsigned char *) buf, (unsigned char *) buf, size);
> return 0;
> }
>
> @@ -1018,45 +1055,42 @@
> .name = "aes",
> .type = GRUB_CIPHER_TYPE_CIPHER,
> .keysizes = aes_keysizes,
> - .keysizes_length = FIELDSOF(aes_keysizes),
> + .keysizes_length = FIELDSOF (aes_keysizes),
>
> .init = grub_cipher_aes_init,
> .deinit = grub_cipher_aes_deinit,
> .u.cipher = {
> - .set_key = grub_cipher_aes_set_key,
> - .encrypt = NULL,
> - .decrypt = NULL,
> - .decrypt_inplace = grub_cipher_aes_decrypt_inplace,
> - .encrypt_inplace = NULL
> - }
> + .set_key = grub_cipher_aes_set_key,
> + .encrypt = NULL,
> + .decrypt = NULL,
> + .decrypt_inplace = grub_cipher_aes_decrypt_inplace,
> + .encrypt_inplace = NULL}
> };
>
> static struct grub_cipher grub_cipher_aes_cbc = {
> .name = "aes-cbc",
> .type = GRUB_CIPHER_TYPE_CIPHER,
> .keysizes = aes_keysizes,
> - .keysizes_length = FIELDSOF(aes_keysizes),
> + .keysizes_length = FIELDSOF (aes_keysizes),
>
> .init = grub_cipher_aes_cbc_init,
> .deinit = grub_cipher_aes_cbc_deinit,
> .u.cipher = {
> - .set_key = grub_cipher_aes_set_key,
> - .encrypt = NULL,
> - .decrypt = NULL,
> - .decrypt_inplace = grub_cipher_aes_cbc_decrypt_inplace,
> - .encrypt_inplace = NULL
> - }
> + .set_key = grub_cipher_aes_set_key,
> + .encrypt = NULL,
> + .decrypt = NULL,
> + .decrypt_inplace = grub_cipher_aes_cbc_decrypt_inplace,
> + .encrypt_inplace = NULL}
> };
>
> -GRUB_MOD_INIT(aes)
> +GRUB_MOD_INIT (aes)
> {
> - (void)mod; /* To stop warning. */
> - grub_crypto_cipher_register(&grub_cipher_aes);
> - grub_crypto_cipher_register(&grub_cipher_aes_cbc);
> + grub_crypto_cipher_register (&grub_cipher_aes);
> + grub_crypto_cipher_register (&grub_cipher_aes_cbc);
> }
>
> -GRUB_MOD_FINI(aes)
> +GRUB_MOD_FINI (aes)
> {
> - grub_crypto_cipher_unregister(&grub_cipher_aes);
> - grub_crypto_cipher_unregister(&grub_cipher_aes_cbc);
> + grub_crypto_cipher_unregister (&grub_cipher_aes);
> + grub_crypto_cipher_unregister (&grub_cipher_aes_cbc);
> }
> diff -u -r -x CVS -N grub2/crypto/crypto.c grub2-new/crypto/crypto.c
> --- grub2/crypto/crypto.c 2007-09-03 20:40:37.000000000 +0200
> +++ grub2-new/crypto/crypto.c 2007-09-03 20:25:40.000000000 +0200
> @@ -31,108 +31,116 @@
>
> #define MAX(a, b) (a > b ? a : b)
>
> -struct cipher_list {
> - grub_cipher_t cipher;
> - struct cipher_list *next;
> +struct cipher_list
> +{
> + grub_cipher_t cipher;
> + struct cipher_list *next;
> };
>
> static struct cipher_list *cipher_list = NULL;
>
> grub_err_t
> -grub_crypto_hash(grub_cipher_params_t params, char *hash, const char *payload,
> - unsigned int size)
> +grub_crypto_hash (grub_cipher_params_t params, char *hash,
> + const char *payload, unsigned int size)
> {
> - return params->cipher->u.hash.fn(params, hash, payload, size);
> + return params->cipher->u.hash.fn (params, hash, payload, size);
> }
>
> static grub_cipher_t
> -get_cipher(const char *name, grub_cipher_type_t type)
> +get_cipher (const char *name, grub_cipher_type_t type)
> {
> struct cipher_list *i;
>
> - for(i = cipher_list; i != NULL; i = i->next)
> - if(!grub_strcmp(i->cipher->name, name) && i->cipher->type == type)
> + for (i = cipher_list; i != NULL; i = i->next)
> + if (!grub_strcmp (i->cipher->name, name) && i->cipher->type == type)
> return i->cipher;
>
> return NULL;
> }
>
> grub_err_t
> -grub_crypto_new_cipher(grub_cipher_params_t *params, const char *name,
> - grub_cipher_type_t type)
> +grub_crypto_new_cipher (grub_cipher_params_t * params, const char *name,
> + grub_cipher_type_t type)
> {
> - grub_cipher_t cipher = get_cipher(name, type);
> - grub_err_t err;
> -
> - if(cipher == NULL) {
> - const char *errstr = "Illegal cipher type";
> + grub_cipher_t cipher = get_cipher (name, type);
> + grub_err_t err;
>
> - switch(type) {
> - case GRUB_CIPHER_TYPE_NONE:
> - break;
> -
> - case GRUB_CIPHER_TYPE_CIPHER:
> - errstr = "Unknown cipher";
> - break;
> + if (cipher == NULL)
> + {
> + const char *errstr = "Illegal cipher type";
> +
> + switch (type)
> + {
> + case GRUB_CIPHER_TYPE_NONE:
> + break;
> +
> + case GRUB_CIPHER_TYPE_CIPHER:
> + errstr = "Unknown cipher";
> + break;
> +
> + case GRUB_CIPHER_TYPE_HASH:
> + errstr = "Unknown hash";
> + break;
> + }
>
> - case GRUB_CIPHER_TYPE_HASH:
> - errstr = "Unknown hash";
> - break;
> + return grub_error (GRUB_ERR_BAD_ARGUMENT, errstr);
> }
>
> - return grub_error(GRUB_ERR_BAD_ARGUMENT, errstr);
> - }
> -
> - *params = grub_malloc(sizeof(struct grub_cipher_params));
> - if(*params == NULL)
> + *params = grub_malloc (sizeof (struct grub_cipher_params));
> + if (*params == NULL)
> return grub_errno;
>
> - if(cipher->init) {
> - if((err = cipher->init(*params)) != GRUB_ERR_NONE) {
> - grub_free(*params);
> - return err;
> + if (cipher->init)
> + {
> + if ((err = cipher->init (*params)) != GRUB_ERR_NONE)
> + {
> + grub_free (*params);
> + return err;
> + }
> }
> - } else {
> - unsigned int i, keysize = 0;
> + else
> + {
> + unsigned int i, keysize = 0;
>
> - /* Set keysize to largest */
> - for(i = 0; i < cipher->keysizes_length; i++)
> - keysize = MAX(keysize, cipher->keysizes[i]);
> + /* Set keysize to largest */
> + for (i = 0; i < cipher->keysizes_length; i++)
> + keysize = MAX (keysize, cipher->keysizes[i]);
>
> - (*params)->keysize = keysize;
> - }
> + (*params)->keysize = keysize;
> + }
>
> (*params)->cipher = cipher;
> return GRUB_ERR_NONE;
> }
>
> void
> -grub_crypto_delete_cipher(grub_cipher_params_t params)
> +grub_crypto_delete_cipher (grub_cipher_params_t params)
> {
> - if(params->cipher->deinit)
> - params->cipher->deinit(params);
> + if (params->cipher->deinit)
> + params->cipher->deinit (params);
>
> - grub_free(params);
> + grub_free (params);
> }
>
> int
> -grub_crypto_cipher_iterate(grub_crypto_hook hook, void *data)
> +grub_crypto_cipher_iterate (grub_crypto_hook hook, void *data)
> {
> struct cipher_list *i;
>
> - for(i = cipher_list; i != NULL; i = i->next)
> - if(hook(i->cipher, data))
> + for (i = cipher_list; i != NULL; i = i->next)
> + if (hook (i->cipher, data))
> return 1;
>
> return 0;
> }
>
> void
> -grub_crypto_cipher_register(grub_cipher_t cipher)
> +grub_crypto_cipher_register (grub_cipher_t cipher)
> {
> - struct cipher_list *newcipher = grub_malloc(sizeof(struct cipher_list));
> + struct cipher_list *newcipher = grub_malloc (sizeof (struct cipher_list));
>
> - if(!newcipher) return; /* out of memory! */
> + if (!newcipher)
> + return; /* out of memory! */
>
> newcipher->cipher = cipher;
> newcipher->next = cipher_list;
> @@ -140,67 +148,75 @@
> }
>
> void
> -grub_crypto_cipher_unregister(grub_cipher_t cipher)
> +grub_crypto_cipher_unregister (grub_cipher_t cipher)
> {
> struct cipher_list *i, **prev;
>
> - for(i = cipher_list, prev = &cipher_list; i != NULL; prev = &i->next, i = i->next)
> - if(!grub_strcmp(i->cipher->name, cipher->name))
> + for (i = cipher_list, prev = &cipher_list; i != NULL;
> + prev = &i->next, i = i->next)
> + if (!grub_strcmp (i->cipher->name, cipher->name))
> break;
>
> - if(!i) {
> - grub_printf("BUG: Trying to unregister a non-registered cipher!\n");
> - return;
> - }
> + if (!i)
> + {
> + grub_printf ("BUG: Trying to unregister a non-registered cipher!\n");
> + return;
> + }
>
> /* Remove cipher from list */
> *prev = i->next;
> - grub_free(i);
> + grub_free (i);
> }
>
> grub_err_t
> -grub_crypto_set_key(grub_cipher_params_t params, const char *key)
> +grub_crypto_set_key (grub_cipher_params_t params, const char *key)
> {
> - if(params->cipher->u.cipher.set_key)
> - return params->cipher->u.cipher.set_key(params, key);
> + if (params->cipher->u.cipher.set_key)
> + return params->cipher->u.cipher.set_key (params, key);
> else
> return GRUB_ERR_NONE;
> }
>
> -grub_err_t grub_crypto_encrypt(grub_cipher_params_t params, char **out,
> - const char *in, grub_size_t *outsize,
> - grub_size_t insize)
> -{
> - if(params->cipher->u.cipher.encrypt)
> - return params->cipher->u.cipher.encrypt(params, out, in, outsize, insize);
> +grub_err_t
> +grub_crypto_encrypt (grub_cipher_params_t params, char **out,
> + const char *in, grub_size_t * outsize,
> + grub_size_t insize)
> +{
> + if (params->cipher->u.cipher.encrypt)
> + return params->cipher->u.cipher.encrypt (params, out, in, outsize,
> + insize);
> else
> return GRUB_ERR_NOT_IMPLEMENTED_YET;
> }
>
> -grub_err_t grub_crypto_decrypt(grub_cipher_params_t params, char **out,
> - const char *in, grub_size_t *outsize,
> - grub_size_t insize)
> -{
> - if(params->cipher->u.cipher.decrypt)
> - return params->cipher->u.cipher.decrypt(params, out, in, outsize, insize);
> +grub_err_t
> +grub_crypto_decrypt (grub_cipher_params_t params, char **out,
> + const char *in, grub_size_t * outsize,
> + grub_size_t insize)
> +{
> + if (params->cipher->u.cipher.decrypt)
> + return params->cipher->u.cipher.decrypt (params, out, in, outsize,
> + insize);
> else
> return GRUB_ERR_NOT_IMPLEMENTED_YET;
> }
>
> -grub_err_t grub_crypto_decrypt_inplace(grub_cipher_params_t params, char *buf,
> - grub_size_t size)
> +grub_err_t
> +grub_crypto_decrypt_inplace (grub_cipher_params_t params, char *buf,
> + grub_size_t size)
> {
> - if(params->cipher->u.cipher.decrypt_inplace)
> - return params->cipher->u.cipher.decrypt_inplace(params, buf, size);
> + if (params->cipher->u.cipher.decrypt_inplace)
> + return params->cipher->u.cipher.decrypt_inplace (params, buf, size);
> else
> return GRUB_ERR_NOT_IMPLEMENTED_YET;
> }
>
> -grub_err_t grub_crypto_encrypt_inplace(grub_cipher_params_t params, char *buf,
> - grub_size_t size)
> +grub_err_t
> +grub_crypto_encrypt_inplace (grub_cipher_params_t params, char *buf,
> + grub_size_t size)
> {
> - if(params->cipher->u.cipher.encrypt_inplace)
> - return params->cipher->u.cipher.encrypt_inplace(params, buf, size);
> + if (params->cipher->u.cipher.encrypt_inplace)
> + return params->cipher->u.cipher.encrypt_inplace (params, buf, size);
> else
> return GRUB_ERR_NOT_IMPLEMENTED_YET;
> }
> @@ -208,29 +224,33 @@
> /***** None cipher interface ***********************************************/
>
> static grub_err_t
> -cipher_none_crypt(grub_cipher_params_t unused, char **out, const char *in, grub_size_t *outsize, grub_size_t insize)
> +cipher_none_crypt (grub_cipher_params_t unused, char **out, const char *in,
> + grub_size_t * outsize, grub_size_t insize)
> {
> - (void)unused;
> - if(!(*out = grub_malloc(insize))) return grub_errno;
> - *out = grub_memcpy(*out, in, insize);
> + (void) unused;
> + if (!(*out = grub_malloc (insize)))
> + return grub_errno;
> + *out = grub_memcpy (*out, in, insize);
> *outsize = insize;
> return 0;
> }
>
> static grub_err_t
> -cipher_none_crypt_inplace(grub_cipher_params_t unused, char *buf, grub_size_t size)
> +cipher_none_crypt_inplace (grub_cipher_params_t unused, char *buf,
> + grub_size_t size)
> {
> - (void)unused;
> - (void)buf;
> - (void)size;
> + (void) unused;
> + (void) buf;
> + (void) size;
> return 0;
> }
>
> static grub_err_t
> -hash_none_fn(grub_cipher_params_t params, char *out, const char *in, grub_size_t insize)
> +hash_none_fn (grub_cipher_params_t params, char *out, const char *in,
> + grub_size_t insize)
> {
> params->keysize = insize;
> - grub_memcpy(out, in, insize);
> + grub_memcpy (out, in, insize);
> return 0;
> }
>
> @@ -240,11 +260,10 @@
> .keysizes_length = 0,
>
> .u.cipher = {
> - .encrypt = cipher_none_crypt,
> - .decrypt = cipher_none_crypt,
> - .decrypt_inplace = cipher_none_crypt_inplace,
> - .encrypt_inplace = cipher_none_crypt_inplace
> - }
> + .encrypt = cipher_none_crypt,
> + .decrypt = cipher_none_crypt,
> + .decrypt_inplace = cipher_none_crypt_inplace,
> + .encrypt_inplace = cipher_none_crypt_inplace}
> };
>
> static struct grub_cipher grub_hash_none = {
> @@ -256,15 +275,14 @@
>
> /***** GRUB module (de-)initialization *************************************/
>
> -GRUB_MOD_INIT(crypto)
> +GRUB_MOD_INIT (crypto)
> {
> - (void)mod; /* To stop warning. */
> - grub_crypto_cipher_register(&grub_cipher_none);
> - grub_crypto_cipher_register(&grub_hash_none);
> + grub_crypto_cipher_register (&grub_cipher_none);
> + grub_crypto_cipher_register (&grub_hash_none);
> }
>
> -GRUB_MOD_FINI(crypto)
> +GRUB_MOD_FINI (crypto)
> {
> - grub_crypto_cipher_unregister(&grub_hash_none);
> - grub_crypto_cipher_unregister(&grub_cipher_none);
> + grub_crypto_cipher_unregister (&grub_hash_none);
> + grub_crypto_cipher_unregister (&grub_cipher_none);
> }
> diff -u -r -x CVS -N grub2/crypto/rmd160.c grub2-new/crypto/rmd160.c
> --- grub2/crypto/rmd160.c 2007-09-03 20:40:37.000000000 +0200
> +++ grub2-new/crypto/rmd160.c 2007-09-03 20:25:42.000000000 +0200
> @@ -50,8 +50,8 @@
> /* typedef 8 and 32 bit types, resp. */
> /* adapt these, if necessary,
> for your operating system and compiler */
> -typedef unsigned char byte;
> -typedef unsigned long dword;
> +typedef unsigned char byte;
> +typedef unsigned long dword;
>
> /* macro definitions */
>
> @@ -67,12 +67,12 @@
> #define ROL(x, n) (((x) << (n)) | ((x) >> (32-(n))))
>
> /* the five basic functions F(), G() and H() */
> -#define F(x, y, z) ((x) ^ (y) ^ (z))
> -#define G(x, y, z) (((x) & (y)) | (~(x) & (z)))
> +#define F(x, y, z) ((x) ^ (y) ^ (z))
> +#define G(x, y, z) (((x) & (y)) | (~(x) & (z)))
> #define H(x, y, z) (((x) | ~(y)) ^ (z))
> -#define I(x, y, z) (((x) & (z)) | ((y) & ~(z)))
> +#define I(x, y, z) (((x) & (z)) | ((y) & ~(z)))
> #define J(x, y, z) ((x) ^ ((y) | ~(z)))
> -
> +
> /* the ten basic operations FF() through III() */
> #define FF(a, b, c, d, e, x, s) {\
> (a) += F((b), (c), (d)) + (x);\
> @@ -127,304 +127,311 @@
>
> /********************************************************************/
>
> -static void MDinit(dword *MDbuf)
> +static void
> +MDinit (dword * MDbuf)
> {
> - MDbuf[0] = 0x67452301UL;
> - MDbuf[1] = 0xefcdab89UL;
> - MDbuf[2] = 0x98badcfeUL;
> - MDbuf[3] = 0x10325476UL;
> - MDbuf[4] = 0xc3d2e1f0UL;
> + MDbuf[0] = 0x67452301UL;
> + MDbuf[1] = 0xefcdab89UL;
> + MDbuf[2] = 0x98badcfeUL;
> + MDbuf[3] = 0x10325476UL;
> + MDbuf[4] = 0xc3d2e1f0UL;
>
> - return;
> + return;
> }
>
> /********************************************************************/
>
> -static void compress(dword *MDbuf, dword *X)
> +static void
> +compress (dword * MDbuf, dword * X)
> {
> - dword aa = MDbuf[0], bb = MDbuf[1], cc = MDbuf[2],
> - dd = MDbuf[3], ee = MDbuf[4];
> - dword aaa = MDbuf[0], bbb = MDbuf[1], ccc = MDbuf[2],
> - ddd = MDbuf[3], eee = MDbuf[4];
> -
> - /* round 1 */
> - FF(aa, bb, cc, dd, ee, X[ 0], 11);
> - FF(ee, aa, bb, cc, dd, X[ 1], 14);
> - FF(dd, ee, aa, bb, cc, X[ 2], 15);
> - FF(cc, dd, ee, aa, bb, X[ 3], 12);
> - FF(bb, cc, dd, ee, aa, X[ 4], 5);
> - FF(aa, bb, cc, dd, ee, X[ 5], 8);
> - FF(ee, aa, bb, cc, dd, X[ 6], 7);
> - FF(dd, ee, aa, bb, cc, X[ 7], 9);
> - FF(cc, dd, ee, aa, bb, X[ 8], 11);
> - FF(bb, cc, dd, ee, aa, X[ 9], 13);
> - FF(aa, bb, cc, dd, ee, X[10], 14);
> - FF(ee, aa, bb, cc, dd, X[11], 15);
> - FF(dd, ee, aa, bb, cc, X[12], 6);
> - FF(cc, dd, ee, aa, bb, X[13], 7);
> - FF(bb, cc, dd, ee, aa, X[14], 9);
> - FF(aa, bb, cc, dd, ee, X[15], 8);
> -
> - /* round 2 */
> - GG(ee, aa, bb, cc, dd, X[ 7], 7);
> - GG(dd, ee, aa, bb, cc, X[ 4], 6);
> - GG(cc, dd, ee, aa, bb, X[13], 8);
> - GG(bb, cc, dd, ee, aa, X[ 1], 13);
> - GG(aa, bb, cc, dd, ee, X[10], 11);
> - GG(ee, aa, bb, cc, dd, X[ 6], 9);
> - GG(dd, ee, aa, bb, cc, X[15], 7);
> - GG(cc, dd, ee, aa, bb, X[ 3], 15);
> - GG(bb, cc, dd, ee, aa, X[12], 7);
> - GG(aa, bb, cc, dd, ee, X[ 0], 12);
> - GG(ee, aa, bb, cc, dd, X[ 9], 15);
> - GG(dd, ee, aa, bb, cc, X[ 5], 9);
> - GG(cc, dd, ee, aa, bb, X[ 2], 11);
> - GG(bb, cc, dd, ee, aa, X[14], 7);
> - GG(aa, bb, cc, dd, ee, X[11], 13);
> - GG(ee, aa, bb, cc, dd, X[ 8], 12);
> -
> - /* round 3 */
> - HH(dd, ee, aa, bb, cc, X[ 3], 11);
> - HH(cc, dd, ee, aa, bb, X[10], 13);
> - HH(bb, cc, dd, ee, aa, X[14], 6);
> - HH(aa, bb, cc, dd, ee, X[ 4], 7);
> - HH(ee, aa, bb, cc, dd, X[ 9], 14);
> - HH(dd, ee, aa, bb, cc, X[15], 9);
> - HH(cc, dd, ee, aa, bb, X[ 8], 13);
> - HH(bb, cc, dd, ee, aa, X[ 1], 15);
> - HH(aa, bb, cc, dd, ee, X[ 2], 14);
> - HH(ee, aa, bb, cc, dd, X[ 7], 8);
> - HH(dd, ee, aa, bb, cc, X[ 0], 13);
> - HH(cc, dd, ee, aa, bb, X[ 6], 6);
> - HH(bb, cc, dd, ee, aa, X[13], 5);
> - HH(aa, bb, cc, dd, ee, X[11], 12);
> - HH(ee, aa, bb, cc, dd, X[ 5], 7);
> - HH(dd, ee, aa, bb, cc, X[12], 5);
> -
> - /* round 4 */
> - II(cc, dd, ee, aa, bb, X[ 1], 11);
> - II(bb, cc, dd, ee, aa, X[ 9], 12);
> - II(aa, bb, cc, dd, ee, X[11], 14);
> - II(ee, aa, bb, cc, dd, X[10], 15);
> - II(dd, ee, aa, bb, cc, X[ 0], 14);
> - II(cc, dd, ee, aa, bb, X[ 8], 15);
> - II(bb, cc, dd, ee, aa, X[12], 9);
> - II(aa, bb, cc, dd, ee, X[ 4], 8);
> - II(ee, aa, bb, cc, dd, X[13], 9);
> - II(dd, ee, aa, bb, cc, X[ 3], 14);
> - II(cc, dd, ee, aa, bb, X[ 7], 5);
> - II(bb, cc, dd, ee, aa, X[15], 6);
> - II(aa, bb, cc, dd, ee, X[14], 8);
> - II(ee, aa, bb, cc, dd, X[ 5], 6);
> - II(dd, ee, aa, bb, cc, X[ 6], 5);
> - II(cc, dd, ee, aa, bb, X[ 2], 12);
> -
> - /* round 5 */
> - JJ(bb, cc, dd, ee, aa, X[ 4], 9);
> - JJ(aa, bb, cc, dd, ee, X[ 0], 15);
> - JJ(ee, aa, bb, cc, dd, X[ 5], 5);
> - JJ(dd, ee, aa, bb, cc, X[ 9], 11);
> - JJ(cc, dd, ee, aa, bb, X[ 7], 6);
> - JJ(bb, cc, dd, ee, aa, X[12], 8);
> - JJ(aa, bb, cc, dd, ee, X[ 2], 13);
> - JJ(ee, aa, bb, cc, dd, X[10], 12);
> - JJ(dd, ee, aa, bb, cc, X[14], 5);
> - JJ(cc, dd, ee, aa, bb, X[ 1], 12);
> - JJ(bb, cc, dd, ee, aa, X[ 3], 13);
> - JJ(aa, bb, cc, dd, ee, X[ 8], 14);
> - JJ(ee, aa, bb, cc, dd, X[11], 11);
> - JJ(dd, ee, aa, bb, cc, X[ 6], 8);
> - JJ(cc, dd, ee, aa, bb, X[15], 5);
> - JJ(bb, cc, dd, ee, aa, X[13], 6);
> -
> - /* parallel round 1 */
> - JJJ(aaa, bbb, ccc, ddd, eee, X[ 5], 8);
> - JJJ(eee, aaa, bbb, ccc, ddd, X[14], 9);
> - JJJ(ddd, eee, aaa, bbb, ccc, X[ 7], 9);
> - JJJ(ccc, ddd, eee, aaa, bbb, X[ 0], 11);
> - JJJ(bbb, ccc, ddd, eee, aaa, X[ 9], 13);
> - JJJ(aaa, bbb, ccc, ddd, eee, X[ 2], 15);
> - JJJ(eee, aaa, bbb, ccc, ddd, X[11], 15);
> - JJJ(ddd, eee, aaa, bbb, ccc, X[ 4], 5);
> - JJJ(ccc, ddd, eee, aaa, bbb, X[13], 7);
> - JJJ(bbb, ccc, ddd, eee, aaa, X[ 6], 7);
> - JJJ(aaa, bbb, ccc, ddd, eee, X[15], 8);
> - JJJ(eee, aaa, bbb, ccc, ddd, X[ 8], 11);
> - JJJ(ddd, eee, aaa, bbb, ccc, X[ 1], 14);
> - JJJ(ccc, ddd, eee, aaa, bbb, X[10], 14);
> - JJJ(bbb, ccc, ddd, eee, aaa, X[ 3], 12);
> - JJJ(aaa, bbb, ccc, ddd, eee, X[12], 6);
> -
> - /* parallel round 2 */
> - III(eee, aaa, bbb, ccc, ddd, X[ 6], 9);
> - III(ddd, eee, aaa, bbb, ccc, X[11], 13);
> - III(ccc, ddd, eee, aaa, bbb, X[ 3], 15);
> - III(bbb, ccc, ddd, eee, aaa, X[ 7], 7);
> - III(aaa, bbb, ccc, ddd, eee, X[ 0], 12);
> - III(eee, aaa, bbb, ccc, ddd, X[13], 8);
> - III(ddd, eee, aaa, bbb, ccc, X[ 5], 9);
> - III(ccc, ddd, eee, aaa, bbb, X[10], 11);
> - III(bbb, ccc, ddd, eee, aaa, X[14], 7);
> - III(aaa, bbb, ccc, ddd, eee, X[15], 7);
> - III(eee, aaa, bbb, ccc, ddd, X[ 8], 12);
> - III(ddd, eee, aaa, bbb, ccc, X[12], 7);
> - III(ccc, ddd, eee, aaa, bbb, X[ 4], 6);
> - III(bbb, ccc, ddd, eee, aaa, X[ 9], 15);
> - III(aaa, bbb, ccc, ddd, eee, X[ 1], 13);
> - III(eee, aaa, bbb, ccc, ddd, X[ 2], 11);
> -
> - /* parallel round 3 */
> - HHH(ddd, eee, aaa, bbb, ccc, X[15], 9);
> - HHH(ccc, ddd, eee, aaa, bbb, X[ 5], 7);
> - HHH(bbb, ccc, ddd, eee, aaa, X[ 1], 15);
> - HHH(aaa, bbb, ccc, ddd, eee, X[ 3], 11);
> - HHH(eee, aaa, bbb, ccc, ddd, X[ 7], 8);
> - HHH(ddd, eee, aaa, bbb, ccc, X[14], 6);
> - HHH(ccc, ddd, eee, aaa, bbb, X[ 6], 6);
> - HHH(bbb, ccc, ddd, eee, aaa, X[ 9], 14);
> - HHH(aaa, bbb, ccc, ddd, eee, X[11], 12);
> - HHH(eee, aaa, bbb, ccc, ddd, X[ 8], 13);
> - HHH(ddd, eee, aaa, bbb, ccc, X[12], 5);
> - HHH(ccc, ddd, eee, aaa, bbb, X[ 2], 14);
> - HHH(bbb, ccc, ddd, eee, aaa, X[10], 13);
> - HHH(aaa, bbb, ccc, ddd, eee, X[ 0], 13);
> - HHH(eee, aaa, bbb, ccc, ddd, X[ 4], 7);
> - HHH(ddd, eee, aaa, bbb, ccc, X[13], 5);
> -
> - /* parallel round 4 */
> - GGG(ccc, ddd, eee, aaa, bbb, X[ 8], 15);
> - GGG(bbb, ccc, ddd, eee, aaa, X[ 6], 5);
> - GGG(aaa, bbb, ccc, ddd, eee, X[ 4], 8);
> - GGG(eee, aaa, bbb, ccc, ddd, X[ 1], 11);
> - GGG(ddd, eee, aaa, bbb, ccc, X[ 3], 14);
> - GGG(ccc, ddd, eee, aaa, bbb, X[11], 14);
> - GGG(bbb, ccc, ddd, eee, aaa, X[15], 6);
> - GGG(aaa, bbb, ccc, ddd, eee, X[ 0], 14);
> - GGG(eee, aaa, bbb, ccc, ddd, X[ 5], 6);
> - GGG(ddd, eee, aaa, bbb, ccc, X[12], 9);
> - GGG(ccc, ddd, eee, aaa, bbb, X[ 2], 12);
> - GGG(bbb, ccc, ddd, eee, aaa, X[13], 9);
> - GGG(aaa, bbb, ccc, ddd, eee, X[ 9], 12);
> - GGG(eee, aaa, bbb, ccc, ddd, X[ 7], 5);
> - GGG(ddd, eee, aaa, bbb, ccc, X[10], 15);
> - GGG(ccc, ddd, eee, aaa, bbb, X[14], 8);
> -
> - /* parallel round 5 */
> - FFF(bbb, ccc, ddd, eee, aaa, X[12] , 8);
> - FFF(aaa, bbb, ccc, ddd, eee, X[15] , 5);
> - FFF(eee, aaa, bbb, ccc, ddd, X[10] , 12);
> - FFF(ddd, eee, aaa, bbb, ccc, X[ 4] , 9);
> - FFF(ccc, ddd, eee, aaa, bbb, X[ 1] , 12);
> - FFF(bbb, ccc, ddd, eee, aaa, X[ 5] , 5);
> - FFF(aaa, bbb, ccc, ddd, eee, X[ 8] , 14);
> - FFF(eee, aaa, bbb, ccc, ddd, X[ 7] , 6);
> - FFF(ddd, eee, aaa, bbb, ccc, X[ 6] , 8);
> - FFF(ccc, ddd, eee, aaa, bbb, X[ 2] , 13);
> - FFF(bbb, ccc, ddd, eee, aaa, X[13] , 6);
> - FFF(aaa, bbb, ccc, ddd, eee, X[14] , 5);
> - FFF(eee, aaa, bbb, ccc, ddd, X[ 0] , 15);
> - FFF(ddd, eee, aaa, bbb, ccc, X[ 3] , 13);
> - FFF(ccc, ddd, eee, aaa, bbb, X[ 9] , 11);
> - FFF(bbb, ccc, ddd, eee, aaa, X[11] , 11);
> -
> - /* combine results */
> - ddd += cc + MDbuf[1]; /* final result for MDbuf[0] */
> - MDbuf[1] = MDbuf[2] + dd + eee;
> - MDbuf[2] = MDbuf[3] + ee + aaa;
> - MDbuf[3] = MDbuf[4] + aa + bbb;
> - MDbuf[4] = MDbuf[0] + bb + ccc;
> - MDbuf[0] = ddd;
> + dword aa = MDbuf[0], bb = MDbuf[1], cc = MDbuf[2],
> + dd = MDbuf[3], ee = MDbuf[4];
> + dword aaa = MDbuf[0], bbb = MDbuf[1], ccc = MDbuf[2],
> + ddd = MDbuf[3], eee = MDbuf[4];
> +
> + /* round 1 */
> + FF (aa, bb, cc, dd, ee, X[0], 11);
> + FF (ee, aa, bb, cc, dd, X[1], 14);
> + FF (dd, ee, aa, bb, cc, X[2], 15);
> + FF (cc, dd, ee, aa, bb, X[3], 12);
> + FF (bb, cc, dd, ee, aa, X[4], 5);
> + FF (aa, bb, cc, dd, ee, X[5], 8);
> + FF (ee, aa, bb, cc, dd, X[6], 7);
> + FF (dd, ee, aa, bb, cc, X[7], 9);
> + FF (cc, dd, ee, aa, bb, X[8], 11);
> + FF (bb, cc, dd, ee, aa, X[9], 13);
> + FF (aa, bb, cc, dd, ee, X[10], 14);
> + FF (ee, aa, bb, cc, dd, X[11], 15);
> + FF (dd, ee, aa, bb, cc, X[12], 6);
> + FF (cc, dd, ee, aa, bb, X[13], 7);
> + FF (bb, cc, dd, ee, aa, X[14], 9);
> + FF (aa, bb, cc, dd, ee, X[15], 8);
> +
> + /* round 2 */
> + GG (ee, aa, bb, cc, dd, X[7], 7);
> + GG (dd, ee, aa, bb, cc, X[4], 6);
> + GG (cc, dd, ee, aa, bb, X[13], 8);
> + GG (bb, cc, dd, ee, aa, X[1], 13);
> + GG (aa, bb, cc, dd, ee, X[10], 11);
> + GG (ee, aa, bb, cc, dd, X[6], 9);
> + GG (dd, ee, aa, bb, cc, X[15], 7);
> + GG (cc, dd, ee, aa, bb, X[3], 15);
> + GG (bb, cc, dd, ee, aa, X[12], 7);
> + GG (aa, bb, cc, dd, ee, X[0], 12);
> + GG (ee, aa, bb, cc, dd, X[9], 15);
> + GG (dd, ee, aa, bb, cc, X[5], 9);
> + GG (cc, dd, ee, aa, bb, X[2], 11);
> + GG (bb, cc, dd, ee, aa, X[14], 7);
> + GG (aa, bb, cc, dd, ee, X[11], 13);
> + GG (ee, aa, bb, cc, dd, X[8], 12);
> +
> + /* round 3 */
> + HH (dd, ee, aa, bb, cc, X[3], 11);
> + HH (cc, dd, ee, aa, bb, X[10], 13);
> + HH (bb, cc, dd, ee, aa, X[14], 6);
> + HH (aa, bb, cc, dd, ee, X[4], 7);
> + HH (ee, aa, bb, cc, dd, X[9], 14);
> + HH (dd, ee, aa, bb, cc, X[15], 9);
> + HH (cc, dd, ee, aa, bb, X[8], 13);
> + HH (bb, cc, dd, ee, aa, X[1], 15);
> + HH (aa, bb, cc, dd, ee, X[2], 14);
> + HH (ee, aa, bb, cc, dd, X[7], 8);
> + HH (dd, ee, aa, bb, cc, X[0], 13);
> + HH (cc, dd, ee, aa, bb, X[6], 6);
> + HH (bb, cc, dd, ee, aa, X[13], 5);
> + HH (aa, bb, cc, dd, ee, X[11], 12);
> + HH (ee, aa, bb, cc, dd, X[5], 7);
> + HH (dd, ee, aa, bb, cc, X[12], 5);
> +
> + /* round 4 */
> + II (cc, dd, ee, aa, bb, X[1], 11);
> + II (bb, cc, dd, ee, aa, X[9], 12);
> + II (aa, bb, cc, dd, ee, X[11], 14);
> + II (ee, aa, bb, cc, dd, X[10], 15);
> + II (dd, ee, aa, bb, cc, X[0], 14);
> + II (cc, dd, ee, aa, bb, X[8], 15);
> + II (bb, cc, dd, ee, aa, X[12], 9);
> + II (aa, bb, cc, dd, ee, X[4], 8);
> + II (ee, aa, bb, cc, dd, X[13], 9);
> + II (dd, ee, aa, bb, cc, X[3], 14);
> + II (cc, dd, ee, aa, bb, X[7], 5);
> + II (bb, cc, dd, ee, aa, X[15], 6);
> + II (aa, bb, cc, dd, ee, X[14], 8);
> + II (ee, aa, bb, cc, dd, X[5], 6);
> + II (dd, ee, aa, bb, cc, X[6], 5);
> + II (cc, dd, ee, aa, bb, X[2], 12);
> +
> + /* round 5 */
> + JJ (bb, cc, dd, ee, aa, X[4], 9);
> + JJ (aa, bb, cc, dd, ee, X[0], 15);
> + JJ (ee, aa, bb, cc, dd, X[5], 5);
> + JJ (dd, ee, aa, bb, cc, X[9], 11);
> + JJ (cc, dd, ee, aa, bb, X[7], 6);
> + JJ (bb, cc, dd, ee, aa, X[12], 8);
> + JJ (aa, bb, cc, dd, ee, X[2], 13);
> + JJ (ee, aa, bb, cc, dd, X[10], 12);
> + JJ (dd, ee, aa, bb, cc, X[14], 5);
> + JJ (cc, dd, ee, aa, bb, X[1], 12);
> + JJ (bb, cc, dd, ee, aa, X[3], 13);
> + JJ (aa, bb, cc, dd, ee, X[8], 14);
> + JJ (ee, aa, bb, cc, dd, X[11], 11);
> + JJ (dd, ee, aa, bb, cc, X[6], 8);
> + JJ (cc, dd, ee, aa, bb, X[15], 5);
> + JJ (bb, cc, dd, ee, aa, X[13], 6);
> +
> + /* parallel round 1 */
> + JJJ (aaa, bbb, ccc, ddd, eee, X[5], 8);
> + JJJ (eee, aaa, bbb, ccc, ddd, X[14], 9);
> + JJJ (ddd, eee, aaa, bbb, ccc, X[7], 9);
> + JJJ (ccc, ddd, eee, aaa, bbb, X[0], 11);
> + JJJ (bbb, ccc, ddd, eee, aaa, X[9], 13);
> + JJJ (aaa, bbb, ccc, ddd, eee, X[2], 15);
> + JJJ (eee, aaa, bbb, ccc, ddd, X[11], 15);
> + JJJ (ddd, eee, aaa, bbb, ccc, X[4], 5);
> + JJJ (ccc, ddd, eee, aaa, bbb, X[13], 7);
> + JJJ (bbb, ccc, ddd, eee, aaa, X[6], 7);
> + JJJ (aaa, bbb, ccc, ddd, eee, X[15], 8);
> + JJJ (eee, aaa, bbb, ccc, ddd, X[8], 11);
> + JJJ (ddd, eee, aaa, bbb, ccc, X[1], 14);
> + JJJ (ccc, ddd, eee, aaa, bbb, X[10], 14);
> + JJJ (bbb, ccc, ddd, eee, aaa, X[3], 12);
> + JJJ (aaa, bbb, ccc, ddd, eee, X[12], 6);
> +
> + /* parallel round 2 */
> + III (eee, aaa, bbb, ccc, ddd, X[6], 9);
> + III (ddd, eee, aaa, bbb, ccc, X[11], 13);
> + III (ccc, ddd, eee, aaa, bbb, X[3], 15);
> + III (bbb, ccc, ddd, eee, aaa, X[7], 7);
> + III (aaa, bbb, ccc, ddd, eee, X[0], 12);
> + III (eee, aaa, bbb, ccc, ddd, X[13], 8);
> + III (ddd, eee, aaa, bbb, ccc, X[5], 9);
> + III (ccc, ddd, eee, aaa, bbb, X[10], 11);
> + III (bbb, ccc, ddd, eee, aaa, X[14], 7);
> + III (aaa, bbb, ccc, ddd, eee, X[15], 7);
> + III (eee, aaa, bbb, ccc, ddd, X[8], 12);
> + III (ddd, eee, aaa, bbb, ccc, X[12], 7);
> + III (ccc, ddd, eee, aaa, bbb, X[4], 6);
> + III (bbb, ccc, ddd, eee, aaa, X[9], 15);
> + III (aaa, bbb, ccc, ddd, eee, X[1], 13);
> + III (eee, aaa, bbb, ccc, ddd, X[2], 11);
> +
> + /* parallel round 3 */
> + HHH (ddd, eee, aaa, bbb, ccc, X[15], 9);
> + HHH (ccc, ddd, eee, aaa, bbb, X[5], 7);
> + HHH (bbb, ccc, ddd, eee, aaa, X[1], 15);
> + HHH (aaa, bbb, ccc, ddd, eee, X[3], 11);
> + HHH (eee, aaa, bbb, ccc, ddd, X[7], 8);
> + HHH (ddd, eee, aaa, bbb, ccc, X[14], 6);
> + HHH (ccc, ddd, eee, aaa, bbb, X[6], 6);
> + HHH (bbb, ccc, ddd, eee, aaa, X[9], 14);
> + HHH (aaa, bbb, ccc, ddd, eee, X[11], 12);
> + HHH (eee, aaa, bbb, ccc, ddd, X[8], 13);
> + HHH (ddd, eee, aaa, bbb, ccc, X[12], 5);
> + HHH (ccc, ddd, eee, aaa, bbb, X[2], 14);
> + HHH (bbb, ccc, ddd, eee, aaa, X[10], 13);
> + HHH (aaa, bbb, ccc, ddd, eee, X[0], 13);
> + HHH (eee, aaa, bbb, ccc, ddd, X[4], 7);
> + HHH (ddd, eee, aaa, bbb, ccc, X[13], 5);
> +
> + /* parallel round 4 */
> + GGG (ccc, ddd, eee, aaa, bbb, X[8], 15);
> + GGG (bbb, ccc, ddd, eee, aaa, X[6], 5);
> + GGG (aaa, bbb, ccc, ddd, eee, X[4], 8);
> + GGG (eee, aaa, bbb, ccc, ddd, X[1], 11);
> + GGG (ddd, eee, aaa, bbb, ccc, X[3], 14);
> + GGG (ccc, ddd, eee, aaa, bbb, X[11], 14);
> + GGG (bbb, ccc, ddd, eee, aaa, X[15], 6);
> + GGG (aaa, bbb, ccc, ddd, eee, X[0], 14);
> + GGG (eee, aaa, bbb, ccc, ddd, X[5], 6);
> + GGG (ddd, eee, aaa, bbb, ccc, X[12], 9);
> + GGG (ccc, ddd, eee, aaa, bbb, X[2], 12);
> + GGG (bbb, ccc, ddd, eee, aaa, X[13], 9);
> + GGG (aaa, bbb, ccc, ddd, eee, X[9], 12);
> + GGG (eee, aaa, bbb, ccc, ddd, X[7], 5);
> + GGG (ddd, eee, aaa, bbb, ccc, X[10], 15);
> + GGG (ccc, ddd, eee, aaa, bbb, X[14], 8);
> +
> + /* parallel round 5 */
> + FFF (bbb, ccc, ddd, eee, aaa, X[12], 8);
> + FFF (aaa, bbb, ccc, ddd, eee, X[15], 5);
> + FFF (eee, aaa, bbb, ccc, ddd, X[10], 12);
> + FFF (ddd, eee, aaa, bbb, ccc, X[4], 9);
> + FFF (ccc, ddd, eee, aaa, bbb, X[1], 12);
> + FFF (bbb, ccc, ddd, eee, aaa, X[5], 5);
> + FFF (aaa, bbb, ccc, ddd, eee, X[8], 14);
> + FFF (eee, aaa, bbb, ccc, ddd, X[7], 6);
> + FFF (ddd, eee, aaa, bbb, ccc, X[6], 8);
> + FFF (ccc, ddd, eee, aaa, bbb, X[2], 13);
> + FFF (bbb, ccc, ddd, eee, aaa, X[13], 6);
> + FFF (aaa, bbb, ccc, ddd, eee, X[14], 5);
> + FFF (eee, aaa, bbb, ccc, ddd, X[0], 15);
> + FFF (ddd, eee, aaa, bbb, ccc, X[3], 13);
> + FFF (ccc, ddd, eee, aaa, bbb, X[9], 11);
> + FFF (bbb, ccc, ddd, eee, aaa, X[11], 11);
> +
> + /* combine results */
> + ddd += cc + MDbuf[1]; /* final result for MDbuf[0] */
> + MDbuf[1] = MDbuf[2] + dd + eee;
> + MDbuf[2] = MDbuf[3] + ee + aaa;
> + MDbuf[3] = MDbuf[4] + aa + bbb;
> + MDbuf[4] = MDbuf[0] + bb + ccc;
> + MDbuf[0] = ddd;
>
> - return;
> + return;
> }
>
> /********************************************************************/
>
> -static void MDfinish(dword *MDbuf, const byte *strptr, dword lswlen, dword mswlen)
> +static void
> +MDfinish (dword * MDbuf, const byte * strptr, dword lswlen, dword mswlen)
> {
> - unsigned int i; /* counter */
> - dword X[16]; /* message words */
> + unsigned int i; /* counter */
> + dword X[16]; /* message words */
>
> - grub_memset(X, 0, 16*sizeof(dword));
> + grub_memset (X, 0, 16 * sizeof (dword));
>
> - /* put bytes from strptr into X */
> - for (i=0; i<(lswlen&63); i++) {
> + /* put bytes from strptr into X */
> + for (i = 0; i < (lswlen & 63); i++)
> + {
> /* byte i goes into word X[i div 4] at pos. 8*(i mod 4) */
> - X[i>>2] ^= (dword) *strptr++ << (8 * (i&3));
> - }
> + X[i >> 2] ^= (dword) * strptr++ << (8 * (i & 3));
> + }
>
> - /* append the bit m_n == 1 */
> - X[(lswlen>>2)&15] ^= (dword)1 << (8*(lswlen&3) + 7);
> + /* append the bit m_n == 1 */
> + X[(lswlen >> 2) & 15] ^= (dword) 1 << (8 * (lswlen & 3) + 7);
>
> - if ((lswlen & 63) > 55) {
> + if ((lswlen & 63) > 55)
> + {
> /* length goes to next block */
> - compress(MDbuf, X);
> - grub_memset(X, 0, 16*sizeof(dword));
> - }
> + compress (MDbuf, X);
> + grub_memset (X, 0, 16 * sizeof (dword));
> + }
> +
> + /* append length in bits */
> + X[14] = lswlen << 3;
> + X[15] = (lswlen >> 29) | (mswlen << 3);
> + compress (MDbuf, X);
>
> - /* append length in bits*/
> - X[14] = lswlen << 3;
> - X[15] = (lswlen >> 29) | (mswlen << 3);
> - compress(MDbuf, X);
> -
> - return;
> + return;
> }
>
> /*** GNU GRUB2 interface ***/
>
> #define RMDsize 160
>
> -static grub_err_t grub_hash_rmd160_fn(grub_cipher_params_t params, char *out,
> - const char *in, grub_size_t insize)
> +static grub_err_t
> +grub_hash_rmd160_fn (grub_cipher_params_t params, char *out,
> + const char *in, grub_size_t insize)
> {
> - dword MDbuf[RMDsize/32]; /* contains (A, B, C, D(, E)) */
> - dword X[16]; /* current 16-word chunk */
> - unsigned int i; /* counter */
> - dword nbytes; /* # of bytes not yet processed */
> -
> - /* initialize */
> - MDinit(MDbuf);
> -
> - /* process message in 16-word chunks */
> - for (nbytes=insize; nbytes > 63; nbytes-=64) {
> - for (i=0; i<16; i++) {
> - X[i] = BYTES_TO_DWORD(in);
> - in += 4;
> - }
> - compress(MDbuf, X);
> - } /* length mod 64 bytes left */
> -
> - /* finish: */
> - MDfinish(MDbuf, (const byte *)in, insize, 0);
> -
> - for (i=0; i<RMDsize/8; i+=4) {
> - out[i] = MDbuf[i>>2]; /* implicit cast to byte */
> - out[i+1] = (MDbuf[i>>2] >> 8); /* extracts the 8 least */
> - out[i+2] = (MDbuf[i>>2] >> 16); /* significant bits. */
> - out[i+3] = (MDbuf[i>>2] >> 24);
> - }
> + dword MDbuf[RMDsize / 32]; /* contains (A, B, C, D(, E)) */
> + dword X[16]; /* current 16-word chunk */
> + unsigned int i; /* counter */
> + dword nbytes; /* # of bytes not yet processed */
> +
> + /* initialize */
> + MDinit (MDbuf);
> +
> + /* process message in 16-word chunks */
> + for (nbytes = insize; nbytes > 63; nbytes -= 64)
> + {
> + for (i = 0; i < 16; i++)
> + {
> + X[i] = BYTES_TO_DWORD (in);
> + in += 4;
> + }
> + compress (MDbuf, X);
> + } /* length mod 64 bytes left */
> +
> + /* finish: */
> + MDfinish (MDbuf, (const byte *) in, insize, 0);
> +
> + for (i = 0; i < RMDsize / 8; i += 4)
> + {
> + out[i] = MDbuf[i >> 2]; /* implicit cast to byte */
> + out[i + 1] = (MDbuf[i >> 2] >> 8); /* extracts the 8 least */
> + out[i + 2] = (MDbuf[i >> 2] >> 16); /* significant bits. */
> + out[i + 3] = (MDbuf[i >> 2] >> 24);
> + }
>
> - return GRUB_ERR_NONE;
> + return GRUB_ERR_NONE;
> }
>
> static struct grub_cipher grub_cipher_rmd160 = {
> .name = "ripemd160",
> .type = GRUB_CIPHER_TYPE_HASH,
> - .keysizes = (const unsigned int[]){ 20 },
> + .keysizes = (const unsigned int[]) {20},
> .keysizes_length = 1,
>
> .u.hash = {
> - .fn = grub_hash_rmd160_fn
> - }
> + .fn = grub_hash_rmd160_fn}
> };
>
> -GRUB_MOD_INIT(ripemd160)
> +GRUB_MOD_INIT (ripemd160)
> {
> - (void)mod; /* To stop warning. */
> - grub_crypto_cipher_register(&grub_cipher_rmd160);
> + grub_crypto_cipher_register (&grub_cipher_rmd160);
> }
>
> -GRUB_MOD_FINI(ripemd160)
> +GRUB_MOD_FINI (ripemd160)
> {
> - grub_crypto_cipher_unregister(&grub_cipher_rmd160);
> + grub_crypto_cipher_unregister (&grub_cipher_rmd160);
> }
> diff -u -r -x CVS -N grub2/disk/devmapper.c grub2-new/disk/devmapper.c
> --- grub2/disk/devmapper.c 2007-09-03 20:40:37.000000000 +0200
> +++ grub2-new/disk/devmapper.c 2007-09-03 20:26:27.000000000 +0200
> @@ -41,19 +41,20 @@
>
> struct grub_crypto
> {
> - char *devname, *source_devname;
> - int has_partitions;
> - grub_cipher_params_t cipher;
> - grub_disk_t srcdisk;
> + char *devname, *source_devname;
> + int has_partitions;
> + grub_cipher_params_t cipher;
> + grub_disk_t srcdisk;
>
> struct grub_crypto *next;
> };
>
> typedef struct grub_crypto *grub_crypto_t;
>
> -struct crypto_private {
> - grub_crypto_t crypto;
> - grub_disk_t srcdisk;
> +struct crypto_private
> +{
> + grub_crypto_t crypto;
> + grub_disk_t srcdisk;
> };
>
> typedef struct crypto_private *crypto_private_t;
> @@ -62,174 +63,208 @@
>
> /* Delete a registered crypto device. */
> static grub_err_t
> -delete_crypto(const char *name)
> +delete_crypto (const char *name)
> {
> grub_crypto_t dev, *prev;
>
> /* Search for the device */
> - for(dev = crypto_list, prev = &crypto_list; dev; prev = &dev->next, dev = dev->next)
> - if(grub_strcmp(dev->devname, name) == 0)
> + for (dev = crypto_list, prev = &crypto_list; dev;
> + prev = &dev->next, dev = dev->next)
> + if (grub_strcmp (dev->devname, name) == 0)
> break;
>
> - if(!dev)
> - return grub_error(GRUB_ERR_BAD_DEVICE, "Device not found");
> + if (!dev)
> + return grub_error (GRUB_ERR_BAD_DEVICE, "Device not found");
>
> /* Remove the device from the list */
> *prev = dev->next;
> - grub_free(dev->devname);
> - grub_free(dev->source_devname);
> - grub_crypto_delete_cipher(dev->cipher);
> - grub_free(dev);
> + grub_free (dev->devname);
> + grub_free (dev->source_devname);
> + grub_crypto_delete_cipher (dev->cipher);
> + grub_free (dev);
>
> return GRUB_ERR_NONE;
> }
>
> /* Hashes a passphrase into a key and stores it with cipher. */
> static grub_err_t
> -set_passphrase(grub_crypto_t dev, grub_cipher_params_t hashparams,
> - const char *passphrase)
> +set_passphrase (grub_crypto_t dev, grub_cipher_params_t hashparams,
> + const char *passphrase)
> {
> - char hash[MAX_KEYSIZE * 2], *p, *key = hash;
> - grub_err_t err = GRUB_ERR_NONE;
> - unsigned int round, i, size = dev->cipher->keysize,
> + char hash[MAX_KEYSIZE * 2], *p, *key = hash;
> + grub_err_t err = GRUB_ERR_NONE;
> + unsigned int round, i, size = dev->cipher->keysize,
> len = hashparams->keysize;
>
> /* Need no passphrase if there's no key */
> - if(size == 0)
> + if (size == 0)
> return err;
>
> /* Hack to support the "none" hash */
> - if(!grub_strcmp(hashparams->cipher->name, "none"))
> - len = hashparams->keysize = grub_strlen(passphrase);
> -
> - if(size > MAX_KEYSIZE || len > MAX_KEYSIZE)
> - return grub_error(GRUB_ERR_BAD_ARGUMENT, "Requested key size too large");
> -
> - p = grub_malloc(grub_strlen(passphrase) + 2 + size / len);
> - if(!p) return grub_errno;
> -
> - for(round = 0; size; round++, key += len, size -= len) {
> - /* hack from hashalot to avoid null bytes in key */
> - for(i = 0; i < round; i++)
> - p[i] = 'A';
> + if (!grub_strcmp (hashparams->cipher->name, "none"))
> + len = hashparams->keysize = grub_strlen (passphrase);
>
> - grub_strcpy(p + i, passphrase);
> + if (size > MAX_KEYSIZE || len > MAX_KEYSIZE)
> + return grub_error (GRUB_ERR_BAD_ARGUMENT, "Requested key size too large");
>
> - if(len > size)
> - len = size;
> + p = grub_malloc (grub_strlen (passphrase) + 2 + size / len);
> + if (!p)
> + return grub_errno;
>
> - if((err = grub_crypto_hash(hashparams, key, p, grub_strlen(p))) != GRUB_ERR_NONE)
> - goto err_out;
> - }
> + for (round = 0; size; round++, key += len, size -= len)
> + {
> + /* hack from hashalot to avoid null bytes in key */
> + for (i = 0; i < round; i++)
> + p[i] = 'A';
> +
> + grub_strcpy (p + i, passphrase);
> +
> + if (len > size)
> + len = size;
> +
> + if ((err =
> + grub_crypto_hash (hashparams, key, p,
> + grub_strlen (p))) != GRUB_ERR_NONE)
> + goto err_out;
> + }
>
> - err = grub_crypto_set_key(dev->cipher, hash);
> + err = grub_crypto_set_key (dev->cipher, hash);
>
> - err_out:
> - grub_free(p);
> +err_out:
> + grub_free (p);
> return err;
> }
>
> /***** GRUB command line interface *****************************************/
>
> static int
> -cipher_print_hook(grub_cipher_t cipher, void *data)
> +cipher_print_hook (grub_cipher_t cipher, void *data)
> {
> - grub_cipher_type_t type = (grub_cipher_type_t)data;
> + grub_cipher_type_t type = (grub_cipher_type_t) data;
>
> - if(cipher->type == type)
> - grub_printf("%s\n", cipher->name);
> + if (cipher->type == type)
> + grub_printf ("%s\n", cipher->name);
>
> return 0;
> }
>
> /* List all known ciphers and hashes */
> static void
> -list_ciphers(void)
> +list_ciphers (void)
> {
> - grub_printf("Known ciphers:\n");
> - grub_crypto_cipher_iterate(cipher_print_hook, (void *)GRUB_CIPHER_TYPE_CIPHER);
> -
> - grub_printf("\nKnown hashes:\n");
> - grub_crypto_cipher_iterate(cipher_print_hook, (void *)GRUB_CIPHER_TYPE_HASH);
> -}
> -
> -static const struct grub_arg_option options[] =
> - {
> - {"delete", 'd', 0, "delete the crypto device entry", 0, ARG_TYPE_NONE},
> - {"partitions", 'p', 0, "set that the device has partitions", 0, ARG_TYPE_NONE},
> - {"cipher", 'c', 0, "set cipher (default=" DEFAULT_CIPHER ")", 0, ARG_TYPE_STRING},
> - {"hash", 'h', 0, "set hash function (default=" DEFAULT_HASH ")", 0, ARG_TYPE_STRING},
> - {"passphrase", 'P', 0, "set decryption passphrase", 0, ARG_TYPE_STRING},
> - {"list", 'l', 0, "list known ciphers and hashes", 0, ARG_TYPE_NONE},
> - {"keysize", 'k', 0, "set key size (default is cipher specific)", 0, ARG_TYPE_INT},
> - {0, 0, 0, 0, 0, 0}
> - };
> + grub_printf ("Known ciphers:\n");
> + grub_crypto_cipher_iterate (cipher_print_hook,
> + (void *) GRUB_CIPHER_TYPE_CIPHER);
> +
> + grub_printf ("\nKnown hashes:\n");
> + grub_crypto_cipher_iterate (cipher_print_hook,
> + (void *) GRUB_CIPHER_TYPE_HASH);
> +}
> +
> +static const struct grub_arg_option options[] = {
> + {"delete", 'd', 0, "delete the crypto device entry", 0, ARG_TYPE_NONE},
> + {"partitions", 'p', 0, "set that the device has partitions", 0,
> + ARG_TYPE_NONE},
> + {"cipher", 'c', 0, "set cipher (default=" DEFAULT_CIPHER ")", 0,
> + ARG_TYPE_STRING},
> + {"hash", 'h', 0, "set hash function (default=" DEFAULT_HASH ")", 0,
> + ARG_TYPE_STRING},
> + {"passphrase", 'P', 0, "set decryption passphrase", 0, ARG_TYPE_STRING},
> + {"list", 'l', 0, "list known ciphers and hashes", 0, ARG_TYPE_NONE},
> + {"keysize", 'k', 0, "set key size (default is cipher specific)", 0,
> + ARG_TYPE_INT},
> + {0, 0, 0, 0, 0, 0}
> +};
>
> static grub_err_t
> -grub_cmd_devmap(struct grub_arg_list *state, int argc, char **args)
> +grub_cmd_devmap (struct grub_arg_list *state, int argc, char **args)
> {
> - grub_disk_t disk;
> - grub_crypto_t newdev;
> - const char *cipher, *hash;
> - grub_cipher_params_t hashparams;
> - grub_err_t err = GRUB_ERR_NONE;
> - char *passphrase = "", cmdphrase[MAX_PASSPHRASE];
> + grub_disk_t disk;
> + grub_crypto_t newdev;
> + const char *cipher, *hash;
> + grub_cipher_params_t hashparams;
> + grub_err_t err = GRUB_ERR_NONE;
> + char *passphrase = "", cmdphrase[MAX_PASSPHRASE];
>
> /* Check whether cipher list is requested */
> - if(state[5].set) {
> - list_ciphers();
> - return 0;
> - }
> + if (state[5].set)
> + {
> + list_ciphers ();
> + return 0;
> + }
>
> - if(argc < 1)
> - return grub_error(GRUB_ERR_BAD_ARGUMENT, "Device name required");
> + if (argc < 1)
> + return grub_error (GRUB_ERR_BAD_ARGUMENT, "Device name required");
>
> /* Check whether delete is requested */
> - if(state[0].set)
> - return delete_crypto(args[0]);
> + if (state[0].set)
> + return delete_crypto (args[0]);
>
> - if(argc < 2)
> - return grub_error(GRUB_ERR_BAD_ARGUMENT, "Source device name required");
> + if (argc < 2)
> + return grub_error (GRUB_ERR_BAD_ARGUMENT, "Source device name required");
>
> /*** Create device is requested ***/
>
> - /* Choke on alrady existing devices */
> - for(newdev = crypto_list; newdev != NULL; newdev = newdev->next)
> - if(grub_strcmp(newdev->devname, args[0]) == 0)
> - return grub_error(GRUB_ERR_BAD_ARGUMENT, "Device already exists");
> + /* Choke on already existing devices */
> + for (newdev = crypto_list; newdev != NULL; newdev = newdev->next)
> + if (grub_strcmp (newdev->devname, args[0]) == 0)
> + return grub_error (GRUB_ERR_BAD_ARGUMENT, "Device already exists");
>
> /* Check whether source device can be opened */
> - disk = grub_disk_open(args[1]);
> - if(!disk) return grub_errno;
> - grub_disk_close(disk);
> + disk = grub_disk_open (args[1]);
> + if (!disk)
> + return grub_errno;
> + grub_disk_close (disk);
>
> /* Parse remaining options */
> - if(state[2].set) cipher = state[2].arg; else cipher = DEFAULT_CIPHER;
> - if(state[3].set) hash = state[3].arg; else hash = DEFAULT_HASH;
> + if (state[2].set)
> + cipher = state[2].arg;
> + else
> + cipher = DEFAULT_CIPHER;
> + if (state[3].set)
> + hash = state[3].arg;
> + else
> + hash = DEFAULT_HASH;
>
> /* Create new device entry */
> - if(!(newdev = grub_malloc(sizeof(struct grub_crypto)))) return grub_errno;
> - if(!(newdev->devname = grub_strdup(args[0]))) { err = grub_errno; goto err_out; }
> - if(!(newdev->source_devname = grub_strdup(args[1]))) { err = grub_errno; goto err2_out; }
> + if (!(newdev = grub_malloc (sizeof (struct grub_crypto))))
> + return grub_errno;
> + if (!(newdev->devname = grub_strdup (args[0])))
> + {
> + err = grub_errno;
> + goto err_out;
> + }
> + if (!(newdev->source_devname = grub_strdup (args[1])))
> + {
> + err = grub_errno;
> + goto err2_out;
> + }
> newdev->has_partitions = state[1].set;
> - err = grub_crypto_new_cipher(&newdev->cipher, cipher, GRUB_CIPHER_TYPE_CIPHER);
> - if(err != GRUB_ERR_NONE) goto err3_out;
> - err = grub_crypto_new_cipher(&hashparams, hash, GRUB_CIPHER_TYPE_HASH);
> - if(err != GRUB_ERR_NONE) goto err4_out;
> + err =
> + grub_crypto_new_cipher (&newdev->cipher, cipher, GRUB_CIPHER_TYPE_CIPHER);
> + if (err != GRUB_ERR_NONE)
> + goto err3_out;
> + err = grub_crypto_new_cipher (&hashparams, hash, GRUB_CIPHER_TYPE_HASH);
> + if (err != GRUB_ERR_NONE)
> + goto err4_out;
> newdev->srcdisk = NULL;
> - if(state[6].set)
> - newdev->cipher->keysize = grub_strtoul(state[6].arg, NULL, 10);
> + if (state[6].set)
> + newdev->cipher->keysize = grub_strtoul (state[6].arg, NULL, 10);
>
> /* Get passphrase */
> - if(state[4].set) /* Passphrase supplied on commandline */
> + if (state[4].set) /* Passphrase supplied on commandline */
> passphrase = state[4].arg;
> - else {
> - if(grub_strcmp(cipher, "none")) {
> - grub_cmdline_get("Passphrase: ", cmdphrase, MAX_PASSPHRASE, '*', 0);
> - passphrase = cmdphrase;
> + else
> + {
> + if (grub_strcmp (cipher, "none"))
> + {
> + grub_cmdline_get ("Passphrase: ", cmdphrase, MAX_PASSPHRASE, '*',
> + 0);
> + passphrase = cmdphrase;
> + }
> }
> - }
> - if((err = set_passphrase(newdev, hashparams, passphrase)) != GRUB_ERR_NONE)
> + if ((err =
> + set_passphrase (newdev, hashparams, passphrase)) != GRUB_ERR_NONE)
> goto errp_out;
>
> /* Add new entry to list and return */
> @@ -237,17 +272,18 @@
> crypto_list = newdev;
>
> /* Error conditions */
> - errp_out:
> - grub_crypto_delete_cipher(hashparams);
> - if(err == GRUB_ERR_NONE) return 0;
> - err4_out:
> - grub_crypto_delete_cipher(newdev->cipher);
> - err3_out:
> - grub_free(newdev->source_devname);
> - err2_out:
> - grub_free(newdev->devname);
> - err_out:
> - grub_free(newdev);
> +errp_out:
> + grub_crypto_delete_cipher (hashparams);
> + if (err == GRUB_ERR_NONE)
> + return 0;
> +err4_out:
> + grub_crypto_delete_cipher (newdev->cipher);
> +err3_out:
> + grub_free (newdev->source_devname);
> +err2_out:
> + grub_free (newdev->devname);
> +err_out:
> + grub_free (newdev);
> return err;
> }
>
> @@ -259,7 +295,7 @@
> grub_crypto_t i;
>
> for (i = crypto_list; i != NULL; i = i->next)
> - if(hook(i->devname))
> + if (hook (i->devname))
> return 1;
>
> return 0;
> @@ -268,30 +304,31 @@
> static grub_err_t
> grub_crypto_open (const char *name, grub_disk_t disk)
> {
> - grub_crypto_t dev;
> - crypto_private_t private;
> + grub_crypto_t dev;
> + crypto_private_t private;
>
> - for(dev = crypto_list; dev != NULL; dev = dev->next)
> - if(grub_strcmp(dev->devname, name) == 0)
> + for (dev = crypto_list; dev != NULL; dev = dev->next)
> + if (grub_strcmp (dev->devname, name) == 0)
> break;
>
> - if(!dev)
> - return grub_error(GRUB_ERR_UNKNOWN_DEVICE, "Can't open device");
> + if (!dev)
> + return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "Can't open device");
>
> /* Setup crypto private structure */
> - if(!(private = grub_malloc(sizeof(struct crypto_private))))
> + if (!(private = grub_malloc (sizeof (struct crypto_private))))
> return grub_errno;
> private->crypto = dev;
>
> /* Open underlying device */
> - private->srcdisk = grub_disk_open(dev->source_devname);
> - if(!private->srcdisk) {
> - return grub_errno;
> - }
> + private->srcdisk = grub_disk_open (dev->source_devname);
> + if (!private->srcdisk)
> + {
> + return grub_errno;
> + }
>
> /* Populate requested disk */
> - disk->total_sectors = grub_disk_get_size(private->srcdisk);
> - disk->id = (int)dev;
> + disk->total_sectors = grub_disk_get_size (private->srcdisk);
> + disk->id = (int) dev;
> disk->has_partitions = dev->has_partitions;
> disk->data = private;
>
> @@ -301,40 +338,42 @@
> static void
> grub_crypto_close (grub_disk_t disk)
> {
> - crypto_private_t private = (crypto_private_t)disk->data;
> -/* char buf[48]; */
> -
> -/* grub_disk_read(disk, 0, 0, 48, buf); */
> -/* grub_printf("disk id: %-48s\n", buf); */
> + crypto_private_t private = (crypto_private_t) disk->data;
>
> - grub_disk_close(private->srcdisk);
> - grub_free(private);
> + grub_disk_close (private->srcdisk);
> + grub_free (private);
> }
>
> static grub_err_t
> grub_crypto_read (grub_disk_t disk, grub_disk_addr_t sector,
> grub_size_t size, char *buf)
> {
> - crypto_private_t private = (crypto_private_t)disk->data;
> - grub_err_t err;
> - grub_cipher_params_t cipher = private->crypto->cipher;
> - grub_size_t i;
> + crypto_private_t private = (crypto_private_t) disk->data;
> + grub_err_t err;
> + grub_cipher_params_t cipher = private->crypto->cipher;
> + grub_size_t i;
>
> /* Read sectors from underlying disk */
> - err = grub_disk_read(private->srcdisk, sector, 0, size << GRUB_DISK_SECTOR_BITS, buf);
> - if(err) return err;
> + err =
> + grub_disk_read (private->srcdisk, sector, 0,
> + size << GRUB_DISK_SECTOR_BITS, buf);
> + if (err)
> + return err;
>
> /* Decrypt sectors */
> - for(i = 0; i < size; i++) {
> - grub_disk_addr_t s = sector + i;
> + for (i = 0; i < size; i++)
> + {
> + grub_disk_addr_t s = sector + i;
> +
> + /* Set IV from raw sector number (plain mode) */
> + grub_memset (cipher->u.cipher.iv, 0, cipher->u.cipher.iv_length);
> + grub_memcpy (cipher->u.cipher.iv, &s,
> + MIN (sizeof (grub_disk_addr_t),
> + cipher->u.cipher.iv_length));
>
> - /* Set IV from raw sector number (plain mode) */
> - grub_memset(cipher->u.cipher.iv, 0, cipher->u.cipher.iv_length);
> - grub_memcpy(cipher->u.cipher.iv, &s, MIN(sizeof(grub_disk_addr_t), cipher->u.cipher.iv_length));
> -
> - grub_crypto_decrypt_inplace(cipher, buf + (i << GRUB_DISK_SECTOR_BITS),
> - GRUB_DISK_SECTOR_SIZE);
> - }
> + grub_crypto_decrypt_inplace (cipher, buf + (i << GRUB_DISK_SECTOR_BITS),
> + GRUB_DISK_SECTOR_SIZE);
> + }
>
> return 0;
> }
> @@ -348,31 +387,30 @@
> return GRUB_ERR_NOT_IMPLEMENTED_YET;
> }
>
> -static struct grub_disk_dev grub_crypto_dev =
> - {
> - .name = "crypto",
> - .id = GRUB_DISK_DEVICE_CRYPTO_ID,
> - .iterate = grub_crypto_iterate,
> - .open = grub_crypto_open,
> - .close = grub_crypto_close,
> - .read = grub_crypto_read,
> - .write = grub_crypto_write,
> - .next = 0
> - };
> +static struct grub_disk_dev grub_crypto_dev = {
> + .name = "crypto",
> + .id = GRUB_DISK_DEVICE_CRYPTO_ID,
> + .iterate = grub_crypto_iterate,
> + .open = grub_crypto_open,
> + .close = grub_crypto_close,
> + .read = grub_crypto_read,
> + .write = grub_crypto_write,
> + .next = 0
> +};
>
> /***** GRUB module (de-)initialization *************************************/
>
> -GRUB_MOD_INIT(devmapper)
> +GRUB_MOD_INIT (devmapper)
> {
> - (void)mod; /* To stop warning. */
> - grub_register_command("devmap", grub_cmd_devmap, GRUB_COMMAND_FLAG_BOTH,
> - "devmap [OPTIONS...] [DEVICE] [SRC-DEV]",
> - "Map one device onto another (w/ cryptography support).", options);
> - grub_disk_dev_register(&grub_crypto_dev);
> + grub_register_command ("devmap", grub_cmd_devmap, GRUB_COMMAND_FLAG_BOTH,
> + "devmap [OPTIONS...] [DEVICE] [SRC-DEV]",
> + "Map one device onto another (w/ cryptography support).",
> + options);
> + grub_disk_dev_register (&grub_crypto_dev);
> }
>
> -GRUB_MOD_FINI(devmapper)
> +GRUB_MOD_FINI (devmapper)
> {
> - grub_unregister_command("devmap");
> - grub_disk_dev_unregister(&grub_crypto_dev);
> + grub_unregister_command ("devmap");
> + grub_disk_dev_unregister (&grub_crypto_dev);
> }
> diff -u -r -x CVS -N grub2/include/grub/crypto.h grub2-new/include/grub/crypto.h
> --- grub2/include/grub/crypto.h 2007-09-03 20:40:37.000000000 +0200
> +++ grub2-new/include/grub/crypto.h 2007-09-03 20:26:04.000000000 +0200
> @@ -27,11 +27,11 @@
> #include <grub/types.h>
>
> enum grub_cipher_type
> - {
> - GRUB_CIPHER_TYPE_NONE = 0,
> - GRUB_CIPHER_TYPE_CIPHER = 1,
> - GRUB_CIPHER_TYPE_HASH = 2
> - };
> +{
> + GRUB_CIPHER_TYPE_NONE = 0,
> + GRUB_CIPHER_TYPE_CIPHER,
> + GRUB_CIPHER_TYPE_HASH
> +};
>
> typedef enum grub_cipher_type grub_cipher_type_t;
>
> @@ -40,26 +40,36 @@
>
> struct grub_cipher
> {
> - const char *name;
> - grub_cipher_type_t type;
> - const unsigned int *keysizes, keysizes_length;
> + const char *name;
> + grub_cipher_type_t type;
> + const unsigned int *keysizes, keysizes_length;
>
> - grub_err_t (*init)(grub_cipher_params_t);
> - void (*deinit)(grub_cipher_params_t);
> + grub_err_t (*init) (grub_cipher_params_t);
> + void (*deinit) (grub_cipher_params_t);
>
> - union {
> - struct {
> + union
> + {
> + struct
> + {
> const unsigned int *ivsizes, ivsizes_length;
>
> - grub_err_t (*set_key)(grub_cipher_params_t, const char *key);
> - grub_err_t (*encrypt)(grub_cipher_params_t, char **out, const char *in, grub_size_t *outsize, grub_size_t insize);
> - grub_err_t (*decrypt)(grub_cipher_params_t, char **out, const char *in, grub_size_t *outsize, grub_size_t insize);
> - grub_err_t (*decrypt_inplace)(grub_cipher_params_t, char *buf, grub_size_t size);
> - grub_err_t (*encrypt_inplace)(grub_cipher_params_t, char *buf, grub_size_t size);
> + grub_err_t (*set_key) (grub_cipher_params_t, const char *key);
> + grub_err_t (*encrypt) (grub_cipher_params_t, char **out,
> + const char *in, grub_size_t * outsize,
> + grub_size_t insize);
> + grub_err_t (*decrypt) (grub_cipher_params_t, char **out,
> + const char *in, grub_size_t * outsize,
> + grub_size_t insize);
> + grub_err_t (*decrypt_inplace) (grub_cipher_params_t, char *buf,
> + grub_size_t size);
> + grub_err_t (*encrypt_inplace) (grub_cipher_params_t, char *buf,
> + grub_size_t size);
> } cipher;
>
> - struct {
> - grub_err_t (*fn)(grub_cipher_params_t, char *out, const char *in, grub_size_t insize);
> + struct
> + {
> + grub_err_t (*fn) (grub_cipher_params_t, char *out, const char *in,
> + grub_size_t insize);
> } hash;
> } u;
> };
> @@ -68,39 +78,48 @@
>
> struct grub_cipher_params
> {
> - grub_cipher_t cipher;
> - void *private;
> - unsigned int keysize;
> -
> - union {
> - struct {
> - unsigned char *iv;
> - unsigned int iv_length;
> + grub_cipher_t cipher;
> + void *private;
> + unsigned int keysize;
> +
> + union
> + {
> + struct
> + {
> + unsigned char *iv;
> + unsigned int iv_length;
> } cipher;
> } u;
> };
>
> -typedef int (*grub_crypto_hook)(grub_cipher_t, void *);
> +typedef int (*grub_crypto_hook) (grub_cipher_t, void *);
>
> -grub_err_t EXPORT_FUNC(grub_crypto_encrypt)(grub_cipher_params_t params, char **out,
> - const char *in, grub_size_t *outsize,
> - grub_size_t insize);
> -grub_err_t EXPORT_FUNC(grub_crypto_decrypt)(grub_cipher_params_t params, char **out,
> - const char *in, grub_size_t *outsize,
> - grub_size_t insize);
> -grub_err_t EXPORT_FUNC(grub_crypto_decrypt_inplace)(grub_cipher_params_t params,
> - char *buf, grub_size_t size);
> -grub_err_t EXPORT_FUNC(grub_crypto_encrypt_inplace)(grub_cipher_params_t params,
> - char *buf, grub_size_t size);
> -grub_err_t EXPORT_FUNC(grub_crypto_set_key)(grub_cipher_params_t params, const char *key);
> -int EXPORT_FUNC(grub_crypto_cipher_iterate)(grub_crypto_hook hook, void *data);
> -grub_err_t EXPORT_FUNC(grub_crypto_hash)(grub_cipher_params_t params,
> - char *hash, const char *payload,
> - unsigned int size);
> -grub_err_t EXPORT_FUNC(grub_crypto_new_cipher)(grub_cipher_params_t *params,
> - const char *name, grub_cipher_type_t type);
> -void EXPORT_FUNC(grub_crypto_delete_cipher)(grub_cipher_params_t params);
> -void EXPORT_FUNC(grub_crypto_cipher_register)(grub_cipher_t cipher);
> -void EXPORT_FUNC(grub_crypto_cipher_unregister)(grub_cipher_t cipher);
> +grub_err_t EXPORT_FUNC (grub_crypto_encrypt) (grub_cipher_params_t params,
> + char **out, const char *in,
> + grub_size_t * outsize,
> + grub_size_t insize);
> +grub_err_t EXPORT_FUNC (grub_crypto_decrypt) (grub_cipher_params_t params,
> + char **out, const char *in,
> + grub_size_t * outsize,
> + grub_size_t insize);
> +grub_err_t EXPORT_FUNC (grub_crypto_decrypt_inplace) (grub_cipher_params_t
> + params, char *buf,
> + grub_size_t size);
> +grub_err_t EXPORT_FUNC (grub_crypto_encrypt_inplace) (grub_cipher_params_t
> + params, char *buf,
> + grub_size_t size);
> +grub_err_t EXPORT_FUNC (grub_crypto_set_key) (grub_cipher_params_t params,
> + const char *key);
> +int EXPORT_FUNC (grub_crypto_cipher_iterate) (grub_crypto_hook hook,
> + void *data);
> +grub_err_t EXPORT_FUNC (grub_crypto_hash) (grub_cipher_params_t params,
> + char *hash, const char *payload,
> + unsigned int size);
> +grub_err_t EXPORT_FUNC (grub_crypto_new_cipher) (grub_cipher_params_t *
> + params, const char *name,
> + grub_cipher_type_t type);
> +void EXPORT_FUNC (grub_crypto_delete_cipher) (grub_cipher_params_t params);
> +void EXPORT_FUNC (grub_crypto_cipher_register) (grub_cipher_t cipher);
> +void EXPORT_FUNC (grub_crypto_cipher_unregister) (grub_cipher_t cipher);
>
> #endif
> _______________________________________________
> Grub-devel mailing list
> Grub-devel@gnu.org
> http://lists.gnu.org/mailman/listinfo/grub-devel
next prev parent reply other threads:[~2007-11-10 17:20 UTC|newest]
Thread overview: 14+ messages / expand[flat|nested] mbox.gz Atom feed top
2007-09-02 12:17 Strong Crypto Support for GRUB2 Simon Peter
2007-09-02 16:05 ` Robert Millan
2007-09-02 17:25 ` Simon Peter
2007-09-02 19:41 ` Robert Millan
2007-09-02 20:53 ` Simon Peter
2007-09-02 23:05 ` Robert Millan
2007-09-03 18:51 ` Simon Peter
2007-11-10 17:20 ` Marco Gerards [this message]
2007-09-03 9:42 ` Patrick Georgi
-- strict thread matches above, loose matches on Subject: below --
2007-09-13 9:16 Simon Peter
2007-11-10 17:22 ` Marco Gerards
2008-07-20 23:49 Fw: " Simon Peter
2008-07-21 13:48 ` Colin D Bennett
2008-07-21 20:38 ` Simon Peter
2008-07-22 22:12 ` Robert Millan
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=878x56f24v.fsf@xs4all.nl \
--to=mgerards@xs4all.nl \
--cc=grub-devel@gnu.org \
--cc=rmh@aybabtu.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.