yuzu/mbedtls
1
0
Fork 0
mirror of https://github.com/yuzu-emu/mbedtls.git synced 2025-02-02 13:50:59 +00:00
Code Issues Packages Projects Releases Wiki Activity

Replace instances of byte reading macros with PUT

Browse source 
Instances of a group of byte reading macros which are equivilant to
MBEDTLS_PUT_UINTx_yz

Signed-off-by: Joe Subbiani <joe.subbiani@arm.com>
This commit is contained in:
Joe Subbiani 2021-07-19 11:56:54 +01:00
parent 197e9edae5
commit c54e908656
8 changed files with 64 additions and 76 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

34
library/common.h
View file

@ -184,6 +184,40 @@
} }
#endif #endif
/**
* Get the unsigned 16 bits integer corresponding to two bytes in
* big-endian order (LSB first).
*
* \param data Base address of the memory to get the two bytes from.
* \param offset Offset from \p base of the first and most significant
* byte of the two bytes to build the 16 bits unsigned
* integer from.
*/
#ifndef MBEDTLS_GET_UINT16_BE
#define MBEDTLS_GET_UINT16_BE( data, offset ) \
( \
( (uint16_t) ( data )[( offset ) ] << 8 ) \
| ( (uint16_t) ( data )[( offset ) + 1] ) \
)
#endif
/**
* Put in memory a 16 bits unsigned integer in big-endian order.
*
* \param n 16 bits unsigned integer to put in memory.
* \param data Base address of the memory where to put the 16
* bits unsigned integer in.
* \param offset Offset from \p base where to put the most significant
* byte of the 16 bits unsigned integer \p n.
*/
#ifndef MBEDTLS_PUT_UINT16_BE
#define MBEDTLS_PUT_UINT16_BE( n, data, offset ) \
{ \
( data )[( offset ) ] = (unsigned char) ( ( (n) >> 8 ) & 0xFF ); \
( data )[( offset ) + 1] = (unsigned char) ( ( (n) ) & 0xFF ); \
}
#endif
/** /**
* Get the unsigned 64 bits integer corresponding to eight bytes in * Get the unsigned 64 bits integer corresponding to eight bytes in
* big-endian order (MSB first). * big-endian order (MSB first).

20
library/poly1305.c
View file

@ -250,22 +250,10 @@ static void poly1305_compute_mac( const mbedtls_poly1305_context *ctx,
acc3 += ctx->s[3] + (uint32_t) ( d >> 32U ); acc3 += ctx->s[3] + (uint32_t) ( d >> 32U );
/* Compute MAC (128 least significant bits of the accumulator) */ /* Compute MAC (128 least significant bits of the accumulator) */
mac[ 0] = MBEDTLS_BYTE_0( acc0 ); MBEDTLS_PUT_UINT32_LE( acc0, mac, 0 );
mac[ 1] = MBEDTLS_BYTE_1( acc0 ); MBEDTLS_PUT_UINT32_LE( acc1, mac, 4 );
mac[ 2] = MBEDTLS_BYTE_2( acc0 ); MBEDTLS_PUT_UINT32_LE( acc2, mac, 8 );
mac[ 3] = MBEDTLS_BYTE_3( acc0 ); MBEDTLS_PUT_UINT32_LE( acc3, mac, 12 );
mac[ 4] = MBEDTLS_BYTE_0( acc1 );
mac[ 5] = MBEDTLS_BYTE_1( acc1 );
mac[ 6] = MBEDTLS_BYTE_2( acc1 );
mac[ 7] = MBEDTLS_BYTE_3( acc1 );
mac[ 8] = MBEDTLS_BYTE_0( acc2 );
mac[ 9] = MBEDTLS_BYTE_1( acc2 );
mac[10] = MBEDTLS_BYTE_2( acc2 );
mac[11] = MBEDTLS_BYTE_3( acc2 );
mac[12] = MBEDTLS_BYTE_0( acc3 );
mac[13] = MBEDTLS_BYTE_1( acc3 );
mac[14] = MBEDTLS_BYTE_2( acc3 );
mac[15] = MBEDTLS_BYTE_3( acc3 );
} }
void mbedtls_poly1305_init( mbedtls_poly1305_context *ctx ) void mbedtls_poly1305_init( mbedtls_poly1305_context *ctx )

10
library/psa_its_file.c
View file

@ -197,14 +197,8 @@ psa_status_t psa_its_set( psa_storage_uid_t uid,
size_t n; size_t n;
memcpy( header.magic, PSA_ITS_MAGIC_STRING, PSA_ITS_MAGIC_LENGTH ); memcpy( header.magic, PSA_ITS_MAGIC_STRING, PSA_ITS_MAGIC_LENGTH );
header.size[0] = MBEDTLS_BYTE_0( data_length ); MBEDTLS_PUT_UINT32_LE( data_length, header.size, 0 );
header.size[1] = MBEDTLS_BYTE_1( data_length ); MBEDTLS_PUT_UINT32_LE( create_flags, header.flags, 0 );
header.size[2] = MBEDTLS_BYTE_2( data_length );
header.size[3] = MBEDTLS_BYTE_3( data_length );
header.flags[0] = MBEDTLS_BYTE_0( create_flags );
header.flags[1] = MBEDTLS_BYTE_1( create_flags );
header.flags[2] = MBEDTLS_BYTE_2( create_flags );
header.flags[3] = MBEDTLS_BYTE_3( create_flags );
psa_its_fill_filename( uid, filename ); psa_its_fill_filename( uid, filename );
stream = fopen( PSA_ITS_STORAGE_TEMP, "wb" ); stream = fopen( PSA_ITS_STORAGE_TEMP, "wb" );

15
library/ssl_cli.c
View file

@ -735,12 +735,10 @@ static int ssl_write_alpn_ext( mbedtls_ssl_context *ssl,
*olen = p - buf; *olen = p - buf;
/* List length = olen - 2 (ext_type) - 2 (ext_len) - 2 (list_len) */ /* List length = olen - 2 (ext_type) - 2 (ext_len) - 2 (list_len) */
buf[4] = MBEDTLS_BYTE_1( *olen - 6 ); MBEDTLS_PUT_UINT16_BE( *olen - 6, buf, 4 );
buf[5] = MBEDTLS_BYTE_0( *olen - 6 );
/* Extension length = olen - 2 (ext_type) - 2 (ext_len) */ /* Extension length = olen - 2 (ext_type) - 2 (ext_len) */
buf[2] = MBEDTLS_BYTE_1( *olen - 4 ); MBEDTLS_PUT_UINT16_BE( *olen - 4, buf, 2 );
buf[3] = MBEDTLS_BYTE_0( *olen - 4 );
return( 0 ); return( 0 );
} }
@ -2897,8 +2895,7 @@ static int ssl_write_encrypted_pms( mbedtls_ssl_context *ssl,
defined(MBEDTLS_SSL_PROTO_TLS1_2) defined(MBEDTLS_SSL_PROTO_TLS1_2)
if( len_bytes == 2 ) if( len_bytes == 2 )
{ {
ssl->out_msg[offset+0] = MBEDTLS_BYTE_1( *olen ); MBEDTLS_PUT_UINT16_BE( *olen, ssl->out_msg, offset );
ssl->out_msg[offset+1] = MBEDTLS_BYTE_0( *olen );
*olen += 2; *olen += 2;
} }
#endif #endif
@ -3682,8 +3679,7 @@ static int ssl_write_client_key_exchange( mbedtls_ssl_context *ssl )
*/ */
content_len = ssl->handshake->dhm_ctx.len; content_len = ssl->handshake->dhm_ctx.len;
ssl->out_msg[4] = MBEDTLS_BYTE_1( content_len ); MBEDTLS_PUT_UINT16_BE( content_len, ssl->out_msg, 4 );
ssl->out_msg[5] = MBEDTLS_BYTE_0( content_len );
header_len = 6; header_len = 6;
ret = mbedtls_dhm_make_public( &ssl->handshake->dhm_ctx, ret = mbedtls_dhm_make_public( &ssl->handshake->dhm_ctx,
@ -4257,8 +4253,7 @@ sign:
return( ret ); return( ret );
} }
ssl->out_msg[4 + offset] = MBEDTLS_BYTE_1( n ); MBEDTLS_PUT_UINT16_BE( n, ssl->out_msg, offset + 4 );
ssl->out_msg[5 + offset] = MBEDTLS_BYTE_0( n );
ssl->out_msglen = 6 + n + offset; ssl->out_msglen = 6 + n + offset;
ssl->out_msgtype = MBEDTLS_SSL_MSG_HANDSHAKE; ssl->out_msgtype = MBEDTLS_SSL_MSG_HANDSHAKE;

21
library/ssl_msg.c
View file

@ -454,15 +454,13 @@ static void ssl_extract_add_data_from_record( unsigned char* add_data,
*cur = rec->cid_len; *cur = rec->cid_len;
cur++; cur++;
cur[0] = MBEDTLS_BYTE_1( rec->data_len ); MBEDTLS_PUT_UINT16_BE( rec->data_len, cur, 0 );
cur[1] = MBEDTLS_BYTE_0( rec->data_len );
cur += 2; cur += 2;
} }
else else
#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */ #endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
{ {
cur[0] = MBEDTLS_BYTE_1( rec->data_len ); MBEDTLS_PUT_UINT16_BE( rec->data_len, cur, 0 );
cur[1] = MBEDTLS_BYTE_0( rec->data_len );
cur += 2; cur += 2;
} }
@ -2759,8 +2757,7 @@ int mbedtls_ssl_write_handshake_msg( mbedtls_ssl_context *ssl )
/* Write message_seq and update it, except for HelloRequest */ /* Write message_seq and update it, except for HelloRequest */
if( hs_type != MBEDTLS_SSL_HS_HELLO_REQUEST ) if( hs_type != MBEDTLS_SSL_HS_HELLO_REQUEST )
{ {
ssl->out_msg[4] = MBEDTLS_BYTE_1( ssl->handshake->out_msg_seq ); MBEDTLS_PUT_UINT16_BE( ssl->handshake->out_msg_seq, ssl->out_msg, 4 );
ssl->out_msg[5] = MBEDTLS_BYTE_0( ssl->handshake->out_msg_seq );
++( ssl->handshake->out_msg_seq ); ++( ssl->handshake->out_msg_seq );
} }
else else
@ -2874,8 +2871,7 @@ int mbedtls_ssl_write_record( mbedtls_ssl_context *ssl, uint8_t force_flush )
ssl->conf->transport, ssl->out_hdr + 1 ); ssl->conf->transport, ssl->out_hdr + 1 );
memcpy( ssl->out_ctr, ssl->cur_out_ctr, 8 ); memcpy( ssl->out_ctr, ssl->cur_out_ctr, 8 );
ssl->out_len[0] = MBEDTLS_BYTE_1( len ); MBEDTLS_PUT_UINT16_BE( len, ssl->out_len, 0);
ssl->out_len[1] = MBEDTLS_BYTE_0( len );
if( ssl->transform_out != NULL ) if( ssl->transform_out != NULL )
{ {
@ -2915,8 +2911,7 @@ int mbedtls_ssl_write_record( mbedtls_ssl_context *ssl, uint8_t force_flush )
memcpy( ssl->out_cid, rec.cid, rec.cid_len ); memcpy( ssl->out_cid, rec.cid, rec.cid_len );
#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */ #endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
ssl->out_msglen = len = rec.data_len; ssl->out_msglen = len = rec.data_len;
ssl->out_len[0] = MBEDTLS_BYTE_1( rec.data_len ); MBEDTLS_PUT_UINT16_BE( rec.data_len, ssl->out_len, 0 );
ssl->out_len[1] = MBEDTLS_BYTE_0( rec.data_len );
} }
protected_record_size = len + mbedtls_ssl_out_hdr_len( ssl ); protected_record_size = len + mbedtls_ssl_out_hdr_len( ssl );
@ -3492,8 +3487,7 @@ static int ssl_check_dtls_clihlo_cookie(
obuf[15] = obuf[23] = MBEDTLS_BYTE_1( *olen - 25 ); obuf[15] = obuf[23] = MBEDTLS_BYTE_1( *olen - 25 );
obuf[16] = obuf[24] = MBEDTLS_BYTE_0( *olen - 25 ); obuf[16] = obuf[24] = MBEDTLS_BYTE_0( *olen - 25 );
obuf[11] = MBEDTLS_BYTE_1( *olen - 13 ); MBEDTLS_PUT_UINT16_BE( *olen - 13, obuf, 11 );
obuf[12] = MBEDTLS_BYTE_0( *olen - 13 );
return( MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED ); return( MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED );
} }
@ -4891,8 +4885,7 @@ static int ssl_get_next_record( mbedtls_ssl_context *ssl )
ssl->in_hdr[0] = rec.type; ssl->in_hdr[0] = rec.type;
ssl->in_msg = rec.buf + rec.data_offset; ssl->in_msg = rec.buf + rec.data_offset;
ssl->in_msglen = rec.data_len; ssl->in_msglen = rec.data_len;
ssl->in_len[0] = MBEDTLS_BYTE_1( rec.data_len ); MBEDTLS_PUT_UINT16_BE( rec.data_len, ssl->in_len, 0 );
ssl->in_len[1] = MBEDTLS_BYTE_0( rec.data_len );
#if defined(MBEDTLS_ZLIB_SUPPORT) #if defined(MBEDTLS_ZLIB_SUPPORT)
if( ssl->transform_in != NULL && if( ssl->transform_in != NULL &&

34
library/ssl_srv.c
View file

@ -2604,16 +2604,13 @@ static void ssl_write_alpn_ext( mbedtls_ssl_context *ssl,
* 6 . 6 protocol name length * 6 . 6 protocol name length
* 7 . 7+n protocol name * 7 . 7+n protocol name
*/ */
buf[0] = MBEDTLS_BYTE_1( MBEDTLS_TLS_EXT_ALPN ); MBEDTLS_PUT_UINT16_BE( MBEDTLS_TLS_EXT_ALPN, buf, 0);
buf[1] = MBEDTLS_BYTE_0( MBEDTLS_TLS_EXT_ALPN );
*olen = 7 + strlen( ssl->alpn_chosen ); *olen = 7 + strlen( ssl->alpn_chosen );
buf[2] = MBEDTLS_BYTE_1( *olen - 4 ); MBEDTLS_PUT_UINT16_BE( *olen - 4, buf, 2 );
buf[3] = MBEDTLS_BYTE_0( *olen - 4 );
buf[4] = MBEDTLS_BYTE_1( *olen - 6 ); MBEDTLS_PUT_UINT16_BE( *olen - 6, buf, 4 );
buf[5] = MBEDTLS_BYTE_0( *olen - 6 );
buf[6] = MBEDTLS_BYTE_0( *olen - 7 ); buf[6] = MBEDTLS_BYTE_0( *olen - 7 );
@ -2660,15 +2657,13 @@ static void ssl_write_use_srtp_ext( mbedtls_ssl_context *ssl,
} }
/* extension */ /* extension */
buf[0] = MBEDTLS_BYTE_1( MBEDTLS_TLS_EXT_USE_SRTP ); MBEDTLS_PUT_UINT16_BE(MBEDTLS_TLS_EXT_USE_SRTP, buf, 0 );
buf[1] = MBEDTLS_BYTE_0( MBEDTLS_TLS_EXT_USE_SRTP );
/* /*
* total length 5 and mki value: only one profile(2 bytes) * total length 5 and mki value: only one profile(2 bytes)
* and length(2 bytes) and srtp_mki ) * and length(2 bytes) and srtp_mki )
*/ */
ext_len = 5 + mki_len; ext_len = 5 + mki_len;
buf[2] = MBEDTLS_BYTE_1( ext_len ); MBEDTLS_PUT_UINT16_BE( ext_len, buf, 2 );
buf[3] = MBEDTLS_BYTE_0( ext_len );
/* protection profile length: 2 */ /* protection profile length: 2 */
buf[4] = 0x00; buf[4] = 0x00;
@ -2677,8 +2672,7 @@ static void ssl_write_use_srtp_ext( mbedtls_ssl_context *ssl,
ssl->dtls_srtp_info.chosen_dtls_srtp_profile ); ssl->dtls_srtp_info.chosen_dtls_srtp_profile );
if( profile_value != MBEDTLS_TLS_SRTP_UNSET ) if( profile_value != MBEDTLS_TLS_SRTP_UNSET )
{ {
buf[6] = MBEDTLS_BYTE_1( profile_value ); MBEDTLS_PUT_UINT16_BE( profile_value, buf, 6 );
buf[7] = MBEDTLS_BYTE_0( profile_value );
} }
else else
{ {
@ -3167,8 +3161,7 @@ static int ssl_write_certificate_request( mbedtls_ssl_context *ssl )
#endif #endif
} }
p[0] = MBEDTLS_BYTE_1( sa_len ); MBEDTLS_PUT_UINT16_BE( sa_len, p, 0 );
p[1] = MBEDTLS_BYTE_0( sa_len );
sa_len += 2; sa_len += 2;
p += sa_len; p += sa_len;
} }
@ -3223,8 +3216,7 @@ static int ssl_write_certificate_request( mbedtls_ssl_context *ssl )
ssl->out_msglen = p - buf; ssl->out_msglen = p - buf;
ssl->out_msgtype = MBEDTLS_SSL_MSG_HANDSHAKE; ssl->out_msgtype = MBEDTLS_SSL_MSG_HANDSHAKE;
ssl->out_msg[0] = MBEDTLS_SSL_HS_CERTIFICATE_REQUEST; ssl->out_msg[0] = MBEDTLS_SSL_HS_CERTIFICATE_REQUEST;
ssl->out_msg[4 + ct_len + sa_len] = MBEDTLS_BYTE_1( total_dn_size ); MBEDTLS_PUT_UINT16_BE( total_dn_size, ssl->out_msg, 4 + ct_len + sa_len );
ssl->out_msg[5 + ct_len + sa_len] = MBEDTLS_BYTE_0( total_dn_size );
ret = mbedtls_ssl_write_handshake_msg( ssl ); ret = mbedtls_ssl_write_handshake_msg( ssl );
@ -4646,14 +4638,8 @@ static int ssl_write_new_session_ticket( mbedtls_ssl_context *ssl )
tlen = 0; tlen = 0;
} }
ssl->out_msg[4] = MBEDTLS_BYTE_3( lifetime ); MBEDTLS_PUT_UINT32_BE( lifetime, ssl->out_msg, 4 );
ssl->out_msg[5] = MBEDTLS_BYTE_2( lifetime ); MBEDTLS_PUT_UINT16_BE( tlen, ssl->out_msg, 8 );
ssl->out_msg[6] = MBEDTLS_BYTE_1( lifetime );
ssl->out_msg[7] = MBEDTLS_BYTE_0( lifetime );
ssl->out_msg[8] = MBEDTLS_BYTE_1( tlen );
ssl->out_msg[9] = MBEDTLS_BYTE_0( tlen );
ssl->out_msglen = 10 + tlen; ssl->out_msglen = 10 + tlen;
/* /*

3
library/ssl_ticket.c
View file

@ -245,8 +245,7 @@ int mbedtls_ssl_ticket_write( void *p_ticket,
{ {
goto cleanup; goto cleanup;
} }
state_len_bytes[0] = MBEDTLS_BYTE_1( clear_len ); MBEDTLS_PUT_UINT16_BE( clear_len, state_len_bytes, 0 );
state_len_bytes[1] = MBEDTLS_BYTE_0( clear_len );
/* Encrypt and authenticate */ /* Encrypt and authenticate */
if( ( ret = mbedtls_cipher_auth_encrypt_ext( &key->ctx, if( ( ret = mbedtls_cipher_auth_encrypt_ext( &key->ctx,

3
library/x509write_crt.c
View file

@ -251,8 +251,7 @@ int mbedtls_x509write_crt_set_key_usage( mbedtls_x509write_cert *ctx,
return( MBEDTLS_ERR_X509_FEATURE_UNAVAILABLE ); return( MBEDTLS_ERR_X509_FEATURE_UNAVAILABLE );
c = buf + 5; c = buf + 5;
ku[0] = MBEDTLS_BYTE_0( key_usage ); MBEDTLS_PUT_UINT16_LE( key_usage, ku, 0 );
ku[1] = MBEDTLS_BYTE_1( key_usage );
ret = mbedtls_asn1_write_named_bitstring( &c, buf, ku, 9 ); ret = mbedtls_asn1_write_named_bitstring( &c, buf, ku, 9 );
if( ret < 0 ) if( ret < 0 )