[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
Re: Strong Crypto Support for GRUB2
|
From: |
Marco Gerards |
|
Subject: |
Re: Strong Crypto Support for GRUB2 |
|
Date: |
Sat, 10 Nov 2007 18:20:48 +0100 |
|
User-agent: |
Gnus/5.110006 (No Gnus v0.6) Emacs/21.4 (gnu/linux) |
Simon Peter <address@hidden> 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 <address@hidden>
> + * 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 <address@hidden>
>
> Patch from Simon Peter <address@hidden>:
> 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
> address@hidden
> http://lists.gnu.org/mailman/listinfo/grub-devel
- Re: Strong Crypto Support for GRUB2,
Marco Gerards <=