mirror of
https://github.com/dolphin-emu/dolphin.git
synced 2025-07-23 14:19:46 -06:00
Externals: Update mbedtls to 2.28.0
This commit is contained in:
OatmealDome
111
Externals/mbedtls/library/aria.c
vendored
111
Externals/mbedtls/library/aria.c
vendored
@ -1,7 +1,7 @@
|
||||
/*
|
||||
* ARIA implementation
|
||||
*
|
||||
* Copyright (C) 2006-2017, ARM Limited, All Rights Reserved
|
||||
* Copyright The Mbed TLS Contributors
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License"); you may
|
||||
@ -15,8 +15,6 @@
|
||||
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
* This file is part of mbed TLS (https://tls.mbed.org)
|
||||
*/
|
||||
|
||||
/*
|
||||
@ -25,11 +23,7 @@
|
||||
* [2] https://tools.ietf.org/html/rfc5794
|
||||
*/
|
||||
|
||||
#if !defined(MBEDTLS_CONFIG_FILE)
|
||||
#include "mbedtls/config.h"
|
||||
#else
|
||||
#include MBEDTLS_CONFIG_FILE
|
||||
#endif
|
||||
#include "common.h"
|
||||
|
||||
#if defined(MBEDTLS_ARIA_C)
|
||||
|
||||
@ -61,29 +55,6 @@
|
||||
#define ARIA_VALIDATE( cond ) \
|
||||
MBEDTLS_INTERNAL_VALIDATE( cond )
|
||||
|
||||
/*
|
||||
* 32-bit integer manipulation macros (little endian)
|
||||
*/
|
||||
#ifndef GET_UINT32_LE
|
||||
#define GET_UINT32_LE( n, b, i ) \
|
||||
{ \
|
||||
(n) = ( (uint32_t) (b)[(i) ] ) \
|
||||
| ( (uint32_t) (b)[(i) + 1] << 8 ) \
|
||||
| ( (uint32_t) (b)[(i) + 2] << 16 ) \
|
||||
| ( (uint32_t) (b)[(i) + 3] << 24 ); \
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef PUT_UINT32_LE
|
||||
#define PUT_UINT32_LE( n, b, i ) \
|
||||
{ \
|
||||
(b)[(i) ] = (unsigned char) ( ( (n) ) & 0xFF ); \
|
||||
(b)[(i) + 1] = (unsigned char) ( ( (n) >> 8 ) & 0xFF ); \
|
||||
(b)[(i) + 2] = (unsigned char) ( ( (n) >> 16 ) & 0xFF ); \
|
||||
(b)[(i) + 3] = (unsigned char) ( ( (n) >> 24 ) & 0xFF ); \
|
||||
}
|
||||
#endif
|
||||
|
||||
/*
|
||||
* modify byte order: ( A B C D ) -> ( B A D C ), i.e. swap pairs of bytes
|
||||
*
|
||||
@ -241,22 +212,22 @@ static inline void aria_sl( uint32_t *a, uint32_t *b,
|
||||
const uint8_t sa[256], const uint8_t sb[256],
|
||||
const uint8_t sc[256], const uint8_t sd[256] )
|
||||
{
|
||||
*a = ( (uint32_t) sa[ *a & 0xFF] ) ^
|
||||
(((uint32_t) sb[(*a >> 8) & 0xFF]) << 8) ^
|
||||
(((uint32_t) sc[(*a >> 16) & 0xFF]) << 16) ^
|
||||
(((uint32_t) sd[ *a >> 24 ]) << 24);
|
||||
*b = ( (uint32_t) sa[ *b & 0xFF] ) ^
|
||||
(((uint32_t) sb[(*b >> 8) & 0xFF]) << 8) ^
|
||||
(((uint32_t) sc[(*b >> 16) & 0xFF]) << 16) ^
|
||||
(((uint32_t) sd[ *b >> 24 ]) << 24);
|
||||
*c = ( (uint32_t) sa[ *c & 0xFF] ) ^
|
||||
(((uint32_t) sb[(*c >> 8) & 0xFF]) << 8) ^
|
||||
(((uint32_t) sc[(*c >> 16) & 0xFF]) << 16) ^
|
||||
(((uint32_t) sd[ *c >> 24 ]) << 24);
|
||||
*d = ( (uint32_t) sa[ *d & 0xFF] ) ^
|
||||
(((uint32_t) sb[(*d >> 8) & 0xFF]) << 8) ^
|
||||
(((uint32_t) sc[(*d >> 16) & 0xFF]) << 16) ^
|
||||
(((uint32_t) sd[ *d >> 24 ]) << 24);
|
||||
*a = ( (uint32_t) sa[ MBEDTLS_BYTE_0( *a ) ] ) ^
|
||||
(((uint32_t) sb[ MBEDTLS_BYTE_1( *a ) ]) << 8) ^
|
||||
(((uint32_t) sc[ MBEDTLS_BYTE_2( *a ) ]) << 16) ^
|
||||
(((uint32_t) sd[ MBEDTLS_BYTE_3( *a ) ]) << 24);
|
||||
*b = ( (uint32_t) sa[ MBEDTLS_BYTE_0( *b ) ] ) ^
|
||||
(((uint32_t) sb[ MBEDTLS_BYTE_1( *b ) ]) << 8) ^
|
||||
(((uint32_t) sc[ MBEDTLS_BYTE_2( *b ) ]) << 16) ^
|
||||
(((uint32_t) sd[ MBEDTLS_BYTE_3( *b ) ]) << 24);
|
||||
*c = ( (uint32_t) sa[ MBEDTLS_BYTE_0( *c ) ] ) ^
|
||||
(((uint32_t) sb[ MBEDTLS_BYTE_1( *c ) ]) << 8) ^
|
||||
(((uint32_t) sc[ MBEDTLS_BYTE_2( *c ) ]) << 16) ^
|
||||
(((uint32_t) sd[ MBEDTLS_BYTE_3( *c ) ]) << 24);
|
||||
*d = ( (uint32_t) sa[ MBEDTLS_BYTE_0( *d ) ] ) ^
|
||||
(((uint32_t) sb[ MBEDTLS_BYTE_1( *d ) ]) << 8) ^
|
||||
(((uint32_t) sc[ MBEDTLS_BYTE_2( *d ) ]) << 16) ^
|
||||
(((uint32_t) sd[ MBEDTLS_BYTE_3( *d ) ]) << 24);
|
||||
}
|
||||
|
||||
/*
|
||||
@ -414,7 +385,8 @@ static void aria_fe_xor( uint32_t r[4], const uint32_t p[4],
|
||||
* Big endian 128-bit rotation: r = a ^ (b <<< n), used only in key setup.
|
||||
*
|
||||
* We chose to store bytes into 32-bit words in little-endian format (see
|
||||
* GET/PUT_UINT32_LE) so we need to reverse bytes here.
|
||||
* MBEDTLS_GET_UINT32_LE / MBEDTLS_PUT_UINT32_LE ) so we need to reverse
|
||||
* bytes here.
|
||||
*/
|
||||
static void aria_rot128( uint32_t r[4], const uint32_t a[4],
|
||||
const uint32_t b[4], uint8_t n )
|
||||
@ -462,21 +434,21 @@ int mbedtls_aria_setkey_enc( mbedtls_aria_context *ctx,
|
||||
return( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA );
|
||||
|
||||
/* Copy key to W0 (and potential remainder to W1) */
|
||||
GET_UINT32_LE( w[0][0], key, 0 );
|
||||
GET_UINT32_LE( w[0][1], key, 4 );
|
||||
GET_UINT32_LE( w[0][2], key, 8 );
|
||||
GET_UINT32_LE( w[0][3], key, 12 );
|
||||
w[0][0] = MBEDTLS_GET_UINT32_LE( key, 0 );
|
||||
w[0][1] = MBEDTLS_GET_UINT32_LE( key, 4 );
|
||||
w[0][2] = MBEDTLS_GET_UINT32_LE( key, 8 );
|
||||
w[0][3] = MBEDTLS_GET_UINT32_LE( key, 12 );
|
||||
|
||||
memset( w[1], 0, 16 );
|
||||
if( keybits >= 192 )
|
||||
{
|
||||
GET_UINT32_LE( w[1][0], key, 16 ); // 192 bit key
|
||||
GET_UINT32_LE( w[1][1], key, 20 );
|
||||
w[1][0] = MBEDTLS_GET_UINT32_LE( key, 16 ); // 192 bit key
|
||||
w[1][1] = MBEDTLS_GET_UINT32_LE( key, 20 );
|
||||
}
|
||||
if( keybits == 256 )
|
||||
{
|
||||
GET_UINT32_LE( w[1][2], key, 24 ); // 256 bit key
|
||||
GET_UINT32_LE( w[1][3], key, 28 );
|
||||
w[1][2] = MBEDTLS_GET_UINT32_LE( key, 24 ); // 256 bit key
|
||||
w[1][3] = MBEDTLS_GET_UINT32_LE( key, 28 );
|
||||
}
|
||||
|
||||
i = ( keybits - 128 ) >> 6; // index: 0, 1, 2
|
||||
@ -553,10 +525,10 @@ int mbedtls_aria_crypt_ecb( mbedtls_aria_context *ctx,
|
||||
ARIA_VALIDATE_RET( input != NULL );
|
||||
ARIA_VALIDATE_RET( output != NULL );
|
||||
|
||||
GET_UINT32_LE( a, input, 0 );
|
||||
GET_UINT32_LE( b, input, 4 );
|
||||
GET_UINT32_LE( c, input, 8 );
|
||||
GET_UINT32_LE( d, input, 12 );
|
||||
a = MBEDTLS_GET_UINT32_LE( input, 0 );
|
||||
b = MBEDTLS_GET_UINT32_LE( input, 4 );
|
||||
c = MBEDTLS_GET_UINT32_LE( input, 8 );
|
||||
d = MBEDTLS_GET_UINT32_LE( input, 12 );
|
||||
|
||||
i = 0;
|
||||
while( 1 )
|
||||
@ -588,10 +560,10 @@ int mbedtls_aria_crypt_ecb( mbedtls_aria_context *ctx,
|
||||
c ^= ctx->rk[i][2];
|
||||
d ^= ctx->rk[i][3];
|
||||
|
||||
PUT_UINT32_LE( a, output, 0 );
|
||||
PUT_UINT32_LE( b, output, 4 );
|
||||
PUT_UINT32_LE( c, output, 8 );
|
||||
PUT_UINT32_LE( d, output, 12 );
|
||||
MBEDTLS_PUT_UINT32_LE( a, output, 0 );
|
||||
MBEDTLS_PUT_UINT32_LE( b, output, 4 );
|
||||
MBEDTLS_PUT_UINT32_LE( c, output, 8 );
|
||||
MBEDTLS_PUT_UINT32_LE( d, output, 12 );
|
||||
|
||||
return( 0 );
|
||||
}
|
||||
@ -927,7 +899,7 @@ static const uint8_t aria_test2_ctr_ct[3][48] = // CTR ciphertext
|
||||
{ \
|
||||
if( verbose ) \
|
||||
mbedtls_printf( "failed\n" ); \
|
||||
return( 1 ); \
|
||||
goto exit; \
|
||||
} else { \
|
||||
if( verbose ) \
|
||||
mbedtls_printf( "passed\n" ); \
|
||||
@ -941,6 +913,7 @@ int mbedtls_aria_self_test( int verbose )
|
||||
int i;
|
||||
uint8_t blk[MBEDTLS_ARIA_BLOCKSIZE];
|
||||
mbedtls_aria_context ctx;
|
||||
int ret = 1;
|
||||
|
||||
#if (defined(MBEDTLS_CIPHER_MODE_CFB) || defined(MBEDTLS_CIPHER_MODE_CTR))
|
||||
size_t j;
|
||||
@ -952,6 +925,8 @@ int mbedtls_aria_self_test( int verbose )
|
||||
uint8_t buf[48], iv[MBEDTLS_ARIA_BLOCKSIZE];
|
||||
#endif
|
||||
|
||||
mbedtls_aria_init( &ctx );
|
||||
|
||||
/*
|
||||
* Test set 1
|
||||
*/
|
||||
@ -1071,7 +1046,11 @@ int mbedtls_aria_self_test( int verbose )
|
||||
mbedtls_printf( "\n" );
|
||||
#endif /* MBEDTLS_CIPHER_MODE_CTR */
|
||||
|
||||
return( 0 );
|
||||
ret = 0;
|
||||
|
||||
exit:
|
||||
mbedtls_aria_free( &ctx );
|
||||
return( ret );
|
||||
}
|
||||
|
||||
#endif /* MBEDTLS_SELF_TEST */
|
||||
|
||||
Reference in New Issue
Block a user