path
stringlengths 14
112
| content
stringlengths 0
6.32M
| size
int64 0
6.32M
| max_lines
int64 1
100k
| repo_name
stringclasses 2
values | autogenerated
bool 1
class |
|---|---|---|---|---|---|
cosmopolitan/third_party/mbedtls/sha1.h | #ifndef MBEDTLS_SHA1_H_
#define MBEDTLS_SHA1_H_
#include "third_party/mbedtls/config.h"
#include "third_party/mbedtls/platform.h"
COSMOPOLITAN_C_START_
/* clang-format off */
/* MBEDTLS_ERR_SHA1_HW_ACCEL_FAILED is deprecated and should not be used. */
#define MBEDTLS_ERR_SHA1_HW_ACCEL_FAILED -0x0035 /*< SHA-1 hardware accelerator failed */
#define MBEDTLS_ERR_SHA1_BAD_INPUT_DATA -0x0073 /*< SHA-1 input data was malformed. */
/**
* \brief The SHA-1 context structure.
*
* \warning SHA-1 is considered a weak message digest and its use
* constitutes a security risk. We recommend considering
* stronger message digests instead.
*
*/
typedef struct mbedtls_sha1_context
{
uint32_t state[5]; /*!< The intermediate digest state. */
uint32_t total[2]; /*!< The number of Bytes processed. */
uint8_t buffer[64]; /*!< The data block being processed. */
}
mbedtls_sha1_context;
void mbedtls_sha1_clone( mbedtls_sha1_context *, const mbedtls_sha1_context * );
int mbedtls_sha1_starts_ret( mbedtls_sha1_context * );
int mbedtls_sha1_update_ret( mbedtls_sha1_context *, const unsigned char *, size_t );
int mbedtls_sha1_finish_ret( mbedtls_sha1_context *, unsigned char[20] );
int mbedtls_internal_sha1_process( mbedtls_sha1_context *, const unsigned char[64] );
int mbedtls_sha1_ret( const void *, size_t, unsigned char[20] );
int mbedtls_sha1_self_test( int );
/**
* \brief This function initializes a SHA-1 context.
*
* \warning SHA-1 is considered a weak message digest and its use
* constitutes a security risk. We recommend considering
* stronger message digests instead.
*
* \param ctx The SHA-1 context to initialize.
* This must not be \c NULL.
*
*/
static inline void mbedtls_sha1_init( mbedtls_sha1_context *ctx )
{
mbedtls_platform_zeroize( ctx, sizeof( mbedtls_sha1_context ) );
}
/**
* \brief This function clears a SHA-1 context.
*
* \warning SHA-1 is considered a weak message digest and its use
* constitutes a security risk. We recommend considering
* stronger message digests instead.
*
* \param ctx The SHA-1 context to clear. This may be \c NULL,
* in which case this function does nothing. If it is
* not \c NULL, it must point to an initialized
* SHA-1 context.
*/
static inline void mbedtls_sha1_free( mbedtls_sha1_context *ctx )
{
if( !ctx ) return;
mbedtls_platform_zeroize( ctx, sizeof( mbedtls_sha1_context ) );
}
COSMOPOLITAN_C_END_
#endif /* MBEDTLS_SHA1_H_ */
| 2,674 | 72 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/sigalg.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2021 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "third_party/mbedtls/ssl.h"
/* https://www.iana.org/assignments/tls-parameters/tls-parameters.xhtml */
const char *mbedtls_sig_alg_name(int t) {
switch (t) {
case 0:
return "anonymous";
case 1:
return "rsa";
case 2:
return "dsa";
case 3:
return "ecdsa";
case 7:
return "ed25519";
case 8:
return "ed448";
case 64:
return "gostr34102012_256";
case 65:
return "gostr34102012_512";
default:
return 0;
}
}
| 2,341 | 44 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/chk.h | #ifndef COSMOPOLITAN_THIRD_PARTY_MBEDTLS_CHK_H_
#define COSMOPOLITAN_THIRD_PARTY_MBEDTLS_CHK_H_
#define MBEDTLS_CHK(f) \
do { \
if ((ret = (f))) goto cleanup; \
} while (0)
#endif /* COSMOPOLITAN_THIRD_PARTY_MBEDTLS_CHK_H_ */
| 276 | 10 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/getsslstatename.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2021 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "third_party/mbedtls/ssl.h"
const char *GetSslStateName(mbedtls_ssl_states x) {
switch (x) {
case MBEDTLS_SSL_HELLO_REQUEST:
return "HELLO_REQUEST";
case MBEDTLS_SSL_CLIENT_HELLO:
return "CLIENT_HELLO";
case MBEDTLS_SSL_SERVER_HELLO:
return "SERVER_HELLO";
case MBEDTLS_SSL_SERVER_CERTIFICATE:
return "SERVER_CERTIFICATE";
case MBEDTLS_SSL_SERVER_KEY_EXCHANGE:
return "SERVER_KEY_EXCHANGE";
case MBEDTLS_SSL_CERTIFICATE_REQUEST:
return "CERTIFICATE_REQUEST";
case MBEDTLS_SSL_SERVER_HELLO_DONE:
return "SERVER_HELLO_DONE";
case MBEDTLS_SSL_CLIENT_CERTIFICATE:
return "CLIENT_CERTIFICATE";
case MBEDTLS_SSL_CLIENT_KEY_EXCHANGE:
return "CLIENT_KEY_EXCHANGE";
case MBEDTLS_SSL_CERTIFICATE_VERIFY:
return "CERTIFICATE_VERIFY";
case MBEDTLS_SSL_CLIENT_CHANGE_CIPHER_SPEC:
return "CLIENT_CHANGE_CIPHER_SPEC";
case MBEDTLS_SSL_CLIENT_FINISHED:
return "CLIENT_FINISHED";
case MBEDTLS_SSL_SERVER_CHANGE_CIPHER_SPEC:
return "SERVER_CHANGE_CIPHER_SPEC";
case MBEDTLS_SSL_SERVER_FINISHED:
return "SERVER_FINISHED";
case MBEDTLS_SSL_FLUSH_BUFFERS:
return "FLUSH_BUFFERS";
case MBEDTLS_SSL_HANDSHAKE_WRAPUP:
return "HANDSHAKE_WRAPUP";
case MBEDTLS_SSL_HANDSHAKE_OVER:
return "HANDSHAKE_OVER";
case MBEDTLS_SSL_SERVER_NEW_SESSION_TICKET:
return "SERVER_NEW_SESSION_TICKET";
case MBEDTLS_SSL_SERVER_HELLO_VERIFY_REQUEST_SENT:
return "SERVER_HELLO_VERIFY_REQUEST_SENT";
default:
return NULL;
}
}
| 3,429 | 65 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/ecdh.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:4;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright The Mbed TLS Contributors â
â â
â Licensed under the Apache License, Version 2.0 (the "License"); â
â you may not use this file except in compliance with the License. â
â You may obtain a copy of the License at â
â â
â http://www.apache.org/licenses/LICENSE-2.0 â
â â
â Unless required by applicable law or agreed to in writing, software â
â distributed under the License is distributed on an "AS IS" BASIS, â
â WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. â
â See the License for the specific language governing permissions and â
â limitations under the License. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "third_party/mbedtls/common.h"
#include "third_party/mbedtls/ecdh.h"
#include "third_party/mbedtls/error.h"
#include "third_party/mbedtls/platform.h"
asm(".ident\t\"\\n\\n\
Mbed TLS (Apache 2.0)\\n\
Copyright ARM Limited\\n\
Copyright Mbed TLS Contributors\"");
asm(".include \"libc/disclaimer.inc\"");
/* clang-format off */
/**
* @fileoverview Elliptic curve Diffie-Hellman
*
* @see SEC1 http://www.secg.org/index.php?action=secg,docs_secg
* @see RFC4492
*/
#if defined(MBEDTLS_ECDH_C)
#define ECDH_VALIDATE_RET( cond ) \
MBEDTLS_INTERNAL_VALIDATE_RET( cond, MBEDTLS_ERR_ECP_BAD_INPUT_DATA )
#define ECDH_VALIDATE( cond ) \
MBEDTLS_INTERNAL_VALIDATE( cond )
#if defined(MBEDTLS_ECDH_LEGACY_CONTEXT)
typedef mbedtls_ecdh_context mbedtls_ecdh_context_mbed;
#endif
static mbedtls_ecp_group_id mbedtls_ecdh_grp_id(
const mbedtls_ecdh_context *ctx )
{
#if defined(MBEDTLS_ECDH_LEGACY_CONTEXT)
return( ctx->grp.id );
#else
return( ctx->grp_id );
#endif
}
int mbedtls_ecdh_can_do( mbedtls_ecp_group_id gid )
{
/* At this time, all groups support ECDH. */
(void) gid;
return( 1 );
}
#if !defined(MBEDTLS_ECDH_GEN_PUBLIC_ALT)
/*
* Generate public key (restartable version)
*
* Note: this internal function relies on its caller preserving the value of
* the output parameter 'd' across continuation calls. This would not be
* acceptable for a public function but is OK here as we control call sites.
*/
static int ecdh_gen_public_restartable( mbedtls_ecp_group *grp,
mbedtls_mpi *d, mbedtls_ecp_point *Q,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
mbedtls_ecp_restart_ctx *rs_ctx )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
/* If multiplication is in progress, we already generated a privkey */
#if defined(MBEDTLS_ECP_RESTARTABLE)
if( !rs_ctx || !rs_ctx->rsm )
#endif
MBEDTLS_MPI_CHK( mbedtls_ecp_gen_privkey( grp, d, f_rng, p_rng ) );
MBEDTLS_MPI_CHK( mbedtls_ecp_mul_restartable( grp, Q, d, &grp->G,
f_rng, p_rng, rs_ctx ) );
cleanup:
return( ret );
}
/*
* Generate public key
*/
int mbedtls_ecdh_gen_public( mbedtls_ecp_group *grp, mbedtls_mpi *d, mbedtls_ecp_point *Q,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
ECDH_VALIDATE_RET( grp != NULL );
ECDH_VALIDATE_RET( d != NULL );
ECDH_VALIDATE_RET( Q != NULL );
ECDH_VALIDATE_RET( f_rng != NULL );
return( ecdh_gen_public_restartable( grp, d, Q, f_rng, p_rng, NULL ) );
}
#endif /* !MBEDTLS_ECDH_GEN_PUBLIC_ALT */
#if !defined(MBEDTLS_ECDH_COMPUTE_SHARED_ALT)
/*
* Compute shared secret (SEC1 3.3.1)
*/
static int ecdh_compute_shared_restartable( mbedtls_ecp_group *grp,
mbedtls_mpi *z,
const mbedtls_ecp_point *Q, const mbedtls_mpi *d,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
mbedtls_ecp_restart_ctx *rs_ctx )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
mbedtls_ecp_point P;
mbedtls_ecp_point_init( &P );
MBEDTLS_MPI_CHK( mbedtls_ecp_mul_restartable( grp, &P, d, Q,
f_rng, p_rng, rs_ctx ) );
if( mbedtls_ecp_is_zero( &P ) )
{
ret = MBEDTLS_ERR_ECP_BAD_INPUT_DATA;
goto cleanup;
}
MBEDTLS_MPI_CHK( mbedtls_mpi_copy( z, &P.X ) );
cleanup:
mbedtls_ecp_point_free( &P );
return( ret );
}
/*
* Compute shared secret (SEC1 3.3.1)
*/
int mbedtls_ecdh_compute_shared( mbedtls_ecp_group *grp, mbedtls_mpi *z,
const mbedtls_ecp_point *Q, const mbedtls_mpi *d,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
ECDH_VALIDATE_RET( grp != NULL );
ECDH_VALIDATE_RET( Q != NULL );
ECDH_VALIDATE_RET( d != NULL );
ECDH_VALIDATE_RET( z != NULL );
return( ecdh_compute_shared_restartable( grp, z, Q, d,
f_rng, p_rng, NULL ) );
}
#endif /* !MBEDTLS_ECDH_COMPUTE_SHARED_ALT */
static void ecdh_init_internal( mbedtls_ecdh_context_mbed *ctx )
{
mbedtls_ecp_group_init( &ctx->grp );
mbedtls_mpi_init( &ctx->d );
mbedtls_ecp_point_init( &ctx->Q );
mbedtls_ecp_point_init( &ctx->Qp );
mbedtls_mpi_init( &ctx->z );
#if defined(MBEDTLS_ECP_RESTARTABLE)
mbedtls_ecp_restart_init( &ctx->rs );
#endif
}
/*
* Initialize context
*/
void mbedtls_ecdh_init( mbedtls_ecdh_context *ctx )
{
ECDH_VALIDATE( ctx != NULL );
#if defined(MBEDTLS_ECDH_LEGACY_CONTEXT)
ecdh_init_internal( ctx );
mbedtls_ecp_point_init( &ctx->Vi );
mbedtls_ecp_point_init( &ctx->Vf );
mbedtls_mpi_init( &ctx->_d );
#else
mbedtls_platform_zeroize( ctx, sizeof( mbedtls_ecdh_context ) );
ctx->var = MBEDTLS_ECDH_VARIANT_NONE;
#endif
ctx->point_format = MBEDTLS_ECP_PF_UNCOMPRESSED;
#if defined(MBEDTLS_ECP_RESTARTABLE)
ctx->restart_enabled = 0;
#endif
}
static int ecdh_setup_internal( mbedtls_ecdh_context_mbed *ctx,
mbedtls_ecp_group_id grp_id )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
ret = mbedtls_ecp_group_load( &ctx->grp, grp_id );
if( ret != 0 )
{
return( MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE );
}
return( 0 );
}
/*
* Setup context
*/
int mbedtls_ecdh_setup( mbedtls_ecdh_context *ctx, mbedtls_ecp_group_id grp_id )
{
ECDH_VALIDATE_RET( ctx != NULL );
#if defined(MBEDTLS_ECDH_LEGACY_CONTEXT)
return( ecdh_setup_internal( ctx, grp_id ) );
#else
switch( grp_id )
{
#if defined(MBEDTLS_ECDH_VARIANT_EVEREST_ENABLED)
case MBEDTLS_ECP_DP_CURVE25519:
ctx->point_format = MBEDTLS_ECP_PF_COMPRESSED;
ctx->var = MBEDTLS_ECDH_VARIANT_EVEREST;
ctx->grp_id = grp_id;
return( mbedtls_everest_setup( &ctx->ctx.everest_ecdh, grp_id ) );
#endif
default:
ctx->point_format = MBEDTLS_ECP_PF_UNCOMPRESSED;
ctx->var = MBEDTLS_ECDH_VARIANT_MBEDTLS_2_0;
ctx->grp_id = grp_id;
ecdh_init_internal( &ctx->ctx.mbed_ecdh );
return( ecdh_setup_internal( &ctx->ctx.mbed_ecdh, grp_id ) );
}
#endif
}
static void ecdh_free_internal( mbedtls_ecdh_context_mbed *ctx )
{
mbedtls_ecp_group_free( &ctx->grp );
mbedtls_mpi_free( &ctx->d );
mbedtls_ecp_point_free( &ctx->Q );
mbedtls_ecp_point_free( &ctx->Qp );
mbedtls_mpi_free( &ctx->z );
#if defined(MBEDTLS_ECP_RESTARTABLE)
mbedtls_ecp_restart_free( &ctx->rs );
#endif
}
#if defined(MBEDTLS_ECP_RESTARTABLE)
/*
* Enable restartable operations for context
*/
void mbedtls_ecdh_enable_restart( mbedtls_ecdh_context *ctx )
{
ECDH_VALIDATE( ctx != NULL );
ctx->restart_enabled = 1;
}
#endif
/*
* Free context
*/
void mbedtls_ecdh_free( mbedtls_ecdh_context *ctx )
{
if( ctx == NULL )
return;
#if defined(MBEDTLS_ECDH_LEGACY_CONTEXT)
mbedtls_ecp_point_free( &ctx->Vi );
mbedtls_ecp_point_free( &ctx->Vf );
mbedtls_mpi_free( &ctx->_d );
ecdh_free_internal( ctx );
#else
switch( ctx->var )
{
#if defined(MBEDTLS_ECDH_VARIANT_EVEREST_ENABLED)
case MBEDTLS_ECDH_VARIANT_EVEREST:
mbedtls_everest_free( &ctx->ctx.everest_ecdh );
break;
#endif
case MBEDTLS_ECDH_VARIANT_MBEDTLS_2_0:
ecdh_free_internal( &ctx->ctx.mbed_ecdh );
break;
default:
break;
}
ctx->point_format = MBEDTLS_ECP_PF_UNCOMPRESSED;
ctx->var = MBEDTLS_ECDH_VARIANT_NONE;
ctx->grp_id = MBEDTLS_ECP_DP_NONE;
#endif
}
static int ecdh_make_params_internal( mbedtls_ecdh_context_mbed *ctx,
size_t *olen, int point_format,
unsigned char *buf, size_t blen,
int (*f_rng)(void *,
unsigned char *,
size_t),
void *p_rng,
int restart_enabled )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t grp_len, pt_len;
#if defined(MBEDTLS_ECP_RESTARTABLE)
mbedtls_ecp_restart_ctx *rs_ctx = NULL;
#endif
if( ctx->grp.pbits == 0 )
return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
#if defined(MBEDTLS_ECP_RESTARTABLE)
if( restart_enabled )
rs_ctx = &ctx->rs;
#else
(void) restart_enabled;
#endif
#if defined(MBEDTLS_ECP_RESTARTABLE)
if( ( ret = ecdh_gen_public_restartable( &ctx->grp, &ctx->d, &ctx->Q,
f_rng, p_rng, rs_ctx ) ) != 0 )
return( ret );
#else
if( ( ret = mbedtls_ecdh_gen_public( &ctx->grp, &ctx->d, &ctx->Q,
f_rng, p_rng ) ) != 0 )
return( ret );
#endif /* MBEDTLS_ECP_RESTARTABLE */
if( ( ret = mbedtls_ecp_tls_write_group( &ctx->grp, &grp_len, buf,
blen ) ) != 0 )
return( ret );
buf += grp_len;
blen -= grp_len;
if( ( ret = mbedtls_ecp_tls_write_point( &ctx->grp, &ctx->Q, point_format,
&pt_len, buf, blen ) ) != 0 )
return( ret );
*olen = grp_len + pt_len;
return( 0 );
}
/*
* Setup and write the ServerKeyExchange parameters (RFC 4492)
* struct {
* ECParameters curve_params;
* ECPoint public;
* } ServerECDHParams;
*/
int mbedtls_ecdh_make_params( mbedtls_ecdh_context *ctx, size_t *olen,
unsigned char *buf, size_t blen,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
int restart_enabled = 0;
ECDH_VALIDATE_RET( ctx != NULL );
ECDH_VALIDATE_RET( olen != NULL );
ECDH_VALIDATE_RET( buf != NULL );
ECDH_VALIDATE_RET( f_rng != NULL );
#if defined(MBEDTLS_ECP_RESTARTABLE)
restart_enabled = ctx->restart_enabled;
#else
(void) restart_enabled;
#endif
#if defined(MBEDTLS_ECDH_LEGACY_CONTEXT)
return( ecdh_make_params_internal( ctx, olen, ctx->point_format, buf, blen,
f_rng, p_rng, restart_enabled ) );
#else
switch( ctx->var )
{
#if defined(MBEDTLS_ECDH_VARIANT_EVEREST_ENABLED)
case MBEDTLS_ECDH_VARIANT_EVEREST:
return( mbedtls_everest_make_params( &ctx->ctx.everest_ecdh, olen,
buf, blen, f_rng, p_rng ) );
#endif
case MBEDTLS_ECDH_VARIANT_MBEDTLS_2_0:
return( ecdh_make_params_internal( &ctx->ctx.mbed_ecdh, olen,
ctx->point_format, buf, blen,
f_rng, p_rng,
restart_enabled ) );
default:
return MBEDTLS_ERR_ECP_BAD_INPUT_DATA;
}
#endif
}
static int ecdh_read_params_internal( mbedtls_ecdh_context_mbed *ctx,
const unsigned char **buf,
const unsigned char *end )
{
return( mbedtls_ecp_tls_read_point( &ctx->grp, &ctx->Qp, buf,
end - *buf ) );
}
/*
* Read the ServerKeyExhange parameters (RFC 4492)
* struct {
* ECParameters curve_params;
* ECPoint public;
* } ServerECDHParams;
*/
int mbedtls_ecdh_read_params( mbedtls_ecdh_context *ctx,
const unsigned char **buf,
const unsigned char *end )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
mbedtls_ecp_group_id grp_id;
ECDH_VALIDATE_RET( ctx != NULL );
ECDH_VALIDATE_RET( buf != NULL );
ECDH_VALIDATE_RET( *buf != NULL );
ECDH_VALIDATE_RET( end != NULL );
if( ( ret = mbedtls_ecp_tls_read_group_id( &grp_id, buf, end - *buf ) )
!= 0 )
return( ret );
if( ( ret = mbedtls_ecdh_setup( ctx, grp_id ) ) != 0 )
return( ret );
#if defined(MBEDTLS_ECDH_LEGACY_CONTEXT)
return( ecdh_read_params_internal( ctx, buf, end ) );
#else
switch( ctx->var )
{
#if defined(MBEDTLS_ECDH_VARIANT_EVEREST_ENABLED)
case MBEDTLS_ECDH_VARIANT_EVEREST:
return( mbedtls_everest_read_params( &ctx->ctx.everest_ecdh,
buf, end) );
#endif
case MBEDTLS_ECDH_VARIANT_MBEDTLS_2_0:
return( ecdh_read_params_internal( &ctx->ctx.mbed_ecdh,
buf, end ) );
default:
return MBEDTLS_ERR_ECP_BAD_INPUT_DATA;
}
#endif
}
static int ecdh_get_params_internal( mbedtls_ecdh_context_mbed *ctx,
const mbedtls_ecp_keypair *key,
mbedtls_ecdh_side side )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
/* If it's not our key, just import the public part as Qp */
if( side == MBEDTLS_ECDH_THEIRS )
return( mbedtls_ecp_copy( &ctx->Qp, &key->Q ) );
/* Our key: import public (as Q) and private parts */
if( side != MBEDTLS_ECDH_OURS )
return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
if( ( ret = mbedtls_ecp_copy( &ctx->Q, &key->Q ) ) != 0 ||
( ret = mbedtls_mpi_copy( &ctx->d, &key->d ) ) != 0 )
return( ret );
return( 0 );
}
/*
* Get parameters from a keypair
*/
int mbedtls_ecdh_get_params( mbedtls_ecdh_context *ctx,
const mbedtls_ecp_keypair *key,
mbedtls_ecdh_side side )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
ECDH_VALIDATE_RET( ctx != NULL );
ECDH_VALIDATE_RET( key != NULL );
ECDH_VALIDATE_RET( side == MBEDTLS_ECDH_OURS ||
side == MBEDTLS_ECDH_THEIRS );
if( mbedtls_ecdh_grp_id( ctx ) == MBEDTLS_ECP_DP_NONE )
{
/* This is the first call to get_params(). Set up the context
* for use with the group. */
if( ( ret = mbedtls_ecdh_setup( ctx, key->grp.id ) ) != 0 )
return( ret );
}
else
{
/* This is not the first call to get_params(). Check that the
* current key's group is the same as the context's, which was set
* from the first key's group. */
if( mbedtls_ecdh_grp_id( ctx ) != key->grp.id )
return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
}
#if defined(MBEDTLS_ECDH_LEGACY_CONTEXT)
return( ecdh_get_params_internal( ctx, key, side ) );
#else
switch( ctx->var )
{
#if defined(MBEDTLS_ECDH_VARIANT_EVEREST_ENABLED)
case MBEDTLS_ECDH_VARIANT_EVEREST:
{
mbedtls_everest_ecdh_side s = side == MBEDTLS_ECDH_OURS ?
MBEDTLS_EVEREST_ECDH_OURS :
MBEDTLS_EVEREST_ECDH_THEIRS;
return( mbedtls_everest_get_params( &ctx->ctx.everest_ecdh,
key, s) );
}
#endif
case MBEDTLS_ECDH_VARIANT_MBEDTLS_2_0:
return( ecdh_get_params_internal( &ctx->ctx.mbed_ecdh,
key, side ) );
default:
return MBEDTLS_ERR_ECP_BAD_INPUT_DATA;
}
#endif
}
static int ecdh_make_public_internal( mbedtls_ecdh_context_mbed *ctx,
size_t *olen, int point_format,
unsigned char *buf, size_t blen,
int (*f_rng)(void *,
unsigned char *,
size_t),
void *p_rng,
int restart_enabled )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
#if defined(MBEDTLS_ECP_RESTARTABLE)
mbedtls_ecp_restart_ctx *rs_ctx = NULL;
#endif
if( ctx->grp.pbits == 0 )
return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
#if defined(MBEDTLS_ECP_RESTARTABLE)
if( restart_enabled )
rs_ctx = &ctx->rs;
#else
(void) restart_enabled;
#endif
#if defined(MBEDTLS_ECP_RESTARTABLE)
if( ( ret = ecdh_gen_public_restartable( &ctx->grp, &ctx->d, &ctx->Q,
f_rng, p_rng, rs_ctx ) ) != 0 )
return( ret );
#else
if( ( ret = mbedtls_ecdh_gen_public( &ctx->grp, &ctx->d, &ctx->Q,
f_rng, p_rng ) ) != 0 )
return( ret );
#endif /* MBEDTLS_ECP_RESTARTABLE */
return mbedtls_ecp_tls_write_point( &ctx->grp, &ctx->Q, point_format, olen,
buf, blen );
}
/*
* Setup and export the client public value
*/
int mbedtls_ecdh_make_public( mbedtls_ecdh_context *ctx, size_t *olen,
unsigned char *buf, size_t blen,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
int restart_enabled = 0;
ECDH_VALIDATE_RET( ctx != NULL );
ECDH_VALIDATE_RET( olen != NULL );
ECDH_VALIDATE_RET( buf != NULL );
ECDH_VALIDATE_RET( f_rng != NULL );
#if defined(MBEDTLS_ECP_RESTARTABLE)
restart_enabled = ctx->restart_enabled;
#endif
#if defined(MBEDTLS_ECDH_LEGACY_CONTEXT)
return( ecdh_make_public_internal( ctx, olen, ctx->point_format, buf, blen,
f_rng, p_rng, restart_enabled ) );
#else
switch( ctx->var )
{
#if defined(MBEDTLS_ECDH_VARIANT_EVEREST_ENABLED)
case MBEDTLS_ECDH_VARIANT_EVEREST:
return( mbedtls_everest_make_public( &ctx->ctx.everest_ecdh, olen,
buf, blen, f_rng, p_rng ) );
#endif
case MBEDTLS_ECDH_VARIANT_MBEDTLS_2_0:
return( ecdh_make_public_internal( &ctx->ctx.mbed_ecdh, olen,
ctx->point_format, buf, blen,
f_rng, p_rng,
restart_enabled ) );
default:
return MBEDTLS_ERR_ECP_BAD_INPUT_DATA;
}
#endif
}
static int ecdh_read_public_internal( mbedtls_ecdh_context_mbed *ctx,
const unsigned char *buf, size_t blen )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
const unsigned char *p = buf;
if( ( ret = mbedtls_ecp_tls_read_point( &ctx->grp, &ctx->Qp, &p,
blen ) ) != 0 )
return( ret );
if( (size_t)( p - buf ) != blen )
return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
return( 0 );
}
/*
* Parse and import the client's public value
*/
int mbedtls_ecdh_read_public( mbedtls_ecdh_context *ctx,
const unsigned char *buf, size_t blen )
{
ECDH_VALIDATE_RET( ctx != NULL );
ECDH_VALIDATE_RET( buf != NULL );
#if defined(MBEDTLS_ECDH_LEGACY_CONTEXT)
return( ecdh_read_public_internal( ctx, buf, blen ) );
#else
switch( ctx->var )
{
#if defined(MBEDTLS_ECDH_VARIANT_EVEREST_ENABLED)
case MBEDTLS_ECDH_VARIANT_EVEREST:
return( mbedtls_everest_read_public( &ctx->ctx.everest_ecdh,
buf, blen ) );
#endif
case MBEDTLS_ECDH_VARIANT_MBEDTLS_2_0:
return( ecdh_read_public_internal( &ctx->ctx.mbed_ecdh,
buf, blen ) );
default:
return MBEDTLS_ERR_ECP_BAD_INPUT_DATA;
}
#endif
}
static int ecdh_calc_secret_internal( mbedtls_ecdh_context_mbed *ctx,
size_t *olen, unsigned char *buf,
size_t blen,
int (*f_rng)(void *,
unsigned char *,
size_t),
void *p_rng,
int restart_enabled )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
#if defined(MBEDTLS_ECP_RESTARTABLE)
mbedtls_ecp_restart_ctx *rs_ctx = NULL;
#endif
if( ctx == NULL || ctx->grp.pbits == 0 )
return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
#if defined(MBEDTLS_ECP_RESTARTABLE)
if( restart_enabled )
rs_ctx = &ctx->rs;
#else
(void) restart_enabled;
#endif
#if defined(MBEDTLS_ECP_RESTARTABLE)
if( ( ret = ecdh_compute_shared_restartable( &ctx->grp, &ctx->z, &ctx->Qp,
&ctx->d, f_rng, p_rng,
rs_ctx ) ) != 0 )
{
return( ret );
}
#else
if( ( ret = mbedtls_ecdh_compute_shared( &ctx->grp, &ctx->z, &ctx->Qp,
&ctx->d, f_rng, p_rng ) ) != 0 )
{
return( ret );
}
#endif /* MBEDTLS_ECP_RESTARTABLE */
if( mbedtls_mpi_size( &ctx->z ) > blen )
return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
*olen = ctx->grp.pbits / 8 + ( ( ctx->grp.pbits % 8 ) != 0 );
if( mbedtls_ecp_get_type( &ctx->grp ) == MBEDTLS_ECP_TYPE_MONTGOMERY )
return mbedtls_mpi_write_binary_le( &ctx->z, buf, *olen );
return mbedtls_mpi_write_binary( &ctx->z, buf, *olen );
}
/*
* Derive and export the shared secret
*/
int mbedtls_ecdh_calc_secret( mbedtls_ecdh_context *ctx, size_t *olen,
unsigned char *buf, size_t blen,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
int restart_enabled = 0;
ECDH_VALIDATE_RET( ctx != NULL );
ECDH_VALIDATE_RET( olen != NULL );
ECDH_VALIDATE_RET( buf != NULL );
#if defined(MBEDTLS_ECP_RESTARTABLE)
restart_enabled = ctx->restart_enabled;
#endif
#if defined(MBEDTLS_ECDH_LEGACY_CONTEXT)
return( ecdh_calc_secret_internal( ctx, olen, buf, blen, f_rng, p_rng,
restart_enabled ) );
#else
switch( ctx->var )
{
#if defined(MBEDTLS_ECDH_VARIANT_EVEREST_ENABLED)
case MBEDTLS_ECDH_VARIANT_EVEREST:
return( mbedtls_everest_calc_secret( &ctx->ctx.everest_ecdh, olen,
buf, blen, f_rng, p_rng ) );
#endif
case MBEDTLS_ECDH_VARIANT_MBEDTLS_2_0:
return( ecdh_calc_secret_internal( &ctx->ctx.mbed_ecdh, olen, buf,
blen, f_rng, p_rng,
restart_enabled ) );
default:
return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
}
#endif
}
#endif /* MBEDTLS_ECDH_C */
| 24,794 | 731 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/nist_kw.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:4;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright The Mbed TLS Contributors â
â â
â Licensed under the Apache License, Version 2.0 (the "License"); â
â you may not use this file except in compliance with the License. â
â You may obtain a copy of the License at â
â â
â http://www.apache.org/licenses/LICENSE-2.0 â
â â
â Unless required by applicable law or agreed to in writing, software â
â distributed under the License is distributed on an "AS IS" BASIS, â
â WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. â
â See the License for the specific language governing permissions and â
â limitations under the License. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/str/str.h"
#include "third_party/mbedtls/common.h"
#include "third_party/mbedtls/endian.h"
#include "third_party/mbedtls/error.h"
#include "third_party/mbedtls/nist_kw.h"
#include "third_party/mbedtls/platform.h"
asm(".ident\t\"\\n\\n\
Mbed TLS (Apache 2.0)\\n\
Copyright ARM Limited\\n\
Copyright Mbed TLS Contributors\"");
asm(".include \"libc/disclaimer.inc\"");
/* clang-format off */
/*
* Implementation of NIST SP 800-38F key wrapping, supporting KW and KWP modes
* only
*
* Copyright The Mbed TLS Contributors
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* Definition of Key Wrapping:
* https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-38F.pdf
* RFC 3394 "Advanced Encryption Standard (AES) Key Wrap Algorithm"
* RFC 5649 "Advanced Encryption Standard (AES) Key Wrap with Padding Algorithm"
*
* Note: RFC 3394 defines different methodology for intermediate operations for
* the wrapping and unwrapping operation than the definition in NIST SP 800-38F.
*/
#if !defined(MBEDTLS_NIST_KW_ALT)
#define KW_SEMIBLOCK_LENGTH 8
#define MIN_SEMIBLOCKS_COUNT 3
/*! The 64-bit default integrity check value (ICV) for KW mode. */
static const unsigned char NIST_KW_ICV1[] = {0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6};
/*! The 32-bit default integrity check value (ICV) for KWP mode. */
static const unsigned char NIST_KW_ICV2[] = {0xA6, 0x59, 0x59, 0xA6};
/*
* Initialize context
*/
void mbedtls_nist_kw_init( mbedtls_nist_kw_context *ctx )
{
mbedtls_platform_zeroize( ctx, sizeof( mbedtls_nist_kw_context ) );
}
int mbedtls_nist_kw_setkey( mbedtls_nist_kw_context *ctx,
mbedtls_cipher_id_t cipher,
const unsigned char *key,
unsigned int keybits,
const int is_wrap )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
const mbedtls_cipher_info_t *cipher_info;
cipher_info = mbedtls_cipher_info_from_values( cipher,
keybits,
MBEDTLS_MODE_ECB );
if( cipher_info == NULL )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
if( cipher_info->block_size != 16 )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
/*
* SP 800-38F currently defines AES cipher as the only block cipher allowed:
* "For KW and KWP, the underlying block cipher shall be approved, and the
* block size shall be 128 bits. Currently, the AES block cipher, with key
* lengths of 128, 192, or 256 bits, is the only block cipher that fits
* this profile."
* Currently we don't support other 128 bit block ciphers for key wrapping,
* such as Camellia and Aria.
*/
if( cipher != MBEDTLS_CIPHER_ID_AES )
return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
mbedtls_cipher_free( &ctx->cipher_ctx );
if( ( ret = mbedtls_cipher_setup( &ctx->cipher_ctx, cipher_info ) ) != 0 )
return( ret );
if( ( ret = mbedtls_cipher_setkey( &ctx->cipher_ctx, key, keybits,
is_wrap ? MBEDTLS_ENCRYPT :
MBEDTLS_DECRYPT )
) != 0 )
{
return( ret );
}
return( 0 );
}
/*
* Free context
*/
void mbedtls_nist_kw_free( mbedtls_nist_kw_context *ctx )
{
mbedtls_cipher_free( &ctx->cipher_ctx );
mbedtls_platform_zeroize( ctx, sizeof( mbedtls_nist_kw_context ) );
}
/*
* Helper function for Xoring the uint64_t "t" with the encrypted A.
* Defined in NIST SP 800-38F section 6.1
*/
static void calc_a_xor_t( unsigned char A[KW_SEMIBLOCK_LENGTH], uint64_t t )
{
size_t i = 0;
for( i = 0; i < sizeof( t ); i++ )
{
A[i] ^= ( t >> ( ( sizeof( t ) - 1 - i ) * 8 ) ) & 0xff;
}
}
/*
* KW-AE as defined in SP 800-38F section 6.2
* KWP-AE as defined in SP 800-38F section 6.3
*/
int mbedtls_nist_kw_wrap( mbedtls_nist_kw_context *ctx,
mbedtls_nist_kw_mode_t mode,
const unsigned char *input, size_t in_len,
unsigned char *output, size_t *out_len, size_t out_size )
{
int ret = 0;
size_t semiblocks = 0;
size_t s;
size_t olen, padlen = 0;
uint64_t t = 0;
unsigned char outbuff[KW_SEMIBLOCK_LENGTH * 2];
unsigned char inbuff[KW_SEMIBLOCK_LENGTH * 2];
unsigned char *R2 = output + KW_SEMIBLOCK_LENGTH;
unsigned char *A = output;
*out_len = 0;
/*
* Generate the String to work on
*/
if( mode == MBEDTLS_KW_MODE_KW )
{
if( out_size < in_len + KW_SEMIBLOCK_LENGTH )
{
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
}
/*
* According to SP 800-38F Table 1, the plaintext length for KW
* must be between 2 to 2^54-1 semiblocks inclusive.
*/
if( in_len < 16 ||
#if SIZE_MAX > 0x1FFFFFFFFFFFFF8
in_len > 0x1FFFFFFFFFFFFF8 ||
#endif
in_len % KW_SEMIBLOCK_LENGTH != 0 )
{
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
}
memcpy( output, NIST_KW_ICV1, KW_SEMIBLOCK_LENGTH );
memmove( output + KW_SEMIBLOCK_LENGTH, input, in_len );
}
else
{
if( in_len % 8 != 0 )
{
padlen = ( 8 - ( in_len % 8 ) );
}
if( out_size < in_len + KW_SEMIBLOCK_LENGTH + padlen )
{
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
}
/*
* According to SP 800-38F Table 1, the plaintext length for KWP
* must be between 1 and 2^32-1 octets inclusive.
*/
if( in_len < 1
#if SIZE_MAX > 0xFFFFFFFF
|| in_len > 0xFFFFFFFF
#endif
)
{
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
}
memcpy( output, NIST_KW_ICV2, KW_SEMIBLOCK_LENGTH / 2 );
PUT_UINT32_BE( ( in_len & 0xffffffff ), output,
KW_SEMIBLOCK_LENGTH / 2 );
memcpy( output + KW_SEMIBLOCK_LENGTH, input, in_len );
memset( output + KW_SEMIBLOCK_LENGTH + in_len, 0, padlen );
}
semiblocks = ( ( in_len + padlen ) / KW_SEMIBLOCK_LENGTH ) + 1;
s = 6 * ( semiblocks - 1 );
if( mode == MBEDTLS_KW_MODE_KWP
&& in_len <= KW_SEMIBLOCK_LENGTH )
{
memcpy( inbuff, output, 16 );
ret = mbedtls_cipher_update( &ctx->cipher_ctx,
inbuff, 16, output, &olen );
if( ret != 0 )
goto cleanup;
}
else
{
/*
* Do the wrapping function W, as defined in RFC 3394 section 2.2.1
*/
if( semiblocks < MIN_SEMIBLOCKS_COUNT )
{
ret = MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA;
goto cleanup;
}
/* Calculate intermediate values */
for( t = 1; t <= s; t++ )
{
memcpy( inbuff, A, KW_SEMIBLOCK_LENGTH );
memcpy( inbuff + KW_SEMIBLOCK_LENGTH, R2, KW_SEMIBLOCK_LENGTH );
ret = mbedtls_cipher_update( &ctx->cipher_ctx,
inbuff, 16, outbuff, &olen );
if( ret != 0 )
goto cleanup;
memcpy( A, outbuff, KW_SEMIBLOCK_LENGTH );
calc_a_xor_t( A, t );
memcpy( R2, outbuff + KW_SEMIBLOCK_LENGTH, KW_SEMIBLOCK_LENGTH );
R2 += KW_SEMIBLOCK_LENGTH;
if( R2 >= output + ( semiblocks * KW_SEMIBLOCK_LENGTH ) )
R2 = output + KW_SEMIBLOCK_LENGTH;
}
}
*out_len = semiblocks * KW_SEMIBLOCK_LENGTH;
cleanup:
if( ret != 0)
{
mbedtls_platform_zeroize( output, semiblocks * KW_SEMIBLOCK_LENGTH );
}
mbedtls_platform_zeroize( inbuff, KW_SEMIBLOCK_LENGTH * 2 );
mbedtls_platform_zeroize( outbuff, KW_SEMIBLOCK_LENGTH * 2 );
return( ret );
}
/*
* W-1 function as defined in RFC 3394 section 2.2.2
* This function assumes the following:
* 1. Output buffer is at least of size ( semiblocks - 1 ) * KW_SEMIBLOCK_LENGTH.
* 2. The input buffer is of size semiblocks * KW_SEMIBLOCK_LENGTH.
* 3. Minimal number of semiblocks is 3.
* 4. A is a buffer to hold the first semiblock of the input buffer.
*/
static int unwrap( mbedtls_nist_kw_context *ctx,
const unsigned char *input, size_t semiblocks,
unsigned char A[KW_SEMIBLOCK_LENGTH],
unsigned char *output, size_t* out_len )
{
int ret = 0;
const size_t s = 6 * ( semiblocks - 1 );
size_t olen;
uint64_t t = 0;
unsigned char outbuff[KW_SEMIBLOCK_LENGTH * 2];
unsigned char inbuff[KW_SEMIBLOCK_LENGTH * 2];
unsigned char *R = output + ( semiblocks - 2 ) * KW_SEMIBLOCK_LENGTH;
*out_len = 0;
if( semiblocks < MIN_SEMIBLOCKS_COUNT )
{
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
}
memcpy( A, input, KW_SEMIBLOCK_LENGTH );
memmove( output, input + KW_SEMIBLOCK_LENGTH, ( semiblocks - 1 ) * KW_SEMIBLOCK_LENGTH );
/* Calculate intermediate values */
for( t = s; t >= 1; t-- )
{
calc_a_xor_t( A, t );
memcpy( inbuff, A, KW_SEMIBLOCK_LENGTH );
memcpy( inbuff + KW_SEMIBLOCK_LENGTH, R, KW_SEMIBLOCK_LENGTH );
ret = mbedtls_cipher_update( &ctx->cipher_ctx,
inbuff, 16, outbuff, &olen );
if( ret != 0 )
goto cleanup;
memcpy( A, outbuff, KW_SEMIBLOCK_LENGTH );
/* Set R as LSB64 of outbuff */
memcpy( R, outbuff + KW_SEMIBLOCK_LENGTH, KW_SEMIBLOCK_LENGTH );
if( R == output )
R = output + ( semiblocks - 2 ) * KW_SEMIBLOCK_LENGTH;
else
R -= KW_SEMIBLOCK_LENGTH;
}
*out_len = ( semiblocks - 1 ) * KW_SEMIBLOCK_LENGTH;
cleanup:
if( ret != 0)
mbedtls_platform_zeroize( output, ( semiblocks - 1 ) * KW_SEMIBLOCK_LENGTH );
mbedtls_platform_zeroize( inbuff, sizeof( inbuff ) );
mbedtls_platform_zeroize( outbuff, sizeof( outbuff ) );
return( ret );
}
/*
* KW-AD as defined in SP 800-38F section 6.2
* KWP-AD as defined in SP 800-38F section 6.3
*/
int mbedtls_nist_kw_unwrap( mbedtls_nist_kw_context *ctx,
mbedtls_nist_kw_mode_t mode,
const unsigned char *input, size_t in_len,
unsigned char *output, size_t *out_len, size_t out_size )
{
int ret = 0;
size_t i, olen;
unsigned char A[KW_SEMIBLOCK_LENGTH];
unsigned char diff, bad_padding = 0;
*out_len = 0;
if( out_size < in_len - KW_SEMIBLOCK_LENGTH )
{
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
}
if( mode == MBEDTLS_KW_MODE_KW )
{
/*
* According to SP 800-38F Table 1, the ciphertext length for KW
* must be between 3 to 2^54 semiblocks inclusive.
*/
if( in_len < 24 ||
#if SIZE_MAX > 0x200000000000000
in_len > 0x200000000000000 ||
#endif
in_len % KW_SEMIBLOCK_LENGTH != 0 )
{
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
}
ret = unwrap( ctx, input, in_len / KW_SEMIBLOCK_LENGTH,
A, output, out_len );
if( ret != 0 )
goto cleanup;
/* Check ICV in "constant-time" */
diff = timingsafe_bcmp( NIST_KW_ICV1, A, KW_SEMIBLOCK_LENGTH );
if( diff != 0 )
{
ret = MBEDTLS_ERR_CIPHER_AUTH_FAILED;
goto cleanup;
}
}
else if( mode == MBEDTLS_KW_MODE_KWP )
{
size_t padlen = 0;
uint32_t Plen;
/*
* According to SP 800-38F Table 1, the ciphertext length for KWP
* must be between 2 to 2^29 semiblocks inclusive.
*/
if( in_len < KW_SEMIBLOCK_LENGTH * 2 ||
#if SIZE_MAX > 0x100000000
in_len > 0x100000000 ||
#endif
in_len % KW_SEMIBLOCK_LENGTH != 0 )
{
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
}
if( in_len == KW_SEMIBLOCK_LENGTH * 2 )
{
unsigned char outbuff[KW_SEMIBLOCK_LENGTH * 2];
ret = mbedtls_cipher_update( &ctx->cipher_ctx,
input, 16, outbuff, &olen );
if( ret != 0 )
goto cleanup;
memcpy( A, outbuff, KW_SEMIBLOCK_LENGTH );
memcpy( output, outbuff + KW_SEMIBLOCK_LENGTH, KW_SEMIBLOCK_LENGTH );
mbedtls_platform_zeroize( outbuff, sizeof( outbuff ) );
*out_len = KW_SEMIBLOCK_LENGTH;
}
else
{
/* in_len >= KW_SEMIBLOCK_LENGTH * 3 */
ret = unwrap( ctx, input, in_len / KW_SEMIBLOCK_LENGTH,
A, output, out_len );
if( ret != 0 )
goto cleanup;
}
/* Check ICV in "constant-time" */
diff = timingsafe_bcmp( NIST_KW_ICV2, A, KW_SEMIBLOCK_LENGTH / 2 );
if( diff != 0 )
{
ret = MBEDTLS_ERR_CIPHER_AUTH_FAILED;
}
GET_UINT32_BE( Plen, A, KW_SEMIBLOCK_LENGTH / 2 );
/*
* Plen is the length of the plaintext, when the input is valid.
* If Plen is larger than the plaintext and padding, padlen will be
* larger than 8, because of the type wrap around.
*/
padlen = in_len - KW_SEMIBLOCK_LENGTH - Plen;
if ( padlen > 7 )
{
padlen &= 7;
ret = MBEDTLS_ERR_CIPHER_AUTH_FAILED;
}
/* Check padding in "constant-time" */
for( diff = 0, i = 0; i < KW_SEMIBLOCK_LENGTH; i++ )
{
if( i >= KW_SEMIBLOCK_LENGTH - padlen )
diff |= output[*out_len - KW_SEMIBLOCK_LENGTH + i];
else
bad_padding |= output[*out_len - KW_SEMIBLOCK_LENGTH + i];
}
if( diff != 0 )
{
ret = MBEDTLS_ERR_CIPHER_AUTH_FAILED;
}
if( ret != 0 )
{
goto cleanup;
}
mbedtls_platform_zeroize( output + Plen, padlen );
*out_len = Plen;
}
else
{
ret = MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE;
goto cleanup;
}
cleanup:
if( ret != 0 )
{
mbedtls_platform_zeroize( output, *out_len );
*out_len = 0;
}
mbedtls_platform_zeroize( &bad_padding, sizeof( bad_padding) );
mbedtls_platform_zeroize( &diff, sizeof( diff ) );
mbedtls_platform_zeroize( A, sizeof( A ) );
return( ret );
}
#endif /* !MBEDTLS_NIST_KW_ALT */
#if defined(MBEDTLS_SELF_TEST) && defined(MBEDTLS_AES_C)
#define KW_TESTS 3
/*
* Test vectors taken from NIST
* https://csrc.nist.gov/Projects/Cryptographic-Algorithm-Validation-Program/CAVP-TESTING-BLOCK-CIPHER-MODES#KW
*/
static const unsigned int key_len[KW_TESTS] = { 16, 24, 32 };
static const unsigned char kw_key[KW_TESTS][32] = {
{ 0x75, 0x75, 0xda, 0x3a, 0x93, 0x60, 0x7c, 0xc2,
0xbf, 0xd8, 0xce, 0xc7, 0xaa, 0xdf, 0xd9, 0xa6 },
{ 0x2d, 0x85, 0x26, 0x08, 0x1d, 0x02, 0xfb, 0x5b,
0x85, 0xf6, 0x9a, 0xc2, 0x86, 0xec, 0xd5, 0x7d,
0x40, 0xdf, 0x5d, 0xf3, 0x49, 0x47, 0x44, 0xd3 },
{ 0x11, 0x2a, 0xd4, 0x1b, 0x48, 0x56, 0xc7, 0x25,
0x4a, 0x98, 0x48, 0xd3, 0x0f, 0xdd, 0x78, 0x33,
0x5b, 0x03, 0x9a, 0x48, 0xa8, 0x96, 0x2c, 0x4d,
0x1c, 0xb7, 0x8e, 0xab, 0xd5, 0xda, 0xd7, 0x88 }
};
static const unsigned char kw_msg[KW_TESTS][40] = {
{ 0x42, 0x13, 0x6d, 0x3c, 0x38, 0x4a, 0x3e, 0xea,
0xc9, 0x5a, 0x06, 0x6f, 0xd2, 0x8f, 0xed, 0x3f },
{ 0x95, 0xc1, 0x1b, 0xf5, 0x35, 0x3a, 0xfe, 0xdb,
0x98, 0xfd, 0xd6, 0xc8, 0xca, 0x6f, 0xdb, 0x6d,
0xa5, 0x4b, 0x74, 0xb4, 0x99, 0x0f, 0xdc, 0x45,
0xc0, 0x9d, 0x15, 0x8f, 0x51, 0xce, 0x62, 0x9d,
0xe2, 0xaf, 0x26, 0xe3, 0x25, 0x0e, 0x6b, 0x4c },
{ 0x1b, 0x20, 0xbf, 0x19, 0x90, 0xb0, 0x65, 0xd7,
0x98, 0xe1, 0xb3, 0x22, 0x64, 0xad, 0x50, 0xa8,
0x74, 0x74, 0x92, 0xba, 0x09, 0xa0, 0x4d, 0xd1 }
};
static const size_t kw_msg_len[KW_TESTS] = { 16, 40, 24 };
static const size_t kw_out_len[KW_TESTS] = { 24, 48, 32 };
static const unsigned char kw_res[KW_TESTS][48] = {
{ 0x03, 0x1f, 0x6b, 0xd7, 0xe6, 0x1e, 0x64, 0x3d,
0xf6, 0x85, 0x94, 0x81, 0x6f, 0x64, 0xca, 0xa3,
0xf5, 0x6f, 0xab, 0xea, 0x25, 0x48, 0xf5, 0xfb },
{ 0x44, 0x3c, 0x6f, 0x15, 0x09, 0x83, 0x71, 0x91,
0x3e, 0x5c, 0x81, 0x4c, 0xa1, 0xa0, 0x42, 0xec,
0x68, 0x2f, 0x7b, 0x13, 0x6d, 0x24, 0x3a, 0x4d,
0x6c, 0x42, 0x6f, 0xc6, 0x97, 0x15, 0x63, 0xe8,
0xa1, 0x4a, 0x55, 0x8e, 0x09, 0x64, 0x16, 0x19,
0xbf, 0x03, 0xfc, 0xaf, 0x90, 0xb1, 0xfc, 0x2d },
{ 0xba, 0x8a, 0x25, 0x9a, 0x47, 0x1b, 0x78, 0x7d,
0xd5, 0xd5, 0x40, 0xec, 0x25, 0xd4, 0x3d, 0x87,
0x20, 0x0f, 0xda, 0xdc, 0x6d, 0x1f, 0x05, 0xd9,
0x16, 0x58, 0x4f, 0xa9, 0xf6, 0xcb, 0xf5, 0x12 }
};
static const unsigned char kwp_key[KW_TESTS][32] = {
{ 0x78, 0x65, 0xe2, 0x0f, 0x3c, 0x21, 0x65, 0x9a,
0xb4, 0x69, 0x0b, 0x62, 0x9c, 0xdf, 0x3c, 0xc4 },
{ 0xf5, 0xf8, 0x96, 0xa3, 0xbd, 0x2f, 0x4a, 0x98,
0x23, 0xef, 0x16, 0x2b, 0x00, 0xb8, 0x05, 0xd7,
0xde, 0x1e, 0xa4, 0x66, 0x26, 0x96, 0xa2, 0x58 },
{ 0x95, 0xda, 0x27, 0x00, 0xca, 0x6f, 0xd9, 0xa5,
0x25, 0x54, 0xee, 0x2a, 0x8d, 0xf1, 0x38, 0x6f,
0x5b, 0x94, 0xa1, 0xa6, 0x0e, 0xd8, 0xa4, 0xae,
0xf6, 0x0a, 0x8d, 0x61, 0xab, 0x5f, 0x22, 0x5a }
};
static const unsigned char kwp_msg[KW_TESTS][31] = {
{ 0xbd, 0x68, 0x43, 0xd4, 0x20, 0x37, 0x8d, 0xc8,
0x96 },
{ 0x6c, 0xcd, 0xd5, 0x85, 0x18, 0x40, 0x97, 0xeb,
0xd5, 0xc3, 0xaf, 0x3e, 0x47, 0xd0, 0x2c, 0x19,
0x14, 0x7b, 0x4d, 0x99, 0x5f, 0x96, 0x43, 0x66,
0x91, 0x56, 0x75, 0x8c, 0x13, 0x16, 0x8f },
{ 0xd1 }
};
static const size_t kwp_msg_len[KW_TESTS] = { 9, 31, 1 };
static const unsigned char kwp_res[KW_TESTS][48] = {
{ 0x41, 0xec, 0xa9, 0x56, 0xd4, 0xaa, 0x04, 0x7e,
0xb5, 0xcf, 0x4e, 0xfe, 0x65, 0x96, 0x61, 0xe7,
0x4d, 0xb6, 0xf8, 0xc5, 0x64, 0xe2, 0x35, 0x00 },
{ 0x4e, 0x9b, 0xc2, 0xbc, 0xbc, 0x6c, 0x1e, 0x13,
0xd3, 0x35, 0xbc, 0xc0, 0xf7, 0x73, 0x6a, 0x88,
0xfa, 0x87, 0x53, 0x66, 0x15, 0xbb, 0x8e, 0x63,
0x8b, 0xcc, 0x81, 0x66, 0x84, 0x68, 0x17, 0x90,
0x67, 0xcf, 0xa9, 0x8a, 0x9d, 0x0e, 0x33, 0x26 },
{ 0x06, 0xba, 0x7a, 0xe6, 0xf3, 0x24, 0x8c, 0xfd,
0xcf, 0x26, 0x75, 0x07, 0xfa, 0x00, 0x1b, 0xc4 }
};
static const size_t kwp_out_len[KW_TESTS] = { 24, 40, 16 };
int mbedtls_nist_kw_self_test( int verbose )
{
mbedtls_nist_kw_context ctx;
unsigned char out[48];
size_t olen;
int i;
int ret = 0;
mbedtls_nist_kw_init( &ctx );
for( i = 0; i < KW_TESTS; i++ )
{
if( verbose != 0 )
mbedtls_printf( " KW-AES-%u ", (unsigned int) key_len[i] * 8 );
ret = mbedtls_nist_kw_setkey( &ctx, MBEDTLS_CIPHER_ID_AES,
kw_key[i], key_len[i] * 8, 1 );
if( ret != 0 )
{
if( verbose != 0 )
mbedtls_printf( " KW: setup failed " );
goto end;
}
ret = mbedtls_nist_kw_wrap( &ctx, MBEDTLS_KW_MODE_KW, kw_msg[i],
kw_msg_len[i], out, &olen, sizeof( out ) );
if( ret != 0 || kw_out_len[i] != olen ||
timingsafe_bcmp( out, kw_res[i], kw_out_len[i] ) != 0 )
{
if( verbose != 0 )
mbedtls_printf( "failed. ");
ret = 1;
goto end;
}
if( ( ret = mbedtls_nist_kw_setkey( &ctx, MBEDTLS_CIPHER_ID_AES,
kw_key[i], key_len[i] * 8, 0 ) )
!= 0 )
{
if( verbose != 0 )
mbedtls_printf( " KW: setup failed ");
goto end;
}
ret = mbedtls_nist_kw_unwrap( &ctx, MBEDTLS_KW_MODE_KW,
out, olen, out, &olen, sizeof( out ) );
if( ret != 0 || olen != kw_msg_len[i] ||
timingsafe_bcmp( out, kw_msg[i], kw_msg_len[i] ) != 0 )
{
if( verbose != 0 )
mbedtls_printf( "failed\n" );
ret = 1;
goto end;
}
if( verbose != 0 )
mbedtls_printf( " passed\n" );
}
for( i = 0; i < KW_TESTS; i++ )
{
olen = sizeof( out );
if( verbose != 0 )
mbedtls_printf( " KWP-AES-%u ", (unsigned int) key_len[i] * 8 );
ret = mbedtls_nist_kw_setkey( &ctx, MBEDTLS_CIPHER_ID_AES, kwp_key[i],
key_len[i] * 8, 1 );
if( ret != 0 )
{
if( verbose != 0 )
mbedtls_printf( " KWP: setup failed " );
goto end;
}
ret = mbedtls_nist_kw_wrap( &ctx, MBEDTLS_KW_MODE_KWP, kwp_msg[i],
kwp_msg_len[i], out, &olen, sizeof( out ) );
if( ret != 0 || kwp_out_len[i] != olen ||
timingsafe_bcmp( out, kwp_res[i], kwp_out_len[i] ) != 0 )
{
if( verbose != 0 )
mbedtls_printf( "failed. ");
ret = 1;
goto end;
}
if( ( ret = mbedtls_nist_kw_setkey( &ctx, MBEDTLS_CIPHER_ID_AES,
kwp_key[i], key_len[i] * 8, 0 ) )
!= 0 )
{
if( verbose != 0 )
mbedtls_printf( " KWP: setup failed ");
goto end;
}
ret = mbedtls_nist_kw_unwrap( &ctx, MBEDTLS_KW_MODE_KWP, out,
olen, out, &olen, sizeof( out ) );
if( ret != 0 || olen != kwp_msg_len[i] ||
timingsafe_bcmp( out, kwp_msg[i], kwp_msg_len[i] ) != 0 )
{
if( verbose != 0 )
mbedtls_printf( "failed. ");
ret = 1;
goto end;
}
if( verbose != 0 )
mbedtls_printf( " passed\n" );
}
end:
mbedtls_nist_kw_free( &ctx );
if( verbose != 0 )
mbedtls_printf( "\n" );
return( ret );
}
#endif /* MBEDTLS_SELF_TEST && MBEDTLS_AES_C */
| 24,564 | 720 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/bignum_internal.h | #ifndef COSMOPOLITAN_THIRD_PARTY_MBEDTLS_BIGNUM_INTERNAL_H_
#define COSMOPOLITAN_THIRD_PARTY_MBEDTLS_BIGNUM_INTERNAL_H_
#include "third_party/mbedtls/platform.h"
#if !(__ASSEMBLER__ + __LINKER__ + 0)
COSMOPOLITAN_C_START_
#define MPI_VALIDATE_RET(cond) \
MBEDTLS_INTERNAL_VALIDATE_RET(cond, MBEDTLS_ERR_MPI_BAD_INPUT_DATA)
#define MPI_VALIDATE(cond) MBEDTLS_INTERNAL_VALIDATE(cond)
#define ciL (sizeof(mbedtls_mpi_uint)) /* chars in limb */
#define biL (ciL << 3) /* bits in limb */
#define biH (ciL << 2) /* half limb size */
#define MPI_SIZE_T_MAX ((size_t)-1) /* SIZE_T_MAX is not standard */
/*
* Convert between bits/chars and number of limbs
* Divide first in order to avoid potential overflows
*/
#define BITS_TO_LIMBS(i) ((i) / biL + ((i) % biL != 0))
#define CHARS_TO_LIMBS(i) ((i) / ciL + ((i) % ciL != 0))
extern void (*Mul4x4)(uint64_t[8], const uint64_t[4], const uint64_t[4]);
extern void (*ShiftRight)(uint64_t *, size_t, unsigned char);
void ShiftRightAvx(uint64_t *, size_t, unsigned char);
void ShiftRightPure(uint64_t *, size_t, unsigned char);
void Mul4x4Adx(uint64_t[8], const uint64_t[4], const uint64_t[4]);
void Mul6x6Adx(uint64_t[12], const uint64_t[6], const uint64_t[6]);
void Mul8x8Adx(uint64_t[16], const uint64_t[8], const uint64_t[8]);
void Mul4x4Pure(uint64_t[16], const uint64_t[8], const uint64_t[8]);
void Mul(uint64_t *, uint64_t *, unsigned, uint64_t *, unsigned);
void Karatsuba(uint64_t *, uint64_t *, uint64_t *, size_t, uint64_t *);
void mbedtls_mpi_mul_hlp(size_t, uint64_t *, uint64_t *, uint64_t);
void mbedtls_mpi_mul_hlp1(size_t, const uint64_t *, uint64_t *, uint64_t);
COSMOPOLITAN_C_END_
#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
#endif /* COSMOPOLITAN_THIRD_PARTY_MBEDTLS_BIGNUM_INTERNAL_H_ */
| 1,765 | 41 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/aes.h | #ifndef MBEDTLS_AES_H_
#define MBEDTLS_AES_H_
#include "third_party/mbedtls/config.h"
COSMOPOLITAN_C_START_
/* clang-format off */
/* padlock.c and aesni.c rely on these values! */
#define MBEDTLS_AES_ENCRYPT 1 /*< AES encryption. */
#define MBEDTLS_AES_DECRYPT 0 /*< AES decryption. */
/* Error codes in range 0x0020-0x0022 */
#define MBEDTLS_ERR_AES_INVALID_KEY_LENGTH -0x0020 /*< Invalid key length. */
#define MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH -0x0022 /*< Invalid data input length. */
/* Error codes in range 0x0021-0x0025 */
#define MBEDTLS_ERR_AES_BAD_INPUT_DATA -0x0021 /*< Invalid input data. */
/* MBEDTLS_ERR_AES_FEATURE_UNAVAILABLE is deprecated and should not be used. */
#define MBEDTLS_ERR_AES_FEATURE_UNAVAILABLE -0x0023 /*< Feature not available. For example, an unsupported AES key size. */
/* MBEDTLS_ERR_AES_HW_ACCEL_FAILED is deprecated and should not be used. */
#define MBEDTLS_ERR_AES_HW_ACCEL_FAILED -0x0025 /*< AES hardware accelerator failed. */
/**
* \brief The AES context-type definition.
*/
typedef struct mbedtls_aes_context
{
int nr; /*!< The number of rounds. */
uint32_t *rk; /*!< AES round keys. */
uint32_t buf[68]; /*!< Unaligned data buffer. This buffer can
hold 32 extra Bytes, which can be used for
one of the following purposes:
<ul><li>Alignment if VIA padlock is
used.</li>
<li>Simplifying key expansion in the 256-bit
case by generating an extra round key.
</li></ul> */
}
mbedtls_aes_context;
#if defined(MBEDTLS_CIPHER_MODE_XTS)
/**
* \brief The AES XTS context-type definition.
*/
typedef struct mbedtls_aes_xts_context
{
mbedtls_aes_context crypt; /*!< The AES context to use for AES block
encryption or decryption. */
mbedtls_aes_context tweak; /*!< The AES context used for tweak
computation. */
} mbedtls_aes_xts_context;
#endif /* MBEDTLS_CIPHER_MODE_XTS */
/**
* \brief This function initializes the specified AES context.
*
* It must be the first API called before using
* the context.
*
* \param ctx The AES context to initialize. This must not be \c NULL.
*/
void mbedtls_aes_init( mbedtls_aes_context *ctx );
/**
* \brief This function releases and clears the specified AES context.
*
* \param ctx The AES context to clear.
* If this is \c NULL, this function does nothing.
* Otherwise, the context must have been at least initialized.
*/
void mbedtls_aes_free( mbedtls_aes_context *ctx );
#if defined(MBEDTLS_CIPHER_MODE_XTS)
/**
* \brief This function initializes the specified AES XTS context.
*
* It must be the first API called before using
* the context.
*
* \param ctx The AES XTS context to initialize. This must not be \c NULL.
*/
void mbedtls_aes_xts_init( mbedtls_aes_xts_context *ctx );
/**
* \brief This function releases and clears the specified AES XTS context.
*
* \param ctx The AES XTS context to clear.
* If this is \c NULL, this function does nothing.
* Otherwise, the context must have been at least initialized.
*/
void mbedtls_aes_xts_free( mbedtls_aes_xts_context *ctx );
#endif /* MBEDTLS_CIPHER_MODE_XTS */
/**
* \brief This function sets the encryption key.
*
* \param ctx The AES context to which the key should be bound.
* It must be initialized.
* \param key The encryption key.
* This must be a readable buffer of size \p keybits bits.
* \param keybits The size of data passed in bits. Valid options are:
* <ul><li>128 bits</li>
* <li>192 bits</li>
* <li>256 bits</li></ul>
*
* \return \c 0 on success.
* \return #MBEDTLS_ERR_AES_INVALID_KEY_LENGTH on failure.
*/
int mbedtls_aes_setkey_enc( mbedtls_aes_context *ctx, const unsigned char *key,
unsigned int keybits );
/**
* \brief This function sets the decryption key.
*
* \param ctx The AES context to which the key should be bound.
* It must be initialized.
* \param key The decryption key.
* This must be a readable buffer of size \p keybits bits.
* \param keybits The size of data passed. Valid options are:
* <ul><li>128 bits</li>
* <li>192 bits</li>
* <li>256 bits</li></ul>
*
* \return \c 0 on success.
* \return #MBEDTLS_ERR_AES_INVALID_KEY_LENGTH on failure.
*/
int mbedtls_aes_setkey_dec( mbedtls_aes_context *ctx, const unsigned char *key,
unsigned int keybits );
#if defined(MBEDTLS_CIPHER_MODE_XTS)
/**
* \brief This function prepares an XTS context for encryption and
* sets the encryption key.
*
* \param ctx The AES XTS context to which the key should be bound.
* It must be initialized.
* \param key The encryption key. This is comprised of the XTS key1
* concatenated with the XTS key2.
* This must be a readable buffer of size \p keybits bits.
* \param keybits The size of \p key passed in bits. Valid options are:
* <ul><li>256 bits (each of key1 and key2 is a 128-bit key)</li>
* <li>512 bits (each of key1 and key2 is a 256-bit key)</li></ul>
*
* \return \c 0 on success.
* \return #MBEDTLS_ERR_AES_INVALID_KEY_LENGTH on failure.
*/
int mbedtls_aes_xts_setkey_enc( mbedtls_aes_xts_context *ctx,
const unsigned char *key,
unsigned int keybits );
/**
* \brief This function prepares an XTS context for decryption and
* sets the decryption key.
*
* \param ctx The AES XTS context to which the key should be bound.
* It must be initialized.
* \param key The decryption key. This is comprised of the XTS key1
* concatenated with the XTS key2.
* This must be a readable buffer of size \p keybits bits.
* \param keybits The size of \p key passed in bits. Valid options are:
* <ul><li>256 bits (each of key1 and key2 is a 128-bit key)</li>
* <li>512 bits (each of key1 and key2 is a 256-bit key)</li></ul>
*
* \return \c 0 on success.
* \return #MBEDTLS_ERR_AES_INVALID_KEY_LENGTH on failure.
*/
int mbedtls_aes_xts_setkey_dec( mbedtls_aes_xts_context *ctx,
const unsigned char *key,
unsigned int keybits );
#endif /* MBEDTLS_CIPHER_MODE_XTS */
/**
* \brief This function performs an AES single-block encryption or
* decryption operation.
*
* It performs the operation defined in the \p mode parameter
* (encrypt or decrypt), on the input data buffer defined in
* the \p input parameter.
*
* mbedtls_aes_init(), and either mbedtls_aes_setkey_enc() or
* mbedtls_aes_setkey_dec() must be called before the first
* call to this API with the same context.
*
* \param ctx The AES context to use for encryption or decryption.
* It must be initialized and bound to a key.
* \param mode The AES operation: #MBEDTLS_AES_ENCRYPT or
* #MBEDTLS_AES_DECRYPT.
* \param input The buffer holding the input data.
* It must be readable and at least \c 16 Bytes long.
* \param output The buffer where the output data will be written.
* It must be writeable and at least \c 16 Bytes long.
* \return \c 0 on success.
*/
int mbedtls_aes_crypt_ecb( mbedtls_aes_context *ctx,
int mode,
const unsigned char input[16],
unsigned char output[16] );
#if defined(MBEDTLS_CIPHER_MODE_CBC)
/**
* \brief This function performs an AES-CBC encryption or decryption operation
* on full blocks.
*
* It performs the operation defined in the \p mode
* parameter (encrypt/decrypt), on the input data buffer defined in
* the \p input parameter.
*
* It can be called as many times as needed, until all the input
* data is processed. mbedtls_aes_init(), and either
* mbedtls_aes_setkey_enc() or mbedtls_aes_setkey_dec() must be called
* before the first call to this API with the same context.
*
* \note This function operates on full blocks, that is, the input size
* must be a multiple of the AES block size of \c 16 Bytes.
*
* \note Upon exit, the content of the IV is updated so that you can
* call the same function again on the next
* block(s) of data and get the same result as if it was
* encrypted in one call. This allows a "streaming" usage.
* If you need to retain the contents of the IV, you should
* either save it manually or use the cipher module instead.
*
*
* \param ctx The AES context to use for encryption or decryption.
* It must be initialized and bound to a key.
* \param mode The AES operation: #MBEDTLS_AES_ENCRYPT or
* #MBEDTLS_AES_DECRYPT.
* \param length The length of the input data in Bytes. This must be a
* multiple of the block size (\c 16 Bytes).
* \param iv Initialization vector (updated after use).
* It must be a readable and writeable buffer of \c 16 Bytes.
* \param input The buffer holding the input data.
* It must be readable and of size \p length Bytes.
* \param output The buffer holding the output data.
* It must be writeable and of size \p length Bytes.
*
* \return \c 0 on success.
* \return #MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH
* on failure.
*/
int mbedtls_aes_crypt_cbc( mbedtls_aes_context *ctx,
int mode,
size_t length,
unsigned char iv[16],
const unsigned char *input,
unsigned char *output );
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#if defined(MBEDTLS_CIPHER_MODE_XTS)
/**
* \brief This function performs an AES-XTS encryption or decryption
* operation for an entire XTS data unit.
*
* AES-XTS encrypts or decrypts blocks based on their location as
* defined by a data unit number. The data unit number must be
* provided by \p data_unit.
*
* NIST SP 800-38E limits the maximum size of a data unit to 2^20
* AES blocks. If the data unit is larger than this, this function
* returns #MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH.
*
* \param ctx The AES XTS context to use for AES XTS operations.
* It must be initialized and bound to a key.
* \param mode The AES operation: #MBEDTLS_AES_ENCRYPT or
* #MBEDTLS_AES_DECRYPT.
* \param length The length of a data unit in Bytes. This can be any
* length between 16 bytes and 2^24 bytes inclusive
* (between 1 and 2^20 block cipher blocks).
* \param data_unit The address of the data unit encoded as an array of 16
* bytes in little-endian format. For disk encryption, this
* is typically the index of the block device sector that
* contains the data.
* \param input The buffer holding the input data (which is an entire
* data unit). This function reads \p length Bytes from \p
* input.
* \param output The buffer holding the output data (which is an entire
* data unit). This function writes \p length Bytes to \p
* output.
*
* \return \c 0 on success.
* \return #MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH if \p length is
* smaller than an AES block in size (16 Bytes) or if \p
* length is larger than 2^20 blocks (16 MiB).
*/
int mbedtls_aes_crypt_xts( mbedtls_aes_xts_context *ctx,
int mode,
size_t length,
const unsigned char data_unit[16],
const unsigned char *input,
unsigned char *output );
#endif /* MBEDTLS_CIPHER_MODE_XTS */
#if defined(MBEDTLS_CIPHER_MODE_CFB)
/**
* \brief This function performs an AES-CFB128 encryption or decryption
* operation.
*
* It performs the operation defined in the \p mode
* parameter (encrypt or decrypt), on the input data buffer
* defined in the \p input parameter.
*
* For CFB, you must set up the context with mbedtls_aes_setkey_enc(),
* regardless of whether you are performing an encryption or decryption
* operation, that is, regardless of the \p mode parameter. This is
* because CFB mode uses the same key schedule for encryption and
* decryption.
*
* \note Upon exit, the content of the IV is updated so that you can
* call the same function again on the next
* block(s) of data and get the same result as if it was
* encrypted in one call. This allows a "streaming" usage.
* If you need to retain the contents of the
* IV, you must either save it manually or use the cipher
* module instead.
*
*
* \param ctx The AES context to use for encryption or decryption.
* It must be initialized and bound to a key.
* \param mode The AES operation: #MBEDTLS_AES_ENCRYPT or
* #MBEDTLS_AES_DECRYPT.
* \param length The length of the input data in Bytes.
* \param iv_off The offset in IV (updated after use).
* It must point to a valid \c size_t.
* \param iv The initialization vector (updated after use).
* It must be a readable and writeable buffer of \c 16 Bytes.
* \param input The buffer holding the input data.
* It must be readable and of size \p length Bytes.
* \param output The buffer holding the output data.
* It must be writeable and of size \p length Bytes.
*
* \return \c 0 on success.
*/
int mbedtls_aes_crypt_cfb128( mbedtls_aes_context *ctx,
int mode,
size_t length,
size_t *iv_off,
unsigned char iv[16],
const unsigned char *input,
unsigned char *output );
/**
* \brief This function performs an AES-CFB8 encryption or decryption
* operation.
*
* It performs the operation defined in the \p mode
* parameter (encrypt/decrypt), on the input data buffer defined
* in the \p input parameter.
*
* Due to the nature of CFB, you must use the same key schedule for
* both encryption and decryption operations. Therefore, you must
* use the context initialized with mbedtls_aes_setkey_enc() for
* both #MBEDTLS_AES_ENCRYPT and #MBEDTLS_AES_DECRYPT.
*
* \note Upon exit, the content of the IV is updated so that you can
* call the same function again on the next
* block(s) of data and get the same result as if it was
* encrypted in one call. This allows a "streaming" usage.
* If you need to retain the contents of the
* IV, you should either save it manually or use the cipher
* module instead.
*
*
* \param ctx The AES context to use for encryption or decryption.
* It must be initialized and bound to a key.
* \param mode The AES operation: #MBEDTLS_AES_ENCRYPT or
* #MBEDTLS_AES_DECRYPT
* \param length The length of the input data.
* \param iv The initialization vector (updated after use).
* It must be a readable and writeable buffer of \c 16 Bytes.
* \param input The buffer holding the input data.
* It must be readable and of size \p length Bytes.
* \param output The buffer holding the output data.
* It must be writeable and of size \p length Bytes.
*
* \return \c 0 on success.
*/
int mbedtls_aes_crypt_cfb8( mbedtls_aes_context *ctx,
int mode,
size_t length,
unsigned char iv[16],
const unsigned char *input,
unsigned char *output );
#endif /*MBEDTLS_CIPHER_MODE_CFB */
#if defined(MBEDTLS_CIPHER_MODE_OFB)
/**
* \brief This function performs an AES-OFB (Output Feedback Mode)
* encryption or decryption operation.
*
* For OFB, you must set up the context with
* mbedtls_aes_setkey_enc(), regardless of whether you are
* performing an encryption or decryption operation. This is
* because OFB mode uses the same key schedule for encryption and
* decryption.
*
* The OFB operation is identical for encryption or decryption,
* therefore no operation mode needs to be specified.
*
* \note Upon exit, the content of iv, the Initialisation Vector, is
* updated so that you can call the same function again on the next
* block(s) of data and get the same result as if it was encrypted
* in one call. This allows a "streaming" usage, by initialising
* iv_off to 0 before the first call, and preserving its value
* between calls.
*
* For non-streaming use, the iv should be initialised on each call
* to a unique value, and iv_off set to 0 on each call.
*
* If you need to retain the contents of the initialisation vector,
* you must either save it manually or use the cipher module
* instead.
*
* \warning For the OFB mode, the initialisation vector must be unique
* every encryption operation. Reuse of an initialisation vector
* will compromise security.
*
* \param ctx The AES context to use for encryption or decryption.
* It must be initialized and bound to a key.
* \param length The length of the input data.
* \param iv_off The offset in IV (updated after use).
* It must point to a valid \c size_t.
* \param iv The initialization vector (updated after use).
* It must be a readable and writeable buffer of \c 16 Bytes.
* \param input The buffer holding the input data.
* It must be readable and of size \p length Bytes.
* \param output The buffer holding the output data.
* It must be writeable and of size \p length Bytes.
*
* \return \c 0 on success.
*/
int mbedtls_aes_crypt_ofb( mbedtls_aes_context *ctx,
size_t length,
size_t *iv_off,
unsigned char iv[16],
const unsigned char *input,
unsigned char *output );
#endif /* MBEDTLS_CIPHER_MODE_OFB */
#if defined(MBEDTLS_CIPHER_MODE_CTR)
/**
* \brief This function performs an AES-CTR encryption or decryption
* operation.
*
* This function performs the operation defined in the \p mode
* parameter (encrypt/decrypt), on the input data buffer
* defined in the \p input parameter.
*
* Due to the nature of CTR, you must use the same key schedule
* for both encryption and decryption operations. Therefore, you
* must use the context initialized with mbedtls_aes_setkey_enc()
* for both #MBEDTLS_AES_ENCRYPT and #MBEDTLS_AES_DECRYPT.
*
* \warning You must never reuse a nonce value with the same key. Doing so
* would void the encryption for the two messages encrypted with
* the same nonce and key.
*
* There are two common strategies for managing nonces with CTR:
*
* 1. You can handle everything as a single message processed over
* successive calls to this function. In that case, you want to
* set \p nonce_counter and \p nc_off to 0 for the first call, and
* then preserve the values of \p nonce_counter, \p nc_off and \p
* stream_block across calls to this function as they will be
* updated by this function.
*
* With this strategy, you must not encrypt more than 2**128
* blocks of data with the same key.
*
* 2. You can encrypt separate messages by dividing the \p
* nonce_counter buffer in two areas: the first one used for a
* per-message nonce, handled by yourself, and the second one
* updated by this function internally.
*
* For example, you might reserve the first 12 bytes for the
* per-message nonce, and the last 4 bytes for internal use. In that
* case, before calling this function on a new message you need to
* set the first 12 bytes of \p nonce_counter to your chosen nonce
* value, the last 4 to 0, and \p nc_off to 0 (which will cause \p
* stream_block to be ignored). That way, you can encrypt at most
* 2**96 messages of up to 2**32 blocks each with the same key.
*
* The per-message nonce (or information sufficient to reconstruct
* it) needs to be communicated with the ciphertext and must be unique.
* The recommended way to ensure uniqueness is to use a message
* counter. An alternative is to generate random nonces, but this
* limits the number of messages that can be securely encrypted:
* for example, with 96-bit random nonces, you should not encrypt
* more than 2**32 messages with the same key.
*
* Note that for both stategies, sizes are measured in blocks and
* that an AES block is 16 bytes.
*
* \warning Upon return, \p stream_block contains sensitive data. Its
* content must not be written to insecure storage and should be
* securely discarded as soon as it's no longer needed.
*
* \param ctx The AES context to use for encryption or decryption.
* It must be initialized and bound to a key.
* \param length The length of the input data.
* \param nc_off The offset in the current \p stream_block, for
* resuming within the current cipher stream. The
* offset pointer should be 0 at the start of a stream.
* It must point to a valid \c size_t.
* \param nonce_counter The 128-bit nonce and counter.
* It must be a readable-writeable buffer of \c 16 Bytes.
* \param stream_block The saved stream block for resuming. This is
* overwritten by the function.
* It must be a readable-writeable buffer of \c 16 Bytes.
* \param input The buffer holding the input data.
* It must be readable and of size \p length Bytes.
* \param output The buffer holding the output data.
* It must be writeable and of size \p length Bytes.
*
* \return \c 0 on success.
*/
int mbedtls_aes_crypt_ctr( mbedtls_aes_context *ctx,
size_t length,
size_t *nc_off,
unsigned char nonce_counter[16],
unsigned char stream_block[16],
const unsigned char *input,
unsigned char *output );
#endif /* MBEDTLS_CIPHER_MODE_CTR */
/**
* \brief Internal AES block encryption function. This is only
* exposed to allow overriding it using
* \c MBEDTLS_AES_ENCRYPT_ALT.
*
* \param ctx The AES context to use for encryption.
* \param input The plaintext block.
* \param output The output (ciphertext) block.
*
* \return \c 0 on success.
*/
int mbedtls_internal_aes_encrypt( mbedtls_aes_context *ctx,
const unsigned char input[16],
unsigned char output[16] );
/**
* \brief Internal AES block decryption function. This is only
* exposed to allow overriding it using see
* \c MBEDTLS_AES_DECRYPT_ALT.
*
* \param ctx The AES context to use for decryption.
* \param input The ciphertext block.
* \param output The output (plaintext) block.
*
* \return \c 0 on success.
*/
int mbedtls_internal_aes_decrypt( mbedtls_aes_context *ctx,
const unsigned char input[16],
unsigned char output[16] );
/**
* \brief Checkup routine.
*
* \return \c 0 on success.
* \return \c 1 on failure.
*/
int mbedtls_aes_self_test( int verbose );
COSMOPOLITAN_C_END_
#endif /* MBEDTLS_AES_H_ */
| 26,151 | 568 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/x509write_crt.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:4;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright The Mbed TLS Contributors â
â â
â Licensed under the Apache License, Version 2.0 (the "License"); â
â you may not use this file except in compliance with the License. â
â You may obtain a copy of the License at â
â â
â http://www.apache.org/licenses/LICENSE-2.0 â
â â
â Unless required by applicable law or agreed to in writing, software â
â distributed under the License is distributed on an "AS IS" BASIS, â
â WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. â
â See the License for the specific language governing permissions and â
â limitations under the License. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "third_party/mbedtls/asn1write.h"
#include "third_party/mbedtls/common.h"
#include "third_party/mbedtls/error.h"
#include "third_party/mbedtls/oid.h"
#include "third_party/mbedtls/pem.h"
#include "third_party/mbedtls/platform.h"
#include "third_party/mbedtls/sha1.h"
#include "third_party/mbedtls/x509_crt.h"
asm(".ident\t\"\\n\\n\
Mbed TLS (Apache 2.0)\\n\
Copyright ARM Limited\\n\
Copyright Mbed TLS Contributors\"");
asm(".include \"libc/disclaimer.inc\"");
/* clang-format off */
/*
* X.509 certificate writing
*
* Copyright The Mbed TLS Contributors
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* References:
* - certificates: RFC 5280, updated by RFC 6818
* - CSRs: PKCS#10 v1.7 aka RFC 2986
* - attributes: PKCS#9 v2.0 aka RFC 2985
*/
#if defined(MBEDTLS_X509_CRT_WRITE_C)
/**
* \brief Initialize a CRT writing context
*
* \param ctx CRT context to initialize
*/
void mbedtls_x509write_crt_init( mbedtls_x509write_cert *ctx )
{
mbedtls_platform_zeroize( ctx, sizeof( mbedtls_x509write_cert ) );
mbedtls_mpi_init( &ctx->serial );
ctx->version = MBEDTLS_X509_CRT_VERSION_3;
}
/**
* \brief Free the contents of a CRT write context
*
* \param ctx CRT context to free
*/
void mbedtls_x509write_crt_free( mbedtls_x509write_cert *ctx )
{
mbedtls_mpi_free( &ctx->serial );
mbedtls_asn1_free_named_data_list( &ctx->subject );
mbedtls_asn1_free_named_data_list( &ctx->issuer );
mbedtls_asn1_free_named_data_list( &ctx->extensions );
mbedtls_platform_zeroize( ctx, sizeof( mbedtls_x509write_cert ) );
}
/**
* \brief Set the verion for a Certificate
* Default: MBEDTLS_X509_CRT_VERSION_3
*
* \param ctx CRT context to use
* \param version version to set (MBEDTLS_X509_CRT_VERSION_1, MBEDTLS_X509_CRT_VERSION_2 or
* MBEDTLS_X509_CRT_VERSION_3)
*/
void mbedtls_x509write_crt_set_version( mbedtls_x509write_cert *ctx,
int version )
{
ctx->version = version;
}
/**
* \brief Set the MD algorithm to use for the signature
* (e.g. MBEDTLS_MD_SHA1)
*
* \param ctx CRT context to use
* \param md_alg MD algorithm to use
*/
void mbedtls_x509write_crt_set_md_alg( mbedtls_x509write_cert *ctx,
mbedtls_md_type_t md_alg )
{
ctx->md_alg = md_alg;
}
/**
* \brief Set the subject public key for the certificate
*
* \param ctx CRT context to use
* \param key public key to include
*/
void mbedtls_x509write_crt_set_subject_key( mbedtls_x509write_cert *ctx,
mbedtls_pk_context *key )
{
ctx->subject_key = key;
}
/**
* \brief Set the issuer key used for signing the certificate
*
* \param ctx CRT context to use
* \param key private key to sign with
*/
void mbedtls_x509write_crt_set_issuer_key( mbedtls_x509write_cert *ctx,
mbedtls_pk_context *key )
{
ctx->issuer_key = key;
}
/**
* \brief Set the subject name for a Certificate
* Subject names should contain a comma-separated list
* of OID types and values:
* e.g. "C=UK,O=ARM,CN=mbed TLS Server 1"
*
* \param ctx CRT context to use
* \param subject_name subject name to set
*
* \return 0 if subject name was parsed successfully, or
* a specific error code
*/
int mbedtls_x509write_crt_set_subject_name( mbedtls_x509write_cert *ctx,
const char *subject_name )
{
return mbedtls_x509_string_to_names( &ctx->subject, subject_name );
}
/**
* \brief Set the issuer name for a Certificate
* Issuer names should contain a comma-separated list
* of OID types and values:
* e.g. "C=UK,O=ARM,CN=mbed TLS CA"
*
* \param ctx CRT context to use
* \param issuer_name issuer name to set
*
* \return 0 if issuer name was parsed successfully, or
* a specific error code
*/
int mbedtls_x509write_crt_set_issuer_name( mbedtls_x509write_cert *ctx,
const char *issuer_name )
{
return mbedtls_x509_string_to_names( &ctx->issuer, issuer_name );
}
/**
* \brief Set the serial number for a Certificate.
*
* \param ctx CRT context to use
* \param serial serial number to set
*
* \return 0 if successful
*/
int mbedtls_x509write_crt_set_serial( mbedtls_x509write_cert *ctx,
const mbedtls_mpi *serial )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
if( ( ret = mbedtls_mpi_copy( &ctx->serial, serial ) ) != 0 )
return( ret );
return( 0 );
}
/**
* \brief Set the validity period for a Certificate
* Timestamps should be in string format for UTC timezone
* i.e. "YYYYMMDDhhmmss"
* e.g. "20131231235959" for December 31st 2013
* at 23:59:59
*
* \param ctx CRT context to use
* \param not_before not_before timestamp
* \param not_after not_after timestamp
*
* \return 0 if timestamp was parsed successfully, or
* a specific error code
*/
int mbedtls_x509write_crt_set_validity( mbedtls_x509write_cert *ctx,
const char *not_before,
const char *not_after )
{
if( strlen( not_before ) != MBEDTLS_X509_RFC5280_UTC_TIME_LEN - 1 ||
strlen( not_after ) != MBEDTLS_X509_RFC5280_UTC_TIME_LEN - 1 )
{
return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
}
strncpy( ctx->not_before, not_before, MBEDTLS_X509_RFC5280_UTC_TIME_LEN );
strncpy( ctx->not_after , not_after , MBEDTLS_X509_RFC5280_UTC_TIME_LEN );
ctx->not_before[MBEDTLS_X509_RFC5280_UTC_TIME_LEN - 1] = 'Z';
ctx->not_after[MBEDTLS_X509_RFC5280_UTC_TIME_LEN - 1] = 'Z';
return( 0 );
}
/**
* \brief Generic function to add to or replace an extension in the
* CRT
*
* \param ctx CRT context to use
* \param oid OID of the extension
* \param oid_len length of the OID
* \param critical if the extension is critical (per the RFC's definition)
* \param val value of the extension OCTET STRING
* \param val_len length of the value data
*
* \return 0 if successful, or a MBEDTLS_ERR_X509_ALLOC_FAILED
*/
int mbedtls_x509write_crt_set_extension( mbedtls_x509write_cert *ctx,
const char *oid, size_t oid_len,
int critical, const unsigned char *val,
size_t val_len )
{
return( mbedtls_x509_set_extension( &ctx->extensions, oid, oid_len,
critical, val, val_len ) );
}
/**
* \brief Set the basicConstraints extension for a CRT
*
* \param ctx CRT context to use
* \param is_ca is this a CA certificate
* \param max_pathlen maximum length of certificate chains below this
* certificate (only for CA certificates, -1 is
* inlimited)
*
* \return 0 if successful, or a MBEDTLS_ERR_X509_ALLOC_FAILED
*/
int mbedtls_x509write_crt_set_basic_constraints( mbedtls_x509write_cert *ctx,
int is_ca, int max_pathlen )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
unsigned char buf[9];
unsigned char *c = buf + sizeof(buf);
size_t len = 0;
mbedtls_platform_zeroize( buf, sizeof(buf) );
if( is_ca && max_pathlen > 127 )
return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
if( is_ca )
{
if( max_pathlen >= 0 )
{
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_int( &c, buf,
max_pathlen ) );
}
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_bool( &c, buf, 1 ) );
}
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &c, buf, len ) );
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( &c, buf,
MBEDTLS_ASN1_CONSTRUCTED |
MBEDTLS_ASN1_SEQUENCE ) );
return(
mbedtls_x509write_crt_set_extension( ctx, MBEDTLS_OID_BASIC_CONSTRAINTS,
MBEDTLS_OID_SIZE( MBEDTLS_OID_BASIC_CONSTRAINTS ),
is_ca, buf + sizeof(buf) - len, len ) );
}
#if defined(MBEDTLS_SHA1_C)
/**
* \brief Set the subjectKeyIdentifier extension for a CRT
* Requires that mbedtls_x509write_crt_set_subject_key() has been
* called before
*
* \param ctx CRT context to use
*
* \return 0 if successful, or a MBEDTLS_ERR_X509_ALLOC_FAILED
*/
int mbedtls_x509write_crt_set_subject_key_identifier( mbedtls_x509write_cert *ctx )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
unsigned char buf[MBEDTLS_MPI_MAX_SIZE * 2 + 20]; /* tag, length + 2xMPI */
unsigned char *c = buf + sizeof(buf);
size_t len = 0;
mbedtls_platform_zeroize( buf, sizeof(buf) );
MBEDTLS_ASN1_CHK_ADD( len,
mbedtls_pk_write_pubkey( &c, buf, ctx->subject_key ) );
ret = mbedtls_sha1_ret( buf + sizeof( buf ) - len, len,
buf + sizeof( buf ) - 20 );
if( ret != 0 )
return( ret );
c = buf + sizeof( buf ) - 20;
len = 20;
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &c, buf, len ) );
MBEDTLS_ASN1_CHK_ADD( len,
mbedtls_asn1_write_tag( &c, buf, MBEDTLS_ASN1_OCTET_STRING ) );
return mbedtls_x509write_crt_set_extension( ctx,
MBEDTLS_OID_SUBJECT_KEY_IDENTIFIER,
MBEDTLS_OID_SIZE( MBEDTLS_OID_SUBJECT_KEY_IDENTIFIER ),
0, buf + sizeof(buf) - len, len );
}
/**
* \brief Set the authorityKeyIdentifier extension for a CRT
* Requires that mbedtls_x509write_crt_set_issuer_key() has been
* called before
*
* \param ctx CRT context to use
*
* \return 0 if successful, or a MBEDTLS_ERR_X509_ALLOC_FAILED
*/
int mbedtls_x509write_crt_set_authority_key_identifier( mbedtls_x509write_cert *ctx )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
unsigned char buf[MBEDTLS_MPI_MAX_SIZE * 2 + 20]; /* tag, length + 2xMPI */
unsigned char *c = buf + sizeof( buf );
size_t len = 0;
mbedtls_platform_zeroize( buf, sizeof(buf) );
MBEDTLS_ASN1_CHK_ADD( len,
mbedtls_pk_write_pubkey( &c, buf, ctx->issuer_key ) );
ret = mbedtls_sha1_ret( buf + sizeof( buf ) - len, len,
buf + sizeof( buf ) - 20 );
if( ret != 0 )
return( ret );
c = buf + sizeof( buf ) - 20;
len = 20;
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &c, buf, len ) );
MBEDTLS_ASN1_CHK_ADD( len,
mbedtls_asn1_write_tag( &c, buf, MBEDTLS_ASN1_CONTEXT_SPECIFIC | 0 ) );
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &c, buf, len ) );
MBEDTLS_ASN1_CHK_ADD( len,
mbedtls_asn1_write_tag( &c, buf,
MBEDTLS_ASN1_CONSTRUCTED |
MBEDTLS_ASN1_SEQUENCE ) );
return mbedtls_x509write_crt_set_extension(
ctx, MBEDTLS_OID_AUTHORITY_KEY_IDENTIFIER,
MBEDTLS_OID_SIZE( MBEDTLS_OID_AUTHORITY_KEY_IDENTIFIER ),
0, buf + sizeof( buf ) - len, len );
}
#endif /* MBEDTLS_SHA1_C */
/**
* \brief Set the Key Usage Extension flags
* (e.g. MBEDTLS_X509_KU_DIGITAL_SIGNATURE | MBEDTLS_X509_KU_KEY_CERT_SIGN)
*
* \param ctx CRT context to use
* \param key_usage key usage flags to set
*
* \return 0 if successful, or MBEDTLS_ERR_X509_ALLOC_FAILED
*/
int mbedtls_x509write_crt_set_key_usage( mbedtls_x509write_cert *ctx,
unsigned int key_usage )
{
unsigned char buf[5], ku[2];
unsigned char *c;
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
const unsigned int allowed_bits = MBEDTLS_X509_KU_DIGITAL_SIGNATURE |
MBEDTLS_X509_KU_NON_REPUDIATION |
MBEDTLS_X509_KU_KEY_ENCIPHERMENT |
MBEDTLS_X509_KU_DATA_ENCIPHERMENT |
MBEDTLS_X509_KU_KEY_AGREEMENT |
MBEDTLS_X509_KU_KEY_CERT_SIGN |
MBEDTLS_X509_KU_CRL_SIGN |
MBEDTLS_X509_KU_ENCIPHER_ONLY |
MBEDTLS_X509_KU_DECIPHER_ONLY;
/* Check that nothing other than the allowed flags is set */
if( ( key_usage & ~allowed_bits ) != 0 )
return( MBEDTLS_ERR_X509_FEATURE_UNAVAILABLE );
c = buf + 5;
ku[0] = (unsigned char)( key_usage );
ku[1] = (unsigned char)( key_usage >> 8 );
ret = mbedtls_asn1_write_named_bitstring( &c, buf, ku, 9 );
if( ret < 0 )
return( ret );
else if( ret < 3 || ret > 5 )
return( MBEDTLS_ERR_X509_INVALID_FORMAT );
ret = mbedtls_x509write_crt_set_extension( ctx, MBEDTLS_OID_KEY_USAGE,
MBEDTLS_OID_SIZE( MBEDTLS_OID_KEY_USAGE ),
1, c, (size_t)ret );
if( ret != 0 )
return( ret );
return( 0 );
}
/**
* \brief Set the Netscape Cert Type flags
* (e.g. MBEDTLS_X509_NS_CERT_TYPE_SSL_CLIENT | MBEDTLS_X509_NS_CERT_TYPE_EMAIL)
*
* \param ctx CRT context to use
* \param ns_cert_type Netscape Cert Type flags to set
*
* \return 0 if successful, or MBEDTLS_ERR_X509_ALLOC_FAILED
*/
int mbedtls_x509write_crt_set_ns_cert_type( mbedtls_x509write_cert *ctx,
unsigned char ns_cert_type )
{
unsigned char buf[4];
unsigned char *c;
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
c = buf + 4;
ret = mbedtls_asn1_write_named_bitstring( &c, buf, &ns_cert_type, 8 );
if( ret < 3 || ret > 4 )
return( ret );
ret = mbedtls_x509write_crt_set_extension( ctx, MBEDTLS_OID_NS_CERT_TYPE,
MBEDTLS_OID_SIZE( MBEDTLS_OID_NS_CERT_TYPE ),
0, c, (size_t)ret );
if( ret != 0 )
return( ret );
return( 0 );
}
/**
* Writes Extended Key Usage section to certificate.
*
* @see mbedtls_x509write_crt_set_ns_cert_type()
* @see RFC5280 §4.2.1.12
*/
int mbedtls_x509write_crt_set_ext_key_usage(mbedtls_x509write_cert *ctx,
int ns_cert_type) {
int ret;
size_t len;
unsigned char buf[256];
unsigned char *c;
if (!ns_cert_type) return 0;
if (ns_cert_type & ~(MBEDTLS_X509_NS_CERT_TYPE_SSL_CLIENT |
MBEDTLS_X509_NS_CERT_TYPE_SSL_SERVER |
MBEDTLS_X509_NS_CERT_TYPE_EMAIL)) {
return MBEDTLS_ERR_X509_BAD_INPUT_DATA;
}
len = 0;
c = buf + sizeof(buf);
mbedtls_platform_zeroize(buf, sizeof(buf));
if (ns_cert_type & MBEDTLS_X509_NS_CERT_TYPE_SSL_CLIENT) {
MBEDTLS_ASN1_CHK_ADD(
len, mbedtls_asn1_write_oid(&c, buf, MBEDTLS_OID_CLIENT_AUTH,
MBEDTLS_OID_SIZE(MBEDTLS_OID_CLIENT_AUTH)));
}
if (ns_cert_type & MBEDTLS_X509_NS_CERT_TYPE_SSL_SERVER) {
MBEDTLS_ASN1_CHK_ADD(
len, mbedtls_asn1_write_oid(&c, buf, MBEDTLS_OID_SERVER_AUTH,
MBEDTLS_OID_SIZE(MBEDTLS_OID_SERVER_AUTH)));
}
if (ns_cert_type & MBEDTLS_X509_NS_CERT_TYPE_EMAIL) {
MBEDTLS_ASN1_CHK_ADD(
len,
mbedtls_asn1_write_oid(&c, buf, MBEDTLS_OID_EMAIL_PROTECTION,
MBEDTLS_OID_SIZE(MBEDTLS_OID_EMAIL_PROTECTION)));
}
MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_len(&c, buf, len));
MBEDTLS_ASN1_CHK_ADD(
len, mbedtls_asn1_write_tag(
&c, buf, MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE));
return mbedtls_x509write_crt_set_extension(
ctx, MBEDTLS_OID_EXTENDED_KEY_USAGE,
MBEDTLS_OID_SIZE(MBEDTLS_OID_EXTENDED_KEY_USAGE), false,
buf + sizeof(buf) - len, len);
}
static int x509_write_time( unsigned char **p, unsigned char *start,
const char *t, size_t size )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t len = 0;
/*
* write MBEDTLS_ASN1_UTC_TIME if year < 2050 (2 bytes shorter)
*/
if( t[0] == '2' && t[1] == '0' && t[2] < '5' )
{
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_raw_buffer( p, start,
(const unsigned char *) t + 2,
size - 2 ) );
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) );
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start,
MBEDTLS_ASN1_UTC_TIME ) );
}
else
{
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_raw_buffer( p, start,
(const unsigned char *) t,
size ) );
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) );
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start,
MBEDTLS_ASN1_GENERALIZED_TIME ) );
}
return( (int) len );
}
/**
* \brief Write a built up certificate to a X509 DER structure
* Note: data is written at the end of the buffer! Use the
* return value to determine where you should start
* using the buffer
*
* \param ctx certificate to write away
* \param buf buffer to write to
* \param size size of the buffer
* \param f_rng RNG function (for signature, see note)
* \param p_rng RNG parameter
*
* \return length of data written if successful, or a specific
* error code
*
* \note f_rng may be NULL if RSA is used for signature and the
* signature is made offline (otherwise f_rng is desirable
* for countermeasures against timing attacks).
* ECDSA signatures always require a non-NULL f_rng.
*/
int mbedtls_x509write_crt_der( mbedtls_x509write_cert *ctx,
unsigned char *buf, size_t size,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
const char *sig_oid;
size_t sig_oid_len = 0;
unsigned char *c, *c2;
unsigned char hash[64];
unsigned char sig[MBEDTLS_PK_SIGNATURE_MAX_SIZE];
size_t sub_len = 0, pub_len = 0, sig_and_oid_len = 0, sig_len;
size_t len = 0;
mbedtls_pk_type_t pk_alg;
/*
* Prepare data to be signed at the end of the target buffer
*/
c = buf + size;
/* Signature algorithm needed in TBS, and later for actual signature */
/* There's no direct way of extracting a signature algorithm
* (represented as an element of mbedtls_pk_type_t) from a PK instance. */
if( mbedtls_pk_can_do( ctx->issuer_key, MBEDTLS_PK_RSA ) )
pk_alg = MBEDTLS_PK_RSA;
else if( mbedtls_pk_can_do( ctx->issuer_key, MBEDTLS_PK_ECDSA ) )
pk_alg = MBEDTLS_PK_ECDSA;
else
return( MBEDTLS_ERR_X509_INVALID_ALG );
if( ( ret = mbedtls_oid_get_oid_by_sig_alg( pk_alg, ctx->md_alg,
&sig_oid, &sig_oid_len ) ) != 0 )
{
return( ret );
}
/*
* Extensions ::= SEQUENCE SIZE (1..MAX) OF Extension
*/
/* Only for v3 */
if( ctx->version == MBEDTLS_X509_CRT_VERSION_3 )
{
MBEDTLS_ASN1_CHK_ADD( len,
mbedtls_x509_write_extensions( &c,
buf, ctx->extensions ) );
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &c, buf, len ) );
MBEDTLS_ASN1_CHK_ADD( len,
mbedtls_asn1_write_tag( &c, buf,
MBEDTLS_ASN1_CONSTRUCTED |
MBEDTLS_ASN1_SEQUENCE ) );
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &c, buf, len ) );
MBEDTLS_ASN1_CHK_ADD( len,
mbedtls_asn1_write_tag( &c, buf,
MBEDTLS_ASN1_CONTEXT_SPECIFIC |
MBEDTLS_ASN1_CONSTRUCTED | 3 ) );
}
/*
* SubjectPublicKeyInfo
*/
MBEDTLS_ASN1_CHK_ADD( pub_len,
mbedtls_pk_write_pubkey_der( ctx->subject_key,
buf, c - buf ) );
c -= pub_len;
len += pub_len;
/*
* Subject ::= Name
*/
MBEDTLS_ASN1_CHK_ADD( len,
mbedtls_x509_write_names( &c, buf,
ctx->subject ) );
/*
* Validity ::= SEQUENCE {
* notBefore Time,
* notAfter Time }
*/
sub_len = 0;
MBEDTLS_ASN1_CHK_ADD( sub_len,
x509_write_time( &c, buf, ctx->not_after,
MBEDTLS_X509_RFC5280_UTC_TIME_LEN ) );
MBEDTLS_ASN1_CHK_ADD( sub_len,
x509_write_time( &c, buf, ctx->not_before,
MBEDTLS_X509_RFC5280_UTC_TIME_LEN ) );
len += sub_len;
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &c, buf, sub_len ) );
MBEDTLS_ASN1_CHK_ADD( len,
mbedtls_asn1_write_tag( &c, buf,
MBEDTLS_ASN1_CONSTRUCTED |
MBEDTLS_ASN1_SEQUENCE ) );
/*
* Issuer ::= Name
*/
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_x509_write_names( &c, buf,
ctx->issuer ) );
/*
* Signature ::= AlgorithmIdentifier
*/
MBEDTLS_ASN1_CHK_ADD( len,
mbedtls_asn1_write_algorithm_identifier( &c, buf,
sig_oid, strlen( sig_oid ), 0 ) );
/*
* Serial ::= INTEGER
*/
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_mpi( &c, buf,
&ctx->serial ) );
/*
* Version ::= INTEGER { v1(0), v2(1), v3(2) }
*/
/* Can be omitted for v1 */
if( ctx->version != MBEDTLS_X509_CRT_VERSION_1 )
{
sub_len = 0;
MBEDTLS_ASN1_CHK_ADD( sub_len,
mbedtls_asn1_write_int( &c, buf, ctx->version ) );
len += sub_len;
MBEDTLS_ASN1_CHK_ADD( len,
mbedtls_asn1_write_len( &c, buf, sub_len ) );
MBEDTLS_ASN1_CHK_ADD( len,
mbedtls_asn1_write_tag( &c, buf,
MBEDTLS_ASN1_CONTEXT_SPECIFIC |
MBEDTLS_ASN1_CONSTRUCTED | 0 ) );
}
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &c, buf, len ) );
MBEDTLS_ASN1_CHK_ADD( len,
mbedtls_asn1_write_tag( &c, buf, MBEDTLS_ASN1_CONSTRUCTED |
MBEDTLS_ASN1_SEQUENCE ) );
/*
* Make signature
*/
/* Compute hash of CRT. */
if( ( ret = mbedtls_md( mbedtls_md_info_from_type( ctx->md_alg ), c,
len, hash ) ) != 0 )
{
return( ret );
}
if( ( ret = mbedtls_pk_sign( ctx->issuer_key, ctx->md_alg,
hash, 0, sig, &sig_len,
f_rng, p_rng ) ) != 0 )
{
return( ret );
}
/* Move CRT to the front of the buffer to have space
* for the signature. */
memmove( buf, c, len );
c = buf + len;
/* Add signature at the end of the buffer,
* making sure that it doesn't underflow
* into the CRT buffer. */
c2 = buf + size;
MBEDTLS_ASN1_CHK_ADD( sig_and_oid_len, mbedtls_x509_write_sig( &c2, c,
sig_oid, sig_oid_len, sig, sig_len ) );
/*
* Memory layout after this step:
*
* buf c=buf+len c2 buf+size
* [CRT0,...,CRTn, UNUSED, ..., UNUSED, SIG0, ..., SIGm]
*/
/* Move raw CRT to just before the signature. */
c = c2 - len;
memmove( c, buf, len );
len += sig_and_oid_len;
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &c, buf, len ) );
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( &c, buf,
MBEDTLS_ASN1_CONSTRUCTED |
MBEDTLS_ASN1_SEQUENCE ) );
return( (int) len );
}
#define PEM_BEGIN_CRT "-----BEGIN CERTIFICATE-----\n"
#define PEM_END_CRT "-----END CERTIFICATE-----\n"
/**
* \brief Write a built up certificate to a X509 PEM string
*
* \param ctx certificate to write away
* \param buf buffer to write to
* \param size size of the buffer
* \param f_rng RNG function (for signature, see note)
* \param p_rng RNG parameter
*
* \return 0 if successful, or a specific error code
*
* \note f_rng may be NULL if RSA is used for signature and the
* signature is made offline (otherwise f_rng is desirable
* for countermeasures against timing attacks).
* ECDSA signatures always require a non-NULL f_rng.
*/
int mbedtls_x509write_crt_pem( mbedtls_x509write_cert *crt,
unsigned char *buf, size_t size,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t olen;
if( ( ret = mbedtls_x509write_crt_der( crt, buf, size,
f_rng, p_rng ) ) < 0 )
{
return( ret );
}
if( ( ret = mbedtls_pem_write_buffer( PEM_BEGIN_CRT, PEM_END_CRT,
buf + size - ret, ret,
buf, size, &olen ) ) != 0 )
{
return( ret );
}
return( 0 );
}
#endif /* MBEDTLS_X509_CRT_WRITE_C */
| 29,079 | 730 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/des.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:4;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright The Mbed TLS Contributors â
â â
â Licensed under the Apache License, Version 2.0 (the "License"); â
â you may not use this file except in compliance with the License. â
â You may obtain a copy of the License at â
â â
â http://www.apache.org/licenses/LICENSE-2.0 â
â â
â Unless required by applicable law or agreed to in writing, software â
â distributed under the License is distributed on an "AS IS" BASIS, â
â WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. â
â See the License for the specific language governing permissions and â
â limitations under the License. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "third_party/mbedtls/des.h"
#include "libc/mem/mem.h"
#include "libc/stdio/stdio.h"
#include "libc/str/str.h"
#include "third_party/mbedtls/common.h"
#include "third_party/mbedtls/endian.h"
#include "third_party/mbedtls/platform.h"
asm(".ident\t\"\\n\\n\
Mbed TLS (Apache 2.0)\\n\
Copyright ARM Limited\\n\
Copyright Mbed TLS Contributors\"");
asm(".include \"libc/disclaimer.inc\"");
/* clang-format off */
/**
* @fileoverview FIPS-46-3 compliant Triple-DES implementation
*
* DES, on which TDES is based, was originally designed by Horst Feistel
* at IBM in 1974, and was adopted as a standard by NIST (formerly NBS).
* NIST calls this DEA. The true name of this algorithm is Lucifer.
*
* http://csrc.nist.gov/publications/fips/fips46-3/fips46-3.pdf
*/
/*
* Expanded DES S-boxes
*/
static const uint32_t SB1[64] =
{
0x01010400, 0x00000000, 0x00010000, 0x01010404,
0x01010004, 0x00010404, 0x00000004, 0x00010000,
0x00000400, 0x01010400, 0x01010404, 0x00000400,
0x01000404, 0x01010004, 0x01000000, 0x00000004,
0x00000404, 0x01000400, 0x01000400, 0x00010400,
0x00010400, 0x01010000, 0x01010000, 0x01000404,
0x00010004, 0x01000004, 0x01000004, 0x00010004,
0x00000000, 0x00000404, 0x00010404, 0x01000000,
0x00010000, 0x01010404, 0x00000004, 0x01010000,
0x01010400, 0x01000000, 0x01000000, 0x00000400,
0x01010004, 0x00010000, 0x00010400, 0x01000004,
0x00000400, 0x00000004, 0x01000404, 0x00010404,
0x01010404, 0x00010004, 0x01010000, 0x01000404,
0x01000004, 0x00000404, 0x00010404, 0x01010400,
0x00000404, 0x01000400, 0x01000400, 0x00000000,
0x00010004, 0x00010400, 0x00000000, 0x01010004
};
static const uint32_t SB2[64] =
{
0x80108020, 0x80008000, 0x00008000, 0x00108020,
0x00100000, 0x00000020, 0x80100020, 0x80008020,
0x80000020, 0x80108020, 0x80108000, 0x80000000,
0x80008000, 0x00100000, 0x00000020, 0x80100020,
0x00108000, 0x00100020, 0x80008020, 0x00000000,
0x80000000, 0x00008000, 0x00108020, 0x80100000,
0x00100020, 0x80000020, 0x00000000, 0x00108000,
0x00008020, 0x80108000, 0x80100000, 0x00008020,
0x00000000, 0x00108020, 0x80100020, 0x00100000,
0x80008020, 0x80100000, 0x80108000, 0x00008000,
0x80100000, 0x80008000, 0x00000020, 0x80108020,
0x00108020, 0x00000020, 0x00008000, 0x80000000,
0x00008020, 0x80108000, 0x00100000, 0x80000020,
0x00100020, 0x80008020, 0x80000020, 0x00100020,
0x00108000, 0x00000000, 0x80008000, 0x00008020,
0x80000000, 0x80100020, 0x80108020, 0x00108000
};
static const uint32_t SB3[64] =
{
0x00000208, 0x08020200, 0x00000000, 0x08020008,
0x08000200, 0x00000000, 0x00020208, 0x08000200,
0x00020008, 0x08000008, 0x08000008, 0x00020000,
0x08020208, 0x00020008, 0x08020000, 0x00000208,
0x08000000, 0x00000008, 0x08020200, 0x00000200,
0x00020200, 0x08020000, 0x08020008, 0x00020208,
0x08000208, 0x00020200, 0x00020000, 0x08000208,
0x00000008, 0x08020208, 0x00000200, 0x08000000,
0x08020200, 0x08000000, 0x00020008, 0x00000208,
0x00020000, 0x08020200, 0x08000200, 0x00000000,
0x00000200, 0x00020008, 0x08020208, 0x08000200,
0x08000008, 0x00000200, 0x00000000, 0x08020008,
0x08000208, 0x00020000, 0x08000000, 0x08020208,
0x00000008, 0x00020208, 0x00020200, 0x08000008,
0x08020000, 0x08000208, 0x00000208, 0x08020000,
0x00020208, 0x00000008, 0x08020008, 0x00020200
};
static const uint32_t SB4[64] =
{
0x00802001, 0x00002081, 0x00002081, 0x00000080,
0x00802080, 0x00800081, 0x00800001, 0x00002001,
0x00000000, 0x00802000, 0x00802000, 0x00802081,
0x00000081, 0x00000000, 0x00800080, 0x00800001,
0x00000001, 0x00002000, 0x00800000, 0x00802001,
0x00000080, 0x00800000, 0x00002001, 0x00002080,
0x00800081, 0x00000001, 0x00002080, 0x00800080,
0x00002000, 0x00802080, 0x00802081, 0x00000081,
0x00800080, 0x00800001, 0x00802000, 0x00802081,
0x00000081, 0x00000000, 0x00000000, 0x00802000,
0x00002080, 0x00800080, 0x00800081, 0x00000001,
0x00802001, 0x00002081, 0x00002081, 0x00000080,
0x00802081, 0x00000081, 0x00000001, 0x00002000,
0x00800001, 0x00002001, 0x00802080, 0x00800081,
0x00002001, 0x00002080, 0x00800000, 0x00802001,
0x00000080, 0x00800000, 0x00002000, 0x00802080
};
static const uint32_t SB5[64] =
{
0x00000100, 0x02080100, 0x02080000, 0x42000100,
0x00080000, 0x00000100, 0x40000000, 0x02080000,
0x40080100, 0x00080000, 0x02000100, 0x40080100,
0x42000100, 0x42080000, 0x00080100, 0x40000000,
0x02000000, 0x40080000, 0x40080000, 0x00000000,
0x40000100, 0x42080100, 0x42080100, 0x02000100,
0x42080000, 0x40000100, 0x00000000, 0x42000000,
0x02080100, 0x02000000, 0x42000000, 0x00080100,
0x00080000, 0x42000100, 0x00000100, 0x02000000,
0x40000000, 0x02080000, 0x42000100, 0x40080100,
0x02000100, 0x40000000, 0x42080000, 0x02080100,
0x40080100, 0x00000100, 0x02000000, 0x42080000,
0x42080100, 0x00080100, 0x42000000, 0x42080100,
0x02080000, 0x00000000, 0x40080000, 0x42000000,
0x00080100, 0x02000100, 0x40000100, 0x00080000,
0x00000000, 0x40080000, 0x02080100, 0x40000100
};
static const uint32_t SB6[64] =
{
0x20000010, 0x20400000, 0x00004000, 0x20404010,
0x20400000, 0x00000010, 0x20404010, 0x00400000,
0x20004000, 0x00404010, 0x00400000, 0x20000010,
0x00400010, 0x20004000, 0x20000000, 0x00004010,
0x00000000, 0x00400010, 0x20004010, 0x00004000,
0x00404000, 0x20004010, 0x00000010, 0x20400010,
0x20400010, 0x00000000, 0x00404010, 0x20404000,
0x00004010, 0x00404000, 0x20404000, 0x20000000,
0x20004000, 0x00000010, 0x20400010, 0x00404000,
0x20404010, 0x00400000, 0x00004010, 0x20000010,
0x00400000, 0x20004000, 0x20000000, 0x00004010,
0x20000010, 0x20404010, 0x00404000, 0x20400000,
0x00404010, 0x20404000, 0x00000000, 0x20400010,
0x00000010, 0x00004000, 0x20400000, 0x00404010,
0x00004000, 0x00400010, 0x20004010, 0x00000000,
0x20404000, 0x20000000, 0x00400010, 0x20004010
};
static const uint32_t SB7[64] =
{
0x00200000, 0x04200002, 0x04000802, 0x00000000,
0x00000800, 0x04000802, 0x00200802, 0x04200800,
0x04200802, 0x00200000, 0x00000000, 0x04000002,
0x00000002, 0x04000000, 0x04200002, 0x00000802,
0x04000800, 0x00200802, 0x00200002, 0x04000800,
0x04000002, 0x04200000, 0x04200800, 0x00200002,
0x04200000, 0x00000800, 0x00000802, 0x04200802,
0x00200800, 0x00000002, 0x04000000, 0x00200800,
0x04000000, 0x00200800, 0x00200000, 0x04000802,
0x04000802, 0x04200002, 0x04200002, 0x00000002,
0x00200002, 0x04000000, 0x04000800, 0x00200000,
0x04200800, 0x00000802, 0x00200802, 0x04200800,
0x00000802, 0x04000002, 0x04200802, 0x04200000,
0x00200800, 0x00000000, 0x00000002, 0x04200802,
0x00000000, 0x00200802, 0x04200000, 0x00000800,
0x04000002, 0x04000800, 0x00000800, 0x00200002
};
static const uint32_t SB8[64] =
{
0x10001040, 0x00001000, 0x00040000, 0x10041040,
0x10000000, 0x10001040, 0x00000040, 0x10000000,
0x00040040, 0x10040000, 0x10041040, 0x00041000,
0x10041000, 0x00041040, 0x00001000, 0x00000040,
0x10040000, 0x10000040, 0x10001000, 0x00001040,
0x00041000, 0x00040040, 0x10040040, 0x10041000,
0x00001040, 0x00000000, 0x00000000, 0x10040040,
0x10000040, 0x10001000, 0x00041040, 0x00040000,
0x00041040, 0x00040000, 0x10041000, 0x00001000,
0x00000040, 0x10040040, 0x00001000, 0x00041040,
0x10001000, 0x00000040, 0x10000040, 0x10040000,
0x10040040, 0x10000000, 0x00040000, 0x10001040,
0x00000000, 0x10041040, 0x00040040, 0x10000040,
0x10040000, 0x10001000, 0x10001040, 0x00000000,
0x10041040, 0x00041000, 0x00041000, 0x00001040,
0x00001040, 0x00040040, 0x10000000, 0x10041000
};
/*
* PC1: left and right halves bit-swap
*/
static const uint32_t LHs[16] =
{
0x00000000, 0x00000001, 0x00000100, 0x00000101,
0x00010000, 0x00010001, 0x00010100, 0x00010101,
0x01000000, 0x01000001, 0x01000100, 0x01000101,
0x01010000, 0x01010001, 0x01010100, 0x01010101
};
static const uint32_t RHs[16] =
{
0x00000000, 0x01000000, 0x00010000, 0x01010000,
0x00000100, 0x01000100, 0x00010100, 0x01010100,
0x00000001, 0x01000001, 0x00010001, 0x01010001,
0x00000101, 0x01000101, 0x00010101, 0x01010101,
};
/*
* Initial Permutation macro
*/
#define DES_IP(X,Y) \
do \
{ \
T = (((X) >> 4) ^ (Y)) & 0x0F0F0F0F; (Y) ^= T; (X) ^= (T << 4); \
T = (((X) >> 16) ^ (Y)) & 0x0000FFFF; (Y) ^= T; (X) ^= (T << 16); \
T = (((Y) >> 2) ^ (X)) & 0x33333333; (X) ^= T; (Y) ^= (T << 2); \
T = (((Y) >> 8) ^ (X)) & 0x00FF00FF; (X) ^= T; (Y) ^= (T << 8); \
(Y) = (((Y) << 1) | ((Y) >> 31)) & 0xFFFFFFFF; \
T = ((X) ^ (Y)) & 0xAAAAAAAA; (Y) ^= T; (X) ^= T; \
(X) = (((X) << 1) | ((X) >> 31)) & 0xFFFFFFFF; \
} while( 0 )
/*
* Final Permutation macro
*/
#define DES_FP(X,Y) \
do \
{ \
(X) = (((X) << 31) | ((X) >> 1)) & 0xFFFFFFFF; \
T = ((X) ^ (Y)) & 0xAAAAAAAA; (X) ^= T; (Y) ^= T; \
(Y) = (((Y) << 31) | ((Y) >> 1)) & 0xFFFFFFFF; \
T = (((Y) >> 8) ^ (X)) & 0x00FF00FF; (X) ^= T; (Y) ^= (T << 8); \
T = (((Y) >> 2) ^ (X)) & 0x33333333; (X) ^= T; (Y) ^= (T << 2); \
T = (((X) >> 16) ^ (Y)) & 0x0000FFFF; (Y) ^= T; (X) ^= (T << 16); \
T = (((X) >> 4) ^ (Y)) & 0x0F0F0F0F; (Y) ^= T; (X) ^= (T << 4); \
} while( 0 )
/*
* DES round macro
*/
#define DES_ROUND(X,Y) \
do \
{ \
T = *SK++ ^ (X); \
(Y) ^= SB8[ (T ) & 0x3F ] ^ \
SB6[ (T >> 8) & 0x3F ] ^ \
SB4[ (T >> 16) & 0x3F ] ^ \
SB2[ (T >> 24) & 0x3F ]; \
\
T = *SK++ ^ (((X) << 28) | ((X) >> 4)); \
(Y) ^= SB7[ (T ) & 0x3F ] ^ \
SB5[ (T >> 8) & 0x3F ] ^ \
SB3[ (T >> 16) & 0x3F ] ^ \
SB1[ (T >> 24) & 0x3F ]; \
} while( 0 )
#define SWAP(a,b) \
do \
{ \
uint32_t t = (a); (a) = (b); (b) = t; t = 0; \
} while( 0 )
void mbedtls_des_init( mbedtls_des_context *ctx )
{
mbedtls_platform_zeroize( ctx, sizeof( mbedtls_des_context ) );
}
void mbedtls_des_free( mbedtls_des_context *ctx )
{
if( ctx == NULL )
return;
mbedtls_platform_zeroize( ctx, sizeof( mbedtls_des_context ) );
}
void mbedtls_des3_init( mbedtls_des3_context *ctx )
{
mbedtls_platform_zeroize( ctx, sizeof( mbedtls_des3_context ) );
}
void mbedtls_des3_free( mbedtls_des3_context *ctx )
{
if( ctx == NULL )
return;
mbedtls_platform_zeroize( ctx, sizeof( mbedtls_des3_context ) );
}
static const unsigned char odd_parity_table[128] = { 1, 2, 4, 7, 8,
11, 13, 14, 16, 19, 21, 22, 25, 26, 28, 31, 32, 35, 37, 38, 41, 42, 44,
47, 49, 50, 52, 55, 56, 59, 61, 62, 64, 67, 69, 70, 73, 74, 76, 79, 81,
82, 84, 87, 88, 91, 93, 94, 97, 98, 100, 103, 104, 107, 109, 110, 112,
115, 117, 118, 121, 122, 124, 127, 128, 131, 133, 134, 137, 138, 140,
143, 145, 146, 148, 151, 152, 155, 157, 158, 161, 162, 164, 167, 168,
171, 173, 174, 176, 179, 181, 182, 185, 186, 188, 191, 193, 194, 196,
199, 200, 203, 205, 206, 208, 211, 213, 214, 217, 218, 220, 223, 224,
227, 229, 230, 233, 234, 236, 239, 241, 242, 244, 247, 248, 251, 253,
254 };
void mbedtls_des_key_set_parity( unsigned char key[MBEDTLS_DES_KEY_SIZE] )
{
int i;
for( i = 0; i < MBEDTLS_DES_KEY_SIZE; i++ )
key[i] = odd_parity_table[key[i] / 2];
}
/*
* Check the given key's parity, returns 1 on failure, 0 on SUCCESS
*/
int mbedtls_des_key_check_key_parity( const unsigned char key[MBEDTLS_DES_KEY_SIZE] )
{
int i;
for( i = 0; i < MBEDTLS_DES_KEY_SIZE; i++ )
if( key[i] != odd_parity_table[key[i] / 2] )
return( 1 );
return( 0 );
}
/*
* Table of weak and semi-weak keys
*
* Source: http://en.wikipedia.org/wiki/Weak_key
*
* Weak:
* Alternating ones + zeros (0x0101010101010101)
* Alternating 'F' + 'E' (0xFEFEFEFEFEFEFEFE)
* '0xE0E0E0E0F1F1F1F1'
* '0x1F1F1F1F0E0E0E0E'
*
* Semi-weak:
* 0x011F011F010E010E and 0x1F011F010E010E01
* 0x01E001E001F101F1 and 0xE001E001F101F101
* 0x01FE01FE01FE01FE and 0xFE01FE01FE01FE01
* 0x1FE01FE00EF10EF1 and 0xE01FE01FF10EF10E
* 0x1FFE1FFE0EFE0EFE and 0xFE1FFE1FFE0EFE0E
* 0xE0FEE0FEF1FEF1FE and 0xFEE0FEE0FEF1FEF1
*
*/
#define WEAK_KEY_COUNT 16
static const unsigned char weak_key_table[WEAK_KEY_COUNT][MBEDTLS_DES_KEY_SIZE] =
{
{ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
{ 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE },
{ 0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E },
{ 0xE0, 0xE0, 0xE0, 0xE0, 0xF1, 0xF1, 0xF1, 0xF1 },
{ 0x01, 0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E },
{ 0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E, 0x01 },
{ 0x01, 0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1 },
{ 0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1, 0x01 },
{ 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE },
{ 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01 },
{ 0x1F, 0xE0, 0x1F, 0xE0, 0x0E, 0xF1, 0x0E, 0xF1 },
{ 0xE0, 0x1F, 0xE0, 0x1F, 0xF1, 0x0E, 0xF1, 0x0E },
{ 0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E, 0xFE },
{ 0xFE, 0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E },
{ 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE },
{ 0xFE, 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1 }
};
int mbedtls_des_key_check_weak( const unsigned char key[MBEDTLS_DES_KEY_SIZE] )
{
int i;
for( i = 0; i < WEAK_KEY_COUNT; i++ )
if( timingsafe_bcmp( weak_key_table[i], key, MBEDTLS_DES_KEY_SIZE) == 0 )
return( 1 );
return( 0 );
}
#if !defined(MBEDTLS_DES_SETKEY_ALT)
void mbedtls_des_setkey( uint32_t SK[32], const unsigned char key[MBEDTLS_DES_KEY_SIZE] )
{
int i;
uint32_t X, Y, T;
GET_UINT32_BE( X, key, 0 );
GET_UINT32_BE( Y, key, 4 );
/*
* Permuted Choice 1
*/
T = ((Y >> 4) ^ X) & 0x0F0F0F0F; X ^= T; Y ^= (T << 4);
T = ((Y ) ^ X) & 0x10101010; X ^= T; Y ^= (T );
X = (LHs[ (X ) & 0xF] << 3) | (LHs[ (X >> 8) & 0xF ] << 2)
| (LHs[ (X >> 16) & 0xF] << 1) | (LHs[ (X >> 24) & 0xF ] )
| (LHs[ (X >> 5) & 0xF] << 7) | (LHs[ (X >> 13) & 0xF ] << 6)
| (LHs[ (X >> 21) & 0xF] << 5) | (LHs[ (X >> 29) & 0xF ] << 4);
Y = (RHs[ (Y >> 1) & 0xF] << 3) | (RHs[ (Y >> 9) & 0xF ] << 2)
| (RHs[ (Y >> 17) & 0xF] << 1) | (RHs[ (Y >> 25) & 0xF ] )
| (RHs[ (Y >> 4) & 0xF] << 7) | (RHs[ (Y >> 12) & 0xF ] << 6)
| (RHs[ (Y >> 20) & 0xF] << 5) | (RHs[ (Y >> 28) & 0xF ] << 4);
X &= 0x0FFFFFFF;
Y &= 0x0FFFFFFF;
/*
* calculate subkeys
*/
for( i = 0; i < 16; i++ )
{
if( i < 2 || i == 8 || i == 15 )
{
X = ((X << 1) | (X >> 27)) & 0x0FFFFFFF;
Y = ((Y << 1) | (Y >> 27)) & 0x0FFFFFFF;
}
else
{
X = ((X << 2) | (X >> 26)) & 0x0FFFFFFF;
Y = ((Y << 2) | (Y >> 26)) & 0x0FFFFFFF;
}
*SK++ = ((X << 4) & 0x24000000) | ((X << 28) & 0x10000000)
| ((X << 14) & 0x08000000) | ((X << 18) & 0x02080000)
| ((X << 6) & 0x01000000) | ((X << 9) & 0x00200000)
| ((X >> 1) & 0x00100000) | ((X << 10) & 0x00040000)
| ((X << 2) & 0x00020000) | ((X >> 10) & 0x00010000)
| ((Y >> 13) & 0x00002000) | ((Y >> 4) & 0x00001000)
| ((Y << 6) & 0x00000800) | ((Y >> 1) & 0x00000400)
| ((Y >> 14) & 0x00000200) | ((Y ) & 0x00000100)
| ((Y >> 5) & 0x00000020) | ((Y >> 10) & 0x00000010)
| ((Y >> 3) & 0x00000008) | ((Y >> 18) & 0x00000004)
| ((Y >> 26) & 0x00000002) | ((Y >> 24) & 0x00000001);
*SK++ = ((X << 15) & 0x20000000) | ((X << 17) & 0x10000000)
| ((X << 10) & 0x08000000) | ((X << 22) & 0x04000000)
| ((X >> 2) & 0x02000000) | ((X << 1) & 0x01000000)
| ((X << 16) & 0x00200000) | ((X << 11) & 0x00100000)
| ((X << 3) & 0x00080000) | ((X >> 6) & 0x00040000)
| ((X << 15) & 0x00020000) | ((X >> 4) & 0x00010000)
| ((Y >> 2) & 0x00002000) | ((Y << 8) & 0x00001000)
| ((Y >> 14) & 0x00000808) | ((Y >> 9) & 0x00000400)
| ((Y ) & 0x00000200) | ((Y << 7) & 0x00000100)
| ((Y >> 7) & 0x00000020) | ((Y >> 3) & 0x00000011)
| ((Y << 2) & 0x00000004) | ((Y >> 21) & 0x00000002);
}
}
#endif /* !MBEDTLS_DES_SETKEY_ALT */
/*
* DES key schedule (56-bit, encryption)
*/
int mbedtls_des_setkey_enc( mbedtls_des_context *ctx, const unsigned char key[MBEDTLS_DES_KEY_SIZE] )
{
mbedtls_des_setkey( ctx->sk, key );
return( 0 );
}
/*
* DES key schedule (56-bit, decryption)
*/
int mbedtls_des_setkey_dec( mbedtls_des_context *ctx, const unsigned char key[MBEDTLS_DES_KEY_SIZE] )
{
int i;
mbedtls_des_setkey( ctx->sk, key );
for( i = 0; i < 16; i += 2 )
{
SWAP( ctx->sk[i ], ctx->sk[30 - i] );
SWAP( ctx->sk[i + 1], ctx->sk[31 - i] );
}
return( 0 );
}
static void des3_set2key( uint32_t esk[96],
uint32_t dsk[96],
const unsigned char key[MBEDTLS_DES_KEY_SIZE*2] )
{
int i;
mbedtls_des_setkey( esk, key );
mbedtls_des_setkey( dsk + 32, key + 8 );
for( i = 0; i < 32; i += 2 )
{
dsk[i ] = esk[30 - i];
dsk[i + 1] = esk[31 - i];
esk[i + 32] = dsk[62 - i];
esk[i + 33] = dsk[63 - i];
esk[i + 64] = esk[i ];
esk[i + 65] = esk[i + 1];
dsk[i + 64] = dsk[i ];
dsk[i + 65] = dsk[i + 1];
}
}
/*
* Triple-DES key schedule (112-bit, encryption)
*/
int mbedtls_des3_set2key_enc( mbedtls_des3_context *ctx,
const unsigned char key[MBEDTLS_DES_KEY_SIZE * 2] )
{
uint32_t sk[96];
des3_set2key( ctx->sk, sk, key );
mbedtls_platform_zeroize( sk, sizeof( sk ) );
return( 0 );
}
/*
* Triple-DES key schedule (112-bit, decryption)
*/
int mbedtls_des3_set2key_dec( mbedtls_des3_context *ctx,
const unsigned char key[MBEDTLS_DES_KEY_SIZE * 2] )
{
uint32_t sk[96];
des3_set2key( sk, ctx->sk, key );
mbedtls_platform_zeroize( sk, sizeof( sk ) );
return( 0 );
}
static void des3_set3key( uint32_t esk[96],
uint32_t dsk[96],
const unsigned char key[24] )
{
int i;
mbedtls_des_setkey( esk, key );
mbedtls_des_setkey( dsk + 32, key + 8 );
mbedtls_des_setkey( esk + 64, key + 16 );
for( i = 0; i < 32; i += 2 )
{
dsk[i ] = esk[94 - i];
dsk[i + 1] = esk[95 - i];
esk[i + 32] = dsk[62 - i];
esk[i + 33] = dsk[63 - i];
dsk[i + 64] = esk[30 - i];
dsk[i + 65] = esk[31 - i];
}
}
/*
* Triple-DES key schedule (168-bit, encryption)
*/
int mbedtls_des3_set3key_enc( mbedtls_des3_context *ctx,
const unsigned char key[MBEDTLS_DES_KEY_SIZE * 3] )
{
uint32_t sk[96];
des3_set3key( ctx->sk, sk, key );
mbedtls_platform_zeroize( sk, sizeof( sk ) );
return( 0 );
}
/*
* Triple-DES key schedule (168-bit, decryption)
*/
int mbedtls_des3_set3key_dec( mbedtls_des3_context *ctx,
const unsigned char key[MBEDTLS_DES_KEY_SIZE * 3] )
{
uint32_t sk[96];
des3_set3key( sk, ctx->sk, key );
mbedtls_platform_zeroize( sk, sizeof( sk ) );
return( 0 );
}
/*
* DES-ECB block encryption/decryption
*/
#if !defined(MBEDTLS_DES_CRYPT_ECB_ALT)
int mbedtls_des_crypt_ecb( mbedtls_des_context *ctx,
const unsigned char input[8],
unsigned char output[8] )
{
int i;
uint32_t X, Y, T, *SK;
SK = ctx->sk;
GET_UINT32_BE( X, input, 0 );
GET_UINT32_BE( Y, input, 4 );
DES_IP( X, Y );
for( i = 0; i < 8; i++ )
{
DES_ROUND( Y, X );
DES_ROUND( X, Y );
}
DES_FP( Y, X );
PUT_UINT32_BE( Y, output, 0 );
PUT_UINT32_BE( X, output, 4 );
return( 0 );
}
#endif /* !MBEDTLS_DES_CRYPT_ECB_ALT */
#if defined(MBEDTLS_CIPHER_MODE_CBC)
/*
* DES-CBC buffer encryption/decryption
*/
int mbedtls_des_crypt_cbc( mbedtls_des_context *ctx,
int mode,
size_t length,
unsigned char iv[8],
const unsigned char *input,
unsigned char *output )
{
int i;
unsigned char temp[8];
if( length % 8 )
return( MBEDTLS_ERR_DES_INVALID_INPUT_LENGTH );
if( mode == MBEDTLS_DES_ENCRYPT )
{
while( length > 0 )
{
for( i = 0; i < 8; i++ )
output[i] = (unsigned char)( input[i] ^ iv[i] );
mbedtls_des_crypt_ecb( ctx, output, output );
memcpy( iv, output, 8 );
input += 8;
output += 8;
length -= 8;
}
}
else /* MBEDTLS_DES_DECRYPT */
{
while( length > 0 )
{
memcpy( temp, input, 8 );
mbedtls_des_crypt_ecb( ctx, input, output );
for( i = 0; i < 8; i++ )
output[i] = (unsigned char)( output[i] ^ iv[i] );
memcpy( iv, temp, 8 );
input += 8;
output += 8;
length -= 8;
}
}
return( 0 );
}
#endif /* MBEDTLS_CIPHER_MODE_CBC */
/*
* 3DES-ECB block encryption/decryption
*/
#if !defined(MBEDTLS_DES3_CRYPT_ECB_ALT)
int mbedtls_des3_crypt_ecb( mbedtls_des3_context *ctx,
const unsigned char input[8],
unsigned char output[8] )
{
int i;
uint32_t X, Y, T, *SK;
SK = ctx->sk;
GET_UINT32_BE( X, input, 0 );
GET_UINT32_BE( Y, input, 4 );
DES_IP( X, Y );
for( i = 0; i < 8; i++ )
{
DES_ROUND( Y, X );
DES_ROUND( X, Y );
}
for( i = 0; i < 8; i++ )
{
DES_ROUND( X, Y );
DES_ROUND( Y, X );
}
for( i = 0; i < 8; i++ )
{
DES_ROUND( Y, X );
DES_ROUND( X, Y );
}
DES_FP( Y, X );
PUT_UINT32_BE( Y, output, 0 );
PUT_UINT32_BE( X, output, 4 );
return( 0 );
}
#endif /* !MBEDTLS_DES3_CRYPT_ECB_ALT */
#if defined(MBEDTLS_CIPHER_MODE_CBC)
/*
* 3DES-CBC buffer encryption/decryption
*/
int mbedtls_des3_crypt_cbc( mbedtls_des3_context *ctx,
int mode,
size_t length,
unsigned char iv[8],
const unsigned char *input,
unsigned char *output )
{
int i;
unsigned char temp[8];
if( length % 8 )
return( MBEDTLS_ERR_DES_INVALID_INPUT_LENGTH );
if( mode == MBEDTLS_DES_ENCRYPT )
{
while( length > 0 )
{
for( i = 0; i < 8; i++ )
output[i] = (unsigned char)( input[i] ^ iv[i] );
mbedtls_des3_crypt_ecb( ctx, output, output );
memcpy( iv, output, 8 );
input += 8;
output += 8;
length -= 8;
}
}
else /* MBEDTLS_DES_DECRYPT */
{
while( length > 0 )
{
memcpy( temp, input, 8 );
mbedtls_des3_crypt_ecb( ctx, input, output );
for( i = 0; i < 8; i++ )
output[i] = (unsigned char)( output[i] ^ iv[i] );
memcpy( iv, temp, 8 );
input += 8;
output += 8;
length -= 8;
}
}
return( 0 );
}
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#if defined(MBEDTLS_SELF_TEST)
/*
* DES and 3DES test vectors from:
*
* http://csrc.nist.gov/groups/STM/cavp/documents/des/tripledes-vectors.zip
*/
static const unsigned char des3_test_keys[24] =
{
0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01,
0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01, 0x23
};
static const unsigned char des3_test_buf[8] =
{
0x4E, 0x6F, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74
};
static const unsigned char des3_test_ecb_dec[3][8] =
{
{ 0x37, 0x2B, 0x98, 0xBF, 0x52, 0x65, 0xB0, 0x59 },
{ 0xC2, 0x10, 0x19, 0x9C, 0x38, 0x5A, 0x65, 0xA1 },
{ 0xA2, 0x70, 0x56, 0x68, 0x69, 0xE5, 0x15, 0x1D }
};
static const unsigned char des3_test_ecb_enc[3][8] =
{
{ 0x1C, 0xD5, 0x97, 0xEA, 0x84, 0x26, 0x73, 0xFB },
{ 0xB3, 0x92, 0x4D, 0xF3, 0xC5, 0xB5, 0x42, 0x93 },
{ 0xDA, 0x37, 0x64, 0x41, 0xBA, 0x6F, 0x62, 0x6F }
};
#if defined(MBEDTLS_CIPHER_MODE_CBC)
static const unsigned char des3_test_iv[8] =
{
0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF,
};
static const unsigned char des3_test_cbc_dec[3][8] =
{
{ 0x58, 0xD9, 0x48, 0xEF, 0x85, 0x14, 0x65, 0x9A },
{ 0x5F, 0xC8, 0x78, 0xD4, 0xD7, 0x92, 0xD9, 0x54 },
{ 0x25, 0xF9, 0x75, 0x85, 0xA8, 0x1E, 0x48, 0xBF }
};
static const unsigned char des3_test_cbc_enc[3][8] =
{
{ 0x91, 0x1C, 0x6D, 0xCF, 0x48, 0xA7, 0xC3, 0x4D },
{ 0x60, 0x1A, 0x76, 0x8F, 0xA1, 0xF9, 0x66, 0xF1 },
{ 0xA1, 0x50, 0x0F, 0x99, 0xB2, 0xCD, 0x64, 0x76 }
};
#endif /* MBEDTLS_CIPHER_MODE_CBC */
static int mbedtls_des_self_test_impl( int verbose,
mbedtls_des_context *ctx,
mbedtls_des3_context *ctx3 )
{
int i, j, u, v, ret = 0;
unsigned char buf[8];
#if defined(MBEDTLS_CIPHER_MODE_CBC)
unsigned char prv[8];
unsigned char iv[8];
#endif
mbedtls_des_init( ctx );
mbedtls_des3_init( ctx3 );
/*
* ECB mode
*/
for( i = 0; i < 6; i++ )
{
u = i >> 1;
v = i & 1;
if( verbose != 0 )
mbedtls_printf( " DES%c-ECB-%3d (%s): ",
( u == 0 ) ? ' ' : '3', 56 + u * 56,
( v == MBEDTLS_DES_DECRYPT ) ? "dec" : "enc" );
memcpy( buf, des3_test_buf, 8 );
switch( i )
{
case 0:
mbedtls_des_setkey_dec( ctx, des3_test_keys );
break;
case 1:
mbedtls_des_setkey_enc( ctx, des3_test_keys );
break;
case 2:
mbedtls_des3_set2key_dec( ctx3, des3_test_keys );
break;
case 3:
mbedtls_des3_set2key_enc( ctx3, des3_test_keys );
break;
case 4:
mbedtls_des3_set3key_dec( ctx3, des3_test_keys );
break;
case 5:
mbedtls_des3_set3key_enc( ctx3, des3_test_keys );
break;
default:
return( 1 );
}
for( j = 0; j < 100; j++ )
{
if( u == 0 )
mbedtls_des_crypt_ecb( ctx, buf, buf );
else
mbedtls_des3_crypt_ecb( ctx3, buf, buf );
}
if( ( v == MBEDTLS_DES_DECRYPT &&
timingsafe_bcmp( buf, des3_test_ecb_dec[u], 8 ) != 0 ) ||
( v != MBEDTLS_DES_DECRYPT &&
timingsafe_bcmp( buf, des3_test_ecb_enc[u], 8 ) != 0 ) )
{
if( verbose != 0 )
mbedtls_printf( "failed\n" );
ret = 1;
goto exit;
}
if( verbose != 0 )
mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
mbedtls_printf( "\n" );
#if defined(MBEDTLS_CIPHER_MODE_CBC)
/*
* CBC mode
*/
for( i = 0; i < 6; i++ )
{
u = i >> 1;
v = i & 1;
if( verbose != 0 )
mbedtls_printf( " DES%c-CBC-%3d (%s): ",
( u == 0 ) ? ' ' : '3', 56 + u * 56,
( v == MBEDTLS_DES_DECRYPT ) ? "dec" : "enc" );
memcpy( iv, des3_test_iv, 8 );
memcpy( prv, des3_test_iv, 8 );
memcpy( buf, des3_test_buf, 8 );
switch( i )
{
case 0:
mbedtls_des_setkey_dec( ctx, des3_test_keys );
break;
case 1:
mbedtls_des_setkey_enc( ctx, des3_test_keys );
break;
case 2:
mbedtls_des3_set2key_dec( ctx3, des3_test_keys );
break;
case 3:
mbedtls_des3_set2key_enc( ctx3, des3_test_keys );
break;
case 4:
mbedtls_des3_set3key_dec( ctx3, des3_test_keys );
break;
case 5:
mbedtls_des3_set3key_enc( ctx3, des3_test_keys );
break;
default:
return( 1 );
}
if( v == MBEDTLS_DES_DECRYPT )
{
for( j = 0; j < 100; j++ )
{
if( u == 0 )
mbedtls_des_crypt_cbc( ctx, v, 8, iv, buf, buf );
else
mbedtls_des3_crypt_cbc( ctx3, v, 8, iv, buf, buf );
}
}
else
{
for( j = 0; j < 100; j++ )
{
unsigned char tmp[8];
if( u == 0 )
mbedtls_des_crypt_cbc( ctx, v, 8, iv, buf, buf );
else
mbedtls_des3_crypt_cbc( ctx3, v, 8, iv, buf, buf );
memcpy( tmp, prv, 8 );
memcpy( prv, buf, 8 );
memcpy( buf, tmp, 8 );
}
memcpy( buf, prv, 8 );
}
if( ( v == MBEDTLS_DES_DECRYPT &&
timingsafe_bcmp( buf, des3_test_cbc_dec[u], 8 ) != 0 ) ||
( v != MBEDTLS_DES_DECRYPT &&
timingsafe_bcmp( buf, des3_test_cbc_enc[u], 8 ) != 0 ) )
{
if( verbose != 0 )
mbedtls_printf( "failed\n" );
ret = 1;
goto exit;
}
if( verbose != 0 )
mbedtls_printf( "passed\n" );
}
#endif /* MBEDTLS_CIPHER_MODE_CBC */
if( verbose != 0 )
mbedtls_printf( "\n" );
exit:
mbedtls_des_free( ctx );
mbedtls_des3_free( ctx3 );
return( ret );
}
int mbedtls_des_self_test( int verbose )
{
int rc;
mbedtls_des_context *ctx;
mbedtls_des3_context *ctx3;
ctx = malloc( sizeof( mbedtls_des_context ) );
ctx3 = malloc( sizeof( mbedtls_des3_context ) );
rc = mbedtls_des_self_test_impl( verbose, ctx, ctx3 );
free( ctx3 );
free( ctx );
return( rc );
}
#endif /* MBEDTLS_SELF_TEST */
| 33,155 | 1,036 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/aesni.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:4;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright The Mbed TLS Contributors â
â â
â Licensed under the Apache License, Version 2.0 (the "License"); â
â you may not use this file except in compliance with the License. â
â You may obtain a copy of the License at â
â â
â http://www.apache.org/licenses/LICENSE-2.0 â
â â
â Unless required by applicable law or agreed to in writing, software â
â distributed under the License is distributed on an "AS IS" BASIS, â
â WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. â
â See the License for the specific language governing permissions and â
â limitations under the License. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "third_party/mbedtls/aesni.h"
#include "libc/intrin/bits.h"
#include "libc/str/str.h"
#include "third_party/mbedtls/common.h"
asm(".ident\t\"\\n\\n\
Mbed TLS (Apache 2.0)\\n\
Copyright ARM Limited\\n\
Copyright Mbed TLS Contributors\"");
asm(".include \"libc/disclaimer.inc\"");
/* clang-format off */
/*
* [AES-WP] http://software.intel.com/en-us/articles/intel-advanced-encryption-standard-aes-instructions-set
* [CLMUL-WP] http://software.intel.com/en-us/articles/intel-carry-less-multiplication-instruction-and-its-usage-for-computing-the-gcm-mode/
*/
#if defined(MBEDTLS_AESNI_C)
#if defined(MBEDTLS_HAVE_X86_64)
/*
* Binutils needs to be at least 2.19 to support AES-NI instructions.
* Unfortunately, a lot of users have a lower version now (2014-04).
* Emit bytecode directly in order to support "old" version of gas.
*
* Opcodes from the Intel architecture reference manual, vol. 3.
* We always use registers, so we don't need prefixes for memory operands.
* Operand macros are in gas order (src, dst) as opposed to Intel order
* (dst, src) in order to blend better into the surrounding assembly code.
*/
#define AESDEC ".byte 0x66,0x0F,0x38,0xDE,"
#define AESDECLAST ".byte 0x66,0x0F,0x38,0xDF,"
#define AESENC ".byte 0x66,0x0F,0x38,0xDC,"
#define AESENCLAST ".byte 0x66,0x0F,0x38,0xDD,"
#define AESIMC ".byte 0x66,0x0F,0x38,0xDB,"
#define AESKEYGENA ".byte 0x66,0x0F,0x3A,0xDF,"
#define PCLMULQDQ ".byte 0x66,0x0F,0x3A,0x44,"
#define xmm0_xmm0 "0xC0"
#define xmm0_xmm1 "0xC8"
#define xmm0_xmm2 "0xD0"
#define xmm0_xmm3 "0xD8"
#define xmm0_xmm4 "0xE0"
#define xmm1_xmm0 "0xC1"
#define xmm1_xmm2 "0xD1"
/**
* \brief Internal AES-NI AES-ECB block encryption and decryption
*
* \note This function is only for internal use by other library
* functions; you must not call it directly.
*
* \param ctx AES context
* \param mode MBEDTLS_AES_ENCRYPT or MBEDTLS_AES_DECRYPT
* \param input 16-byte input block
* \param output 16-byte output block
*
* \return 0 on success (cannot fail)
*/
int mbedtls_aesni_crypt_ecb( mbedtls_aes_context *ctx,
int mode,
const unsigned char input[16],
unsigned char output[16] )
{
asm( "movdqu (%3), %%xmm0 \n\t" // load input
"movdqu (%1), %%xmm1 \n\t" // load round key 0
"pxor %%xmm1, %%xmm0 \n\t" // round 0
"add $16, %1 \n\t" // point to next round key
"subl $1, %0 \n\t" // normal rounds = nr - 1
"test %2, %2 \n\t" // mode?
"jz 2f \n\t" // 0 = decrypt
"1: \n\t" // encryption loop
"movdqu (%1), %%xmm1 \n\t" // load round key
"aesenc %%xmm1, %%xmm0 \n\t" // do round
"add $16, %1 \n\t" // point to next round key
"subl $1, %0 \n\t" // loop
"jnz 1b \n\t"
"movdqu (%1), %%xmm1 \n\t" // load round key
"aesenclast %%xmm1, %%xmm0 \n\t" // last round
"jmp 3f \n\t"
"2: \n\t" // decryption loop
"movdqu (%1), %%xmm1 \n\t"
"aesdec %%xmm1, %%xmm0 \n\t" // do round
"add $16, %1 \n\t"
"subl $1, %0 \n\t"
"jnz 2b \n\t"
"movdqu (%1), %%xmm1 \n\t" // load round key
"aesdeclast %%xmm1,%%xmm0 \n\t" // last round
"3: \n\t"
"movdqu %%xmm0, (%4) \n\t" // export output
:
: "r" (ctx->nr), "r" (ctx->rk), "r" (mode), "r" (input), "r" (output)
: "memory", "cc", "xmm0", "xmm1" );
return( 0 );
}
/**
* \brief Internal GCM multiplication: a = a * b in GF(2^128)
* Based on [CLMUL-WP] algorithms 1 (with equation 27) and 5.
*
* \note This function is intended for internal use.
*
* \param a First operand (big endian)
* \param b Second operand (host endian)
*
* \note Both operands and result are bit strings interpreted as
* elements of GF(2^128) as per the GCM spec.
*/
void mbedtls_aesni_gcm_mult( unsigned char a[16], const uint64_t b[2] )
{
size_t i;
uint64_t aa _Vector_size(16) forcealign(16);
uint64_t bb _Vector_size(16) forcealign(16);
/* The inputs are in big-endian order, so byte-reverse them */
aa[0] = READ64BE(a+8);
aa[1] = READ64BE(a+0);
memcpy(&bb, b, 16);
asm( /*
* Caryless multiplication xmm2:xmm1 = xmm0 * xmm1
* using [CLMUL-WP] algorithm 1 (p. 13).
*/
"movdqa %1, %%xmm2 \n\t" // copy of b1:b0
"movdqa %1, %%xmm3 \n\t" // same
"movdqa %1, %%xmm4 \n\t" // same
"pclmullqlqdq %0,%1 \n\t" // a0*b0 = c1:c0
"pclmulhqhqdq %0,%%xmm2 \n\t" // a1*b1 = d1:d0
"pclmullqhqdq %0,%%xmm3 \n\t" // a0*b1 = e1:e0
"pclmulhqlqdq %0,%%xmm4 \n\t" // a1*b0 = f1:f0
"pxor %%xmm3, %%xmm4 \n\t" // e1+f1:e0+f0
"movdqa %%xmm4, %%xmm3 \n\t" // same
"psrldq $8, %%xmm4 \n\t" // 0:e1+f1
"pslldq $8, %%xmm3 \n\t" // e0+f0:0
"pxor %%xmm4, %%xmm2 \n\t" // d1:d0+e1+f1
"pxor %%xmm3, %1 \n\t" // c1+e0+f1:c0
/*
* Now shift the result one bit to the left,
* taking advantage of [CLMUL-WP] eq 27 (p. 20)
*/
"movdqa %1, %%xmm3 \n\t" // r1:r0
"movdqa %%xmm2, %%xmm4 \n\t" // r3:r2
"psllq $1, %1 \n\t" // r1<<1:r0<<1
"psllq $1, %%xmm2 \n\t" // r3<<1:r2<<1
"psrlq $63, %%xmm3 \n\t" // r1>>63:r0>>63
"psrlq $63, %%xmm4 \n\t" // r3>>63:r2>>63
"movdqa %%xmm3, %%xmm5 \n\t" // r1>>63:r0>>63
"pslldq $8, %%xmm3 \n\t" // r0>>63:0
"pslldq $8, %%xmm4 \n\t" // r2>>63:0
"psrldq $8, %%xmm5 \n\t" // 0:r1>>63
"por %%xmm3, %1 \n\t" // r1<<1|r0>>63:r0<<1
"por %%xmm4, %%xmm2 \n\t" // r3<<1|r2>>62:r2<<1
"por %%xmm5, %%xmm2 \n\t" // r3<<1|r2>>62:r2<<1|r1>>63
/*
* Now reduce modulo the GCM polynomial x^128 + x^7 + x^2 + x + 1
* using [CLMUL-WP] algorithm 5 (p. 20).
* Currently xmm2:xmm1 holds x3:x2:x1:x0 (already shifted).
*/
/* Step 2 (1) */
"movdqa %1, %%xmm3 \n\t" // x1:x0
"movdqa %1, %%xmm4 \n\t" // same
"movdqa %1, %%xmm5 \n\t" // same
"psllq $63, %%xmm3 \n\t" // x1<<63:x0<<63 = stuff:a
"psllq $62, %%xmm4 \n\t" // x1<<62:x0<<62 = stuff:b
"psllq $57, %%xmm5 \n\t" // x1<<57:x0<<57 = stuff:c
/* Step 2 (2) */
"pxor %%xmm4, %%xmm3 \n\t" // stuff:a+b
"pxor %%xmm5, %%xmm3 \n\t" // stuff:a+b+c
"pslldq $8, %%xmm3 \n\t" // a+b+c:0
"pxor %%xmm3, %1 \n\t" // x1+a+b+c:x0 = d:x0
/* Steps 3 and 4 */
"movdqa %1,%0 \n\t" // d:x0
"movdqa %1,%%xmm4 \n\t" // same
"movdqa %1,%%xmm5 \n\t" // same
"psrlq $1, %0 \n\t" // e1:x0>>1 = e1:e0'
"psrlq $2, %%xmm4 \n\t" // f1:x0>>2 = f1:f0'
"psrlq $7, %%xmm5 \n\t" // g1:x0>>7 = g1:g0'
"pxor %%xmm4, %0 \n\t" // e1+f1:e0'+f0'
"pxor %%xmm5, %0 \n\t" // e1+f1+g1:e0'+f0'+g0'
// e0'+f0'+g0' is almost e0+f0+g0, ex\tcept for some missing
// bits carried from d. Now get those\t bits back in.
"movdqa %1,%%xmm3 \n\t" // d:x0
"movdqa %1,%%xmm4 \n\t" // same
"movdqa %1,%%xmm5 \n\t" // same
"psllq $63, %%xmm3 \n\t" // d<<63:stuff
"psllq $62, %%xmm4 \n\t" // d<<62:stuff
"psllq $57, %%xmm5 \n\t" // d<<57:stuff
"pxor %%xmm4, %%xmm3 \n\t" // d<<63+d<<62:stuff
"pxor %%xmm5, %%xmm3 \n\t" // missing bits of d:stuff
"psrldq $8, %%xmm3 \n\t" // 0:missing bits of d
"pxor %%xmm3, %0 \n\t" // e1+f1+g1:e0+f0+g0
"pxor %1, %0 \n\t" // h1:h0
"pxor %%xmm2, %0 \n\t" // x3+h1:x2+h0
: "+x" (aa)
: "x" (bb)
: "xmm2", "xmm3", "xmm4", "xmm5" );
/* Now byte-reverse the outputs */
WRITE64BE(a+0, aa[1]);
WRITE64BE(a+8, aa[0]);
}
/**
* \brief Internal round key inversion. This function computes
* decryption round keys from the encryption round keys.
*
* \note This function is only for internal use by other library
* functions; you must not call it directly.
*
* \param invkey Round keys for the equivalent inverse cipher
* \param fwdkey Original round keys (for encryption)
* \param nr Number of rounds (that is, number of round keys minus one)
*/
void mbedtls_aesni_inverse_key( unsigned char *invkey,
const unsigned char *fwdkey, int nr )
{
unsigned char *ik = invkey;
const unsigned char *fk = fwdkey + 16 * nr;
memcpy( ik, fk, 16 );
for( fk -= 16, ik += 16; fk > fwdkey; fk -= 16, ik += 16 )
asm( "movdqu (%0), %%xmm0 \n\t"
AESIMC xmm0_xmm0 "\n\t"
"movdqu %%xmm0, (%1) \n\t"
:
: "r" (fk), "r" (ik)
: "memory", "xmm0" );
memcpy( ik, fk, 16 );
}
/*
* Key expansion, 128-bit case
*/
static void aesni_setkey_enc_128( unsigned char *rk,
const unsigned char *key )
{
asm( "movdqu (%1), %%xmm0 \n\t" // copy the original key
"movdqu %%xmm0, (%0) \n\t" // as round key 0
"jmp 2f \n\t" // skip auxiliary routine
/*
* Finish generating the next round key.
*
* On entry xmm0 is r3:r2:r1:r0 and xmm1 is X:stuff:stuff:stuff
* with X = rot( sub( r3 ) ) ^ RCON.
*
* On exit, xmm0 is r7:r6:r5:r4
* with r4 = X + r0, r5 = r4 + r1, r6 = r5 + r2, r7 = r6 + r3
* and those are written to the round key buffer.
*/
"1: \n\t"
"pshufd $0xff, %%xmm1, %%xmm1 \n\t" // X:X:X:X
"pxor %%xmm0, %%xmm1 \n\t" // X+r3:X+r2:X+r1:r4
"pslldq $4, %%xmm0 \n\t" // r2:r1:r0:0
"pxor %%xmm0, %%xmm1 \n\t" // X+r3+r2:X+r2+r1:r5:r4
"pslldq $4, %%xmm0 \n\t" // etc
"pxor %%xmm0, %%xmm1 \n\t"
"pslldq $4, %%xmm0 \n\t"
"pxor %%xmm1, %%xmm0 \n\t" // update xmm0 for next time!
"add $16, %0 \n\t" // point to next round key
"movdqu %%xmm0, (%0) \n\t" // write it
"ret \n\t"
/* Main "loop" */
"2: \n\t"
AESKEYGENA xmm0_xmm1 ",0x01 \n\tcall 1b \n\t"
AESKEYGENA xmm0_xmm1 ",0x02 \n\tcall 1b \n\t"
AESKEYGENA xmm0_xmm1 ",0x04 \n\tcall 1b \n\t"
AESKEYGENA xmm0_xmm1 ",0x08 \n\tcall 1b \n\t"
AESKEYGENA xmm0_xmm1 ",0x10 \n\tcall 1b \n\t"
AESKEYGENA xmm0_xmm1 ",0x20 \n\tcall 1b \n\t"
AESKEYGENA xmm0_xmm1 ",0x40 \n\tcall 1b \n\t"
AESKEYGENA xmm0_xmm1 ",0x80 \n\tcall 1b \n\t"
AESKEYGENA xmm0_xmm1 ",0x1B \n\tcall 1b \n\t"
AESKEYGENA xmm0_xmm1 ",0x36 \n\tcall 1b \n\t"
:
: "r" (rk), "r" (key)
: "memory", "cc", "0" );
}
/*
* Key expansion, 192-bit case
*/
static void aesni_setkey_enc_192( unsigned char *rk,
const unsigned char *key )
{
asm( "movdqu (%1), %%xmm0 \n\t" // copy original round key
"movdqu %%xmm0, (%0) \n\t"
"add $16, %0 \n\t"
"movq 16(%1), %%xmm1 \n\t"
"movq %%xmm1, (%0) \n\t"
"add $8, %0 \n\t"
"jmp 2f \n\t" // skip auxiliary routine
/*
* Finish generating the next 6 quarter-keys.
*
* On entry xmm0 is r3:r2:r1:r0, xmm1 is stuff:stuff:r5:r4
* and xmm2 is stuff:stuff:X:stuff with X = rot( sub( r3 ) ) ^ RCON.
*
* On exit, xmm0 is r9:r8:r7:r6 and xmm1 is stuff:stuff:r11:r10
* and those are written to the round key buffer.
*/
"1: \n\t"
"pshufd $0x55, %%xmm2, %%xmm2 \n\t" // X:X:X:X
"pxor %%xmm0, %%xmm2 \n\t" // X+r3:X+r2:X+r1:r4
"pslldq $4, %%xmm0 \n\t" // etc
"pxor %%xmm0, %%xmm2 \n\t"
"pslldq $4, %%xmm0 \n\t"
"pxor %%xmm0, %%xmm2 \n\t"
"pslldq $4, %%xmm0 \n\t"
"pxor %%xmm2, %%xmm0 \n\t" // update xmm0 = r9:r8:r7:r6
"movdqu %%xmm0, (%0) \n\t"
"add $16, %0 \n\t"
"pshufd $0xff, %%xmm0, %%xmm2 \n\t" // r9:r9:r9:r9
"pxor %%xmm1, %%xmm2 \n\t" // stuff:stuff:r9+r5:r10
"pslldq $4, %%xmm1 \n\t" // r2:r1:r0:0
"pxor %%xmm2, %%xmm1 \n\t" // xmm1 = stuff:stuff:r11:r10
"movq %%xmm1, (%0) \n\t"
"add $8, %0 \n\t"
"ret \n\t"
"2: \n\t"
AESKEYGENA xmm1_xmm2 ",0x01 \n\tcall 1b \n\t"
AESKEYGENA xmm1_xmm2 ",0x02 \n\tcall 1b \n\t"
AESKEYGENA xmm1_xmm2 ",0x04 \n\tcall 1b \n\t"
AESKEYGENA xmm1_xmm2 ",0x08 \n\tcall 1b \n\t"
AESKEYGENA xmm1_xmm2 ",0x10 \n\tcall 1b \n\t"
AESKEYGENA xmm1_xmm2 ",0x20 \n\tcall 1b \n\t"
AESKEYGENA xmm1_xmm2 ",0x40 \n\tcall 1b \n\t"
AESKEYGENA xmm1_xmm2 ",0x80 \n\tcall 1b \n\t"
:
: "r" (rk), "r" (key)
: "memory", "cc", "0" );
}
/*
* Key expansion, 256-bit case
*/
static void aesni_setkey_enc_256( unsigned char *rk,
const unsigned char *key )
{
asm( "movdqu (%1), %%xmm0 \n\t"
"movdqu %%xmm0, (%0) \n\t"
"add $16, %0 \n\t"
"movdqu 16(%1), %%xmm1 \n\t"
"movdqu %%xmm1, (%0) \n\t"
"jmp 2f \n\t" // skip auxiliary routine
/*
* Finish generating the next two round keys.
*
* On entry xmm0 is r3:r2:r1:r0, xmm1 is r7:r6:r5:r4 and
* xmm2 is X:stuff:stuff:stuff with X = rot( sub( r7 )) ^ RCON
*
* On exit, xmm0 is r11:r10:r9:r8 and xmm1 is r15:r14:r13:r12
* and those have been written to the output buffer.
*/
"1: \n\t"
"pshufd $0xff, %%xmm2, %%xmm2 \n\t"
"pxor %%xmm0, %%xmm2 \n\t"
"pslldq $4, %%xmm0 \n\t"
"pxor %%xmm0, %%xmm2 \n\t"
"pslldq $4, %%xmm0 \n\t"
"pxor %%xmm0, %%xmm2 \n\t"
"pslldq $4, %%xmm0 \n\t"
"pxor %%xmm2, %%xmm0 \n\t"
"add $16, %0 \n\t"
"movdqu %%xmm0, (%0) \n\t"
/* Set xmm2 to stuff:Y:stuff:stuff with Y = subword( r11 )
* and proceed to generate next round key from there */
AESKEYGENA xmm0_xmm2 ",0x00 \n\t"
"pshufd $0xaa, %%xmm2, %%xmm2 \n\t"
"pxor %%xmm1, %%xmm2 \n\t"
"pslldq $4, %%xmm1 \n\t"
"pxor %%xmm1, %%xmm2 \n\t"
"pslldq $4, %%xmm1 \n\t"
"pxor %%xmm1, %%xmm2 \n\t"
"pslldq $4, %%xmm1 \n\t"
"pxor %%xmm2, %%xmm1 \n\t"
"add $16, %0 \n\t"
"movdqu %%xmm1, (%0) \n\t"
"ret \n\t"
/*
* Main "loop" - Generating one more key than necessary,
* see definition of mbedtls_aes_context.buf
*/
"2: \n\t"
AESKEYGENA xmm1_xmm2 ",0x01 \n\tcall 1b \n\t"
AESKEYGENA xmm1_xmm2 ",0x02 \n\tcall 1b \n\t"
AESKEYGENA xmm1_xmm2 ",0x04 \n\tcall 1b \n\t"
AESKEYGENA xmm1_xmm2 ",0x08 \n\tcall 1b \n\t"
AESKEYGENA xmm1_xmm2 ",0x10 \n\tcall 1b \n\t"
AESKEYGENA xmm1_xmm2 ",0x20 \n\tcall 1b \n\t"
AESKEYGENA xmm1_xmm2 ",0x40 \n\tcall 1b \n\t"
:
: "r" (rk), "r" (key)
: "memory", "cc", "0" );
}
/**
* \brief Internal key expansion for encryption
*
* \note This function is only for internal use by other library
* functions; you must not call it directly.
*
* \param rk Destination buffer where the round keys are written
* \param key Encryption key
* \param bits Key size in bits (must be 128, 192 or 256)
*
* \return 0 if successful, or MBEDTLS_ERR_AES_INVALID_KEY_LENGTH
*/
int mbedtls_aesni_setkey_enc( unsigned char *rk,
const unsigned char *key,
size_t bits )
{
switch( bits )
{
case 128: aesni_setkey_enc_128( rk, key ); break;
case 192: aesni_setkey_enc_192( rk, key ); break;
case 256: aesni_setkey_enc_256( rk, key ); break;
default : return( MBEDTLS_ERR_AES_INVALID_KEY_LENGTH );
}
return( 0 );
}
#endif /* MBEDTLS_HAVE_X86_64 */
#endif /* MBEDTLS_AESNI_C */
| 20,100 | 460 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/pk_internal.h | #ifndef MBEDTLS_PK_WRAP_H
#define MBEDTLS_PK_WRAP_H
#include "third_party/mbedtls/config.h"
#include "third_party/mbedtls/pk.h"
/* clang-format off */
struct mbedtls_pk_info_t
{
/** Public key type */
mbedtls_pk_type_t type;
/** Type name */
const char *name;
/** Get key size in bits */
size_t (*get_bitlen)( const void * );
/** Tell if the context implements this type (e.g. ECKEY can do ECDSA) */
int (*can_do)( mbedtls_pk_type_t type );
/** Verify signature */
int (*verify_func)( void *ctx, mbedtls_md_type_t md_alg,
const unsigned char *hash, size_t hash_len,
const unsigned char *sig, size_t sig_len );
/** Make signature */
int (*sign_func)( void *ctx, mbedtls_md_type_t md_alg,
const unsigned char *hash, size_t hash_len,
unsigned char *sig, size_t *sig_len,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng );
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
/** Verify signature (restartable) */
int (*verify_rs_func)( void *ctx, mbedtls_md_type_t md_alg,
const unsigned char *hash, size_t hash_len,
const unsigned char *sig, size_t sig_len,
void *rs_ctx );
/** Make signature (restartable) */
int (*sign_rs_func)( void *ctx, mbedtls_md_type_t md_alg,
const unsigned char *hash, size_t hash_len,
unsigned char *sig, size_t *sig_len,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng, void *rs_ctx );
#endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
/** Decrypt message */
int (*decrypt_func)( void *ctx, const unsigned char *input, size_t ilen,
unsigned char *output, size_t *olen, size_t osize,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng );
/** Encrypt message */
int (*encrypt_func)( void *ctx, const unsigned char *input, size_t ilen,
unsigned char *output, size_t *olen, size_t osize,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng );
/** Check public-private key pair */
int (*check_pair_func)( const void *pub, const void *prv );
/** Allocate a new context */
void * (*ctx_alloc_func)( void );
/** Free the given context */
void (*ctx_free_func)( void *ctx );
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
/** Allocate the restart context */
void * (*rs_alloc_func)( void );
/** Free the restart context */
void (*rs_free_func)( void *rs_ctx );
#endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
/** Interface with the debug module */
void (*debug_func)( const void *ctx, mbedtls_pk_debug_item *items );
};
/* Container for RSA-alt */
typedef struct
{
void *key;
mbedtls_pk_rsa_alt_decrypt_func decrypt_func;
mbedtls_pk_rsa_alt_sign_func sign_func;
mbedtls_pk_rsa_alt_key_len_func key_len_func;
} mbedtls_rsa_alt_context;
extern const mbedtls_pk_info_t mbedtls_rsa_info;
extern const mbedtls_pk_info_t mbedtls_eckey_info;
extern const mbedtls_pk_info_t mbedtls_eckeydh_info;
extern const mbedtls_pk_info_t mbedtls_ecdsa_info;
extern const mbedtls_pk_info_t mbedtls_rsa_alt_info;
extern const mbedtls_pk_info_t mbedtls_pk_opaque_info;
#endif /* MBEDTLS_PK_WRAP_H */
| 3,607 | 99 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/entropy.h | #ifndef COSMOPOLITAN_THIRD_PARTY_MBEDTLS_ENTROPY_H_
#define COSMOPOLITAN_THIRD_PARTY_MBEDTLS_ENTROPY_H_
#include "third_party/mbedtls/config.h"
#include "third_party/mbedtls/sha256.h"
#include "third_party/mbedtls/sha512.h"
COSMOPOLITAN_C_START_
/* clang-format off */
#if defined(MBEDTLS_SHA512_C) && !defined(MBEDTLS_ENTROPY_FORCE_SHA256)
#define MBEDTLS_ENTROPY_SHA512_ACCUMULATOR
#else
#if defined(MBEDTLS_SHA256_C)
#define MBEDTLS_ENTROPY_SHA256_ACCUMULATOR
#endif
#endif
#define MBEDTLS_ERR_ENTROPY_SOURCE_FAILED -0x003C /*< Critical entropy source failure. */
#define MBEDTLS_ERR_ENTROPY_MAX_SOURCES -0x003E /*< No more sources can be added. */
#define MBEDTLS_ERR_ENTROPY_NO_SOURCES_DEFINED -0x0040 /*< No sources have been added to poll. */
#define MBEDTLS_ERR_ENTROPY_NO_STRONG_SOURCE -0x003D /*< No strong sources have been added to poll. */
#define MBEDTLS_ERR_ENTROPY_FILE_IO_ERROR -0x003F /*< Read/write error in file. */
#if !defined(MBEDTLS_ENTROPY_MAX_SOURCES)
#define MBEDTLS_ENTROPY_MAX_SOURCES 20 /*< Maximum number of sources supported */
#endif
#if !defined(MBEDTLS_ENTROPY_MAX_GATHER)
#define MBEDTLS_ENTROPY_MAX_GATHER 128 /*< Maximum amount requested from entropy sources */
#endif
#if defined(MBEDTLS_ENTROPY_SHA512_ACCUMULATOR)
#define MBEDTLS_ENTROPY_BLOCK_SIZE 64 /*< Block size of entropy accumulator (SHA-512) */
#else
#define MBEDTLS_ENTROPY_BLOCK_SIZE 32 /*< Block size of entropy accumulator (SHA-256) */
#endif
#define MBEDTLS_ENTROPY_MAX_SEED_SIZE 1024 /*< Maximum size of seed we read from seed file */
#define MBEDTLS_ENTROPY_SOURCE_MANUAL MBEDTLS_ENTROPY_MAX_SOURCES
#define MBEDTLS_ENTROPY_SOURCE_STRONG 1 /*< Entropy source is strong */
#define MBEDTLS_ENTROPY_SOURCE_WEAK 0 /*< Entropy source is weak */
/**
* \brief Entropy poll callback pointer
*
* \param data Callback-specific data pointer
* \param output Data to fill
* \param len Maximum size to provide
* \param olen The actual amount of bytes put into the buffer (Can be 0)
*
* \return 0 if no critical failures occurred,
* MBEDTLS_ERR_ENTROPY_SOURCE_FAILED otherwise
*/
typedef int (*mbedtls_entropy_f_source_ptr)(void *data, unsigned char *output, size_t len, size_t *olen);
/**
* \brief Entropy source state
*/
typedef struct mbedtls_entropy_source_state
{
mbedtls_entropy_f_source_ptr f_source; /*< The entropy source callback */
void * p_source; /*< The callback data pointer */
size_t size; /*< Amount received in bytes */
size_t threshold; /*< Minimum bytes required before release */
int strong; /*< Is the source strong? */
}
mbedtls_entropy_source_state;
/**
* \brief Entropy context structure
*/
typedef struct mbedtls_entropy_context
{
int accumulator_started; /* 0 after init.
* 1 after the first update.
* -1 after free. */
#if defined(MBEDTLS_ENTROPY_SHA512_ACCUMULATOR)
mbedtls_sha512_context accumulator;
#else
mbedtls_sha256_context accumulator;
#endif
int source_count; /* Number of entries used in source. */
mbedtls_entropy_source_state source[MBEDTLS_ENTROPY_MAX_SOURCES];
#if defined(MBEDTLS_ENTROPY_NV_SEED)
int initial_entropy_run;
#endif
}
mbedtls_entropy_context;
void mbedtls_entropy_init( mbedtls_entropy_context * );
void mbedtls_entropy_free( mbedtls_entropy_context * );
int mbedtls_entropy_add_source( mbedtls_entropy_context *, mbedtls_entropy_f_source_ptr, void *, size_t, int );
int mbedtls_entropy_gather( mbedtls_entropy_context * );
int mbedtls_entropy_func( void *, unsigned char *, size_t );
int mbedtls_entropy_update_manual( mbedtls_entropy_context *, const unsigned char *, size_t );
int mbedtls_entropy_update_nv_seed( mbedtls_entropy_context * );
int mbedtls_entropy_write_seed_file( mbedtls_entropy_context *, const char * );
int mbedtls_entropy_update_seed_file( mbedtls_entropy_context *, const char * );
int mbedtls_entropy_self_test( int );
int mbedtls_entropy_source_self_test( int );
COSMOPOLITAN_C_END_
#endif /* COSMOPOLITAN_THIRD_PARTY_MBEDTLS_ENTROPY_H_ */
| 4,341 | 104 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/pkwrite.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:4;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright The Mbed TLS Contributors â
â â
â Licensed under the Apache License, Version 2.0 (the "License"); â
â you may not use this file except in compliance with the License. â
â You may obtain a copy of the License at â
â â
â http://www.apache.org/licenses/LICENSE-2.0 â
â â
â Unless required by applicable law or agreed to in writing, software â
â distributed under the License is distributed on an "AS IS" BASIS, â
â WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. â
â See the License for the specific language governing permissions and â
â limitations under the License. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "third_party/mbedtls/asn1write.h"
#include "third_party/mbedtls/bignum.h"
#include "third_party/mbedtls/common.h"
#include "third_party/mbedtls/ecdsa.h"
#include "third_party/mbedtls/ecp.h"
#include "third_party/mbedtls/error.h"
#include "third_party/mbedtls/oid.h"
#include "third_party/mbedtls/pem.h"
#include "third_party/mbedtls/pk.h"
#include "third_party/mbedtls/platform.h"
#include "third_party/mbedtls/rsa.h"
asm(".ident\t\"\\n\\n\
Mbed TLS (Apache 2.0)\\n\
Copyright ARM Limited\\n\
Copyright Mbed TLS Contributors\"");
asm(".include \"libc/disclaimer.inc\"");
/* clang-format off */
/*
* Public Key layer for writing key files and structures
*
* Copyright The Mbed TLS Contributors
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#if defined(MBEDTLS_PK_WRITE_C)
/* Parameter validation macros based on platform_util.h */
#define PK_VALIDATE_RET( cond ) \
MBEDTLS_INTERNAL_VALIDATE_RET( cond, MBEDTLS_ERR_PK_BAD_INPUT_DATA )
#define PK_VALIDATE( cond ) \
MBEDTLS_INTERNAL_VALIDATE( cond )
#if defined(MBEDTLS_RSA_C)
/*
* RSAPublicKey ::= SEQUENCE {
* modulus INTEGER, -- n
* publicExponent INTEGER -- e
* }
*/
static int pk_write_rsa_pubkey( unsigned char **p, unsigned char *start,
mbedtls_rsa_context *rsa )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t len = 0;
mbedtls_mpi T;
mbedtls_mpi_init( &T );
/* Export E */
if ( ( ret = mbedtls_rsa_export( rsa, NULL, NULL, NULL, NULL, &T ) ) != 0 ||
( ret = mbedtls_asn1_write_mpi( p, start, &T ) ) < 0 )
goto end_of_export;
len += ret;
/* Export N */
if ( ( ret = mbedtls_rsa_export( rsa, &T, NULL, NULL, NULL, NULL ) ) != 0 ||
( ret = mbedtls_asn1_write_mpi( p, start, &T ) ) < 0 )
goto end_of_export;
len += ret;
end_of_export:
mbedtls_mpi_free( &T );
if( ret < 0 )
return( ret );
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) );
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start, MBEDTLS_ASN1_CONSTRUCTED |
MBEDTLS_ASN1_SEQUENCE ) );
return( (int) len );
}
#endif /* MBEDTLS_RSA_C */
#if defined(MBEDTLS_ECP_C)
/*
* EC public key is an EC point
*/
static int pk_write_ec_pubkey( unsigned char **p, unsigned char *start,
mbedtls_ecp_keypair *ec )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t len = 0;
unsigned char buf[MBEDTLS_ECP_MAX_PT_LEN];
if( ( ret = mbedtls_ecp_point_write_binary( &ec->grp, &ec->Q,
MBEDTLS_ECP_PF_UNCOMPRESSED,
&len, buf, sizeof( buf ) ) ) != 0 )
{
return( ret );
}
if( *p < start || (size_t)( *p - start ) < len )
return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
*p -= len;
memcpy( *p, buf, len );
return( (int) len );
}
/*
* ECParameters ::= CHOICE {
* namedCurve OBJECT IDENTIFIER
* }
*/
static int pk_write_ec_param( unsigned char **p, unsigned char *start,
mbedtls_ecp_keypair *ec )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t len = 0;
const char *oid;
size_t oid_len;
if( ( ret = mbedtls_oid_get_oid_by_ec_grp( ec->grp.id, &oid, &oid_len ) ) != 0 )
return( ret );
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_oid( p, start, oid, oid_len ) );
return( (int) len );
}
/*
* privateKey OCTET STRING -- always of length ceil(log2(n)/8)
*/
static int pk_write_ec_private( unsigned char **p, unsigned char *start,
mbedtls_ecp_keypair *ec )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t byte_length = ( ec->grp.pbits + 7 ) / 8;
unsigned char tmp[MBEDTLS_ECP_MAX_BYTES];
ret = mbedtls_ecp_write_key( ec, tmp, byte_length );
if( ret != 0 )
goto exit;
ret = mbedtls_asn1_write_octet_string( p, start, tmp, byte_length );
exit:
mbedtls_platform_zeroize( tmp, byte_length );
return( ret );
}
#endif /* MBEDTLS_ECP_C */
/**
* \brief Write a subjectPublicKey to ASN.1 data
* Note: function works backwards in data buffer
*
* \param p reference to current position pointer
* \param start start of the buffer (for bounds-checking)
* \param key PK context which must contain a valid public or private key.
*
* \return the length written or a negative error code
*/
int mbedtls_pk_write_pubkey( unsigned char **p, unsigned char *start,
const mbedtls_pk_context *key )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t len = 0;
PK_VALIDATE_RET( p != NULL );
PK_VALIDATE_RET( *p != NULL );
PK_VALIDATE_RET( start != NULL );
PK_VALIDATE_RET( key != NULL );
#if defined(MBEDTLS_RSA_C)
if( mbedtls_pk_get_type( key ) == MBEDTLS_PK_RSA )
MBEDTLS_ASN1_CHK_ADD( len, pk_write_rsa_pubkey( p, start, mbedtls_pk_rsa( *key ) ) );
else
#endif
#if defined(MBEDTLS_ECP_C)
if( mbedtls_pk_get_type( key ) == MBEDTLS_PK_ECKEY )
MBEDTLS_ASN1_CHK_ADD( len, pk_write_ec_pubkey( p, start, mbedtls_pk_ec( *key ) ) );
else
#endif
#if defined(MBEDTLS_USE_PSA_CRYPTO)
if( mbedtls_pk_get_type( key ) == MBEDTLS_PK_OPAQUE )
{
size_t buffer_size;
psa_key_id_t* key_id = (psa_key_id_t*) key->pk_ctx;
if ( *p < start )
return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
buffer_size = (size_t)( *p - start );
if ( psa_export_public_key( *key_id, start, buffer_size, &len )
!= PSA_SUCCESS )
{
return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
}
else
{
*p -= len;
memmove( *p, start, len );
}
}
else
#endif /* MBEDTLS_USE_PSA_CRYPTO */
return( MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE );
return( (int) len );
}
/**
* \brief Write a public key to a SubjectPublicKeyInfo DER structure
* Note: data is written at the end of the buffer! Use the
* return value to determine where you should start
* using the buffer
*
* \param ctx PK context which must contain a valid public or private key.
* \param buf buffer to write to
* \param size size of the buffer
*
* \return length of data written if successful, or a specific
* error code
*/
int mbedtls_pk_write_pubkey_der( mbedtls_pk_context *key, unsigned char *buf, size_t size )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
unsigned char *c;
size_t len = 0, par_len = 0, oid_len;
mbedtls_pk_type_t pk_type;
const char *oid;
PK_VALIDATE_RET( key != NULL );
if( size == 0 )
return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
PK_VALIDATE_RET( buf != NULL );
c = buf + size;
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_pk_write_pubkey( &c, buf, key ) );
if( c - buf < 1 )
return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
/*
* SubjectPublicKeyInfo ::= SEQUENCE {
* algorithm AlgorithmIdentifier,
* subjectPublicKey BIT STRING }
*/
*--c = 0;
len += 1;
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &c, buf, len ) );
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( &c, buf, MBEDTLS_ASN1_BIT_STRING ) );
pk_type = mbedtls_pk_get_type( key );
#if defined(MBEDTLS_ECP_C)
if( pk_type == MBEDTLS_PK_ECKEY )
{
MBEDTLS_ASN1_CHK_ADD( par_len, pk_write_ec_param( &c, buf, mbedtls_pk_ec( *key ) ) );
}
#endif
#if defined(MBEDTLS_USE_PSA_CRYPTO)
if( pk_type == MBEDTLS_PK_OPAQUE )
{
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
psa_key_type_t key_type;
psa_key_id_t key_id;
psa_ecc_family_t curve;
size_t bits;
key_id = *((psa_key_id_t*) key->pk_ctx );
if( PSA_SUCCESS != psa_get_key_attributes( key_id, &attributes ) )
return( MBEDTLS_ERR_PK_HW_ACCEL_FAILED );
key_type = psa_get_key_type( &attributes );
bits = psa_get_key_bits( &attributes );
psa_reset_key_attributes( &attributes );
curve = PSA_KEY_TYPE_ECC_GET_FAMILY( key_type );
if( curve == 0 )
return( MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE );
ret = mbedtls_psa_get_ecc_oid_from_id( curve, bits, &oid, &oid_len );
if( ret != 0 )
return( MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE );
/* Write EC algorithm parameters; that's akin
* to pk_write_ec_param() above. */
MBEDTLS_ASN1_CHK_ADD( par_len, mbedtls_asn1_write_oid( &c, buf,
oid, oid_len ) );
/* The rest of the function works as for legacy EC contexts. */
pk_type = MBEDTLS_PK_ECKEY;
}
#endif /* MBEDTLS_USE_PSA_CRYPTO */
if( ( ret = mbedtls_oid_get_oid_by_pk_alg( pk_type, &oid,
&oid_len ) ) != 0 )
{
return( ret );
}
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_algorithm_identifier( &c, buf, oid, oid_len,
par_len ) );
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &c, buf, len ) );
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( &c, buf, MBEDTLS_ASN1_CONSTRUCTED |
MBEDTLS_ASN1_SEQUENCE ) );
return( (int) len );
}
/**
* \brief Write a private key to a PKCS#1 or SEC1 DER structure
* Note: data is written at the end of the buffer! Use the
* return value to determine where you should start
* using the buffer
*
* \param ctx PK context which must contain a valid private key.
* \param buf buffer to write to
* \param size size of the buffer
*
* \return length of data written if successful, or a specific
* error code
*/
int mbedtls_pk_write_key_der( mbedtls_pk_context *key, unsigned char *buf, size_t size )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
unsigned char *c;
size_t len = 0;
PK_VALIDATE_RET( key != NULL );
if( size == 0 )
return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
PK_VALIDATE_RET( buf != NULL );
c = buf + size;
#if defined(MBEDTLS_RSA_C)
if( mbedtls_pk_get_type( key ) == MBEDTLS_PK_RSA )
{
mbedtls_mpi T; /* Temporary holding the exported parameters */
mbedtls_rsa_context *rsa = mbedtls_pk_rsa( *key );
/*
* Export the parameters one after another to avoid simultaneous copies.
*/
mbedtls_mpi_init( &T );
/* Export QP */
if( ( ret = mbedtls_rsa_export_crt( rsa, NULL, NULL, &T ) ) != 0 ||
( ret = mbedtls_asn1_write_mpi( &c, buf, &T ) ) < 0 )
goto end_of_export;
len += ret;
/* Export DQ */
if( ( ret = mbedtls_rsa_export_crt( rsa, NULL, &T, NULL ) ) != 0 ||
( ret = mbedtls_asn1_write_mpi( &c, buf, &T ) ) < 0 )
goto end_of_export;
len += ret;
/* Export DP */
if( ( ret = mbedtls_rsa_export_crt( rsa, &T, NULL, NULL ) ) != 0 ||
( ret = mbedtls_asn1_write_mpi( &c, buf, &T ) ) < 0 )
goto end_of_export;
len += ret;
/* Export Q */
if ( ( ret = mbedtls_rsa_export( rsa, NULL, NULL,
&T, NULL, NULL ) ) != 0 ||
( ret = mbedtls_asn1_write_mpi( &c, buf, &T ) ) < 0 )
goto end_of_export;
len += ret;
/* Export P */
if ( ( ret = mbedtls_rsa_export( rsa, NULL, &T,
NULL, NULL, NULL ) ) != 0 ||
( ret = mbedtls_asn1_write_mpi( &c, buf, &T ) ) < 0 )
goto end_of_export;
len += ret;
/* Export D */
if ( ( ret = mbedtls_rsa_export( rsa, NULL, NULL,
NULL, &T, NULL ) ) != 0 ||
( ret = mbedtls_asn1_write_mpi( &c, buf, &T ) ) < 0 )
goto end_of_export;
len += ret;
/* Export E */
if ( ( ret = mbedtls_rsa_export( rsa, NULL, NULL,
NULL, NULL, &T ) ) != 0 ||
( ret = mbedtls_asn1_write_mpi( &c, buf, &T ) ) < 0 )
goto end_of_export;
len += ret;
/* Export N */
if ( ( ret = mbedtls_rsa_export( rsa, &T, NULL,
NULL, NULL, NULL ) ) != 0 ||
( ret = mbedtls_asn1_write_mpi( &c, buf, &T ) ) < 0 )
goto end_of_export;
len += ret;
end_of_export:
mbedtls_mpi_free( &T );
if( ret < 0 )
return( ret );
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_int( &c, buf, 0 ) );
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &c, buf, len ) );
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( &c,
buf, MBEDTLS_ASN1_CONSTRUCTED |
MBEDTLS_ASN1_SEQUENCE ) );
}
else
#endif /* MBEDTLS_RSA_C */
#if defined(MBEDTLS_ECP_C)
if( mbedtls_pk_get_type( key ) == MBEDTLS_PK_ECKEY )
{
mbedtls_ecp_keypair *ec = mbedtls_pk_ec( *key );
size_t pub_len = 0, par_len = 0;
/*
* RFC 5915, or SEC1 Appendix C.4
*
* ECPrivateKey ::= SEQUENCE {
* version INTEGER { ecPrivkeyVer1(1) } (ecPrivkeyVer1),
* privateKey OCTET STRING,
* parameters [0] ECParameters {{ NamedCurve }} OPTIONAL,
* publicKey [1] BIT STRING OPTIONAL
* }
*/
/* publicKey */
MBEDTLS_ASN1_CHK_ADD( pub_len, pk_write_ec_pubkey( &c, buf, ec ) );
if( c - buf < 1 )
return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
*--c = 0;
pub_len += 1;
MBEDTLS_ASN1_CHK_ADD( pub_len, mbedtls_asn1_write_len( &c, buf, pub_len ) );
MBEDTLS_ASN1_CHK_ADD( pub_len, mbedtls_asn1_write_tag( &c, buf, MBEDTLS_ASN1_BIT_STRING ) );
MBEDTLS_ASN1_CHK_ADD( pub_len, mbedtls_asn1_write_len( &c, buf, pub_len ) );
MBEDTLS_ASN1_CHK_ADD( pub_len, mbedtls_asn1_write_tag( &c, buf,
MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | 1 ) );
len += pub_len;
/* parameters */
MBEDTLS_ASN1_CHK_ADD( par_len, pk_write_ec_param( &c, buf, ec ) );
MBEDTLS_ASN1_CHK_ADD( par_len, mbedtls_asn1_write_len( &c, buf, par_len ) );
MBEDTLS_ASN1_CHK_ADD( par_len, mbedtls_asn1_write_tag( &c, buf,
MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | 0 ) );
len += par_len;
/* privateKey */
MBEDTLS_ASN1_CHK_ADD( len, pk_write_ec_private( &c, buf, ec ) );
/* version */
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_int( &c, buf, 1 ) );
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &c, buf, len ) );
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( &c, buf, MBEDTLS_ASN1_CONSTRUCTED |
MBEDTLS_ASN1_SEQUENCE ) );
}
else
#endif /* MBEDTLS_ECP_C */
return( MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE );
return( (int) len );
}
#if defined(MBEDTLS_PEM_WRITE_C)
#define PEM_BEGIN_PUBLIC_KEY "-----BEGIN PUBLIC KEY-----\n"
#define PEM_END_PUBLIC_KEY "-----END PUBLIC KEY-----\n"
#define PEM_BEGIN_PRIVATE_KEY_RSA "-----BEGIN RSA PRIVATE KEY-----\n"
#define PEM_END_PRIVATE_KEY_RSA "-----END RSA PRIVATE KEY-----\n"
#define PEM_BEGIN_PRIVATE_KEY_EC "-----BEGIN EC PRIVATE KEY-----\n"
#define PEM_END_PRIVATE_KEY_EC "-----END EC PRIVATE KEY-----\n"
/*
* Max sizes of key per types. Shown as tag + len (+ content).
*/
#if defined(MBEDTLS_RSA_C)
/*
* RSA public keys:
* SubjectPublicKeyInfo ::= SEQUENCE { 1 + 3
* algorithm AlgorithmIdentifier, 1 + 1 (sequence)
* + 1 + 1 + 9 (rsa oid)
* + 1 + 1 (params null)
* subjectPublicKey BIT STRING } 1 + 3 + (1 + below)
* RSAPublicKey ::= SEQUENCE { 1 + 3
* modulus INTEGER, -- n 1 + 3 + MPI_MAX + 1
* publicExponent INTEGER -- e 1 + 3 + MPI_MAX + 1
* }
*/
#define RSA_PUB_DER_MAX_BYTES ( 38 + 2 * MBEDTLS_MPI_MAX_SIZE )
/*
* RSA private keys:
* RSAPrivateKey ::= SEQUENCE { 1 + 3
* version Version, 1 + 1 + 1
* modulus INTEGER, 1 + 3 + MPI_MAX + 1
* publicExponent INTEGER, 1 + 3 + MPI_MAX + 1
* privateExponent INTEGER, 1 + 3 + MPI_MAX + 1
* prime1 INTEGER, 1 + 3 + MPI_MAX / 2 + 1
* prime2 INTEGER, 1 + 3 + MPI_MAX / 2 + 1
* exponent1 INTEGER, 1 + 3 + MPI_MAX / 2 + 1
* exponent2 INTEGER, 1 + 3 + MPI_MAX / 2 + 1
* coefficient INTEGER, 1 + 3 + MPI_MAX / 2 + 1
* otherPrimeInfos OtherPrimeInfos OPTIONAL 0 (not supported)
* }
*/
#define MPI_MAX_SIZE_2 ( MBEDTLS_MPI_MAX_SIZE / 2 + \
MBEDTLS_MPI_MAX_SIZE % 2 )
#define RSA_PRV_DER_MAX_BYTES ( 47 + 3 * MBEDTLS_MPI_MAX_SIZE \
+ 5 * MPI_MAX_SIZE_2 )
#else /* MBEDTLS_RSA_C */
#define RSA_PUB_DER_MAX_BYTES 0
#define RSA_PRV_DER_MAX_BYTES 0
#endif /* MBEDTLS_RSA_C */
#if defined(MBEDTLS_ECP_C)
/*
* EC public keys:
* SubjectPublicKeyInfo ::= SEQUENCE { 1 + 2
* algorithm AlgorithmIdentifier, 1 + 1 (sequence)
* + 1 + 1 + 7 (ec oid)
* + 1 + 1 + 9 (namedCurve oid)
* subjectPublicKey BIT STRING 1 + 2 + 1 [1]
* + 1 (point format) [1]
* + 2 * ECP_MAX (coords) [1]
* }
*/
#define ECP_PUB_DER_MAX_BYTES ( 30 + 2 * MBEDTLS_ECP_MAX_BYTES )
/*
* EC private keys:
* ECPrivateKey ::= SEQUENCE { 1 + 2
* version INTEGER , 1 + 1 + 1
* privateKey OCTET STRING, 1 + 1 + ECP_MAX
* parameters [0] ECParameters OPTIONAL, 1 + 1 + (1 + 1 + 9)
* publicKey [1] BIT STRING OPTIONAL 1 + 2 + [1] above
* }
*/
#define ECP_PRV_DER_MAX_BYTES ( 29 + 3 * MBEDTLS_ECP_MAX_BYTES )
#else /* MBEDTLS_ECP_C */
#define ECP_PUB_DER_MAX_BYTES 0
#define ECP_PRV_DER_MAX_BYTES 0
#endif /* MBEDTLS_ECP_C */
#define PUB_DER_MAX_BYTES ( RSA_PUB_DER_MAX_BYTES > ECP_PUB_DER_MAX_BYTES ? \
RSA_PUB_DER_MAX_BYTES : ECP_PUB_DER_MAX_BYTES )
#define PRV_DER_MAX_BYTES ( RSA_PRV_DER_MAX_BYTES > ECP_PRV_DER_MAX_BYTES ? \
RSA_PRV_DER_MAX_BYTES : ECP_PRV_DER_MAX_BYTES )
/**
* \brief Write a public key to a PEM string
*
* \param ctx PK context which must contain a valid public or private key.
* \param buf Buffer to write to. The output includes a
* terminating null byte.
* \param size Size of the buffer in bytes.
*
* \return 0 if successful, or a specific error code
*/
int mbedtls_pk_write_pubkey_pem( mbedtls_pk_context *key, unsigned char *buf, size_t size )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
unsigned char output_buf[PUB_DER_MAX_BYTES];
size_t olen = 0;
PK_VALIDATE_RET( key != NULL );
PK_VALIDATE_RET( buf != NULL || size == 0 );
if( ( ret = mbedtls_pk_write_pubkey_der( key, output_buf,
sizeof(output_buf) ) ) < 0 )
{
return( ret );
}
if( ( ret = mbedtls_pem_write_buffer( PEM_BEGIN_PUBLIC_KEY, PEM_END_PUBLIC_KEY,
output_buf + sizeof(output_buf) - ret,
ret, buf, size, &olen ) ) != 0 )
{
return( ret );
}
return( 0 );
}
/**
* \brief Write a private key to a PKCS#1 or SEC1 PEM string
*
* \param ctx PK context which must contain a valid private key.
* \param buf Buffer to write to. The output includes a
* terminating null byte.
* \param size Size of the buffer in bytes.
*
* \return 0 if successful, or a specific error code
*/
int mbedtls_pk_write_key_pem( mbedtls_pk_context *key, unsigned char *buf, size_t size )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
unsigned char *output_buf;
const char *begin, *end;
size_t olen = 0;
PK_VALIDATE_RET( key != NULL );
PK_VALIDATE_RET( buf != NULL || size == 0 );
output_buf = malloc(PRV_DER_MAX_BYTES);
if( ( ret = mbedtls_pk_write_key_der( key, output_buf, PRV_DER_MAX_BYTES ) ) < 0 ) {
free(output_buf);
return( ret );
}
#if defined(MBEDTLS_RSA_C)
if( mbedtls_pk_get_type( key ) == MBEDTLS_PK_RSA )
{
begin = PEM_BEGIN_PRIVATE_KEY_RSA;
end = PEM_END_PRIVATE_KEY_RSA;
}
else
#endif
#if defined(MBEDTLS_ECP_C)
if( mbedtls_pk_get_type( key ) == MBEDTLS_PK_ECKEY )
{
begin = PEM_BEGIN_PRIVATE_KEY_EC;
end = PEM_END_PRIVATE_KEY_EC;
}
else
#endif
return( MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE );
if( ( ret = mbedtls_pem_write_buffer( begin, end,
output_buf + PRV_DER_MAX_BYTES - ret,
ret, buf, size, &olen ) ) != 0 )
{
free(output_buf);
return( ret );
}
free(output_buf);
return( 0 );
}
#endif /* MBEDTLS_PEM_WRITE_C */
#endif /* MBEDTLS_PK_WRITE_C */
| 24,438 | 685 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/cipher_wrap.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:4;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright The Mbed TLS Contributors â
â â
â Licensed under the Apache License, Version 2.0 (the "License"); â
â you may not use this file except in compliance with the License. â
â You may obtain a copy of the License at â
â â
â http://www.apache.org/licenses/LICENSE-2.0 â
â â
â Unless required by applicable law or agreed to in writing, software â
â distributed under the License is distributed on an "AS IS" BASIS, â
â WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. â
â See the License for the specific language governing permissions and â
â limitations under the License. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/mem/mem.h"
#include "third_party/mbedtls/aes.h"
#include "third_party/mbedtls/ccm.h"
#include "third_party/mbedtls/chacha20.h"
#include "third_party/mbedtls/chachapoly.h"
#include "third_party/mbedtls/cipher_internal.h"
#include "third_party/mbedtls/common.h"
#include "third_party/mbedtls/des.h"
#include "third_party/mbedtls/error.h"
#include "third_party/mbedtls/gcm.h"
#include "third_party/mbedtls/nist_kw.h"
#include "third_party/mbedtls/platform.h"
asm(".ident\t\"\\n\\n\
Mbed TLS (Apache 2.0)\\n\
Copyright ARM Limited\\n\
Copyright Mbed TLS Contributors\"");
asm(".include \"libc/disclaimer.inc\"");
/* clang-format off */
#if defined(MBEDTLS_CIPHER_C)
#if defined(MBEDTLS_GCM_C)
/* shared by all GCM ciphers */
static void *gcm_ctx_alloc( void )
{
void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_gcm_context ) );
if( ctx )
mbedtls_gcm_init( (mbedtls_gcm_context *) ctx );
return( ctx );
}
static void gcm_ctx_free( void *ctx )
{
mbedtls_gcm_free( ctx );
mbedtls_free( ctx );
}
#endif /* MBEDTLS_GCM_C */
#if defined(MBEDTLS_CCM_C)
/* shared by all CCM ciphers */
static void *ccm_ctx_alloc( void )
{
void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_ccm_context ) );
if( ctx )
mbedtls_ccm_init( (mbedtls_ccm_context *) ctx );
return( ctx );
}
static void ccm_ctx_free( void *ctx )
{
mbedtls_ccm_free( ctx );
mbedtls_free( ctx );
}
#endif /* MBEDTLS_CCM_C */
#if defined(MBEDTLS_AES_C)
#if defined(MBEDTLS_CIPHER_MODE_CFB)
static int aes_crypt_cfb128_wrap( void *ctx, mbedtls_operation_t operation,
size_t length, size_t *iv_off, unsigned char *iv,
const unsigned char *input, unsigned char *output )
{
return mbedtls_aes_crypt_cfb128( (mbedtls_aes_context *) ctx, operation, length, iv_off, iv,
input, output );
}
#endif /* MBEDTLS_CIPHER_MODE_CFB */
#if defined(MBEDTLS_CIPHER_MODE_OFB)
static int aes_crypt_ofb_wrap( void *ctx, size_t length, size_t *iv_off,
unsigned char *iv, const unsigned char *input, unsigned char *output )
{
return mbedtls_aes_crypt_ofb( (mbedtls_aes_context *) ctx, length, iv_off,
iv, input, output );
}
#endif /* MBEDTLS_CIPHER_MODE_OFB */
#if defined(MBEDTLS_CIPHER_MODE_CTR)
static int aes_crypt_ctr_wrap( void *ctx, size_t length, size_t *nc_off,
unsigned char *nonce_counter, unsigned char *stream_block,
const unsigned char *input, unsigned char *output )
{
return mbedtls_aes_crypt_ctr( (mbedtls_aes_context *) ctx, length, nc_off, nonce_counter,
stream_block, input, output );
}
#endif /* MBEDTLS_CIPHER_MODE_CTR */
#if defined(MBEDTLS_CIPHER_MODE_XTS)
static int aes_crypt_xts_wrap( void *ctx, mbedtls_operation_t operation,
size_t length,
const unsigned char data_unit[16],
const unsigned char *input,
unsigned char *output )
{
mbedtls_aes_xts_context *xts_ctx = ctx;
int mode;
switch( operation )
{
case MBEDTLS_ENCRYPT:
mode = MBEDTLS_AES_ENCRYPT;
break;
case MBEDTLS_DECRYPT:
mode = MBEDTLS_AES_DECRYPT;
break;
default:
return MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA;
}
return mbedtls_aes_crypt_xts( xts_ctx, mode, length,
data_unit, input, output );
}
#endif /* MBEDTLS_CIPHER_MODE_XTS */
static int aes_setkey_dec_wrap( void *ctx, const unsigned char *key,
unsigned int key_bitlen )
{
return mbedtls_aes_setkey_dec( (mbedtls_aes_context *) ctx, key, key_bitlen );
}
static int aes_setkey_enc_wrap( void *ctx, const unsigned char *key,
unsigned int key_bitlen )
{
return mbedtls_aes_setkey_enc( (mbedtls_aes_context *) ctx, key, key_bitlen );
}
static void * aes_ctx_alloc( void )
{
mbedtls_aes_context *aes = mbedtls_calloc( 1, sizeof( mbedtls_aes_context ) );
if( !aes )
return( NULL );
mbedtls_aes_init( aes );
return( aes );
}
static void aes_ctx_free( void *ctx )
{
mbedtls_aes_free( (mbedtls_aes_context *) ctx );
mbedtls_free( ctx );
}
static const mbedtls_cipher_base_t aes_info = {
MBEDTLS_CIPHER_ID_AES,
(void *)mbedtls_aes_crypt_ecb,
#if defined(MBEDTLS_CIPHER_MODE_CBC)
(void *)mbedtls_aes_crypt_cbc,
#endif
#if defined(MBEDTLS_CIPHER_MODE_CFB)
aes_crypt_cfb128_wrap,
#endif
#if defined(MBEDTLS_CIPHER_MODE_OFB)
aes_crypt_ofb_wrap,
#endif
#if defined(MBEDTLS_CIPHER_MODE_CTR)
aes_crypt_ctr_wrap,
#endif
#if defined(MBEDTLS_CIPHER_MODE_XTS)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_STREAM)
NULL,
#endif
aes_setkey_enc_wrap,
aes_setkey_dec_wrap,
aes_ctx_alloc,
aes_ctx_free
};
static const mbedtls_cipher_info_t aes_128_ecb_info = {
MBEDTLS_CIPHER_AES_128_ECB,
MBEDTLS_MODE_ECB,
128,
"AES-128-ECB",
0,
0,
16,
&aes_info
};
static const mbedtls_cipher_info_t aes_192_ecb_info = {
MBEDTLS_CIPHER_AES_192_ECB,
MBEDTLS_MODE_ECB,
192,
"AES-192-ECB",
0,
0,
16,
&aes_info
};
static const mbedtls_cipher_info_t aes_256_ecb_info = {
MBEDTLS_CIPHER_AES_256_ECB,
MBEDTLS_MODE_ECB,
256,
"AES-256-ECB",
0,
0,
16,
&aes_info
};
#if defined(MBEDTLS_CIPHER_MODE_CBC)
static const mbedtls_cipher_info_t aes_128_cbc_info = {
MBEDTLS_CIPHER_AES_128_CBC,
MBEDTLS_MODE_CBC,
128,
"AES-128-CBC",
16,
0,
16,
&aes_info
};
static const mbedtls_cipher_info_t aes_192_cbc_info = {
MBEDTLS_CIPHER_AES_192_CBC,
MBEDTLS_MODE_CBC,
192,
"AES-192-CBC",
16,
0,
16,
&aes_info
};
static const mbedtls_cipher_info_t aes_256_cbc_info = {
MBEDTLS_CIPHER_AES_256_CBC,
MBEDTLS_MODE_CBC,
256,
"AES-256-CBC",
16,
0,
16,
&aes_info
};
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#if defined(MBEDTLS_CIPHER_MODE_CFB)
static const mbedtls_cipher_info_t aes_128_cfb128_info = {
MBEDTLS_CIPHER_AES_128_CFB128,
MBEDTLS_MODE_CFB,
128,
"AES-128-CFB128",
16,
0,
16,
&aes_info
};
static const mbedtls_cipher_info_t aes_192_cfb128_info = {
MBEDTLS_CIPHER_AES_192_CFB128,
MBEDTLS_MODE_CFB,
192,
"AES-192-CFB128",
16,
0,
16,
&aes_info
};
static const mbedtls_cipher_info_t aes_256_cfb128_info = {
MBEDTLS_CIPHER_AES_256_CFB128,
MBEDTLS_MODE_CFB,
256,
"AES-256-CFB128",
16,
0,
16,
&aes_info
};
#endif /* MBEDTLS_CIPHER_MODE_CFB */
#if defined(MBEDTLS_CIPHER_MODE_OFB)
static const mbedtls_cipher_info_t aes_128_ofb_info = {
MBEDTLS_CIPHER_AES_128_OFB,
MBEDTLS_MODE_OFB,
128,
"AES-128-OFB",
16,
0,
16,
&aes_info
};
static const mbedtls_cipher_info_t aes_192_ofb_info = {
MBEDTLS_CIPHER_AES_192_OFB,
MBEDTLS_MODE_OFB,
192,
"AES-192-OFB",
16,
0,
16,
&aes_info
};
static const mbedtls_cipher_info_t aes_256_ofb_info = {
MBEDTLS_CIPHER_AES_256_OFB,
MBEDTLS_MODE_OFB,
256,
"AES-256-OFB",
16,
0,
16,
&aes_info
};
#endif /* MBEDTLS_CIPHER_MODE_OFB */
#if defined(MBEDTLS_CIPHER_MODE_CTR)
static const mbedtls_cipher_info_t aes_128_ctr_info = {
MBEDTLS_CIPHER_AES_128_CTR,
MBEDTLS_MODE_CTR,
128,
"AES-128-CTR",
16,
0,
16,
&aes_info
};
static const mbedtls_cipher_info_t aes_192_ctr_info = {
MBEDTLS_CIPHER_AES_192_CTR,
MBEDTLS_MODE_CTR,
192,
"AES-192-CTR",
16,
0,
16,
&aes_info
};
static const mbedtls_cipher_info_t aes_256_ctr_info = {
MBEDTLS_CIPHER_AES_256_CTR,
MBEDTLS_MODE_CTR,
256,
"AES-256-CTR",
16,
0,
16,
&aes_info
};
#endif /* MBEDTLS_CIPHER_MODE_CTR */
#if defined(MBEDTLS_CIPHER_MODE_XTS)
static int xts_aes_setkey_enc_wrap( void *ctx, const unsigned char *key,
unsigned int key_bitlen )
{
mbedtls_aes_xts_context *xts_ctx = ctx;
return( mbedtls_aes_xts_setkey_enc( xts_ctx, key, key_bitlen ) );
}
static int xts_aes_setkey_dec_wrap( void *ctx, const unsigned char *key,
unsigned int key_bitlen )
{
mbedtls_aes_xts_context *xts_ctx = ctx;
return( mbedtls_aes_xts_setkey_dec( xts_ctx, key, key_bitlen ) );
}
static void *xts_aes_ctx_alloc( void )
{
mbedtls_aes_xts_context *xts_ctx = mbedtls_calloc( 1, sizeof( *xts_ctx ) );
if( xts_ctx != NULL )
mbedtls_aes_xts_init( xts_ctx );
return( xts_ctx );
}
static void xts_aes_ctx_free( void *ctx )
{
mbedtls_aes_xts_context *xts_ctx = ctx;
if( xts_ctx == NULL )
return;
mbedtls_aes_xts_free( xts_ctx );
mbedtls_free( xts_ctx );
}
static const mbedtls_cipher_base_t xts_aes_info = {
MBEDTLS_CIPHER_ID_AES,
NULL,
#if defined(MBEDTLS_CIPHER_MODE_CBC)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_CFB)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_OFB)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_CTR)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_XTS)
aes_crypt_xts_wrap,
#endif
#if defined(MBEDTLS_CIPHER_MODE_STREAM)
NULL,
#endif
xts_aes_setkey_enc_wrap,
xts_aes_setkey_dec_wrap,
xts_aes_ctx_alloc,
xts_aes_ctx_free
};
static const mbedtls_cipher_info_t aes_128_xts_info = {
MBEDTLS_CIPHER_AES_128_XTS,
MBEDTLS_MODE_XTS,
256,
"AES-128-XTS",
16,
0,
16,
&xts_aes_info
};
static const mbedtls_cipher_info_t aes_256_xts_info = {
MBEDTLS_CIPHER_AES_256_XTS,
MBEDTLS_MODE_XTS,
512,
"AES-256-XTS",
16,
0,
16,
&xts_aes_info
};
#endif /* MBEDTLS_CIPHER_MODE_XTS */
#if defined(MBEDTLS_GCM_C)
static int gcm_aes_setkey_wrap( void *ctx, const unsigned char *key,
unsigned int key_bitlen )
{
return mbedtls_gcm_setkey( (mbedtls_gcm_context *) ctx, MBEDTLS_CIPHER_ID_AES,
key, key_bitlen );
}
static const mbedtls_cipher_base_t gcm_aes_info = {
MBEDTLS_CIPHER_ID_AES,
NULL,
#if defined(MBEDTLS_CIPHER_MODE_CBC)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_CFB)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_OFB)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_CTR)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_XTS)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_STREAM)
NULL,
#endif
gcm_aes_setkey_wrap,
gcm_aes_setkey_wrap,
gcm_ctx_alloc,
gcm_ctx_free,
};
static const mbedtls_cipher_info_t aes_128_gcm_info = {
MBEDTLS_CIPHER_AES_128_GCM,
MBEDTLS_MODE_GCM,
128,
"AES-128-GCM",
12,
MBEDTLS_CIPHER_VARIABLE_IV_LEN,
16,
&gcm_aes_info
};
static const mbedtls_cipher_info_t aes_192_gcm_info = {
MBEDTLS_CIPHER_AES_192_GCM,
MBEDTLS_MODE_GCM,
192,
"AES-192-GCM",
12,
MBEDTLS_CIPHER_VARIABLE_IV_LEN,
16,
&gcm_aes_info
};
static const mbedtls_cipher_info_t aes_256_gcm_info = {
MBEDTLS_CIPHER_AES_256_GCM,
MBEDTLS_MODE_GCM,
256,
"AES-256-GCM",
12,
MBEDTLS_CIPHER_VARIABLE_IV_LEN,
16,
&gcm_aes_info
};
#endif /* MBEDTLS_GCM_C */
#if defined(MBEDTLS_CCM_C)
static int ccm_aes_setkey_wrap( void *ctx, const unsigned char *key,
unsigned int key_bitlen )
{
return mbedtls_ccm_setkey( (mbedtls_ccm_context *) ctx, MBEDTLS_CIPHER_ID_AES,
key, key_bitlen );
}
static const mbedtls_cipher_base_t ccm_aes_info = {
MBEDTLS_CIPHER_ID_AES,
NULL,
#if defined(MBEDTLS_CIPHER_MODE_CBC)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_CFB)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_OFB)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_CTR)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_XTS)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_STREAM)
NULL,
#endif
ccm_aes_setkey_wrap,
ccm_aes_setkey_wrap,
ccm_ctx_alloc,
ccm_ctx_free,
};
static const mbedtls_cipher_info_t aes_128_ccm_info = {
MBEDTLS_CIPHER_AES_128_CCM,
MBEDTLS_MODE_CCM,
128,
"AES-128-CCM",
12,
MBEDTLS_CIPHER_VARIABLE_IV_LEN,
16,
&ccm_aes_info
};
static const mbedtls_cipher_info_t aes_192_ccm_info = {
MBEDTLS_CIPHER_AES_192_CCM,
MBEDTLS_MODE_CCM,
192,
"AES-192-CCM",
12,
MBEDTLS_CIPHER_VARIABLE_IV_LEN,
16,
&ccm_aes_info
};
static const mbedtls_cipher_info_t aes_256_ccm_info = {
MBEDTLS_CIPHER_AES_256_CCM,
MBEDTLS_MODE_CCM,
256,
"AES-256-CCM",
12,
MBEDTLS_CIPHER_VARIABLE_IV_LEN,
16,
&ccm_aes_info
};
#endif /* MBEDTLS_CCM_C */
#endif /* MBEDTLS_AES_C */
#if defined(MBEDTLS_DES_C)
static int des_crypt_ecb_wrap( void *ctx, mbedtls_operation_t operation,
const unsigned char *input, unsigned char *output )
{
((void) operation);
return mbedtls_des_crypt_ecb( (mbedtls_des_context *) ctx, input, output );
}
static int des3_crypt_ecb_wrap( void *ctx, mbedtls_operation_t operation,
const unsigned char *input, unsigned char *output )
{
((void) operation);
return mbedtls_des3_crypt_ecb( (mbedtls_des3_context *) ctx, input, output );
}
#if defined(MBEDTLS_CIPHER_MODE_CBC)
static int des_crypt_cbc_wrap( void *ctx, mbedtls_operation_t operation, size_t length,
unsigned char *iv, const unsigned char *input, unsigned char *output )
{
return mbedtls_des_crypt_cbc( (mbedtls_des_context *) ctx, operation, length, iv, input,
output );
}
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#if defined(MBEDTLS_CIPHER_MODE_CBC)
static int des3_crypt_cbc_wrap( void *ctx, mbedtls_operation_t operation, size_t length,
unsigned char *iv, const unsigned char *input, unsigned char *output )
{
return mbedtls_des3_crypt_cbc( (mbedtls_des3_context *) ctx, operation, length, iv, input,
output );
}
#endif /* MBEDTLS_CIPHER_MODE_CBC */
static int des_setkey_dec_wrap( void *ctx, const unsigned char *key,
unsigned int key_bitlen )
{
((void) key_bitlen);
return mbedtls_des_setkey_dec( (mbedtls_des_context *) ctx, key );
}
static int des_setkey_enc_wrap( void *ctx, const unsigned char *key,
unsigned int key_bitlen )
{
((void) key_bitlen);
return mbedtls_des_setkey_enc( (mbedtls_des_context *) ctx, key );
}
static int des3_set2key_dec_wrap( void *ctx, const unsigned char *key,
unsigned int key_bitlen )
{
((void) key_bitlen);
return mbedtls_des3_set2key_dec( (mbedtls_des3_context *) ctx, key );
}
static int des3_set2key_enc_wrap( void *ctx, const unsigned char *key,
unsigned int key_bitlen )
{
((void) key_bitlen);
return mbedtls_des3_set2key_enc( (mbedtls_des3_context *) ctx, key );
}
static int des3_set3key_dec_wrap( void *ctx, const unsigned char *key,
unsigned int key_bitlen )
{
((void) key_bitlen);
return mbedtls_des3_set3key_dec( (mbedtls_des3_context *) ctx, key );
}
static int des3_set3key_enc_wrap( void *ctx, const unsigned char *key,
unsigned int key_bitlen )
{
((void) key_bitlen);
return mbedtls_des3_set3key_enc( (mbedtls_des3_context *) ctx, key );
}
static void * des_ctx_alloc( void )
{
mbedtls_des_context *des = mbedtls_calloc( 1, sizeof( mbedtls_des_context ) );
if( des == NULL )
return( NULL );
mbedtls_des_init( des );
return( des );
}
static void des_ctx_free( void *ctx )
{
mbedtls_des_free( (mbedtls_des_context *) ctx );
mbedtls_free( ctx );
}
static void * des3_ctx_alloc( void )
{
mbedtls_des3_context *des3;
des3 = mbedtls_calloc( 1, sizeof( mbedtls_des3_context ) );
if( des3 == NULL )
return( NULL );
mbedtls_des3_init( des3 );
return( des3 );
}
static void des3_ctx_free( void *ctx )
{
mbedtls_des3_free( (mbedtls_des3_context *) ctx );
mbedtls_free( ctx );
}
static const mbedtls_cipher_base_t des_info = {
MBEDTLS_CIPHER_ID_DES,
des_crypt_ecb_wrap,
#if defined(MBEDTLS_CIPHER_MODE_CBC)
des_crypt_cbc_wrap,
#endif
#if defined(MBEDTLS_CIPHER_MODE_CFB)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_OFB)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_CTR)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_XTS)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_STREAM)
NULL,
#endif
des_setkey_enc_wrap,
des_setkey_dec_wrap,
des_ctx_alloc,
des_ctx_free
};
static const mbedtls_cipher_info_t des_ecb_info = {
MBEDTLS_CIPHER_DES_ECB,
MBEDTLS_MODE_ECB,
MBEDTLS_KEY_LENGTH_DES,
"DES-ECB",
0,
0,
8,
&des_info
};
#if defined(MBEDTLS_CIPHER_MODE_CBC)
static const mbedtls_cipher_info_t des_cbc_info = {
MBEDTLS_CIPHER_DES_CBC,
MBEDTLS_MODE_CBC,
MBEDTLS_KEY_LENGTH_DES,
"DES-CBC",
8,
0,
8,
&des_info
};
#endif /* MBEDTLS_CIPHER_MODE_CBC */
static const mbedtls_cipher_base_t des_ede_info = {
MBEDTLS_CIPHER_ID_DES,
des3_crypt_ecb_wrap,
#if defined(MBEDTLS_CIPHER_MODE_CBC)
des3_crypt_cbc_wrap,
#endif
#if defined(MBEDTLS_CIPHER_MODE_CFB)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_OFB)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_CTR)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_XTS)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_STREAM)
NULL,
#endif
des3_set2key_enc_wrap,
des3_set2key_dec_wrap,
des3_ctx_alloc,
des3_ctx_free
};
static const mbedtls_cipher_info_t des_ede_ecb_info = {
MBEDTLS_CIPHER_DES_EDE_ECB,
MBEDTLS_MODE_ECB,
MBEDTLS_KEY_LENGTH_DES_EDE,
"DES-EDE-ECB",
0,
0,
8,
&des_ede_info
};
#if defined(MBEDTLS_CIPHER_MODE_CBC)
static const mbedtls_cipher_info_t des_ede_cbc_info = {
MBEDTLS_CIPHER_DES_EDE_CBC,
MBEDTLS_MODE_CBC,
MBEDTLS_KEY_LENGTH_DES_EDE,
"DES-EDE-CBC",
8,
0,
8,
&des_ede_info
};
#endif /* MBEDTLS_CIPHER_MODE_CBC */
static const mbedtls_cipher_base_t des_ede3_info = {
MBEDTLS_CIPHER_ID_3DES,
des3_crypt_ecb_wrap,
#if defined(MBEDTLS_CIPHER_MODE_CBC)
des3_crypt_cbc_wrap,
#endif
#if defined(MBEDTLS_CIPHER_MODE_CFB)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_OFB)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_CTR)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_XTS)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_STREAM)
NULL,
#endif
des3_set3key_enc_wrap,
des3_set3key_dec_wrap,
des3_ctx_alloc,
des3_ctx_free
};
static const mbedtls_cipher_info_t des_ede3_ecb_info = {
MBEDTLS_CIPHER_DES_EDE3_ECB,
MBEDTLS_MODE_ECB,
MBEDTLS_KEY_LENGTH_DES_EDE3,
"DES-EDE3-ECB",
0,
0,
8,
&des_ede3_info
};
#if defined(MBEDTLS_CIPHER_MODE_CBC)
static const mbedtls_cipher_info_t des_ede3_cbc_info = {
MBEDTLS_CIPHER_DES_EDE3_CBC,
MBEDTLS_MODE_CBC,
MBEDTLS_KEY_LENGTH_DES_EDE3,
"DES-EDE3-CBC",
8,
0,
8,
&des_ede3_info
};
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#endif /* MBEDTLS_DES_C */
#if defined(MBEDTLS_BLOWFISH_C)
static int blowfish_crypt_ecb_wrap( void *ctx, mbedtls_operation_t operation,
const unsigned char *input, unsigned char *output )
{
return mbedtls_blowfish_crypt_ecb( (mbedtls_blowfish_context *) ctx, operation, input,
output );
}
#if defined(MBEDTLS_CIPHER_MODE_CBC)
static int blowfish_crypt_cbc_wrap( void *ctx, mbedtls_operation_t operation,
size_t length, unsigned char *iv, const unsigned char *input,
unsigned char *output )
{
return mbedtls_blowfish_crypt_cbc( (mbedtls_blowfish_context *) ctx, operation, length, iv,
input, output );
}
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#if defined(MBEDTLS_CIPHER_MODE_CFB)
static int blowfish_crypt_cfb64_wrap( void *ctx, mbedtls_operation_t operation,
size_t length, size_t *iv_off, unsigned char *iv,
const unsigned char *input, unsigned char *output )
{
return mbedtls_blowfish_crypt_cfb64( (mbedtls_blowfish_context *) ctx, operation, length,
iv_off, iv, input, output );
}
#endif /* MBEDTLS_CIPHER_MODE_CFB */
#if defined(MBEDTLS_CIPHER_MODE_CTR)
static int blowfish_crypt_ctr_wrap( void *ctx, size_t length, size_t *nc_off,
unsigned char *nonce_counter, unsigned char *stream_block,
const unsigned char *input, unsigned char *output )
{
return mbedtls_blowfish_crypt_ctr( (mbedtls_blowfish_context *) ctx, length, nc_off,
nonce_counter, stream_block, input, output );
}
#endif /* MBEDTLS_CIPHER_MODE_CTR */
static int blowfish_setkey_wrap( void *ctx, const unsigned char *key,
unsigned int key_bitlen )
{
return mbedtls_blowfish_setkey( (mbedtls_blowfish_context *) ctx, key, key_bitlen );
}
static void * blowfish_ctx_alloc( void )
{
mbedtls_blowfish_context *ctx;
ctx = mbedtls_calloc( 1, sizeof( mbedtls_blowfish_context ) );
if( ctx == NULL )
return( NULL );
mbedtls_blowfish_init( ctx );
return( ctx );
}
static void blowfish_ctx_free( void *ctx )
{
mbedtls_blowfish_free( (mbedtls_blowfish_context *) ctx );
mbedtls_free( ctx );
}
static const mbedtls_cipher_base_t blowfish_info = {
MBEDTLS_CIPHER_ID_BLOWFISH,
blowfish_crypt_ecb_wrap,
#if defined(MBEDTLS_CIPHER_MODE_CBC)
blowfish_crypt_cbc_wrap,
#endif
#if defined(MBEDTLS_CIPHER_MODE_CFB)
blowfish_crypt_cfb64_wrap,
#endif
#if defined(MBEDTLS_CIPHER_MODE_OFB)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_CTR)
blowfish_crypt_ctr_wrap,
#endif
#if defined(MBEDTLS_CIPHER_MODE_XTS)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_STREAM)
NULL,
#endif
blowfish_setkey_wrap,
blowfish_setkey_wrap,
blowfish_ctx_alloc,
blowfish_ctx_free
};
static const mbedtls_cipher_info_t blowfish_ecb_info = {
MBEDTLS_CIPHER_BLOWFISH_ECB,
MBEDTLS_MODE_ECB,
128,
"BLOWFISH-ECB",
0,
MBEDTLS_CIPHER_VARIABLE_KEY_LEN,
8,
&blowfish_info
};
#if defined(MBEDTLS_CIPHER_MODE_CBC)
static const mbedtls_cipher_info_t blowfish_cbc_info = {
MBEDTLS_CIPHER_BLOWFISH_CBC,
MBEDTLS_MODE_CBC,
128,
"BLOWFISH-CBC",
8,
MBEDTLS_CIPHER_VARIABLE_KEY_LEN,
8,
&blowfish_info
};
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#if defined(MBEDTLS_CIPHER_MODE_CFB)
static const mbedtls_cipher_info_t blowfish_cfb64_info = {
MBEDTLS_CIPHER_BLOWFISH_CFB64,
MBEDTLS_MODE_CFB,
128,
"BLOWFISH-CFB64",
8,
MBEDTLS_CIPHER_VARIABLE_KEY_LEN,
8,
&blowfish_info
};
#endif /* MBEDTLS_CIPHER_MODE_CFB */
#if defined(MBEDTLS_CIPHER_MODE_CTR)
static const mbedtls_cipher_info_t blowfish_ctr_info = {
MBEDTLS_CIPHER_BLOWFISH_CTR,
MBEDTLS_MODE_CTR,
128,
"BLOWFISH-CTR",
8,
MBEDTLS_CIPHER_VARIABLE_KEY_LEN,
8,
&blowfish_info
};
#endif /* MBEDTLS_CIPHER_MODE_CTR */
#endif /* MBEDTLS_BLOWFISH_C */
#if defined(MBEDTLS_CHACHA20_C)
static int chacha20_setkey_wrap( void *ctx, const unsigned char *key,
unsigned int key_bitlen )
{
if( key_bitlen != 256U )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
if ( 0 != mbedtls_chacha20_setkey( (mbedtls_chacha20_context*)ctx, key ) )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
return( 0 );
}
static int chacha20_stream_wrap( void *ctx, size_t length,
const unsigned char *input,
unsigned char *output )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
ret = mbedtls_chacha20_update( ctx, length, input, output );
if( ret == MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
return( ret );
}
static void * chacha20_ctx_alloc( void )
{
mbedtls_chacha20_context *ctx;
ctx = mbedtls_calloc( 1, sizeof( mbedtls_chacha20_context ) );
if( ctx == NULL )
return( NULL );
mbedtls_chacha20_init( ctx );
return( ctx );
}
static void chacha20_ctx_free( void *ctx )
{
mbedtls_chacha20_free( (mbedtls_chacha20_context *) ctx );
mbedtls_free( ctx );
}
static const mbedtls_cipher_base_t chacha20_base_info = {
MBEDTLS_CIPHER_ID_CHACHA20,
NULL,
#if defined(MBEDTLS_CIPHER_MODE_CBC)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_CFB)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_OFB)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_CTR)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_XTS)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_STREAM)
chacha20_stream_wrap,
#endif
chacha20_setkey_wrap,
chacha20_setkey_wrap,
chacha20_ctx_alloc,
chacha20_ctx_free
};
static const mbedtls_cipher_info_t chacha20_info = {
MBEDTLS_CIPHER_CHACHA20,
MBEDTLS_MODE_STREAM,
256,
"CHACHA20",
12,
0,
1,
&chacha20_base_info
};
#endif /* MBEDTLS_CHACHA20_C */
#if defined(MBEDTLS_CHACHAPOLY_C)
static int chachapoly_setkey_wrap( void *ctx,
const unsigned char *key,
unsigned int key_bitlen )
{
if( key_bitlen != 256U )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
if ( 0 != mbedtls_chachapoly_setkey( (mbedtls_chachapoly_context*)ctx, key ) )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
return( 0 );
}
static void * chachapoly_ctx_alloc( void )
{
mbedtls_chachapoly_context *ctx;
ctx = mbedtls_calloc( 1, sizeof( mbedtls_chachapoly_context ) );
if( ctx == NULL )
return( NULL );
mbedtls_chachapoly_init( ctx );
return( ctx );
}
static void chachapoly_ctx_free( void *ctx )
{
mbedtls_chachapoly_free( (mbedtls_chachapoly_context *) ctx );
mbedtls_free( ctx );
}
static const mbedtls_cipher_base_t chachapoly_base_info = {
MBEDTLS_CIPHER_ID_CHACHA20,
NULL,
#if defined(MBEDTLS_CIPHER_MODE_CBC)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_CFB)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_OFB)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_CTR)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_XTS)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_STREAM)
NULL,
#endif
chachapoly_setkey_wrap,
chachapoly_setkey_wrap,
chachapoly_ctx_alloc,
chachapoly_ctx_free
};
static const mbedtls_cipher_info_t chachapoly_info = {
MBEDTLS_CIPHER_CHACHA20_POLY1305,
MBEDTLS_MODE_CHACHAPOLY,
256,
"CHACHA20-POLY1305",
12,
0,
1,
&chachapoly_base_info
};
#endif /* MBEDTLS_CHACHAPOLY_C */
#if defined(MBEDTLS_CIPHER_NULL_CIPHER)
static int null_crypt_stream( void *ctx, size_t length,
const unsigned char *input,
unsigned char *output )
{
((void) ctx);
memmove( output, input, length );
return( 0 );
}
static int null_setkey( void *ctx, const unsigned char *key,
unsigned int key_bitlen )
{
((void) ctx);
((void) key);
((void) key_bitlen);
return( 0 );
}
static void * null_ctx_alloc( void )
{
return( (void *) 1 );
}
static void null_ctx_free( void *ctx )
{
((void) ctx);
}
static const mbedtls_cipher_base_t null_base_info = {
MBEDTLS_CIPHER_ID_NULL,
NULL,
#if defined(MBEDTLS_CIPHER_MODE_CBC)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_CFB)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_OFB)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_CTR)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_XTS)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_STREAM)
null_crypt_stream,
#endif
null_setkey,
null_setkey,
null_ctx_alloc,
null_ctx_free
};
static const mbedtls_cipher_info_t null_cipher_info = {
MBEDTLS_CIPHER_NULL,
MBEDTLS_MODE_STREAM,
0,
"NULL",
0,
0,
1,
&null_base_info
};
#endif /* defined(MBEDTLS_CIPHER_NULL_CIPHER) */
#if defined(MBEDTLS_NIST_KW_C)
static void *kw_ctx_alloc( void )
{
void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_nist_kw_context ) );
if( ctx != NULL )
mbedtls_nist_kw_init( (mbedtls_nist_kw_context *) ctx );
return( ctx );
}
static void kw_ctx_free( void *ctx )
{
mbedtls_nist_kw_free( ctx );
mbedtls_free( ctx );
}
static int kw_aes_setkey_wrap( void *ctx, const unsigned char *key,
unsigned int key_bitlen )
{
return mbedtls_nist_kw_setkey( (mbedtls_nist_kw_context *) ctx,
MBEDTLS_CIPHER_ID_AES, key, key_bitlen, 1 );
}
static int kw_aes_setkey_unwrap( void *ctx, const unsigned char *key,
unsigned int key_bitlen )
{
return mbedtls_nist_kw_setkey( (mbedtls_nist_kw_context *) ctx,
MBEDTLS_CIPHER_ID_AES, key, key_bitlen, 0 );
}
static const mbedtls_cipher_base_t kw_aes_info = {
MBEDTLS_CIPHER_ID_AES,
NULL,
#if defined(MBEDTLS_CIPHER_MODE_CBC)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_CFB)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_OFB)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_CTR)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_XTS)
NULL,
#endif
#if defined(MBEDTLS_CIPHER_MODE_STREAM)
NULL,
#endif
kw_aes_setkey_wrap,
kw_aes_setkey_unwrap,
kw_ctx_alloc,
kw_ctx_free,
};
static const mbedtls_cipher_info_t aes_128_nist_kw_info = {
MBEDTLS_CIPHER_AES_128_KW,
MBEDTLS_MODE_KW,
128,
"AES-128-KW",
0,
0,
16,
&kw_aes_info
};
static const mbedtls_cipher_info_t aes_192_nist_kw_info = {
MBEDTLS_CIPHER_AES_192_KW,
MBEDTLS_MODE_KW,
192,
"AES-192-KW",
0,
0,
16,
&kw_aes_info
};
static const mbedtls_cipher_info_t aes_256_nist_kw_info = {
MBEDTLS_CIPHER_AES_256_KW,
MBEDTLS_MODE_KW,
256,
"AES-256-KW",
0,
0,
16,
&kw_aes_info
};
static const mbedtls_cipher_info_t aes_128_nist_kwp_info = {
MBEDTLS_CIPHER_AES_128_KWP,
MBEDTLS_MODE_KWP,
128,
"AES-128-KWP",
0,
0,
16,
&kw_aes_info
};
static const mbedtls_cipher_info_t aes_192_nist_kwp_info = {
MBEDTLS_CIPHER_AES_192_KWP,
MBEDTLS_MODE_KWP,
192,
"AES-192-KWP",
0,
0,
16,
&kw_aes_info
};
static const mbedtls_cipher_info_t aes_256_nist_kwp_info = {
MBEDTLS_CIPHER_AES_256_KWP,
MBEDTLS_MODE_KWP,
256,
"AES-256-KWP",
0,
0,
16,
&kw_aes_info
};
#endif /* MBEDTLS_NIST_KW_C */
const mbedtls_cipher_definition_t mbedtls_cipher_definitions[] =
{
#if defined(MBEDTLS_AES_C)
{ MBEDTLS_CIPHER_AES_128_ECB, &aes_128_ecb_info },
{ MBEDTLS_CIPHER_AES_192_ECB, &aes_192_ecb_info },
{ MBEDTLS_CIPHER_AES_256_ECB, &aes_256_ecb_info },
#if defined(MBEDTLS_CIPHER_MODE_CBC)
{ MBEDTLS_CIPHER_AES_128_CBC, &aes_128_cbc_info },
{ MBEDTLS_CIPHER_AES_192_CBC, &aes_192_cbc_info },
{ MBEDTLS_CIPHER_AES_256_CBC, &aes_256_cbc_info },
#endif
#if defined(MBEDTLS_CIPHER_MODE_CFB)
{ MBEDTLS_CIPHER_AES_128_CFB128, &aes_128_cfb128_info },
{ MBEDTLS_CIPHER_AES_192_CFB128, &aes_192_cfb128_info },
{ MBEDTLS_CIPHER_AES_256_CFB128, &aes_256_cfb128_info },
#endif
#if defined(MBEDTLS_CIPHER_MODE_OFB)
{ MBEDTLS_CIPHER_AES_128_OFB, &aes_128_ofb_info },
{ MBEDTLS_CIPHER_AES_192_OFB, &aes_192_ofb_info },
{ MBEDTLS_CIPHER_AES_256_OFB, &aes_256_ofb_info },
#endif
#if defined(MBEDTLS_CIPHER_MODE_CTR)
{ MBEDTLS_CIPHER_AES_128_CTR, &aes_128_ctr_info },
{ MBEDTLS_CIPHER_AES_192_CTR, &aes_192_ctr_info },
{ MBEDTLS_CIPHER_AES_256_CTR, &aes_256_ctr_info },
#endif
#if defined(MBEDTLS_CIPHER_MODE_XTS)
{ MBEDTLS_CIPHER_AES_128_XTS, &aes_128_xts_info },
{ MBEDTLS_CIPHER_AES_256_XTS, &aes_256_xts_info },
#endif
#if defined(MBEDTLS_GCM_C)
{ MBEDTLS_CIPHER_AES_128_GCM, &aes_128_gcm_info },
{ MBEDTLS_CIPHER_AES_192_GCM, &aes_192_gcm_info },
{ MBEDTLS_CIPHER_AES_256_GCM, &aes_256_gcm_info },
#endif
#if defined(MBEDTLS_CCM_C)
{ MBEDTLS_CIPHER_AES_128_CCM, &aes_128_ccm_info },
{ MBEDTLS_CIPHER_AES_192_CCM, &aes_192_ccm_info },
{ MBEDTLS_CIPHER_AES_256_CCM, &aes_256_ccm_info },
#endif
#endif /* MBEDTLS_AES_C */
#if defined(MBEDTLS_BLOWFISH_C)
{ MBEDTLS_CIPHER_BLOWFISH_ECB, &blowfish_ecb_info },
#if defined(MBEDTLS_CIPHER_MODE_CBC)
{ MBEDTLS_CIPHER_BLOWFISH_CBC, &blowfish_cbc_info },
#endif
#if defined(MBEDTLS_CIPHER_MODE_CFB)
{ MBEDTLS_CIPHER_BLOWFISH_CFB64, &blowfish_cfb64_info },
#endif
#if defined(MBEDTLS_CIPHER_MODE_CTR)
{ MBEDTLS_CIPHER_BLOWFISH_CTR, &blowfish_ctr_info },
#endif
#endif /* MBEDTLS_BLOWFISH_C */
#if defined(MBEDTLS_CAMELLIA_C)
{ MBEDTLS_CIPHER_CAMELLIA_128_ECB, &camellia_128_ecb_info },
{ MBEDTLS_CIPHER_CAMELLIA_192_ECB, &camellia_192_ecb_info },
{ MBEDTLS_CIPHER_CAMELLIA_256_ECB, &camellia_256_ecb_info },
#if defined(MBEDTLS_CIPHER_MODE_CBC)
{ MBEDTLS_CIPHER_CAMELLIA_128_CBC, &camellia_128_cbc_info },
{ MBEDTLS_CIPHER_CAMELLIA_192_CBC, &camellia_192_cbc_info },
{ MBEDTLS_CIPHER_CAMELLIA_256_CBC, &camellia_256_cbc_info },
#endif
#if defined(MBEDTLS_CIPHER_MODE_CFB)
{ MBEDTLS_CIPHER_CAMELLIA_128_CFB128, &camellia_128_cfb128_info },
{ MBEDTLS_CIPHER_CAMELLIA_192_CFB128, &camellia_192_cfb128_info },
{ MBEDTLS_CIPHER_CAMELLIA_256_CFB128, &camellia_256_cfb128_info },
#endif
#if defined(MBEDTLS_CIPHER_MODE_CTR)
{ MBEDTLS_CIPHER_CAMELLIA_128_CTR, &camellia_128_ctr_info },
{ MBEDTLS_CIPHER_CAMELLIA_192_CTR, &camellia_192_ctr_info },
{ MBEDTLS_CIPHER_CAMELLIA_256_CTR, &camellia_256_ctr_info },
#endif
#if defined(MBEDTLS_GCM_C)
{ MBEDTLS_CIPHER_CAMELLIA_128_GCM, &camellia_128_gcm_info },
{ MBEDTLS_CIPHER_CAMELLIA_192_GCM, &camellia_192_gcm_info },
{ MBEDTLS_CIPHER_CAMELLIA_256_GCM, &camellia_256_gcm_info },
#endif
#if defined(MBEDTLS_CCM_C)
{ MBEDTLS_CIPHER_CAMELLIA_128_CCM, &camellia_128_ccm_info },
{ MBEDTLS_CIPHER_CAMELLIA_192_CCM, &camellia_192_ccm_info },
{ MBEDTLS_CIPHER_CAMELLIA_256_CCM, &camellia_256_ccm_info },
#endif
#endif /* MBEDTLS_CAMELLIA_C */
#if defined(MBEDTLS_DES_C)
{ MBEDTLS_CIPHER_DES_ECB, &des_ecb_info },
{ MBEDTLS_CIPHER_DES_EDE_ECB, &des_ede_ecb_info },
{ MBEDTLS_CIPHER_DES_EDE3_ECB, &des_ede3_ecb_info },
#if defined(MBEDTLS_CIPHER_MODE_CBC)
{ MBEDTLS_CIPHER_DES_CBC, &des_cbc_info },
{ MBEDTLS_CIPHER_DES_EDE_CBC, &des_ede_cbc_info },
{ MBEDTLS_CIPHER_DES_EDE3_CBC, &des_ede3_cbc_info },
#endif
#endif /* MBEDTLS_DES_C */
#if defined(MBEDTLS_CHACHA20_C)
{ MBEDTLS_CIPHER_CHACHA20, &chacha20_info },
#endif
#if defined(MBEDTLS_CHACHAPOLY_C)
{ MBEDTLS_CIPHER_CHACHA20_POLY1305, &chachapoly_info },
#endif
#if defined(MBEDTLS_NIST_KW_C)
{ MBEDTLS_CIPHER_AES_128_KW, &aes_128_nist_kw_info },
{ MBEDTLS_CIPHER_AES_192_KW, &aes_192_nist_kw_info },
{ MBEDTLS_CIPHER_AES_256_KW, &aes_256_nist_kw_info },
{ MBEDTLS_CIPHER_AES_128_KWP, &aes_128_nist_kwp_info },
{ MBEDTLS_CIPHER_AES_192_KWP, &aes_192_nist_kwp_info },
{ MBEDTLS_CIPHER_AES_256_KWP, &aes_256_nist_kwp_info },
#endif
#if defined(MBEDTLS_CIPHER_NULL_CIPHER)
{ MBEDTLS_CIPHER_NULL, &null_cipher_info },
#endif /* MBEDTLS_CIPHER_NULL_CIPHER */
{ MBEDTLS_CIPHER_NONE, NULL }
};
#define NUM_CIPHERS ( sizeof(mbedtls_cipher_definitions) / \
sizeof(mbedtls_cipher_definitions[0]) )
int mbedtls_cipher_supported[NUM_CIPHERS];
#endif /* MBEDTLS_CIPHER_C */
| 37,689 | 1,482 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/ssl_ciphersuites.h | #ifndef COSMOPOLITAN_THIRD_PARTY_MBEDTLS_SSL_CIPHERSUITES_H_
#define COSMOPOLITAN_THIRD_PARTY_MBEDTLS_SSL_CIPHERSUITES_H_
#include "third_party/mbedtls/cipher.h"
#include "third_party/mbedtls/config.h"
#include "third_party/mbedtls/md.h"
#include "third_party/mbedtls/pk.h"
COSMOPOLITAN_C_START_
/* clang-format off */
/*
* Supported ciphersuites (Official IANA names)
*/
#define MBEDTLS_TLS_RSA_WITH_NULL_MD5 0x0001 /*< Weak! */
#define MBEDTLS_TLS_RSA_WITH_NULL_SHA 0x0002 /*< Weak! */
#define MBEDTLS_TLS_RSA_WITH_RC4_128_MD5 0x0004
#define MBEDTLS_TLS_RSA_WITH_RC4_128_SHA 0x0005
#define MBEDTLS_TLS_RSA_WITH_DES_CBC_SHA 0x0009 /*< Weak! Not in TLS 1.2 */
#define MBEDTLS_TLS_RSA_WITH_3DES_EDE_CBC_SHA 0x000A
#define MBEDTLS_TLS_DHE_RSA_WITH_DES_CBC_SHA 0x0015 /*< Weak! Not in TLS 1.2 */
#define MBEDTLS_TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA 0x0016
#define MBEDTLS_TLS_PSK_WITH_NULL_SHA 0x002C /*< Weak! */
#define MBEDTLS_TLS_DHE_PSK_WITH_NULL_SHA 0x002D /*< Weak! */
#define MBEDTLS_TLS_RSA_PSK_WITH_NULL_SHA 0x002E /*< Weak! */
#define MBEDTLS_TLS_RSA_WITH_AES_128_CBC_SHA 0x002F
#define MBEDTLS_TLS_DHE_RSA_WITH_AES_128_CBC_SHA 0x0033
#define MBEDTLS_TLS_RSA_WITH_AES_256_CBC_SHA 0x0035
#define MBEDTLS_TLS_DHE_RSA_WITH_AES_256_CBC_SHA 0x0039
#define MBEDTLS_TLS_RSA_WITH_NULL_SHA256 0x003B /*< Weak! */
#define MBEDTLS_TLS_RSA_WITH_AES_128_CBC_SHA256 0x003C /*< TLS 1.2 */
#define MBEDTLS_TLS_RSA_WITH_AES_256_CBC_SHA256 0x003D /*< TLS 1.2 */
#define MBEDTLS_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA 0x0041
#define MBEDTLS_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA 0x0045
#define MBEDTLS_TLS_DHE_RSA_WITH_AES_128_CBC_SHA256 0x0067 /*< TLS 1.2 */
#define MBEDTLS_TLS_DHE_RSA_WITH_AES_256_CBC_SHA256 0x006B /*< TLS 1.2 */
#define MBEDTLS_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA 0x0084
#define MBEDTLS_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA 0x0088
#define MBEDTLS_TLS_PSK_WITH_RC4_128_SHA 0x008A
#define MBEDTLS_TLS_PSK_WITH_3DES_EDE_CBC_SHA 0x008B
#define MBEDTLS_TLS_PSK_WITH_AES_128_CBC_SHA 0x008C
#define MBEDTLS_TLS_PSK_WITH_AES_256_CBC_SHA 0x008D
#define MBEDTLS_TLS_DHE_PSK_WITH_RC4_128_SHA 0x008E
#define MBEDTLS_TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA 0x008F
#define MBEDTLS_TLS_DHE_PSK_WITH_AES_128_CBC_SHA 0x0090
#define MBEDTLS_TLS_DHE_PSK_WITH_AES_256_CBC_SHA 0x0091
#define MBEDTLS_TLS_RSA_PSK_WITH_RC4_128_SHA 0x0092
#define MBEDTLS_TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA 0x0093
#define MBEDTLS_TLS_RSA_PSK_WITH_AES_128_CBC_SHA 0x0094
#define MBEDTLS_TLS_RSA_PSK_WITH_AES_256_CBC_SHA 0x0095
#define MBEDTLS_TLS_RSA_WITH_AES_128_GCM_SHA256 0x009C /*< TLS 1.2 */
#define MBEDTLS_TLS_RSA_WITH_AES_256_GCM_SHA384 0x009D /*< TLS 1.2 */
#define MBEDTLS_TLS_DHE_RSA_WITH_AES_128_GCM_SHA256 0x009E /*< TLS 1.2 */
#define MBEDTLS_TLS_DHE_RSA_WITH_AES_256_GCM_SHA384 0x009F /*< TLS 1.2 */
#define MBEDTLS_TLS_PSK_WITH_AES_128_GCM_SHA256 0x00A8 /*< TLS 1.2 */
#define MBEDTLS_TLS_PSK_WITH_AES_256_GCM_SHA384 0x00A9 /*< TLS 1.2 */
#define MBEDTLS_TLS_DHE_PSK_WITH_AES_128_GCM_SHA256 0x00AA /*< TLS 1.2 */
#define MBEDTLS_TLS_DHE_PSK_WITH_AES_256_GCM_SHA384 0x00AB /*< TLS 1.2 */
#define MBEDTLS_TLS_RSA_PSK_WITH_AES_128_GCM_SHA256 0x00AC /*< TLS 1.2 */
#define MBEDTLS_TLS_RSA_PSK_WITH_AES_256_GCM_SHA384 0x00AD /*< TLS 1.2 */
#define MBEDTLS_TLS_PSK_WITH_AES_128_CBC_SHA256 0x00AE
#define MBEDTLS_TLS_PSK_WITH_AES_256_CBC_SHA384 0x00AF
#define MBEDTLS_TLS_PSK_WITH_NULL_SHA256 0x00B0 /*< Weak! */
#define MBEDTLS_TLS_PSK_WITH_NULL_SHA384 0x00B1 /*< Weak! */
#define MBEDTLS_TLS_DHE_PSK_WITH_AES_128_CBC_SHA256 0x00B2
#define MBEDTLS_TLS_DHE_PSK_WITH_AES_256_CBC_SHA384 0x00B3
#define MBEDTLS_TLS_DHE_PSK_WITH_NULL_SHA256 0x00B4 /*< Weak! */
#define MBEDTLS_TLS_DHE_PSK_WITH_NULL_SHA384 0x00B5 /*< Weak! */
#define MBEDTLS_TLS_RSA_PSK_WITH_AES_128_CBC_SHA256 0x00B6
#define MBEDTLS_TLS_RSA_PSK_WITH_AES_256_CBC_SHA384 0x00B7
#define MBEDTLS_TLS_RSA_PSK_WITH_NULL_SHA256 0x00B8 /*< Weak! */
#define MBEDTLS_TLS_RSA_PSK_WITH_NULL_SHA384 0x00B9 /*< Weak! */
#define MBEDTLS_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256 0x00BA /*< TLS 1.2 */
#define MBEDTLS_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 0x00BE /*< TLS 1.2 */
#define MBEDTLS_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256 0x00C0 /*< TLS 1.2 */
#define MBEDTLS_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256 0x00C4 /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDH_ECDSA_WITH_NULL_SHA 0xC001 /*< Weak! */
#define MBEDTLS_TLS_ECDH_ECDSA_WITH_RC4_128_SHA 0xC002 /*< Not in SSL3! */
#define MBEDTLS_TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA 0xC003 /*< Not in SSL3! */
#define MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA 0xC004 /*< Not in SSL3! */
#define MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA 0xC005 /*< Not in SSL3! */
#define MBEDTLS_TLS_ECDHE_ECDSA_WITH_NULL_SHA 0xC006 /*< Weak! */
#define MBEDTLS_TLS_ECDHE_ECDSA_WITH_RC4_128_SHA 0xC007 /*< Not in SSL3! */
#define MBEDTLS_TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA 0xC008 /*< Not in SSL3! */
#define MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA 0xC009 /*< Not in SSL3! */
#define MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA 0xC00A /*< Not in SSL3! */
#define MBEDTLS_TLS_ECDH_RSA_WITH_NULL_SHA 0xC00B /*< Weak! */
#define MBEDTLS_TLS_ECDH_RSA_WITH_RC4_128_SHA 0xC00C /*< Not in SSL3! */
#define MBEDTLS_TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA 0xC00D /*< Not in SSL3! */
#define MBEDTLS_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA 0xC00E /*< Not in SSL3! */
#define MBEDTLS_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA 0xC00F /*< Not in SSL3! */
#define MBEDTLS_TLS_ECDHE_RSA_WITH_NULL_SHA 0xC010 /*< Weak! */
#define MBEDTLS_TLS_ECDHE_RSA_WITH_RC4_128_SHA 0xC011 /*< Not in SSL3! */
#define MBEDTLS_TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA 0xC012 /*< Not in SSL3! */
#define MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA 0xC013 /*< Not in SSL3! */
#define MBEDTLS_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA 0xC014 /*< Not in SSL3! */
#define MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 0xC023 /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 0xC024 /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256 0xC025 /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384 0xC026 /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 0xC027 /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 0xC028 /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256 0xC029 /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384 0xC02A /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 0xC02B /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 0xC02C /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256 0xC02D /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384 0xC02E /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 0xC02F /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 0xC030 /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256 0xC031 /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384 0xC032 /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDHE_PSK_WITH_RC4_128_SHA 0xC033 /*< Not in SSL3! */
#define MBEDTLS_TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA 0xC034 /*< Not in SSL3! */
#define MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA 0xC035 /*< Not in SSL3! */
#define MBEDTLS_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA 0xC036 /*< Not in SSL3! */
#define MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256 0xC037 /*< Not in SSL3! */
#define MBEDTLS_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384 0xC038 /*< Not in SSL3! */
#define MBEDTLS_TLS_ECDHE_PSK_WITH_NULL_SHA 0xC039 /*< Weak! No SSL3! */
#define MBEDTLS_TLS_ECDHE_PSK_WITH_NULL_SHA256 0xC03A /*< Weak! No SSL3! */
#define MBEDTLS_TLS_ECDHE_PSK_WITH_NULL_SHA384 0xC03B /*< Weak! No SSL3! */
#define MBEDTLS_TLS_RSA_WITH_ARIA_128_CBC_SHA256 0xC03C /*< TLS 1.2 */
#define MBEDTLS_TLS_RSA_WITH_ARIA_256_CBC_SHA384 0xC03D /*< TLS 1.2 */
#define MBEDTLS_TLS_DHE_RSA_WITH_ARIA_128_CBC_SHA256 0xC044 /*< TLS 1.2 */
#define MBEDTLS_TLS_DHE_RSA_WITH_ARIA_256_CBC_SHA384 0xC045 /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDHE_ECDSA_WITH_ARIA_128_CBC_SHA256 0xC048 /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDHE_ECDSA_WITH_ARIA_256_CBC_SHA384 0xC049 /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDH_ECDSA_WITH_ARIA_128_CBC_SHA256 0xC04A /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDH_ECDSA_WITH_ARIA_256_CBC_SHA384 0xC04B /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDHE_RSA_WITH_ARIA_128_CBC_SHA256 0xC04C /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDHE_RSA_WITH_ARIA_256_CBC_SHA384 0xC04D /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDH_RSA_WITH_ARIA_128_CBC_SHA256 0xC04E /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDH_RSA_WITH_ARIA_256_CBC_SHA384 0xC04F /*< TLS 1.2 */
#define MBEDTLS_TLS_RSA_WITH_ARIA_128_GCM_SHA256 0xC050 /*< TLS 1.2 */
#define MBEDTLS_TLS_RSA_WITH_ARIA_256_GCM_SHA384 0xC051 /*< TLS 1.2 */
#define MBEDTLS_TLS_DHE_RSA_WITH_ARIA_128_GCM_SHA256 0xC052 /*< TLS 1.2 */
#define MBEDTLS_TLS_DHE_RSA_WITH_ARIA_256_GCM_SHA384 0xC053 /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256 0xC05C /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384 0xC05D /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256 0xC05E /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384 0xC05F /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256 0xC060 /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384 0xC061 /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDH_RSA_WITH_ARIA_128_GCM_SHA256 0xC062 /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDH_RSA_WITH_ARIA_256_GCM_SHA384 0xC063 /*< TLS 1.2 */
#define MBEDTLS_TLS_PSK_WITH_ARIA_128_CBC_SHA256 0xC064 /*< TLS 1.2 */
#define MBEDTLS_TLS_PSK_WITH_ARIA_256_CBC_SHA384 0xC065 /*< TLS 1.2 */
#define MBEDTLS_TLS_DHE_PSK_WITH_ARIA_128_CBC_SHA256 0xC066 /*< TLS 1.2 */
#define MBEDTLS_TLS_DHE_PSK_WITH_ARIA_256_CBC_SHA384 0xC067 /*< TLS 1.2 */
#define MBEDTLS_TLS_RSA_PSK_WITH_ARIA_128_CBC_SHA256 0xC068 /*< TLS 1.2 */
#define MBEDTLS_TLS_RSA_PSK_WITH_ARIA_256_CBC_SHA384 0xC069 /*< TLS 1.2 */
#define MBEDTLS_TLS_PSK_WITH_ARIA_128_GCM_SHA256 0xC06A /*< TLS 1.2 */
#define MBEDTLS_TLS_PSK_WITH_ARIA_256_GCM_SHA384 0xC06B /*< TLS 1.2 */
#define MBEDTLS_TLS_DHE_PSK_WITH_ARIA_128_GCM_SHA256 0xC06C /*< TLS 1.2 */
#define MBEDTLS_TLS_DHE_PSK_WITH_ARIA_256_GCM_SHA384 0xC06D /*< TLS 1.2 */
#define MBEDTLS_TLS_RSA_PSK_WITH_ARIA_128_GCM_SHA256 0xC06E /*< TLS 1.2 */
#define MBEDTLS_TLS_RSA_PSK_WITH_ARIA_256_GCM_SHA384 0xC06F /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDHE_PSK_WITH_ARIA_128_CBC_SHA256 0xC070 /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDHE_PSK_WITH_ARIA_256_CBC_SHA384 0xC071 /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 0xC072 /*< Not in SSL3! */
#define MBEDTLS_TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 0xC073 /*< Not in SSL3! */
#define MBEDTLS_TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 0xC074 /*< Not in SSL3! */
#define MBEDTLS_TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 0xC075 /*< Not in SSL3! */
#define MBEDTLS_TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 0xC076 /*< Not in SSL3! */
#define MBEDTLS_TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384 0xC077 /*< Not in SSL3! */
#define MBEDTLS_TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256 0xC078 /*< Not in SSL3! */
#define MBEDTLS_TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384 0xC079 /*< Not in SSL3! */
#define MBEDTLS_TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256 0xC07A /*< TLS 1.2 */
#define MBEDTLS_TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384 0xC07B /*< TLS 1.2 */
#define MBEDTLS_TLS_DHE_RSA_WITH_CAMELLIA_128_GCM_SHA256 0xC07C /*< TLS 1.2 */
#define MBEDTLS_TLS_DHE_RSA_WITH_CAMELLIA_256_GCM_SHA384 0xC07D /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_GCM_SHA256 0xC086 /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_GCM_SHA384 0xC087 /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDH_ECDSA_WITH_CAMELLIA_128_GCM_SHA256 0xC088 /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDH_ECDSA_WITH_CAMELLIA_256_GCM_SHA384 0xC089 /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDHE_RSA_WITH_CAMELLIA_128_GCM_SHA256 0xC08A /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDHE_RSA_WITH_CAMELLIA_256_GCM_SHA384 0xC08B /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDH_RSA_WITH_CAMELLIA_128_GCM_SHA256 0xC08C /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384 0xC08D /*< TLS 1.2 */
#define MBEDTLS_TLS_PSK_WITH_CAMELLIA_128_GCM_SHA256 0xC08E /*< TLS 1.2 */
#define MBEDTLS_TLS_PSK_WITH_CAMELLIA_256_GCM_SHA384 0xC08F /*< TLS 1.2 */
#define MBEDTLS_TLS_DHE_PSK_WITH_CAMELLIA_128_GCM_SHA256 0xC090 /*< TLS 1.2 */
#define MBEDTLS_TLS_DHE_PSK_WITH_CAMELLIA_256_GCM_SHA384 0xC091 /*< TLS 1.2 */
#define MBEDTLS_TLS_RSA_PSK_WITH_CAMELLIA_128_GCM_SHA256 0xC092 /*< TLS 1.2 */
#define MBEDTLS_TLS_RSA_PSK_WITH_CAMELLIA_256_GCM_SHA384 0xC093 /*< TLS 1.2 */
#define MBEDTLS_TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256 0xC094
#define MBEDTLS_TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384 0xC095
#define MBEDTLS_TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256 0xC096
#define MBEDTLS_TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384 0xC097
#define MBEDTLS_TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256 0xC098
#define MBEDTLS_TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384 0xC099
#define MBEDTLS_TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256 0xC09A /*< Not in SSL3! */
#define MBEDTLS_TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384 0xC09B /*< Not in SSL3! */
#define MBEDTLS_TLS_RSA_WITH_AES_128_CCM 0xC09C /*< TLS 1.2 */
#define MBEDTLS_TLS_RSA_WITH_AES_256_CCM 0xC09D /*< TLS 1.2 */
#define MBEDTLS_TLS_DHE_RSA_WITH_AES_128_CCM 0xC09E /*< TLS 1.2 */
#define MBEDTLS_TLS_DHE_RSA_WITH_AES_256_CCM 0xC09F /*< TLS 1.2 */
#define MBEDTLS_TLS_RSA_WITH_AES_128_CCM_8 0xC0A0 /*< TLS 1.2 */
#define MBEDTLS_TLS_RSA_WITH_AES_256_CCM_8 0xC0A1 /*< TLS 1.2 */
#define MBEDTLS_TLS_DHE_RSA_WITH_AES_128_CCM_8 0xC0A2 /*< TLS 1.2 */
#define MBEDTLS_TLS_DHE_RSA_WITH_AES_256_CCM_8 0xC0A3 /*< TLS 1.2 */
#define MBEDTLS_TLS_PSK_WITH_AES_128_CCM 0xC0A4 /*< TLS 1.2 */
#define MBEDTLS_TLS_PSK_WITH_AES_256_CCM 0xC0A5 /*< TLS 1.2 */
#define MBEDTLS_TLS_DHE_PSK_WITH_AES_128_CCM 0xC0A6 /*< TLS 1.2 */
#define MBEDTLS_TLS_DHE_PSK_WITH_AES_256_CCM 0xC0A7 /*< TLS 1.2 */
#define MBEDTLS_TLS_PSK_WITH_AES_128_CCM_8 0xC0A8 /*< TLS 1.2 */
#define MBEDTLS_TLS_PSK_WITH_AES_256_CCM_8 0xC0A9 /*< TLS 1.2 */
#define MBEDTLS_TLS_DHE_PSK_WITH_AES_128_CCM_8 0xC0AA /*< TLS 1.2 */
#define MBEDTLS_TLS_DHE_PSK_WITH_AES_256_CCM_8 0xC0AB /*< TLS 1.2 */
/* The last two are named with PSK_DHE in the RFC, which looks like a typo */
#define MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CCM 0xC0AC /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_CCM 0xC0AD /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8 0xC0AE /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8 0xC0AF /*< TLS 1.2 */
#define MBEDTLS_TLS_ECJPAKE_WITH_AES_128_CCM_8 0xC0FF /*< experimental */
/* RFC 7905 */
#define MBEDTLS_TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 0xCCA8 /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 0xCCA9 /*< TLS 1.2 */
#define MBEDTLS_TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256 0xCCAA /*< TLS 1.2 */
#define MBEDTLS_TLS_PSK_WITH_CHACHA20_POLY1305_SHA256 0xCCAB /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256 0xCCAC /*< TLS 1.2 */
#define MBEDTLS_TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256 0xCCAD /*< TLS 1.2 */
#define MBEDTLS_TLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256 0xCCAE /*< TLS 1.2 */
/* RFC 8442 */
#define MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_GCM_SHA256 0xD001 /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDHE_PSK_WITH_AES_256_GCM_SHA384 0xD002 /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CCM_8_SHA256 0xD003 /*< TLS 1.2 */
#define MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CCM_SHA256 0xD005 /*< TLS 1.2 */
/* Reminder: update mbedtls_ssl_premaster_secret when adding a new key exchange.
* Reminder: update MBEDTLS_KEY_EXCHANGE__xxx below
*/
typedef enum {
MBEDTLS_KEY_EXCHANGE_NONE = 0,
MBEDTLS_KEY_EXCHANGE_RSA = 1,
MBEDTLS_KEY_EXCHANGE_DHE_RSA = 2,
MBEDTLS_KEY_EXCHANGE_ECDHE_RSA = 3,
MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA = 4,
MBEDTLS_KEY_EXCHANGE_PSK = 5,
MBEDTLS_KEY_EXCHANGE_DHE_PSK = 6,
MBEDTLS_KEY_EXCHANGE_RSA_PSK = 7,
MBEDTLS_KEY_EXCHANGE_ECDHE_PSK = 8,
MBEDTLS_KEY_EXCHANGE_ECDH_RSA = 9,
MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA = 10,
MBEDTLS_KEY_EXCHANGE_ECJPAKE = 11,
} mbedtls_key_exchange_type_t;
typedef struct mbedtls_ssl_ciphersuite_t mbedtls_ssl_ciphersuite_t;
#define MBEDTLS_CIPHERSUITE_WEAK 0x01 /*< Weak ciphersuite flag */
#define MBEDTLS_CIPHERSUITE_SHORT_TAG 0x02 /*< Short authentication tag,
eg for CCM_8 */
#define MBEDTLS_CIPHERSUITE_NODTLS 0x04 /*< Can't be used with DTLS */
/**
* \brief This structure is used for storing ciphersuite information
*/
struct thatispacked mbedtls_ssl_ciphersuite_t
{
uint16_t id;
const char * name;
unsigned char cipher; /* mbedtls_cipher_type_t */
unsigned char mac; /* mbedtls_md_type_t */
unsigned char key_exchange; /* mbedtls_key_exchange_type_t */
unsigned char min_major_ver;
unsigned char min_minor_ver;
unsigned char max_major_ver;
unsigned char max_minor_ver;
unsigned char flags;
};
const uint16_t *mbedtls_ssl_list_ciphersuites( void );
const mbedtls_ssl_ciphersuite_t *mbedtls_ssl_ciphersuite_from_string( const char *ciphersuite_name );
const mbedtls_ssl_ciphersuite_t *mbedtls_ssl_ciphersuite_from_id( int ciphersuite_id );
#if defined(MBEDTLS_PK_C)
mbedtls_pk_type_t mbedtls_ssl_get_ciphersuite_sig_pk_alg( const mbedtls_ssl_ciphersuite_t *info );
mbedtls_pk_type_t mbedtls_ssl_get_ciphersuite_sig_alg( const mbedtls_ssl_ciphersuite_t *info );
#endif
int mbedtls_ssl_ciphersuite_uses_ec( const mbedtls_ssl_ciphersuite_t *info );
int mbedtls_ssl_ciphersuite_uses_psk( const mbedtls_ssl_ciphersuite_t *info );
#if defined(MBEDTLS_KEY_EXCHANGE_SOME_PFS_ENABLED)
static inline int mbedtls_ssl_ciphersuite_has_pfs( const mbedtls_ssl_ciphersuite_t *info )
{
switch( info->key_exchange )
{
case MBEDTLS_KEY_EXCHANGE_DHE_RSA:
case MBEDTLS_KEY_EXCHANGE_DHE_PSK:
case MBEDTLS_KEY_EXCHANGE_ECDHE_RSA:
case MBEDTLS_KEY_EXCHANGE_ECDHE_PSK:
case MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA:
case MBEDTLS_KEY_EXCHANGE_ECJPAKE:
return( 1 );
default:
return( 0 );
}
}
#endif /* MBEDTLS_KEY_EXCHANGE_SOME_PFS_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_SOME_NON_PFS_ENABLED)
static inline int mbedtls_ssl_ciphersuite_no_pfs( const mbedtls_ssl_ciphersuite_t *info )
{
switch( info->key_exchange )
{
case MBEDTLS_KEY_EXCHANGE_ECDH_RSA:
case MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA:
case MBEDTLS_KEY_EXCHANGE_RSA:
case MBEDTLS_KEY_EXCHANGE_PSK:
case MBEDTLS_KEY_EXCHANGE_RSA_PSK:
return( 1 );
default:
return( 0 );
}
}
#endif /* MBEDTLS_KEY_EXCHANGE_SOME_NON_PFS_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_SOME_ECDH_ENABLED)
static inline int mbedtls_ssl_ciphersuite_uses_ecdh( const mbedtls_ssl_ciphersuite_t *info )
{
switch( info->key_exchange )
{
case MBEDTLS_KEY_EXCHANGE_ECDH_RSA:
case MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA:
return( 1 );
default:
return( 0 );
}
}
#endif /* MBEDTLS_KEY_EXCHANGE_SOME_ECDH_ENABLED */
static inline int mbedtls_ssl_ciphersuite_cert_req_allowed( const mbedtls_ssl_ciphersuite_t *info )
{
switch( info->key_exchange )
{
case MBEDTLS_KEY_EXCHANGE_RSA:
case MBEDTLS_KEY_EXCHANGE_DHE_RSA:
case MBEDTLS_KEY_EXCHANGE_ECDH_RSA:
case MBEDTLS_KEY_EXCHANGE_ECDHE_RSA:
case MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA:
case MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA:
return( 1 );
default:
return( 0 );
}
}
static inline int mbedtls_ssl_ciphersuite_uses_srv_cert( const mbedtls_ssl_ciphersuite_t *info )
{
if (!info) return 0; /* TODO: wut */
switch( info->key_exchange )
{
case MBEDTLS_KEY_EXCHANGE_RSA:
case MBEDTLS_KEY_EXCHANGE_RSA_PSK:
case MBEDTLS_KEY_EXCHANGE_DHE_RSA:
case MBEDTLS_KEY_EXCHANGE_ECDH_RSA:
case MBEDTLS_KEY_EXCHANGE_ECDHE_RSA:
case MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA:
case MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA:
return( 1 );
default:
return( 0 );
}
}
#if defined(MBEDTLS_KEY_EXCHANGE_SOME_DHE_ENABLED)
static inline int mbedtls_ssl_ciphersuite_uses_dhe( const mbedtls_ssl_ciphersuite_t *info )
{
switch( info->key_exchange )
{
case MBEDTLS_KEY_EXCHANGE_DHE_RSA:
case MBEDTLS_KEY_EXCHANGE_DHE_PSK:
return( 1 );
default:
return( 0 );
}
}
#endif /* MBEDTLS_KEY_EXCHANGE_SOME_DHE_ENABLED) */
#if defined(MBEDTLS_KEY_EXCHANGE_SOME_ECDHE_ENABLED)
static inline int mbedtls_ssl_ciphersuite_uses_ecdhe( const mbedtls_ssl_ciphersuite_t *info )
{
switch( info->key_exchange )
{
case MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA:
case MBEDTLS_KEY_EXCHANGE_ECDHE_RSA:
case MBEDTLS_KEY_EXCHANGE_ECDHE_PSK:
return( 1 );
default:
return( 0 );
}
}
#endif /* MBEDTLS_KEY_EXCHANGE_SOME_ECDHE_ENABLED) */
#if defined(MBEDTLS_KEY_EXCHANGE_WITH_SERVER_SIGNATURE_ENABLED)
static inline int mbedtls_ssl_ciphersuite_uses_server_signature( const mbedtls_ssl_ciphersuite_t *info )
{
switch( info->key_exchange )
{
case MBEDTLS_KEY_EXCHANGE_DHE_RSA:
case MBEDTLS_KEY_EXCHANGE_ECDHE_RSA:
case MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA:
return( 1 );
default:
return( 0 );
}
}
#endif /* MBEDTLS_KEY_EXCHANGE_WITH_SERVER_SIGNATURE_ENABLED */
const mbedtls_ssl_ciphersuite_t *GetCipherSuite(const char *);
COSMOPOLITAN_C_END_
#endif /* COSMOPOLITAN_THIRD_PARTY_MBEDTLS_SSL_CIPHERSUITES_H_ */
| 23,246 | 458 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/ssl_cookie.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:4;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright The Mbed TLS Contributors â
â â
â Licensed under the Apache License, Version 2.0 (the "License"); â
â you may not use this file except in compliance with the License. â
â You may obtain a copy of the License at â
â â
â http://www.apache.org/licenses/LICENSE-2.0 â
â â
â Unless required by applicable law or agreed to in writing, software â
â distributed under the License is distributed on an "AS IS" BASIS, â
â WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. â
â See the License for the specific language governing permissions and â
â limitations under the License. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "third_party/mbedtls/common.h"
#include "third_party/mbedtls/error.h"
#include "third_party/mbedtls/platform.h"
#include "third_party/mbedtls/ssl_cookie.h"
#include "third_party/mbedtls/ssl_internal.h"
asm(".ident\t\"\\n\\n\
Mbed TLS (Apache 2.0)\\n\
Copyright ARM Limited\\n\
Copyright Mbed TLS Contributors\"");
asm(".include \"libc/disclaimer.inc\"");
/* clang-format off */
/*
* DTLS cookie callbacks implementation
*
* Copyright The Mbed TLS Contributors
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* These session callbacks use a simple chained list
* to store and retrieve the session information.
*/
#if defined(MBEDTLS_SSL_COOKIE_C)
/*
* If DTLS is in use, then at least one of SHA-1, SHA-256, SHA-512 is
* available. Try SHA-256 first, 512 wastes resources since we need to stay
* with max 32 bytes of cookie for DTLS 1.0
*/
#if defined(MBEDTLS_SHA256_C)
#define COOKIE_MD MBEDTLS_MD_SHA224
#define COOKIE_MD_OUTLEN 32
#define COOKIE_HMAC_LEN 28
#elif defined(MBEDTLS_SHA512_C)
#define COOKIE_MD MBEDTLS_MD_SHA384
#define COOKIE_MD_OUTLEN 48
#define COOKIE_HMAC_LEN 28
#elif defined(MBEDTLS_SHA1_C)
#define COOKIE_MD MBEDTLS_MD_SHA1
#define COOKIE_MD_OUTLEN 20
#define COOKIE_HMAC_LEN 20
#else
#error "DTLS hello verify needs SHA-1 or SHA-2"
#endif
/*
* Cookies are formed of a 4-bytes timestamp (or serial number) and
* an HMAC of timestemp and client ID.
*/
#define COOKIE_LEN ( 4 + COOKIE_HMAC_LEN )
void mbedtls_ssl_cookie_init( mbedtls_ssl_cookie_ctx *ctx )
{
mbedtls_md_init( &ctx->hmac_ctx );
#if !defined(MBEDTLS_HAVE_TIME)
ctx->serial = 0;
#endif
ctx->timeout = MBEDTLS_SSL_COOKIE_TIMEOUT;
}
void mbedtls_ssl_cookie_set_timeout( mbedtls_ssl_cookie_ctx *ctx, unsigned long delay )
{
ctx->timeout = delay;
}
void mbedtls_ssl_cookie_free( mbedtls_ssl_cookie_ctx *ctx )
{
mbedtls_md_free( &ctx->hmac_ctx );
mbedtls_platform_zeroize( ctx, sizeof( mbedtls_ssl_cookie_ctx ) );
}
int mbedtls_ssl_cookie_setup( mbedtls_ssl_cookie_ctx *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
unsigned char key[COOKIE_MD_OUTLEN];
if( ( ret = f_rng( p_rng, key, sizeof( key ) ) ) != 0 )
return( ret );
ret = mbedtls_md_setup( &ctx->hmac_ctx, mbedtls_md_info_from_type( COOKIE_MD ), 1 );
if( ret != 0 )
return( ret );
ret = mbedtls_md_hmac_starts( &ctx->hmac_ctx, key, sizeof( key ) );
if( ret != 0 )
return( ret );
mbedtls_platform_zeroize( key, sizeof( key ) );
return( 0 );
}
/*
* Generate the HMAC part of a cookie
*/
static int ssl_cookie_hmac( mbedtls_md_context_t *hmac_ctx,
const unsigned char time[4],
unsigned char **p, unsigned char *end,
const unsigned char *cli_id, size_t cli_id_len )
{
unsigned char hmac_out[COOKIE_MD_OUTLEN];
MBEDTLS_SSL_CHK_BUF_PTR( *p, end, COOKIE_HMAC_LEN );
if( mbedtls_md_hmac_reset( hmac_ctx ) != 0 ||
mbedtls_md_hmac_update( hmac_ctx, time, 4 ) != 0 ||
mbedtls_md_hmac_update( hmac_ctx, cli_id, cli_id_len ) != 0 ||
mbedtls_md_hmac_finish( hmac_ctx, hmac_out ) != 0 )
{
return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
memcpy( *p, hmac_out, COOKIE_HMAC_LEN );
*p += COOKIE_HMAC_LEN;
return( 0 );
}
/*
* Generate cookie for DTLS ClientHello verification
*/
int mbedtls_ssl_cookie_write( void *p_ctx,
unsigned char **p, unsigned char *end,
const unsigned char *cli_id, size_t cli_id_len )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
mbedtls_ssl_cookie_ctx *ctx = (mbedtls_ssl_cookie_ctx *) p_ctx;
unsigned long t;
if( ctx == NULL || cli_id == NULL )
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
MBEDTLS_SSL_CHK_BUF_PTR( *p, end, COOKIE_LEN );
#if defined(MBEDTLS_HAVE_TIME)
t = (unsigned long) mbedtls_time( NULL );
#else
t = ctx->serial++;
#endif
(*p)[0] = (unsigned char)( t >> 24 );
(*p)[1] = (unsigned char)( t >> 16 );
(*p)[2] = (unsigned char)( t >> 8 );
(*p)[3] = (unsigned char)( t );
*p += 4;
return ssl_cookie_hmac( &ctx->hmac_ctx, *p - 4,
p, end, cli_id, cli_id_len );
}
/*
* Check a cookie
*/
int mbedtls_ssl_cookie_check( void *p_ctx,
const unsigned char *cookie, size_t cookie_len,
const unsigned char *cli_id, size_t cli_id_len )
{
unsigned char ref_hmac[COOKIE_HMAC_LEN];
int ret = 0;
unsigned char *p = ref_hmac;
mbedtls_ssl_cookie_ctx *ctx = (mbedtls_ssl_cookie_ctx *) p_ctx;
unsigned long cur_time, cookie_time;
if( ctx == NULL || cli_id == NULL )
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
if( cookie_len != COOKIE_LEN )
return( -1 );
if( ssl_cookie_hmac( &ctx->hmac_ctx, cookie,
&p, p + sizeof( ref_hmac ),
cli_id, cli_id_len ) != 0 )
ret = -1;
if( ret != 0 )
return( ret );
if( timingsafe_bcmp( cookie + 4, ref_hmac, sizeof( ref_hmac ) ) != 0 )
return( -1 );
#if defined(MBEDTLS_HAVE_TIME)
cur_time = (unsigned long) mbedtls_time( NULL );
#else
cur_time = ctx->serial;
#endif
cookie_time = ( (unsigned long) cookie[0] << 24 ) |
( (unsigned long) cookie[1] << 16 ) |
( (unsigned long) cookie[2] << 8 ) |
( (unsigned long) cookie[3] );
if( ctx->timeout != 0 && cur_time - cookie_time > ctx->timeout )
return( -1 );
return( 0 );
}
#endif /* MBEDTLS_SSL_COOKIE_C */
| 8,085 | 231 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/certs.h | #ifndef MBEDTLS_CERTS_H
#define MBEDTLS_CERTS_H
#include "third_party/mbedtls/config.h"
/* clang-format off */
#ifdef __cplusplus
extern "C" {
#endif
/* List of all PEM-encoded CA certificates, terminated by NULL;
* PEM encoded if MBEDTLS_PEM_PARSE_C is enabled, DER encoded
* otherwise. */
extern const char * mbedtls_test_cas[];
extern const size_t mbedtls_test_cas_len[];
/* List of all DER-encoded CA certificates, terminated by NULL */
extern const unsigned char * mbedtls_test_cas_der[];
extern const size_t mbedtls_test_cas_der_len[];
#if defined(MBEDTLS_PEM_PARSE_C)
/* Concatenation of all CA certificates in PEM format if available */
extern const char mbedtls_test_cas_pem[];
extern const size_t mbedtls_test_cas_pem_len;
#endif /* MBEDTLS_PEM_PARSE_C */
/*
* CA test certificates
*/
extern const char mbedtls_test_ca_crt_ec_pem[];
extern const char mbedtls_test_ca_key_ec_pem[];
extern const char mbedtls_test_ca_pwd_ec_pem[];
extern const char mbedtls_test_ca_key_rsa_pem[];
extern const char mbedtls_test_ca_pwd_rsa_pem[];
extern const char mbedtls_test_ca_crt_rsa_sha1_pem[];
extern const char mbedtls_test_ca_crt_rsa_sha256_pem[];
extern const unsigned char mbedtls_test_ca_crt_ec_der[];
extern const unsigned char mbedtls_test_ca_key_ec_der[];
extern const unsigned char mbedtls_test_ca_key_rsa_der[];
extern const unsigned char mbedtls_test_ca_crt_rsa_sha1_der[];
extern const unsigned char mbedtls_test_ca_crt_rsa_sha256_der[];
extern const size_t mbedtls_test_ca_crt_ec_pem_len;
extern const size_t mbedtls_test_ca_key_ec_pem_len;
extern const size_t mbedtls_test_ca_pwd_ec_pem_len;
extern const size_t mbedtls_test_ca_key_rsa_pem_len;
extern const size_t mbedtls_test_ca_pwd_rsa_pem_len;
extern const size_t mbedtls_test_ca_crt_rsa_sha1_pem_len;
extern const size_t mbedtls_test_ca_crt_rsa_sha256_pem_len;
extern const size_t mbedtls_test_ca_crt_ec_der_len;
extern const size_t mbedtls_test_ca_key_ec_der_len;
extern const size_t mbedtls_test_ca_pwd_ec_der_len;
extern const size_t mbedtls_test_ca_key_rsa_der_len;
extern const size_t mbedtls_test_ca_pwd_rsa_der_len;
extern const size_t mbedtls_test_ca_crt_rsa_sha1_der_len;
extern const size_t mbedtls_test_ca_crt_rsa_sha256_der_len;
/* Config-dependent dispatch between PEM and DER encoding
* (PEM if enabled, otherwise DER) */
extern const char mbedtls_test_ca_crt_ec[];
extern const char mbedtls_test_ca_key_ec[];
extern const char mbedtls_test_ca_pwd_ec[];
extern const char mbedtls_test_ca_key_rsa[];
extern const char mbedtls_test_ca_pwd_rsa[];
extern const char mbedtls_test_ca_crt_rsa_sha1[];
extern const char mbedtls_test_ca_crt_rsa_sha256[];
extern const size_t mbedtls_test_ca_crt_ec_len;
extern const size_t mbedtls_test_ca_key_ec_len;
extern const size_t mbedtls_test_ca_pwd_ec_len;
extern const size_t mbedtls_test_ca_key_rsa_len;
extern const size_t mbedtls_test_ca_pwd_rsa_len;
extern const size_t mbedtls_test_ca_crt_rsa_sha1_len;
extern const size_t mbedtls_test_ca_crt_rsa_sha256_len;
/* Config-dependent dispatch between SHA-1 and SHA-256
* (SHA-256 if enabled, otherwise SHA-1) */
extern const char mbedtls_test_ca_crt_rsa[];
extern const size_t mbedtls_test_ca_crt_rsa_len;
/* Config-dependent dispatch between EC and RSA
* (RSA if enabled, otherwise EC) */
extern const char * mbedtls_test_ca_crt;
extern const char * mbedtls_test_ca_key;
extern const char * mbedtls_test_ca_pwd;
extern const size_t mbedtls_test_ca_crt_len;
extern const size_t mbedtls_test_ca_key_len;
extern const size_t mbedtls_test_ca_pwd_len;
/*
* Server test certificates
*/
extern const char mbedtls_test_srv_crt_ec_pem[];
extern const char mbedtls_test_srv_key_ec_pem[];
extern const char mbedtls_test_srv_pwd_ec_pem[];
extern const char mbedtls_test_srv_key_rsa_pem[];
extern const char mbedtls_test_srv_pwd_rsa_pem[];
extern const char mbedtls_test_srv_crt_rsa_sha1_pem[];
extern const char mbedtls_test_srv_crt_rsa_sha256_pem[];
extern const unsigned char mbedtls_test_srv_crt_ec_der[];
extern const unsigned char mbedtls_test_srv_key_ec_der[];
extern const unsigned char mbedtls_test_srv_key_rsa_der[];
extern const unsigned char mbedtls_test_srv_crt_rsa_sha1_der[];
extern const unsigned char mbedtls_test_srv_crt_rsa_sha256_der[];
extern const size_t mbedtls_test_srv_crt_ec_pem_len;
extern const size_t mbedtls_test_srv_key_ec_pem_len;
extern const size_t mbedtls_test_srv_pwd_ec_pem_len;
extern const size_t mbedtls_test_srv_key_rsa_pem_len;
extern const size_t mbedtls_test_srv_pwd_rsa_pem_len;
extern const size_t mbedtls_test_srv_crt_rsa_sha1_pem_len;
extern const size_t mbedtls_test_srv_crt_rsa_sha256_pem_len;
extern const size_t mbedtls_test_srv_crt_ec_der_len;
extern const size_t mbedtls_test_srv_key_ec_der_len;
extern const size_t mbedtls_test_srv_pwd_ec_der_len;
extern const size_t mbedtls_test_srv_key_rsa_der_len;
extern const size_t mbedtls_test_srv_pwd_rsa_der_len;
extern const size_t mbedtls_test_srv_crt_rsa_sha1_der_len;
extern const size_t mbedtls_test_srv_crt_rsa_sha256_der_len;
/* Config-dependent dispatch between PEM and DER encoding
* (PEM if enabled, otherwise DER) */
extern const char mbedtls_test_srv_crt_ec[];
extern const char mbedtls_test_srv_key_ec[];
extern const char mbedtls_test_srv_pwd_ec[];
extern const char mbedtls_test_srv_key_rsa[];
extern const char mbedtls_test_srv_pwd_rsa[];
extern const char mbedtls_test_srv_crt_rsa_sha1[];
extern const char mbedtls_test_srv_crt_rsa_sha256[];
extern const size_t mbedtls_test_srv_crt_ec_len;
extern const size_t mbedtls_test_srv_key_ec_len;
extern const size_t mbedtls_test_srv_pwd_ec_len;
extern const size_t mbedtls_test_srv_key_rsa_len;
extern const size_t mbedtls_test_srv_pwd_rsa_len;
extern const size_t mbedtls_test_srv_crt_rsa_sha1_len;
extern const size_t mbedtls_test_srv_crt_rsa_sha256_len;
/* Config-dependent dispatch between SHA-1 and SHA-256
* (SHA-256 if enabled, otherwise SHA-1) */
extern const char mbedtls_test_srv_crt_rsa[];
extern const size_t mbedtls_test_srv_crt_rsa_len;
/* Config-dependent dispatch between EC and RSA
* (RSA if enabled, otherwise EC) */
extern const char * mbedtls_test_srv_crt;
extern const char * mbedtls_test_srv_key;
extern const char * mbedtls_test_srv_pwd;
extern const size_t mbedtls_test_srv_crt_len;
extern const size_t mbedtls_test_srv_key_len;
extern const size_t mbedtls_test_srv_pwd_len;
/*
* Client test certificates
*/
extern const char mbedtls_test_cli_crt_ec_pem[];
extern const char mbedtls_test_cli_key_ec_pem[];
extern const char mbedtls_test_cli_pwd_ec_pem[];
extern const char mbedtls_test_cli_key_rsa_pem[];
extern const char mbedtls_test_cli_pwd_rsa_pem[];
extern const char mbedtls_test_cli_crt_rsa_pem[];
extern const unsigned char mbedtls_test_cli_crt_ec_der[];
extern const unsigned char mbedtls_test_cli_key_ec_der[];
extern const unsigned char mbedtls_test_cli_key_rsa_der[];
extern const unsigned char mbedtls_test_cli_crt_rsa_der[];
extern const size_t mbedtls_test_cli_crt_ec_pem_len;
extern const size_t mbedtls_test_cli_key_ec_pem_len;
extern const size_t mbedtls_test_cli_pwd_ec_pem_len;
extern const size_t mbedtls_test_cli_key_rsa_pem_len;
extern const size_t mbedtls_test_cli_pwd_rsa_pem_len;
extern const size_t mbedtls_test_cli_crt_rsa_pem_len;
extern const size_t mbedtls_test_cli_crt_ec_der_len;
extern const size_t mbedtls_test_cli_key_ec_der_len;
extern const size_t mbedtls_test_cli_key_rsa_der_len;
extern const size_t mbedtls_test_cli_crt_rsa_der_len;
/* Config-dependent dispatch between PEM and DER encoding
* (PEM if enabled, otherwise DER) */
extern const char mbedtls_test_cli_crt_ec[];
extern const char mbedtls_test_cli_key_ec[];
extern const char mbedtls_test_cli_pwd_ec[];
extern const char mbedtls_test_cli_key_rsa[];
extern const char mbedtls_test_cli_pwd_rsa[];
extern const char mbedtls_test_cli_crt_rsa[];
extern const size_t mbedtls_test_cli_crt_ec_len;
extern const size_t mbedtls_test_cli_key_ec_len;
extern const size_t mbedtls_test_cli_pwd_ec_len;
extern const size_t mbedtls_test_cli_key_rsa_len;
extern const size_t mbedtls_test_cli_pwd_rsa_len;
extern const size_t mbedtls_test_cli_crt_rsa_len;
/* Config-dependent dispatch between EC and RSA
* (RSA if enabled, otherwise EC) */
extern const char * mbedtls_test_cli_crt;
extern const char * mbedtls_test_cli_key;
extern const char * mbedtls_test_cli_pwd;
extern const size_t mbedtls_test_cli_crt_len;
extern const size_t mbedtls_test_cli_key_len;
extern const size_t mbedtls_test_cli_pwd_len;
#ifdef __cplusplus
}
#endif
#endif /* certs.h */
| 8,529 | 224 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/ssl_ticket.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:4;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright The Mbed TLS Contributors â
â â
â Licensed under the Apache License, Version 2.0 (the "License"); â
â you may not use this file except in compliance with the License. â
â You may obtain a copy of the License at â
â â
â http://www.apache.org/licenses/LICENSE-2.0 â
â â
â Unless required by applicable law or agreed to in writing, software â
â distributed under the License is distributed on an "AS IS" BASIS, â
â WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. â
â See the License for the specific language governing permissions and â
â limitations under the License. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/time/time.h"
#include "third_party/mbedtls/common.h"
#include "third_party/mbedtls/error.h"
#include "third_party/mbedtls/platform.h"
#include "third_party/mbedtls/ssl_internal.h"
#include "third_party/mbedtls/ssl_ticket.h"
asm(".ident\t\"\\n\\n\
Mbed TLS (Apache 2.0)\\n\
Copyright ARM Limited\\n\
Copyright Mbed TLS Contributors\"");
asm(".include \"libc/disclaimer.inc\"");
/* clang-format off */
/*
* TLS server tickets callbacks implementation
*
* Copyright The Mbed TLS Contributors
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#if defined(MBEDTLS_SSL_TICKET_C)
/*
* Initialze context
*/
void mbedtls_ssl_ticket_init( mbedtls_ssl_ticket_context *ctx )
{
mbedtls_platform_zeroize( ctx, sizeof( mbedtls_ssl_ticket_context ) );
}
#define MAX_KEY_BYTES 32 /* 256 bits */
#define TICKET_KEY_NAME_BYTES 4
#define TICKET_IV_BYTES 12
#define TICKET_CRYPT_LEN_BYTES 2
#define TICKET_AUTH_TAG_BYTES 16
#define TICKET_MIN_LEN ( TICKET_KEY_NAME_BYTES + \
TICKET_IV_BYTES + \
TICKET_CRYPT_LEN_BYTES + \
TICKET_AUTH_TAG_BYTES )
#define TICKET_ADD_DATA_LEN ( TICKET_KEY_NAME_BYTES + \
TICKET_IV_BYTES + \
TICKET_CRYPT_LEN_BYTES )
/*
* Generate/update a key
*/
static int ssl_ticket_gen_key( mbedtls_ssl_ticket_context *ctx,
unsigned char index )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
unsigned char buf[MAX_KEY_BYTES];
mbedtls_ssl_ticket_key *key = ctx->keys + index;
#if defined(MBEDTLS_HAVE_TIME)
key->generation_time = (uint32_t) mbedtls_time( NULL );
#endif
if( ( ret = ctx->f_rng( ctx->p_rng, key->name, sizeof( key->name ) ) ) != 0 )
return( ret );
if( ( ret = ctx->f_rng( ctx->p_rng, buf, sizeof( buf ) ) ) != 0 )
return( ret );
/* With GCM and CCM, same context can encrypt & decrypt */
ret = mbedtls_cipher_setkey( &key->ctx, buf,
mbedtls_cipher_get_key_bitlen( &key->ctx ),
MBEDTLS_ENCRYPT );
mbedtls_platform_zeroize( buf, sizeof( buf ) );
return( ret );
}
/*
* Rotate/generate keys if necessary
*/
static int ssl_ticket_update_keys( mbedtls_ssl_ticket_context *ctx )
{
#if !defined(MBEDTLS_HAVE_TIME)
((void) ctx);
#else
if( ctx->ticket_lifetime != 0 )
{
uint32_t current_time = (uint32_t) mbedtls_time( NULL );
uint32_t key_time = ctx->keys[ctx->active].generation_time;
if( current_time >= key_time &&
current_time - key_time < ctx->ticket_lifetime )
{
return( 0 );
}
ctx->active = 1 - ctx->active;
return( ssl_ticket_gen_key( ctx, ctx->active ) );
}
else
#endif /* MBEDTLS_HAVE_TIME */
return( 0 );
}
/**
* \brief Prepare context to be actually used
*
* \param ctx Context to be set up
* \param f_rng RNG callback function
* \param p_rng RNG callback context
* \param cipher AEAD cipher to use for ticket protection.
* Recommended value: MBEDTLS_CIPHER_AES_256_GCM.
* \param lifetime Tickets lifetime in seconds
* Recommended value: 86400 (one day).
*
* \note It is highly recommended to select a cipher that is at
* least as strong as the the strongest ciphersuite
* supported. Usually that means a 256-bit key.
*
* \note The lifetime of the keys is twice the lifetime of tickets.
* It is recommended to pick a reasonnable lifetime so as not
* to negate the benefits of forward secrecy.
*
* \return 0 if successful,
* or a specific MBEDTLS_ERR_XXX error code
*/
int mbedtls_ssl_ticket_setup( mbedtls_ssl_ticket_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t), void *p_rng,
mbedtls_cipher_type_t cipher,
uint32_t lifetime )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
const mbedtls_cipher_info_t *cipher_info;
ctx->f_rng = f_rng;
ctx->p_rng = p_rng;
ctx->ticket_lifetime = lifetime;
cipher_info = mbedtls_cipher_info_from_type( cipher);
if( cipher_info == NULL )
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
if( cipher_info->mode != MBEDTLS_MODE_GCM &&
cipher_info->mode != MBEDTLS_MODE_CCM )
{
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
}
if( cipher_info->key_bitlen > 8 * MAX_KEY_BYTES )
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
#if defined(MBEDTLS_USE_PSA_CRYPTO)
ret = mbedtls_cipher_setup_psa( &ctx->keys[0].ctx,
cipher_info, TICKET_AUTH_TAG_BYTES );
if( ret != 0 && ret != MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE )
return( ret );
/* We don't yet expect to support all ciphers through PSA,
* so allow fallback to ordinary mbedtls_cipher_setup(). */
if( ret == MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE )
#endif /* MBEDTLS_USE_PSA_CRYPTO */
if( ( ret = mbedtls_cipher_setup( &ctx->keys[0].ctx, cipher_info ) ) != 0 )
return( ret );
#if defined(MBEDTLS_USE_PSA_CRYPTO)
ret = mbedtls_cipher_setup_psa( &ctx->keys[1].ctx,
cipher_info, TICKET_AUTH_TAG_BYTES );
if( ret != 0 && ret != MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE )
return( ret );
if( ret == MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE )
#endif /* MBEDTLS_USE_PSA_CRYPTO */
if( ( ret = mbedtls_cipher_setup( &ctx->keys[1].ctx, cipher_info ) ) != 0 )
return( ret );
if( ( ret = ssl_ticket_gen_key( ctx, 0 ) ) != 0 ||
( ret = ssl_ticket_gen_key( ctx, 1 ) ) != 0 )
{
return( ret );
}
return( 0 );
}
/*
* Create session ticket, with the following structure:
*
* struct {
* opaque key_name[4];
* opaque iv[12];
* opaque encrypted_state<0..2^16-1>;
* opaque tag[16];
* } ticket;
*
* The key_name, iv, and length of encrypted_state are the additional
* authenticated data.
*/
int mbedtls_ssl_ticket_write( void *p_ticket,
const mbedtls_ssl_session *session,
unsigned char *start,
const unsigned char *end,
size_t *tlen,
uint32_t *ticket_lifetime )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
mbedtls_ssl_ticket_context *ctx = p_ticket;
mbedtls_ssl_ticket_key *key;
unsigned char *key_name = start;
unsigned char *iv = start + TICKET_KEY_NAME_BYTES;
unsigned char *state_len_bytes = iv + TICKET_IV_BYTES;
unsigned char *state = state_len_bytes + TICKET_CRYPT_LEN_BYTES;
size_t clear_len, ciph_len;
*tlen = 0;
if( ctx == NULL || ctx->f_rng == NULL )
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
/* We need at least 4 bytes for key_name, 12 for IV, 2 for len 16 for tag,
* in addition to session itself, that will be checked when writing it. */
MBEDTLS_SSL_CHK_BUF_PTR( start, end, TICKET_MIN_LEN );
if( ( ret = ssl_ticket_update_keys( ctx ) ) != 0 )
goto cleanup;
key = &ctx->keys[ctx->active];
*ticket_lifetime = ctx->ticket_lifetime;
memcpy( key_name, key->name, TICKET_KEY_NAME_BYTES );
if( ( ret = ctx->f_rng( ctx->p_rng, iv, TICKET_IV_BYTES ) ) != 0 )
goto cleanup;
/* Dump session state */
if( ( ret = mbedtls_ssl_session_save( session,
state, end - state,
&clear_len ) ) != 0 ||
(unsigned long) clear_len > 65535 )
{
goto cleanup;
}
state_len_bytes[0] = ( clear_len >> 8 ) & 0xff;
state_len_bytes[1] = ( clear_len ) & 0xff;
/* Encrypt and authenticate */
if( ( ret = mbedtls_cipher_auth_encrypt_ext( &key->ctx,
iv, TICKET_IV_BYTES,
/* Additional data: key name, IV and length */
key_name, TICKET_ADD_DATA_LEN,
state, clear_len,
state, end - state, &ciph_len,
TICKET_AUTH_TAG_BYTES ) ) != 0 )
{
goto cleanup;
}
if( ciph_len != clear_len + TICKET_AUTH_TAG_BYTES )
{
ret = MBEDTLS_ERR_SSL_INTERNAL_ERROR;
goto cleanup;
}
*tlen = TICKET_MIN_LEN + ciph_len - TICKET_AUTH_TAG_BYTES;
cleanup:
return( ret );
}
/*
* Select key based on name
*/
static mbedtls_ssl_ticket_key *ssl_ticket_select_key(
mbedtls_ssl_ticket_context *ctx,
const unsigned char name[4] )
{
unsigned char i;
for( i = 0; i < sizeof( ctx->keys ) / sizeof( *ctx->keys ); i++ )
if( timingsafe_bcmp( name, ctx->keys[i].name, 4 ) == 0 )
return( &ctx->keys[i] );
return( NULL );
}
/*
* Load session ticket (see mbedtls_ssl_ticket_write for structure)
*/
int mbedtls_ssl_ticket_parse( void *p_ticket,
mbedtls_ssl_session *session,
unsigned char *buf,
size_t len )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
mbedtls_ssl_ticket_context *ctx = p_ticket;
mbedtls_ssl_ticket_key *key;
unsigned char *key_name = buf;
unsigned char *iv = buf + TICKET_KEY_NAME_BYTES;
unsigned char *enc_len_p = iv + TICKET_IV_BYTES;
unsigned char *ticket = enc_len_p + TICKET_CRYPT_LEN_BYTES;
size_t enc_len, clear_len;
if( ctx == NULL || ctx->f_rng == NULL )
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
if( len < TICKET_MIN_LEN )
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
if( ( ret = ssl_ticket_update_keys( ctx ) ) != 0 )
goto cleanup;
enc_len = ( enc_len_p[0] << 8 ) | enc_len_p[1];
if( len != TICKET_MIN_LEN + enc_len )
{
ret = MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
goto cleanup;
}
/* Select key */
if( ( key = ssl_ticket_select_key( ctx, key_name ) ) == NULL )
{
/* We can't know for sure but this is a likely option unless we're
* under attack - this is only informative anyway */
ret = MBEDTLS_ERR_SSL_SESSION_TICKET_EXPIRED;
goto cleanup;
}
/* Decrypt and authenticate */
if( ( ret = mbedtls_cipher_auth_decrypt_ext( &key->ctx,
iv, TICKET_IV_BYTES,
/* Additional data: key name, IV and length */
key_name, TICKET_ADD_DATA_LEN,
ticket, enc_len + TICKET_AUTH_TAG_BYTES,
ticket, enc_len, &clear_len,
TICKET_AUTH_TAG_BYTES ) ) != 0 )
{
if( ret == MBEDTLS_ERR_CIPHER_AUTH_FAILED )
ret = MBEDTLS_ERR_SSL_INVALID_MAC;
goto cleanup;
}
if( clear_len != enc_len )
{
ret = MBEDTLS_ERR_SSL_INTERNAL_ERROR;
goto cleanup;
}
/* Actually load session */
if( ( ret = mbedtls_ssl_session_load( session, ticket, clear_len ) ) != 0 )
goto cleanup;
#if defined(MBEDTLS_HAVE_TIME)
{
/* Check for expiration */
mbedtls_time_t current_time = mbedtls_time( NULL );
if( current_time < session->start ||
(uint32_t)( current_time - session->start ) > ctx->ticket_lifetime )
{
ret = MBEDTLS_ERR_SSL_SESSION_TICKET_EXPIRED;
goto cleanup;
}
}
#endif
cleanup:
return( ret );
}
/*
* Free context
*/
void mbedtls_ssl_ticket_free( mbedtls_ssl_ticket_context *ctx )
{
mbedtls_cipher_free( &ctx->keys[0].ctx );
mbedtls_cipher_free( &ctx->keys[1].ctx );
mbedtls_platform_zeroize( ctx, sizeof( mbedtls_ssl_ticket_context ) );
}
#endif /* MBEDTLS_SSL_TICKET_C */
| 14,145 | 410 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/ecp_internal.h | #ifndef COSMOPOLITAN_THIRD_PARTY_MBEDTLS_ECP_INTERNAL_H_
#define COSMOPOLITAN_THIRD_PARTY_MBEDTLS_ECP_INTERNAL_H_
#include "third_party/mbedtls/config.h"
#include "third_party/mbedtls/ecp.h"
/* clang-format off */
#if defined(MBEDTLS_ECP_INTERNAL_ALT)
/**
* \brief Indicate if the Elliptic Curve Point module extension can
* handle the group.
*
* \param grp The pointer to the elliptic curve group that will be the
* basis of the cryptographic computations.
*
* \return Non-zero if successful.
*/
unsigned char mbedtls_internal_ecp_grp_capable( const mbedtls_ecp_group *grp );
/**
* \brief Initialise the Elliptic Curve Point module extension.
*
* If mbedtls_internal_ecp_grp_capable returns true for a
* group, this function has to be able to initialise the
* module for it.
*
* This module can be a driver to a crypto hardware
* accelerator, for which this could be an initialise function.
*
* \param grp The pointer to the group the module needs to be
* initialised for.
*
* \return 0 if successful.
*/
int mbedtls_internal_ecp_init( const mbedtls_ecp_group *grp );
/**
* \brief Frees and deallocates the Elliptic Curve Point module
* extension.
*
* \param grp The pointer to the group the module was initialised for.
*/
void mbedtls_internal_ecp_free( const mbedtls_ecp_group *grp );
#if defined(MBEDTLS_ECP_SHORT_WEIERSTRASS_ENABLED)
#if defined(MBEDTLS_ECP_RANDOMIZE_JAC_ALT)
/**
* \brief Randomize jacobian coordinates:
* (X, Y, Z) -> (l^2 X, l^3 Y, l Z) for random l.
*
* \param grp Pointer to the group representing the curve.
*
* \param pt The point on the curve to be randomised, given with Jacobian
* coordinates.
*
* \param f_rng A function pointer to the random number generator.
*
* \param p_rng A pointer to the random number generator state.
*
* \return 0 if successful.
*/
int mbedtls_internal_ecp_randomize_jac( const mbedtls_ecp_group *grp,
mbedtls_ecp_point *pt, int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng );
#endif
#if defined(MBEDTLS_ECP_ADD_MIXED_ALT)
/**
* \brief Addition: R = P + Q, mixed affine-Jacobian coordinates.
*
* The coordinates of Q must be normalized (= affine),
* but those of P don't need to. R is not normalized.
*
* This function is used only as a subrutine of
* ecp_mul_comb().
*
* Special cases: (1) P or Q is zero, (2) R is zero,
* (3) P == Q.
* None of these cases can happen as intermediate step in
* ecp_mul_comb():
* - at each step, P, Q and R are multiples of the base
* point, the factor being less than its order, so none of
* them is zero;
* - Q is an odd multiple of the base point, P an even
* multiple, due to the choice of precomputed points in the
* modified comb method.
* So branches for these cases do not leak secret information.
*
* We accept Q->Z being unset (saving memory in tables) as
* meaning 1.
*
* Cost in field operations if done by [5] 3.22:
* 1A := 8M + 3S
*
* \param grp Pointer to the group representing the curve.
*
* \param R Pointer to a point structure to hold the result.
*
* \param P Pointer to the first summand, given with Jacobian
* coordinates
*
* \param Q Pointer to the second summand, given with affine
* coordinates.
*
* \return 0 if successful.
*/
int mbedtls_internal_ecp_add_mixed( const mbedtls_ecp_group *grp,
mbedtls_ecp_point *R,
const mbedtls_ecp_point *P,
const mbedtls_ecp_point *Q );
#endif
/**
* \brief Point doubling R = 2 P, Jacobian coordinates.
*
* Cost: 1D := 3M + 4S (A == 0)
* 4M + 4S (A == -3)
* 3M + 6S + 1a otherwise
* when the implementation is based on the "dbl-1998-cmo-2"
* doubling formulas in [8] and standard optimizations are
* applied when curve parameter A is one of { 0, -3 }.
*
* \param grp Pointer to the group representing the curve.
*
* \param R Pointer to a point structure to hold the result.
*
* \param P Pointer to the point that has to be doubled, given with
* Jacobian coordinates.
*
* \return 0 if successful.
*/
#if defined(MBEDTLS_ECP_DOUBLE_JAC_ALT)
int mbedtls_internal_ecp_double_jac( const mbedtls_ecp_group *grp,
mbedtls_ecp_point *R, const mbedtls_ecp_point *P );
#endif
/**
* \brief Normalize jacobian coordinates of an array of (pointers to)
* points.
*
* Using Montgomery's trick to perform only one inversion mod P
* the cost is:
* 1N(t) := 1I + (6t - 3)M + 1S
* (See for example Algorithm 10.3.4. in [9])
*
* This function is used only as a subrutine of
* ecp_mul_comb().
*
* Warning: fails (returning an error) if one of the points is
* zero!
* This should never happen, see choice of w in ecp_mul_comb().
*
* \param grp Pointer to the group representing the curve.
*
* \param T Array of pointers to the points to normalise.
*
* \param t_len Number of elements in the array.
*
* \return 0 if successful,
* an error if one of the points is zero.
*/
#if defined(MBEDTLS_ECP_NORMALIZE_JAC_MANY_ALT)
int mbedtls_internal_ecp_normalize_jac_many( const mbedtls_ecp_group *grp,
mbedtls_ecp_point *T[], size_t t_len );
#endif
/**
* \brief Normalize jacobian coordinates so that Z == 0 || Z == 1.
*
* Cost in field operations if done by [5] 3.2.1:
* 1N := 1I + 3M + 1S
*
* \param grp Pointer to the group representing the curve.
*
* \param pt pointer to the point to be normalised. This is an
* input/output parameter.
*
* \return 0 if successful.
*/
#if defined(MBEDTLS_ECP_NORMALIZE_JAC_ALT)
int mbedtls_internal_ecp_normalize_jac( const mbedtls_ecp_group *grp,
mbedtls_ecp_point *pt );
#endif
#endif /* MBEDTLS_ECP_SHORT_WEIERSTRASS_ENABLED */
#if defined(MBEDTLS_ECP_MONTGOMERY_ENABLED)
#if defined(MBEDTLS_ECP_DOUBLE_ADD_MXZ_ALT)
int mbedtls_internal_ecp_double_add_mxz( const mbedtls_ecp_group *grp,
mbedtls_ecp_point *R, mbedtls_ecp_point *S, const mbedtls_ecp_point *P,
const mbedtls_ecp_point *Q, const mbedtls_mpi *d );
#endif
/**
* \brief Randomize projective x/z coordinates:
* (X, Z) -> (l X, l Z) for random l
*
* \param grp pointer to the group representing the curve
*
* \param P the point on the curve to be randomised given with
* projective coordinates. This is an input/output parameter.
*
* \param f_rng a function pointer to the random number generator
*
* \param p_rng a pointer to the random number generator state
*
* \return 0 if successful
*/
#if defined(MBEDTLS_ECP_RANDOMIZE_MXZ_ALT)
int mbedtls_internal_ecp_randomize_mxz( const mbedtls_ecp_group *grp,
mbedtls_ecp_point *P,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng );
#endif
/**
* \brief Normalize Montgomery x/z coordinates: X = X/Z, Z = 1.
*
* \param grp pointer to the group representing the curve
*
* \param P pointer to the point to be normalised. This is an
* input/output parameter.
*
* \return 0 if successful
*/
#if defined(MBEDTLS_ECP_NORMALIZE_MXZ_ALT)
int mbedtls_internal_ecp_normalize_mxz( const mbedtls_ecp_group *grp,
mbedtls_ecp_point *P );
#endif
#endif /* MBEDTLS_ECP_MONTGOMERY_ENABLED */
#endif /* MBEDTLS_ECP_INTERNAL_ALT */
void secp256r1( uint64_t[8] );
void secp384r1( uint64_t[12] );
int mbedtls_p256_double_jac( const mbedtls_ecp_group *,
const mbedtls_ecp_point *,
mbedtls_ecp_point * );
int mbedtls_p256_add_mixed( const mbedtls_ecp_group *,
const mbedtls_ecp_point *,
const mbedtls_ecp_point *,
mbedtls_ecp_point * );
int mbedtls_p256_normalize_jac( const mbedtls_ecp_group *,
mbedtls_ecp_point * );
int mbedtls_p256_normalize_jac_many( const mbedtls_ecp_group *,
mbedtls_ecp_point *[], size_t );
int mbedtls_p384_double_jac( const mbedtls_ecp_group *,
const mbedtls_ecp_point *,
mbedtls_ecp_point * );
int mbedtls_p384_add_mixed( const mbedtls_ecp_group *,
const mbedtls_ecp_point *,
const mbedtls_ecp_point *,
mbedtls_ecp_point * );
int mbedtls_p384_normalize_jac( const mbedtls_ecp_group *,
mbedtls_ecp_point * );
int mbedtls_p384_normalize_jac_many( const mbedtls_ecp_group *,
mbedtls_ecp_point *[], size_t );
void mbedtls_p384_mod( uint64_t X[12] );
#endif /* COSMOPOLITAN_THIRD_PARTY_MBEDTLS_ECP_INTERNAL_H_ */
| 10,132 | 267 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/blake2b256.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:4;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2021 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/str/blake2.h"
#include "third_party/mbedtls/md.h"
/* clang-format off */
const mbedtls_md_info_t mbedtls_blake2b256_info = {
"BLAKE2B256",
MBEDTLS_MD_BLAKE2B256,
BLAKE2B256_DIGEST_LENGTH,
BLAKE2B_CBLOCK,
(void *)BLAKE2B256_Init,
(void *)BLAKE2B256_Update,
(void *)BLAKE2B256_Process,
(void *)BLAKE2B256_Final,
(void *)BLAKE2B256,
};
| 2,221 | 34 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/mdtype.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:4;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright The Mbed TLS Contributors â
â â
â Licensed under the Apache License, Version 2.0 (the "License"); â
â you may not use this file except in compliance with the License. â
â You may obtain a copy of the License at â
â â
â http://www.apache.org/licenses/LICENSE-2.0 â
â â
â Unless required by applicable law or agreed to in writing, software â
â distributed under the License is distributed on an "AS IS" BASIS, â
â WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. â
â See the License for the specific language governing permissions and â
â limitations under the License. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "third_party/mbedtls/md.h"
const char *mbedtls_md_type_name(mbedtls_md_type_t t) {
switch (t) {
case MBEDTLS_MD_NONE:
return "NONE";
case MBEDTLS_MD_MD2:
return "MD2";
case MBEDTLS_MD_MD4:
return "MD4";
case MBEDTLS_MD_MD5:
return "MD5";
case MBEDTLS_MD_SHA1:
return "SHA1";
case MBEDTLS_MD_SHA224:
return "SHA224";
case MBEDTLS_MD_SHA256:
return "SHA256";
case MBEDTLS_MD_SHA384:
return "SHA384";
case MBEDTLS_MD_SHA512:
return "SHA512";
default:
return 0;
}
}
| 2,327 | 44 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/ssl_invasive.h | #ifndef COSMOPOLITAN_THIRD_PARTY_MBEDTLS_SSL_INVASIVE_H_
#define COSMOPOLITAN_THIRD_PARTY_MBEDTLS_SSL_INVASIVE_H_
#include "third_party/mbedtls/common.h"
#include "third_party/mbedtls/md.h"
#if !(__ASSEMBLER__ + __LINKER__ + 0)
COSMOPOLITAN_C_START_
#if defined(MBEDTLS_TEST_HOOKS) && defined(MBEDTLS_SSL_SOME_SUITES_USE_TLS_CBC)
/** \brief Compute the HMAC of variable-length data with constant flow.
*
* This function computes the HMAC of the concatenation of \p add_data and \p
* data, and does with a code flow and memory access pattern that does not
* depend on \p data_len_secret, but only on \p min_data_len and \p
* max_data_len. In particular, this function always reads exactly \p
* max_data_len bytes from \p data.
*
* \param ctx The HMAC context. It must have keys configured
* with mbedtls_md_hmac_starts() and use one of the
* following hashes: SHA-384, SHA-256, SHA-1 or MD-5.
* It is reset using mbedtls_md_hmac_reset() after
* the computation is complete to prepare for the
* next computation.
* \param add_data The additional data prepended to \p data. This
* must point to a readable buffer of \p add_data_len
* bytes.
* \param add_data_len The length of \p add_data in bytes.
* \param data The data appended to \p add_data. This must point
* to a readable buffer of \p max_data_len bytes.
* \param data_len_secret The length of the data to process in \p data.
* This must be no less than \p min_data_len and no
* greater than \p max_data_len.
* \param min_data_len The minimal length of \p data in bytes.
* \param max_data_len The maximal length of \p data in bytes.
* \param output The HMAC will be written here. This must point to
* a writable buffer of sufficient size to hold the
* HMAC value.
*
* \retval 0
* Success.
* \retval MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED
* The hardware accelerator failed.
*/
int mbedtls_ssl_cf_hmac(mbedtls_md_context_t *ctx,
const unsigned char *add_data, size_t add_data_len,
const unsigned char *data, size_t data_len_secret,
size_t min_data_len, size_t max_data_len,
unsigned char *output);
/**
* \brief Copy data from a secret position with constant flow.
*
* This function copies \p len bytes from \p src_base + \p offset_secret to \p
* dst, with a code flow and memory access pattern that does not depend on \p
* offset_secret, but only on \p offset_min, \p offset_max and \p len.
*
* \param dst The destination buffer. This must point to a writable
* buffer of at least \p len bytes.
* \param src_base The base of the source buffer. This must point to a
* readable buffer of at least \p offset_max + \p len
* bytes.
* \param offset_secret The offset in the source buffer from which to copy.
* This must be no less than \p offset_min and no greater
* than \p offset_max.
* \param offset_min The minimal value of \p offset_secret.
* \param offset_max The maximal value of \p offset_secret.
* \param len The number of bytes to copy.
*/
void mbedtls_ssl_cf_memcpy_offset(unsigned char *dst,
const unsigned char *src_base,
size_t offset_secret, size_t offset_min,
size_t offset_max, size_t len);
#endif /* MBEDTLS_TEST_HOOKS && MBEDTLS_SSL_SOME_SUITES_USE_TLS_CBC */
COSMOPOLITAN_C_END_
#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
#endif /* COSMOPOLITAN_THIRD_PARTY_MBEDTLS_SSL_INVASIVE_H_ */
| 4,020 | 77 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/ecpshl.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:4;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright The Mbed TLS Contributors â
â â
â Licensed under the Apache License, Version 2.0 (the "License"); â
â you may not use this file except in compliance with the License. â
â You may obtain a copy of the License at â
â â
â http://www.apache.org/licenses/LICENSE-2.0 â
â â
â Unless required by applicable law or agreed to in writing, software â
â distributed under the License is distributed on an "AS IS" BASIS, â
â WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. â
â See the License for the specific language governing permissions and â
â limitations under the License. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "third_party/mbedtls/ecp.h"
#include "third_party/mbedtls/math.h"
/* clang-format off */
static void mbedtls_mpi_shift_l_mod_p256( const mbedtls_ecp_group *G,
mbedtls_mpi *X )
{
bool c;
MBEDTLS_ASSERT( G->P.n == 4 );
MBEDTLS_ASSERT( mbedtls_mpi_bitlen( X ) <= 256 );
MBEDTLS_ASSERT( mbedtls_mpi_bitlen( &G->P ) <= 256 );
X->p[4] = X->p[3] >> 63;
X->p[3] = X->p[3] << 1 | X->p[2] >> 63;
X->p[2] = X->p[2] << 1 | X->p[1] >> 63;
X->p[1] = X->p[1] << 1 | X->p[0] >> 63;
X->p[0] = X->p[0] << 1;
if( (X->p[4] ||
X->p[3] > G->P.p[3] ||
(X->p[3] == G->P.p[3] &&
X->p[2] > G->P.p[2] ||
(X->p[2] == G->P.p[2] &&
X->p[0] > G->P.p[0] ||
(X->p[0] == G->P.p[0])))) )
{
SBB(X->p[0], X->p[0], G->P.p[0], 0, c);
SBB(X->p[1], X->p[1], G->P.p[1], c, c);
SBB(X->p[2], X->p[2], G->P.p[2], c, c);
SBB(X->p[3], X->p[3], G->P.p[3], c, c);
SBB(X->p[4], X->p[4], 0, c, c);
}
}
static void mbedtls_mpi_shift_l_mod_p384( const mbedtls_ecp_group *G,
mbedtls_mpi *X )
{
bool c;
MBEDTLS_ASSERT( G->P.n == 6 );
MBEDTLS_ASSERT( mbedtls_mpi_bitlen( X ) <= 384 );
MBEDTLS_ASSERT( mbedtls_mpi_bitlen( &G->P ) <= 384 );
X->p[6] = X->p[5] >> 63;
X->p[5] = X->p[5] << 1 | X->p[4] >> 63;
X->p[4] = X->p[4] << 1 | X->p[3] >> 63;
X->p[3] = X->p[3] << 1 | X->p[2] >> 63;
X->p[2] = X->p[2] << 1 | X->p[1] >> 63;
X->p[1] = X->p[1] << 1 | X->p[0] >> 63;
X->p[0] = X->p[0] << 1;
if( (X->p[6] ||
X->p[5] > G->P.p[5] ||
(X->p[5] == G->P.p[5] &&
X->p[4] > G->P.p[4] ||
(X->p[4] == G->P.p[4] &&
X->p[3] > G->P.p[3] ||
(X->p[3] == G->P.p[3] &&
X->p[2] > G->P.p[2] ||
(X->p[2] == G->P.p[2] &&
X->p[0] > G->P.p[0] ||
(X->p[0] == G->P.p[0])))))) )
{
SBB(X->p[0], X->p[0], G->P.p[0], 0, c);
SBB(X->p[1], X->p[1], G->P.p[1], c, c);
SBB(X->p[2], X->p[2], G->P.p[2], c, c);
SBB(X->p[3], X->p[3], G->P.p[3], c, c);
SBB(X->p[4], X->p[4], G->P.p[4], c, c);
SBB(X->p[5], X->p[5], G->P.p[5], c, c);
SBB(X->p[6], X->p[6], 0, c, c);
}
}
int mbedtls_mpi_shift_l_mod( const mbedtls_ecp_group *G, mbedtls_mpi *X )
{
int ret = 0;
MBEDTLS_ASSERT( mbedtls_mpi_cmp_int( X, 0 ) >= 0 );
MBEDTLS_ASSERT( mbedtls_mpi_cmp_mpi( X, &G->P ) < 0 );
if( X->n == 8 )
mbedtls_mpi_shift_l_mod_p256( G, X );
else if( X->n == 12 )
mbedtls_mpi_shift_l_mod_p384( G, X );
else
{
MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( X, 1 ) );
if( mbedtls_mpi_cmp_mpi( X, &G->P ) >= 0 )
MBEDTLS_MPI_CHK( mbedtls_mpi_sub_abs( X, X, &G->P ) );
}
MBEDTLS_ASSERT( mbedtls_mpi_cmp_mpi( X, &G->P ) < 0 );
MBEDTLS_ASSERT( mbedtls_mpi_cmp_int( X, 0 ) >= 0 );
cleanup:
return( ret );
}
| 4,833 | 106 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/sha1.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:4;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright The Mbed TLS Contributors â
â â
â Licensed under the Apache License, Version 2.0 (the "License"); â
â you may not use this file except in compliance with the License. â
â You may obtain a copy of the License at â
â â
â http://www.apache.org/licenses/LICENSE-2.0 â
â â
â Unless required by applicable law or agreed to in writing, software â
â distributed under the License is distributed on an "AS IS" BASIS, â
â WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. â
â See the License for the specific language governing permissions and â
â limitations under the License. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/intrin/asan.internal.h"
#include "libc/intrin/bits.h"
#include "libc/macros.internal.h"
#include "libc/nexgen32e/sha.h"
#include "libc/nexgen32e/x86feature.h"
#include "libc/str/str.h"
#include "third_party/mbedtls/common.h"
#include "third_party/mbedtls/endian.h"
#include "third_party/mbedtls/error.h"
#include "third_party/mbedtls/md.h"
#include "third_party/mbedtls/platform.h"
#include "third_party/mbedtls/sha1.h"
asm(".ident\t\"\\n\\n\
Mbed TLS (Apache 2.0)\\n\
Copyright ARM Limited\\n\
Copyright Mbed TLS Contributors\"");
asm(".include \"libc/disclaimer.inc\"");
/* clang-format off */
/**
* @fileoverview FIPS-180-1 compliant SHA-1 implementation
*
* The SHA-1 standard was published by NIST in 1993.
*
* @see http://www.itl.nist.gov/fipspubs/fip180-1.htm
*/
#define SHA1_VALIDATE_RET(cond) \
MBEDTLS_INTERNAL_VALIDATE_RET( cond, MBEDTLS_ERR_SHA1_BAD_INPUT_DATA )
#define SHA1_VALIDATE(cond) MBEDTLS_INTERNAL_VALIDATE( cond )
/**
* \brief This function clones the state of a SHA-1 context.
*
* \warning SHA-1 is considered a weak message digest and its use
* constitutes a security risk. We recommend considering
* stronger message digests instead.
*
* \param dst The SHA-1 context to clone to. This must be initialized.
* \param src The SHA-1 context to clone from. This must be initialized.
*
*/
void mbedtls_sha1_clone( mbedtls_sha1_context *dst,
const mbedtls_sha1_context *src )
{
SHA1_VALIDATE( dst != NULL );
SHA1_VALIDATE( src != NULL );
*dst = *src;
}
/**
* \brief This function starts a SHA-1 checksum calculation.
*
* \warning SHA-1 is considered a weak message digest and its use
* constitutes a security risk. We recommend considering
* stronger message digests instead.
*
* \param ctx The SHA-1 context to initialize. This must be initialized.
*
* \return \c 0 on success.
* \return A negative error code on failure.
*
*/
int mbedtls_sha1_starts_ret( mbedtls_sha1_context *ctx )
{
SHA1_VALIDATE_RET( ctx != NULL );
ctx->total[0] = 0;
ctx->total[1] = 0;
ctx->state[0] = 0x67452301;
ctx->state[1] = 0xEFCDAB89;
ctx->state[2] = 0x98BADCFE;
ctx->state[3] = 0x10325476;
ctx->state[4] = 0xC3D2E1F0;
return( 0 );
}
#if !defined(MBEDTLS_SHA1_PROCESS_ALT)
/**
* \brief SHA-1 process data block (internal use only).
*
* \warning SHA-1 is considered a weak message digest and its use
* constitutes a security risk. We recommend considering
* stronger message digests instead.
*
* \param ctx The SHA-1 context to use. This must be initialized.
* \param data The data block being processed. This must be a
* readable buffer of length \c 64 Bytes.
*
* \return \c 0 on success.
* \return A negative error code on failure.
*
*/
int mbedtls_internal_sha1_process( mbedtls_sha1_context *ctx,
const unsigned char data[64] )
{
SHA1_VALIDATE_RET( ctx != NULL );
SHA1_VALIDATE_RET( (const unsigned char *)data != NULL );
if( !IsTiny() || X86_NEED( SHA ) )
{
if( X86_HAVE( SHA ) )
{
if( IsAsan() )
{
__asan_verify( data, 64 );
__asan_verify( ctx, sizeof(*ctx) );
}
sha1_transform_ni( ctx->state, data, 1 );
return( 0 );
}
if( X86_HAVE( BMI ) &&
X86_HAVE( BMI2 ) &&
X86_HAVE( AVX2 ) )
{
if( IsAsan() )
{
__asan_verify( data, 64 );
__asan_verify( ctx, sizeof(*ctx) );
}
sha1_transform_avx2( ctx->state, data, 1 );
return( 0 );
}
}
#ifdef MBEDTLS_SHA1_SMALLER
#define ROL(a, b) ((a << b) | (a >> (32 - b)))
uint32_t a, b, c, d, e, i, j, t, m[80];
for (i = 0, j = 0; i < 16; ++i, j += 4) {
m[i] = READ32BE(data + j);
}
for (; i < 80; ++i) {
m[i] = (m[i - 3] ^ m[i - 8] ^ m[i - 14] ^ m[i - 16]);
m[i] = (m[i] << 1) | (m[i] >> 31);
}
a = ctx->state[0];
b = ctx->state[1];
c = ctx->state[2];
d = ctx->state[3];
e = ctx->state[4];
for (i = 0; i < 20; ++i) {
t = ROL(a, 5) + ((b & c) ^ (~b & d)) + e + 0x5a827999 + m[i];
e = d, d = c;
c = ROL(b, 30);
b = a, a = t;
}
for (; i < 40; ++i) {
t = ROL(a, 5) + (b ^ c ^ d) + e + 0x6ed9eba1 + m[i];
e = d, d = c;
c = ROL(b, 30);
b = a, a = t;
}
for (; i < 60; ++i) {
t = ROL(a, 5) + ((b & c) ^ (b & d) ^ (c & d)) + e + 0x8f1bbcdc + m[i];
e = d, d = c;
c = ROL(b, 30);
b = a, a = t;
}
for (; i < 80; ++i) {
t = ROL(a, 5) + (b ^ c ^ d) + e + 0xca62c1d6 + m[i];
e = d, d = c;
c = ROL(b, 30);
b = a, a = t;
}
ctx->state[0] += a;
ctx->state[1] += b;
ctx->state[2] += c;
ctx->state[3] += d;
ctx->state[4] += e;
mbedtls_platform_zeroize(m, sizeof(m));
#else
struct
{
uint32_t temp, W[16], A, B, C, D, E;
} local;
GET_UINT32_BE( local.W[ 0], data, 0 );
GET_UINT32_BE( local.W[ 1], data, 4 );
GET_UINT32_BE( local.W[ 2], data, 8 );
GET_UINT32_BE( local.W[ 3], data, 12 );
GET_UINT32_BE( local.W[ 4], data, 16 );
GET_UINT32_BE( local.W[ 5], data, 20 );
GET_UINT32_BE( local.W[ 6], data, 24 );
GET_UINT32_BE( local.W[ 7], data, 28 );
GET_UINT32_BE( local.W[ 8], data, 32 );
GET_UINT32_BE( local.W[ 9], data, 36 );
GET_UINT32_BE( local.W[10], data, 40 );
GET_UINT32_BE( local.W[11], data, 44 );
GET_UINT32_BE( local.W[12], data, 48 );
GET_UINT32_BE( local.W[13], data, 52 );
GET_UINT32_BE( local.W[14], data, 56 );
GET_UINT32_BE( local.W[15], data, 60 );
#define S(x,n) (((x) << (n)) | (((x) & 0xFFFFFFFF) >> (32 - (n))))
#define R(t) \
( \
local.temp = local.W[( (t) - 3 ) & 0x0F] ^ \
local.W[( (t) - 8 ) & 0x0F] ^ \
local.W[( (t) - 14 ) & 0x0F] ^ \
local.W[ (t) & 0x0F], \
( local.W[(t) & 0x0F] = S(local.temp,1) ) \
)
#define P(a,b,c,d,e,x) \
do \
{ \
(e) += S((a),5) + F((b),(c),(d)) + K + (x); \
(b) = S((b),30); \
} while( 0 )
local.A = ctx->state[0];
local.B = ctx->state[1];
local.C = ctx->state[2];
local.D = ctx->state[3];
local.E = ctx->state[4];
#define F(x,y,z) ((z) ^ ((x) & ((y) ^ (z))))
#define K 0x5A827999
P( local.A, local.B, local.C, local.D, local.E, local.W[0] );
P( local.E, local.A, local.B, local.C, local.D, local.W[1] );
P( local.D, local.E, local.A, local.B, local.C, local.W[2] );
P( local.C, local.D, local.E, local.A, local.B, local.W[3] );
P( local.B, local.C, local.D, local.E, local.A, local.W[4] );
P( local.A, local.B, local.C, local.D, local.E, local.W[5] );
P( local.E, local.A, local.B, local.C, local.D, local.W[6] );
P( local.D, local.E, local.A, local.B, local.C, local.W[7] );
P( local.C, local.D, local.E, local.A, local.B, local.W[8] );
P( local.B, local.C, local.D, local.E, local.A, local.W[9] );
P( local.A, local.B, local.C, local.D, local.E, local.W[10] );
P( local.E, local.A, local.B, local.C, local.D, local.W[11] );
P( local.D, local.E, local.A, local.B, local.C, local.W[12] );
P( local.C, local.D, local.E, local.A, local.B, local.W[13] );
P( local.B, local.C, local.D, local.E, local.A, local.W[14] );
P( local.A, local.B, local.C, local.D, local.E, local.W[15] );
P( local.E, local.A, local.B, local.C, local.D, R(16) );
P( local.D, local.E, local.A, local.B, local.C, R(17) );
P( local.C, local.D, local.E, local.A, local.B, R(18) );
P( local.B, local.C, local.D, local.E, local.A, R(19) );
#undef K
#undef F
#define F(x,y,z) ((x) ^ (y) ^ (z))
#define K 0x6ED9EBA1
P( local.A, local.B, local.C, local.D, local.E, R(20) );
P( local.E, local.A, local.B, local.C, local.D, R(21) );
P( local.D, local.E, local.A, local.B, local.C, R(22) );
P( local.C, local.D, local.E, local.A, local.B, R(23) );
P( local.B, local.C, local.D, local.E, local.A, R(24) );
P( local.A, local.B, local.C, local.D, local.E, R(25) );
P( local.E, local.A, local.B, local.C, local.D, R(26) );
P( local.D, local.E, local.A, local.B, local.C, R(27) );
P( local.C, local.D, local.E, local.A, local.B, R(28) );
P( local.B, local.C, local.D, local.E, local.A, R(29) );
P( local.A, local.B, local.C, local.D, local.E, R(30) );
P( local.E, local.A, local.B, local.C, local.D, R(31) );
P( local.D, local.E, local.A, local.B, local.C, R(32) );
P( local.C, local.D, local.E, local.A, local.B, R(33) );
P( local.B, local.C, local.D, local.E, local.A, R(34) );
P( local.A, local.B, local.C, local.D, local.E, R(35) );
P( local.E, local.A, local.B, local.C, local.D, R(36) );
P( local.D, local.E, local.A, local.B, local.C, R(37) );
P( local.C, local.D, local.E, local.A, local.B, R(38) );
P( local.B, local.C, local.D, local.E, local.A, R(39) );
#undef K
#undef F
#define F(x,y,z) (((x) & (y)) | ((z) & ((x) | (y))))
#define K 0x8F1BBCDC
P( local.A, local.B, local.C, local.D, local.E, R(40) );
P( local.E, local.A, local.B, local.C, local.D, R(41) );
P( local.D, local.E, local.A, local.B, local.C, R(42) );
P( local.C, local.D, local.E, local.A, local.B, R(43) );
P( local.B, local.C, local.D, local.E, local.A, R(44) );
P( local.A, local.B, local.C, local.D, local.E, R(45) );
P( local.E, local.A, local.B, local.C, local.D, R(46) );
P( local.D, local.E, local.A, local.B, local.C, R(47) );
P( local.C, local.D, local.E, local.A, local.B, R(48) );
P( local.B, local.C, local.D, local.E, local.A, R(49) );
P( local.A, local.B, local.C, local.D, local.E, R(50) );
P( local.E, local.A, local.B, local.C, local.D, R(51) );
P( local.D, local.E, local.A, local.B, local.C, R(52) );
P( local.C, local.D, local.E, local.A, local.B, R(53) );
P( local.B, local.C, local.D, local.E, local.A, R(54) );
P( local.A, local.B, local.C, local.D, local.E, R(55) );
P( local.E, local.A, local.B, local.C, local.D, R(56) );
P( local.D, local.E, local.A, local.B, local.C, R(57) );
P( local.C, local.D, local.E, local.A, local.B, R(58) );
P( local.B, local.C, local.D, local.E, local.A, R(59) );
#undef K
#undef F
#define F(x,y,z) ((x) ^ (y) ^ (z))
#define K 0xCA62C1D6
P( local.A, local.B, local.C, local.D, local.E, R(60) );
P( local.E, local.A, local.B, local.C, local.D, R(61) );
P( local.D, local.E, local.A, local.B, local.C, R(62) );
P( local.C, local.D, local.E, local.A, local.B, R(63) );
P( local.B, local.C, local.D, local.E, local.A, R(64) );
P( local.A, local.B, local.C, local.D, local.E, R(65) );
P( local.E, local.A, local.B, local.C, local.D, R(66) );
P( local.D, local.E, local.A, local.B, local.C, R(67) );
P( local.C, local.D, local.E, local.A, local.B, R(68) );
P( local.B, local.C, local.D, local.E, local.A, R(69) );
P( local.A, local.B, local.C, local.D, local.E, R(70) );
P( local.E, local.A, local.B, local.C, local.D, R(71) );
P( local.D, local.E, local.A, local.B, local.C, R(72) );
P( local.C, local.D, local.E, local.A, local.B, R(73) );
P( local.B, local.C, local.D, local.E, local.A, R(74) );
P( local.A, local.B, local.C, local.D, local.E, R(75) );
P( local.E, local.A, local.B, local.C, local.D, R(76) );
P( local.D, local.E, local.A, local.B, local.C, R(77) );
P( local.C, local.D, local.E, local.A, local.B, R(78) );
P( local.B, local.C, local.D, local.E, local.A, R(79) );
#undef K
#undef F
ctx->state[0] += local.A;
ctx->state[1] += local.B;
ctx->state[2] += local.C;
ctx->state[3] += local.D;
ctx->state[4] += local.E;
/* Zeroise buffers and variables to clear sensitive data from memory. */
mbedtls_platform_zeroize( &local, sizeof( local ) );
#endif /* MBEDTLS_SHA1_SMALLER */
return( 0 );
}
#endif /* !MBEDTLS_SHA1_PROCESS_ALT */
/**
* \brief This function feeds an input buffer into an ongoing SHA-1
* checksum calculation.
*
* \warning SHA-1 is considered a weak message digest and its use
* constitutes a security risk. We recommend considering
* stronger message digests instead.
*
* \param ctx The SHA-1 context. This must be initialized
* and have a hash operation started.
* \param input The buffer holding the input data.
* This must be a readable buffer of length \p ilen Bytes.
* \param ilen The length of the input data \p input in Bytes.
*
* \return \c 0 on success.
* \return A negative error code on failure.
*/
int mbedtls_sha1_update_ret( mbedtls_sha1_context *ctx,
const unsigned char *input,
size_t ilen )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
uint32_t left;
size_t n, fill;
SHA1_VALIDATE_RET( ctx != NULL );
SHA1_VALIDATE_RET( ilen == 0 || input != NULL );
if( ilen == 0 )
return( 0 );
left = ctx->total[0] & 0x3F;
fill = 64 - left;
ctx->total[0] += (uint32_t) ilen;
ctx->total[0] &= 0xFFFFFFFF;
if( ctx->total[0] < (uint32_t) ilen )
ctx->total[1]++;
if( left && ilen >= fill )
{
memcpy( (void *) (ctx->buffer + left), input, fill );
if( ( ret = mbedtls_internal_sha1_process( ctx, ctx->buffer ) ) != 0 )
return( ret );
input += fill;
ilen -= fill;
left = 0;
}
if( ilen >= 64 )
{
if( ( !IsTiny() || X86_NEED(SHA) ) && X86_HAVE( SHA ) )
{
if( IsAsan() )
__asan_verify( input, ilen );
sha1_transform_ni( ctx->state, input, ilen / 64 );
input += ROUNDDOWN( ilen, 64 );
ilen -= ROUNDDOWN( ilen, 64 );
}
else if( !IsTiny() &&
X86_HAVE( BMI ) &&
X86_HAVE( BMI2 ) &&
X86_HAVE( AVX2 ) )
{
if( IsAsan() )
__asan_verify( input, ilen );
sha1_transform_avx2( ctx->state, input, ilen / 64 );
input += ROUNDDOWN( ilen, 64 );
ilen -= ROUNDDOWN( ilen, 64 );
}
else
{
do
{
if(( ret = mbedtls_internal_sha1_process( ctx, input ) ))
return( ret );
input += 64;
ilen -= 64;
}
while( ilen >= 64 );
}
}
if( ilen > 0 )
memcpy( (void *) (ctx->buffer + left), input, ilen );
return( 0 );
}
/**
* \brief This function finishes the SHA-1 operation, and writes
* the result to the output buffer.
*
* \warning SHA-1 is considered a weak message digest and its use
* constitutes a security risk. We recommend considering
* stronger message digests instead.
*
* \param ctx The SHA-1 context to use. This must be initialized and
* have a hash operation started.
* \param output The SHA-1 checksum result. This must be a writable
* buffer of length \c 20 Bytes.
*
* \return \c 0 on success.
* \return A negative error code on failure.
*/
int mbedtls_sha1_finish_ret( mbedtls_sha1_context *ctx,
unsigned char output[20] )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
uint32_t used;
uint32_t high, low;
SHA1_VALIDATE_RET( ctx != NULL );
SHA1_VALIDATE_RET( (unsigned char *)output != NULL );
/*
* Add padding: 0x80 then 0x00 until 8 bytes remain for the length
*/
used = ctx->total[0] & 0x3F;
ctx->buffer[used++] = 0x80;
if( used <= 56 )
{
/* Enough room for padding + length in current block */
mbedtls_platform_zeroize( ctx->buffer + used, 56 - used );
}
else
{
/* We'll need an extra block */
mbedtls_platform_zeroize( ctx->buffer + used, 64 - used );
if( ( ret = mbedtls_internal_sha1_process( ctx, ctx->buffer ) ) != 0 )
return( ret );
mbedtls_platform_zeroize( ctx->buffer, 56 );
}
/*
* Add message length
*/
high = ( ctx->total[0] >> 29 )
| ( ctx->total[1] << 3 );
low = ( ctx->total[0] << 3 );
PUT_UINT32_BE( high, ctx->buffer, 56 );
PUT_UINT32_BE( low, ctx->buffer, 60 );
if( ( ret = mbedtls_internal_sha1_process( ctx, ctx->buffer ) ) != 0 )
return( ret );
/*
* Output final state
*/
PUT_UINT32_BE( ctx->state[0], output, 0 );
PUT_UINT32_BE( ctx->state[1], output, 4 );
PUT_UINT32_BE( ctx->state[2], output, 8 );
PUT_UINT32_BE( ctx->state[3], output, 12 );
PUT_UINT32_BE( ctx->state[4], output, 16 );
return( 0 );
}
/**
* \brief This function calculates the SHA-1 checksum of a buffer.
*
* The function allocates the context, performs the
* calculation, and frees the context.
*
* The SHA-1 result is calculated as
* output = SHA-1(input buffer).
*
* \warning SHA-1 is considered a weak message digest and its use
* constitutes a security risk. We recommend considering
* stronger message digests instead.
*
* \param input The buffer holding the input data.
* This must be a readable buffer of length \p ilen Bytes.
* \param ilen The length of the input data \p input in Bytes.
* \param output The SHA-1 checksum result.
* This must be a writable buffer of length \c 20 Bytes.
*
* \return \c 0 on success.
* \return A negative error code on failure.
*
*/
int mbedtls_sha1_ret( const void *input,
size_t ilen,
unsigned char output[20] )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
mbedtls_sha1_context ctx;
SHA1_VALIDATE_RET( ilen == 0 || input != NULL );
SHA1_VALIDATE_RET( (unsigned char *)output != NULL );
mbedtls_sha1_init( &ctx );
if( ( ret = mbedtls_sha1_starts_ret( &ctx ) ) != 0 )
goto exit;
if( ( ret = mbedtls_sha1_update_ret( &ctx, input, ilen ) ) != 0 )
goto exit;
if( ( ret = mbedtls_sha1_finish_ret( &ctx, output ) ) != 0 )
goto exit;
exit:
mbedtls_sha1_free( &ctx );
return( ret );
}
const mbedtls_md_info_t mbedtls_sha1_info = {
"SHA1",
MBEDTLS_MD_SHA1,
20,
64,
(void *)mbedtls_sha1_starts_ret,
(void *)mbedtls_sha1_update_ret,
(void *)mbedtls_internal_sha1_process,
(void *)mbedtls_sha1_finish_ret,
(void *)mbedtls_sha1_ret,
};
| 21,262 | 580 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/hkdf.h | #ifndef COSMOPOLITAN_THIRD_PARTY_MBEDTLS_HKDF_H_
#define COSMOPOLITAN_THIRD_PARTY_MBEDTLS_HKDF_H_
#include "third_party/mbedtls/config.h"
#include "third_party/mbedtls/md.h"
#if !(__ASSEMBLER__ + __LINKER__ + 0)
COSMOPOLITAN_C_START_
/* clang-format off */
#define MBEDTLS_ERR_HKDF_BAD_INPUT_DATA -0x5F80 /*< Bad input parameters to function. */
/* clang-format on */
int mbedtls_hkdf(const mbedtls_md_info_t *, const unsigned char *, size_t,
const unsigned char *, size_t, const unsigned char *, size_t,
unsigned char *, size_t);
int mbedtls_hkdf_extract(const mbedtls_md_info_t *, const unsigned char *,
size_t, const unsigned char *, size_t,
unsigned char *);
int mbedtls_hkdf_expand(const mbedtls_md_info_t *, const unsigned char *,
size_t, const unsigned char *, size_t, unsigned char *,
size_t);
COSMOPOLITAN_C_END_
#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
#endif /* COSMOPOLITAN_THIRD_PARTY_MBEDTLS_HKDF_H_ */
| 1,060 | 25 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/ctr_drbg.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:4;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright The Mbed TLS Contributors â
â â
â Licensed under the Apache License, Version 2.0 (the "License"); â
â you may not use this file except in compliance with the License. â
â You may obtain a copy of the License at â
â â
â http://www.apache.org/licenses/LICENSE-2.0 â
â â
â Unless required by applicable law or agreed to in writing, software â
â distributed under the License is distributed on an "AS IS" BASIS, â
â WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. â
â See the License for the specific language governing permissions and â
â limitations under the License. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/stdio/stdio.h"
#include "libc/str/str.h"
#include "third_party/mbedtls/common.h"
#include "third_party/mbedtls/ctr_drbg.h"
#include "third_party/mbedtls/error.h"
#include "third_party/mbedtls/platform.h"
/* clang-format off */
asm(".ident\t\"\\n\\n\
Mbed TLS (Apache 2.0)\\n\
Copyright ARM Limited\\n\
Copyright Mbed TLS Contributors\"");
asm(".include \"libc/disclaimer.inc\"");
/**
* @fileoverview CTR_DRBG implementation based on AES-256 (NIST SP 800-90)
*
* The NIST SP 800-90 DRBGs are described in the following publication.
*
* http://csrc.nist.gov/publications/nistpubs/800-90/SP800-90revised_March2007.pdf
*/
/**
* \brief This function initializes the CTR_DRBG context,
* and prepares it for mbedtls_ctr_drbg_seed()
* or mbedtls_ctr_drbg_free().
*
* \note The reseed interval is
* #MBEDTLS_CTR_DRBG_RESEED_INTERVAL by default.
* You can override it by calling
* mbedtls_ctr_drbg_set_reseed_interval().
*
* \param ctx The CTR_DRBG context to initialize.
*/
void mbedtls_ctr_drbg_init( mbedtls_ctr_drbg_context *ctx )
{
mbedtls_platform_zeroize( ctx, sizeof( mbedtls_ctr_drbg_context ) );
/* Indicate that the entropy nonce length is not set explicitly.
* See mbedtls_ctr_drbg_set_nonce_len(). */
ctx->reseed_counter = -1;
ctx->reseed_interval = MBEDTLS_CTR_DRBG_RESEED_INTERVAL;
}
/*
* This function resets CTR_DRBG context to the state immediately
* after initial call of mbedtls_ctr_drbg_init().
*/
void mbedtls_ctr_drbg_free( mbedtls_ctr_drbg_context *ctx )
{
if( ctx == NULL )
return;
mbedtls_aes_free( &ctx->aes_ctx );
mbedtls_platform_zeroize( ctx, sizeof( mbedtls_ctr_drbg_context ) );
ctx->reseed_interval = MBEDTLS_CTR_DRBG_RESEED_INTERVAL;
ctx->reseed_counter = -1;
}
void mbedtls_ctr_drbg_set_prediction_resistance( mbedtls_ctr_drbg_context *ctx,
int resistance )
{
ctx->prediction_resistance = resistance;
}
void mbedtls_ctr_drbg_set_entropy_len( mbedtls_ctr_drbg_context *ctx,
size_t len )
{
ctx->entropy_len = len;
}
int mbedtls_ctr_drbg_set_nonce_len( mbedtls_ctr_drbg_context *ctx,
size_t len )
{
/* If mbedtls_ctr_drbg_seed() has already been called, it's
* too late. Return the error code that's closest to making sense. */
if( ctx->f_entropy != NULL )
return( MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED );
if( len > MBEDTLS_CTR_DRBG_MAX_SEED_INPUT )
return( MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG );
#if SIZE_MAX > INT_MAX
/* This shouldn't be an issue because
* MBEDTLS_CTR_DRBG_MAX_SEED_INPUT < INT_MAX in any sensible
* configuration, but make sure anyway. */
if( len > INT_MAX )
return( MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG );
#endif
/* For backward compatibility with Mbed TLS <= 2.19, store the
* entropy nonce length in a field that already exists, but isn't
* used until after the initial seeding. */
/* Due to the capping of len above, the value fits in an int. */
ctx->reseed_counter = (int) len;
return( 0 );
}
void mbedtls_ctr_drbg_set_reseed_interval( mbedtls_ctr_drbg_context *ctx,
int interval )
{
ctx->reseed_interval = interval;
}
static int block_cipher_df( unsigned char *output,
const unsigned char *data, size_t data_len )
{
unsigned char buf[MBEDTLS_CTR_DRBG_MAX_SEED_INPUT +
MBEDTLS_CTR_DRBG_BLOCKSIZE + 16];
unsigned char tmp[MBEDTLS_CTR_DRBG_SEEDLEN];
unsigned char key[MBEDTLS_CTR_DRBG_KEYSIZE];
unsigned char chain[MBEDTLS_CTR_DRBG_BLOCKSIZE];
unsigned char *p, *iv;
mbedtls_aes_context aes_ctx;
int ret = 0;
int i, j;
size_t buf_len, use_len;
if( data_len > MBEDTLS_CTR_DRBG_MAX_SEED_INPUT )
return( MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG );
mbedtls_platform_zeroize( buf, MBEDTLS_CTR_DRBG_MAX_SEED_INPUT +
MBEDTLS_CTR_DRBG_BLOCKSIZE + 16 );
mbedtls_aes_init( &aes_ctx );
/*
* Construct IV (16 bytes) and S in buffer
* IV = Counter (in 32-bits) padded to 16 with zeroes
* S = Length input string (in 32-bits) || Length of output (in 32-bits) ||
* data || 0x80
* (Total is padded to a multiple of 16-bytes with zeroes)
*/
p = buf + MBEDTLS_CTR_DRBG_BLOCKSIZE;
*p++ = ( data_len >> 24 ) & 0xff;
*p++ = ( data_len >> 16 ) & 0xff;
*p++ = ( data_len >> 8 ) & 0xff;
*p++ = ( data_len ) & 0xff;
p += 3;
*p++ = MBEDTLS_CTR_DRBG_SEEDLEN;
memcpy( p, data, data_len );
p[data_len] = 0x80;
buf_len = MBEDTLS_CTR_DRBG_BLOCKSIZE + 8 + data_len + 1;
for( i = 0; i < MBEDTLS_CTR_DRBG_KEYSIZE; i++ )
key[i] = i;
if( ( ret = mbedtls_aes_setkey_enc( &aes_ctx, key,
MBEDTLS_CTR_DRBG_KEYBITS ) ) != 0 )
{
goto exit;
}
/*
* Reduce data to MBEDTLS_CTR_DRBG_SEEDLEN bytes of data
*/
for( j = 0; j < MBEDTLS_CTR_DRBG_SEEDLEN; j += MBEDTLS_CTR_DRBG_BLOCKSIZE )
{
p = buf;
mbedtls_platform_zeroize( chain, MBEDTLS_CTR_DRBG_BLOCKSIZE );
use_len = buf_len;
while( use_len > 0 )
{
for( i = 0; i < MBEDTLS_CTR_DRBG_BLOCKSIZE; i++ )
chain[i] ^= p[i];
p += MBEDTLS_CTR_DRBG_BLOCKSIZE;
use_len -= ( use_len >= MBEDTLS_CTR_DRBG_BLOCKSIZE ) ?
MBEDTLS_CTR_DRBG_BLOCKSIZE : use_len;
if( ( ret = mbedtls_aes_crypt_ecb( &aes_ctx, MBEDTLS_AES_ENCRYPT,
chain, chain ) ) != 0 )
{
goto exit;
}
}
memcpy( tmp + j, chain, MBEDTLS_CTR_DRBG_BLOCKSIZE );
/*
* Update IV
*/
buf[3]++;
}
/*
* Do final encryption with reduced data
*/
if( ( ret = mbedtls_aes_setkey_enc( &aes_ctx, tmp,
MBEDTLS_CTR_DRBG_KEYBITS ) ) != 0 )
{
goto exit;
}
iv = tmp + MBEDTLS_CTR_DRBG_KEYSIZE;
p = output;
for( j = 0; j < MBEDTLS_CTR_DRBG_SEEDLEN; j += MBEDTLS_CTR_DRBG_BLOCKSIZE )
{
if( ( ret = mbedtls_aes_crypt_ecb( &aes_ctx, MBEDTLS_AES_ENCRYPT,
iv, iv ) ) != 0 )
{
goto exit;
}
memcpy( p, iv, MBEDTLS_CTR_DRBG_BLOCKSIZE );
p += MBEDTLS_CTR_DRBG_BLOCKSIZE;
}
exit:
mbedtls_aes_free( &aes_ctx );
/*
* tidy up the stack
*/
mbedtls_platform_zeroize( buf, sizeof( buf ) );
mbedtls_platform_zeroize( tmp, sizeof( tmp ) );
mbedtls_platform_zeroize( key, sizeof( key ) );
mbedtls_platform_zeroize( chain, sizeof( chain ) );
if( 0 != ret )
{
/*
* wipe partial seed from memory
*/
mbedtls_platform_zeroize( output, MBEDTLS_CTR_DRBG_SEEDLEN );
}
return( ret );
}
/* CTR_DRBG_Update (SP 800-90A §10.2.1.2)
* ctr_drbg_update_internal(ctx, provided_data)
* implements
* CTR_DRBG_Update(provided_data, Key, V)
* with inputs and outputs
* ctx->aes_ctx = Key
* ctx->counter = V
*/
static int ctr_drbg_update_internal( mbedtls_ctr_drbg_context *ctx,
const unsigned char data[MBEDTLS_CTR_DRBG_SEEDLEN] )
{
unsigned char tmp[MBEDTLS_CTR_DRBG_SEEDLEN];
unsigned char *p = tmp;
int i, j;
int ret = 0;
mbedtls_platform_zeroize( tmp, MBEDTLS_CTR_DRBG_SEEDLEN );
for( j = 0; j < MBEDTLS_CTR_DRBG_SEEDLEN; j += MBEDTLS_CTR_DRBG_BLOCKSIZE )
{
/*
* Increase counter
*/
for( i = MBEDTLS_CTR_DRBG_BLOCKSIZE; i > 0; i-- )
if( ++ctx->counter[i - 1] != 0 )
break;
/*
* Crypt counter block
*/
if( ( ret = mbedtls_aes_crypt_ecb( &ctx->aes_ctx, MBEDTLS_AES_ENCRYPT,
ctx->counter, p ) ) != 0 )
{
goto exit;
}
p += MBEDTLS_CTR_DRBG_BLOCKSIZE;
}
for( i = 0; i < MBEDTLS_CTR_DRBG_SEEDLEN; i++ )
tmp[i] ^= data[i];
/*
* Update key and counter
*/
if( ( ret = mbedtls_aes_setkey_enc( &ctx->aes_ctx, tmp,
MBEDTLS_CTR_DRBG_KEYBITS ) ) != 0 )
{
goto exit;
}
memcpy( ctx->counter, tmp + MBEDTLS_CTR_DRBG_KEYSIZE,
MBEDTLS_CTR_DRBG_BLOCKSIZE );
exit:
mbedtls_platform_zeroize( tmp, sizeof( tmp ) );
return( ret );
}
/* CTR_DRBG_Instantiate with derivation function (SP 800-90A §10.2.1.3.2)
* mbedtls_ctr_drbg_update(ctx, additional, add_len)
* implements
* CTR_DRBG_Instantiate(entropy_input, nonce, personalization_string,
* security_strength) -> initial_working_state
* with inputs
* ctx->counter = all-bits-0
* ctx->aes_ctx = context from all-bits-0 key
* additional[:add_len] = entropy_input || nonce || personalization_string
* and with outputs
* ctx = initial_working_state
*/
int mbedtls_ctr_drbg_update_ret( mbedtls_ctr_drbg_context *ctx,
const unsigned char *additional,
size_t add_len )
{
unsigned char add_input[MBEDTLS_CTR_DRBG_SEEDLEN];
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
if( add_len == 0 )
return( 0 );
if( ( ret = block_cipher_df( add_input, additional, add_len ) ) != 0 )
goto exit;
if( ( ret = ctr_drbg_update_internal( ctx, add_input ) ) != 0 )
goto exit;
exit:
mbedtls_platform_zeroize( add_input, sizeof( add_input ) );
return( ret );
}
/* CTR_DRBG_Reseed with derivation function (SP 800-90A §10.2.1.4.2)
* mbedtls_ctr_drbg_reseed(ctx, additional, len, nonce_len)
* implements
* CTR_DRBG_Reseed(working_state, entropy_input, additional_input)
* -> new_working_state
* with inputs
* ctx contains working_state
* additional[:len] = additional_input
* and entropy_input comes from calling ctx->f_entropy
* for (ctx->entropy_len + nonce_len) bytes
* and with output
* ctx contains new_working_state
*/
static int mbedtls_ctr_drbg_reseed_internal( mbedtls_ctr_drbg_context *ctx,
const unsigned char *additional,
size_t len,
size_t nonce_len )
{
unsigned char seed[MBEDTLS_CTR_DRBG_MAX_SEED_INPUT];
size_t seedlen = 0;
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
if( ctx->entropy_len > MBEDTLS_CTR_DRBG_MAX_SEED_INPUT )
return( MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG );
if( nonce_len > MBEDTLS_CTR_DRBG_MAX_SEED_INPUT - ctx->entropy_len )
return( MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG );
if( len > MBEDTLS_CTR_DRBG_MAX_SEED_INPUT - ctx->entropy_len - nonce_len )
return( MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG );
mbedtls_platform_zeroize( seed, MBEDTLS_CTR_DRBG_MAX_SEED_INPUT );
/* Gather entropy_len bytes of entropy to seed state. */
if( 0 != ctx->f_entropy( ctx->p_entropy, seed, ctx->entropy_len ) )
{
return( MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED );
}
seedlen += ctx->entropy_len;
/* Gather entropy for a nonce if requested. */
if( nonce_len != 0 )
{
if( 0 != ctx->f_entropy( ctx->p_entropy, seed + seedlen, nonce_len ) )
{
return( MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED );
}
seedlen += nonce_len;
}
/* Add additional data if provided. */
if( additional != NULL && len != 0 )
{
memcpy( seed + seedlen, additional, len );
seedlen += len;
}
/* Reduce to 384 bits. */
if( ( ret = block_cipher_df( seed, seed, seedlen ) ) != 0 )
goto exit;
/* Update state. */
if( ( ret = ctr_drbg_update_internal( ctx, seed ) ) != 0 )
goto exit;
ctx->reseed_counter = 1;
exit:
mbedtls_platform_zeroize( seed, sizeof( seed ) );
return( ret );
}
int mbedtls_ctr_drbg_reseed( mbedtls_ctr_drbg_context *ctx,
const void *additional, size_t len )
{
return( mbedtls_ctr_drbg_reseed_internal( ctx, additional, len, 0 ) );
}
/* Return a "good" nonce length for CTR_DRBG. The chosen nonce length
* is sufficient to achieve the maximum security strength given the key
* size and entropy length. If there is enough entropy in the initial
* call to the entropy function to serve as both the entropy input and
* the nonce, don't make a second call to get a nonce. */
static size_t good_nonce_len( size_t entropy_len )
{
if( entropy_len >= MBEDTLS_CTR_DRBG_KEYSIZE * 3 / 2 )
return( 0 );
else
return( ( entropy_len + 1 ) / 2 );
}
/* CTR_DRBG_Instantiate with derivation function (SP 800-90A §10.2.1.3.2)
* mbedtls_ctr_drbg_seed(ctx, f_entropy, p_entropy, custom, len)
* implements
* CTR_DRBG_Instantiate(entropy_input, nonce, personalization_string,
* security_strength) -> initial_working_state
* with inputs
* custom[:len] = nonce || personalization_string
* where entropy_input comes from f_entropy for ctx->entropy_len bytes
* and with outputs
* ctx = initial_working_state
*/
int mbedtls_ctr_drbg_seed( mbedtls_ctr_drbg_context *ctx,
int (*f_entropy)(void *, unsigned char *, size_t),
void *p_entropy,
const void *custom,
size_t len )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
unsigned char key[MBEDTLS_CTR_DRBG_KEYSIZE];
size_t nonce_len;
mbedtls_platform_zeroize( key, MBEDTLS_CTR_DRBG_KEYSIZE );
mbedtls_aes_init( &ctx->aes_ctx );
ctx->f_entropy = f_entropy;
ctx->p_entropy = p_entropy;
if( ctx->entropy_len == 0 )
ctx->entropy_len = MBEDTLS_CTR_DRBG_ENTROPY_LEN;
/* ctx->reseed_counter contains the desired amount of entropy to
* grab for a nonce (see mbedtls_ctr_drbg_set_nonce_len()).
* If it's -1, indicating that the entropy nonce length was not set
* explicitly, use a sufficiently large nonce for security. */
nonce_len = ( ctx->reseed_counter >= 0 ?
(size_t) ctx->reseed_counter :
good_nonce_len( ctx->entropy_len ) );
/* Initialize with an empty key. */
if( ( ret = mbedtls_aes_setkey_enc( &ctx->aes_ctx, key,
MBEDTLS_CTR_DRBG_KEYBITS ) ) != 0 )
{
return( ret );
}
/* Do the initial seeding. */
if( ( ret = mbedtls_ctr_drbg_reseed_internal( ctx, custom, len,
nonce_len ) ) != 0 )
{
return( ret );
}
return( 0 );
}
/* CTR_DRBG_Generate with derivation function (SP 800-90A §10.2.1.5.2)
* mbedtls_ctr_drbg_random_with_add(ctx, output, output_len, additional, add_len)
* implements
* CTR_DRBG_Reseed(working_state, entropy_input, additional[:add_len])
* -> working_state_after_reseed
* if required, then
* CTR_DRBG_Generate(working_state_after_reseed,
* requested_number_of_bits, additional_input)
* -> status, returned_bits, new_working_state
* with inputs
* ctx contains working_state
* requested_number_of_bits = 8 * output_len
* additional[:add_len] = additional_input
* and entropy_input comes from calling ctx->f_entropy
* and with outputs
* status = SUCCESS (this function does the reseed internally)
* returned_bits = output[:output_len]
* ctx contains new_working_state
*/
int mbedtls_ctr_drbg_random_with_add( void *p_rng,
unsigned char *output, size_t output_len,
const unsigned char *additional, size_t add_len )
{
int ret = 0;
mbedtls_ctr_drbg_context *ctx = (mbedtls_ctr_drbg_context *) p_rng;
unsigned char add_input[MBEDTLS_CTR_DRBG_SEEDLEN];
unsigned char *p = output;
unsigned char tmp[MBEDTLS_CTR_DRBG_BLOCKSIZE];
int i;
size_t use_len;
if( output_len > MBEDTLS_CTR_DRBG_MAX_REQUEST )
return( MBEDTLS_ERR_CTR_DRBG_REQUEST_TOO_BIG );
if( add_len > MBEDTLS_CTR_DRBG_MAX_INPUT )
return( MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG );
mbedtls_platform_zeroize( add_input, MBEDTLS_CTR_DRBG_SEEDLEN );
if( ctx->reseed_counter > ctx->reseed_interval ||
ctx->prediction_resistance )
{
if( ( ret = mbedtls_ctr_drbg_reseed( ctx, additional, add_len ) ) != 0 )
{
return( ret );
}
add_len = 0;
}
if( add_len > 0 )
{
if( ( ret = block_cipher_df( add_input, additional, add_len ) ) != 0 )
goto exit;
if( ( ret = ctr_drbg_update_internal( ctx, add_input ) ) != 0 )
goto exit;
}
while( output_len > 0 )
{
/*
* Increase counter
*/
for( i = MBEDTLS_CTR_DRBG_BLOCKSIZE; i > 0; i-- )
if( ++ctx->counter[i - 1] != 0 )
break;
/*
* Crypt counter block
*/
if( ( ret = mbedtls_aes_crypt_ecb( &ctx->aes_ctx, MBEDTLS_AES_ENCRYPT,
ctx->counter, tmp ) ) != 0 )
{
goto exit;
}
use_len = ( output_len > MBEDTLS_CTR_DRBG_BLOCKSIZE )
? MBEDTLS_CTR_DRBG_BLOCKSIZE : output_len;
/*
* Copy random block to destination
*/
memcpy( p, tmp, use_len );
p += use_len;
output_len -= use_len;
}
if( ( ret = ctr_drbg_update_internal( ctx, add_input ) ) != 0 )
goto exit;
ctx->reseed_counter++;
exit:
mbedtls_platform_zeroize( add_input, sizeof( add_input ) );
mbedtls_platform_zeroize( tmp, sizeof( tmp ) );
return( ret );
}
/**
* \brief This function uses CTR_DRBG to generate random data.
*
* This function automatically reseeds if the reseed counter is exceeded
* or prediction resistance is enabled.
*
* \param p_rng The CTR_DRBG context. This must be a pointer to a
* #mbedtls_ctr_drbg_context structure.
* \param output The buffer to fill.
* \param output_len The length of the buffer in bytes.
*
* \return \c 0 on success.
* \return #MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED or
* #MBEDTLS_ERR_CTR_DRBG_REQUEST_TOO_BIG on failure.
*/
int mbedtls_ctr_drbg_random( void *p_rng, unsigned char *output,
size_t output_len )
{
mbedtls_ctr_drbg_context *ctx = (mbedtls_ctr_drbg_context *) p_rng;
return mbedtls_ctr_drbg_random_with_add( ctx, output, output_len, NULL, 0 );
}
#if defined(MBEDTLS_FS_IO)
int mbedtls_ctr_drbg_write_seed_file( mbedtls_ctr_drbg_context *ctx,
const char *path )
{
int ret = MBEDTLS_ERR_CTR_DRBG_FILE_IO_ERROR;
FILE *f;
unsigned char buf[ MBEDTLS_CTR_DRBG_MAX_INPUT ];
if( ( f = fopen( path, "wb" ) ) == NULL )
return( MBEDTLS_ERR_CTR_DRBG_FILE_IO_ERROR );
if( ( ret = mbedtls_ctr_drbg_random( ctx, buf,
MBEDTLS_CTR_DRBG_MAX_INPUT ) ) != 0 )
goto exit;
if( fwrite( buf, 1, MBEDTLS_CTR_DRBG_MAX_INPUT, f ) !=
MBEDTLS_CTR_DRBG_MAX_INPUT )
{
ret = MBEDTLS_ERR_CTR_DRBG_FILE_IO_ERROR;
}
else
{
ret = 0;
}
exit:
mbedtls_platform_zeroize( buf, sizeof( buf ) );
fclose( f );
return( ret );
}
int mbedtls_ctr_drbg_update_seed_file( mbedtls_ctr_drbg_context *ctx,
const char *path )
{
int ret = 0;
FILE *f = NULL;
size_t n;
unsigned char buf[ MBEDTLS_CTR_DRBG_MAX_INPUT ];
unsigned char c;
if( ( f = fopen( path, "rb" ) ) == NULL )
return( MBEDTLS_ERR_CTR_DRBG_FILE_IO_ERROR );
n = fread( buf, 1, sizeof( buf ), f );
if( fread( &c, 1, 1, f ) != 0 )
{
ret = MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG;
goto exit;
}
if( n == 0 || ferror( f ) )
{
ret = MBEDTLS_ERR_CTR_DRBG_FILE_IO_ERROR;
goto exit;
}
fclose( f );
f = NULL;
ret = mbedtls_ctr_drbg_update_ret( ctx, buf, n );
exit:
mbedtls_platform_zeroize( buf, sizeof( buf ) );
if( f != NULL )
fclose( f );
if( ret != 0 )
return( ret );
return( mbedtls_ctr_drbg_write_seed_file( ctx, path ) );
}
#endif /* MBEDTLS_FS_IO */
#if defined(MBEDTLS_SELF_TEST)
/* The CTR_DRBG NIST test vectors used here are available at
* https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Algorithm-Validation-Program/documents/drbg/drbgtestvectors.zip
*
* The parameters used to derive the test data are:
*
* [AES-128 use df]
* [PredictionResistance = True/False]
* [EntropyInputLen = 128]
* [NonceLen = 64]
* [PersonalizationStringLen = 128]
* [AdditionalInputLen = 0]
* [ReturnedBitsLen = 512]
*
* [AES-256 use df]
* [PredictionResistance = True/False]
* [EntropyInputLen = 256]
* [NonceLen = 128]
* [PersonalizationStringLen = 256]
* [AdditionalInputLen = 0]
* [ReturnedBitsLen = 512]
*
*/
#if defined(MBEDTLS_CTR_DRBG_USE_128_BIT_KEY)
static const unsigned char entropy_source_pr[] =
{ 0x04, 0xd9, 0x49, 0xa6, 0xdc, 0xe8, 0x6e, 0xbb,
0xf1, 0x08, 0x77, 0x2b, 0x9e, 0x08, 0xca, 0x92,
0x65, 0x16, 0xda, 0x99, 0xa2, 0x59, 0xf3, 0xe8,
0x38, 0x7e, 0x3f, 0x6b, 0x51, 0x70, 0x7b, 0x20,
0xec, 0x53, 0xd0, 0x66, 0xc3, 0x0f, 0xe3, 0xb0,
0xe0, 0x86, 0xa6, 0xaa, 0x5f, 0x72, 0x2f, 0xad,
0xf7, 0xef, 0x06, 0xb8, 0xd6, 0x9c, 0x9d, 0xe8 };
static const unsigned char entropy_source_nopr[] =
{ 0x07, 0x0d, 0x59, 0x63, 0x98, 0x73, 0xa5, 0x45,
0x27, 0x38, 0x22, 0x7b, 0x76, 0x85, 0xd1, 0xa9,
0x74, 0x18, 0x1f, 0x3c, 0x22, 0xf6, 0x49, 0x20,
0x4a, 0x47, 0xc2, 0xf3, 0x85, 0x16, 0xb4, 0x6f,
0x00, 0x2e, 0x71, 0xda, 0xed, 0x16, 0x9b, 0x5c };
static const unsigned char pers_pr[] =
{ 0xbf, 0xa4, 0x9a, 0x8f, 0x7b, 0xd8, 0xb1, 0x7a,
0x9d, 0xfa, 0x45, 0xed, 0x21, 0x52, 0xb3, 0xad };
static const unsigned char pers_nopr[] =
{ 0x4e, 0x61, 0x79, 0xd4, 0xc2, 0x72, 0xa1, 0x4c,
0xf1, 0x3d, 0xf6, 0x5e, 0xa3, 0xa6, 0xe5, 0x0f };
static const unsigned char result_pr[] =
{ 0xc9, 0x0a, 0xaf, 0x85, 0x89, 0x71, 0x44, 0x66,
0x4f, 0x25, 0x0b, 0x2b, 0xde, 0xd8, 0xfa, 0xff,
0x52, 0x5a, 0x1b, 0x32, 0x5e, 0x41, 0x7a, 0x10,
0x1f, 0xef, 0x1e, 0x62, 0x23, 0xe9, 0x20, 0x30,
0xc9, 0x0d, 0xad, 0x69, 0xb4, 0x9c, 0x5b, 0xf4,
0x87, 0x42, 0xd5, 0xae, 0x5e, 0x5e, 0x43, 0xcc,
0xd9, 0xfd, 0x0b, 0x93, 0x4a, 0xe3, 0xd4, 0x06,
0x37, 0x36, 0x0f, 0x3f, 0x72, 0x82, 0x0c, 0xcf };
static const unsigned char result_nopr[] =
{ 0x31, 0xc9, 0x91, 0x09, 0xf8, 0xc5, 0x10, 0x13,
0x3c, 0xd3, 0x96, 0xf9, 0xbc, 0x2c, 0x12, 0xc0,
0x7c, 0xc1, 0x61, 0x5f, 0xa3, 0x09, 0x99, 0xaf,
0xd7, 0xf2, 0x36, 0xfd, 0x40, 0x1a, 0x8b, 0xf2,
0x33, 0x38, 0xee, 0x1d, 0x03, 0x5f, 0x83, 0xb7,
0xa2, 0x53, 0xdc, 0xee, 0x18, 0xfc, 0xa7, 0xf2,
0xee, 0x96, 0xc6, 0xc2, 0xcd, 0x0c, 0xff, 0x02,
0x76, 0x70, 0x69, 0xaa, 0x69, 0xd1, 0x3b, 0xe8 };
#else /* MBEDTLS_CTR_DRBG_USE_128_BIT_KEY */
static const unsigned char entropy_source_pr[] =
{ 0xca, 0x58, 0xfd, 0xf2, 0xb9, 0x77, 0xcb, 0x49,
0xd4, 0xe0, 0x5b, 0xe2, 0x39, 0x50, 0xd9, 0x8a,
0x6a, 0xb3, 0xc5, 0x2f, 0xdf, 0x74, 0xd5, 0x85,
0x8f, 0xd1, 0xba, 0x64, 0x54, 0x7b, 0xdb, 0x1e,
0xc5, 0xea, 0x24, 0xc0, 0xfa, 0x0c, 0x90, 0x15,
0x09, 0x20, 0x92, 0x42, 0x32, 0x36, 0x45, 0x45,
0x7d, 0x20, 0x76, 0x6b, 0xcf, 0xa2, 0x15, 0xc8,
0x2f, 0x9f, 0xbc, 0x88, 0x3f, 0x80, 0xd1, 0x2c,
0xb7, 0x16, 0xd1, 0x80, 0x9e, 0xe1, 0xc9, 0xb3,
0x88, 0x1b, 0x21, 0x45, 0xef, 0xa1, 0x7f, 0xce,
0xc8, 0x92, 0x35, 0x55, 0x2a, 0xd9, 0x1d, 0x8e,
0x12, 0x38, 0xac, 0x01, 0x4e, 0x38, 0x18, 0x76,
0x9c, 0xf2, 0xb6, 0xd4, 0x13, 0xb6, 0x2c, 0x77,
0xc0, 0xe7, 0xe6, 0x0c, 0x47, 0x44, 0x95, 0xbe };
static const unsigned char entropy_source_nopr[] =
{ 0x4c, 0xfb, 0x21, 0x86, 0x73, 0x34, 0x6d, 0x9d,
0x50, 0xc9, 0x22, 0xe4, 0x9b, 0x0d, 0xfc, 0xd0,
0x90, 0xad, 0xf0, 0x4f, 0x5c, 0x3b, 0xa4, 0x73,
0x27, 0xdf, 0xcd, 0x6f, 0xa6, 0x3a, 0x78, 0x5c,
0x01, 0x69, 0x62, 0xa7, 0xfd, 0x27, 0x87, 0xa2,
0x4b, 0xf6, 0xbe, 0x47, 0xef, 0x37, 0x83, 0xf1,
0xb7, 0xec, 0x46, 0x07, 0x23, 0x63, 0x83, 0x4a,
0x1b, 0x01, 0x33, 0xf2, 0xc2, 0x38, 0x91, 0xdb,
0x4f, 0x11, 0xa6, 0x86, 0x51, 0xf2, 0x3e, 0x3a,
0x8b, 0x1f, 0xdc, 0x03, 0xb1, 0x92, 0xc7, 0xe7 };
static const unsigned char pers_pr[] =
{ 0x5a, 0x70, 0x95, 0xe9, 0x81, 0x40, 0x52, 0x33,
0x91, 0x53, 0x7e, 0x75, 0xd6, 0x19, 0x9d, 0x1e,
0xad, 0x0d, 0xc6, 0xa7, 0xde, 0x6c, 0x1f, 0xe0,
0xea, 0x18, 0x33, 0xa8, 0x7e, 0x06, 0x20, 0xe9 };
static const unsigned char pers_nopr[] =
{ 0x88, 0xee, 0xb8, 0xe0, 0xe8, 0x3b, 0xf3, 0x29,
0x4b, 0xda, 0xcd, 0x60, 0x99, 0xeb, 0xe4, 0xbf,
0x55, 0xec, 0xd9, 0x11, 0x3f, 0x71, 0xe5, 0xeb,
0xcb, 0x45, 0x75, 0xf3, 0xd6, 0xa6, 0x8a, 0x6b };
static const unsigned char result_pr[] =
{ 0xce, 0x2f, 0xdb, 0xb6, 0xd9, 0xb7, 0x39, 0x85,
0x04, 0xc5, 0xc0, 0x42, 0xc2, 0x31, 0xc6, 0x1d,
0x9b, 0x5a, 0x59, 0xf8, 0x7e, 0x0d, 0xcc, 0x62,
0x7b, 0x65, 0x11, 0x55, 0x10, 0xeb, 0x9e, 0x3d,
0xa4, 0xfb, 0x1c, 0x6a, 0x18, 0xc0, 0x74, 0xdb,
0xdd, 0xe7, 0x02, 0x23, 0x63, 0x21, 0xd0, 0x39,
0xf9, 0xa7, 0xc4, 0x52, 0x84, 0x3b, 0x49, 0x40,
0x72, 0x2b, 0xb0, 0x6c, 0x9c, 0xdb, 0xc3, 0x43 };
static const unsigned char result_nopr[] =
{ 0xa5, 0x51, 0x80, 0xa1, 0x90, 0xbe, 0xf3, 0xad,
0xaf, 0x28, 0xf6, 0xb7, 0x95, 0xe9, 0xf1, 0xf3,
0xd6, 0xdf, 0xa1, 0xb2, 0x7d, 0xd0, 0x46, 0x7b,
0x0c, 0x75, 0xf5, 0xfa, 0x93, 0x1e, 0x97, 0x14,
0x75, 0xb2, 0x7c, 0xae, 0x03, 0xa2, 0x96, 0x54,
0xe2, 0xf4, 0x09, 0x66, 0xea, 0x33, 0x64, 0x30,
0x40, 0xd1, 0x40, 0x0f, 0xe6, 0x77, 0x87, 0x3a,
0xf8, 0x09, 0x7c, 0x1f, 0xe9, 0xf0, 0x02, 0x98 };
#endif /* MBEDTLS_CTR_DRBG_USE_128_BIT_KEY */
static size_t test_offset;
static int ctr_drbg_self_test_entropy( void *data, unsigned char *buf,
size_t len )
{
const unsigned char *p = data;
memcpy( buf, p + test_offset, len );
test_offset += len;
return( 0 );
}
#define CHK( c ) if( (c) != 0 ) \
{ \
if( verbose != 0 ) \
mbedtls_printf( "failed\n" ); \
return( 1 ); \
}
#define SELF_TEST_OUPUT_DISCARD_LENGTH 64
/*
* Checkup routine
*/
int mbedtls_ctr_drbg_self_test( int verbose )
{
mbedtls_ctr_drbg_context ctx;
unsigned char buf[ sizeof( result_pr ) ];
mbedtls_ctr_drbg_init( &ctx );
/*
* Based on a NIST CTR_DRBG test vector (PR = True)
*/
if( verbose != 0 )
mbedtls_printf( " CTR_DRBG (PR = TRUE) : " );
test_offset = 0;
mbedtls_ctr_drbg_set_entropy_len( &ctx, MBEDTLS_CTR_DRBG_KEYSIZE );
mbedtls_ctr_drbg_set_nonce_len( &ctx, MBEDTLS_CTR_DRBG_KEYSIZE / 2 );
CHK( mbedtls_ctr_drbg_seed( &ctx,
ctr_drbg_self_test_entropy,
(void *) entropy_source_pr,
pers_pr, MBEDTLS_CTR_DRBG_KEYSIZE ) );
mbedtls_ctr_drbg_set_prediction_resistance( &ctx, MBEDTLS_CTR_DRBG_PR_ON );
CHK( mbedtls_ctr_drbg_random( &ctx, buf, SELF_TEST_OUPUT_DISCARD_LENGTH ) );
CHK( mbedtls_ctr_drbg_random( &ctx, buf, sizeof( result_pr ) ) );
CHK( timingsafe_bcmp( buf, result_pr, sizeof( result_pr ) ) );
mbedtls_ctr_drbg_free( &ctx );
if( verbose != 0 )
mbedtls_printf( "passed\n" );
/*
* Based on a NIST CTR_DRBG test vector (PR = FALSE)
*/
if( verbose != 0 )
mbedtls_printf( " CTR_DRBG (PR = FALSE): " );
mbedtls_ctr_drbg_init( &ctx );
test_offset = 0;
mbedtls_ctr_drbg_set_entropy_len( &ctx, MBEDTLS_CTR_DRBG_KEYSIZE);
mbedtls_ctr_drbg_set_nonce_len( &ctx, MBEDTLS_CTR_DRBG_KEYSIZE / 2 );
CHK( mbedtls_ctr_drbg_seed( &ctx,
ctr_drbg_self_test_entropy,
(void *) entropy_source_nopr,
pers_nopr, MBEDTLS_CTR_DRBG_KEYSIZE ) );
CHK( mbedtls_ctr_drbg_reseed( &ctx, NULL, 0 ) );
CHK( mbedtls_ctr_drbg_random( &ctx, buf, SELF_TEST_OUPUT_DISCARD_LENGTH ) );
CHK( mbedtls_ctr_drbg_random( &ctx, buf, sizeof( result_nopr ) ) );
CHK( timingsafe_bcmp( buf, result_nopr, sizeof( result_nopr ) ) );
mbedtls_ctr_drbg_free( &ctx );
if( verbose != 0 )
mbedtls_printf( "passed\n" );
if( verbose != 0 )
mbedtls_printf( "\n" );
return( 0 );
}
#endif /* MBEDTLS_SELF_TEST */
| 31,102 | 879 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/config.h | #ifndef MBEDTLS_CONFIG_H_
#define MBEDTLS_CONFIG_H_
/* protocols */
#define MBEDTLS_SSL_PROTO_TLS1_2
#ifndef TINY
#define MBEDTLS_SSL_PROTO_TLS1_1
#define MBEDTLS_SSL_PROTO_TLS1
/*#define MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL*/
/*#define MBEDTLS_SSL_PROTO_DTLS*/
/*#define MBEDTLS_SSL_PROTO_SSL3*/
#endif
/* hash functions */
#define MBEDTLS_MD5_C
#define MBEDTLS_SHA1_C
#define MBEDTLS_SHA256_C
#define MBEDTLS_SHA512_C
/* random numbers */
#define ENTROPY_HAVE_STRONG
#define MBEDTLS_CTR_DRBG_C
#define MBEDTLS_HMAC_DRBG_C
/*#define MBEDTLS_ENTROPY_FORCE_SHA256*/
/*#define MBEDTLS_TEST_NULL_ENTROPY*/
/* ciphers */
#define MBEDTLS_AES_C
#ifndef TINY
#define MBEDTLS_CHACHA20_C
#define MBEDTLS_POLY1305_C
#define MBEDTLS_CHACHAPOLY_C
#endif
#ifdef MBEDTLS_SSL_PROTO_TLS1
#define MBEDTLS_DES_C
#endif
/*#define MBEDTLS_CIPHER_NULL_CIPHER*/
/*#define MBEDTLS_ENABLE_WEAK_CIPHERSUITES*/
/*#define MBEDTLS_REMOVE_3DES_CIPHERSUITES*/
/* block modes */
#define MBEDTLS_GCM_C
#ifndef TINY
#define MBEDTLS_CIPHER_MODE_CBC
/*#define MBEDTLS_CCM_C*/
/*#define MBEDTLS_CIPHER_MODE_CFB*/
/*#define MBEDTLS_CIPHER_MODE_CTR*/
/*#define MBEDTLS_CIPHER_MODE_OFB*/
/*#define MBEDTLS_CIPHER_MODE_XTS*/
#endif
/* key exchange */
#define MBEDTLS_RSA_C
#define MBEDTLS_KEY_EXCHANGE_RSA_ENABLED
#define MBEDTLS_KEY_EXCHANGE_PSK_ENABLED
#define MBEDTLS_ECP_C
#define MBEDTLS_ECDH_C
#define MBEDTLS_ECDSA_C
#define MBEDTLS_ECDSA_DETERMINISTIC
#define MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED
#ifndef TINY
#define MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED
#define MBEDTLS_ECDH_VARIANT_EVEREST_ENABLED
#define MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED
#define MBEDTLS_DHM_C
#define MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED
/*#define MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED*/
/*#define MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED*/
/*#define MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED*/
/*#define MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED*/
#endif
/* eliptic curves */
#define MBEDTLS_ECP_DP_SECP256R1_ENABLED
#define MBEDTLS_ECP_DP_SECP384R1_ENABLED
#ifndef TINY
#define MBEDTLS_ECP_DP_CURVE25519_ENABLED
#define MBEDTLS_ECP_DP_CURVE448_ENABLED
/*#define MBEDTLS_ECP_DP_SECP521R1_ENABLED*/
/*#define MBEDTLS_ECP_DP_BP384R1_ENABLED*/
/*#define MBEDTLS_ECP_DP_SECP192R1_ENABLED*/
/*#define MBEDTLS_ECP_DP_SECP224R1_ENABLED*/
/*#define MBEDTLS_ECP_DP_SECP192K1_ENABLED*/
/*#define MBEDTLS_ECP_DP_SECP224K1_ENABLED*/
/*#define MBEDTLS_ECP_DP_SECP256K1_ENABLED*/
/*#define MBEDTLS_ECP_DP_BP256R1_ENABLED*/
/*#define MBEDTLS_ECP_DP_BP512R1_ENABLED*/
#endif
#define MBEDTLS_X509_CHECK_KEY_USAGE
#define MBEDTLS_X509_CHECK_EXTENDED_KEY_USAGE
/*#define MBEDTLS_X509_ALLOW_EXTENSIONS_NON_V3*/
/*#define MBEDTLS_X509_ALLOW_UNSUPPORTED_CRITICAL_EXTENSION*/
/* boringssl and mbedtls hold considerable disagreement */
#define MBEDTLS_CTR_DRBG_RESEED_INTERVAL 4096
#define MBEDTLS_HMAC_DRBG_RESEED_INTERVAL 4096
#define MBEDTLS_ENTROPY_MAX_SOURCES 4
#define MBEDTLS_X509_MAX_INTERMEDIATE_CA 8
/*
* Boosts performance from 230k qps to 330k
* Hardens against against sbox side channels
*/
#define MBEDTLS_AESNI_C
#if defined(__x86_64__) && !defined(TINY)
#define MBEDTLS_HAVE_X86_64
#define MBEDTLS_HAVE_SSE2
#endif
#ifndef TINY
/*
* TODO(jart): RHEL5 sends SSLv2 hello even though it supports TLS. Is
* DROWN really a problem if we turn this on? Since Google
* supports it on their website. SSLLabs says we're OK.
*/
#define MBEDTLS_SSL_SRV_SUPPORT_SSLV2_CLIENT_HELLO
#endif
#ifndef TINY
/*
* The CIA says "messages should be compressed prior to encryption"
* because "compression reduces the amount of information to be
* encrypted, thereby decreasing the amount of material available for
* cryptanalysis. Additionally, compression is designed to eliminate
* redundancies in the message, further complicating cryptanalysis."
*
* Google says that if you (1) have the ability to record encrypted
* communications made by a machine and (2) have the ability to run code
* on that machine which injects plaintext repeatedly into the encrypted
* messages, then you can extract other small parts of the mesasge which
* the code execution sandbox doesn't allow you to see, and that the
* only solution to stop using compression.
*
* Since we pay $0.12/gb for GCP bandwidth we choose to believe the CIA.
*/
#define MBEDTLS_ZLIB_SUPPORT
#endif
#ifdef MODE_DBG
#define MBEDTLS_CHECK_PARAMS
#endif
#define MBEDTLS_MD5_SMALLER
#define MBEDTLS_SHA1_SMALLER
#define MBEDTLS_SHA256_SMALLER
#define MBEDTLS_SHA512_SMALLER
#define MBEDTLS_ECP_NIST_OPTIM
#ifdef TINY
#define MBEDTLS_AES_ROM_TABLES
#define MBEDTLS_AES_FEWER_TABLES
#endif
#define MBEDTLS_PLATFORM_C
#define MBEDTLS_HAVE_TIME
#define MBEDTLS_HAVE_TIME_DATE
#define MBEDTLS_DEPRECATED_REMOVED
#define MBEDTLS_NO_PLATFORM_ENTROPY
/**
* \def MBEDTLS_PLATFORM_MEMORY
*
* Enable the memory allocation layer.
*
* By default mbed TLS uses the system-provided calloc() and free().
* This allows different allocators (self-implemented or provided) to be
* provided to the platform abstraction layer.
*
* Enabling MBEDTLS_PLATFORM_MEMORY without the
* MBEDTLS_PLATFORM_{FREE,CALLOC}_MACROs will provide
* "mbedtls_platform_set_calloc_free()" allowing you to set an alternative
* calloc() and free() function pointer at runtime.
*
* Enabling MBEDTLS_PLATFORM_MEMORY and specifying
* MBEDTLS_PLATFORM_{CALLOC,FREE}_MACROs will allow you to specify the
* alternate function at compile time.
*
* Enable this layer to allow use of alternative memory allocators.
*/
/*#define MBEDTLS_PLATFORM_MEMORY*/
/**
* \def MBEDTLS_ENTROPY_HARDWARE_ALT
*
* Uncomment this macro to let mbed TLS use your own implementation of a
* hardware entropy collector.
*
* Your function must be called \c mbedtls_hardware_poll(), have the same
* prototype as declared in entropy_poll.h, and accept NULL as first argument.
*
* Uncomment to use your own hardware entropy collector.
*/
#define MBEDTLS_ENTROPY_HARDWARE_ALT
/**
* Enables PKCS#5 functions, e.g. PBKDF2.
*/
#define MBEDTLS_PKCS5_C
/**
* \def MBEDTLS_CIPHER_PADDING_PKCS7
*
* MBEDTLS_CIPHER_PADDING_XXX: Uncomment or comment macros to add support for
* specific padding modes in the cipher layer with cipher modes that support
* padding (e.g. CBC)
*
* If you disable all padding modes, only full blocks can be used with CBC.
*
* Enable padding modes in the cipher layer.
*/
#define MBEDTLS_CIPHER_PADDING_PKCS7
#define MBEDTLS_CIPHER_PADDING_ONE_AND_ZEROS
#define MBEDTLS_CIPHER_PADDING_ZEROS_AND_LEN
#define MBEDTLS_CIPHER_PADDING_ZEROS
/**
* \def MBEDTLS_CTR_DRBG_USE_128_BIT_KEY
*
* Uncomment this macro to use a 128-bit key in the CTR_DRBG module.
* By default, CTR_DRBG uses a 256-bit key.
*/
/*#define MBEDTLS_CTR_DRBG_USE_128_BIT_KEY*/
/**
* \def MBEDTLS_ECP_NO_INTERNAL_RNG
*
* When this option is disabled, mbedtls_ecp_mul() will make use of an
* internal RNG when called with a NULL \c f_rng argument, in order to protect
* against some side-channel attacks.
*
* This protection introduces a dependency of the ECP module on one of the
* DRBG modules. For very constrained implementations that don't require this
* protection (for example, because you're only doing signature verification,
* so not manipulating any secret, or because local/physical side-channel
* attacks are outside your threat model), it might be desirable to get rid of
* that dependency.
*
* \warning Enabling this option makes some uses of ECP vulnerable to some
* side-channel attacks. Only enable it if you know that's not a problem for
* your use case.
*
* Uncomment this macro to disable some counter-measures in ECP.
*/
/*#define MBEDTLS_ECP_NO_INTERNAL_RNG*/
/**
* \def MBEDTLS_ECP_RESTARTABLE
*
* Enable "non-blocking" ECC operations that can return early and be resumed.
*
* This allows various functions to pause by returning
* #MBEDTLS_ERR_ECP_IN_PROGRESS (or, for functions in the SSL module,
* #MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS) and then be called later again in
* order to further progress and eventually complete their operation. This is
* controlled through mbedtls_ecp_set_max_ops() which limits the maximum
* number of ECC operations a function may perform before pausing; see
* mbedtls_ecp_set_max_ops() for more information.
*
* This is useful in non-threaded environments if you want to avoid blocking
* for too long on ECC (and, hence, X.509 or SSL/TLS) operations.
*
* Uncomment this macro to enable restartable ECC computations.
*
* \note This option only works with the default software implementation of
* elliptic curve functionality. It is incompatible with
* MBEDTLS_ECP_ALT, MBEDTLS_ECDH_XXX_ALT, MBEDTLS_ECDSA_XXX_ALT
* and MBEDTLS_ECDH_LEGACY_CONTEXT.
*/
/*#define MBEDTLS_ECP_RESTARTABLE*/
/**
* \def MBEDTLS_ECDH_LEGACY_CONTEXT
*
* Use a backward compatible ECDH context.
*
* Mbed TLS supports two formats for ECDH contexts (#mbedtls_ecdh_context
* defined in `ecdh.h`). For most applications, the choice of format makes
* no difference, since all library functions can work with either format,
* except that the new format is incompatible with MBEDTLS_ECP_RESTARTABLE.
*
* The new format used when this option is disabled is smaller
* (56 bytes on a 32-bit platform). In future versions of the library, it
* will support alternative implementations of ECDH operations.
* The new format is incompatible with applications that access
* context fields directly and with restartable ECP operations.
*
* Define this macro if you enable MBEDTLS_ECP_RESTARTABLE or if you
* want to access ECDH context fields directly. Otherwise you should
* comment out this macro definition.
*
* This option has no effect if #MBEDTLS_ECDH_C is not enabled.
*
* \note This configuration option is experimental. Future versions of the
* library may modify the way the ECDH context layout is configured
* and may modify the layout of the new context type.
*/
/*#define MBEDTLS_ECDH_LEGACY_CONTEXT*/
/**
* \def MBEDTLS_PK_PARSE_EC_EXTENDED
*
* Enhance support for reading EC keys using variants of SEC1 not allowed by
* RFC 5915 and RFC 5480.
*
* Currently this means parsing the SpecifiedECDomain choice of EC
* parameters (only known groups are supported, not arbitrary domains, to
* avoid validation issues).
*
* Disable if you only need to support RFC 5915 + 5480 key formats.
*/
/*#define MBEDTLS_PK_PARSE_EC_EXTENDED*/
/**
* \def MBEDTLS_ERROR_STRERROR_DUMMY
*
* Enable a dummy error function to make use of mbedtls_strerror() in
* third party libraries easier when MBEDTLS_ERROR_C is disabled
* (no effect when MBEDTLS_ERROR_C is enabled).
*
* You can safely disable this if MBEDTLS_ERROR_C is enabled, or if you're
* not using mbedtls_strerror() or error_strerror() in your application.
*
* Disable if you run into name conflicts and want to really remove the
* mbedtls_strerror()
*/
#define MBEDTLS_ERROR_STRERROR_DUMMY
/**
* \def MBEDTLS_GENPRIME
*
* Enable the prime-number generation code.
*
* Requires: MBEDTLS_BIGNUM_C
*/
#define MBEDTLS_GENPRIME
/**
* \def MBEDTLS_FS_IO
*
* Enable functions that use the filesystem.
*/
#define MBEDTLS_FS_IO
/**
* \def MBEDTLS_MEMORY_DEBUG
*
* Enable debugging of buffer allocator memory issues. Automatically prints
* (to stderr) all (fatal) messages on memory allocation issues. Enables
* function for 'debug output' of allocated memory.
*
* Requires: MBEDTLS_MEMORY_BUFFER_ALLOC_C
*
* Uncomment this macro to let the buffer allocator print out error messages.
*/
/*#define MBEDTLS_MEMORY_DEBUG*/
/**
* \def MBEDTLS_MEMORY_BACKTRACE
*
* Include backtrace information with each allocated block.
*
* Requires: MBEDTLS_MEMORY_BUFFER_ALLOC_C
* GLIBC-compatible backtrace() an backtrace_symbols() support
*
* Uncomment this macro to include backtrace information
*/
/*#define MBEDTLS_MEMORY_BACKTRACE*/
/**
* \def MBEDTLS_PK_RSA_ALT_SUPPORT
*
* Support external private RSA keys (eg from a HSM) in the PK layer.
*
* Comment this macro to disable support for external private RSA keys.
*/
/*#define MBEDTLS_PK_RSA_ALT_SUPPORT*/
/**
* \def MBEDTLS_PKCS1_V15
*
* Enable support for PKCS#1 v1.5 encoding.
*
* Requires: MBEDTLS_RSA_C
*
* This enables support for PKCS#1 v1.5 operations.
*/
#define MBEDTLS_PKCS1_V15
/**
* \def MBEDTLS_PKCS1_V21
*
* Enable support for PKCS#1 v2.1 encoding.
*
* Requires: MBEDTLS_MD_C, MBEDTLS_RSA_C
*
* This enables support for RSAES-OAEP and RSASSA-PSS operations.
*/
/*#define MBEDTLS_PKCS1_V21*/
/**
* \def MBEDTLS_RSA_NO_CRT
*
* Do not use the Chinese Remainder Theorem
* for the RSA private operation.
*
* Uncomment this macro to disable the use of CRT in RSA.
*/
/*#define MBEDTLS_RSA_NO_CRT*/
/**
* \def MBEDTLS_SELF_TEST
*
* Enable the checkup functions (*_self_test).
*/
#define MBEDTLS_SELF_TEST
/**
* \def MBEDTLS_CERTS_C
*
* Enable the test certificates.
*
* Module: library/certs.c
* Caller:
*
* This module is used for testing (ssl_client/server).
*/
#define MBEDTLS_CERTS_C
/**
* \def MBEDTLS_SHA512_NO_SHA384
*
* Disable the SHA-384 option of the SHA-512 module. Use this to save some
* code size on devices that don't use SHA-384.
*
* Requires: MBEDTLS_SHA512_C
*
* Uncomment to disable SHA-384
*/
/*#define MBEDTLS_SHA512_NO_SHA384*/
/**
* \def MBEDTLS_SSL_ALL_ALERT_MESSAGES
*
* Enable sending of alert messages in case of encountered errors as per RFC.
* If you choose not to send the alert messages, mbed TLS can still communicate
* with other servers, only debugging of failures is harder.
*
* The advantage of not sending alert messages, is that no information is given
* about reasons for failures thus preventing adversaries of gaining intel.
*
* Enable sending of all alert messages
*/
#define MBEDTLS_SSL_ALL_ALERT_MESSAGES
#ifdef MBEDTLS_SSL_PROTO_DTLS
/**
* \def MBEDTLS_SSL_RECORD_CHECKING
*
* Enable the function mbedtls_ssl_check_record() which can be used to check
* the validity and authenticity of an incoming record, to verify that it has
* not been seen before. These checks are performed without modifying the
* externally visible state of the SSL context.
*
* See mbedtls_ssl_check_record() for more information.
*
* Uncomment to enable support for record checking.
*/
#define MBEDTLS_SSL_RECORD_CHECKING
#endif
/**
* \def MBEDTLS_SSL_DTLS_CONNECTION_ID
*
* Enable support for the DTLS Connection ID extension
* (version draft-ietf-tls-dtls-connection-id-05,
* https://tools.ietf.org/html/draft-ietf-tls-dtls-connection-id-05)
* which allows to identify DTLS connections across changes
* in the underlying transport.
*
* Setting this option enables the SSL APIs `mbedtls_ssl_set_cid()`,
* `mbedtls_ssl_get_peer_cid()` and `mbedtls_ssl_conf_cid()`.
* See the corresponding documentation for more information.
*
* \warning The Connection ID extension is still in draft state.
* We make no stability promises for the availability
* or the shape of the API controlled by this option.
*
* The maximum lengths of outgoing and incoming CIDs can be configured
* through the options
* - MBEDTLS_SSL_CID_OUT_LEN_MAX
* - MBEDTLS_SSL_CID_IN_LEN_MAX.
*
* Requires: MBEDTLS_SSL_PROTO_DTLS
*
* Uncomment to enable the Connection ID extension.
*/
/*#define MBEDTLS_SSL_DTLS_CONNECTION_ID*/
/**
* \def MBEDTLS_SSL_ASYNC_PRIVATE
*
* Enable asynchronous external private key operations in SSL. This allows
* you to configure an SSL connection to call an external cryptographic
* module to perform private key operations instead of performing the
* operation inside the library.
*/
/*#define MBEDTLS_SSL_ASYNC_PRIVATE*/
/**
* \def MBEDTLS_SSL_CONTEXT_SERIALIZATION
*
* Enable serialization of the TLS context structures, through use of the
* functions mbedtls_ssl_context_save() and mbedtls_ssl_context_load().
*
* This pair of functions allows one side of a connection to serialize the
* context associated with the connection, then free or re-use that context
* while the serialized state is persisted elsewhere, and finally deserialize
* that state to a live context for resuming read/write operations on the
* connection. From a protocol perspective, the state of the connection is
* unaffected, in particular this is entirely transparent to the peer.
*
* Note: this is distinct from TLS session resumption, which is part of the
* protocol and fully visible by the peer. TLS session resumption enables
* establishing new connections associated to a saved session with shorter,
* lighter handshakes, while context serialization is a local optimization in
* handling a single, potentially long-lived connection.
*
* Enabling these APIs makes some SSL structures larger, as 64 extra bytes are
* saved after the handshake to allow for more efficient serialization, so if
* you don't need this feature you'll save RAM by disabling it.
*
* Comment to disable the context serialization APIs.
*/
/*#define MBEDTLS_SSL_CONTEXT_SERIALIZATION*/
/**
* \def MBEDTLS_SSL_DEBUG_ALL
*
* Enable the debug messages in SSL module for all issues.
* Debug messages have been disabled in some places to prevent timing
* attacks due to (unbalanced) debugging function calls.
*
* If you need all error reporting you should enable this during debugging,
* but remove this for production servers that should log as well.
*
* Uncomment this macro to report all debug messages on errors introducing
* a timing side-channel.
*/
/*#define MBEDTLS_SSL_DEBUG_ALL*/
/**
* \def MBEDTLS_SSL_ENCRYPT_THEN_MAC
*
* Enable support for Encrypt-then-MAC, RFC 7366.
*
* This allows peers that both support it to use a more robust protection for
* ciphersuites using CBC, providing deep resistance against timing attacks
* on the padding or underlying cipher.
*
* This only affects CBC ciphersuites, and is useless if none is defined.
*
* Requires: MBEDTLS_SSL_PROTO_TLS1 or
* MBEDTLS_SSL_PROTO_TLS1_1 or
* MBEDTLS_SSL_PROTO_TLS1_2
*
* Comment this macro to disable support for Encrypt-then-MAC
*/
#define MBEDTLS_SSL_ENCRYPT_THEN_MAC
/**
* \def MBEDTLS_SSL_EXTENDED_MASTER_SECRET
*
* Enable support for RFC 7627: Session Hash and Extended Master Secret
* Extension.
*
* This was introduced as "the proper fix" to the Triple Handshake familiy of
* attacks, but it is recommended to always use it (even if you disable
* renegotiation), since it actually fixes a more fundamental issue in the
* original SSL/TLS design, and has implications beyond Triple Handshake.
*
* Requires: MBEDTLS_SSL_PROTO_TLS1 or
* MBEDTLS_SSL_PROTO_TLS1_1 or
* MBEDTLS_SSL_PROTO_TLS1_2
*
* Comment this macro to disable support for Extended Master Secret.
*/
#define MBEDTLS_SSL_EXTENDED_MASTER_SECRET
#if (MBEDTLS_SSL_PROTO_SSL3 + MBEDTLS_SSL_PROTO_TLS1 + \
MBEDTLS_SSL_PROTO_TLS1_1 + MBEDTLS_SSL_PROTO_TLS1_2 + \
MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL + 0) > 1
/**
* \def MBEDTLS_SSL_FALLBACK_SCSV
*
* Enable support for RFC 7507: Fallback Signaling Cipher Suite Value (SCSV)
* for Preventing Protocol Downgrade Attacks.
*
* For servers, it is recommended to always enable this, unless you support
* only one version of TLS, or know for sure that none of your clients
* implements a fallback strategy.
*
* For clients, you only need this if you're using a fallback strategy, which
* is not recommended in the first place, unless you absolutely need it to
* interoperate with buggy (version-intolerant) servers.
*
* Comment this macro to disable support for FALLBACK_SCSV
*/
#define MBEDTLS_SSL_FALLBACK_SCSV
#endif
/**
* \def MBEDTLS_SSL_KEEP_PEER_CERTIFICATE
*
* This option controls the availability of the API mbedtls_ssl_get_peer_cert()
* giving access to the peer's certificate after completion of the handshake.
*
* Unless you need mbedtls_ssl_peer_cert() in your application, it is
* recommended to disable this option for reduced RAM usage.
*
* \note If this option is disabled, mbedtls_ssl_get_peer_cert() is still
* defined, but always returns \c NULL.
*
* \note This option has no influence on the protection against the
* triple handshake attack. Even if it is disabled, Mbed TLS will
* still ensure that certificates do not change during renegotiation,
* for exaple by keeping a hash of the peer's certificate.
*
* Comment this macro to disable storing the peer's certificate
* after the handshake.
*/
#define MBEDTLS_SSL_KEEP_PEER_CERTIFICATE
/**
* \def MBEDTLS_SSL_CBC_RECORD_SPLITTING
*
* Enable 1/n-1 record splitting for CBC mode in SSLv3 and TLS 1.0.
*
* This is a countermeasure to the BEAST attack, which also minimizes the risk
* of interoperability issues compared to sending 0-length records.
*
* Comment this macro to disable 1/n-1 record splitting.
*/
#define MBEDTLS_SSL_CBC_RECORD_SPLITTING
/**
* \def MBEDTLS_SSL_RENEGOTIATION
*
* Enable support for TLS renegotiation.
*
* The two main uses of renegotiation are (1) refresh keys on long-lived
* connections and (2) client authentication after the initial handshake.
* If you don't need renegotiation, it's probably better to disable it, since
* it has been associated with security issues in the past and is easy to
* misuse/misunderstand.
*
* Comment this to disable support for renegotiation.
*
* \note Even if this option is disabled, both client and server are aware
* of the Renegotiation Indication Extension (RFC 5746) used to
* prevent the SSL renegotiation attack (see RFC 5746 Sect. 1).
* (See \c mbedtls_ssl_conf_legacy_renegotiation for the
* configuration of this extension).
*/
/*#define MBEDTLS_SSL_RENEGOTIATION*/
/**
* \def MBEDTLS_SSL_SRV_RESPECT_CLIENT_PREFERENCE
*
* Pick the ciphersuite according to the client's preferences rather than ours
* in the SSL Server module (MBEDTLS_SSL_SRV_C).
*
* Uncomment this macro to respect client's ciphersuite order
*/
#define MBEDTLS_SSL_SRV_RESPECT_CLIENT_PREFERENCE
/**
* \def MBEDTLS_SSL_MAX_FRAGMENT_LENGTH
*
* Enable support for RFC 6066 max_fragment_length extension in SSL.
*
* Comment this macro to disable support for the max_fragment_length extension
*/
#define MBEDTLS_SSL_MAX_FRAGMENT_LENGTH
/**
* \def MBEDTLS_SSL_ALPN
*
* Enable support for RFC 7301 Application Layer Protocol Negotiation.
*
* Comment this macro to disable support for ALPN.
*/
#define MBEDTLS_SSL_ALPN
#ifdef MBEDTLS_SSL_PROTO_DTLS
/**
* \def MBEDTLS_SSL_DTLS_ANTI_REPLAY
*
* Enable support for the anti-replay mechanism in DTLS.
*
* Requires: MBEDTLS_SSL_TLS_C
* MBEDTLS_SSL_PROTO_DTLS
*
* \warning Disabling this is often a security risk!
* See mbedtls_ssl_conf_dtls_anti_replay() for details.
*
* Comment this to disable anti-replay in DTLS.
*/
#define MBEDTLS_SSL_DTLS_ANTI_REPLAY
#endif
#ifdef MBEDTLS_SSL_PROTO_DTLS
/**
* \def MBEDTLS_SSL_DTLS_HELLO_VERIFY
*
* Enable support for HelloVerifyRequest on DTLS servers.
*
* This feature is highly recommended to prevent DTLS servers being used as
* amplifiers in DoS attacks against other hosts. It should always be enabled
* unless you know for sure amplification cannot be a problem in the
* environment in which your server operates.
*
* \warning Disabling this can ba a security risk! (see above)
*
* Requires: MBEDTLS_SSL_PROTO_DTLS
*
* Comment this to disable support for HelloVerifyRequest.
*/
#define MBEDTLS_SSL_DTLS_HELLO_VERIFY
#endif
/**
* \def MBEDTLS_SSL_DTLS_SRTP
*
* Enable support for negotation of DTLS-SRTP (RFC 5764)
* through the use_srtp extension.
*
* \note This feature provides the minimum functionality required
* to negotiate the use of DTLS-SRTP and to allow the derivation of
* the associated SRTP packet protection key material.
* In particular, the SRTP packet protection itself, as well as the
* demultiplexing of RTP and DTLS packets at the datagram layer
* (see Section 5 of RFC 5764), are not handled by this feature.
* Instead, after successful completion of a handshake negotiating
* the use of DTLS-SRTP, the extended key exporter API
* mbedtls_ssl_conf_export_keys_ext_cb() should be used to implement
* the key exporter described in Section 4.2 of RFC 5764 and RFC 5705
* (this is implemented in the SSL example programs).
* The resulting key should then be passed to an SRTP stack.
*
* Setting this option enables the runtime API
* mbedtls_ssl_conf_dtls_srtp_protection_profiles()
* through which the supported DTLS-SRTP protection
* profiles can be configured. You must call this API at
* runtime if you wish to negotiate the use of DTLS-SRTP.
*
* Requires: MBEDTLS_SSL_PROTO_DTLS
*
* Uncomment this to enable support for use_srtp extension.
*/
/*#define MBEDTLS_SSL_DTLS_SRTP*/
#ifdef MBEDTLS_SSL_PROTO_DTLS
/**
* \def MBEDTLS_SSL_DTLS_CLIENT_PORT_REUSE
*
* Enable server-side support for clients that reconnect from the same port.
*
* Some clients unexpectedly close the connection and try to reconnect using the
* same source port. This needs special support from the server to handle the
* new connection securely, as described in section 4.2.8 of RFC 6347. This
* flag enables that support.
*
* Requires: MBEDTLS_SSL_DTLS_HELLO_VERIFY
*
* Comment this to disable support for clients reusing the source port.
*/
#define MBEDTLS_SSL_DTLS_CLIENT_PORT_REUSE
#endif
/**
* \def MBEDTLS_SSL_DTLS_BADMAC_LIMIT
*
* Enable support for a limit of records with bad MAC.
*
* See mbedtls_ssl_conf_dtls_badmac_limit().
*
* Requires: MBEDTLS_SSL_PROTO_DTLS
*/
/*#define MBEDTLS_SSL_DTLS_BADMAC_LIMIT*/
/**
* \def MBEDTLS_SSL_SESSION_TICKETS
*
* Enable support for RFC 5077 session tickets in SSL.
* Client-side, provides full support for session tickets (maintenance of a
* session store remains the responsibility of the application, though).
* Server-side, you also need to provide callbacks for writing and parsing
* tickets, including authenticated encryption and key management. Example
* callbacks are provided by MBEDTLS_SSL_TICKET_C.
*
* Comment this macro to disable support for SSL session tickets
*/
#define MBEDTLS_SSL_SESSION_TICKETS
/**
* \def MBEDTLS_SSL_EXPORT_KEYS
*
* Enable support for exporting key block and master secret.
* This is required for certain users of TLS, e.g. EAP-TLS.
*
* Comment this macro to disable support for key export
*/
/*#define MBEDTLS_SSL_EXPORT_KEYS*/
/**
* \def MBEDTLS_SSL_SERVER_NAME_INDICATION
*
* Enable support for RFC 6066 server name indication (SNI) in SSL.
*
* Requires: MBEDTLS_X509_CRT_PARSE_C
*
* Comment this macro to disable support for server name indication in SSL
*/
#define MBEDTLS_SSL_SERVER_NAME_INDICATION
/**
* \def MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH
*
* When this option is enabled, the SSL buffer will be resized automatically
* based on the negotiated maximum fragment length in each direction.
*
* Requires: MBEDTLS_SSL_MAX_FRAGMENT_LENGTH
*/
/*#define MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH*/
/**
* \def MBEDTLS_TEST_CONSTANT_FLOW_MEMSAN
*
* Enable testing of the constant-flow nature of some sensitive functions with
* clang's MemorySanitizer. This causes some existing tests to also test
* this non-functional property of the code under test.
*
* This setting requires compiling with clang -fsanitize=memory. The test
* suites can then be run normally.
*
* \warning This macro is only used for extended testing; it is not considered
* part of the library's API, so it may change or disappear at any time.
*
* Uncomment to enable testing of the constant-flow nature of selected code.
*/
/*#define MBEDTLS_TEST_CONSTANT_FLOW_MEMSAN*/
/**
* \def MBEDTLS_TEST_CONSTANT_FLOW_VALGRIND
*
* Enable testing of the constant-flow nature of some sensitive functions with
* valgrind's memcheck tool. This causes some existing tests to also test
* this non-functional property of the code under test.
*
* This setting requires valgrind headers for building, and is only useful for
* testing if the tests suites are run with valgrind's memcheck. This can be
* done for an individual test suite with 'valgrind ./test_suite_xxx', or when
* using CMake, this can be done for all test suites with 'make memcheck'.
*
* \warning This macro is only used for extended testing; it is not considered
* part of the library's API, so it may change or disappear at any time.
*
* Uncomment to enable testing of the constant-flow nature of selected code.
*/
/*#define MBEDTLS_TEST_CONSTANT_FLOW_VALGRIND*/
/**
* \def MBEDTLS_TEST_HOOKS
*
* Enable features for invasive testing such as introspection functions and
* hooks for fault injection. This enables additional unit tests.
*
* Merely enabling this feature should not change the behavior of the product.
* It only adds new code, and new branching points where the default behavior
* is the same as when this feature is disabled.
* However, this feature increases the attack surface: there is an added
* risk of vulnerabilities, and more gadgets that can make exploits easier.
* Therefore this feature must never be enabled in production.
*
* See `docs/architecture/testing/mbed-crypto-invasive-testing.md` for more
* information.
*
* Uncomment to enable invasive tests.
*/
/*#define MBEDTLS_TEST_HOOKS*/
/**
* \def MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK
*
* If set, this enables the X.509 API `mbedtls_x509_crt_verify_with_ca_cb()`
* and the SSL API `mbedtls_ssl_conf_ca_cb()` which allow users to configure
* the set of trusted certificates through a callback instead of a linked
* list.
*
* This is useful for example in environments where a large number of trusted
* certificates is present and storing them in a linked list isn't efficient
* enough, or when the set of trusted certificates changes frequently.
*
* See the documentation of `mbedtls_x509_crt_verify_with_ca_cb()` and
* `mbedtls_ssl_conf_ca_cb()` for more information.
*
* Uncomment to enable trusted certificate callbacks.
*/
/*#define MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK*/
/**
* \def MBEDTLS_ASN1_PARSE_C
*
* Enable the generic ASN1 parser.
*
* Module: library/asn1.c
* Caller: library/x509.c
* library/dhm.c
* library/pkcs12.c
* library/pkcs5.c
* library/pkparse.c
*/
#define MBEDTLS_ASN1_PARSE_C
/**
* \def MBEDTLS_ASN1_WRITE_C
*
* Enable the generic ASN1 writer.
*
* Module: library/asn1write.c
* Caller: library/ecdsa.c
* library/pkwrite.c
* library/x509_create.c
* library/x509write_crt.c
* library/x509write_csr.c
*/
#define MBEDTLS_ASN1_WRITE_C
/**
* \def MBEDTLS_BASE64_C
*
* Enable the Base64 module.
*
* Module: library/base64.c
* Caller: library/pem.c
*
* This module is required for PEM support (required by X.509).
*/
#define MBEDTLS_BASE64_C
/**
* \def MBEDTLS_BIGNUM_C
*
* Enable the multi-precision integer library.
*
* Module: library/bignum.c
* Caller: library/dhm.c
* library/ecp.c
* library/ecdsa.c
* library/rsa.c
* library/rsa_internal.c
* library/ssl_tls.c
*
* This module is required for RSA, DHM and ECC (ECDH, ECDSA) support.
*/
#define MBEDTLS_BIGNUM_C
/**
* \def MBEDTLS_CIPHER_C
*
* Enable the generic cipher layer.
*
* Module: library/cipher.c
* Caller: library/ssl_tls.c
*
* Uncomment to enable generic cipher wrappers.
*/
#define MBEDTLS_CIPHER_C
#ifndef TINY
/**
* \def MBEDTLS_DEBUG_C
*
* Enable the debug functions.
*
* Module: library/debug.c
* Caller: library/ssl_cli.c
* library/ssl_srv.c
* library/ssl_tls.c
*
* This module provides debugging functions.
*/
#define MBEDTLS_DEBUG_C
#endif
/**
* \def MBEDTLS_ENTROPY_C
*
* Enable the platform-specific entropy code.
*
* Module: library/entropy.c
* Caller:
*
* Requires: MBEDTLS_SHA512_C or MBEDTLS_SHA256_C
*
* This module provides a generic entropy pool
*/
#define MBEDTLS_ENTROPY_C
/**
* \def MBEDTLS_ERROR_C
*
* Enable error code to error string conversion.
*
* Module: library/error.c
* Caller:
*
* This module enables mbedtls_strerror().
*/
#define MBEDTLS_ERROR_C
/**
* \def MBEDTLS_HKDF_C
*
* Enable the HKDF algorithm (RFC 5869).
*
* Module: library/hkdf.c
* Caller:
*
* Requires: MBEDTLS_MD_C
*
* This module adds support for the Hashed Message Authentication Code
* (HMAC)-based key derivation function (HKDF).
*/
/*#define MBEDTLS_HKDF_C*/
/**
* \def MBEDTLS_NIST_KW_C
*
* Enable the Key Wrapping mode for 128-bit block ciphers,
* as defined in NIST SP 800-38F. Only KW and KWP modes
* are supported. At the moment, only AES is approved by NIST.
*
* Module: library/nist_kw.c
*
* Requires: MBEDTLS_AES_C and MBEDTLS_CIPHER_C
*/
#define MBEDTLS_NIST_KW_C
/**
* \def MBEDTLS_MD_C
*
* Enable the generic message digest layer.
*
* Module: library/md.c
* Caller:
*
* Uncomment to enable generic message digest wrappers.
*/
#define MBEDTLS_MD_C
#define MBEDTLS_OID_C
#define MBEDTLS_PEM_PARSE_C
#define MBEDTLS_PEM_WRITE_C
#define MBEDTLS_PK_C
#define MBEDTLS_PK_PARSE_C
#define MBEDTLS_PK_WRITE_C
#define MBEDTLS_X509_USE_C
#define MBEDTLS_X509_CREATE_C
#define MBEDTLS_X509_CRT_WRITE_C
#define MBEDTLS_X509_CRT_PARSE_C
#define MBEDTLS_X509_CSR_PARSE_C
#define MBEDTLS_X509_CSR_WRITE_C
#define MBEDTLS_X509_CRL_PARSE_C
#define MBEDTLS_SSL_TLS_C
#define MBEDTLS_SSL_CLI_C
#define MBEDTLS_SSL_SRV_C
#define MBEDTLS_SSL_TICKET_C
#define MBEDTLS_SSL_CACHE_C
/*#define MBEDTLS_SSL_COOKIE_C*/
/**
* \def MBEDTLS_SSL_MAX_CONTENT_LEN
*
* Maximum length (in bytes) of incoming and outgoing plaintext fragments.
*
* This determines the size of both the incoming and outgoing TLS I/O buffers
* in such a way that both are capable of holding the specified amount of
* plaintext data, regardless of the protection mechanism used.
*
* To configure incoming and outgoing I/O buffers separately, use
* #MBEDTLS_SSL_IN_CONTENT_LEN and #MBEDTLS_SSL_OUT_CONTENT_LEN,
* which overwrite the value set by this option.
*
* \note When using a value less than the default of 16KB on the client, it is
* recommended to use the Maximum Fragment Length (MFL) extension to
* inform the server about this limitation. On the server, there
* is no supported, standardized way of informing the client about
* restriction on the maximum size of incoming messages, and unless
* the limitation has been communicated by other means, it is recommended
* to only change the outgoing buffer size #MBEDTLS_SSL_OUT_CONTENT_LEN
* while keeping the default value of 16KB for the incoming buffer.
*
* Uncomment to set the maximum plaintext size of both
* incoming and outgoing I/O buffers.
*/
/*#define MBEDTLS_SSL_MAX_CONTENT_LEN 16384*/
/**
* \def MBEDTLS_SSL_IN_CONTENT_LEN
*
* Maximum length (in bytes) of incoming plaintext fragments.
*
* This determines the size of the incoming TLS I/O buffer in such a way
* that it is capable of holding the specified amount of plaintext data,
* regardless of the protection mechanism used.
*
* If this option is undefined, it inherits its value from
* #MBEDTLS_SSL_MAX_CONTENT_LEN.
*
* \note When using a value less than the default of 16KB on the client, it is
* recommended to use the Maximum Fragment Length (MFL) extension to
* inform the server about this limitation. On the server, there
* is no supported, standardized way of informing the client about
* restriction on the maximum size of incoming messages, and unless
* the limitation has been communicated by other means, it is recommended
* to only change the outgoing buffer size #MBEDTLS_SSL_OUT_CONTENT_LEN
* while keeping the default value of 16KB for the incoming buffer.
*
* Uncomment to set the maximum plaintext size of the incoming I/O buffer
* independently of the outgoing I/O buffer.
*/
/*#define MBEDTLS_SSL_IN_CONTENT_LEN 16384*/
/**
* \def MBEDTLS_SSL_CID_IN_LEN_MAX
*
* The maximum length of CIDs used for incoming DTLS messages.
*/
/*#define MBEDTLS_SSL_CID_IN_LEN_MAX 32*/
/**
* \def MBEDTLS_SSL_CID_OUT_LEN_MAX
*
* The maximum length of CIDs used for outgoing DTLS messages.
*/
/*#define MBEDTLS_SSL_CID_OUT_LEN_MAX 32*/
/**
* \def MBEDTLS_SSL_CID_PADDING_GRANULARITY
*
* This option controls the use of record plaintext padding
* when using the Connection ID extension in DTLS 1.2.
*
* The padding will always be chosen so that the length of the
* padded plaintext is a multiple of the value of this option.
*
* Note: A value of \c 1 means that no padding will be used
* for outgoing records.
*
* Note: On systems lacking division instructions,
* a power of two should be preferred.
*/
/*#define MBEDTLS_SSL_CID_PADDING_GRANULARITY 16*/
/**
* \def MBEDTLS_SSL_TLS1_3_PADDING_GRANULARITY
*
* This option controls the use of record plaintext padding
* in TLS 1.3.
*
* The padding will always be chosen so that the length of the
* padded plaintext is a multiple of the value of this option.
*
* Note: A value of \c 1 means that no padding will be used
* for outgoing records.
*
* Note: On systems lacking division instructions,
* a power of two should be preferred.
*/
/*#define MBEDTLS_SSL_TLS1_3_PADDING_GRANULARITY 1*/
/**
* \def MBEDTLS_SSL_OUT_CONTENT_LEN
*
* Maximum length (in bytes) of outgoing plaintext fragments.
*
* This determines the size of the outgoing TLS I/O buffer in such a way
* that it is capable of holding the specified amount of plaintext data,
* regardless of the protection mechanism used.
*
* If this option undefined, it inherits its value from
* #MBEDTLS_SSL_MAX_CONTENT_LEN.
*
* It is possible to save RAM by setting a smaller outward buffer, while keeping
* the default inward 16384 byte buffer to conform to the TLS specification.
*
* The minimum required outward buffer size is determined by the handshake
* protocol's usage. Handshaking will fail if the outward buffer is too small.
* The specific size requirement depends on the configured ciphers and any
* certificate data which is sent during the handshake.
*
* Uncomment to set the maximum plaintext size of the outgoing I/O buffer
* independently of the incoming I/O buffer.
*/
/*#define MBEDTLS_SSL_OUT_CONTENT_LEN 16384*/
/**
* \def MBEDTLS_SSL_DTLS_MAX_BUFFERING
*
* Maximum number of heap-allocated bytes for the purpose of
* DTLS handshake message reassembly and future message buffering.
*
* This should be at least 9/8 * MBEDTLSSL_IN_CONTENT_LEN
* to account for a reassembled handshake message of maximum size,
* together with its reassembly bitmap.
*
* A value of 2 * MBEDTLS_SSL_IN_CONTENT_LEN (32768 by default)
* should be sufficient for all practical situations as it allows
* to reassembly a large handshake message (such as a certificate)
* while buffering multiple smaller handshake messages.
*/
/*#define MBEDTLS_SSL_DTLS_MAX_BUFFERING 32768*/
/**
* Allow SHA-1 in the default TLS configuration for certificate signing.
* Without this build-time option, SHA-1 support must be activated explicitly
* through mbedtls_ssl_conf_cert_profile. Turning on this option is not
* recommended because of it is possible to generate SHA-1 collisions, however
* this may be safe for legacy infrastructure where additional controls apply.
*
* \warning SHA-1 is considered a weak message digest and its use constitutes
* a security risk. If possible, we recommend avoiding dependencies
* on it, and considering stronger message digests instead.
*/
/*#define MBEDTLS_TLS_DEFAULT_ALLOW_SHA1_IN_CERTIFICATES*/
/**
* Allow SHA-1 in the default TLS configuration for TLS 1.2 handshake
* signature and ciphersuite selection. Without this build-time option, SHA-1
* support must be activated explicitly through mbedtls_ssl_conf_sig_hashes.
* The use of SHA-1 in TLS <= 1.1 and in HMAC-SHA-1 is always allowed by
* default. At the time of writing, there is no practical attack on the use
* of SHA-1 in handshake signatures, hence this option is turned on by default
* to preserve compatibility with existing peers, but the general
* warning applies nonetheless:
*
* \warning SHA-1 is considered a weak message digest and its use constitutes
* a security risk. If possible, we recommend avoiding dependencies
* on it, and considering stronger message digests instead.
*/
#define MBEDTLS_TLS_DEFAULT_ALLOW_SHA1_IN_KEY_EXCHANGE
#define mbedtls_t_udbl uint128_t
#define MBEDTLS_HAVE_UDBL
#include "libc/dce.h"
#include "third_party/mbedtls/check.inc"
#endif /* MBEDTLS_CONFIG_H_ */
| 40,874 | 1,261 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/ecp.h | #ifndef COSMOPOLITAN_THIRD_PARTY_MBEDTLS_ECP_H_
#define COSMOPOLITAN_THIRD_PARTY_MBEDTLS_ECP_H_
#include "third_party/mbedtls/bignum.h"
#include "third_party/mbedtls/config.h"
COSMOPOLITAN_C_START_
/* clang-format off */
#define MBEDTLS_ERR_ECP_BAD_INPUT_DATA -0x4F80 /*< Bad input parameters to function. */
#define MBEDTLS_ERR_ECP_BUFFER_TOO_SMALL -0x4F00 /*< The buffer is too small to write to. */
#define MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE -0x4E80 /*< The requested feature is not available, for example, the requested curve is not supported. */
#define MBEDTLS_ERR_ECP_VERIFY_FAILED -0x4E00 /*< The signature is not valid. */
#define MBEDTLS_ERR_ECP_ALLOC_FAILED -0x4D80 /*< Memory allocation failed. */
#define MBEDTLS_ERR_ECP_RANDOM_FAILED -0x4D00 /*< Generation of random value, such as ephemeral key, failed. */
#define MBEDTLS_ERR_ECP_INVALID_KEY -0x4C80 /*< Invalid private or public key. */
#define MBEDTLS_ERR_ECP_SIG_LEN_MISMATCH -0x4C00 /*< The buffer contains a valid signature followed by more data. */
#define MBEDTLS_ERR_ECP_HW_ACCEL_FAILED -0x4B80 /*< The ECP hardware accelerator failed. */
#define MBEDTLS_ERR_ECP_IN_PROGRESS -0x4B00 /*< Operation in progress, call again with the same parameters to continue. */
/**
* Domain-parameter identifiers: curve, subgroup, and generator.
*
* \note Only curves over prime fields are supported.
*
* \warning This library does not support validation of arbitrary domain
* parameters. Therefore, only standardized domain parameters from trusted
* sources should be used. See mbedtls_ecp_group_load().
*/
typedef enum
{
/* Note: when adding a new curve:
* - Add it at the end of this enum, otherwise you'll break the ABI by
* changing the numerical value for existing curves.
* - Increment MBEDTLS_ECP_DP_MAX below if needed.
* - Add the corresponding MBEDTLS_ECP_DP_xxx_ENABLED macro definition to
* config.h.
* - List the curve as a dependency of MBEDTLS_ECP_C and
* MBEDTLS_ECDSA_C if supported in check.h.
* - Add the curve to the appropriate curve type macro
* MBEDTLS_ECP_yyy_ENABLED above.
* - Add the necessary definitions to ecp_curves.c.
* - Add the curve to the ecp_supported_curves array in ecp.c.
* - Add the curve to applicable profiles in x509_crt.c if applicable.
*/
MBEDTLS_ECP_DP_NONE = 0, /*!< Curve not defined. */
MBEDTLS_ECP_DP_SECP192R1, /*!< Domain parameters for the 192-bit curve defined by FIPS 186-4 and SEC1. */
MBEDTLS_ECP_DP_SECP224R1, /*!< Domain parameters for the 224-bit curve defined by FIPS 186-4 and SEC1. */
MBEDTLS_ECP_DP_SECP256R1, /*!< Domain parameters for the 256-bit curve defined by FIPS 186-4 and SEC1. */
MBEDTLS_ECP_DP_SECP384R1, /*!< Domain parameters for the 384-bit curve defined by FIPS 186-4 and SEC1. */
MBEDTLS_ECP_DP_SECP521R1, /*!< Domain parameters for the 521-bit curve defined by FIPS 186-4 and SEC1. */
MBEDTLS_ECP_DP_BP256R1, /*!< Domain parameters for 256-bit Brainpool curve. */
MBEDTLS_ECP_DP_BP384R1, /*!< Domain parameters for 384-bit Brainpool curve. */
MBEDTLS_ECP_DP_BP512R1, /*!< Domain parameters for 512-bit Brainpool curve. */
MBEDTLS_ECP_DP_CURVE25519, /*!< Domain parameters for Curve25519. */
MBEDTLS_ECP_DP_SECP192K1, /*!< Domain parameters for 192-bit "Koblitz" curve. */
MBEDTLS_ECP_DP_SECP224K1, /*!< Domain parameters for 224-bit "Koblitz" curve. */
MBEDTLS_ECP_DP_SECP256K1, /*!< Domain parameters for 256-bit "Koblitz" curve. */
MBEDTLS_ECP_DP_CURVE448, /*!< Domain parameters for Curve448. */
} mbedtls_ecp_group_id;
/**
* The number of supported curves, plus one for #MBEDTLS_ECP_DP_NONE.
*
* \note Montgomery curves are currently excluded.
*/
#define MBEDTLS_ECP_DP_MAX 12
#define MBEDTLS_ECP_PF_UNCOMPRESSED 0 /*< Uncompressed point format (RFC4492) */
#define MBEDTLS_ECP_PF_COMPRESSED 1 /*< Compressed point format (RFC4492) */
#define MBEDTLS_ECP_TLS_NAMED_CURVE 3 /*< The named_curve of ECCurveType (RFC4492) */
/*
* Curve types
*/
typedef enum
{
MBEDTLS_ECP_TYPE_NONE = 0,
MBEDTLS_ECP_TYPE_SHORT_WEIERSTRASS, /* y^2 = x^3 + a x + b */
MBEDTLS_ECP_TYPE_MONTGOMERY, /* y^2 = x^3 + a x^2 + x */
} mbedtls_ecp_curve_type;
/**
* Curve information, for use by other modules.
*/
typedef struct mbedtls_ecp_curve_info
{
mbedtls_ecp_group_id grp_id; /*!< An internal identifier. */
uint16_t tls_id; /*!< The TLS NamedCurve identifier. */
uint16_t bit_size; /*!< The curve size in bits. */
const char *name; /*!< A human-friendly name. */
} mbedtls_ecp_curve_info;
/**
* \brief The ECP point structure, in Jacobian coordinates.
*
* \note All functions expect and return points satisfying
* the following condition: <code>Z == 0</code> or
* <code>Z == 1</code>. Other values of \p Z are
* used only by internal functions.
* The point is zero, or "at infinity", if <code>Z == 0</code>.
* Otherwise, \p X and \p Y are its standard (affine)
* coordinates.
*/
typedef struct mbedtls_ecp_point
{
mbedtls_mpi X; /*!< The X coordinate of the ECP point. */
mbedtls_mpi Y; /*!< The Y coordinate of the ECP point. */
mbedtls_mpi Z; /*!< The Z coordinate of the ECP point. */
}
mbedtls_ecp_point;
#if !defined(MBEDTLS_ECP_ALT)
/*
* default mbed TLS elliptic curve arithmetic implementation
*
* (in case MBEDTLS_ECP_ALT is defined then the developer has to provide an
* alternative implementation for the whole module and it will replace this
* one.)
*/
/**
* \brief The ECP group structure.
*
* We consider two types of curve equations:
* <ul><li>Short Weierstrass: <code>y^2 = x^3 + A x + B mod P</code>
* (SEC1 + RFC-4492)</li>
* <li>Montgomery: <code>y^2 = x^3 + A x^2 + x mod P</code> (Curve25519,
* Curve448)</li></ul>
* In both cases, the generator (\p G) for a prime-order subgroup is fixed.
*
* For Short Weierstrass, this subgroup is the whole curve, and its
* cardinality is denoted by \p N. Our code requires that \p N is an
* odd prime as mbedtls_ecp_mul() requires an odd number, and
* mbedtls_ecdsa_sign() requires that it is prime for blinding purposes.
*
* For Montgomery curves, we do not store \p A, but <code>(A + 2) / 4</code>,
* which is the quantity used in the formulas. Additionally, \p nbits is
* not the size of \p N but the required size for private keys.
*
* If \p modp is NULL, reduction modulo \p P is done using a generic algorithm.
* Otherwise, \p modp must point to a function that takes an \p mbedtls_mpi in the
* range of <code>0..2^(2*pbits)-1</code>, and transforms it in-place to an integer
* which is congruent mod \p P to the given MPI, and is close enough to \p pbits
* in size, so that it may be efficiently brought in the 0..P-1 range by a few
* additions or subtractions. Therefore, it is only an approximative modular
* reduction. It must return 0 on success and non-zero on failure.
*
* \note Alternative implementations must keep the group IDs distinct. If
* two group structures have the same ID, then they must be
* identical.
*
*/
typedef struct mbedtls_ecp_group
{
mbedtls_ecp_group_id id; /*!< An internal group identifier. */
mbedtls_mpi P; /*!< The prime modulus of the base field. */
mbedtls_mpi A; /*!< For Short Weierstrass: \p A in the equation. For
Montgomery curves: <code>(A + 2) / 4</code>. */
mbedtls_mpi B; /*!< For Short Weierstrass: \p B in the equation.
For Montgomery curves: unused. */
mbedtls_ecp_point G; /*!< The generator of the subgroup used. */
mbedtls_mpi N; /*!< The order of \p G. */
size_t pbits; /*!< The number of bits in \p P.*/
size_t nbits; /*!< For Short Weierstrass: The number of bits in \p P.
For Montgomery curves: the number of bits in the
private keys. */
unsigned int h; /*!< \internal 1 if the constants are static. */
int (*modp)(mbedtls_mpi *); /*!< The function for fast pseudo-reduction
mod \p P (see above).*/
int (*t_pre)(mbedtls_ecp_point *, void *); /*!< Unused. */
int (*t_post)(mbedtls_ecp_point *, void *); /*!< Unused. */
void *t_data; /*!< Unused. */
mbedtls_ecp_point *T; /*!< Pre-computed points for ecp_mul_comb(). */
size_t T_size; /*!< The number of pre-computed points. */
}
mbedtls_ecp_group;
/**
* \name SECTION: Module settings
*
* The configuration options you can set for this module are in this section.
* Either change them in config.h, or define them using the compiler command line.
* \{
*/
#if !defined(MBEDTLS_ECP_MAX_BITS)
/**
* The maximum size of the groups, that is, of \c N and \c P.
*/
#define MBEDTLS_ECP_MAX_BITS 521 /*< The maximum size of groups, in bits. */
#endif
#define MBEDTLS_ECP_MAX_BYTES ( ( MBEDTLS_ECP_MAX_BITS + 7 ) / 8 )
#define MBEDTLS_ECP_MAX_PT_LEN ( 2 * MBEDTLS_ECP_MAX_BYTES + 1 )
#if !defined(MBEDTLS_ECP_WINDOW_SIZE)
/*
* Maximum "window" size used for point multiplication.
* Default: 6.
* Minimum value: 2. Maximum value: 7.
*
* Result is an array of at most ( 1 << ( MBEDTLS_ECP_WINDOW_SIZE - 1 ) )
* points used for point multiplication. This value is directly tied to EC
* peak memory usage, so decreasing it by one should roughly cut memory usage
* by two (if large curves are in use).
*
* Reduction in size may reduce speed, but larger curves are impacted first.
* Sample performances (in ECDHE handshakes/s, with FIXED_POINT_OPTIM = 1):
* w-size: 6 5 4 3 2
* 521 145 141 135 120 97
* 384 214 209 198 177 146
* 256 320 320 303 262 226
* 224 475 475 453 398 342
* 192 640 640 633 587 476
*/
#define MBEDTLS_ECP_WINDOW_SIZE 6 /*< The maximum window size used. */
#endif /* MBEDTLS_ECP_WINDOW_SIZE */
#if !defined(MBEDTLS_ECP_FIXED_POINT_OPTIM)
/*
* Trade memory for speed on fixed-point multiplication.
*
* This speeds up repeated multiplication of the generator (that is, the
* multiplication in ECDSA signatures, and half of the multiplications in
* ECDSA verification and ECDHE) by a factor roughly 3 to 4.
*
* The cost is increasing EC peak memory usage by a factor roughly 2.
*
* Change this value to 0 to reduce peak memory usage.
*/
#define MBEDTLS_ECP_FIXED_POINT_OPTIM 1 /*< Enable fixed-point speed-up. */
#endif /* MBEDTLS_ECP_FIXED_POINT_OPTIM */
/* \} name SECTION: Module settings */
#endif /* MBEDTLS_ECP_ALT */
#if defined(MBEDTLS_ECP_RESTARTABLE)
/**
* \brief Internal restart context for multiplication
*
* \note Opaque struct
*/
typedef struct mbedtls_ecp_restart_mul mbedtls_ecp_restart_mul_ctx;
/**
* \brief Internal restart context for ecp_muladd()
*
* \note Opaque struct
*/
typedef struct mbedtls_ecp_restart_muladd mbedtls_ecp_restart_muladd_ctx;
/**
* \brief General context for resuming ECC operations
*/
typedef struct
{
unsigned ops_done; /*!< current ops count */
unsigned depth; /*!< call depth (0 = top-level) */
mbedtls_ecp_restart_mul_ctx *rsm; /*!< ecp_mul_comb() sub-context */
mbedtls_ecp_restart_muladd_ctx *ma; /*!< ecp_muladd() sub-context */
} mbedtls_ecp_restart_ctx;
/*
* Operation counts for restartable functions
*/
#define MBEDTLS_ECP_OPS_CHK 3 /*!< basic ops count for ecp_check_pubkey() */
#define MBEDTLS_ECP_OPS_DBL 8 /*!< basic ops count for ecp_double_jac() */
#define MBEDTLS_ECP_OPS_ADD 11 /*!< basic ops count for see ecp_add_mixed() */
#define MBEDTLS_ECP_OPS_INV 120 /*!< empirical equivalent for mpi_mod_inv() */
/**
* \brief Internal; for restartable functions in other modules.
* Check and update basic ops budget.
*
* \param grp Group structure
* \param rs_ctx Restart context
* \param ops Number of basic ops to do
*
* \return \c 0 if doing \p ops basic ops is still allowed,
* \return #MBEDTLS_ERR_ECP_IN_PROGRESS otherwise.
*/
int mbedtls_ecp_check_budget( const mbedtls_ecp_group *grp,
mbedtls_ecp_restart_ctx *rs_ctx,
unsigned ops );
/* Utility macro for checking and updating ops budget */
#define MBEDTLS_ECP_BUDGET( ops ) \
MBEDTLS_MPI_CHK( mbedtls_ecp_check_budget( grp, rs_ctx, \
(unsigned) (ops) ) );
#else /* MBEDTLS_ECP_RESTARTABLE */
#define MBEDTLS_ECP_BUDGET( ops ) /* no-op; for compatibility */
/* We want to declare restartable versions of existing functions anyway */
typedef void mbedtls_ecp_restart_ctx;
#endif /* MBEDTLS_ECP_RESTARTABLE */
/**
* \brief The ECP key-pair structure.
*
* A generic key-pair that may be used for ECDSA and fixed ECDH, for example.
*
* \note Members are deliberately in the same order as in the
* ::mbedtls_ecdsa_context structure.
*/
typedef struct mbedtls_ecp_keypair
{
mbedtls_ecp_group grp; /*!< Elliptic curve and base point */
mbedtls_mpi d; /*!< our secret value */
mbedtls_ecp_point Q; /*!< our public value */
}
mbedtls_ecp_keypair;
const mbedtls_ecp_curve_info *mbedtls_ecp_curve_info_from_grp_id( mbedtls_ecp_group_id );
const mbedtls_ecp_curve_info *mbedtls_ecp_curve_info_from_name( const char * );
const mbedtls_ecp_curve_info *mbedtls_ecp_curve_info_from_tls_id( uint16_t );
const mbedtls_ecp_curve_info *mbedtls_ecp_curve_list( void );
const mbedtls_ecp_group_id *mbedtls_ecp_grp_id_list( void );
int mbedtls_ecp_check_privkey( const mbedtls_ecp_group *, const mbedtls_mpi * );
int mbedtls_ecp_check_pub_priv( const mbedtls_ecp_keypair *, const mbedtls_ecp_keypair * );
int mbedtls_ecp_check_pubkey( const mbedtls_ecp_group *, const mbedtls_ecp_point * );
int mbedtls_ecp_copy( mbedtls_ecp_point *, const mbedtls_ecp_point * );
int mbedtls_ecp_gen_key( mbedtls_ecp_group_id, mbedtls_ecp_keypair *, int (*)(void *, unsigned char *, size_t), void * );
int mbedtls_ecp_gen_keypair( mbedtls_ecp_group *, mbedtls_mpi *, mbedtls_ecp_point *, int (*)(void *, unsigned char *, size_t), void * );
int mbedtls_ecp_gen_keypair_base( mbedtls_ecp_group *, const mbedtls_ecp_point *, mbedtls_mpi *, mbedtls_ecp_point *, int (*)(void *, unsigned char *, size_t), void * );
int mbedtls_ecp_gen_privkey( const mbedtls_ecp_group *, mbedtls_mpi *, int (*)(void *, unsigned char *, size_t), void * );
int mbedtls_ecp_group_copy( mbedtls_ecp_group *, const mbedtls_ecp_group * );
int mbedtls_ecp_group_load( mbedtls_ecp_group *, mbedtls_ecp_group_id );
int mbedtls_ecp_is_zero( mbedtls_ecp_point * );
int mbedtls_ecp_mul( mbedtls_ecp_group *, mbedtls_ecp_point *, const mbedtls_mpi *, const mbedtls_ecp_point *, int (*)(void *, unsigned char *, size_t), void * );
int mbedtls_ecp_mul_restartable( mbedtls_ecp_group *, mbedtls_ecp_point *, const mbedtls_mpi *, const mbedtls_ecp_point *, int (*)(void *, unsigned char *, size_t), void *, mbedtls_ecp_restart_ctx * );
int mbedtls_ecp_muladd( mbedtls_ecp_group *, mbedtls_ecp_point *, const mbedtls_mpi *, const mbedtls_ecp_point *, const mbedtls_mpi *, const mbedtls_ecp_point * );
int mbedtls_ecp_muladd_restartable( mbedtls_ecp_group *, mbedtls_ecp_point *, const mbedtls_mpi *, const mbedtls_ecp_point *, const mbedtls_mpi *, const mbedtls_ecp_point *, mbedtls_ecp_restart_ctx * );
int mbedtls_ecp_point_cmp( const mbedtls_ecp_point *, const mbedtls_ecp_point * );
int mbedtls_ecp_point_read_binary( const mbedtls_ecp_group *, mbedtls_ecp_point *, const unsigned char *, size_t );
int mbedtls_ecp_point_read_string( mbedtls_ecp_point *, int, const char *, const char * );
int mbedtls_ecp_point_write_binary( const mbedtls_ecp_group *, const mbedtls_ecp_point *, int, size_t *, unsigned char *, size_t );
int mbedtls_ecp_read_key( mbedtls_ecp_group_id, mbedtls_ecp_keypair *, const unsigned char *, size_t );
int mbedtls_ecp_restart_is_enabled( void );
int mbedtls_ecp_self_test( int );
int mbedtls_ecp_set_zero( mbedtls_ecp_point * );
int mbedtls_ecp_tls_read_group( mbedtls_ecp_group *, const unsigned char **, size_t );
int mbedtls_ecp_tls_read_group_id( mbedtls_ecp_group_id *, const unsigned char **, size_t );
int mbedtls_ecp_tls_read_point( const mbedtls_ecp_group *, mbedtls_ecp_point *, const unsigned char **, size_t );
int mbedtls_ecp_tls_write_group( const mbedtls_ecp_group *, size_t *, unsigned char *, size_t );
int mbedtls_ecp_tls_write_point( const mbedtls_ecp_group *, const mbedtls_ecp_point *, int, size_t *, unsigned char *, size_t );
int mbedtls_ecp_write_key( mbedtls_ecp_keypair *, unsigned char *, size_t );
int mbedtls_mpi_shift_l_mod( const mbedtls_ecp_group *, mbedtls_mpi * );
mbedtls_ecp_curve_type mbedtls_ecp_get_type( const mbedtls_ecp_group * );
void mbedtls_ecp_group_free( mbedtls_ecp_group * );
void mbedtls_ecp_group_init( mbedtls_ecp_group * );
void mbedtls_ecp_keypair_free( mbedtls_ecp_keypair * );
void mbedtls_ecp_keypair_init( mbedtls_ecp_keypair * );
void mbedtls_ecp_point_free( mbedtls_ecp_point * );
void mbedtls_ecp_point_init( mbedtls_ecp_point * );
void mbedtls_ecp_restart_free( mbedtls_ecp_restart_ctx * );
void mbedtls_ecp_restart_init( mbedtls_ecp_restart_ctx * );
void mbedtls_ecp_set_max_ops( unsigned );
int ecp_mod_p256(mbedtls_mpi *);
int ecp_mod_p384(mbedtls_mpi *);
COSMOPOLITAN_C_END_
#endif /* COSMOPOLITAN_THIRD_PARTY_MBEDTLS_ECP_H_ */
| 18,319 | 368 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/bignum.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:4;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright The Mbed TLS Contributors â
â â
â Licensed under the Apache License, Version 2.0 (the "License"); â
â you may not use this file except in compliance with the License. â
â You may obtain a copy of the License at â
â â
â http://www.apache.org/licenses/LICENSE-2.0 â
â â
â Unless required by applicable law or agreed to in writing, software â
â distributed under the License is distributed on an "AS IS" BASIS, â
â WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. â
â See the License for the specific language governing permissions and â
â limitations under the License. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/intrin/bits.h"
#include "libc/intrin/bsf.h"
#include "libc/intrin/bswap.h"
#include "libc/macros.internal.h"
#include "libc/nexgen32e/nexgen32e.h"
#include "libc/nexgen32e/x86feature.h"
#include "libc/runtime/runtime.h"
#include "libc/str/str.h"
#include "third_party/mbedtls/bignum.h"
#include "third_party/mbedtls/bignum_internal.h"
#include "third_party/mbedtls/chk.h"
#include "third_party/mbedtls/common.h"
#include "third_party/mbedtls/error.h"
#include "third_party/mbedtls/fastdiv.h"
#include "third_party/mbedtls/math.h"
#include "third_party/mbedtls/platform.h"
#include "third_party/mbedtls/profile.h"
#include "third_party/mbedtls/select.h"
asm(".ident\t\"\\n\\n\
Mbed TLS (Apache 2.0)\\n\
Copyright ARM Limited\\n\
Copyright Mbed TLS Contributors\"");
asm(".include \"libc/disclaimer.inc\"");
/* clang-format off */
/**
* @fileoverview Big Numbers.
*
* The following sources were referenced in the design of this
* Multi-precision Integer library:
*
* [1] Handbook of Applied Cryptography - 1997
* Menezes, van Oorschot and Vanstone
*
* [2] Multi-Precision Math
* Tom St Denis
* https://github.com/libtom/libtommath/blob/develop/tommath.pdf
*
* [3] GNU Multi-Precision Arithmetic Library
* https://gmplib.org/manual/index.html
*/
#if defined(MBEDTLS_BIGNUM_C)
/* Implementation that should never be optimized out by the compiler */
static inline void mbedtls_mpi_zeroize( mbedtls_mpi_uint *v, size_t n )
{
mbedtls_platform_zeroize( v, ciL * n );
}
/**
* \brief This function frees the components of an MPI context.
*
* \param X The MPI context to be cleared. This may be \c NULL,
* in which case this function is a no-op. If it is
* not \c NULL, it must point to an initialized MPI.
*/
void mbedtls_mpi_free( mbedtls_mpi *X )
{
if( !X )
return;
if( X->p )
{
mbedtls_mpi_zeroize( X->p, X->n );
mbedtls_free( X->p );
}
X->s = 1;
X->n = 0;
X->p = NULL;
}
/**
* \brief Enlarge an MPI to the specified number of limbs.
*
* \note This function does nothing if the MPI is
* already large enough.
*
* \param X The MPI to grow. It must be initialized.
* \param nblimbs The target number of limbs.
*
* \return \c 0 if successful.
* \return #MBEDTLS_ERR_MPI_ALLOC_FAILED if memory allocation failed.
* \return Another negative error code on other kinds of failure.
*/
int mbedtls_mpi_grow(mbedtls_mpi *X, size_t nblimbs)
{
mbedtls_mpi_uint *p;
MPI_VALIDATE_RET(X);
if (nblimbs > MBEDTLS_MPI_MAX_LIMBS)
return MBEDTLS_ERR_MPI_ALLOC_FAILED;
if (nblimbs > X->n)
{
if (X->p && (p = realloc_in_place(X->p, nblimbs * ciL)))
{
mbedtls_mpi_zeroize(p + X->n, nblimbs - X->n);
}
else
{
if (!(p = malloc(nblimbs * ciL)))
return MBEDTLS_ERR_MPI_ALLOC_FAILED;
if (X->p)
{
memcpy(p, X->p, X->n * ciL);
mbedtls_mpi_zeroize(p + X->n, nblimbs - X->n);
mbedtls_mpi_zeroize(X->p, X->n);
free(X->p);
}
else
{
mbedtls_mpi_zeroize(p, nblimbs);
}
}
X->n = nblimbs;
X->p = p;
}
return 0;
}
/**
* \brief This function resizes an MPI to a number of limbs.
*
* \param X The MPI to resize. This must point to an initialized MPI.
* \param n The minimum number of limbs to keep.
*
* \return \c 0 if successful.
* \return #MBEDTLS_ERR_MPI_ALLOC_FAILED if memory allocation failed
* which can only happen when resizing up
* \return Another negative error code on other kinds of failure.
*/
int mbedtls_mpi_resize(mbedtls_mpi *X, size_t n)
{
mbedtls_mpi_uint *p;
MPI_VALIDATE_RET(X);
if (X->n == n)
return 0;
if (X->n <= n)
return mbedtls_mpi_grow(X, n);
if (n > MBEDTLS_MPI_MAX_LIMBS)
return MBEDTLS_ERR_MPI_ALLOC_FAILED;
mbedtls_mpi_zeroize(X->p + n, X->n - n);
if (!realloc_in_place(X->p, n * ciL))
{
if (!(p = malloc(n * ciL)))
return MBEDTLS_ERR_MPI_ALLOC_FAILED;
memcpy(p, X->p, n * ciL);
mbedtls_mpi_zeroize(X->p, n);
free(X->p);
X->p = p;
}
X->n = n;
return 0;
}
/**
* \brief This function resizes an MPI downwards, keeping at
* least the specified number of limbs.
*
* If \c X is smaller than \c nblimbs, it is resized up
* instead.
*
* \param X The MPI to shrink. This must point to an initialized MPI.
* \param nblimbs The minimum number of limbs to keep.
*
* \return \c 0 if successful.
* \return #MBEDTLS_ERR_MPI_ALLOC_FAILED if memory allocation failed
* which can only happen when resizing up
* \return Another negative error code on other kinds of failure.
*/
int mbedtls_mpi_shrink(mbedtls_mpi *X, size_t nblimbs)
{
MPI_VALIDATE_RET(X);
if (X->n <= nblimbs) return mbedtls_mpi_grow(X, nblimbs);
return mbedtls_mpi_resize(X, MAX(MAX(1, nblimbs), mbedtls_mpi_limbs(X)));
}
/**
* \brief Make a copy of an MPI.
*
* \param X The destination MPI. This must point to an initialized MPI.
* \param Y The source MPI. This must point to an initialized MPI.
*
* \note The limb-buffer in the destination MPI is enlarged
* if necessary to hold the value in the source MPI.
*
* \return \c 0 if successful.
* \return #MBEDTLS_ERR_MPI_ALLOC_FAILED if memory allocation failed.
* \return Another negative error code on other kinds of failure.
*/
int mbedtls_mpi_copy( mbedtls_mpi *X, const mbedtls_mpi *Y )
{
int ret = 0;
size_t i;
MPI_VALIDATE_RET( X );
MPI_VALIDATE_RET( Y );
if( X == Y )
return( 0 );
if( Y->n == 0 )
{
mbedtls_mpi_free( X );
return( 0 );
}
for( i = Y->n - 1; i > 0; i-- )
if( Y->p[i] != 0 )
break;
i++;
X->s = Y->s;
if( X->n < i )
{
MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, i ) );
}
else
{
mbedtls_platform_zeroize( X->p + i, ( X->n - i ) * ciL );
}
memcpy( X->p, Y->p, i * ciL );
cleanup:
return( ret );
}
/**
* \brief Swap the contents of two MPIs.
*
* \param X The first MPI. It must be initialized.
* \param Y The second MPI. It must be initialized.
*/
void mbedtls_mpi_swap( mbedtls_mpi *X, mbedtls_mpi *Y )
{
mbedtls_mpi T;
MPI_VALIDATE( X );
MPI_VALIDATE( Y );
memcpy( &T, X, sizeof( mbedtls_mpi ) );
memcpy( X, Y, sizeof( mbedtls_mpi ) );
memcpy( Y, &T, sizeof( mbedtls_mpi ) );
}
/**
* \brief Perform a safe conditional copy of MPI which doesn't
* reveal whether the condition was true or not.
*
* \param X The MPI to conditionally assign to. This must point
* to an initialized MPI.
* \param Y The MPI to be assigned from. This must point to an
* initialized MPI.
* \param assign The condition deciding whether to perform the
* assignment or not. Possible values:
* * \c 1: Perform the assignment `X = Y`.
* * \c 0: Keep the original value of \p X.
*
* \note This function is equivalent to
* `if( assign ) mbedtls_mpi_copy( X, Y );`
* except that it avoids leaking any information about whether
* the assignment was done or not (the above code may leak
* information through branch prediction and/or memory access
* patterns analysis).
*
* \return \c 0 if successful.
* \return #MBEDTLS_ERR_MPI_ALLOC_FAILED if memory allocation failed.
* \return Another negative error code on other kinds of failure.
*/
int mbedtls_mpi_safe_cond_assign(mbedtls_mpi *X,
const mbedtls_mpi *Y,
unsigned char assign)
{
int ret = 0;
size_t i;
MPI_VALIDATE_RET(X);
MPI_VALIDATE_RET(Y);
/* make sure assign is 0 or 1 in a time-constant manner */
if (Y->n > X->n)
MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, Y->n ) );
assign = (assign | (unsigned char)-assign) >> 7;
X->s = Select(Y->s, X->s, -assign);
for (i = 0; i < Y->n; i++)
X->p[i] = Select(Y->p[i], X->p[i], -assign);
for (i = Y->n; i < X->n; i++)
X->p[i] &= CONCEAL("r", assign - 1);
cleanup:
return( ret );
}
/**
* \brief Perform a safe conditional swap which doesn't
* reveal whether the condition was true or not.
*
* \param X The first MPI. This must be initialized.
* \param Y The second MPI. This must be initialized.
* \param assign The condition deciding whether to perform
* the swap or not. Possible values:
* * \c 1: Swap the values of \p X and \p Y.
* * \c 0: Keep the original values of \p X and \p Y.
*
* \note This function is equivalent to
* if( assign ) mbedtls_mpi_swap( X, Y );
* except that it avoids leaking any information about whether
* the assignment was done or not (the above code may leak
* information through branch prediction and/or memory access
* patterns analysis).
*
* \return \c 0 if successful.
* \return #MBEDTLS_ERR_MPI_ALLOC_FAILED if memory allocation failed.
* \return Another negative error code on other kinds of failure.
*
*/
int mbedtls_mpi_safe_cond_swap( mbedtls_mpi *X, mbedtls_mpi *Y, unsigned char swap )
{
int ret, s;
size_t i;
mbedtls_mpi_uint tmp;
MPI_VALIDATE_RET( X );
MPI_VALIDATE_RET( Y );
if( X == Y )
return( 0 );
/* make sure swap is 0 or 1 in a time-constant manner */
swap = (swap | (unsigned char)-swap) >> 7;
MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, Y->n ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_grow( Y, X->n ) );
s = X->s;
X->s = X->s * ( 1 - swap ) + Y->s * swap;
Y->s = Y->s * ( 1 - swap ) + s * swap;
for( i = 0; i < X->n; i++ )
{
tmp = X->p[i];
X->p[i] = X->p[i] * ( 1 - swap ) + Y->p[i] * swap;
Y->p[i] = Y->p[i] * ( 1 - swap ) + tmp * swap;
}
cleanup:
return( ret );
}
/**
* \brief Store integer value in MPI.
*
* \param X The MPI to set. This must be initialized.
* \param z The value to use.
*
* \return \c 0 if successful.
* \return #MBEDTLS_ERR_MPI_ALLOC_FAILED if memory allocation failed.
* \return Another negative error code on other kinds of failure.
*/
int mbedtls_mpi_lset( mbedtls_mpi *X, mbedtls_mpi_sint z )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
MPI_VALIDATE_RET( X );
MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, 1 ) );
mbedtls_platform_zeroize( X->p, X->n * ciL );
X->p[0] = ( z < 0 ) ? -z : z;
X->s = ( z < 0 ) ? -1 : 1;
cleanup:
return( ret );
}
/**
* \brief Get a specific bit from an MPI.
*
* \param X The MPI to query. This must be initialized.
* \param pos Zero-based index of the bit to query.
*
* \return \c 0 or \c 1 on success, depending on whether bit \c pos
* of \c X is unset or set.
* \return A negative error code on failure.
*/
int mbedtls_mpi_get_bit( const mbedtls_mpi *X, size_t pos )
{
MPI_VALIDATE_RET( X );
if( X->n * biL <= pos )
return( 0 );
return( ( X->p[pos / biL] >> ( pos % biL ) ) & 0x01 );
}
/* Get a specific byte, without range checks. */
#define GET_BYTE( X, i ) \
( ( ( X )->p[( i ) / ciL] >> ( ( ( i ) % ciL ) * 8 ) ) & 0xff )
/**
* \brief Modify a specific bit in an MPI.
*
* \note This function will grow the target MPI if necessary to set a
* bit to \c 1 in a not yet existing limb. It will not grow if
* the bit should be set to \c 0.
*
* \param X The MPI to modify. This must be initialized.
* \param pos Zero-based index of the bit to modify.
* \param val The desired value of bit \c pos: \c 0 or \c 1.
*
* \return \c 0 if successful.
* \return #MBEDTLS_ERR_MPI_ALLOC_FAILED if memory allocation failed.
* \return Another negative error code on other kinds of failure.
*/
int mbedtls_mpi_set_bit( mbedtls_mpi *X, size_t pos, unsigned char val )
{
int ret = 0;
size_t off = pos / biL;
size_t idx = pos % biL;
MPI_VALIDATE_RET( X );
if( val != 0 && val != 1 )
return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
if( X->n * biL <= pos )
{
if( !val )
return( 0 );
MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, off + 1 ) );
}
X->p[off] &= ~( (mbedtls_mpi_uint) 0x01 << idx );
X->p[off] |= (mbedtls_mpi_uint) val << idx;
cleanup:
return( ret );
}
/**
* \brief Return the number of bits of value \c 0 before the
* least significant bit of value \c 1.
*
* \note This is the same as the zero-based index of
* the least significant bit of value \c 1.
*
* \param X The MPI to query.
*
* \return The number of bits of value \c 0 before the least significant
* bit of value \c 1 in \p X.
*/
size_t mbedtls_mpi_lsb( const mbedtls_mpi *X )
{
size_t i, j, count = 0;
MBEDTLS_INTERNAL_VALIDATE_RET(X, 0);
for( i = 0; i < X->n; i++ )
{
if ( X->p[i] )
return count + __builtin_ctzll(X->p[i]);
else
count += biL;
}
return 0;
}
/*
* Count leading zero bits in a given integer
*/
static inline size_t mbedtls_clz( const mbedtls_mpi_uint x )
{
return x ? __builtin_clzll(x) : biL;
}
/**
* \brief Return the number of bits up to and including the most
* significant bit of value \c 1.
*
* \note This is same as the one-based index of the most
* significant bit of value \c 1.
*
* \param X The MPI to query. This must point to an initialized MPI.
*
* \return The number of bits up to and including the most
* significant bit of value \c 1.
*/
size_t mbedtls_mpi_bitlen(const mbedtls_mpi *X)
{
size_t n;
n = mbedtls_mpi_limbs(X);
if (!n) return 0;
return biL - __builtin_clzll(X->p[n - 1]) + (n - 1) * biL;
}
/**
* \brief Return the total size of an MPI value in bytes.
*
* \param X The MPI to use. This must point to an initialized MPI.
*
* \note The value returned by this function may be less than
* the number of bytes used to store \p X internally.
* This happens if and only if there are trailing bytes
* of value zero.
*
* \return The least number of bytes capable of storing
* the absolute value of \p X.
*/
size_t mbedtls_mpi_size( const mbedtls_mpi *X )
{
return( ( mbedtls_mpi_bitlen( X ) + 7 ) >> 3 );
}
/*
* Convert an ASCII character to digit value
*/
static int mpi_get_digit( mbedtls_mpi_uint *d, int radix, char c )
{
*d = 255;
if( c >= 0x30 && c <= 0x39 ) *d = c - 0x30;
if( c >= 0x41 && c <= 0x46 ) *d = c - 0x37;
if( c >= 0x61 && c <= 0x66 ) *d = c - 0x57;
if( *d >= (mbedtls_mpi_uint) radix )
return( MBEDTLS_ERR_MPI_INVALID_CHARACTER );
return( 0 );
}
/**
* \brief Import an MPI from an ASCII string.
*
* \param X The destination MPI. This must point to an initialized MPI.
* \param radix The numeric base of the input string.
* \param s Null-terminated string buffer.
*
* \return \c 0 if successful.
* \return A negative error code on failure.
*/
int mbedtls_mpi_read_string( mbedtls_mpi *X, int radix, const char *s )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t i, j, slen, n;
mbedtls_mpi_uint d;
mbedtls_mpi T;
MPI_VALIDATE_RET( X );
MPI_VALIDATE_RET( s );
if( radix < 2 || radix > 16 )
return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
mbedtls_mpi_init( &T );
slen = strlen( s );
if( radix == 16 )
{
if( slen > MPI_SIZE_T_MAX >> 2 )
return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
n = BITS_TO_LIMBS( slen << 2 );
MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, n ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_lset( X, 0 ) );
for( i = slen, j = 0; i > 0; i--, j++ )
{
if( i == 1 && s[i - 1] == '-' )
{
X->s = -1;
break;
}
MBEDTLS_MPI_CHK( mpi_get_digit( &d, radix, s[i - 1] ) );
X->p[j / ( 2 * ciL )] |= d << ( ( j % ( 2 * ciL ) ) << 2 );
}
}
else
{
MBEDTLS_MPI_CHK( mbedtls_mpi_lset( X, 0 ) );
for( i = 0; i < slen; i++ )
{
if( i == 0 && s[i] == '-' )
{
X->s = -1;
continue;
}
MBEDTLS_MPI_CHK( mpi_get_digit( &d, radix, s[i] ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_mul_int( &T, X, radix ) );
if( X->s == 1 )
{
MBEDTLS_MPI_CHK( mbedtls_mpi_add_int( X, &T, d ) );
}
else
{
MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( X, &T, d ) );
}
}
}
cleanup:
mbedtls_mpi_free( &T );
return( ret );
}
/*
* Helper to write the digits high-order first.
*/
static int mpi_write_hlp( mbedtls_mpi *X, int radix,
char **p, const size_t buflen )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
mbedtls_mpi_uint r;
size_t length = 0;
char *p_end = *p + buflen;
do
{
if( length >= buflen )
{
return( MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL );
}
MBEDTLS_MPI_CHK( mbedtls_mpi_mod_int( &r, X, radix ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_div_int( X, NULL, X, radix ) );
/*
* Write the residue in the current position, as an ASCII character.
*/
if( r < 0xA )
*(--p_end) = (char)( '0' + r );
else
*(--p_end) = (char)( 'A' + ( r - 0xA ) );
length++;
} while( mbedtls_mpi_cmp_int( X, 0 ) != 0 );
memmove( *p, p_end, length );
*p += length;
cleanup:
return( ret );
}
/**
* \brief Export an MPI to an ASCII string.
*
* \param X The source MPI. This must point to an initialized MPI.
* \param radix The numeric base of the output string.
* \param buf The buffer to write the string to. This must be writable
* buffer of length \p buflen Bytes.
* \param buflen The available size in Bytes of \p buf.
* \param olen The address at which to store the length of the string
* written, including the final \c NULL byte. This must
* not be \c NULL.
*
* \note You can call this function with `buflen == 0` to obtain the
* minimum required buffer size in `*olen`.
*
* \return \c 0 if successful.
* \return #MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL if the target buffer \p buf
* is too small to hold the value of \p X in the desired base.
* In this case, `*olen` is nonetheless updated to contain the
* size of \p buf required for a successful call.
* \return Another negative error code on different kinds of failure.
*/
int mbedtls_mpi_write_string( const mbedtls_mpi *X, int radix,
char *buf, size_t buflen, size_t *olen )
{
int ret = 0;
size_t n;
char *p;
mbedtls_mpi T;
MPI_VALIDATE_RET( X );
MPI_VALIDATE_RET( olen );
MPI_VALIDATE_RET( buflen == 0 || buf );
if( radix < 2 || radix > 16 )
return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
n = mbedtls_mpi_bitlen( X ); /* Number of bits necessary to present `n`. */
if( radix >= 4 ) n >>= 1; /* Number of 4-adic digits necessary to present
* `n`. If radix > 4, this might be a strict
* overapproximation of the number of
* radix-adic digits needed to present `n`. */
if( radix >= 16 ) n >>= 1; /* Number of hexadecimal digits necessary to
* present `n`. */
n += 1; /* Terminating null byte */
n += 1; /* Compensate for the divisions above, which round down `n`
* in case it's not even. */
n += 1; /* Potential '-'-sign. */
n += ( n & 1 ); /* Make n even to have enough space for hexadecimal writing,
* which always uses an even number of hex-digits. */
if( buflen < n )
{
*olen = n;
return( MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL );
}
p = buf;
mbedtls_mpi_init( &T );
if( X->s == -1 )
{
*p++ = '-';
buflen--;
}
if( radix == 16 )
{
int c;
size_t i, j, k;
for( i = X->n, k = 0; i > 0; i-- )
{
for( j = ciL; j > 0; j-- )
{
c = ( X->p[i - 1] >> ( ( j - 1 ) << 3) ) & 0xFF;
if( c == 0 && k == 0 && ( i + j ) != 2 )
continue;
*(p++) = "0123456789ABCDEF" [c / 16];
*(p++) = "0123456789ABCDEF" [c % 16];
k = 1;
}
}
}
else
{
MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &T, X ) );
if( T.s == -1 )
T.s = 1;
MBEDTLS_MPI_CHK( mpi_write_hlp( &T, radix, &p, buflen ) );
}
*p++ = '\0';
*olen = p - buf;
cleanup:
mbedtls_mpi_free( &T );
return( ret );
}
#if defined(MBEDTLS_FS_IO)
/**
* \brief Read an MPI from a line in an opened file.
*
* \param X The destination MPI. This must point to an initialized MPI.
* \param radix The numeric base of the string representation used
* in the source line.
* \param fin The input file handle to use. This must not be \c NULL.
*
* \note On success, this function advances the file stream
* to the end of the current line or to EOF.
*
* The function returns \c 0 on an empty line.
*
* Leading whitespaces are ignored, as is a
* '0x' prefix for radix \c 16.
*
* \return \c 0 if successful.
* \return #MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL if the file read buffer
* is too small.
* \return Another negative error code on failure.
*/
int mbedtls_mpi_read_file( mbedtls_mpi *X, int radix, FILE *fin )
{
mbedtls_mpi_uint d;
size_t slen;
char *p;
/*
* Buffer should have space for (short) label and decimal formatted MPI,
* newline characters and '\0'
*/
char s[ MBEDTLS_MPI_RW_BUFFER_SIZE ];
MPI_VALIDATE_RET( X );
MPI_VALIDATE_RET( fin );
if( radix < 2 || radix > 16 )
return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
mbedtls_platform_zeroize( s, sizeof( s ) );
if( fgets( s, sizeof( s ) - 1, fin ) == NULL )
return( MBEDTLS_ERR_MPI_FILE_IO_ERROR );
slen = strlen( s );
if( slen == sizeof( s ) - 2 )
return( MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL );
if( slen > 0 && s[slen - 1] == '\n' ) { slen--; s[slen] = '\0'; }
if( slen > 0 && s[slen - 1] == '\r' ) { slen--; s[slen] = '\0'; }
p = s + slen;
while( p-- > s )
if( mpi_get_digit( &d, radix, *p ) != 0 )
break;
return( mbedtls_mpi_read_string( X, radix, p + 1 ) );
}
/**
* \brief Export an MPI into an opened file.
*
* \param p A string prefix to emit prior to the MPI data.
* For example, this might be a label, or "0x" when
* printing in base \c 16. This may be \c NULL if no prefix
* is needed.
* \param X The source MPI. This must point to an initialized MPI.
* \param radix The numeric base to be used in the emitted string.
* \param fout The output file handle. This may be \c NULL, in which case
* the output is written to \c stdout.
*
* \return \c 0 if successful.
* \return A negative error code on failure.
*/
int mbedtls_mpi_write_file( const char *p, const mbedtls_mpi *X, int radix, FILE *fout )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t n, slen, plen;
/*
* Buffer should have space for (short) label and decimal formatted MPI,
* newline characters and '\0'
*/
char s[ MBEDTLS_MPI_RW_BUFFER_SIZE ];
MPI_VALIDATE_RET( X );
if( radix < 2 || radix > 16 )
return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
mbedtls_platform_zeroize( s, sizeof( s ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_write_string( X, radix, s, sizeof( s ) - 2, &n ) );
if( p == NULL ) p = "";
plen = strlen( p );
slen = strlen( s );
s[slen++] = '\r';
s[slen++] = '\n';
if( fout )
{
if( fwrite( p, 1, plen, fout ) != plen ||
fwrite( s, 1, slen, fout ) != slen )
return( MBEDTLS_ERR_MPI_FILE_IO_ERROR );
}
else
mbedtls_printf( "%s%s", p, s );
cleanup:
return( ret );
}
#endif /* MBEDTLS_FS_IO */
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
#define mpi_uint_bigendian_to_host(x) (x)
#elif __SIZEOF_LONG__ == 8
#define mpi_uint_bigendian_to_host(x) __builtin_bswap64(x)
#elif __SIZEOF_LONG__ == 4
#define mpi_uint_bigendian_to_host(x) __builtin_bswap32(x)
#endif
static void mpi_bigendian_to_host( mbedtls_mpi_uint * const p, size_t limbs )
{
mbedtls_mpi_uint *cur_limb_left;
mbedtls_mpi_uint *cur_limb_right;
if( !limbs )
return;
/*
* Traverse limbs and
* - adapt byte-order in each limb
* - swap the limbs themselves.
* For that, simultaneously traverse the limbs from left to right
* and from right to left, as long as the left index is not bigger
* than the right index (it's not a problem if limbs is odd and the
* indices coincide in the last iteration).
*/
for( cur_limb_left = p, cur_limb_right = p + ( limbs - 1 );
cur_limb_left <= cur_limb_right;
cur_limb_left++, cur_limb_right-- )
{
mbedtls_mpi_uint tmp;
/* Note that if cur_limb_left == cur_limb_right,
* this code effectively swaps the bytes only once. */
tmp = mpi_uint_bigendian_to_host( *cur_limb_left );
*cur_limb_left = mpi_uint_bigendian_to_host( *cur_limb_right );
*cur_limb_right = tmp;
}
}
/**
* \brief Import X from unsigned binary data, little endian
*
* \param X The destination MPI. This must point to an initialized MPI.
* \param p The input buffer with \p n bytes.
* \param n The length of the input buffer \p p in Bytes.
*
* \return \c 0 if successful.
* \return #MBEDTLS_ERR_MPI_ALLOC_FAILED if memory allocation failed.
* \return Another negative error code on different kinds of failure.
*/
int mbedtls_mpi_read_binary_le(mbedtls_mpi *X, const unsigned char *p, size_t n)
{
int ret;
size_t i;
mbedtls_mpi_uint w;
MPI_VALIDATE_RET(X);
MPI_VALIDATE_RET(!n || p);
if ((ret = mbedtls_mpi_resize(X, MAX(1, CHARS_TO_LIMBS(n))))) return ret;
if (n) {
for (i = 0; i + 8 <= n; i += 8)
X->p[i / ciL] = READ64LE(p + i);
if (i < n) {
w = 0;
do {
w <<= 8;
w |= p[i];
} while (++i < n);
X->p[i / ciL] = w;
}
} else {
X->p[0] = 0;
}
X->s = 1;
return 0;
}
/**
* \brief Import an MPI from unsigned big endian binary data.
*
* \param X The destination MPI. This must point to an initialized MPI.
* \param p The input buffer. This must be a readable buffer of length
* \p n Bytes.
* \param n The length of the input buffer \p p in Bytes.
*
* \return \c 0 if successful.
* \return #MBEDTLS_ERR_MPI_ALLOC_FAILED if memory allocation failed.
* \return Another negative error code on different kinds of failure.
*/
int mbedtls_mpi_read_binary(mbedtls_mpi *X, const unsigned char *p, size_t n)
{
int ret;
size_t i, j, k;
mbedtls_mpi_uint w;
MPI_VALIDATE_RET(X);
MPI_VALIDATE_RET(!n || p);
if ((ret = mbedtls_mpi_resize(X, MAX(1, CHARS_TO_LIMBS(n)))))
return ret;
if (n)
{
for (j = 0, i = n; i >= 8; i -= 8)
X->p[j++] = READ64BE(p + i - ciL);
if (i)
{
k = 0;
w = 0;
do
{
--i;
w <<= 8;
w |= p[k++];
} while (i);
X->p[j] = w;
}
}
else
{
X->p[0] = 0;
}
X->s = 1;
return 0;
}
/**
* \brief Export X into unsigned binary data, little endian.
* Always fills the whole buffer, which will end with zeros
* if the number is smaller.
*
* \param X The source MPI. This must point to an initialized MPI.
* \param buf The output buffer. This must be a writable buffer of length
* \p buflen Bytes.
* \param buflen The size of the output buffer \p buf in Bytes.
*
* \return \c 0 if successful.
* \return #MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL if \p buf isn't
* large enough to hold the value of \p X.
* \return Another negative error code on different kinds of failure.
*/
int mbedtls_mpi_write_binary_le( const mbedtls_mpi *X,
unsigned char *buf, size_t buflen )
{
size_t stored_bytes = X->n * ciL;
size_t bytes_to_copy;
size_t i;
if( stored_bytes < buflen )
{
bytes_to_copy = stored_bytes;
}
else
{
bytes_to_copy = buflen;
/* The output buffer is smaller than the allocated size of X.
* However X may fit if its leading bytes are zero. */
for( i = bytes_to_copy; i < stored_bytes; i++ )
{
if( GET_BYTE( X, i ) != 0 )
return( MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL );
}
}
for( i = 0; i < bytes_to_copy; i++ )
buf[i] = GET_BYTE( X, i );
if( stored_bytes < buflen )
{
/* Write trailing 0 bytes */
mbedtls_platform_zeroize( buf + stored_bytes, buflen - stored_bytes );
}
return( 0 );
}
/**
* \brief Export X into unsigned binary data, big endian.
* Always fills the whole buffer, which will start with zeros
* if the number is smaller.
*
* \param X The source MPI. This must point to an initialized MPI.
* \param buf The output buffer. This must be a writable buffer of length
* \p buflen Bytes.
* \param buflen The size of the output buffer \p buf in Bytes.
*
* \return \c 0 if successful.
* \return #MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL if \p buf isn't
* large enough to hold the value of \p X.
* \return Another negative error code on different kinds of failure.
*/
int mbedtls_mpi_write_binary( const mbedtls_mpi *X,
unsigned char *buf, size_t buflen )
{
size_t stored_bytes;
size_t bytes_to_copy;
unsigned char *p;
size_t i;
MPI_VALIDATE_RET( X );
MPI_VALIDATE_RET( buflen == 0 || buf );
stored_bytes = X->n * ciL;
if( stored_bytes < buflen )
{
/* There is enough space in the output buffer. Write initial
* null bytes and record the position at which to start
* writing the significant bytes. In this case, the execution
* trace of this function does not depend on the value of the
* number. */
bytes_to_copy = stored_bytes;
p = buf + buflen - stored_bytes;
mbedtls_platform_zeroize( buf, buflen - stored_bytes );
}
else
{
/* The output buffer is smaller than the allocated size of X.
* However X may fit if its leading bytes are zero. */
bytes_to_copy = buflen;
p = buf;
for( i = bytes_to_copy; i < stored_bytes; i++ )
{
if( GET_BYTE( X, i ) != 0 )
return( MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL );
}
}
for( i = 0; i < bytes_to_copy; i++ )
p[bytes_to_copy - i - 1] = GET_BYTE( X, i );
return( 0 );
}
/**
* \brief Compare the absolute values of two MPIs.
*
* \param X The left-hand MPI. This must point to an initialized MPI.
* \param Y The right-hand MPI. This must point to an initialized MPI.
*
* \return \c 1 if `|X|` is greater than `|Y|`.
* \return \c -1 if `|X|` is lesser than `|Y|`.
* \return \c 0 if `|X|` is equal to `|Y|`.
*/
int mbedtls_mpi_cmp_abs( const mbedtls_mpi *X, const mbedtls_mpi *Y )
{
size_t i, j;
MPI_VALIDATE_RET( X );
MPI_VALIDATE_RET( Y );
i = mbedtls_mpi_limbs(X);
j = mbedtls_mpi_limbs(Y);
if( !i && !j )
return( 0 );
if( i > j ) return( 1 );
if( j > i ) return( -1 );
for( ; i > 0; i-- )
{
if( X->p[i - 1] > Y->p[i - 1] ) return( 1 );
if( X->p[i - 1] < Y->p[i - 1] ) return( -1 );
}
return( 0 );
}
/**
* \brief Compare two MPIs.
*
* \param X The left-hand MPI. This must point to an initialized MPI.
* \param Y The right-hand MPI. This must point to an initialized MPI.
*
* \return \c 1 if \p X is greater than \p Y.
* \return \c -1 if \p X is lesser than \p Y.
* \return \c 0 if \p X is equal to \p Y.
*/
int mbedtls_mpi_cmp_mpi( const mbedtls_mpi *X, const mbedtls_mpi *Y )
{
size_t i, j;
MPI_VALIDATE_RET( X );
MPI_VALIDATE_RET( Y );
i = mbedtls_mpi_limbs(X);
j = mbedtls_mpi_limbs(Y);
if( !i && !j )
return( 0 );
if( i > j ) return( X->s );
if( j > i ) return( -Y->s );
if( X->s > 0 && Y->s < 0 ) return( 1 );
if( Y->s > 0 && X->s < 0 ) return( -1 );
for( ; i > 0; i-- )
{
if( X->p[i - 1] > Y->p[i - 1] ) return( X->s );
if( X->p[i - 1] < Y->p[i - 1] ) return( -X->s );
}
return( 0 );
}
/**
* Decide if an integer is less than the other, without branches.
*
* \param x First integer.
* \param y Second integer.
*
* \return 1 if \p x is less than \p y, 0 otherwise
*/
static unsigned ct_lt_mpi_uint( const mbedtls_mpi_uint x,
const mbedtls_mpi_uint y )
{
mbedtls_mpi_uint ret;
mbedtls_mpi_uint cond;
/*
* Check if the most significant bits (MSB) of the operands are different.
*/
cond = ( x ^ y );
/*
* If the MSB are the same then the difference x-y will be negative (and
* have its MSB set to 1 during conversion to unsigned) if and only if x<y.
*/
ret = ( x - y ) & ~cond;
/*
* If the MSB are different, then the operand with the MSB of 1 is the
* bigger. (That is if y has MSB of 1, then x<y is true and it is false if
* the MSB of y is 0.)
*/
ret |= y & cond;
ret = ret >> ( biL - 1 );
return (unsigned) ret;
}
/**
* \brief Check if an MPI is less than the other in constant time.
*
* \param X The left-hand MPI. This must point to an initialized MPI
* with the same allocated length as Y.
* \param Y The right-hand MPI. This must point to an initialized MPI
* with the same allocated length as X.
* \param ret The result of the comparison:
* \c 1 if \p X is less than \p Y.
* \c 0 if \p X is greater than or equal to \p Y.
*
* \return 0 on success.
* \return MBEDTLS_ERR_MPI_BAD_INPUT_DATA if the allocated length of
* the two input MPIs is not the same.
*/
int mbedtls_mpi_lt_mpi_ct( const mbedtls_mpi *X, const mbedtls_mpi *Y,
unsigned *ret )
{
size_t i;
/* The value of any of these variables is either 0 or 1 at all times. */
unsigned cond, done, X_is_negative, Y_is_negative;
MPI_VALIDATE_RET( X );
MPI_VALIDATE_RET( Y );
MPI_VALIDATE_RET( ret );
if( X->n != Y->n )
return MBEDTLS_ERR_MPI_BAD_INPUT_DATA;
/*
* Set sign_N to 1 if N >= 0, 0 if N < 0.
* We know that N->s == 1 if N >= 0 and N->s == -1 if N < 0.
*/
X_is_negative = ( X->s & 2 ) >> 1;
Y_is_negative = ( Y->s & 2 ) >> 1;
/*
* If the signs are different, then the positive operand is the bigger.
* That is if X is negative (X_is_negative == 1), then X < Y is true and it
* is false if X is positive (X_is_negative == 0).
*/
cond = ( X_is_negative ^ Y_is_negative );
*ret = cond & X_is_negative;
/*
* This is a constant-time function. We might have the result, but we still
* need to go through the loop. Record if we have the result already.
*/
done = cond;
for( i = X->n; i > 0; i-- )
{
/*
* If Y->p[i - 1] < X->p[i - 1] then X < Y is true if and only if both
* X and Y are negative.
*
* Again even if we can make a decision, we just mark the result and
* the fact that we are done and continue looping.
*/
cond = ct_lt_mpi_uint( Y->p[i - 1], X->p[i - 1] );
*ret |= cond & ( 1 - done ) & X_is_negative;
done |= cond;
/*
* If X->p[i - 1] < Y->p[i - 1] then X < Y is true if and only if both
* X and Y are positive.
*
* Again even if we can make a decision, we just mark the result and
* the fact that we are done and continue looping.
*/
cond = ct_lt_mpi_uint( X->p[i - 1], Y->p[i - 1] );
*ret |= cond & ( 1 - done ) & ( 1 - X_is_negative );
done |= cond;
}
return( 0 );
}
/**
* \brief Compare an MPI with an integer.
*
* \param X The left-hand MPI. This must point to an initialized MPI.
* \param z The integer value to compare \p X to.
*
* \return \c 1 if \p X is greater than \p z.
* \return \c -1 if \p X is lesser than \p z.
* \return \c 0 if \p X is equal to \p z.
*/
int mbedtls_mpi_cmp_int( const mbedtls_mpi *X, mbedtls_mpi_sint z )
{
mbedtls_mpi Y;
mbedtls_mpi_uint p[1];
MPI_VALIDATE_RET( X );
*p = ( z < 0 ) ? -z : z;
Y.s = ( z < 0 ) ? -1 : 1;
Y.n = 1;
Y.p = p;
return( mbedtls_mpi_cmp_mpi( X, &Y ) );
}
/**
* \brief Perform an unsigned addition of MPIs: X = |A| + |B|
*
* \param X The destination MPI. This must point to an initialized MPI.
* \param A The first summand. This must point to an initialized MPI.
* \param B The second summand. This must point to an initialized MPI.
*
* \return \c 0 if successful.
* \return #MBEDTLS_ERR_MPI_ALLOC_FAILED if a memory allocation failed.
* \return Another negative error code on different kinds of failure.
*/
int mbedtls_mpi_add_abs( mbedtls_mpi *X, const mbedtls_mpi *A, const mbedtls_mpi *B )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t i, j;
mbedtls_mpi_uint *o, *p, c, tmp;
MPI_VALIDATE_RET( X );
MPI_VALIDATE_RET( A );
MPI_VALIDATE_RET( B );
if( X == B )
{
const mbedtls_mpi *T = A; A = X; B = T;
}
if( X != A )
MBEDTLS_MPI_CHK( mbedtls_mpi_copy( X, A ) );
/*
* X should always be positive as a result of unsigned additions.
*/
X->s = 1;
for( j = B->n; j > 0; j-- )
if( B->p[j - 1] != 0 )
break;
MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, j ) );
o = B->p; p = X->p; c = 0;
/*
* tmp is used because it might happen that p == o
*/
for( i = 0; i < j; i++, o++, p++ )
{
tmp= *o;
*p += c; c = ( *p < c );
*p += tmp; c += ( *p < tmp );
}
while( c != 0 )
{
if( i >= X->n )
{
MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, i + 1 ) );
p = X->p + i;
}
*p += c; c = ( *p < c ); i++; p++;
}
cleanup:
return( ret );
}
/**
* Helper for mbedtls_mpi subtraction.
*
* Calculate d = a - b where d, a, and b have the same size.
* This function operates modulo (2^ciL)^n and returns the carry
* (1 if there was a wraparound, i.e. if `a < b`, and 0 otherwise).
*
* \param[out] d Result of subtraction.
* \param[in] a Left operand.
* \param[in] b Right operand.
* \param n Number of limbs of \p a and \p b.
* \return 1 if `d < s`.
* 0 if `d >= s`.
*/
forceinline mbedtls_mpi_uint mpi_sub_hlp(mbedtls_mpi_uint *d,
const mbedtls_mpi_uint *a,
const mbedtls_mpi_uint *b,
size_t n)
{
size_t i;
unsigned char cf;
mbedtls_mpi_uint c, x;
cf = c = i = 0;
#if defined(__x86_64__) && !defined(__STRICT_ANSI__)
if (!n) return 0;
asm volatile("xor\t%1,%1\n\t"
".align\t16\n1:\t"
"mov\t(%5,%3,8),%1\n\t"
"sbb\t(%6,%3,8),%1\n\t"
"mov\t%1,(%4,%3,8)\n\t"
"lea\t1(%3),%3\n\t"
"dec\t%2\n\t"
"jnz\t1b"
: "=@ccb"(cf), "=&r"(x), "+&c"(n), "=&r"(i)
: "r"(d), "r"(a), "r"(b), "3"(0)
: "cc", "memory");
return cf;
#else
for (; i < n; ++i)
SBB(d[i], a[i], b[i], c, c);
return c;
#endif
}
/**
* \brief Perform an unsigned subtraction of MPIs: X = |A| - |B|
*
* \param X The destination MPI. This must point to an initialized MPI.
* \param A The minuend. This must point to an initialized MPI.
* \param B The subtrahend. This must point to an initialized MPI.
*
* \return \c 0 if successful.
* \return #MBEDTLS_ERR_MPI_NEGATIVE_VALUE if \p B is greater than \p A.
* \return Another negative error code on different kinds of failure.
*/
int mbedtls_mpi_sub_abs( mbedtls_mpi *X, const mbedtls_mpi *A, const mbedtls_mpi *B )
{
size_t n, m, r;
MPI_VALIDATE_RET( X );
MPI_VALIDATE_RET( A );
MPI_VALIDATE_RET( B );
if( X != A && !B->n )
return mbedtls_mpi_copy( X, A ); /* wut */
for( n = B->n; n > 0; n-- )
if( B->p[n - 1] != 0 )
break;
if( n > A->n )
return MBEDTLS_ERR_MPI_NEGATIVE_VALUE; /* B >= (2^ciL)^n > A */
if (X != A)
{
if (X->n < A->n) {
if ((r = mbedtls_mpi_grow(X, A->n))) return r;
} else if (X->n > A->n) {
mbedtls_mpi_zeroize(X->p + A->n, X->n - A->n);
}
if ((m = A->n - n))
memcpy(X->p + n, A->p + n, m * ciL);
}
/*
* X should always be positive as a result of unsigned subtractions.
*/
X->s = 1;
if( mpi_sub_hlp( X->p, A->p, B->p, n ) ){
/* Propagate the carry to the first nonzero limb of X. */
for( ; n < A->n && A->p[n] == 0; n++ )
/* --X->p[n]; */
X->p[n] = A->p[n] - 1;
/* If we ran out of space for the carry, it means that the result
* is negative. */
if( n == X->n )
return MBEDTLS_ERR_MPI_NEGATIVE_VALUE;
--X->p[n];
}
return( 0 );
}
static int mpi_cmp_abs(const mbedtls_mpi *X,
const mbedtls_mpi *Y,
size_t *Xn,
size_t *Yn)
{
size_t i, j;
i = mbedtls_mpi_limbs(X);
j = mbedtls_mpi_limbs(Y);
*Xn = i;
*Yn = j;
if (!i && !j) return 0;
if (i > j) return 1;
if (j > i) return -1;
for (; i > 0; i--)
{
if (X->p[i - 1] > Y->p[i - 1]) return 1;
if (X->p[i - 1] < Y->p[i - 1]) return -1;
}
return 0;
}
static int mpi_sub_abs( mbedtls_mpi *X, const mbedtls_mpi *A, const mbedtls_mpi *B, size_t n )
{
size_t m, r;
if( X != A && !B->n )
return mbedtls_mpi_copy( X, A ); /* wut */
if( n > A->n )
return MBEDTLS_ERR_MPI_NEGATIVE_VALUE; /* B >= (2^ciL)^n > A */
if (X != A)
{
if (X->n < A->n) {
if ((r = mbedtls_mpi_grow(X, A->n))) return r;
} else if (X->n > A->n) {
mbedtls_mpi_zeroize(X->p + A->n, X->n - A->n);
}
if ((m = A->n - n))
memcpy(X->p + n, A->p + n, m * ciL);
}
/*
* X should always be positive as a result of unsigned subtractions.
*/
X->s = 1;
if( mpi_sub_hlp( X->p, A->p, B->p, n ) ){
/* Propagate the carry to the first nonzero limb of X. */
for( ; n < A->n && A->p[n] == 0; n++ )
/* --X->p[n]; */
X->p[n] = A->p[n] - 1;
/* If we ran out of space for the carry, it means that the result
* is negative. */
if( n == X->n )
return MBEDTLS_ERR_MPI_NEGATIVE_VALUE;
--X->p[n];
}
return( 0 );
}
/**
* \brief Perform a signed addition of MPIs: X = A + B
*
* \param X The destination MPI. This must point to an initialized MPI.
* \param A The first summand. This must point to an initialized MPI.
* \param B The second summand. This must point to an initialized MPI.
*
* \return \c 0 if successful.
* \return #MBEDTLS_ERR_MPI_ALLOC_FAILED if a memory allocation failed.
* \return Another negative error code on different kinds of failure.
*/
int mbedtls_mpi_add_mpi( mbedtls_mpi *X, const mbedtls_mpi *A, const mbedtls_mpi *B )
{
int ret, s;
size_t i, j;
MPI_VALIDATE_RET( X );
MPI_VALIDATE_RET( A );
MPI_VALIDATE_RET( B );
s = A->s;
if( A->s * B->s < 0 )
{
if( mpi_cmp_abs( A, B, &i, &j ) >= 0 )
{
MBEDTLS_MPI_CHK( mpi_sub_abs( X, A, B, j ) );
X->s = s;
}
else
{
MBEDTLS_MPI_CHK( mpi_sub_abs( X, B, A, i ) );
X->s = -s;
}
}
else
{
MBEDTLS_MPI_CHK( mbedtls_mpi_add_abs( X, A, B ) );
X->s = s;
}
cleanup:
return( ret );
}
/**
* \brief Perform a signed subtraction of MPIs: X = A - B
*
* \param X The destination MPI. This must point to an initialized MPI.
* \param A The minuend. This must point to an initialized MPI.
* \param B The subtrahend. This must point to an initialized MPI.
*
* \return \c 0 if successful.
* \return #MBEDTLS_ERR_MPI_ALLOC_FAILED if a memory allocation failed.
* \return Another negative error code on different kinds of failure.
*/
int mbedtls_mpi_sub_mpi( mbedtls_mpi *X, const mbedtls_mpi *A, const mbedtls_mpi *B )
{
int ret, s;
size_t i, j;
MPI_VALIDATE_RET( X );
MPI_VALIDATE_RET( A );
MPI_VALIDATE_RET( B );
s = A->s;
if( A->s * B->s > 0 )
{
if( mpi_cmp_abs( A, B, &i, &j ) >= 0 )
{
MBEDTLS_MPI_CHK( mpi_sub_abs( X, A, B, j ) );
X->s = s;
}
else
{
MBEDTLS_MPI_CHK( mpi_sub_abs( X, B, A, i ) );
X->s = -s;
}
}
else
{
MBEDTLS_MPI_CHK( mbedtls_mpi_add_abs( X, A, B ) );
X->s = s;
}
cleanup:
return( ret );
}
/**
* \brief Perform a signed addition of an MPI and an integer: X = A + b
*
* \param X The destination MPI. This must point to an initialized MPI.
* \param A The first summand. This must point to an initialized MPI.
* \param b The second summand.
*
* \return \c 0 if successful.
* \return #MBEDTLS_ERR_MPI_ALLOC_FAILED if a memory allocation failed.
* \return Another negative error code on different kinds of failure.
*/
int mbedtls_mpi_add_int( mbedtls_mpi *X, const mbedtls_mpi *A, mbedtls_mpi_sint b )
{
mbedtls_mpi _B;
mbedtls_mpi_uint p[1];
MPI_VALIDATE_RET( X );
MPI_VALIDATE_RET( A );
p[0] = ( b < 0 ) ? -b : b;
_B.s = ( b < 0 ) ? -1 : 1;
_B.n = 1;
_B.p = p;
return( mbedtls_mpi_add_mpi( X, A, &_B ) );
}
/**
* \brief Perform a signed subtraction of an MPI and an integer:
* X = A - b
*
* \param X The destination MPI. This must point to an initialized MPI.
* \param A The minuend. This must point to an initialized MPI.
* \param b The subtrahend.
*
* \return \c 0 if successful.
* \return #MBEDTLS_ERR_MPI_ALLOC_FAILED if a memory allocation failed.
* \return Another negative error code on different kinds of failure.
*/
int mbedtls_mpi_sub_int( mbedtls_mpi *X, const mbedtls_mpi *A, mbedtls_mpi_sint b )
{
mbedtls_mpi _B;
mbedtls_mpi_uint p[1];
MPI_VALIDATE_RET( X );
MPI_VALIDATE_RET( A );
p[0] = ( b < 0 ) ? -b : b;
_B.s = ( b < 0 ) ? -1 : 1;
_B.n = 1;
_B.p = p;
return( mbedtls_mpi_sub_mpi( X, A, &_B ) );
}
/*
* Unsigned integer divide - double mbedtls_mpi_uint dividend, u1/u0, and
* mbedtls_mpi_uint divisor, d
*/
static mbedtls_mpi_uint mbedtls_int_div_int( mbedtls_mpi_uint u1,
mbedtls_mpi_uint u0,
mbedtls_mpi_uint d,
mbedtls_mpi_uint *r )
{
#if defined(__x86_64__) && !defined(__STRICT_ANSI__)
if (d && u1 < d)
{
mbedtls_mpi_uint quo, rem;
asm("div\t%2" : "=a"(quo), "=d"(rem) : "r"(d), "0"(u0), "1"(u1) : "cc");
if (r) *r = rem;
return quo;
}
else
{
if (r) *r = ~0;
return ~0;
}
#else
#if defined(MBEDTLS_HAVE_UDBL)
mbedtls_t_udbl dividend, quotient;
#else
const mbedtls_mpi_uint radix = (mbedtls_mpi_uint) 1 << biH;
const mbedtls_mpi_uint uint_halfword_mask = ( (mbedtls_mpi_uint) 1 << biH ) - 1;
mbedtls_mpi_uint d0, d1, q0, q1, rAX, r0, quotient;
mbedtls_mpi_uint u0_msw, u0_lsw;
size_t s;
#endif
/*
* Check for overflow
*/
if( 0 == d || u1 >= d )
{
if (r) *r = ~0;
return ( ~0 );
}
#if defined(MBEDTLS_HAVE_UDBL)
dividend = (mbedtls_t_udbl) u1 << biL;
dividend |= (mbedtls_t_udbl) u0;
quotient = dividend / d;
if( quotient > ( (mbedtls_t_udbl) 1 << biL ) - 1 )
quotient = ( (mbedtls_t_udbl) 1 << biL ) - 1;
if( r )
*r = (mbedtls_mpi_uint)( dividend - (quotient * d ) );
return (mbedtls_mpi_uint) quotient;
#else
/*
* Algorithm D, Section 4.3.1 - The Art of Computer Programming
* Vol. 2 - Seminumerical Algorithms, Knuth
*/
/*
* Normalize the divisor, d, and dividend, u0, u1
*/
s = mbedtls_clz( d );
d = d << s;
u1 = u1 << s;
u1 |= ( u0 >> ( biL - s ) ) & ( -(mbedtls_mpi_sint)s >> ( biL - 1 ) );
u0 = u0 << s;
d1 = d >> biH;
d0 = d & uint_halfword_mask;
u0_msw = u0 >> biH;
u0_lsw = u0 & uint_halfword_mask;
/*
* Find the first quotient and remainder
*/
q1 = u1 / d1;
r0 = u1 - d1 * q1;
while( q1 >= radix || ( q1 * d0 > radix * r0 + u0_msw ) )
{
q1 -= 1;
r0 += d1;
if ( r0 >= radix ) break;
}
rAX = ( u1 * radix ) + ( u0_msw - q1 * d );
q0 = rAX / d1;
r0 = rAX - q0 * d1;
while( q0 >= radix || ( q0 * d0 > radix * r0 + u0_lsw ) )
{
q0 -= 1;
r0 += d1;
if ( r0 >= radix ) break;
}
if (r)
*r = ( rAX * radix + u0_lsw - q0 * d ) >> s;
quotient = q1 * radix + q0;
return quotient;
#endif
#endif
}
static inline void Multiply2x1(uint64_t a[3], uint64_t b) {
uint128_t x;
uint64_t l, h;
x = a[0];
x *= b;
l = x;
h = x >> 64;
x = a[1];
x *= b;
x += h + ((a[0] = l) < 0);
l = x;
h = x >> 64;
a[2] = h + ((a[1] = l) < 0);
}
static inline bool GreaterThan3x3(uint64_t a[3], uint64_t b[3]) {
if (a[2] > b[2]) return true;
if (a[2] < b[2]) return false;
if (a[1] > b[1]) return true;
if (a[1] < b[1]) return false;
return a[0] > b[0];
}
/**
* \brief Perform a division with remainder of two MPIs:
* A = Q * B + R
*
* \param Q The destination MPI for the quotient.
* This may be \c NULL if the value of the
* quotient is not needed.
* \param R The destination MPI for the remainder value.
* This may be \c NULL if the value of the
* remainder is not needed.
* \param A The dividend. This must point to an initialized MPi.
* \param B The divisor. This must point to an initialized MPI.
*
* \return \c 0 if successful.
* \return #MBEDTLS_ERR_MPI_ALLOC_FAILED if memory allocation failed.
* \return #MBEDTLS_ERR_MPI_DIVISION_BY_ZERO if \p B equals zero.
* \return Another negative error code on different kinds of failure.
*/
int mbedtls_mpi_div_mpi(mbedtls_mpi *Q, mbedtls_mpi *R, const mbedtls_mpi *A,
const mbedtls_mpi *B)
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t i, n, t, k, Xn, Yn;
mbedtls_mpi X, Y, Z, T1, T2;
mbedtls_mpi_uint TP2[3];
MPI_VALIDATE_RET(A);
MPI_VALIDATE_RET(B);
if (mbedtls_mpi_is_zero(B))
return MBEDTLS_ERR_MPI_DIVISION_BY_ZERO;
mbedtls_mpi_init(&X);
mbedtls_mpi_init(&Y);
mbedtls_mpi_init(&Z);
mbedtls_mpi_init(&T1);
/*
* Avoid dynamic memory allocations for constant-size T2.
*
* T2 is used for comparison only and the 3 limbs are assigned explicitly,
* so nobody increase the size of the MPI and we're safe to use an on-stack
* buffer.
*/
T2.s = 1;
T2.n = sizeof(TP2) / sizeof(*TP2);
T2.p = TP2;
if (mbedtls_mpi_cmp_abs(A, B) < 0)
{
if (Q) MBEDTLS_MPI_CHK(mbedtls_mpi_lset(Q, 0));
if (R) MBEDTLS_MPI_CHK(mbedtls_mpi_copy(R, A));
return 0;
}
MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&X, A));
MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&Y, B));
X.s = Y.s = 1;
MBEDTLS_MPI_CHK(mbedtls_mpi_grow(&Z, A->n + 2));
MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&Z, 0));
MBEDTLS_MPI_CHK(mbedtls_mpi_grow(&T1, 80)); /* we need left pad hard below */
k = mbedtls_mpi_bitlen(&Y) % biL;
if (k < biL - 1)
{
k = biL - 1 - k;
MBEDTLS_MPI_CHK(mbedtls_mpi_shift_l(&X, k));
MBEDTLS_MPI_CHK(mbedtls_mpi_shift_l(&Y, k));
}
else
{
k = 0;
}
n = X.n - 1;
t = Y.n - 1;
MBEDTLS_MPI_CHK(mbedtls_mpi_shift_l(&Y, biL * (n - t)));
while (mbedtls_mpi_cmp_abs(&X, &Y) >= 0)
{
Z.p[n - t]++;
MBEDTLS_MPI_CHK(mbedtls_mpi_sub_abs(&X, &X, &Y));
}
mbedtls_mpi_shift_r(&Y, biL * (n - t));
for (i = n; i > t; i--)
{
if (X.p[i] >= Y.p[t])
Z.p[i - t - 1] = ~0;
else
Z.p[i - t - 1] = mbedtls_int_div_int(X.p[i], X.p[i - 1], Y.p[t], NULL);
T2.p[0] = (i < 2) ? 0 : X.p[i - 2];
T2.p[1] = (i < 1) ? 0 : X.p[i - 1];
T2.p[2] = X.p[i];
Z.p[i - t - 1]++;
do {
Z.p[i - t - 1]--;
T1.p[0] = (t < 1) ? 0 : Y.p[t - 1];
T1.p[1] = Y.p[t];
Multiply2x1(T1.p, Z.p[i - t - 1]);
} while (GreaterThan3x3(T1.p, T2.p));
MBEDTLS_MPI_CHK(mbedtls_mpi_mul_int(&T1, &Y, Z.p[i - t - 1]));
MBEDTLS_MPI_CHK(mbedtls_mpi_shift_l(&T1, biL * (i - t - 1)));
MBEDTLS_MPI_CHK(mbedtls_mpi_sub_mpi(&X, &X, &T1));
if (X.s < 0)
{
MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&T1, &Y));
MBEDTLS_MPI_CHK(mbedtls_mpi_shift_l(&T1, biL * (i - t - 1)));
MBEDTLS_MPI_CHK(mbedtls_mpi_add_mpi(&X, &X, &T1));
Z.p[i - t - 1]--;
}
}
if (Q)
{
MBEDTLS_MPI_CHK(mbedtls_mpi_copy(Q, &Z));
Q->s = A->s * B->s;
}
if (R)
{
mbedtls_mpi_shift_r(&X, k);
X.s = A->s;
MBEDTLS_MPI_CHK(mbedtls_mpi_copy(R, &X));
if (mbedtls_mpi_is_zero(R)) R->s = 1;
}
cleanup:
mbedtls_mpi_free(&X);
mbedtls_mpi_free(&Y);
mbedtls_mpi_free(&Z);
mbedtls_mpi_free(&T1);
mbedtls_platform_zeroize(TP2, sizeof(TP2));
return ret;
}
/**
* \brief Perform a division with remainder of an MPI by an integer:
* A = Q * b + R
*
* \param Q The destination MPI for the quotient.
* This may be \c NULL if the value of the
* quotient is not needed.
* \param R The destination MPI for the remainder value.
* This may be \c NULL if the value of the
* remainder is not needed.
* \param A The dividend. This must point to an initialized MPi.
* \param b The divisor.
*
* \return \c 0 if successful.
* \return #MBEDTLS_ERR_MPI_ALLOC_FAILED if memory allocation failed.
* \return #MBEDTLS_ERR_MPI_DIVISION_BY_ZERO if \p b equals zero.
* \return Another negative error code on different kinds of failure.
*/
int mbedtls_mpi_div_int( mbedtls_mpi *Q, mbedtls_mpi *R,
const mbedtls_mpi *A,
mbedtls_mpi_sint b )
{
mbedtls_mpi _B;
mbedtls_mpi_uint p[1];
MPI_VALIDATE_RET( A );
p[0] = ( b < 0 ) ? -b : b;
_B.s = ( b < 0 ) ? -1 : 1;
_B.n = 1;
_B.p = p;
return( mbedtls_mpi_div_mpi( Q, R, A, &_B ) );
}
/**
* \brief Perform a modular reduction. R = A mod B
*
* \param R The destination MPI for the residue value.
* This must point to an initialized MPI.
* \param A The MPI to compute the residue of.
* This must point to an initialized MPI.
* \param B The base of the modular reduction.
* This must point to an initialized MPI.
*
* \return \c 0 if successful.
* \return #MBEDTLS_ERR_MPI_ALLOC_FAILED if a memory allocation failed.
* \return #MBEDTLS_ERR_MPI_DIVISION_BY_ZERO if \p B equals zero.
* \return #MBEDTLS_ERR_MPI_NEGATIVE_VALUE if \p B is negative.
* \return Another negative error code on different kinds of failure.
*
*/
int mbedtls_mpi_mod_mpi( mbedtls_mpi *R, const mbedtls_mpi *A, const mbedtls_mpi *B )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
MPI_VALIDATE_RET( R );
MPI_VALIDATE_RET( A );
MPI_VALIDATE_RET( B );
if( mbedtls_mpi_cmp_int( B, 0 ) < 0 )
return( MBEDTLS_ERR_MPI_NEGATIVE_VALUE );
MBEDTLS_MPI_CHK( mbedtls_mpi_div_mpi( NULL, R, A, B ) );
while( mbedtls_mpi_cmp_int( R, 0 ) < 0 )
MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( R, R, B ) );
while( mbedtls_mpi_cmp_mpi( R, B ) >= 0 )
MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( R, R, B ) );
cleanup:
return( ret );
}
/**
* \brief Perform a modular reduction with respect to an integer.
* r = A mod b
*
* \param r The address at which to store the residue.
* This must not be \c NULL.
* \param A The MPI to compute the residue of.
* This must point to an initialized MPi.
* \param b The integer base of the modular reduction.
*
* \return \c 0 if successful.
* \return #MBEDTLS_ERR_MPI_ALLOC_FAILED if a memory allocation failed.
* \return #MBEDTLS_ERR_MPI_DIVISION_BY_ZERO if \p b equals zero.
* \return #MBEDTLS_ERR_MPI_NEGATIVE_VALUE if \p b is negative.
* \return Another negative error code on different kinds of failure.
*/
int mbedtls_mpi_mod_int( mbedtls_mpi_uint *r, const mbedtls_mpi *A, mbedtls_mpi_sint b )
{
size_t i;
mbedtls_mpi_uint x, y, z;
MPI_VALIDATE_RET( r );
MPI_VALIDATE_RET( A );
if( b == 0 )
return( MBEDTLS_ERR_MPI_DIVISION_BY_ZERO );
if( b < 0 )
return( MBEDTLS_ERR_MPI_NEGATIVE_VALUE );
/*
* handle trivial cases
*/
if( b == 1 )
{
*r = 0;
return( 0 );
}
if( b == 2 )
{
*r = A->p[0] & 1;
return( 0 );
}
/*
* general case
*/
for( i = A->n, y = 0; i > 0; i-- )
{
x = A->p[i - 1];
y = ( y << biH ) | ( x >> biH );
z = y / b;
y -= z * b;
x <<= biH;
y = ( y << biH ) | ( x >> biH );
z = y / b;
y -= z * b;
}
/*
* If A is negative, then the current y represents a negative value.
* Flipping it to the positive side.
*/
if( A->s < 0 && y != 0 )
y = b - y;
*r = y;
return( 0 );
}
/*
* Fast Montgomery initialization (thanks to Tom St Denis)
*/
static void mpi_montg_init( mbedtls_mpi_uint *mm, const mbedtls_mpi *N )
{
mbedtls_mpi_uint x, m0 = N->p[0];
unsigned int i;
x = m0;
x += ( ( m0 + 2 ) & 4 ) << 1;
for( i = biL; i >= 8; i /= 2 )
x *= ( 2 - ( m0 * x ) );
*mm = -x;
}
/**
* Montgomery multiplication: A = A * B * R^-1 mod N (HAC 14.36)
*
* \param[in,out] A One of the numbers to multiply.
* It must have at least as many limbs as N
* (A->n >= N->n), and any limbs beyond n are ignored.
* On successful completion, A contains the result of
* the multiplication A * B * R^-1 mod N where
* R = (2^ciL)^n.
* \param[in] B One of the numbers to multiply.
* It must be nonzero and must not have more limbs than N
* (B->n <= N->n).
* \param[in] N The modulo. N must be odd.
* \param mm The value calculated by `mpi_montg_init(&mm, N)`.
* This is -N^-1 mod 2^ciL.
* \param[in,out] T A bignum for temporary storage.
* It must be at least twice the limb size of N plus 2
* (T->n >= 2 * (N->n + 1)).
* Its initial content is unused and
* its final content is indeterminate.
* Note that unlike the usual convention in the library
* for `const mbedtls_mpi*`, the content of T can change.
*/
static void mpi_montmul( mbedtls_mpi *A, const mbedtls_mpi *B, const mbedtls_mpi *N,
mbedtls_mpi_uint mm, const mbedtls_mpi *T )
{
size_t i, n, m;
mbedtls_mpi_uint u0, u1, *d, *Ap, *Bp, *Np;
mbedtls_platform_zeroize( T->p, T->n * ciL );
d = T->p;
n = N->n;
m = ( B->n < n ) ? B->n : n;
Ap = A->p;
Bp = B->p;
Np = N->p;
for( i = 0; i < n; i++ )
{
/*
* T = (T + u0*B + u1*N) / 2^biL
*/
u0 = Ap[i];
u1 = ( d[0] + u0 * Bp[0] ) * mm;
mbedtls_mpi_mul_hlp( m, Bp, d, u0 );
mbedtls_mpi_mul_hlp( n, Np, d, u1 );
*d++ = u0; d[n + 1] = 0;
}
/* At this point, d is either the desired result or the desired result
* plus N. We now potentially subtract N, avoiding leaking whether the
* subtraction is performed through side channels. */
/* Copy the n least significant limbs of d to A, so that
* A = d if d < N (recall that N has n limbs). */
memcpy( Ap, d, n * ciL );
/* If d >= N then we want to set A to d - N. To prevent timing attacks,
* do the calculation without using conditional tests. */
/* Set d to d0 + (2^biL)^n - N where d0 is the current value of d. */
d[n] += 1;
d[n] -= mpi_sub_hlp( d, d, Np, n );
/* If d0 < N then d < (2^biL)^n
* so d[n] == 0 and we want to keep A as it is.
* If d0 >= N then d >= (2^biL)^n, and d <= (2^biL)^n + N < 2 * (2^biL)^n
* so d[n] == 1 and we want to set A to the result of the subtraction
* which is d - (2^biL)^n, i.e. the n least significant limbs of d.
* This exactly corresponds to a conditional assignment. */
for (i = 0; i < n; ++i) {
Ap[i] = Select(d[i], Ap[i], -d[n]);
}
}
/*
* Montgomery reduction: A = A * R^-1 mod N
*
* See mpi_montmul() regarding constraints and guarantees on the parameters.
*/
static void mpi_montred( mbedtls_mpi *A, const mbedtls_mpi *N,
mbedtls_mpi_uint mm, const mbedtls_mpi *T )
{
mbedtls_mpi_uint z = 1;
mbedtls_mpi U;
U.n = U.s = (int) z;
U.p = &z;
mpi_montmul( A, &U, N, mm, T );
}
/**
* \brief Perform a sliding-window exponentiation: X = A^E mod N
*
* \param X The destination MPI. This must point to an initialized MPI.
* \param A The base of the exponentiation.
* This must point to an initialized MPI.
* \param E The exponent MPI. This must point to an initialized MPI.
* \param N The base for the modular reduction. This must point to an
* initialized MPI.
* \param _RR A helper MPI depending solely on \p N which can be used to
* speed-up multiple modular exponentiations for the same value
* of \p N. This may be \c NULL. If it is not \c NULL, it must
* point to an initialized MPI. If it hasn't been used after
* the call to mbedtls_mpi_init(), this function will compute
* the helper value and store it in \p _RR for reuse on
* subsequent calls to this function. Otherwise, the function
* will assume that \p _RR holds the helper value set by a
* previous call to mbedtls_mpi_exp_mod(), and reuse it.
*
* \return \c 0 if successful.
* \return #MBEDTLS_ERR_MPI_ALLOC_FAILED if a memory allocation failed.
* \return #MBEDTLS_ERR_MPI_BAD_INPUT_DATA if \c N is negative or
* even, or if \c E is negative.
* \return Another negative error code on different kinds of failures.
*
*/
int mbedtls_mpi_exp_mod( mbedtls_mpi *X, const mbedtls_mpi *A,
const mbedtls_mpi *E, const mbedtls_mpi *N,
mbedtls_mpi *_RR )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t wbits, wsize, one = 1;
size_t i, j, nblimbs;
size_t bufsize, nbits;
mbedtls_mpi_uint ei, mm, state;
mbedtls_mpi RR, T, W[ 1 << MBEDTLS_MPI_WINDOW_SIZE ], Apos;
int neg;
MPI_VALIDATE_RET( X );
MPI_VALIDATE_RET( A );
MPI_VALIDATE_RET( E );
MPI_VALIDATE_RET( N );
if( mbedtls_mpi_cmp_int( N, 0 ) <= 0 || ( N->p[0] & 1 ) == 0 )
return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
if( mbedtls_mpi_cmp_int( E, 0 ) < 0 )
return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
if( mbedtls_mpi_bitlen( E ) > MBEDTLS_MPI_MAX_BITS ||
mbedtls_mpi_bitlen( N ) > MBEDTLS_MPI_MAX_BITS )
return ( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
/*
* Init temps and window size
*/
mpi_montg_init( &mm, N );
mbedtls_mpi_init( &RR ); mbedtls_mpi_init( &T );
mbedtls_mpi_init( &Apos );
mbedtls_platform_zeroize( W, sizeof( W ) );
i = mbedtls_mpi_bitlen( E );
wsize = ( i > 671 ) ? 6 : ( i > 239 ) ? 5 :
( i > 79 ) ? 4 : ( i > 23 ) ? 3 : 1;
#if( MBEDTLS_MPI_WINDOW_SIZE < 6 )
if( wsize > MBEDTLS_MPI_WINDOW_SIZE )
wsize = MBEDTLS_MPI_WINDOW_SIZE;
#endif
j = N->n + 1;
MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, j ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_grow( &W[1], j ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_grow( &T, j * 2 ) );
/*
* Compensate for negative A (and correct at the end)
*/
neg = ( A->s == -1 );
if( neg )
{
MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &Apos, A ) );
Apos.s = 1;
A = &Apos;
}
/*
* If 1st call, pre-compute R^2 mod N
*/
if( _RR == NULL || _RR->p == NULL )
{
MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &RR, 1 ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( &RR, N->n * 2 * biL ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &RR, &RR, N ) );
if( _RR )
memcpy( _RR, &RR, sizeof( mbedtls_mpi ) );
}
else
memcpy( &RR, _RR, sizeof( mbedtls_mpi ) );
/*
* W[1] = A * R^2 * R^-1 mod N = A * R mod N
*/
if( mbedtls_mpi_cmp_mpi( A, N ) >= 0 )
MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &W[1], A, N ) );
else
MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &W[1], A ) );
mpi_montmul( &W[1], &RR, N, mm, &T );
/*
* X = R^2 * R^-1 mod N = R mod N
*/
MBEDTLS_MPI_CHK( mbedtls_mpi_copy( X, &RR ) );
mpi_montred( X, N, mm, &T );
if( wsize > 1 )
{
/*
* W[1 << (wsize - 1)] = W[1] ^ (wsize - 1)
*/
j = one << ( wsize - 1 );
MBEDTLS_MPI_CHK( mbedtls_mpi_grow( &W[j], N->n + 1 ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &W[j], &W[1] ) );
for( i = 0; i < wsize - 1; i++ )
mpi_montmul( &W[j], &W[j], N, mm, &T );
/*
* W[i] = W[i - 1] * W[1]
*/
for( i = j + 1; i < ( one << wsize ); i++ )
{
MBEDTLS_MPI_CHK( mbedtls_mpi_grow( &W[i], N->n + 1 ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &W[i], &W[i - 1] ) );
mpi_montmul( &W[i], &W[1], N, mm, &T );
}
}
nblimbs = E->n;
bufsize = 0;
nbits = 0;
wbits = 0;
state = 0;
while( 1 )
{
if( bufsize == 0 )
{
if( nblimbs == 0 )
break;
nblimbs--;
bufsize = sizeof( mbedtls_mpi_uint ) << 3;
}
bufsize--;
ei = (E->p[nblimbs] >> bufsize) & 1;
/*
* skip leading 0s
*/
if( ei == 0 && state == 0 )
continue;
if( ei == 0 && state == 1 )
{
/*
* out of window, square X
*/
mpi_montmul( X, X, N, mm, &T );
continue;
}
/*
* add ei to current window
*/
state = 2;
nbits++;
wbits |= ( ei << ( wsize - nbits ) );
if( nbits == wsize )
{
/*
* X = X^wsize R^-1 mod N
*/
for( i = 0; i < wsize; i++ )
mpi_montmul( X, X, N, mm, &T );
/*
* X = X * W[wbits] R^-1 mod N
*/
mpi_montmul( X, &W[wbits], N, mm, &T );
state--;
nbits = 0;
wbits = 0;
}
}
/*
* process the remaining bits
*/
for( i = 0; i < nbits; i++ )
{
mpi_montmul( X, X, N, mm, &T );
wbits <<= 1;
if( ( wbits & ( one << wsize ) ) != 0 )
mpi_montmul( X, &W[1], N, mm, &T );
}
/*
* X = A^E * R * R^-1 mod N = A^E mod N
*/
mpi_montred( X, N, mm, &T );
if( neg && E->n != 0 && ( E->p[0] & 1 ) != 0 )
{
X->s = -1;
MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( X, N, X ) );
}
cleanup:
for( i = ( one << ( wsize - 1 ) ); i < ( one << wsize ); i++ )
mbedtls_mpi_free( &W[i] );
mbedtls_mpi_free( &W[1] ); mbedtls_mpi_free( &T ); mbedtls_mpi_free( &Apos );
if( _RR == NULL || _RR->p == NULL )
mbedtls_mpi_free( &RR );
return( ret );
}
/**
* \brief Compute the greatest common divisor: G = gcd(A, B)
*
* \param G The destination MPI. This must point to an initialized MPI.
* \param A The first operand. This must point to an initialized MPI.
* \param B The second operand. This must point to an initialized MPI.
*
* \return \c 0 if successful.
* \return #MBEDTLS_ERR_MPI_ALLOC_FAILED if a memory allocation failed.
* \return Another negative error code on different kinds of failure.
*/
int mbedtls_mpi_gcd( mbedtls_mpi *G, const mbedtls_mpi *A, const mbedtls_mpi *B )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
mbedtls_mpi TA, TB;
size_t lz, lzt, i, j;
MPI_VALIDATE_RET( G );
MPI_VALIDATE_RET( A );
MPI_VALIDATE_RET( B );
mbedtls_mpi_init( &TA ); mbedtls_mpi_init( &TB );
MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TA, A ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TB, B ) );
lz = mbedtls_mpi_lsb( &TA );
lzt = mbedtls_mpi_lsb( &TB );
if( lzt < lz )
lz = lzt;
MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &TA, lz ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &TB, lz ) );
TA.s = TB.s = 1;
while( !mbedtls_mpi_is_zero( &TA ) )
{
MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &TA, mbedtls_mpi_lsb( &TA ) ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &TB, mbedtls_mpi_lsb( &TB ) ) );
if( mpi_cmp_abs( &TA, &TB, &i, &j ) >= 0 )
{
MBEDTLS_MPI_CHK( mpi_sub_abs( &TA, &TA, &TB, j ) );
ShiftRight( TA.p, TA.n, 1 );
}
else
{
MBEDTLS_MPI_CHK( mpi_sub_abs( &TB, &TB, &TA, i ) );
ShiftRight( TB.p, TB.n, 1 );
}
}
MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( &TB, lz ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_copy( G, &TB ) );
cleanup:
mbedtls_mpi_free( &TA ); mbedtls_mpi_free( &TB );
return( ret );
}
/**
* \brief Fill an MPI with a number of random bytes.
*
* Use a temporary bytes representation to make sure the result is the
* same regardless of the platform endianness (useful when f_rng is
* actually deterministic, eg for tests).
*
* \param X The destination MPI. This must point to an initialized MPI.
* \param size The number of random bytes to generate.
* \param f_rng The RNG function to use. This must not be \c NULL.
* \param p_rng The RNG parameter to be passed to \p f_rng. This may be
* \c NULL if \p f_rng doesn't need a context argument.
*
* \return \c 0 if successful.
* \return #MBEDTLS_ERR_MPI_ALLOC_FAILED if a memory allocation failed.
* \return Another negative error code on failure.
*
* \note The bytes obtained from the RNG are interpreted
* as a big-endian representation of an MPI; this can
* be relevant in applications like deterministic ECDSA.
*/
int mbedtls_mpi_fill_random( mbedtls_mpi *X, size_t size,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t const limbs = CHARS_TO_LIMBS( size );
size_t const overhead = ( limbs * ciL ) - size;
unsigned char *Xp;
MPI_VALIDATE_RET( X );
MPI_VALIDATE_RET( f_rng );
MBEDTLS_MPI_CHK(mbedtls_mpi_resize( X, limbs ));
MBEDTLS_MPI_CHK( mbedtls_mpi_lset( X, 0 ) );
Xp = (unsigned char*) X->p;
MBEDTLS_MPI_CHK( f_rng( p_rng, Xp + overhead, size ) );
mpi_bigendian_to_host( X->p, limbs );
cleanup:
return( ret );
}
/**
* \brief Compute the modular inverse: X = A^-1 mod N
*
* \param X The destination MPI. This must point to an initialized MPI.
* \param A The MPI to calculate the modular inverse of. This must point
* to an initialized MPI.
* \param N The base of the modular inversion. This must point to an
* initialized MPI.
*
* \return \c 0 if successful.
* \return #MBEDTLS_ERR_MPI_ALLOC_FAILED if a memory allocation failed.
* \return #MBEDTLS_ERR_MPI_BAD_INPUT_DATA if \p N is less than
* or equal to one.
* \return #MBEDTLS_ERR_MPI_NOT_ACCEPTABLE if \p has no modular inverse
* with respect to \p N.
*/
int mbedtls_mpi_inv_mod( mbedtls_mpi *X, const mbedtls_mpi *A, const mbedtls_mpi *N )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
mbedtls_mpi G, TA, TU, U1, U2, TB, TV, V1, V2;
MPI_VALIDATE_RET( X );
MPI_VALIDATE_RET( A );
MPI_VALIDATE_RET( N );
if( mbedtls_mpi_cmp_int( N, 1 ) <= 0 )
return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
mbedtls_mpi_init( &TA ); mbedtls_mpi_init( &TU ); mbedtls_mpi_init( &U1 ); mbedtls_mpi_init( &U2 );
mbedtls_mpi_init( &G ); mbedtls_mpi_init( &TB ); mbedtls_mpi_init( &TV );
mbedtls_mpi_init( &V1 ); mbedtls_mpi_init( &V2 );
MBEDTLS_MPI_CHK( mbedtls_mpi_gcd( &G, A, N ) );
if( mbedtls_mpi_cmp_int( &G, 1 ) != 0 )
{
ret = MBEDTLS_ERR_MPI_NOT_ACCEPTABLE;
goto cleanup;
}
MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &TA, A, N ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TU, &TA ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TB, N ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TV, N ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &U1, 1 ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &U2, 0 ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &V1, 0 ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &V2, 1 ) );
do
{
while( ( TU.p[0] & 1 ) == 0 )
{
ShiftRight( TU.p, TU.n, 1 );
if( ( U1.p[0] & 1 ) != 0 || ( U2.p[0] & 1 ) != 0 )
{
MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &U1, &U1, &TB ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &U2, &U2, &TA ) );
}
ShiftRight( U1.p, U1.n, 1 );
ShiftRight( U2.p, U2.n, 1 );
}
while( ( TV.p[0] & 1 ) == 0 )
{
ShiftRight( TV.p, TV.n, 1 );
if( ( V1.p[0] & 1 ) != 0 || ( V2.p[0] & 1 ) != 0 )
{
MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &V1, &V1, &TB ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &V2, &V2, &TA ) );
}
ShiftRight( V1.p, V1.n, 1 );
ShiftRight( V2.p, V2.n, 1 );
}
if( mbedtls_mpi_cmp_mpi( &TU, &TV ) >= 0 )
{
MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &TU, &TU, &TV ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &U1, &U1, &V1 ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &U2, &U2, &V2 ) );
}
else
{
MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &TV, &TV, &TU ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &V1, &V1, &U1 ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &V2, &V2, &U2 ) );
}
}
while( !mbedtls_mpi_is_zero(&TU) );
while( mbedtls_mpi_cmp_int( &V1, 0 ) < 0 )
MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &V1, &V1, N ) );
while( mbedtls_mpi_cmp_mpi( &V1, N ) >= 0 )
MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &V1, &V1, N ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_copy( X, &V1 ) );
cleanup:
mbedtls_mpi_free( &TA ); mbedtls_mpi_free( &TU ); mbedtls_mpi_free( &U1 ); mbedtls_mpi_free( &U2 );
mbedtls_mpi_free( &G ); mbedtls_mpi_free( &TB ); mbedtls_mpi_free( &TV );
mbedtls_mpi_free( &V1 ); mbedtls_mpi_free( &V2 );
return( ret );
}
#if defined(MBEDTLS_GENPRIME)
static const short small_prime[] =
{
3, 5, 7, 11, 13, 17, 19, 23,
29, 31, 37, 41, 43, 47, 53, 59,
61, 67, 71, 73, 79, 83, 89, 97,
101, 103, 107, 109, 113, 127, 131, 137,
139, 149, 151, 157, 163, 167, 173, 179,
181, 191, 193, 197, 199, 211, 223, 227,
229, 233, 239, 241, 251, 257, 263, 269,
271, 277, 281, 283, 293, 307, 311, 313,
317, 331, 337, 347, 349, 353, 359, 367,
373, 379, 383, 389, 397, 401, 409, 419,
421, 431, 433, 439, 443, 449, 457, 461,
463, 467, 479, 487, 491, 499, 503, 509,
521, 523, 541, 547, 557, 563, 569, 571,
577, 587, 593, 599, 601, 607, 613, 617,
619, 631, 641, 643, 647, 653, 659, 661,
673, 677, 683, 691, 701, 709, 719, 727,
733, 739, 743, 751, 757, 761, 769, 773,
787, 797, 809, 811, 821, 823, 827, 829,
839, 853, 857, 859, 863, 877, 881, 883,
887, 907, 911, 919, 929, 937, 941, 947,
953, 967, 971, 977, 983, 991, 997, -103
};
/*
* Small divisors test (X must be positive)
*
* Return values:
* 0: no small factor (possible prime, more tests needed)
* 1: certain prime
* MBEDTLS_ERR_MPI_NOT_ACCEPTABLE: certain non-prime
* other negative: error
*/
static int mpi_check_small_factors( const mbedtls_mpi *X )
{
int ret = 0;
size_t i;
mbedtls_mpi_uint r;
if( ( X->p[0] & 1 ) == 0 )
return( MBEDTLS_ERR_MPI_NOT_ACCEPTABLE );
for( i = 0; small_prime[i] > 0; i++ )
{
if( mbedtls_mpi_cmp_int( X, small_prime[i] ) <= 0 )
return( 1 );
MBEDTLS_MPI_CHK( mbedtls_mpi_mod_int( &r, X, small_prime[i] ) );
if( r == 0 )
return( MBEDTLS_ERR_MPI_NOT_ACCEPTABLE );
}
cleanup:
return( ret );
}
/*
* Miller-Rabin pseudo-primality test (HAC 4.24)
*/
static int mpi_miller_rabin( const mbedtls_mpi *X, size_t rounds,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
int ret, count;
size_t i, j, k, s;
mbedtls_mpi W, R, T, A, RR;
MPI_VALIDATE_RET( X );
MPI_VALIDATE_RET( f_rng );
mbedtls_mpi_init( &W ); mbedtls_mpi_init( &R );
mbedtls_mpi_init( &T ); mbedtls_mpi_init( &A );
mbedtls_mpi_init( &RR );
/*
* W = |X| - 1
* R = W >> lsb( W )
*/
MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( &W, X, 1 ) );
s = mbedtls_mpi_lsb( &W );
MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &R, &W ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &R, s ) );
for( i = 0; i < rounds; i++ )
{
/*
* pick a random A, 1 < A < |X| - 1
*/
count = 0;
do {
MBEDTLS_MPI_CHK( mbedtls_mpi_fill_random( &A, X->n * ciL, f_rng, p_rng ) );
j = mbedtls_mpi_bitlen( &A );
k = mbedtls_mpi_bitlen( &W );
if (j > k) {
A.p[A.n - 1] &= ( (mbedtls_mpi_uint) 1 << ( k - ( A.n - 1 ) * biL - 1 ) ) - 1;
}
if (count++ > 30) {
ret = MBEDTLS_ERR_MPI_NOT_ACCEPTABLE;
goto cleanup;
}
} while ( mbedtls_mpi_cmp_mpi( &A, &W ) >= 0 ||
mbedtls_mpi_cmp_int( &A, 1 ) <= 0 );
/*
* A = A^R mod |X|
*/
MBEDTLS_MPI_CHK( mbedtls_mpi_exp_mod( &A, &A, &R, X, &RR ) );
if( mbedtls_mpi_cmp_mpi( &A, &W ) == 0 ||
mbedtls_mpi_cmp_int( &A, 1 ) == 0 )
continue;
j = 1;
while( j < s && mbedtls_mpi_cmp_mpi( &A, &W ) != 0 )
{
/*
* A = A * A mod |X|
*/
MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T, &A, &A ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &A, &T, X ) );
if( mbedtls_mpi_cmp_int( &A, 1 ) == 0 )
break;
j++;
}
/*
* not prime if A != |X| - 1 or A == 1
*/
if( mbedtls_mpi_cmp_mpi( &A, &W ) != 0 ||
mbedtls_mpi_cmp_int( &A, 1 ) == 0 )
{
ret = MBEDTLS_ERR_MPI_NOT_ACCEPTABLE;
break;
}
}
cleanup:
mbedtls_mpi_free( &W ); mbedtls_mpi_free( &R );
mbedtls_mpi_free( &T ); mbedtls_mpi_free( &A );
mbedtls_mpi_free( &RR );
return( ret );
}
/**
* \brief Miller-Rabin primality test.
*
* \warning If \p X is potentially generated by an adversary, for example
* when validating cryptographic parameters that you didn't
* generate yourself and that are supposed to be prime, then
* \p rounds should be at least the half of the security
* strength of the cryptographic algorithm. On the other hand,
* if \p X is chosen uniformly or non-adversially (as is the
* case when mbedtls_mpi_gen_prime calls this function), then
* \p rounds can be much lower.
*
* \param X The MPI to check for primality.
* This must point to an initialized MPI.
* \param rounds The number of bases to perform the Miller-Rabin primality
* test for. The probability of returning 0 on a composite is
* at most 2<sup>-2*\p rounds</sup>.
* \param f_rng The RNG function to use. This must not be \c NULL.
* \param p_rng The RNG parameter to be passed to \p f_rng.
* This may be \c NULL if \p f_rng doesn't use
* a context parameter.
*
* \return \c 0 if successful, i.e. \p X is probably prime.
* \return #MBEDTLS_ERR_MPI_ALLOC_FAILED if a memory allocation failed.
* \return #MBEDTLS_ERR_MPI_NOT_ACCEPTABLE if \p X is not prime.
* \return Another negative error code on other kinds of failure.
*/
int mbedtls_mpi_is_prime_ext( const mbedtls_mpi *X, int rounds,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
mbedtls_mpi XX;
MPI_VALIDATE_RET( X );
MPI_VALIDATE_RET( f_rng );
XX.s = 1;
XX.n = X->n;
XX.p = X->p;
if( mbedtls_mpi_cmp_int( &XX, 0 ) == 0 ||
mbedtls_mpi_cmp_int( &XX, 1 ) == 0 )
return( MBEDTLS_ERR_MPI_NOT_ACCEPTABLE );
if( mbedtls_mpi_cmp_int( &XX, 2 ) == 0 )
return( 0 );
if( ( ret = mpi_check_small_factors( &XX ) ) != 0 )
{
if( ret == 1 )
return( 0 );
return( ret );
}
return( mpi_miller_rabin( &XX, rounds, f_rng, p_rng ) );
}
/**
* \brief Generate a prime number.
*
* To generate an RSA key in a way recommended by FIPS
* 186-4, both primes must be either 1024 bits or 1536
* bits long, and flags must contain
* MBEDTLS_MPI_GEN_PRIME_FLAG_LOW_ERR.
*
* \param X The destination MPI to store the generated prime in.
* This must point to an initialized MPi.
* \param nbits The required size of the destination MPI in bits.
* This must be between \c 3 and #MBEDTLS_MPI_MAX_BITS.
* \param flags A mask of flags of type #mbedtls_mpi_gen_prime_flag_t.
* \param f_rng The RNG function to use. This must not be \c NULL.
* \param p_rng The RNG parameter to be passed to \p f_rng.
* This may be \c NULL if \p f_rng doesn't use
* a context parameter.
*
* \return \c 0 if successful, in which case \p X holds a
* probably prime number.
* \return #MBEDTLS_ERR_MPI_ALLOC_FAILED if a memory allocation failed.
* \return #MBEDTLS_ERR_MPI_BAD_INPUT_DATA if `nbits` is not between
* \c 3 and #MBEDTLS_MPI_MAX_BITS.
*/
int mbedtls_mpi_gen_prime( mbedtls_mpi *X, size_t nbits, int flags,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
int ret = MBEDTLS_ERR_MPI_NOT_ACCEPTABLE;
size_t k, n;
int rounds;
mbedtls_mpi_uint r;
mbedtls_mpi Y;
MPI_VALIDATE_RET( X );
MPI_VALIDATE_RET( f_rng );
if( nbits < 3 || nbits > MBEDTLS_MPI_MAX_BITS )
return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
mbedtls_mpi_init( &Y );
n = BITS_TO_LIMBS( nbits );
if( ( flags & MBEDTLS_MPI_GEN_PRIME_FLAG_LOW_ERR ) == 0 )
{
/*
* 2^-80 error probability, number of rounds chosen per HAC, table 4.4
*/
rounds = ( ( nbits >= 1300 ) ? 2 : ( nbits >= 850 ) ? 3 :
( nbits >= 650 ) ? 4 : ( nbits >= 350 ) ? 8 :
( nbits >= 250 ) ? 12 : ( nbits >= 150 ) ? 18 : 27 );
}
else
{
/*
* 2^-100 error probability, number of rounds computed based on HAC,
* fact 4.48
*/
rounds = ( ( nbits >= 1450 ) ? 4 : ( nbits >= 1150 ) ? 5 :
( nbits >= 1000 ) ? 6 : ( nbits >= 850 ) ? 7 :
( nbits >= 750 ) ? 8 : ( nbits >= 500 ) ? 13 :
( nbits >= 250 ) ? 28 : ( nbits >= 150 ) ? 40 : 51 );
}
while( 1 )
{
MBEDTLS_MPI_CHK( mbedtls_mpi_fill_random( X, n * ciL, f_rng, p_rng ) );
/* make sure generated number is at least (nbits-1)+0.5 bits (FIPS 186-4 §B.3.3 steps 4.4, 5.5) */
if( X->p[n-1] < 0xb504f333f9de6485ULL /* ceil(2^63.5) */ ) continue;
k = n * biL;
if( k > nbits ) MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( X, k - nbits ) );
X->p[0] |= 1;
if( ( flags & MBEDTLS_MPI_GEN_PRIME_FLAG_DH ) == 0 )
{
ret = mbedtls_mpi_is_prime_ext( X, rounds, f_rng, p_rng );
if( ret != MBEDTLS_ERR_MPI_NOT_ACCEPTABLE )
goto cleanup;
}
else
{
/*
* An necessary condition for Y and X = 2Y + 1 to be prime
* is X = 2 mod 3 (which is equivalent to Y = 2 mod 3).
* Make sure it is satisfied, while keeping X = 3 mod 4
*/
X->p[0] |= 2;
MBEDTLS_MPI_CHK( mbedtls_mpi_mod_int( &r, X, 3 ) );
if( r == 0 )
MBEDTLS_MPI_CHK( mbedtls_mpi_add_int( X, X, 8 ) );
else if( r == 1 )
MBEDTLS_MPI_CHK( mbedtls_mpi_add_int( X, X, 4 ) );
/* Set Y = (X-1) / 2, which is X / 2 because X is odd */
MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &Y, X ) );
ShiftRight( Y.p, Y.n, 1 );
while( 1 )
{
/*
* First, check small factors for X and Y
* before doing Miller-Rabin on any of them
*/
if( ( ret = mpi_check_small_factors( X ) ) == 0 &&
( ret = mpi_check_small_factors( &Y ) ) == 0 &&
( ret = mpi_miller_rabin( X, rounds, f_rng, p_rng ) )
== 0 &&
( ret = mpi_miller_rabin( &Y, rounds, f_rng, p_rng ) )
== 0 )
goto cleanup;
if( ret != MBEDTLS_ERR_MPI_NOT_ACCEPTABLE )
goto cleanup;
/*
* Next candidates. We want to preserve Y = (X-1) / 2 and
* Y = 1 mod 2 and Y = 2 mod 3 (eq X = 3 mod 4 and X = 2 mod 3)
* so up Y by 6 and X by 12.
*/
MBEDTLS_MPI_CHK( mbedtls_mpi_add_int( X, X, 12 ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_add_int( &Y, &Y, 6 ) );
}
}
}
cleanup:
mbedtls_mpi_free( &Y );
return( ret );
}
#endif /* MBEDTLS_GENPRIME */
#if defined(MBEDTLS_SELF_TEST)
#define GCD_PAIR_COUNT 3
static const int gcd_pairs[GCD_PAIR_COUNT][3] =
{
{ 693, 609, 21 },
{ 1764, 868, 28 },
{ 768454923, 542167814, 1 }
};
/**
* \brief Checkup routine
*
* \return 0 if successful, or 1 if the test failed
*/
int mbedtls_mpi_self_test( int verbose )
{
int ret, i;
mbedtls_mpi A, E, N, X, Y, U, V;
mbedtls_mpi_init( &A ); mbedtls_mpi_init( &E ); mbedtls_mpi_init( &N ); mbedtls_mpi_init( &X );
mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &U ); mbedtls_mpi_init( &V );
MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &A, 16,
"EFE021C2645FD1DC586E69184AF4A31E" \
"D5F53E93B5F123FA41680867BA110131" \
"944FE7952E2517337780CB0DB80E61AA" \
"E7C8DDC6C5C6AADEB34EB38A2F40D5E6" ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &E, 16,
"B2E7EFD37075B9F03FF989C7C5051C20" \
"34D2A323810251127E7BF8625A4F49A5" \
"F3E27F4DA8BD59C47D6DAABA4C8127BD" \
"5B5C25763222FEFCCFC38B832366C29E" ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &N, 16,
"0066A198186C18C10B2F5ED9B522752A" \
"9830B69916E535C8F047518A889A43A5" \
"94B6BED27A168D31D4A52F88925AA8F5" ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &X, &A, &N ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &U, 16,
"602AB7ECA597A3D6B56FF9829A5E8B85" \
"9E857EA95A03512E2BAE7391688D264A" \
"A5663B0341DB9CCFD2C4C5F421FEC814" \
"8001B72E848A38CAE1C65F78E56ABDEF" \
"E12D3C039B8A02D6BE593F0BBBDA56F1" \
"ECF677152EF804370C1A305CAF3B5BF1" \
"30879B56C61DE584A0F53A2447A51E" ) );
if( verbose != 0 )
mbedtls_printf( " MPI test #1 (mul_mpi): " );
if( mbedtls_mpi_cmp_mpi( &X, &U ) != 0 )
{
if( verbose != 0 )
mbedtls_printf( "failed\n" );
ret = 1;
goto cleanup;
}
if( verbose != 0 )
mbedtls_printf( "passed\n" );
MBEDTLS_MPI_CHK( mbedtls_mpi_div_mpi( &X, &Y, &A, &N ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &U, 16,
"256567336059E52CAE22925474705F39A94" ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &V, 16,
"6613F26162223DF488E9CD48CC132C7A" \
"0AC93C701B001B092E4E5B9F73BCD27B" \
"9EE50D0657C77F374E903CDFA4C642" ) );
if( verbose != 0 )
mbedtls_printf( " MPI test #2 (div_mpi): " );
if( mbedtls_mpi_cmp_mpi( &X, &U ) != 0 ||
mbedtls_mpi_cmp_mpi( &Y, &V ) != 0 )
{
if( verbose != 0 )
mbedtls_printf( "failed\n" );
ret = 1;
goto cleanup;
}
if( verbose != 0 )
mbedtls_printf( "passed\n" );
MBEDTLS_MPI_CHK( mbedtls_mpi_exp_mod( &X, &A, &E, &N, NULL ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &U, 16,
"36E139AEA55215609D2816998ED020BB" \
"BD96C37890F65171D948E9BC7CBAA4D9" \
"325D24D6A3C12710F10A09FA08AB87" ) );
if( verbose != 0 )
mbedtls_printf( " MPI test #3 (exp_mod): " );
if( mbedtls_mpi_cmp_mpi( &X, &U ) != 0 )
{
if( verbose != 0 )
mbedtls_printf( "failed\n" );
ret = 1;
goto cleanup;
}
if( verbose != 0 )
mbedtls_printf( "passed\n" );
MBEDTLS_MPI_CHK( mbedtls_mpi_inv_mod( &X, &A, &N ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &U, 16,
"003A0AAEDD7E784FC07D8F9EC6E3BFD5" \
"C3DBA76456363A10869622EAC2DD84EC" \
"C5B8A74DAC4D09E03B5E0BE779F2DF61" ) );
if( verbose != 0 )
mbedtls_printf( " MPI test #4 (inv_mod): " );
if( mbedtls_mpi_cmp_mpi( &X, &U ) != 0 )
{
if( verbose != 0 )
mbedtls_printf( "failed\n" );
ret = 1;
goto cleanup;
}
if( verbose != 0 )
mbedtls_printf( "passed\n" );
if( verbose != 0 )
mbedtls_printf( " MPI test #5 (simple gcd): " );
for( i = 0; i < GCD_PAIR_COUNT; i++ )
{
MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &X, gcd_pairs[i][0] ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &Y, gcd_pairs[i][1] ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_gcd( &A, &X, &Y ) );
if( mbedtls_mpi_cmp_int( &A, gcd_pairs[i][2] ) != 0 )
{
if( verbose != 0 )
mbedtls_printf( "failed at %d\n", i );
ret = 1;
goto cleanup;
}
}
if( verbose != 0 )
mbedtls_printf( "passed\n" );
cleanup:
if( ret != 0 && verbose != 0 )
mbedtls_printf( "Unexpected error, return code = %08X\n", (unsigned int) ret );
mbedtls_mpi_free( &A ); mbedtls_mpi_free( &E ); mbedtls_mpi_free( &N ); mbedtls_mpi_free( &X );
mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &U ); mbedtls_mpi_free( &V );
if( verbose != 0 )
mbedtls_printf( "\n" );
return( ret );
}
#endif /* MBEDTLS_SELF_TEST */
#endif /* MBEDTLS_BIGNUM_C */
| 97,361 | 2,836 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/error.h | #ifndef MBEDTLS_ERROR_H
#define MBEDTLS_ERROR_H
#include "third_party/mbedtls/config.h"
/* clang-format off */
/**
* Error code layout.
*
* Currently we try to keep all error codes within the negative space of 16
* bits signed integers to support all platforms (-0x0001 - -0x7FFF). In
* addition we'd like to give two layers of information on the error if
* possible.
*
* For that purpose the error codes are segmented in the following manner:
*
* 16 bit error code bit-segmentation
*
* 1 bit - Unused (sign bit)
* 3 bits - High level module ID
* 5 bits - Module-dependent error code
* 7 bits - Low level module errors
*
* For historical reasons, low-level error codes are divided in even and odd,
* even codes were assigned first, and -1 is reserved for other errors.
*
* Low-level module errors (0x0002-0x007E, 0x0001-0x007F)
*
* Module Nr Codes assigned
* ERROR 2 0x006E 0x0001
* MPI 7 0x0002-0x0010
* GCM 3 0x0012-0x0014 0x0013-0x0013
* BLOWFISH 3 0x0016-0x0018 0x0017-0x0017
* THREADING 3 0x001A-0x001E
* AES 5 0x0020-0x0022 0x0021-0x0025
* CAMELLIA 3 0x0024-0x0026 0x0027-0x0027
* XTEA 2 0x0028-0x0028 0x0029-0x0029
* BASE64 2 0x002A-0x002C
* OID 1 0x002E-0x002E 0x000B-0x000B
* PADLOCK 1 0x0030-0x0030
* DES 2 0x0032-0x0032 0x0033-0x0033
* CTR_DBRG 4 0x0034-0x003A
* ENTROPY 3 0x003C-0x0040 0x003D-0x003F
* NET 13 0x0042-0x0052 0x0043-0x0049
* ARIA 4 0x0058-0x005E
* ASN1 7 0x0060-0x006C
* CMAC 1 0x007A-0x007A
* PBKDF2 1 0x007C-0x007C
* HMAC_DRBG 4 0x0003-0x0009
* CCM 3 0x000D-0x0011
* ARC4 1 0x0019-0x0019
* MD2 1 0x002B-0x002B
* MD4 1 0x002D-0x002D
* MD5 1 0x002F-0x002F
* RIPEMD160 1 0x0031-0x0031
* SHA1 1 0x0035-0x0035 0x0073-0x0073
* SHA256 1 0x0037-0x0037 0x0074-0x0074
* SHA512 1 0x0039-0x0039 0x0075-0x0075
* CHACHA20 3 0x0051-0x0055
* POLY1305 3 0x0057-0x005B
* CHACHAPOLY 2 0x0054-0x0056
* PLATFORM 2 0x0070-0x0072
*
* High-level module nr (3 bits - 0x0...-0x7...)
* Name ID Nr of Errors
* PEM 1 9
* PKCS#12 1 4 (Started from top)
* X509 2 20
* PKCS5 2 4 (Started from top)
* DHM 3 11
* PK 3 15 (Started from top)
* RSA 4 11
* ECP 4 10 (Started from top)
* MD 5 5
* HKDF 5 1 (Started from top)
* SSL 5 2 (Started from 0x5F00)
* CIPHER 6 8 (Started from 0x6080)
* SSL 6 24 (Started from top, plus 0x6000)
* SSL 7 32
*
* Module dependent error code (5 bits 0x.00.-0x.F8.)
*/
#ifdef __cplusplus
extern "C" {
#endif
#define MBEDTLS_ERR_ERROR_GENERIC_ERROR -0x0001 /*< Generic error */
#define MBEDTLS_ERR_THIS_CORRUPTION -0x006E /*< This is a bug in the library */
/**
* \brief Translate a mbed TLS error code into a string representation,
* Result is truncated if necessary and always includes a terminating
* null byte.
*
* \param errnum error code
* \param buffer buffer to place representation in
* \param buflen length of the buffer
*/
void mbedtls_strerror( int errnum, char *buffer, size_t buflen );
/**
* \brief Translate the high-level part of an Mbed TLS error code into a string
* representation.
*
* This function returns a const pointer to an un-modifiable string. The caller
* must not try to modify the string. It is intended to be used mostly for
* logging purposes.
*
* \param error_code error code
*
* \return The string representation of the error code, or \c NULL if the error
* code is unknown.
*/
const char * mbedtls_high_level_strerr( int error_code );
/**
* \brief Translate the low-level part of an Mbed TLS error code into a string
* representation.
*
* This function returns a const pointer to an un-modifiable string. The caller
* must not try to modify the string. It is intended to be used mostly for
* logging purposes.
*
* \param error_code error code
*
* \return The string representation of the error code, or \c NULL if the error
* code is unknown.
*/
const char * mbedtls_low_level_strerr( int error_code );
#ifdef __cplusplus
}
#endif
#endif /* error.h */
| 4,471 | 136 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/ssl_cookie.h | #ifndef MBEDTLS_SSL_COOKIE_H
#define MBEDTLS_SSL_COOKIE_H
#include "third_party/mbedtls/config.h"
#include "third_party/mbedtls/ssl.h"
/* clang-format off */
/**
* \name SECTION: Module settings
*
* The configuration options you can set for this module are in this section.
* Either change them in config.h or define them on the compiler command line.
* \{
*/
#ifndef MBEDTLS_SSL_COOKIE_TIMEOUT
#define MBEDTLS_SSL_COOKIE_TIMEOUT 60 /*< Default expiration delay of DTLS cookies, in seconds if HAVE_TIME, or in number of cookies issued */
#endif
/* \} name SECTION: Module settings */
#ifdef __cplusplus
extern "C" {
#endif
/**
* \brief Context for the default cookie functions.
*/
typedef struct mbedtls_ssl_cookie_ctx
{
mbedtls_md_context_t hmac_ctx; /*!< context for the HMAC portion */
#if !defined(MBEDTLS_HAVE_TIME)
unsigned long serial; /*!< serial number for expiration */
#endif
unsigned long timeout; /*!< timeout delay, in seconds if HAVE_TIME,
or in number of tickets issued */
} mbedtls_ssl_cookie_ctx;
/**
* \brief Initialize cookie context
*/
void mbedtls_ssl_cookie_init( mbedtls_ssl_cookie_ctx *ctx );
/**
* \brief Setup cookie context (generate keys)
*/
int mbedtls_ssl_cookie_setup( mbedtls_ssl_cookie_ctx *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng );
/**
* \brief Set expiration delay for cookies
* (Default MBEDTLS_SSL_COOKIE_TIMEOUT)
*
* \param ctx Cookie contex
* \param delay Delay, in seconds if HAVE_TIME, or in number of cookies
* issued in the meantime.
* 0 to disable expiration (NOT recommended)
*/
void mbedtls_ssl_cookie_set_timeout( mbedtls_ssl_cookie_ctx *ctx, unsigned long delay );
/**
* \brief Free cookie context
*/
void mbedtls_ssl_cookie_free( mbedtls_ssl_cookie_ctx *ctx );
/**
* \brief Generate cookie, see \c mbedtls_ssl_cookie_write_t
*/
mbedtls_ssl_cookie_write_t mbedtls_ssl_cookie_write;
/**
* \brief Verify cookie, see \c mbedtls_ssl_cookie_write_t
*/
mbedtls_ssl_cookie_check_t mbedtls_ssl_cookie_check;
#ifdef __cplusplus
}
#endif
#endif /* ssl_cookie.h */
| 2,302 | 80 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/ssl_tls13_keys.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:4;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright The Mbed TLS Contributors â
â â
â Licensed under the Apache License, Version 2.0 (the "License"); â
â you may not use this file except in compliance with the License. â
â You may obtain a copy of the License at â
â â
â http://www.apache.org/licenses/LICENSE-2.0 â
â â
â Unless required by applicable law or agreed to in writing, software â
â distributed under the License is distributed on an "AS IS" BASIS, â
â WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. â
â See the License for the specific language governing permissions and â
â limitations under the License. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "third_party/mbedtls/common.h"
#include "third_party/mbedtls/hkdf.h"
#include "third_party/mbedtls/ssl_internal.h"
#include "third_party/mbedtls/ssl_tls13_keys.h"
asm(".ident\t\"\\n\\n\
Mbed TLS (Apache 2.0)\\n\
Copyright ARM Limited\\n\
Copyright Mbed TLS Contributors\"");
asm(".include \"libc/disclaimer.inc\"");
/* clang-format off */
/*
* TLS 1.3 key schedule
*
* Copyright The Mbed TLS Contributors
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 ( the "License" ); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#if defined(MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL)
#define MBEDTLS_SSL_TLS1_3_LABEL( name, string ) \
.name = string,
struct mbedtls_ssl_tls1_3_labels_struct const mbedtls_ssl_tls1_3_labels =
{
/* This seems to work in C, despite the string literal being one
* character too long due to the 0-termination. */
MBEDTLS_SSL_TLS1_3_LABEL_LIST
};
#undef MBEDTLS_SSL_TLS1_3_LABEL
/*
* This function creates a HkdfLabel structure used in the TLS 1.3 key schedule.
*
* The HkdfLabel is specified in RFC 8446 as follows:
*
* struct HkdfLabel {
* uint16 length; // Length of expanded key material
* opaque label<7..255>; // Always prefixed by "tls13 "
* opaque context<0..255>; // Usually a communication transcript hash
* };
*
* Parameters:
* - desired_length: Length of expanded key material
* Even though the standard allows expansion to up to
* 2**16 Bytes, TLS 1.3 never uses expansion to more than
* 255 Bytes, so we require `desired_length` to be at most
* 255. This allows us to save a few Bytes of code by
* hardcoding the writing of the high bytes.
* - (label, llen): label + label length, without "tls13 " prefix
* The label length MUST be less than or equal to
* MBEDTLS_SSL_TLS1_3_KEY_SCHEDULE_MAX_LABEL_LEN
* It is the caller's responsibility to ensure this.
* All (label, label length) pairs used in TLS 1.3
* can be obtained via MBEDTLS_SSL_TLS1_3_LBL_WITH_LEN().
* - (ctx, clen): context + context length
* The context length MUST be less than or equal to
* MBEDTLS_SSL_TLS1_3_KEY_SCHEDULE_MAX_CONTEXT_LEN
* It is the caller's responsibility to ensure this.
* - dst: Target buffer for HkdfLabel structure,
* This MUST be a writable buffer of size
* at least SSL_TLS1_3_KEY_SCHEDULE_MAX_HKDF_LABEL_LEN Bytes.
* - dlen: Pointer at which to store the actual length of
* the HkdfLabel structure on success.
*/
static const char tls1_3_label_prefix[6] = "tls13 ";
#define SSL_TLS1_3_KEY_SCHEDULE_HKDF_LABEL_LEN( label_len, context_len ) \
( 2 /* expansion length */ \
+ 1 /* label length */ \
+ label_len \
+ 1 /* context length */ \
+ context_len )
#define SSL_TLS1_3_KEY_SCHEDULE_MAX_HKDF_LABEL_LEN \
SSL_TLS1_3_KEY_SCHEDULE_HKDF_LABEL_LEN( \
sizeof(tls1_3_label_prefix) + \
MBEDTLS_SSL_TLS1_3_KEY_SCHEDULE_MAX_LABEL_LEN, \
MBEDTLS_SSL_TLS1_3_KEY_SCHEDULE_MAX_CONTEXT_LEN )
static void ssl_tls1_3_hkdf_encode_label(
size_t desired_length,
const unsigned char *label, size_t llen,
const unsigned char *ctx, size_t clen,
unsigned char *dst, size_t *dlen )
{
size_t total_label_len =
sizeof(tls1_3_label_prefix) + llen;
size_t total_hkdf_lbl_len =
SSL_TLS1_3_KEY_SCHEDULE_HKDF_LABEL_LEN( total_label_len, clen );
unsigned char *p = dst;
/* Add the size of the expanded key material.
* We're hardcoding the high byte to 0 here assuming that we never use
* TLS 1.3 HKDF key expansion to more than 255 Bytes. */
#if MBEDTLS_SSL_TLS1_3_KEY_SCHEDULE_MAX_EXPANSION_LEN > 255
#error "The implementation of ssl_tls1_3_hkdf_encode_label() is not fit for the \
value of MBEDTLS_SSL_TLS1_3_KEY_SCHEDULE_MAX_EXPANSION_LEN"
#endif
*p++ = 0;
*p++ = (unsigned char)( ( desired_length >> 0 ) & 0xFF );
/* Add label incl. prefix */
*p++ = (unsigned char)( total_label_len & 0xFF );
memcpy( p, tls1_3_label_prefix, sizeof(tls1_3_label_prefix) );
p += sizeof(tls1_3_label_prefix);
memcpy( p, label, llen );
p += llen;
/* Add context value */
*p++ = (unsigned char)( clen & 0xFF );
if( clen != 0 )
memcpy( p, ctx, clen );
/* Return total length to the caller. */
*dlen = total_hkdf_lbl_len;
}
/**
* \brief The \c HKDF-Expand-Label function from
* the TLS 1.3 standard RFC 8446.
*
* <tt>
* HKDF-Expand-Label( Secret, Label, Context, Length ) =
* HKDF-Expand( Secret, HkdfLabel, Length )
* </tt>
*
* \param hash_alg The identifier for the hash algorithm to use.
* \param secret The \c Secret argument to \c HKDF-Expand-Label.
* This must be a readable buffer of length \p slen Bytes.
* \param slen The length of \p secret in Bytes.
* \param label The \c Label argument to \c HKDF-Expand-Label.
* This must be a readable buffer of length \p llen Bytes.
* \param llen The length of \p label in Bytes.
* \param ctx The \c Context argument to \c HKDF-Expand-Label.
* This must be a readable buffer of length \p clen Bytes.
* \param clen The length of \p context in Bytes.
* \param buf The destination buffer to hold the expanded secret.
* This must be a writable buffer of length \p blen Bytes.
* \param blen The desired size of the expanded secret in Bytes.
*
* \returns \c 0 on success.
* \return A negative error code on failure.
*/
int mbedtls_ssl_tls1_3_hkdf_expand_label(
mbedtls_md_type_t hash_alg,
const unsigned char *secret, size_t slen,
const unsigned char *label, size_t llen,
const unsigned char *ctx, size_t clen,
unsigned char *buf, size_t blen )
{
const mbedtls_md_info_t *md;
unsigned char hkdf_label[ SSL_TLS1_3_KEY_SCHEDULE_MAX_HKDF_LABEL_LEN ];
size_t hkdf_label_len;
if( llen > MBEDTLS_SSL_TLS1_3_KEY_SCHEDULE_MAX_LABEL_LEN )
{
/* Should never happen since this is an internal
* function, and we know statically which labels
* are allowed. */
return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
if( clen > MBEDTLS_SSL_TLS1_3_KEY_SCHEDULE_MAX_CONTEXT_LEN )
{
/* Should not happen, as above. */
return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
if( blen > MBEDTLS_SSL_TLS1_3_KEY_SCHEDULE_MAX_EXPANSION_LEN )
{
/* Should not happen, as above. */
return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
md = mbedtls_md_info_from_type( hash_alg );
if( md == NULL )
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
ssl_tls1_3_hkdf_encode_label( blen,
label, llen,
ctx, clen,
hkdf_label,
&hkdf_label_len );
return( mbedtls_hkdf_expand( md,
secret, slen,
hkdf_label, hkdf_label_len,
buf, blen ) );
}
/**
* \brief This function is part of the TLS 1.3 key schedule.
* It extracts key and IV for the actual client/server traffic
* from the client/server traffic secrets.
*
* From RFC 8446:
*
* <tt>
* [sender]_write_key = HKDF-Expand-Label(Secret, "key", "", key_length)
* [sender]_write_iv = HKDF-Expand-Label(Secret, "iv", "", iv_length)*
* </tt>
*
* The traffic keying material is generated from the following inputs:
*
* - One secret value per sender.
* - A purpose value indicating the specific value being generated
* - The desired lengths of key and IV.
*
* The expansion itself is based on HKDF:
*
* [sender]_write_key = HKDF-Expand-Label( Secret, "key", "", key_length )
* [sender]_write_iv = HKDF-Expand-Label( Secret, "iv" , "", iv_length )
*
* [sender] denotes the sending side and the Secret value is provided
* by the function caller. Note that we generate server and client side
* keys in a single function call.
*
* \param hash_alg The identifier for the hash algorithm to be used
* for the HKDF-based expansion of the secret.
* \param client_secret The client traffic secret.
* This must be a readable buffer of size \p slen Bytes
* \param server_secret The server traffic secret.
* This must be a readable buffer of size \p slen Bytes
* \param slen Length of the secrets \p client_secret and
* \p server_secret in Bytes.
* \param key_len The desired length of the key to be extracted in Bytes.
* \param iv_len The desired length of the IV to be extracted in Bytes.
* \param keys The address of the structure holding the generated
* keys and IVs.
*
* \returns \c 0 on success.
* \returns A negative error code on failure.
*/
int mbedtls_ssl_tls1_3_make_traffic_keys(
mbedtls_md_type_t hash_alg,
const unsigned char *client_secret,
const unsigned char *server_secret,
size_t slen, size_t key_len, size_t iv_len,
mbedtls_ssl_key_set *keys )
{
int ret = 0;
ret = mbedtls_ssl_tls1_3_hkdf_expand_label( hash_alg,
client_secret, slen,
MBEDTLS_SSL_TLS1_3_LBL_WITH_LEN( key ),
NULL, 0,
keys->client_write_key, key_len );
if( ret != 0 )
return( ret );
ret = mbedtls_ssl_tls1_3_hkdf_expand_label( hash_alg,
server_secret, slen,
MBEDTLS_SSL_TLS1_3_LBL_WITH_LEN( key ),
NULL, 0,
keys->server_write_key, key_len );
if( ret != 0 )
return( ret );
ret = mbedtls_ssl_tls1_3_hkdf_expand_label( hash_alg,
client_secret, slen,
MBEDTLS_SSL_TLS1_3_LBL_WITH_LEN( iv ),
NULL, 0,
keys->client_write_iv, iv_len );
if( ret != 0 )
return( ret );
ret = mbedtls_ssl_tls1_3_hkdf_expand_label( hash_alg,
server_secret, slen,
MBEDTLS_SSL_TLS1_3_LBL_WITH_LEN( iv ),
NULL, 0,
keys->server_write_iv, iv_len );
if( ret != 0 )
return( ret );
keys->key_len = key_len;
keys->iv_len = iv_len;
return( 0 );
}
/**
* \brief The \c Derive-Secret function from the TLS 1.3 standard RFC 8446.
*
* <tt>
* Derive-Secret( Secret, Label, Messages ) =
* HKDF-Expand-Label( Secret, Label,
* Hash( Messages ),
* Hash.Length ) )
* </tt>
*
* \param hash_alg The identifier for the hash function used for the
* applications of HKDF.
* \param secret The \c Secret argument to the \c Derive-Secret function.
* This must be a readable buffer of length \p slen Bytes.
* \param slen The length of \p secret in Bytes.
* \param label The \c Label argument to the \c Derive-Secret function.
* This must be a readable buffer of length \p llen Bytes.
* \param llen The length of \p label in Bytes.
* \param ctx The hash of the \c Messages argument to the
* \c Derive-Secret function, or the \c Messages argument
* itself, depending on \p context_already_hashed.
* \param clen The length of \p hash.
* \param ctx_hashed This indicates whether the \p ctx contains the hash of
* the \c Messages argument in the application of the
* \c Derive-Secret function
* (value MBEDTLS_SSL_TLS1_3_CONTEXT_HASHED), or whether
* it is the content of \c Messages itself, in which case
* the function takes care of the hashing
* (value MBEDTLS_SSL_TLS1_3_CONTEXT_UNHASHED).
* \param dstbuf The target buffer to write the output of
* \c Derive-Secret to. This must be a writable buffer of
* size \p buflen Bytes.
* \param buflen The length of \p dstbuf in Bytes.
*
* \returns \c 0 on success.
* \returns A negative error code on failure.
*/
int mbedtls_ssl_tls1_3_derive_secret(
mbedtls_md_type_t hash_alg,
const unsigned char *secret, size_t slen,
const unsigned char *label, size_t llen,
const unsigned char *ctx, size_t clen,
int ctx_hashed,
unsigned char *dstbuf, size_t buflen )
{
int ret;
unsigned char hashed_context[ MBEDTLS_MD_MAX_SIZE ];
const mbedtls_md_info_t *md;
md = mbedtls_md_info_from_type( hash_alg );
if( md == NULL )
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
if( ctx_hashed == MBEDTLS_SSL_TLS1_3_CONTEXT_UNHASHED )
{
ret = mbedtls_md( md, ctx, clen, hashed_context );
if( ret != 0 )
return( ret );
clen = mbedtls_md_get_size( md );
}
else
{
if( clen > sizeof(hashed_context) )
{
/* This should never happen since this function is internal
* and the code sets `ctx_hashed` correctly.
* Let's double-check nonetheless to not run at the risk
* of getting a stack overflow. */
return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
memcpy( hashed_context, ctx, clen );
}
return( mbedtls_ssl_tls1_3_hkdf_expand_label( hash_alg,
secret, slen,
label, llen,
hashed_context, clen,
dstbuf, buflen ) );
}
/**
* \brief Compute the next secret in the TLS 1.3 key schedule
*
* The TLS 1.3 key schedule proceeds as follows to compute
* the three main secrets during the handshake: The early
* secret for early data, the handshake secret for all
* other encrypted handshake messages, and the master
* secret for all application traffic.
*
* <tt>
* 0
* |
* v
* PSK -> HKDF-Extract = Early Secret
* |
* v
* Derive-Secret( ., "derived", "" )
* |
* v
* (EC)DHE -> HKDF-Extract = Handshake Secret
* |
* v
* Derive-Secret( ., "derived", "" )
* |
* v
* 0 -> HKDF-Extract = Master Secret
* </tt>
*
* Each of the three secrets in turn is the basis for further
* key derivations, such as the derivation of traffic keys and IVs;
* see e.g. mbedtls_ssl_tls1_3_make_traffic_keys().
*
* This function implements one step in this evolution of secrets:
*
* <tt>
* old_secret
* |
* v
* Derive-Secret( ., "derived", "" )
* |
* v
* input -> HKDF-Extract = new_secret
* </tt>
*
* \param hash_alg The identifier for the hash function used for the
* applications of HKDF.
* \param secret_old The address of the buffer holding the old secret
* on function entry. If not \c NULL, this must be a
* readable buffer whose size matches the output size
* of the hash function represented by \p hash_alg.
* If \c NULL, an all \c 0 array will be used instead.
* \param input The address of the buffer holding the additional
* input for the key derivation (e.g., the PSK or the
* ephemeral (EC)DH secret). If not \c NULL, this must be
* a readable buffer whose size \p input_len Bytes.
* If \c NULL, an all \c 0 array will be used instead.
* \param input_len The length of \p input in Bytes.
* \param secret_new The address of the buffer holding the new secret
* on function exit. This must be a writable buffer
* whose size matches the output size of the hash
* function represented by \p hash_alg.
* This may be the same as \p secret_old.
*
* \returns \c 0 on success.
* \returns A negative error code on failure.
*/
int mbedtls_ssl_tls1_3_evolve_secret(
mbedtls_md_type_t hash_alg,
const unsigned char *secret_old,
const unsigned char *input, size_t input_len,
unsigned char *secret_new )
{
int ret = MBEDTLS_ERR_SSL_INTERNAL_ERROR;
size_t hlen, ilen;
unsigned char tmp_secret[ MBEDTLS_MD_MAX_SIZE ] = { 0 };
unsigned char tmp_input [ MBEDTLS_MD_MAX_SIZE ] = { 0 };
const mbedtls_md_info_t *md;
md = mbedtls_md_info_from_type( hash_alg );
if( md == NULL )
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
hlen = mbedtls_md_get_size( md );
/* For non-initial runs, call Derive-Secret( ., "derived", "")
* on the old secret. */
if( secret_old != NULL )
{
ret = mbedtls_ssl_tls1_3_derive_secret(
hash_alg,
secret_old, hlen,
MBEDTLS_SSL_TLS1_3_LBL_WITH_LEN( derived ),
NULL, 0, /* context */
MBEDTLS_SSL_TLS1_3_CONTEXT_UNHASHED,
tmp_secret, hlen );
if( ret != 0 )
goto cleanup;
}
if( input != NULL )
{
memcpy( tmp_input, input, input_len );
ilen = input_len;
}
else
{
ilen = hlen;
}
/* HKDF-Extract takes a salt and input key material.
* The salt is the old secret, and the input key material
* is the input secret (PSK / ECDHE). */
ret = mbedtls_hkdf_extract( md,
tmp_secret, hlen,
tmp_input, ilen,
secret_new );
if( ret != 0 )
goto cleanup;
ret = 0;
cleanup:
mbedtls_platform_zeroize( tmp_secret, sizeof(tmp_secret) );
mbedtls_platform_zeroize( tmp_input, sizeof(tmp_input) );
return( ret );
}
#endif /* MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL */
| 21,407 | 526 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/profile.h | #ifndef COSMOPOLITAN_THIRD_PARTY_MBEDTLS_PROFILE_H_
#define COSMOPOLITAN_THIRD_PARTY_MBEDTLS_PROFILE_H_
#include "libc/intrin/safemacros.internal.h"
#include "libc/log/log.h"
#include "libc/nexgen32e/bench.h"
#include "libc/nexgen32e/rdtsc.h"
#if 1
#define START() \
{ \
volatile uint64_t Time = __startbench()
#define STOP(x) \
fprintf(stderr, "PROFILE %,10ldc %s\n", \
unsignedsubtract(__endbench(), Time), #x); \
}
#define PROFILE(x) \
({ \
typeof(x) Res; \
START(); \
Res = (x); \
STOP(x); \
Res; \
})
#define PROFILS(x) \
do { \
START(); \
x; \
STOP(x); \
} while (0)
#define PRINT() \
fprintf(stderr, "PRINT %s called by %s\n", __FUNCTION__, GetCallerName(0))
#else
#define PRINT() ((void)0)
#define PROFILE(x) x
#define PROFILS(x) x
#define START() ((void)0)
#define STOP(x) ((void)0)
#endif
#endif /* COSMOPOLITAN_THIRD_PARTY_MBEDTLS_PROFILE_H_ */
| 1,068 | 44 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/ssl_ciphersuites.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:4;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright The Mbed TLS Contributors â
â â
â Licensed under the Apache License, Version 2.0 (the "License"); â
â you may not use this file except in compliance with the License. â
â You may obtain a copy of the License at â
â â
â http://www.apache.org/licenses/LICENSE-2.0 â
â â
â Unless required by applicable law or agreed to in writing, software â
â distributed under the License is distributed on an "AS IS" BASIS, â
â WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. â
â See the License for the specific language governing permissions and â
â limitations under the License. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/nexgen32e/x86feature.h"
#include "third_party/mbedtls/cipher.h"
#include "third_party/mbedtls/common.h"
#include "third_party/mbedtls/platform.h"
#include "third_party/mbedtls/ssl.h"
#include "third_party/mbedtls/ssl_ciphersuites.h"
asm(".ident\t\"\\n\\n\
Mbed TLS (Apache 2.0)\\n\
Copyright ARM Limited\\n\
Copyright Mbed TLS Contributors\"");
asm(".include \"libc/disclaimer.inc\"");
/* clang-format off */
/*
* CRYPTOGRAPHY 101
*
* OK WEAK BROKEN
* ------------------ ------ ------
* ECDHE > ECDH > DHE
* ECDSA > RSA
* GCM > CCM > CBC > ECB
* SHA2 > SHA1 > MD5
* AES > 3DES > DES
* CHACHA > RC4
*/
#if defined(MBEDTLS_SSL_TLS_C)
const uint16_t ciphersuite_preference[] =
{
#ifdef MBEDTLS_KEY_EXCHANGE_SOME_PFS_ENABLED
MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
MBEDTLS_TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256,
#endif
#ifdef MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED
MBEDTLS_TLS_ECDHE_PSK_WITH_AES_256_GCM_SHA384,
MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_GCM_SHA256,
MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CCM_SHA256,
MBEDTLS_TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256,
#endif
#ifdef MBEDTLS_KEY_EXCHANGE_SOME_PFS_ENABLED
MBEDTLS_TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
MBEDTLS_TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
MBEDTLS_TLS_DHE_RSA_WITH_AES_256_GCM_SHA384,
MBEDTLS_TLS_DHE_RSA_WITH_AES_128_GCM_SHA256,
MBEDTLS_TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
MBEDTLS_TLS_DHE_RSA_WITH_AES_256_CCM,
MBEDTLS_TLS_DHE_RSA_WITH_AES_128_CCM,
MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256,
MBEDTLS_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384,
MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256,
MBEDTLS_TLS_DHE_RSA_WITH_AES_256_CBC_SHA256,
MBEDTLS_TLS_DHE_RSA_WITH_AES_128_CBC_SHA256,
#endif
#ifdef MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED
MBEDTLS_TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256,
MBEDTLS_TLS_DHE_PSK_WITH_AES_256_GCM_SHA384,
MBEDTLS_TLS_DHE_PSK_WITH_AES_128_GCM_SHA256,
MBEDTLS_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384,
MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256,
MBEDTLS_TLS_DHE_PSK_WITH_AES_256_CBC_SHA384,
MBEDTLS_TLS_DHE_PSK_WITH_AES_128_CBC_SHA256,
#endif
#ifdef MBEDTLS_KEY_EXCHANGE_SOME_PFS_ENABLED
MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
MBEDTLS_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
MBEDTLS_TLS_DHE_RSA_WITH_AES_256_CBC_SHA,
MBEDTLS_TLS_DHE_RSA_WITH_AES_128_CBC_SHA,
#endif
#ifdef MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED
MBEDTLS_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA,
MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA,
MBEDTLS_TLS_DHE_PSK_WITH_AES_256_CBC_SHA,
MBEDTLS_TLS_DHE_PSK_WITH_AES_128_CBC_SHA,
#endif
#ifdef MBEDTLS_KEY_EXCHANGE_SOME_NON_PFS_ENABLED
MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384,
MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256,
MBEDTLS_TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384,
MBEDTLS_TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256,
MBEDTLS_TLS_RSA_WITH_AES_256_GCM_SHA384,
MBEDTLS_TLS_RSA_WITH_AES_128_GCM_SHA256,
MBEDTLS_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384,
MBEDTLS_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256,
MBEDTLS_TLS_RSA_WITH_AES_256_CBC_SHA256,
MBEDTLS_TLS_RSA_WITH_AES_128_CBC_SHA256,
MBEDTLS_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA,
MBEDTLS_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA,
MBEDTLS_TLS_RSA_WITH_AES_256_CBC_SHA,
MBEDTLS_TLS_RSA_WITH_AES_128_CBC_SHA,
#endif
#ifdef MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED
MBEDTLS_TLS_RSA_PSK_WITH_AES_256_GCM_SHA384,
MBEDTLS_TLS_RSA_PSK_WITH_AES_128_GCM_SHA256,
MBEDTLS_TLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256,
MBEDTLS_TLS_RSA_PSK_WITH_AES_256_CBC_SHA384,
MBEDTLS_TLS_RSA_PSK_WITH_AES_128_CBC_SHA256,
MBEDTLS_TLS_RSA_PSK_WITH_AES_256_CBC_SHA,
MBEDTLS_TLS_RSA_PSK_WITH_AES_128_CBC_SHA,
MBEDTLS_TLS_PSK_WITH_AES_256_GCM_SHA384,
MBEDTLS_TLS_PSK_WITH_AES_128_GCM_SHA256,
MBEDTLS_TLS_PSK_WITH_CHACHA20_POLY1305_SHA256,
MBEDTLS_TLS_PSK_WITH_AES_256_CBC_SHA384,
MBEDTLS_TLS_PSK_WITH_AES_256_CBC_SHA,
MBEDTLS_TLS_PSK_WITH_AES_128_CBC_SHA256,
MBEDTLS_TLS_PSK_WITH_AES_128_CBC_SHA,
#endif
#ifdef MBEDTLS_DES_C
MBEDTLS_TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA,
MBEDTLS_TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA,
MBEDTLS_TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA,
MBEDTLS_TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA,
MBEDTLS_TLS_RSA_WITH_3DES_EDE_CBC_SHA, // e.g. IE 8 XP
MBEDTLS_TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA,
MBEDTLS_TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA,
MBEDTLS_TLS_PSK_WITH_3DES_EDE_CBC_SHA,
#endif
#ifdef MBEDTLS_ENABLE_WEAK_CIPHERSUITES
MBEDTLS_TLS_DHE_RSA_WITH_DES_CBC_SHA,
MBEDTLS_TLS_RSA_WITH_DES_CBC_SHA,
#endif
#ifdef MBEDTLS_CIPHER_NULL_CIPHER
MBEDTLS_TLS_ECDHE_ECDSA_WITH_NULL_SHA,
MBEDTLS_TLS_ECDHE_RSA_WITH_NULL_SHA,
MBEDTLS_TLS_ECDHE_PSK_WITH_NULL_SHA384,
MBEDTLS_TLS_ECDHE_PSK_WITH_NULL_SHA256,
MBEDTLS_TLS_ECDHE_PSK_WITH_NULL_SHA,
MBEDTLS_TLS_DHE_PSK_WITH_NULL_SHA384,
MBEDTLS_TLS_DHE_PSK_WITH_NULL_SHA256,
MBEDTLS_TLS_DHE_PSK_WITH_NULL_SHA,
MBEDTLS_TLS_RSA_WITH_NULL_SHA256,
MBEDTLS_TLS_RSA_WITH_NULL_SHA,
MBEDTLS_TLS_RSA_WITH_NULL_MD5,
MBEDTLS_TLS_ECDH_RSA_WITH_NULL_SHA,
MBEDTLS_TLS_ECDH_ECDSA_WITH_NULL_SHA,
MBEDTLS_TLS_RSA_PSK_WITH_NULL_SHA384,
MBEDTLS_TLS_RSA_PSK_WITH_NULL_SHA256,
MBEDTLS_TLS_RSA_PSK_WITH_NULL_SHA,
MBEDTLS_TLS_PSK_WITH_NULL_SHA384,
MBEDTLS_TLS_PSK_WITH_NULL_SHA256,
MBEDTLS_TLS_PSK_WITH_NULL_SHA,
#endif
0
};
// if we don't have aes-ni then chacha will do a
// better job guarding against timing attacks
const uint16_t ciphersuite_preference_nehalem[] =
{
#ifdef MBEDTLS_KEY_EXCHANGE_SOME_PFS_ENABLED
MBEDTLS_TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256,
MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
#endif
#ifdef MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED
MBEDTLS_TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256,
MBEDTLS_TLS_ECDHE_PSK_WITH_AES_256_GCM_SHA384,
MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_GCM_SHA256,
MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CCM_SHA256,
#endif
#ifdef MBEDTLS_KEY_EXCHANGE_SOME_PFS_ENABLED
MBEDTLS_TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
MBEDTLS_TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
MBEDTLS_TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
MBEDTLS_TLS_DHE_RSA_WITH_AES_256_GCM_SHA384,
MBEDTLS_TLS_DHE_RSA_WITH_AES_128_GCM_SHA256,
MBEDTLS_TLS_DHE_RSA_WITH_AES_256_CCM,
MBEDTLS_TLS_DHE_RSA_WITH_AES_128_CCM,
MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256,
MBEDTLS_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384,
MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256,
MBEDTLS_TLS_DHE_RSA_WITH_AES_256_CBC_SHA256,
MBEDTLS_TLS_DHE_RSA_WITH_AES_128_CBC_SHA256,
#endif
#ifdef MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED
MBEDTLS_TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256,
MBEDTLS_TLS_DHE_PSK_WITH_AES_256_GCM_SHA384,
MBEDTLS_TLS_DHE_PSK_WITH_AES_128_GCM_SHA256,
MBEDTLS_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384,
MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256,
MBEDTLS_TLS_DHE_PSK_WITH_AES_256_CBC_SHA384,
MBEDTLS_TLS_DHE_PSK_WITH_AES_128_CBC_SHA256,
#endif
#ifdef MBEDTLS_KEY_EXCHANGE_SOME_PFS_ENABLED
MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
MBEDTLS_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
MBEDTLS_TLS_DHE_RSA_WITH_AES_256_CBC_SHA,
MBEDTLS_TLS_DHE_RSA_WITH_AES_128_CBC_SHA,
#endif
#ifdef MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED
MBEDTLS_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA,
MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA,
MBEDTLS_TLS_DHE_PSK_WITH_AES_256_CBC_SHA,
MBEDTLS_TLS_DHE_PSK_WITH_AES_128_CBC_SHA,
#endif
#ifdef MBEDTLS_KEY_EXCHANGE_SOME_NON_PFS_ENABLED
MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384,
MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256,
MBEDTLS_TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384,
MBEDTLS_TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256,
MBEDTLS_TLS_RSA_WITH_AES_256_GCM_SHA384,
MBEDTLS_TLS_RSA_WITH_AES_128_GCM_SHA256,
MBEDTLS_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384,
MBEDTLS_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256,
MBEDTLS_TLS_RSA_WITH_AES_256_CBC_SHA256,
MBEDTLS_TLS_RSA_WITH_AES_128_CBC_SHA256,
MBEDTLS_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA,
MBEDTLS_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA,
MBEDTLS_TLS_RSA_WITH_AES_256_CBC_SHA,
MBEDTLS_TLS_RSA_WITH_AES_128_CBC_SHA,
#endif
#ifdef MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED
MBEDTLS_TLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256,
MBEDTLS_TLS_RSA_PSK_WITH_AES_256_GCM_SHA384,
MBEDTLS_TLS_RSA_PSK_WITH_AES_128_GCM_SHA256,
MBEDTLS_TLS_RSA_PSK_WITH_AES_256_CBC_SHA384,
MBEDTLS_TLS_RSA_PSK_WITH_AES_128_CBC_SHA256,
MBEDTLS_TLS_RSA_PSK_WITH_AES_256_CBC_SHA,
MBEDTLS_TLS_RSA_PSK_WITH_AES_128_CBC_SHA,
MBEDTLS_TLS_PSK_WITH_CHACHA20_POLY1305_SHA256,
MBEDTLS_TLS_PSK_WITH_AES_256_GCM_SHA384,
MBEDTLS_TLS_PSK_WITH_AES_128_GCM_SHA256,
MBEDTLS_TLS_PSK_WITH_AES_256_CBC_SHA384,
MBEDTLS_TLS_PSK_WITH_AES_256_CBC_SHA,
MBEDTLS_TLS_PSK_WITH_AES_128_CBC_SHA256,
MBEDTLS_TLS_PSK_WITH_AES_128_CBC_SHA,
#endif
#ifdef MBEDTLS_DES_C
MBEDTLS_TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA,
MBEDTLS_TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA,
MBEDTLS_TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA,
MBEDTLS_TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA,
MBEDTLS_TLS_RSA_WITH_3DES_EDE_CBC_SHA, // e.g. IE 8 XP
MBEDTLS_TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA,
MBEDTLS_TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA,
MBEDTLS_TLS_PSK_WITH_3DES_EDE_CBC_SHA,
#endif
#ifdef MBEDTLS_ENABLE_WEAK_CIPHERSUITES
MBEDTLS_TLS_DHE_RSA_WITH_DES_CBC_SHA,
MBEDTLS_TLS_RSA_WITH_DES_CBC_SHA,
#endif
#ifdef MBEDTLS_CIPHER_NULL_CIPHER
MBEDTLS_TLS_ECDHE_ECDSA_WITH_NULL_SHA,
MBEDTLS_TLS_ECDHE_RSA_WITH_NULL_SHA,
MBEDTLS_TLS_ECDHE_PSK_WITH_NULL_SHA384,
MBEDTLS_TLS_ECDHE_PSK_WITH_NULL_SHA256,
MBEDTLS_TLS_ECDHE_PSK_WITH_NULL_SHA,
MBEDTLS_TLS_DHE_PSK_WITH_NULL_SHA384,
MBEDTLS_TLS_DHE_PSK_WITH_NULL_SHA256,
MBEDTLS_TLS_DHE_PSK_WITH_NULL_SHA,
MBEDTLS_TLS_RSA_WITH_NULL_SHA256,
MBEDTLS_TLS_RSA_WITH_NULL_SHA,
MBEDTLS_TLS_RSA_WITH_NULL_MD5,
MBEDTLS_TLS_ECDH_RSA_WITH_NULL_SHA,
MBEDTLS_TLS_ECDH_ECDSA_WITH_NULL_SHA,
MBEDTLS_TLS_RSA_PSK_WITH_NULL_SHA384,
MBEDTLS_TLS_RSA_PSK_WITH_NULL_SHA256,
MBEDTLS_TLS_RSA_PSK_WITH_NULL_SHA,
MBEDTLS_TLS_PSK_WITH_NULL_SHA384,
MBEDTLS_TLS_PSK_WITH_NULL_SHA256,
MBEDTLS_TLS_PSK_WITH_NULL_SHA,
#endif
0
};
static const mbedtls_ssl_ciphersuite_t ciphersuite_definitions[] =
{
#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED) && defined(MBEDTLS_AES_C) && defined(MBEDTLS_GCM_C) && defined(MBEDTLS_SHA512_C) && !defined(MBEDTLS_SHA512_NO_SHA384)
{ MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384, "ECDHE-ECDSA-AES256-GCM-SHA384",
MBEDTLS_CIPHER_AES_256_GCM, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif
#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED) && defined(MBEDTLS_AES_C) && defined(MBEDTLS_GCM_C) && defined(MBEDTLS_SHA512_C) && !defined(MBEDTLS_SHA512_NO_SHA384)
{ MBEDTLS_TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384, "ECDHE-RSA-AES256-GCM-SHA384",
MBEDTLS_CIPHER_AES_256_GCM, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_ECDHE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif
#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED) && defined(MBEDTLS_AES_C) && defined(MBEDTLS_GCM_C) && defined(MBEDTLS_SHA256_C)
{ MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, "ECDHE-ECDSA-AES128-GCM-SHA256",
MBEDTLS_CIPHER_AES_128_GCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif
#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED) && defined(MBEDTLS_AES_C) && defined(MBEDTLS_GCM_C) && defined(MBEDTLS_SHA256_C)
{ MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, "ECDHE-RSA-AES128-GCM-SHA256",
MBEDTLS_CIPHER_AES_128_GCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDHE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif
#if defined(MBEDTLS_KEY_EXCHANGE_PSK_ENABLED) && defined(MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED) && defined(MBEDTLS_AES_C) && defined(MBEDTLS_GCM_C) && defined(MBEDTLS_SHA512_C) && !defined(MBEDTLS_SHA512_NO_SHA384)
{ MBEDTLS_TLS_ECDHE_PSK_WITH_AES_256_GCM_SHA384, "ECDHE-PSK-AES256-GCM-SHA384",
MBEDTLS_CIPHER_AES_256_GCM, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_ECDHE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif
#if defined(MBEDTLS_CHACHAPOLY_C) && \
defined(MBEDTLS_SHA256_C) && \
defined(MBEDTLS_SSL_PROTO_TLS1_2)
#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED)
{ MBEDTLS_TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
"ECDHE-RSA-CHACHA20-POLY1305-SHA256",
MBEDTLS_CIPHER_CHACHA20_POLY1305, MBEDTLS_MD_SHA256,
MBEDTLS_KEY_EXCHANGE_ECDHE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif
#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
{ MBEDTLS_TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256,
"ECDHE-ECDSA-CHACHA20-POLY1305-SHA256",
MBEDTLS_CIPHER_CHACHA20_POLY1305, MBEDTLS_MD_SHA256,
MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif
#if defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED)
{ MBEDTLS_TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
"DHE-RSA-CHACHA20-POLY1305-SHA256",
MBEDTLS_CIPHER_CHACHA20_POLY1305, MBEDTLS_MD_SHA256,
MBEDTLS_KEY_EXCHANGE_DHE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif
#if defined(MBEDTLS_KEY_EXCHANGE_PSK_ENABLED)
{ MBEDTLS_TLS_PSK_WITH_CHACHA20_POLY1305_SHA256,
"PSK-CHACHA20-POLY1305-SHA256",
MBEDTLS_CIPHER_CHACHA20_POLY1305, MBEDTLS_MD_SHA256,
MBEDTLS_KEY_EXCHANGE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif
#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED)
{ MBEDTLS_TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256,
"ECDHE-PSK-CHACHA20-POLY1305-SHA256",
MBEDTLS_CIPHER_CHACHA20_POLY1305, MBEDTLS_MD_SHA256,
MBEDTLS_KEY_EXCHANGE_ECDHE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif
#if defined(MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED)
{ MBEDTLS_TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256,
"DHE-PSK-CHACHA20-POLY1305-SHA256",
MBEDTLS_CIPHER_CHACHA20_POLY1305, MBEDTLS_MD_SHA256,
MBEDTLS_KEY_EXCHANGE_DHE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif
#if defined(MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED)
{ MBEDTLS_TLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256,
"RSA-PSK-CHACHA20-POLY1305-SHA256",
MBEDTLS_CIPHER_CHACHA20_POLY1305, MBEDTLS_MD_SHA256,
MBEDTLS_KEY_EXCHANGE_RSA_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif
#endif /* MBEDTLS_CHACHAPOLY_C &&
MBEDTLS_SHA256_C &&
MBEDTLS_SSL_PROTO_TLS1_2 */
#if defined(MBEDTLS_KEY_EXCHANGE_PSK_ENABLED) && defined(MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED) && defined(MBEDTLS_AES_C) && defined(MBEDTLS_GCM_C) && defined(MBEDTLS_SHA512_C)
{ MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_GCM_SHA256, "ECDHE-PSK-AES128-GCM-SHA256",
MBEDTLS_CIPHER_AES_128_GCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDHE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif
#if defined(MBEDTLS_KEY_EXCHANGE_PSK_ENABLED) && defined(MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED) && defined(MBEDTLS_AES_C) && defined(MBEDTLS_CCM_C) && defined(MBEDTLS_SHA512_C)
{ MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CCM_SHA256, "ECDHE-PSK-AES128-CCM-SHA256",
MBEDTLS_CIPHER_AES_128_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDHE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif
#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
#if defined(MBEDTLS_AES_C)
#if defined(MBEDTLS_SHA1_C)
#if defined(MBEDTLS_CIPHER_MODE_CBC)
{ MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, "ECDHE-ECDSA-AES128-CBC-SHA",
MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
{ MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, "ECDHE-ECDSA-AES256-CBC-SHA",
MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#endif /* MBEDTLS_SHA1_C */
#if defined(MBEDTLS_SHA256_C)
#if defined(MBEDTLS_CIPHER_MODE_CBC)
{ MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256, "ECDHE-ECDSA-AES128-CBC-SHA256",
MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#endif /* MBEDTLS_SHA256_C */
#if defined(MBEDTLS_SHA512_C)
#if defined(MBEDTLS_CIPHER_MODE_CBC)
{ MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384, "ECDHE-ECDSA-AES256-CBC-SHA384",
MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#endif /* MBEDTLS_SHA512_C */
#if defined(MBEDTLS_CCM_C)
{ MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_CCM, "ECDHE-ECDSA-AES256-CCM",
MBEDTLS_CIPHER_AES_256_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
{ MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8, "ECDHE-ECDSA-AES256-CCM8",
MBEDTLS_CIPHER_AES_256_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_SHORT_TAG },
{ MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CCM, "ECDHE-ECDSA-AES128-CCM",
MBEDTLS_CIPHER_AES_128_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
{ MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8, "ECDHE-ECDSA-AES128-CCM8",
MBEDTLS_CIPHER_AES_128_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_SHORT_TAG },
#endif /* MBEDTLS_CCM_C */
#endif /* MBEDTLS_AES_C */
#if defined(MBEDTLS_DES_C)
#if defined(MBEDTLS_CIPHER_MODE_CBC)
#if defined(MBEDTLS_SHA1_C)
{ MBEDTLS_TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA, "ECDHE-ECDSA-3DES-EDE-CBC-SHA",
MBEDTLS_CIPHER_DES_EDE3_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_SHA1_C */
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#endif /* MBEDTLS_DES_C */
#if defined(MBEDTLS_ARC4_C)
#if defined(MBEDTLS_SHA1_C)
{ MBEDTLS_TLS_ECDHE_ECDSA_WITH_RC4_128_SHA, "ECDHE-ECDSA-RC4-128-SHA",
MBEDTLS_CIPHER_ARC4_128, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_NODTLS },
#endif /* MBEDTLS_SHA1_C */
#endif /* MBEDTLS_ARC4_C */
#if defined(MBEDTLS_CIPHER_NULL_CIPHER)
#if defined(MBEDTLS_SHA1_C)
{ MBEDTLS_TLS_ECDHE_ECDSA_WITH_NULL_SHA, "ECDHE-ECDSA-NULL-SHA",
MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_WEAK },
#endif /* MBEDTLS_SHA1_C */
#endif /* MBEDTLS_CIPHER_NULL_CIPHER */
#endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED)
#if defined(MBEDTLS_AES_C)
#if defined(MBEDTLS_SHA1_C)
#if defined(MBEDTLS_CIPHER_MODE_CBC)
{ MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA, "ECDHE-RSA-AES128-CBC-SHA",
MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDHE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
{ MBEDTLS_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA, "ECDHE-RSA-AES256-CBC-SHA",
MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDHE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#endif /* MBEDTLS_SHA1_C */
#if defined(MBEDTLS_SHA256_C)
#if defined(MBEDTLS_CIPHER_MODE_CBC)
{ MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256, "ECDHE-RSA-AES128-CBC-SHA256",
MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDHE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#endif /* MBEDTLS_SHA256_C */
#if defined(MBEDTLS_SHA512_C)
#if defined(MBEDTLS_CIPHER_MODE_CBC)
{ MBEDTLS_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384, "ECDHE-RSA-AES256-CBC-SHA384",
MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_ECDHE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#endif /* MBEDTLS_SHA512_C */
#endif /* MBEDTLS_AES_C */
#if defined(MBEDTLS_DES_C)
#if defined(MBEDTLS_CIPHER_MODE_CBC)
#if defined(MBEDTLS_SHA1_C)
{ MBEDTLS_TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA, "ECDHE-RSA-3DES-EDE-CBC-SHA",
MBEDTLS_CIPHER_DES_EDE3_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDHE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_SHA1_C */
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#endif /* MBEDTLS_DES_C */
#if defined(MBEDTLS_ARC4_C)
#if defined(MBEDTLS_SHA1_C)
{ MBEDTLS_TLS_ECDHE_RSA_WITH_RC4_128_SHA, "ECDHE-RSA-RC4-128-SHA",
MBEDTLS_CIPHER_ARC4_128, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDHE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_NODTLS },
#endif /* MBEDTLS_SHA1_C */
#endif /* MBEDTLS_ARC4_C */
#if defined(MBEDTLS_CIPHER_NULL_CIPHER)
#if defined(MBEDTLS_SHA1_C)
{ MBEDTLS_TLS_ECDHE_RSA_WITH_NULL_SHA, "ECDHE-RSA-NULL-SHA",
MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDHE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_WEAK },
#endif /* MBEDTLS_SHA1_C */
#endif /* MBEDTLS_CIPHER_NULL_CIPHER */
#endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED)
#if defined(MBEDTLS_AES_C)
#if defined(MBEDTLS_SHA512_C) && defined(MBEDTLS_GCM_C)
{ MBEDTLS_TLS_DHE_RSA_WITH_AES_256_GCM_SHA384, "DHE-RSA-AES256-GCM-SHA384",
MBEDTLS_CIPHER_AES_256_GCM, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_DHE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_SHA512_C && MBEDTLS_GCM_C */
#if defined(MBEDTLS_SHA256_C)
#if defined(MBEDTLS_GCM_C)
{ MBEDTLS_TLS_DHE_RSA_WITH_AES_128_GCM_SHA256, "DHE-RSA-AES128-GCM-SHA256",
MBEDTLS_CIPHER_AES_128_GCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_DHE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_GCM_C */
#if defined(MBEDTLS_CIPHER_MODE_CBC)
{ MBEDTLS_TLS_DHE_RSA_WITH_AES_128_CBC_SHA256, "DHE-RSA-AES128-CBC-SHA256",
MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_DHE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
{ MBEDTLS_TLS_DHE_RSA_WITH_AES_256_CBC_SHA256, "DHE-RSA-AES256-CBC-SHA256",
MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_DHE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#endif /* MBEDTLS_SHA256_C */
#if defined(MBEDTLS_CIPHER_MODE_CBC)
#if defined(MBEDTLS_SHA1_C)
{ MBEDTLS_TLS_DHE_RSA_WITH_AES_128_CBC_SHA, "DHE-RSA-AES128-CBC-SHA",
MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_DHE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
{ MBEDTLS_TLS_DHE_RSA_WITH_AES_256_CBC_SHA, "DHE-RSA-AES256-CBC-SHA",
MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_DHE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_SHA1_C */
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#if defined(MBEDTLS_CCM_C)
{ MBEDTLS_TLS_DHE_RSA_WITH_AES_256_CCM, "DHE-RSA-AES256-CCM",
MBEDTLS_CIPHER_AES_256_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_DHE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
{ MBEDTLS_TLS_DHE_RSA_WITH_AES_256_CCM_8, "DHE-RSA-AES256-CCM8",
MBEDTLS_CIPHER_AES_256_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_DHE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_SHORT_TAG },
{ MBEDTLS_TLS_DHE_RSA_WITH_AES_128_CCM, "DHE-RSA-AES128-CCM",
MBEDTLS_CIPHER_AES_128_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_DHE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
{ MBEDTLS_TLS_DHE_RSA_WITH_AES_128_CCM_8, "DHE-RSA-AES128-CCM8",
MBEDTLS_CIPHER_AES_128_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_DHE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_SHORT_TAG },
#endif /* MBEDTLS_CCM_C */
#endif /* MBEDTLS_AES_C */
#if defined(MBEDTLS_DES_C)
#if defined(MBEDTLS_CIPHER_MODE_CBC)
#if defined(MBEDTLS_SHA1_C)
{ MBEDTLS_TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA, "DHE-RSA-3DES-EDE-CBC-SHA",
MBEDTLS_CIPHER_DES_EDE3_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_DHE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_SHA1_C */
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#endif /* MBEDTLS_DES_C */
#endif /* MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED)
#if defined(MBEDTLS_AES_C)
#if defined(MBEDTLS_SHA512_C) && defined(MBEDTLS_GCM_C)
{ MBEDTLS_TLS_RSA_WITH_AES_256_GCM_SHA384, "RSA-AES256-GCM-SHA384",
MBEDTLS_CIPHER_AES_256_GCM, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_SHA512_C && MBEDTLS_GCM_C */
#if defined(MBEDTLS_SHA256_C)
#if defined(MBEDTLS_GCM_C)
{ MBEDTLS_TLS_RSA_WITH_AES_128_GCM_SHA256, "RSA-AES128-GCM-SHA256",
MBEDTLS_CIPHER_AES_128_GCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_GCM_C */
#if defined(MBEDTLS_CIPHER_MODE_CBC)
{ MBEDTLS_TLS_RSA_WITH_AES_128_CBC_SHA256, "RSA-AES128-CBC-SHA256",
MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
{ MBEDTLS_TLS_RSA_WITH_AES_256_CBC_SHA256, "RSA-AES256-CBC-SHA256",
MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#endif /* MBEDTLS_SHA256_C */
#if defined(MBEDTLS_SHA1_C)
#if defined(MBEDTLS_CIPHER_MODE_CBC)
{ MBEDTLS_TLS_RSA_WITH_AES_128_CBC_SHA, "RSA-AES128-CBC-SHA",
MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
{ MBEDTLS_TLS_RSA_WITH_AES_256_CBC_SHA, "RSA-AES256-CBC-SHA",
MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#endif /* MBEDTLS_SHA1_C */
#if defined(MBEDTLS_CCM_C)
{ MBEDTLS_TLS_RSA_WITH_AES_256_CCM, "RSA-AES256-CCM",
MBEDTLS_CIPHER_AES_256_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
{ MBEDTLS_TLS_RSA_WITH_AES_256_CCM_8, "RSA-AES256-CCM8",
MBEDTLS_CIPHER_AES_256_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_SHORT_TAG },
{ MBEDTLS_TLS_RSA_WITH_AES_128_CCM, "RSA-AES128-CCM",
MBEDTLS_CIPHER_AES_128_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
{ MBEDTLS_TLS_RSA_WITH_AES_128_CCM_8, "RSA-AES128-CCM8",
MBEDTLS_CIPHER_AES_128_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_SHORT_TAG },
#endif /* MBEDTLS_CCM_C */
#endif /* MBEDTLS_AES_C */
#if defined(MBEDTLS_DES_C)
#if defined(MBEDTLS_CIPHER_MODE_CBC)
#if defined(MBEDTLS_SHA1_C)
{ MBEDTLS_TLS_RSA_WITH_3DES_EDE_CBC_SHA, "RSA-3DES-EDE-CBC-SHA",
MBEDTLS_CIPHER_DES_EDE3_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_SHA1_C */
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#endif /* MBEDTLS_DES_C */
#if defined(MBEDTLS_ARC4_C)
#if defined(MBEDTLS_MD5_C)
{ MBEDTLS_TLS_RSA_WITH_RC4_128_MD5, "RSA-RC4-128-MD5",
MBEDTLS_CIPHER_ARC4_128, MBEDTLS_MD_MD5, MBEDTLS_KEY_EXCHANGE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_NODTLS },
#endif
#if defined(MBEDTLS_SHA1_C)
{ MBEDTLS_TLS_RSA_WITH_RC4_128_SHA, "RSA-RC4-128-SHA",
MBEDTLS_CIPHER_ARC4_128, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_NODTLS },
#endif
#endif /* MBEDTLS_ARC4_C */
#endif /* MBEDTLS_KEY_EXCHANGE_RSA_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED)
#if defined(MBEDTLS_AES_C)
#if defined(MBEDTLS_SHA1_C)
#if defined(MBEDTLS_CIPHER_MODE_CBC)
{ MBEDTLS_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA, "ECDH-RSA-AES128-CBC-SHA",
MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDH_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
{ MBEDTLS_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA, "ECDH-RSA-AES256-CBC-SHA",
MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDH_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#endif /* MBEDTLS_SHA1_C */
#if defined(MBEDTLS_SHA256_C)
#if defined(MBEDTLS_CIPHER_MODE_CBC)
{ MBEDTLS_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256, "ECDH-RSA-AES128-CBC-SHA256",
MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDH_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#if defined(MBEDTLS_GCM_C)
{ MBEDTLS_TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256, "ECDH-RSA-AES128-GCM-SHA256",
MBEDTLS_CIPHER_AES_128_GCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDH_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_GCM_C */
#endif /* MBEDTLS_SHA256_C */
#if defined(MBEDTLS_SHA512_C)
#if defined(MBEDTLS_CIPHER_MODE_CBC)
{ MBEDTLS_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384, "ECDH-RSA-AES256-CBC-SHA384",
MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_ECDH_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#if defined(MBEDTLS_GCM_C)
{ MBEDTLS_TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384, "ECDH-RSA-AES256-GCM-SHA384",
MBEDTLS_CIPHER_AES_256_GCM, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_ECDH_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_GCM_C */
#endif /* MBEDTLS_SHA512_C */
#endif /* MBEDTLS_AES_C */
#if defined(MBEDTLS_DES_C)
#if defined(MBEDTLS_CIPHER_MODE_CBC)
#if defined(MBEDTLS_SHA1_C)
{ MBEDTLS_TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA, "ECDH-RSA-3DES-EDE-CBC-SHA",
MBEDTLS_CIPHER_DES_EDE3_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDH_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_SHA1_C */
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#endif /* MBEDTLS_DES_C */
#if defined(MBEDTLS_ARC4_C)
#if defined(MBEDTLS_SHA1_C)
{ MBEDTLS_TLS_ECDH_RSA_WITH_RC4_128_SHA, "ECDH-RSA-RC4-128-SHA",
MBEDTLS_CIPHER_ARC4_128, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDH_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_NODTLS },
#endif /* MBEDTLS_SHA1_C */
#endif /* MBEDTLS_ARC4_C */
#if defined(MBEDTLS_CIPHER_NULL_CIPHER)
#if defined(MBEDTLS_SHA1_C)
{ MBEDTLS_TLS_ECDH_RSA_WITH_NULL_SHA, "ECDH-RSA-NULL-SHA",
MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDH_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_WEAK },
#endif /* MBEDTLS_SHA1_C */
#endif /* MBEDTLS_CIPHER_NULL_CIPHER */
#endif /* MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
#if defined(MBEDTLS_AES_C)
#if defined(MBEDTLS_SHA1_C)
#if defined(MBEDTLS_CIPHER_MODE_CBC)
{ MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA, "ECDH-ECDSA-AES128-CBC-SHA",
MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
{ MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA, "ECDH-ECDSA-AES256-CBC-SHA",
MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#endif /* MBEDTLS_SHA1_C */
#if defined(MBEDTLS_SHA256_C)
#if defined(MBEDTLS_CIPHER_MODE_CBC)
{ MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256, "ECDH-ECDSA-AES128-CBC-SHA256",
MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#if defined(MBEDTLS_GCM_C)
{ MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256, "ECDH-ECDSA-AES128-GCM-SHA256",
MBEDTLS_CIPHER_AES_128_GCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_GCM_C */
#endif /* MBEDTLS_SHA256_C */
#if defined(MBEDTLS_SHA512_C)
#if defined(MBEDTLS_CIPHER_MODE_CBC)
{ MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384, "ECDH-ECDSA-AES256-CBC-SHA384",
MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#if defined(MBEDTLS_GCM_C)
{ MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384, "ECDH-ECDSA-AES256-GCM-SHA384",
MBEDTLS_CIPHER_AES_256_GCM, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_GCM_C */
#endif /* MBEDTLS_SHA512_C */
#endif /* MBEDTLS_AES_C */
#if defined(MBEDTLS_DES_C)
#if defined(MBEDTLS_CIPHER_MODE_CBC)
#if defined(MBEDTLS_SHA1_C)
{ MBEDTLS_TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA, "ECDH-ECDSA-3DES-EDE-CBC-SHA",
MBEDTLS_CIPHER_DES_EDE3_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_SHA1_C */
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#endif /* MBEDTLS_DES_C */
#if defined(MBEDTLS_ARC4_C)
#if defined(MBEDTLS_SHA1_C)
{ MBEDTLS_TLS_ECDH_ECDSA_WITH_RC4_128_SHA, "ECDH-ECDSA-RC4-128-SHA",
MBEDTLS_CIPHER_ARC4_128, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_NODTLS },
#endif /* MBEDTLS_SHA1_C */
#endif /* MBEDTLS_ARC4_C */
#if defined(MBEDTLS_CIPHER_NULL_CIPHER)
#if defined(MBEDTLS_SHA1_C)
{ MBEDTLS_TLS_ECDH_ECDSA_WITH_NULL_SHA, "ECDH-ECDSA-NULL-SHA",
MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_WEAK },
#endif /* MBEDTLS_SHA1_C */
#endif /* MBEDTLS_CIPHER_NULL_CIPHER */
#endif /* MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_PSK_ENABLED)
#if defined(MBEDTLS_AES_C)
#if defined(MBEDTLS_GCM_C)
#if defined(MBEDTLS_SHA256_C)
{ MBEDTLS_TLS_PSK_WITH_AES_128_GCM_SHA256, "PSK-AES128-GCM-SHA256",
MBEDTLS_CIPHER_AES_128_GCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_SHA256_C */
#if defined(MBEDTLS_SHA512_C)
{ MBEDTLS_TLS_PSK_WITH_AES_256_GCM_SHA384, "PSK-AES256-GCM-SHA384",
MBEDTLS_CIPHER_AES_256_GCM, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_SHA512_C */
#endif /* MBEDTLS_GCM_C */
#if defined(MBEDTLS_CIPHER_MODE_CBC)
#if defined(MBEDTLS_SHA256_C)
{ MBEDTLS_TLS_PSK_WITH_AES_128_CBC_SHA256, "PSK-AES128-CBC-SHA256",
MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_SHA256_C */
#if defined(MBEDTLS_SHA512_C)
{ MBEDTLS_TLS_PSK_WITH_AES_256_CBC_SHA384, "PSK-AES256-CBC-SHA384",
MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_SHA512_C */
#if defined(MBEDTLS_SHA1_C)
{ MBEDTLS_TLS_PSK_WITH_AES_128_CBC_SHA, "PSK-AES128-CBC-SHA",
MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
{ MBEDTLS_TLS_PSK_WITH_AES_256_CBC_SHA, "PSK-AES256-CBC-SHA",
MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_SHA1_C */
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#if defined(MBEDTLS_CCM_C)
{ MBEDTLS_TLS_PSK_WITH_AES_256_CCM, "PSK-AES256-CCM",
MBEDTLS_CIPHER_AES_256_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
{ MBEDTLS_TLS_PSK_WITH_AES_256_CCM_8, "PSK-AES256-CCM8",
MBEDTLS_CIPHER_AES_256_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_SHORT_TAG },
{ MBEDTLS_TLS_PSK_WITH_AES_128_CCM, "PSK-AES128-CCM",
MBEDTLS_CIPHER_AES_128_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
{ MBEDTLS_TLS_PSK_WITH_AES_128_CCM_8, "PSK-AES128-CCM8",
MBEDTLS_CIPHER_AES_128_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_SHORT_TAG },
#endif /* MBEDTLS_CCM_C */
#endif /* MBEDTLS_AES_C */
#if defined(MBEDTLS_DES_C)
#if defined(MBEDTLS_CIPHER_MODE_CBC)
#if defined(MBEDTLS_SHA1_C)
{ MBEDTLS_TLS_PSK_WITH_3DES_EDE_CBC_SHA, "PSK-3DES-EDE-CBC-SHA",
MBEDTLS_CIPHER_DES_EDE3_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_SHA1_C */
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#endif /* MBEDTLS_DES_C */
#if defined(MBEDTLS_ARC4_C)
#if defined(MBEDTLS_SHA1_C)
{ MBEDTLS_TLS_PSK_WITH_RC4_128_SHA, "PSK-RC4-128-SHA",
MBEDTLS_CIPHER_ARC4_128, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_NODTLS },
#endif /* MBEDTLS_SHA1_C */
#endif /* MBEDTLS_ARC4_C */
#endif /* MBEDTLS_KEY_EXCHANGE_PSK_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED)
#if defined(MBEDTLS_AES_C)
#if defined(MBEDTLS_GCM_C)
#if defined(MBEDTLS_SHA256_C)
{ MBEDTLS_TLS_DHE_PSK_WITH_AES_128_GCM_SHA256, "DHE-PSK-AES128-GCM-SHA256",
MBEDTLS_CIPHER_AES_128_GCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_DHE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_SHA256_C */
#if defined(MBEDTLS_SHA512_C)
{ MBEDTLS_TLS_DHE_PSK_WITH_AES_256_GCM_SHA384, "DHE-PSK-AES256-GCM-SHA384",
MBEDTLS_CIPHER_AES_256_GCM, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_DHE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_SHA512_C */
#endif /* MBEDTLS_GCM_C */
#if defined(MBEDTLS_CIPHER_MODE_CBC)
#if defined(MBEDTLS_SHA256_C)
{ MBEDTLS_TLS_DHE_PSK_WITH_AES_128_CBC_SHA256, "DHE-PSK-AES128-CBC-SHA256",
MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_DHE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_SHA256_C */
#if defined(MBEDTLS_SHA512_C)
{ MBEDTLS_TLS_DHE_PSK_WITH_AES_256_CBC_SHA384, "DHE-PSK-AES256-CBC-SHA384",
MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_DHE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_SHA512_C */
#if defined(MBEDTLS_SHA1_C)
{ MBEDTLS_TLS_DHE_PSK_WITH_AES_128_CBC_SHA, "DHE-PSK-AES128-CBC-SHA",
MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_DHE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
{ MBEDTLS_TLS_DHE_PSK_WITH_AES_256_CBC_SHA, "DHE-PSK-AES256-CBC-SHA",
MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_DHE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_SHA1_C */
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#if defined(MBEDTLS_CCM_C)
{ MBEDTLS_TLS_DHE_PSK_WITH_AES_256_CCM, "DHE-PSK-AES256-CCM",
MBEDTLS_CIPHER_AES_256_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_DHE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
{ MBEDTLS_TLS_DHE_PSK_WITH_AES_256_CCM_8, "DHE-PSK-AES256-CCM8",
MBEDTLS_CIPHER_AES_256_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_DHE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_SHORT_TAG },
{ MBEDTLS_TLS_DHE_PSK_WITH_AES_128_CCM, "DHE-PSK-AES128-CCM",
MBEDTLS_CIPHER_AES_128_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_DHE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
{ MBEDTLS_TLS_DHE_PSK_WITH_AES_128_CCM_8, "DHE-PSK-AES128-CCM8",
MBEDTLS_CIPHER_AES_128_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_DHE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_SHORT_TAG },
#endif /* MBEDTLS_CCM_C */
#endif /* MBEDTLS_AES_C */
#if defined(MBEDTLS_DES_C)
#if defined(MBEDTLS_CIPHER_MODE_CBC)
#if defined(MBEDTLS_SHA1_C)
{ MBEDTLS_TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA, "DHE-PSK-3DES-EDE-CBC-SHA",
MBEDTLS_CIPHER_DES_EDE3_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_DHE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_SHA1_C */
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#endif /* MBEDTLS_DES_C */
#if defined(MBEDTLS_ARC4_C)
#if defined(MBEDTLS_SHA1_C)
{ MBEDTLS_TLS_DHE_PSK_WITH_RC4_128_SHA, "DHE-PSK-RC4-128-SHA",
MBEDTLS_CIPHER_ARC4_128, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_DHE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_NODTLS },
#endif /* MBEDTLS_SHA1_C */
#endif /* MBEDTLS_ARC4_C */
#endif /* MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED)
#if defined(MBEDTLS_AES_C)
#if defined(MBEDTLS_CIPHER_MODE_CBC)
#if defined(MBEDTLS_SHA256_C)
{ MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256, "ECDHE-PSK-AES128-CBC-SHA256",
MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDHE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_SHA256_C */
#if defined(MBEDTLS_SHA512_C)
{ MBEDTLS_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384, "ECDHE-PSK-AES256-CBC-SHA384",
MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_ECDHE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_SHA512_C */
#if defined(MBEDTLS_SHA1_C)
{ MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA, "ECDHE-PSK-AES128-CBC-SHA",
MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDHE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
{ MBEDTLS_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA, "ECDHE-PSK-AES256-CBC-SHA",
MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDHE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_SHA1_C */
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#endif /* MBEDTLS_AES_C */
#if defined(MBEDTLS_DES_C)
#if defined(MBEDTLS_CIPHER_MODE_CBC)
#if defined(MBEDTLS_SHA1_C)
{ MBEDTLS_TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA, "ECDHE-PSK-3DES-EDE-CBC-SHA",
MBEDTLS_CIPHER_DES_EDE3_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDHE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_SHA1_C */
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#endif /* MBEDTLS_DES_C */
#if defined(MBEDTLS_ARC4_C)
#if defined(MBEDTLS_SHA1_C)
{ MBEDTLS_TLS_ECDHE_PSK_WITH_RC4_128_SHA, "ECDHE-PSK-RC4-128-SHA",
MBEDTLS_CIPHER_ARC4_128, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDHE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_NODTLS },
#endif /* MBEDTLS_SHA1_C */
#endif /* MBEDTLS_ARC4_C */
#endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED)
#if defined(MBEDTLS_AES_C)
#if defined(MBEDTLS_GCM_C)
#if defined(MBEDTLS_SHA256_C)
{ MBEDTLS_TLS_RSA_PSK_WITH_AES_128_GCM_SHA256, "RSA-PSK-AES128-GCM-SHA256",
MBEDTLS_CIPHER_AES_128_GCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_RSA_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_SHA256_C */
#if defined(MBEDTLS_SHA512_C)
{ MBEDTLS_TLS_RSA_PSK_WITH_AES_256_GCM_SHA384, "RSA-PSK-AES256-GCM-SHA384",
MBEDTLS_CIPHER_AES_256_GCM, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_RSA_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_SHA512_C */
#endif /* MBEDTLS_GCM_C */
#if defined(MBEDTLS_CIPHER_MODE_CBC)
#if defined(MBEDTLS_SHA256_C)
{ MBEDTLS_TLS_RSA_PSK_WITH_AES_128_CBC_SHA256, "RSA-PSK-AES128-CBC-SHA256",
MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_RSA_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_SHA256_C */
#if defined(MBEDTLS_SHA512_C)
{ MBEDTLS_TLS_RSA_PSK_WITH_AES_256_CBC_SHA384, "RSA-PSK-AES256-CBC-SHA384",
MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_RSA_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_SHA512_C */
#if defined(MBEDTLS_SHA1_C)
{ MBEDTLS_TLS_RSA_PSK_WITH_AES_128_CBC_SHA, "RSA-PSK-AES128-CBC-SHA",
MBEDTLS_CIPHER_AES_128_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_RSA_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
{ MBEDTLS_TLS_RSA_PSK_WITH_AES_256_CBC_SHA, "RSA-PSK-AES256-CBC-SHA",
MBEDTLS_CIPHER_AES_256_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_RSA_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_SHA1_C */
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#endif /* MBEDTLS_AES_C */
#if defined(MBEDTLS_DES_C)
#if defined(MBEDTLS_CIPHER_MODE_CBC)
#if defined(MBEDTLS_SHA1_C)
{ MBEDTLS_TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA, "RSA-PSK-3DES-EDE-CBC-SHA",
MBEDTLS_CIPHER_DES_EDE3_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_RSA_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
0 },
#endif /* MBEDTLS_SHA1_C */
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#endif /* MBEDTLS_DES_C */
#if defined(MBEDTLS_ARC4_C)
#if defined(MBEDTLS_SHA1_C)
{ MBEDTLS_TLS_RSA_PSK_WITH_RC4_128_SHA, "RSA-PSK-RC4-128-SHA",
MBEDTLS_CIPHER_ARC4_128, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_RSA_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_NODTLS },
#endif /* MBEDTLS_SHA1_C */
#endif /* MBEDTLS_ARC4_C */
#endif /* MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
#if defined(MBEDTLS_AES_C)
#if defined(MBEDTLS_CCM_C)
{ MBEDTLS_TLS_ECJPAKE_WITH_AES_128_CCM_8, "ECJPAKE-AES128-CCM8",
MBEDTLS_CIPHER_AES_128_CCM, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECJPAKE,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_SHORT_TAG },
#endif /* MBEDTLS_CCM_C */
#endif /* MBEDTLS_AES_C */
#endif /* MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED */
#if defined(MBEDTLS_ENABLE_WEAK_CIPHERSUITES)
#if defined(MBEDTLS_CIPHER_NULL_CIPHER)
#if defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED)
#if defined(MBEDTLS_MD5_C)
{ MBEDTLS_TLS_RSA_WITH_NULL_MD5, "RSA-NULL-MD5",
MBEDTLS_CIPHER_NULL, MBEDTLS_MD_MD5, MBEDTLS_KEY_EXCHANGE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_WEAK },
#endif
#if defined(MBEDTLS_SHA1_C)
{ MBEDTLS_TLS_RSA_WITH_NULL_SHA, "RSA-NULL-SHA",
MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_WEAK },
#endif
#if defined(MBEDTLS_SHA256_C)
{ MBEDTLS_TLS_RSA_WITH_NULL_SHA256, "RSA-NULL-SHA256",
MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_WEAK },
#endif
#endif /* MBEDTLS_KEY_EXCHANGE_RSA_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_PSK_ENABLED)
#if defined(MBEDTLS_SHA1_C)
{ MBEDTLS_TLS_PSK_WITH_NULL_SHA, "PSK-NULL-SHA",
MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_WEAK },
#endif /* MBEDTLS_SHA1_C */
#if defined(MBEDTLS_SHA256_C)
{ MBEDTLS_TLS_PSK_WITH_NULL_SHA256, "PSK-NULL-SHA256",
MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_WEAK },
#endif
#if defined(MBEDTLS_SHA512_C)
{ MBEDTLS_TLS_PSK_WITH_NULL_SHA384, "PSK-NULL-SHA384",
MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_WEAK },
#endif
#endif /* MBEDTLS_KEY_EXCHANGE_PSK_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED)
#if defined(MBEDTLS_SHA1_C)
{ MBEDTLS_TLS_DHE_PSK_WITH_NULL_SHA, "DHE-PSK-NULL-SHA",
MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_DHE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_WEAK },
#endif /* MBEDTLS_SHA1_C */
#if defined(MBEDTLS_SHA256_C)
{ MBEDTLS_TLS_DHE_PSK_WITH_NULL_SHA256, "DHE-PSK-NULL-SHA256",
MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_DHE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_WEAK },
#endif
#if defined(MBEDTLS_SHA512_C)
{ MBEDTLS_TLS_DHE_PSK_WITH_NULL_SHA384, "DHE-PSK-NULL-SHA384",
MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_DHE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_WEAK },
#endif
#endif /* MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED)
#if defined(MBEDTLS_SHA1_C)
{ MBEDTLS_TLS_ECDHE_PSK_WITH_NULL_SHA, "ECDHE-PSK-NULL-SHA",
MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_ECDHE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_WEAK },
#endif /* MBEDTLS_SHA1_C */
#if defined(MBEDTLS_SHA256_C)
{ MBEDTLS_TLS_ECDHE_PSK_WITH_NULL_SHA256, "ECDHE-PSK-NULL-SHA256",
MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_ECDHE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_WEAK },
#endif
#if defined(MBEDTLS_SHA512_C)
{ MBEDTLS_TLS_ECDHE_PSK_WITH_NULL_SHA384, "ECDHE-PSK-NULL-SHA384",
MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_ECDHE_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_WEAK },
#endif
#endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED)
#if defined(MBEDTLS_SHA1_C)
{ MBEDTLS_TLS_RSA_PSK_WITH_NULL_SHA, "RSA-PSK-NULL-SHA",
MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_RSA_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_WEAK },
#endif /* MBEDTLS_SHA1_C */
#if defined(MBEDTLS_SHA256_C)
{ MBEDTLS_TLS_RSA_PSK_WITH_NULL_SHA256, "RSA-PSK-NULL-SHA256",
MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA256, MBEDTLS_KEY_EXCHANGE_RSA_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_WEAK },
#endif
#if defined(MBEDTLS_SHA512_C)
{ MBEDTLS_TLS_RSA_PSK_WITH_NULL_SHA384, "RSA-PSK-NULL-SHA384",
MBEDTLS_CIPHER_NULL, MBEDTLS_MD_SHA384, MBEDTLS_KEY_EXCHANGE_RSA_PSK,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_1,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_WEAK },
#endif
#endif /* MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED */
#endif /* MBEDTLS_CIPHER_NULL_CIPHER */
#if defined(MBEDTLS_DES_C)
#if defined(MBEDTLS_CIPHER_MODE_CBC)
#if defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED)
#if defined(MBEDTLS_SHA1_C)
{ MBEDTLS_TLS_DHE_RSA_WITH_DES_CBC_SHA, "DHE-RSA-DES-CBC-SHA",
MBEDTLS_CIPHER_DES_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_DHE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_WEAK },
#endif /* MBEDTLS_SHA1_C */
#endif /* MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED)
#if defined(MBEDTLS_SHA1_C)
{ MBEDTLS_TLS_RSA_WITH_DES_CBC_SHA, "RSA-DES-CBC-SHA",
MBEDTLS_CIPHER_DES_CBC, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_WEAK },
#endif /* MBEDTLS_SHA1_C */
#endif /* MBEDTLS_KEY_EXCHANGE_RSA_ENABLED */
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#endif /* MBEDTLS_DES_C */
#endif /* MBEDTLS_ENABLE_WEAK_CIPHERSUITES */
{ MBEDTLS_TLS_RSA_WITH_RC4_128_SHA, "RSA-RC4-128-SHA",
MBEDTLS_CIPHER_ARC4_128, MBEDTLS_MD_SHA1, MBEDTLS_KEY_EXCHANGE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_NODTLS },
{ MBEDTLS_TLS_RSA_WITH_RC4_128_MD5, "RSA-RC4-128-MD5",
MBEDTLS_CIPHER_ARC4_128, MBEDTLS_MD_MD5, MBEDTLS_KEY_EXCHANGE_RSA,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0,
MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3,
MBEDTLS_CIPHERSUITE_NODTLS },
{ 0, "",
MBEDTLS_CIPHER_NONE, MBEDTLS_MD_NONE, MBEDTLS_KEY_EXCHANGE_NONE,
0, 0, 0, 0, 0 }
};
#define MAX_CIPHERSUITES sizeof( ciphersuite_definitions ) / \
sizeof( ciphersuite_definitions[0] )
static uint16_t supported_ciphersuites[MAX_CIPHERSUITES];
static int supported_init = 0;
static int ciphersuite_is_removed( const mbedtls_ssl_ciphersuite_t *cs_info )
{
(void)cs_info;
#if defined(MBEDTLS_REMOVE_3DES_CIPHERSUITES)
if( cs_info->cipher == MBEDTLS_CIPHER_DES_EDE3_ECB ||
cs_info->cipher == MBEDTLS_CIPHER_DES_EDE3_CBC )
{
return( 1 );
}
#endif /* MBEDTLS_REMOVE_3DES_CIPHERSUITES */
return( 0 );
}
const uint16_t *mbedtls_ssl_list_ciphersuites( void )
{
/*
* On initial call filter out all ciphersuites not supported by current
* build based on presence in the ciphersuite_definitions.
*/
if( supported_init == 0 )
{
const uint16_t *p;
uint16_t *q;
if( X86_HAVE( AES ) )
p = ciphersuite_preference;
else
p = ciphersuite_preference_nehalem;
for( q = supported_ciphersuites;
*p != 0 && q < supported_ciphersuites + MAX_CIPHERSUITES - 1;
p++ )
{
const mbedtls_ssl_ciphersuite_t *cs_info;
if( ( cs_info = mbedtls_ssl_ciphersuite_from_id( *p ) ) != NULL &&
!ciphersuite_is_removed( cs_info ) )
{
*(q++) = *p;
}
}
*q = 0;
supported_init = 1;
}
return( supported_ciphersuites );
}
const mbedtls_ssl_ciphersuite_t *mbedtls_ssl_ciphersuite_from_string(
const char *ciphersuite_name )
{
const mbedtls_ssl_ciphersuite_t *cur = ciphersuite_definitions;
if( NULL == ciphersuite_name )
return( NULL );
while( cur->id != 0 )
{
if( 0 == strcmp( cur->name, ciphersuite_name ) )
return( cur );
cur++;
}
return( NULL );
}
const mbedtls_ssl_ciphersuite_t *mbedtls_ssl_ciphersuite_from_id( int ciphersuite )
{
const mbedtls_ssl_ciphersuite_t *cur = ciphersuite_definitions;
while( cur->id != 0 )
{
if( cur->id == ciphersuite )
return( cur );
cur++;
}
return( NULL );
}
/**
* \brief Return the name of the ciphersuite associated with the
* given ID
*
* \param ciphersuite_id SSL ciphersuite ID
*
* \return a string containing the ciphersuite name
*/
const char *mbedtls_ssl_get_ciphersuite_name( const int ciphersuite_id )
{
const mbedtls_ssl_ciphersuite_t *cur;
cur = mbedtls_ssl_ciphersuite_from_id( ciphersuite_id );
if( cur == NULL )
return( "unknown" );
return( cur->name );
}
/**
* \brief Return the ID of the ciphersuite associated with the
* given name
*
* \param ciphersuite_name SSL ciphersuite name
*
* \return the ID with the ciphersuite or 0 if not found
*/
int mbedtls_ssl_get_ciphersuite_id( const char *ciphersuite_name )
{
const mbedtls_ssl_ciphersuite_t *cur;
cur = mbedtls_ssl_ciphersuite_from_string( ciphersuite_name );
if( cur == NULL )
return( 0 );
return( cur->id );
}
#if defined(MBEDTLS_PK_C)
mbedtls_pk_type_t mbedtls_ssl_get_ciphersuite_sig_pk_alg( const mbedtls_ssl_ciphersuite_t *info )
{
switch( info->key_exchange )
{
case MBEDTLS_KEY_EXCHANGE_RSA:
case MBEDTLS_KEY_EXCHANGE_DHE_RSA:
case MBEDTLS_KEY_EXCHANGE_ECDHE_RSA:
case MBEDTLS_KEY_EXCHANGE_RSA_PSK:
return( MBEDTLS_PK_RSA );
case MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA:
return( MBEDTLS_PK_ECDSA );
case MBEDTLS_KEY_EXCHANGE_ECDH_RSA:
case MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA:
return( MBEDTLS_PK_ECKEY );
default:
return( MBEDTLS_PK_NONE );
}
}
mbedtls_pk_type_t mbedtls_ssl_get_ciphersuite_sig_alg( const mbedtls_ssl_ciphersuite_t *info )
{
switch( info->key_exchange )
{
case MBEDTLS_KEY_EXCHANGE_RSA:
case MBEDTLS_KEY_EXCHANGE_DHE_RSA:
case MBEDTLS_KEY_EXCHANGE_ECDHE_RSA:
return( MBEDTLS_PK_RSA );
case MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA:
return( MBEDTLS_PK_ECDSA );
default:
return( MBEDTLS_PK_NONE );
}
}
#endif /* MBEDTLS_PK_C */
#if defined(MBEDTLS_ECDH_C) || defined(MBEDTLS_ECDSA_C) || \
defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
int mbedtls_ssl_ciphersuite_uses_ec( const mbedtls_ssl_ciphersuite_t *info )
{
switch( info->key_exchange )
{
case MBEDTLS_KEY_EXCHANGE_ECDHE_RSA:
case MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA:
case MBEDTLS_KEY_EXCHANGE_ECDHE_PSK:
case MBEDTLS_KEY_EXCHANGE_ECDH_RSA:
case MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA:
case MBEDTLS_KEY_EXCHANGE_ECJPAKE:
return( 1 );
default:
return( 0 );
}
}
#endif /* MBEDTLS_ECDH_C || MBEDTLS_ECDSA_C || MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED*/
#if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED)
int mbedtls_ssl_ciphersuite_uses_psk( const mbedtls_ssl_ciphersuite_t *info )
{
switch( info->key_exchange )
{
case MBEDTLS_KEY_EXCHANGE_PSK:
case MBEDTLS_KEY_EXCHANGE_RSA_PSK:
case MBEDTLS_KEY_EXCHANGE_DHE_PSK:
case MBEDTLS_KEY_EXCHANGE_ECDHE_PSK:
return( 1 );
default:
return( 0 );
}
}
#endif /* MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED */
#endif /* MBEDTLS_SSL_TLS_C */
| 71,584 | 1,675 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/md5.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:4;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright The Mbed TLS Contributors â
â â
â Licensed under the Apache License, Version 2.0 (the "License"); â
â you may not use this file except in compliance with the License. â
â You may obtain a copy of the License at â
â â
â http://www.apache.org/licenses/LICENSE-2.0 â
â â
â Unless required by applicable law or agreed to in writing, software â
â distributed under the License is distributed on an "AS IS" BASIS, â
â WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. â
â See the License for the specific language governing permissions and â
â limitations under the License. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/intrin/bits.h"
#include "libc/str/str.h"
#include "third_party/mbedtls/common.h"
#include "third_party/mbedtls/error.h"
#include "third_party/mbedtls/md.h"
#include "third_party/mbedtls/md5.h"
#include "third_party/mbedtls/platform.h"
asm(".ident\t\"\\n\\n\
Mbed TLS (Apache 2.0)\\n\
Copyright ARM Limited\\n\
Copyright Mbed TLS Contributors\"");
asm(".include \"libc/disclaimer.inc\"");
/* clang-format off */
/*
* RFC 1321 compliant MD5 implementation
*
* Copyright The Mbed TLS Contributors
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* The MD5 algorithm was designed by Ron Rivest in 1991.
*
* http://www.ietf.org/rfc/rfc1321.txt
*/
#if !defined(MBEDTLS_MD5_ALT)
#define GET_UINT32_LE(n,b,i) (n) = READ32LE((b) + (i))
#define PUT_UINT32_LE(n,b,i) WRITE32LE((b) + (i), n)
/**
* \brief Clone (the state of) an MD5 context
*
* \param dst The destination context
* \param src The context to be cloned
*
* \warning MD5 is considered a weak message digest and its use
* constitutes a security risk. We recommend considering
* stronger message digests instead.
*/
void mbedtls_md5_clone( mbedtls_md5_context *dst,
const mbedtls_md5_context *src )
{
*dst = *src;
}
/**
* \brief MD5 context setup
*
* \param ctx context to be initialized
*
* \return 0 if successful
*
* \warning MD5 is considered a weak message digest and its use
* constitutes a security risk. We recommend considering
* stronger message digests instead.
*/
int mbedtls_md5_starts_ret( mbedtls_md5_context *ctx )
{
ctx->total[0] = 0;
ctx->total[1] = 0;
ctx->state[0] = 0x67452301;
ctx->state[1] = 0xEFCDAB89;
ctx->state[2] = 0x98BADCFE;
ctx->state[3] = 0x10325476;
return( 0 );
}
#if !defined(MBEDTLS_MD5_PROCESS_ALT)
/**
* \brief MD5 process data block (internal use only)
*
* \param ctx MD5 context
* \param data buffer holding one block of data
*
* \return 0 if successful
*
* \warning MD5 is considered a weak message digest and its use
* constitutes a security risk. We recommend considering
* stronger message digests instead.
*
*/
int mbedtls_internal_md5_process( mbedtls_md5_context *ctx,
const unsigned char data[64] )
{
register uint32_t A, B, C, D;
#define S(x,n) \
( ( (x) << (n) ) | ( ( (x) & 0xFFFFFFFF) >> ( 32 - (n) ) ) )
#define P(a,b,c,d,k,s,t) \
a += F(b, c, d) + READ32LE(data + k * 4) + (t); \
a = S(a, s) + b
A = ctx->state[0];
B = ctx->state[1];
C = ctx->state[2];
D = ctx->state[3];
#define F(x,y,z) ((z) ^ ((x) & ((y) ^ (z))))
P( A, B, C, D, 0, 7, 0xD76AA478 );
P( D, A, B, C, 1, 12, 0xE8C7B756 );
P( C, D, A, B, 2, 17, 0x242070DB );
P( B, C, D, A, 3, 22, 0xC1BDCEEE );
P( A, B, C, D, 4, 7, 0xF57C0FAF );
P( D, A, B, C, 5, 12, 0x4787C62A );
P( C, D, A, B, 6, 17, 0xA8304613 );
P( B, C, D, A, 7, 22, 0xFD469501 );
P( A, B, C, D, 8, 7, 0x698098D8 );
P( D, A, B, C, 9, 12, 0x8B44F7AF );
P( C, D, A, B, 10, 17, 0xFFFF5BB1 );
P( B, C, D, A, 11, 22, 0x895CD7BE );
P( A, B, C, D, 12, 7, 0x6B901122 );
P( D, A, B, C, 13, 12, 0xFD987193 );
P( C, D, A, B, 14, 17, 0xA679438E );
P( B, C, D, A, 15, 22, 0x49B40821 );
#undef F
#define F(x,y,z) ((y) ^ ((z) & ((x) ^ (y))))
P( A, B, C, D, 1, 5, 0xF61E2562 );
P( D, A, B, C, 6, 9, 0xC040B340 );
P( C, D, A, B, 11, 14, 0x265E5A51 );
P( B, C, D, A, 0, 20, 0xE9B6C7AA );
P( A, B, C, D, 5, 5, 0xD62F105D );
P( D, A, B, C, 10, 9, 0x02441453 );
P( C, D, A, B, 15, 14, 0xD8A1E681 );
P( B, C, D, A, 4, 20, 0xE7D3FBC8 );
P( A, B, C, D, 9, 5, 0x21E1CDE6 );
P( D, A, B, C, 14, 9, 0xC33707D6 );
P( C, D, A, B, 3, 14, 0xF4D50D87 );
P( B, C, D, A, 8, 20, 0x455A14ED );
P( A, B, C, D, 13, 5, 0xA9E3E905 );
P( D, A, B, C, 2, 9, 0xFCEFA3F8 );
P( C, D, A, B, 7, 14, 0x676F02D9 );
P( B, C, D, A, 12, 20, 0x8D2A4C8A );
#undef F
#define F(x,y,z) ((x) ^ (y) ^ (z))
P( A, B, C, D, 5, 4, 0xFFFA3942 );
P( D, A, B, C, 8, 11, 0x8771F681 );
P( C, D, A, B, 11, 16, 0x6D9D6122 );
P( B, C, D, A, 14, 23, 0xFDE5380C );
P( A, B, C, D, 1, 4, 0xA4BEEA44 );
P( D, A, B, C, 4, 11, 0x4BDECFA9 );
P( C, D, A, B, 7, 16, 0xF6BB4B60 );
P( B, C, D, A, 10, 23, 0xBEBFBC70 );
P( A, B, C, D, 13, 4, 0x289B7EC6 );
P( D, A, B, C, 0, 11, 0xEAA127FA );
P( C, D, A, B, 3, 16, 0xD4EF3085 );
P( B, C, D, A, 6, 23, 0x04881D05 );
P( A, B, C, D, 9, 4, 0xD9D4D039 );
P( D, A, B, C, 12, 11, 0xE6DB99E5 );
P( C, D, A, B, 15, 16, 0x1FA27CF8 );
P( B, C, D, A, 2, 23, 0xC4AC5665 );
#undef F
#define F(x,y,z) ((y) ^ ((x) | ~(z)))
P( A, B, C, D, 0, 6, 0xF4292244 );
P( D, A, B, C, 7, 10, 0x432AFF97 );
P( C, D, A, B, 14, 15, 0xAB9423A7 );
P( B, C, D, A, 5, 21, 0xFC93A039 );
P( A, B, C, D, 12, 6, 0x655B59C3 );
P( D, A, B, C, 3, 10, 0x8F0CCC92 );
P( C, D, A, B, 10, 15, 0xFFEFF47D );
P( B, C, D, A, 1, 21, 0x85845DD1 );
P( A, B, C, D, 8, 6, 0x6FA87E4F );
P( D, A, B, C, 15, 10, 0xFE2CE6E0 );
P( C, D, A, B, 6, 15, 0xA3014314 );
P( B, C, D, A, 13, 21, 0x4E0811A1 );
P( A, B, C, D, 4, 6, 0xF7537E82 );
P( D, A, B, C, 11, 10, 0xBD3AF235 );
P( C, D, A, B, 2, 15, 0x2AD7D2BB );
P( B, C, D, A, 9, 21, 0xEB86D391 );
#undef F
ctx->state[0] += A;
ctx->state[1] += B;
ctx->state[2] += C;
ctx->state[3] += D;
return( 0 );
}
#endif /* !MBEDTLS_MD5_PROCESS_ALT */
/**
* \brief MD5 process buffer
*
* \param ctx MD5 context
* \param input buffer holding the data
* \param ilen length of the input data
*
* \return 0 if successful
*
* \warning MD5 is considered a weak message digest and its use
* constitutes a security risk. We recommend considering
* stronger message digests instead.
*/
int mbedtls_md5_update_ret( mbedtls_md5_context *ctx,
const unsigned char *input,
size_t ilen )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t fill;
uint32_t left;
if( ilen == 0 )
return( 0 );
left = ctx->total[0] & 0x3F;
fill = 64 - left;
ctx->total[0] += (uint32_t) ilen;
ctx->total[0] &= 0xFFFFFFFF;
if( ctx->total[0] < (uint32_t) ilen )
ctx->total[1]++;
if( left && ilen >= fill )
{
memcpy( (void *) (ctx->buffer + left), input, fill );
if( ( ret = mbedtls_internal_md5_process( ctx, ctx->buffer ) ) != 0 )
return( ret );
input += fill;
ilen -= fill;
left = 0;
}
while( ilen >= 64 )
{
if( ( ret = mbedtls_internal_md5_process( ctx, input ) ) != 0 )
return( ret );
input += 64;
ilen -= 64;
}
if( ilen > 0 )
{
memcpy( (void *) (ctx->buffer + left), input, ilen );
}
return( 0 );
}
/**
* \brief MD5 final digest
*
* \param ctx MD5 context
* \param output MD5 checksum result
*
* \return 0 if successful
*
* \warning MD5 is considered a weak message digest and its use
* constitutes a security risk. We recommend considering
* stronger message digests instead.
*/
int mbedtls_md5_finish_ret( mbedtls_md5_context *ctx,
unsigned char output[16] )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
uint32_t used;
uint32_t high, low;
/*
* Add padding: 0x80 then 0x00 until 8 bytes remain for the length
*/
used = ctx->total[0] & 0x3F;
ctx->buffer[used++] = 0x80;
if( used <= 56 )
{
/* Enough room for padding + length in current block */
mbedtls_platform_zeroize( ctx->buffer + used, 56 - used );
}
else
{
/* We'll need an extra block */
mbedtls_platform_zeroize( ctx->buffer + used, 64 - used );
if( ( ret = mbedtls_internal_md5_process( ctx, ctx->buffer ) ) != 0 )
return( ret );
mbedtls_platform_zeroize( ctx->buffer, 56 );
}
/*
* Add message length
*/
high = ( ctx->total[0] >> 29 )
| ( ctx->total[1] << 3 );
low = ( ctx->total[0] << 3 );
PUT_UINT32_LE( low, ctx->buffer, 56 );
PUT_UINT32_LE( high, ctx->buffer, 60 );
if( ( ret = mbedtls_internal_md5_process( ctx, ctx->buffer ) ) != 0 )
return( ret );
/*
* Output final state
*/
PUT_UINT32_LE( ctx->state[0], output, 0 );
PUT_UINT32_LE( ctx->state[1], output, 4 );
PUT_UINT32_LE( ctx->state[2], output, 8 );
PUT_UINT32_LE( ctx->state[3], output, 12 );
return( 0 );
}
#endif /* !MBEDTLS_MD5_ALT */
/**
* \brief Output = MD5( input buffer )
*
* \param input buffer holding the data
* \param ilen length of the input data
* \param output MD5 checksum result
*
* \return 0 if successful
*
* \warning MD5 is considered a weak message digest and its use
* constitutes a security risk. We recommend considering
* stronger message digests instead.
*/
int mbedtls_md5_ret( const void *input,
size_t ilen,
unsigned char output[16] )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
mbedtls_md5_context ctx;
mbedtls_md5_init( &ctx );
if( ( ret = mbedtls_md5_starts_ret( &ctx ) ) != 0 )
goto exit;
if( ( ret = mbedtls_md5_update_ret( &ctx, input, ilen ) ) != 0 )
goto exit;
if( ( ret = mbedtls_md5_finish_ret( &ctx, output ) ) != 0 )
goto exit;
exit:
mbedtls_md5_free( &ctx );
return( ret );
}
const mbedtls_md_info_t mbedtls_md5_info = {
"MD5",
MBEDTLS_MD_MD5,
16,
64,
(void *)mbedtls_md5_starts_ret,
(void *)mbedtls_md5_update_ret,
(void *)mbedtls_internal_md5_process,
(void *)mbedtls_md5_finish_ret,
(void *)mbedtls_md5_ret,
};
| 12,619 | 403 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/platform.h | #ifndef COSMOPOLITAN_THIRD_PARTY_MBEDTLS_PLATFORM_H_
#define COSMOPOLITAN_THIRD_PARTY_MBEDTLS_PLATFORM_H_
#include "libc/assert.h"
#include "libc/fmt/fmt.h"
#include "libc/intrin/likely.h"
#include "libc/mem/mem.h"
#include "libc/runtime/runtime.h"
#include "libc/stdio/stdio.h"
#include "third_party/mbedtls/config.h"
COSMOPOLITAN_C_START_
#define MBEDTLS_EXIT_SUCCESS 0
#define MBEDTLS_EXIT_FAILURE 1
#define mbedtls_free free
#define mbedtls_calloc calloc
#define mbedtls_snprintf snprintf
#define mbedtls_vsnprintf vsnprintf
#define mbedtls_exit exit
#define mbedtls_time_t int64_t
#define mbedtls_time time
#define mbedtls_platform_gmtime_r gmtime_r
#define mbedtls_fprintf(...) ((void)0)
#define mbedtls_printf(...) ((void)0)
#ifdef MBEDTLS_CHECK_PARAMS
#define MBEDTLS_PARAM_FAILED(cond) \
mbedtls_param_failed(#cond, __FILE__, __LINE__)
#else
#define MBEDTLS_PARAM_FAILED(cond) unreachable
#endif
#define MBEDTLS_INTERNAL_VALIDATE_RET(cond, ret) \
do { \
if (UNLIKELY(!(cond))) { \
MBEDTLS_PARAM_FAILED(cond); \
return ret; \
} \
} while (0)
#define MBEDTLS_INTERNAL_VALIDATE(cond) \
do { \
if (UNLIKELY(!(cond))) { \
MBEDTLS_PARAM_FAILED(cond); \
return; \
} \
} while (0)
#if IsModeDbg()
#define MBEDTLS_ASSERT(EXPR) \
((void)((EXPR) || (__assert_fail(#EXPR, __FILE__, __LINE__), 0)))
#else
#define MBEDTLS_ASSERT(EXPR) _unassert(EXPR)
#endif
typedef struct mbedtls_platform_context {
char dummy;
} mbedtls_platform_context;
void mbedtls_platform_zeroize(void *, size_t);
int mbedtls_platform_setup(mbedtls_platform_context *);
void mbedtls_platform_teardown(mbedtls_platform_context *);
void mbedtls_param_failed(const char *, const char *, int) relegated;
COSMOPOLITAN_C_END_
#endif /* COSMOPOLITAN_THIRD_PARTY_MBEDTLS_PLATFORM_H_ */
| 2,150 | 68 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/ssl.h | #ifndef COSMOPOLITAN_THIRD_PARTY_MBEDTLS_SSL_H_
#define COSMOPOLITAN_THIRD_PARTY_MBEDTLS_SSL_H_
#include "third_party/mbedtls/bignum.h"
#include "third_party/mbedtls/config.h"
#include "third_party/mbedtls/dhm.h"
#include "third_party/mbedtls/ecdh.h"
#include "third_party/mbedtls/ecp.h"
#include "third_party/mbedtls/platform.h"
#include "third_party/mbedtls/ssl_ciphersuites.h"
#include "third_party/mbedtls/x509_crl.h"
#include "third_party/mbedtls/x509_crt.h"
COSMOPOLITAN_C_START_
/* clang-format off */
/*
* SSL Error codes
*/
#define MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE -0x7080 /*< The requested feature is not available. */
#define MBEDTLS_ERR_SSL_BAD_INPUT_DATA -0x7100 /*< Bad input parameters to function. */
#define MBEDTLS_ERR_SSL_INVALID_MAC -0x7180 /*< Verification of the message MAC failed. */
#define MBEDTLS_ERR_SSL_INVALID_RECORD -0x7200 /*< An invalid SSL record was received. */
#define MBEDTLS_ERR_SSL_CONN_EOF -0x7280 /*< The connection indicated an EOF. */
#define MBEDTLS_ERR_SSL_UNKNOWN_CIPHER -0x7300 /*< An unknown cipher was received. */
#define MBEDTLS_ERR_SSL_NO_CIPHER_CHOSEN -0x7380 /*< The server has no ciphersuites in common with the client. */
#define MBEDTLS_ERR_SSL_NO_RNG -0x7400 /*< No RNG was provided to the SSL module. */
#define MBEDTLS_ERR_SSL_NO_CLIENT_CERTIFICATE -0x7480 /*< No client certification received from the client, but required by the authentication mode. */
#define MBEDTLS_ERR_SSL_CERTIFICATE_TOO_LARGE -0x7500 /*< Our own certificate(s) is/are too large to send in an SSL message. */
#define MBEDTLS_ERR_SSL_CERTIFICATE_REQUIRED -0x7580 /*< The own certificate is not set, but needed by the server. */
#define MBEDTLS_ERR_SSL_PRIVATE_KEY_REQUIRED -0x7600 /*< The own private key or pre-shared key is not set, but needed. */
#define MBEDTLS_ERR_SSL_CA_CHAIN_REQUIRED -0x7680 /*< No CA Chain is set, but required to operate. */
#define MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE -0x7700 /*< An unexpected message was received from our peer. */
#define MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE -0x7780 /*< A fatal alert message was received from our peer. */
#define MBEDTLS_ERR_SSL_PEER_VERIFY_FAILED -0x7800 /*< Verification of our peer failed. */
#define MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY -0x7880 /*< The peer notified us that the connection is going to be closed. */
#define MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO -0x7900 /*< Processing of the ClientHello handshake message failed. */
#define MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO -0x7980 /*< Processing of the ServerHello handshake message failed. */
#define MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE -0x7A00 /*< Processing of the Certificate handshake message failed. */
#define MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_REQUEST -0x7A80 /*< Processing of the CertificateRequest handshake message failed. */
#define MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE -0x7B00 /*< Processing of the ServerKeyExchange handshake message failed. */
#define MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO_DONE -0x7B80 /*< Processing of the ServerHelloDone handshake message failed. */
#define MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE -0x7C00 /*< Processing of the ClientKeyExchange handshake message failed. */
#define MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_RP -0x7C80 /*< Processing of the ClientKeyExchange handshake message failed in DHM / ECDH Read Public. */
#define MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_CS -0x7D00 /*< Processing of the ClientKeyExchange handshake message failed in DHM / ECDH Calculate Secret. */
#define MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_VERIFY -0x7D80 /*< Processing of the CertificateVerify handshake message failed. */
#define MBEDTLS_ERR_SSL_BAD_HS_CHANGE_CIPHER_SPEC -0x7E00 /*< Processing of the ChangeCipherSpec handshake message failed. */
#define MBEDTLS_ERR_SSL_BAD_HS_FINISHED -0x7E80 /*< Processing of the Finished handshake message failed. */
#define MBEDTLS_ERR_SSL_ALLOC_FAILED -0x7F00 /*< Memory allocation failed */
#define MBEDTLS_ERR_SSL_HW_ACCEL_FAILED -0x7F80 /*< Hardware acceleration function returned with error */
#define MBEDTLS_ERR_SSL_HW_ACCEL_FALLTHROUGH -0x6F80 /*< Hardware acceleration function skipped / left alone data */
#define MBEDTLS_ERR_SSL_COMPRESSION_FAILED -0x6F00 /*< Processing of the compression / decompression failed */
#define MBEDTLS_ERR_SSL_BAD_HS_PROTOCOL_VERSION -0x6E80 /*< Handshake protocol not within min/max boundaries */
#define MBEDTLS_ERR_SSL_BAD_HS_NEW_SESSION_TICKET -0x6E00 /*< Processing of the NewSessionTicket handshake message failed. */
#define MBEDTLS_ERR_SSL_SESSION_TICKET_EXPIRED -0x6D80 /*< Session ticket has expired. */
#define MBEDTLS_ERR_SSL_PK_TYPE_MISMATCH -0x6D00 /*< Public key type mismatch (eg, asked for RSA key exchange and presented EC key) */
#define MBEDTLS_ERR_SSL_UNKNOWN_IDENTITY -0x6C80 /*< Unknown identity received (eg, PSK identity) */
#define MBEDTLS_ERR_SSL_INTERNAL_ERROR -0x6C00 /*< Internal error (eg, unexpected failure in lower-level module) */
#define MBEDTLS_ERR_SSL_COUNTER_WRAPPING -0x6B80 /*< A counter would wrap (eg, too many messages exchanged). */
#define MBEDTLS_ERR_SSL_WAITING_SERVER_HELLO_RENEGO -0x6B00 /*< Unexpected message at ServerHello in renegotiation. */
#define MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED -0x6A80 /*< DTLS client must retry for hello verification */
#define MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL -0x6A00 /*< A buffer is too small to receive or write a message */
#define MBEDTLS_ERR_SSL_NO_USABLE_CIPHERSUITE -0x6980 /*< None of the common ciphersuites is usable (eg, no suitable certificate, see debug messages). */
#define MBEDTLS_ERR_SSL_WANT_READ -0x6900 /*< No data of requested type currently available on underlying transport. */
#define MBEDTLS_ERR_SSL_WANT_WRITE -0x6880 /*< Connection requires a write call. */
#define MBEDTLS_ERR_SSL_TIMEOUT -0x6800 /*< The operation timed out. */
#define MBEDTLS_ERR_SSL_CLIENT_RECONNECT -0x6780 /*< The client initiated a reconnect from the same port. */
#define MBEDTLS_ERR_SSL_UNEXPECTED_RECORD -0x6700 /*< Record header looks valid but is not expected. */
#define MBEDTLS_ERR_SSL_NON_FATAL -0x6680 /*< The alert message received indicates a non-fatal error. */
#define MBEDTLS_ERR_SSL_INVALID_VERIFY_HASH -0x6600 /*< Couldn't set the hash for verifying CertificateVerify */
#define MBEDTLS_ERR_SSL_CONTINUE_PROCESSING -0x6580 /*< Internal-only message signaling that further message-processing should be done */
#define MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS -0x6500 /*< The asynchronous operation is not completed yet. */
#define MBEDTLS_ERR_SSL_EARLY_MESSAGE -0x6480 /*< Internal-only message signaling that a message arrived early. */
#define MBEDTLS_ERR_SSL_UNEXPECTED_CID -0x6000 /*< An encrypted DTLS-frame with an unexpected CID was received. */
#define MBEDTLS_ERR_SSL_VERSION_MISMATCH -0x5F00 /*< An operation failed due to an unexpected version or configuration. */
#define MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS -0x7000 /*< A cryptographic operation is in progress. Try again later. */
#define MBEDTLS_ERR_SSL_BAD_CONFIG -0x5E80 /*< Invalid value in SSL config */
/*
* Various constants
*/
#define MBEDTLS_SSL_MAJOR_VERSION_3 3
#define MBEDTLS_SSL_MINOR_VERSION_0 0 /*!< SSL v3.0 */
#define MBEDTLS_SSL_MINOR_VERSION_1 1 /*!< TLS v1.0 */
#define MBEDTLS_SSL_MINOR_VERSION_2 2 /*!< TLS v1.1 */
#define MBEDTLS_SSL_MINOR_VERSION_3 3 /*!< TLS v1.2 */
#define MBEDTLS_SSL_MINOR_VERSION_4 4 /*!< TLS v1.3 (experimental) */
#define MBEDTLS_SSL_TRANSPORT_STREAM 0 /*!< TLS */
#define MBEDTLS_SSL_TRANSPORT_DATAGRAM 1 /*!< DTLS */
#define MBEDTLS_SSL_MAX_HOST_NAME_LEN 255 /*!< Maximum host name defined in RFC 1035 */
#define MBEDTLS_SSL_MAX_ALPN_NAME_LEN 255 /*!< Maximum size in bytes of a protocol name in alpn ext., RFC 7301 */
#define MBEDTLS_SSL_MAX_ALPN_LIST_LEN 65535 /*!< Maximum size in bytes of list in alpn ext., RFC 7301 */
/* RFC 6066 section 4, see also mfl_code_to_length in ssl_tls.c
* NONE must be zero so that memset()ing structure to zero works */
#define MBEDTLS_SSL_MAX_FRAG_LEN_NONE 0 /*!< don't use this extension */
#define MBEDTLS_SSL_MAX_FRAG_LEN_512 1 /*!< MaxFragmentLength 2^9 */
#define MBEDTLS_SSL_MAX_FRAG_LEN_1024 2 /*!< MaxFragmentLength 2^10 */
#define MBEDTLS_SSL_MAX_FRAG_LEN_2048 3 /*!< MaxFragmentLength 2^11 */
#define MBEDTLS_SSL_MAX_FRAG_LEN_4096 4 /*!< MaxFragmentLength 2^12 */
#define MBEDTLS_SSL_MAX_FRAG_LEN_INVALID 5 /*!< first invalid value */
#define MBEDTLS_SSL_IS_CLIENT 0
#define MBEDTLS_SSL_IS_SERVER 1
#define MBEDTLS_SSL_IS_NOT_FALLBACK 0
#define MBEDTLS_SSL_IS_FALLBACK 1
#define MBEDTLS_SSL_EXTENDED_MS_DISABLED 0
#define MBEDTLS_SSL_EXTENDED_MS_ENABLED 1
#define MBEDTLS_SSL_CID_DISABLED 0
#define MBEDTLS_SSL_CID_ENABLED 1
#define MBEDTLS_SSL_ETM_DISABLED 0
#define MBEDTLS_SSL_ETM_ENABLED 1
#define MBEDTLS_SSL_COMPRESS_NULL 0
#define MBEDTLS_SSL_COMPRESS_DEFLATE 1
#define MBEDTLS_SSL_VERIFY_NONE 0
#define MBEDTLS_SSL_VERIFY_OPTIONAL 1
#define MBEDTLS_SSL_VERIFY_REQUIRED 2
#define MBEDTLS_SSL_VERIFY_UNSET 3 /* Used only for sni_authmode */
#define MBEDTLS_SSL_LEGACY_RENEGOTIATION 0
#define MBEDTLS_SSL_SECURE_RENEGOTIATION 1
#define MBEDTLS_SSL_RENEGOTIATION_DISABLED 0
#define MBEDTLS_SSL_RENEGOTIATION_ENABLED 1
#define MBEDTLS_SSL_ANTI_REPLAY_DISABLED 0
#define MBEDTLS_SSL_ANTI_REPLAY_ENABLED 1
#define MBEDTLS_SSL_RENEGOTIATION_NOT_ENFORCED -1
#define MBEDTLS_SSL_RENEGO_MAX_RECORDS_DEFAULT 16
#define MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION 0
#define MBEDTLS_SSL_LEGACY_ALLOW_RENEGOTIATION 1
#define MBEDTLS_SSL_LEGACY_BREAK_HANDSHAKE 2
#define MBEDTLS_SSL_TRUNC_HMAC_DISABLED 0
#define MBEDTLS_SSL_TRUNC_HMAC_ENABLED 1
#define MBEDTLS_SSL_TRUNCATED_HMAC_LEN 10 /* 80 bits, rfc 6066 section 7 */
#define MBEDTLS_SSL_SESSION_TICKETS_DISABLED 0
#define MBEDTLS_SSL_SESSION_TICKETS_ENABLED 1
#define MBEDTLS_SSL_CBC_RECORD_SPLITTING_DISABLED 0
#define MBEDTLS_SSL_CBC_RECORD_SPLITTING_ENABLED 1
#define MBEDTLS_SSL_ARC4_ENABLED 0
#define MBEDTLS_SSL_ARC4_DISABLED 1
#define MBEDTLS_SSL_PRESET_DEFAULT MBEDTLS_SSL_PRESET_SUITEC
#define MBEDTLS_SSL_PRESET_SUITEB 2
#define MBEDTLS_SSL_PRESET_SUITEC 0
#define MBEDTLS_SSL_CERT_REQ_CA_LIST_ENABLED 1
#define MBEDTLS_SSL_CERT_REQ_CA_LIST_DISABLED 0
#define MBEDTLS_SSL_DTLS_SRTP_MKI_UNSUPPORTED 0
#define MBEDTLS_SSL_DTLS_SRTP_MKI_SUPPORTED 1
#define MBEDTLS_SSL_UNEXPECTED_CID_IGNORE 0
#define MBEDTLS_SSL_UNEXPECTED_CID_FAIL 1
/*
* Default range for DTLS retransmission timer value, in milliseconds.
* RFC 6347 4.2.4.1 says from 1 second to 60 seconds.
*/
#define MBEDTLS_SSL_DTLS_TIMEOUT_DFL_MIN 1000
#define MBEDTLS_SSL_DTLS_TIMEOUT_DFL_MAX 60000
/**
* \name SECTION: Module settings
*
* The configuration options you can set for this module are in this section.
* Either change them in config.h or define them on the compiler command line.
* \{
*/
#if !defined(MBEDTLS_SSL_DEFAULT_TICKET_LIFETIME)
#define MBEDTLS_SSL_DEFAULT_TICKET_LIFETIME 86400 /*< Lifetime of session tickets (if enabled) */
#endif
/*
* Maximum fragment length in bytes,
* determines the size of each of the two internal I/O buffers.
*
* Note: the RFC defines the default size of SSL / TLS messages. If you
* change the value here, other clients / servers may not be able to
* communicate with you anymore. Only change this value if you control
* both sides of the connection and have it reduced at both sides, or
* if you're using the Max Fragment Length extension and you know all your
* peers are using it too!
*/
#if !defined(MBEDTLS_SSL_MAX_CONTENT_LEN)
#define MBEDTLS_SSL_MAX_CONTENT_LEN 16384 /*< Size of the input / output buffer */
#endif
#if !defined(MBEDTLS_SSL_IN_CONTENT_LEN)
#define MBEDTLS_SSL_IN_CONTENT_LEN MBEDTLS_SSL_MAX_CONTENT_LEN
#endif
#if !defined(MBEDTLS_SSL_OUT_CONTENT_LEN)
#define MBEDTLS_SSL_OUT_CONTENT_LEN MBEDTLS_SSL_MAX_CONTENT_LEN
#endif
/*
* Maximum number of heap-allocated bytes for the purpose of
* DTLS handshake message reassembly and future message buffering.
*/
#if !defined(MBEDTLS_SSL_DTLS_MAX_BUFFERING)
#define MBEDTLS_SSL_DTLS_MAX_BUFFERING 32768
#endif
/*
* Maximum length of CIDs for incoming and outgoing messages.
*/
#if !defined(MBEDTLS_SSL_CID_IN_LEN_MAX)
#define MBEDTLS_SSL_CID_IN_LEN_MAX 32
#endif
#if !defined(MBEDTLS_SSL_CID_OUT_LEN_MAX)
#define MBEDTLS_SSL_CID_OUT_LEN_MAX 32
#endif
#if !defined(MBEDTLS_SSL_CID_PADDING_GRANULARITY)
#define MBEDTLS_SSL_CID_PADDING_GRANULARITY 16
#endif
#if !defined(MBEDTLS_SSL_TLS1_3_PADDING_GRANULARITY)
#define MBEDTLS_SSL_TLS1_3_PADDING_GRANULARITY 1
#endif
/*
* Length of the verify data for secure renegotiation
*/
#if defined(MBEDTLS_SSL_PROTO_SSL3)
#define MBEDTLS_SSL_VERIFY_DATA_MAX_LEN 36
#else
#define MBEDTLS_SSL_VERIFY_DATA_MAX_LEN 12
#endif
/*
* Signaling ciphersuite values (SCSV)
*/
#define MBEDTLS_SSL_EMPTY_RENEGOTIATION_INFO 0xFF /*< renegotiation info ext */
#define MBEDTLS_SSL_FALLBACK_SCSV_VALUE 0x5600 /*< RFC 7507 section 2 */
/*
* Supported Signature and Hash algorithms (For TLS 1.2)
* RFC 5246 section 7.4.1.4.1
*/
#define MBEDTLS_SSL_HASH_NONE 0
#define MBEDTLS_SSL_HASH_MD5 1
#define MBEDTLS_SSL_HASH_SHA1 2
#define MBEDTLS_SSL_HASH_SHA224 3
#define MBEDTLS_SSL_HASH_SHA256 4
#define MBEDTLS_SSL_HASH_SHA384 5
#define MBEDTLS_SSL_HASH_SHA512 6
#define MBEDTLS_SSL_SIG_ANON 0
#define MBEDTLS_SSL_SIG_RSA 1
#define MBEDTLS_SSL_SIG_ECDSA 3
/*
* Client Certificate Types
* RFC 5246 section 7.4.4 plus RFC 4492 section 5.5
*/
#define MBEDTLS_SSL_CERT_TYPE_RSA_SIGN 1
#define MBEDTLS_SSL_CERT_TYPE_ECDSA_SIGN 64
/*
* Message, alert and handshake types
*/
#define MBEDTLS_SSL_MSG_CHANGE_CIPHER_SPEC 20
#define MBEDTLS_SSL_MSG_ALERT 21
#define MBEDTLS_SSL_MSG_HANDSHAKE 22
#define MBEDTLS_SSL_MSG_APPLICATION_DATA 23
#define MBEDTLS_SSL_MSG_CID 25
#define MBEDTLS_SSL_ALERT_LEVEL_WARNING 1
#define MBEDTLS_SSL_ALERT_LEVEL_FATAL 2
#define MBEDTLS_SSL_ALERT_MSG_CLOSE_NOTIFY 0 /* 0x00 */
#define MBEDTLS_SSL_ALERT_MSG_UNEXPECTED_MESSAGE 10 /* 0x0A */
#define MBEDTLS_SSL_ALERT_MSG_BAD_RECORD_MAC 20 /* 0x14 */
#define MBEDTLS_SSL_ALERT_MSG_DECRYPTION_FAILED 21 /* 0x15 */
#define MBEDTLS_SSL_ALERT_MSG_RECORD_OVERFLOW 22 /* 0x16 */
#define MBEDTLS_SSL_ALERT_MSG_DECOMPRESSION_FAILURE 30 /* 0x1E */
#define MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE 40 /* 0x28 */
#define MBEDTLS_SSL_ALERT_MSG_NO_CERT 41 /* 0x29 */
#define MBEDTLS_SSL_ALERT_MSG_BAD_CERT 42 /* 0x2A */
#define MBEDTLS_SSL_ALERT_MSG_UNSUPPORTED_CERT 43 /* 0x2B */
#define MBEDTLS_SSL_ALERT_MSG_CERT_REVOKED 44 /* 0x2C */
#define MBEDTLS_SSL_ALERT_MSG_CERT_EXPIRED 45 /* 0x2D */
#define MBEDTLS_SSL_ALERT_MSG_CERT_UNKNOWN 46 /* 0x2E */
#define MBEDTLS_SSL_ALERT_MSG_ILLEGAL_PARAMETER 47 /* 0x2F */
#define MBEDTLS_SSL_ALERT_MSG_UNKNOWN_CA 48 /* 0x30 */
#define MBEDTLS_SSL_ALERT_MSG_ACCESS_DENIED 49 /* 0x31 */
#define MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR 50 /* 0x32 */
#define MBEDTLS_SSL_ALERT_MSG_DECRYPT_ERROR 51 /* 0x33 */
#define MBEDTLS_SSL_ALERT_MSG_EXPORT_RESTRICTION 60 /* 0x3C */
#define MBEDTLS_SSL_ALERT_MSG_PROTOCOL_VERSION 70 /* 0x46 */
#define MBEDTLS_SSL_ALERT_MSG_INSUFFICIENT_SECURITY 71 /* 0x47 */
#define MBEDTLS_SSL_ALERT_MSG_INTERNAL_ERROR 80 /* 0x50 */
#define MBEDTLS_SSL_ALERT_MSG_INAPROPRIATE_FALLBACK 86 /* 0x56 */
#define MBEDTLS_SSL_ALERT_MSG_USER_CANCELED 90 /* 0x5A */
#define MBEDTLS_SSL_ALERT_MSG_NO_RENEGOTIATION 100 /* 0x64 */
#define MBEDTLS_SSL_ALERT_MSG_UNSUPPORTED_EXT 110 /* 0x6E */
#define MBEDTLS_SSL_ALERT_MSG_UNRECOGNIZED_NAME 112 /* 0x70 */
#define MBEDTLS_SSL_ALERT_MSG_UNKNOWN_PSK_IDENTITY 115 /* 0x73 */
#define MBEDTLS_SSL_ALERT_MSG_NO_APPLICATION_PROTOCOL 120 /* 0x78 */
#define MBEDTLS_SSL_HS_HELLO_REQUEST 0
#define MBEDTLS_SSL_HS_CLIENT_HELLO 1
#define MBEDTLS_SSL_HS_SERVER_HELLO 2
#define MBEDTLS_SSL_HS_HELLO_VERIFY_REQUEST 3
#define MBEDTLS_SSL_HS_NEW_SESSION_TICKET 4
#define MBEDTLS_SSL_HS_CERTIFICATE 11
#define MBEDTLS_SSL_HS_SERVER_KEY_EXCHANGE 12
#define MBEDTLS_SSL_HS_CERTIFICATE_REQUEST 13
#define MBEDTLS_SSL_HS_SERVER_HELLO_DONE 14
#define MBEDTLS_SSL_HS_CERTIFICATE_VERIFY 15
#define MBEDTLS_SSL_HS_CLIENT_KEY_EXCHANGE 16
#define MBEDTLS_SSL_HS_FINISHED 20
/*
* TLS extensions
*/
#define MBEDTLS_TLS_EXT_SERVERNAME 0
#define MBEDTLS_TLS_EXT_SERVERNAME_HOSTNAME 0
#define MBEDTLS_TLS_EXT_MAX_FRAGMENT_LENGTH 1
#define MBEDTLS_TLS_EXT_TRUNCATED_HMAC 4
#define MBEDTLS_TLS_EXT_SUPPORTED_ELLIPTIC_CURVES 10
#define MBEDTLS_TLS_EXT_SUPPORTED_POINT_FORMATS 11
#define MBEDTLS_TLS_EXT_SIG_ALG 13
#define MBEDTLS_TLS_EXT_USE_SRTP 14
#define MBEDTLS_TLS_EXT_ALPN 16
#define MBEDTLS_TLS_EXT_ENCRYPT_THEN_MAC 22 /* 0x16 */
#define MBEDTLS_TLS_EXT_EXTENDED_MASTER_SECRET 0x0017 /* 23 */
#define MBEDTLS_TLS_EXT_SESSION_TICKET 35
/* The value of the CID extension is still TBD as of
* draft-ietf-tls-dtls-connection-id-05
* (https://tools.ietf.org/html/draft-ietf-tls-dtls-connection-id-05) */
#define MBEDTLS_TLS_EXT_CID 254 /* TBD */
#define MBEDTLS_TLS_EXT_ECJPAKE_KKPP 256 /* experimental */
#define MBEDTLS_TLS_EXT_RENEGOTIATION_INFO 0xFF01
/*
* Size defines
*/
#if !defined(MBEDTLS_PSK_MAX_LEN)
#define MBEDTLS_PSK_MAX_LEN 32 /* 256 bits */
#endif
/* Dummy type used only for its size */
union mbedtls_ssl_premaster_secret
{
#if defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED)
unsigned char _pms_rsa[48]; /* RFC 5246 8.1.1 */
#endif
#if defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED)
unsigned char _pms_dhm[MBEDTLS_MPI_MAX_SIZE]; /* RFC 5246 8.1.2 */
#endif
#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED) || \
defined(MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED) || \
defined(MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
unsigned char _pms_ecdh[MBEDTLS_ECP_MAX_BYTES]; /* RFC 4492 5.10 */
#endif
#if defined(MBEDTLS_KEY_EXCHANGE_PSK_ENABLED)
unsigned char _pms_psk[4 + 2 * MBEDTLS_PSK_MAX_LEN]; /* RFC 4279 2 */
#endif
#if defined(MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED)
unsigned char _pms_dhe_psk[4 + MBEDTLS_MPI_MAX_SIZE
+ MBEDTLS_PSK_MAX_LEN]; /* RFC 4279 3 */
#endif
#if defined(MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED)
unsigned char _pms_rsa_psk[52 + MBEDTLS_PSK_MAX_LEN]; /* RFC 4279 4 */
#endif
#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED)
unsigned char _pms_ecdhe_psk[4 + MBEDTLS_ECP_MAX_BYTES
+ MBEDTLS_PSK_MAX_LEN]; /* RFC 5489 2 */
#endif
#if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
unsigned char _pms_ecjpake[32]; /* Thread spec: SHA-256 output */
#endif
};
#define MBEDTLS_PREMASTER_SIZE sizeof( union mbedtls_ssl_premaster_secret )
/*
* SSL state machine
*/
typedef enum
{
MBEDTLS_SSL_HELLO_REQUEST,
MBEDTLS_SSL_CLIENT_HELLO,
MBEDTLS_SSL_SERVER_HELLO,
MBEDTLS_SSL_SERVER_CERTIFICATE,
MBEDTLS_SSL_SERVER_KEY_EXCHANGE,
MBEDTLS_SSL_CERTIFICATE_REQUEST,
MBEDTLS_SSL_SERVER_HELLO_DONE,
MBEDTLS_SSL_CLIENT_CERTIFICATE,
MBEDTLS_SSL_CLIENT_KEY_EXCHANGE,
MBEDTLS_SSL_CERTIFICATE_VERIFY,
MBEDTLS_SSL_CLIENT_CHANGE_CIPHER_SPEC,
MBEDTLS_SSL_CLIENT_FINISHED,
MBEDTLS_SSL_SERVER_CHANGE_CIPHER_SPEC,
MBEDTLS_SSL_SERVER_FINISHED,
MBEDTLS_SSL_FLUSH_BUFFERS,
MBEDTLS_SSL_HANDSHAKE_WRAPUP,
MBEDTLS_SSL_HANDSHAKE_OVER,
MBEDTLS_SSL_SERVER_NEW_SESSION_TICKET,
MBEDTLS_SSL_SERVER_HELLO_VERIFY_REQUEST_SENT,
}
mbedtls_ssl_states;
/*
* The tls_prf function types.
*/
typedef enum
{
MBEDTLS_SSL_TLS_PRF_NONE,
MBEDTLS_SSL_TLS_PRF_SSL3,
MBEDTLS_SSL_TLS_PRF_TLS1,
MBEDTLS_SSL_TLS_PRF_SHA384,
MBEDTLS_SSL_TLS_PRF_SHA256
}
mbedtls_tls_prf_types;
/**
* \brief Callback type: send data on the network.
*
* \note That callback may be either blocking or non-blocking.
*
* \param ctx Context for the send callback (typically a file descriptor)
* \param buf Buffer holding the data to send
* \param len Length of the data to send
*
* \return The callback must return the number of bytes sent if any,
* or a non-zero error code.
* If performing non-blocking I/O, \c MBEDTLS_ERR_SSL_WANT_WRITE
* must be returned when the operation would block.
*
* \note The callback is allowed to send fewer bytes than requested.
* It must always return the number of bytes actually sent.
*/
typedef int mbedtls_ssl_send_t( void *ctx,
const unsigned char *buf,
size_t len );
/**
* \brief Callback type: receive data from the network.
*
* \note That callback may be either blocking or non-blocking.
*
* \param ctx Context for the receive callback (typically a file
* descriptor)
* \param buf Buffer to write the received data to
* \param len Length of the receive buffer
*
* \return The callback must return the number of bytes received,
* or a non-zero error code.
* If performing non-blocking I/O, \c MBEDTLS_ERR_SSL_WANT_READ
* must be returned when the operation would block.
*
* \note The callback may receive fewer bytes than the length of the
* buffer. It must always return the number of bytes actually
* received and written to the buffer.
*/
typedef int mbedtls_ssl_recv_t( void *ctx,
unsigned char *buf,
size_t len );
/**
* \brief Callback type: receive data from the network, with timeout
*
* \note That callback must block until data is received, or the
* timeout delay expires, or the operation is interrupted by a
* signal.
*
* \param ctx Context for the receive callback (typically a file descriptor)
* \param buf Buffer to write the received data to
* \param len Length of the receive buffer
* \param timeout Maximum nomber of millisecondes to wait for data
* 0 means no timeout (potentially waiting forever)
*
* \return The callback must return the number of bytes received,
* or a non-zero error code:
* \c MBEDTLS_ERR_SSL_TIMEOUT if the operation timed out,
* \c MBEDTLS_ERR_SSL_WANT_READ if interrupted by a signal.
*
* \note The callback may receive fewer bytes than the length of the
* buffer. It must always return the number of bytes actually
* received and written to the buffer.
*/
typedef int mbedtls_ssl_recv_timeout_t( void *ctx,
unsigned char *buf,
size_t len,
uint32_t timeout );
/**
* \brief Callback type: set a pair of timers/delays to watch
*
* \param ctx Context pointer
* \param int_ms Intermediate delay in milliseconds
* \param fin_ms Final delay in milliseconds
* 0 cancels the current timer.
*
* \note This callback must at least store the necessary information
* for the associated \c mbedtls_ssl_get_timer_t callback to
* return correct information.
*
* \note If using a event-driven style of programming, an event must
* be generated when the final delay is passed. The event must
* cause a call to \c mbedtls_ssl_handshake() with the proper
* SSL context to be scheduled. Care must be taken to ensure
* that at most one such call happens at a time.
*
* \note Only one timer at a time must be running. Calling this
* function while a timer is running must cancel it. Cancelled
* timers must not generate any event.
*/
typedef void mbedtls_ssl_set_timer_t( void * ctx,
uint32_t int_ms,
uint32_t fin_ms );
/**
* \brief Callback type: get status of timers/delays
*
* \param ctx Context pointer
*
* \return This callback must return:
* -1 if cancelled (fin_ms == 0),
* 0 if none of the delays have passed,
* 1 if only the intermediate delay has passed,
* 2 if the final delay has passed.
*/
typedef int mbedtls_ssl_get_timer_t( void * ctx );
/* Defined below */
typedef struct mbedtls_ssl_session mbedtls_ssl_session;
typedef struct mbedtls_ssl_context mbedtls_ssl_context;
typedef struct mbedtls_ssl_config mbedtls_ssl_config;
/* Defined in ssl_internal.h */
typedef struct mbedtls_ssl_transform mbedtls_ssl_transform;
typedef struct mbedtls_ssl_handshake_params mbedtls_ssl_handshake_params;
typedef struct mbedtls_ssl_sig_hash_set_t mbedtls_ssl_sig_hash_set_t;
typedef struct mbedtls_ssl_key_cert mbedtls_ssl_key_cert;
typedef struct mbedtls_ssl_flight_item mbedtls_ssl_flight_item;
/**
* \brief Callback type: start external signature operation.
*
* This callback is called during an SSL handshake to start
* a signature decryption operation using an
* external processor. The parameter \p cert contains
* the public key; it is up to the callback function to
* determine how to access the associated private key.
*
* This function typically sends or enqueues a request, and
* does not wait for the operation to complete. This allows
* the handshake step to be non-blocking.
*
* The parameters \p ssl and \p cert are guaranteed to remain
* valid throughout the handshake. On the other hand, this
* function must save the contents of \p hash if the value
* is needed for later processing, because the \p hash buffer
* is no longer valid after this function returns.
*
* This function may call mbedtls_ssl_set_async_operation_data()
* to store an operation context for later retrieval
* by the resume or cancel callback.
*
* \note For RSA signatures, this function must produce output
* that is consistent with PKCS#1 v1.5 in the same way as
* mbedtls_rsa_pkcs1_sign(). Before the private key operation,
* apply the padding steps described in RFC 8017, section 9.2
* "EMSA-PKCS1-v1_5" as follows.
* - If \p md_alg is #MBEDTLS_MD_NONE, apply the PKCS#1 v1.5
* encoding, treating \p hash as the DigestInfo to be
* padded. In other words, apply EMSA-PKCS1-v1_5 starting
* from step 3, with `T = hash` and `tLen = hash_len`.
* - If `md_alg != MBEDTLS_MD_NONE`, apply the PKCS#1 v1.5
* encoding, treating \p hash as the hash to be encoded and
* padded. In other words, apply EMSA-PKCS1-v1_5 starting
* from step 2, with `digestAlgorithm` obtained by calling
* mbedtls_oid_get_oid_by_md() on \p md_alg.
*
* \note For ECDSA signatures, the output format is the DER encoding
* `Ecdsa-Sig-Value` defined in
* [RFC 4492 section 5.4](https://tools.ietf.org/html/rfc4492#section-5.4).
*
* \param ssl The SSL connection instance. It should not be
* modified other than via
* mbedtls_ssl_set_async_operation_data().
* \param cert Certificate containing the public key.
* In simple cases, this is one of the pointers passed to
* mbedtls_ssl_conf_own_cert() when configuring the SSL
* connection. However, if other callbacks are used, this
* property may not hold. For example, if an SNI callback
* is registered with mbedtls_ssl_conf_sni(), then
* this callback determines what certificate is used.
* \param md_alg Hash algorithm.
* \param hash Buffer containing the hash. This buffer is
* no longer valid when the function returns.
* \param hash_len Size of the \c hash buffer in bytes.
*
* \return 0 if the operation was started successfully and the SSL
* stack should call the resume callback immediately.
* \return #MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS if the operation
* was started successfully and the SSL stack should return
* immediately without calling the resume callback yet.
* \return #MBEDTLS_ERR_SSL_HW_ACCEL_FALLTHROUGH if the external
* processor does not support this key. The SSL stack will
* use the private key object instead.
* \return Any other error indicates a fatal failure and is
* propagated up the call chain. The callback should
* use \c MBEDTLS_ERR_PK_xxx error codes, and <b>must not</b>
* use \c MBEDTLS_ERR_SSL_xxx error codes except as
* directed in the documentation of this callback.
*/
typedef int mbedtls_ssl_async_sign_t( mbedtls_ssl_context *ssl,
mbedtls_x509_crt *cert,
mbedtls_md_type_t md_alg,
const unsigned char *hash,
size_t hash_len );
/**
* \brief Callback type: start external decryption operation.
*
* This callback is called during an SSL handshake to start
* an RSA decryption operation using an
* external processor. The parameter \p cert contains
* the public key; it is up to the callback function to
* determine how to access the associated private key.
*
* This function typically sends or enqueues a request, and
* does not wait for the operation to complete. This allows
* the handshake step to be non-blocking.
*
* The parameters \p ssl and \p cert are guaranteed to remain
* valid throughout the handshake. On the other hand, this
* function must save the contents of \p input if the value
* is needed for later processing, because the \p input buffer
* is no longer valid after this function returns.
*
* This function may call mbedtls_ssl_set_async_operation_data()
* to store an operation context for later retrieval
* by the resume or cancel callback.
*
* \warning RSA decryption as used in TLS is subject to a potential
* timing side channel attack first discovered by Bleichenbacher
* in 1998. This attack can be remotely exploitable
* in practice. To avoid this attack, you must ensure that
* if the callback performs an RSA decryption, the time it
* takes to execute and return the result does not depend
* on whether the RSA decryption succeeded or reported
* invalid padding.
*
* \param ssl The SSL connection instance. It should not be
* modified other than via
* mbedtls_ssl_set_async_operation_data().
* \param cert Certificate containing the public key.
* In simple cases, this is one of the pointers passed to
* mbedtls_ssl_conf_own_cert() when configuring the SSL
* connection. However, if other callbacks are used, this
* property may not hold. For example, if an SNI callback
* is registered with mbedtls_ssl_conf_sni(), then
* this callback determines what certificate is used.
* \param input Buffer containing the input ciphertext. This buffer
* is no longer valid when the function returns.
* \param input_len Size of the \p input buffer in bytes.
*
* \return 0 if the operation was started successfully and the SSL
* stack should call the resume callback immediately.
* \return #MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS if the operation
* was started successfully and the SSL stack should return
* immediately without calling the resume callback yet.
* \return #MBEDTLS_ERR_SSL_HW_ACCEL_FALLTHROUGH if the external
* processor does not support this key. The SSL stack will
* use the private key object instead.
* \return Any other error indicates a fatal failure and is
* propagated up the call chain. The callback should
* use \c MBEDTLS_ERR_PK_xxx error codes, and <b>must not</b>
* use \c MBEDTLS_ERR_SSL_xxx error codes except as
* directed in the documentation of this callback.
*/
typedef int mbedtls_ssl_async_decrypt_t( mbedtls_ssl_context *ssl,
mbedtls_x509_crt *cert,
const unsigned char *input,
size_t input_len );
/**
* \brief Callback type: resume external operation.
*
* This callback is called during an SSL handshake to resume
* an external operation started by the
* ::mbedtls_ssl_async_sign_t or
* ::mbedtls_ssl_async_decrypt_t callback.
*
* This function typically checks the status of a pending
* request or causes the request queue to make progress, and
* does not wait for the operation to complete. This allows
* the handshake step to be non-blocking.
*
* This function may call mbedtls_ssl_get_async_operation_data()
* to retrieve an operation context set by the start callback.
* It may call mbedtls_ssl_set_async_operation_data() to modify
* this context.
*
* Note that when this function returns a status other than
* #MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS, it must free any
* resources associated with the operation.
*
* \param ssl The SSL connection instance. It should not be
* modified other than via
* mbedtls_ssl_set_async_operation_data().
* \param output Buffer containing the output (signature or decrypted
* data) on success.
* \param output_len On success, number of bytes written to \p output.
* \param output_size Size of the \p output buffer in bytes.
*
* \return 0 if output of the operation is available in the
* \p output buffer.
* \return #MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS if the operation
* is still in progress. Subsequent requests for progress
* on the SSL connection will call the resume callback
* again.
* \return Any other error means that the operation is aborted.
* The SSL handshake is aborted. The callback should
* use \c MBEDTLS_ERR_PK_xxx error codes, and <b>must not</b>
* use \c MBEDTLS_ERR_SSL_xxx error codes except as
* directed in the documentation of this callback.
*/
typedef int mbedtls_ssl_async_resume_t( mbedtls_ssl_context *ssl,
unsigned char *output,
size_t *output_len,
size_t output_size );
/**
* \brief Callback type: cancel external operation.
*
* This callback is called if an SSL connection is closed
* while an asynchronous operation is in progress. Note that
* this callback is not called if the
* ::mbedtls_ssl_async_resume_t callback has run and has
* returned a value other than
* #MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS, since in that case
* the asynchronous operation has already completed.
*
* This function may call mbedtls_ssl_get_async_operation_data()
* to retrieve an operation context set by the start callback.
*
* \param ssl The SSL connection instance. It should not be
* modified.
*/
typedef void mbedtls_ssl_async_cancel_t( mbedtls_ssl_context *ssl );
#define MBEDTLS_TLS_SRTP_MAX_MKI_LENGTH 255
#define MBEDTLS_TLS_SRTP_MAX_PROFILE_LIST_LENGTH 4
/*
* For code readability use a typedef for DTLS-SRTP profiles
*
* Use_srtp extension protection profiles values as defined in
* http://www.iana.org/assignments/srtp-protection/srtp-protection.xhtml
*
* Reminder: if this list is expanded mbedtls_ssl_check_srtp_profile_value
* must be updated too.
*/
#define MBEDTLS_TLS_SRTP_AES128_CM_HMAC_SHA1_80 ( (uint16_t) 0x0001)
#define MBEDTLS_TLS_SRTP_AES128_CM_HMAC_SHA1_32 ( (uint16_t) 0x0002)
#define MBEDTLS_TLS_SRTP_NULL_HMAC_SHA1_80 ( (uint16_t) 0x0005)
#define MBEDTLS_TLS_SRTP_NULL_HMAC_SHA1_32 ( (uint16_t) 0x0006)
/* This one is not iana defined, but for code readability. */
#define MBEDTLS_TLS_SRTP_UNSET ( (uint16_t) 0x0000)
typedef uint16_t mbedtls_ssl_srtp_profile;
typedef struct mbedtls_dtls_srtp_info_t
{
/*! The SRTP profile that was negotiated. */
mbedtls_ssl_srtp_profile chosen_dtls_srtp_profile;
/*! The length of mki_value. */
uint16_t mki_len;
/*! The mki_value used, with max size of 256 bytes. */
unsigned char mki_value[MBEDTLS_TLS_SRTP_MAX_MKI_LENGTH];
}
mbedtls_dtls_srtp_info;
/*
* This structure is used for storing current session data.
*
* Note: when changing this definition, we need to check and update:
* - in tests/suites/test_suite_ssl.function:
* ssl_populate_session() and ssl_serialize_session_save_load()
* - in library/ssl_tls.c:
* mbedtls_ssl_session_init() and mbedtls_ssl_session_free()
* mbedtls_ssl_session_save() and ssl_session_load()
* ssl_session_copy()
*/
struct mbedtls_ssl_session
{
#if defined(MBEDTLS_HAVE_TIME)
mbedtls_time_t start; /*!< starting time */
#endif
int ciphersuite; /*!< chosen ciphersuite */
int compression; /*!< chosen compression */
size_t id_len; /*!< session id length */
unsigned char id[32]; /*!< session identifier */
unsigned char master[48]; /*!< the master secret */
#if defined(MBEDTLS_X509_CRT_PARSE_C)
#if defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
mbedtls_x509_crt *peer_cert; /*!< peer X.509 cert chain */
#else /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
/*! The digest of the peer's end-CRT. This must be kept to detect CRT
* changes during renegotiation, mitigating the triple handshake attack. */
unsigned char *peer_cert_digest;
size_t peer_cert_digest_len;
mbedtls_md_type_t peer_cert_digest_type;
#endif /* !MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
#endif /* MBEDTLS_X509_CRT_PARSE_C */
uint32_t verify_result; /*!< verification result */
#if defined(MBEDTLS_SSL_SESSION_TICKETS) && defined(MBEDTLS_SSL_CLI_C)
unsigned char *ticket; /*!< RFC 5077 session ticket */
size_t ticket_len; /*!< session ticket length */
uint32_t ticket_lifetime; /*!< ticket lifetime hint */
#endif /* MBEDTLS_SSL_SESSION_TICKETS && MBEDTLS_SSL_CLI_C */
#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
unsigned char mfl_code; /*!< MaxFragmentLength negotiated by peer */
#endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */
#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
int encrypt_then_mac; /*!< flag for EtM activation */
#endif
};
/**
* SSL/TLS configuration to be shared between mbedtls_ssl_context structures.
*/
struct mbedtls_ssl_config
{
/* Group items by size (largest first) to minimize padding overhead */
/*
* Pointers
*/
const uint16_t *ciphersuite_list[4]; /*!< allowed ciphersuites per version */
/** Callback to SSL handshake step */
int (*f_step)( mbedtls_ssl_context * );
/** Callback for printing debug output */
void (*f_dbg)(void *, int, const char *, int, const char *);
void *p_dbg; /*!< context for the debug function */
/** Callback for getting (pseudo-)random numbers */
int (*f_rng)(void *, unsigned char *, size_t);
void *p_rng; /*!< context for the RNG function */
/** Callback to retrieve a session from the cache */
int (*f_get_cache)(void *, mbedtls_ssl_session *);
/** Callback to store a session into the cache */
int (*f_set_cache)(void *, const mbedtls_ssl_session *);
void *p_cache; /*!< context for cache callbacks */
#if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
/** Callback for setting cert according to SNI extension */
int (*f_sni)(void *, mbedtls_ssl_context *, const unsigned char *, size_t);
void *p_sni; /*!< context for SNI callback */
#endif
#if defined(MBEDTLS_X509_CRT_PARSE_C)
/** Callback to customize X.509 certificate chain verification */
int (*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *);
void *p_vrfy; /*!< context for X.509 verify calllback */
#endif
#if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED)
/** Callback to retrieve PSK key from identity */
int (*f_psk)(void *, mbedtls_ssl_context *, const unsigned char *, size_t);
void *p_psk; /*!< context for PSK callback */
#endif
#if defined(MBEDTLS_SSL_DTLS_HELLO_VERIFY) && defined(MBEDTLS_SSL_SRV_C)
/** Callback to create & write a cookie for ClientHello veirifcation */
int (*f_cookie_write)( void *, unsigned char **, unsigned char *,
const unsigned char *, size_t );
/** Callback to verify validity of a ClientHello cookie */
int (*f_cookie_check)( void *, const unsigned char *, size_t,
const unsigned char *, size_t );
void *p_cookie; /*!< context for the cookie callbacks */
#endif
#if defined(MBEDTLS_SSL_SESSION_TICKETS) && defined(MBEDTLS_SSL_SRV_C)
/** Callback to create & write a session ticket */
int (*f_ticket_write)( void *, const mbedtls_ssl_session *,
unsigned char *, const unsigned char *, size_t *, uint32_t * );
/** Callback to parse a session ticket into a session structure */
int (*f_ticket_parse)( void *, mbedtls_ssl_session *, unsigned char *, size_t);
void *p_ticket; /*!< context for the ticket callbacks */
#endif /* MBEDTLS_SSL_SESSION_TICKETS && MBEDTLS_SSL_SRV_C */
#if defined(MBEDTLS_SSL_EXPORT_KEYS)
/** Callback to export key block and master secret */
int (*f_export_keys)( void *, const unsigned char *,
const unsigned char *, size_t, size_t, size_t );
/** Callback to export key block, master secret,
* tls_prf and random bytes. Should replace f_export_keys */
int (*f_export_keys_ext)( void *, const unsigned char *,
const unsigned char *, size_t, size_t, size_t,
const unsigned char[32], const unsigned char[32],
mbedtls_tls_prf_types );
void *p_export_keys; /*!< context for key export callback */
#endif
#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
size_t cid_len; /*!< The length of CIDs for incoming DTLS records. */
#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
#if defined(MBEDTLS_X509_CRT_PARSE_C)
const mbedtls_x509_crt_profile *cert_profile; /*!< verification profile */
mbedtls_ssl_key_cert *key_cert; /*!< own certificate/key pair(s) */
mbedtls_x509_crt *ca_chain; /*!< trusted CAs */
mbedtls_x509_crl *ca_crl; /*!< trusted CAs CRLs */
#if defined(MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK)
mbedtls_x509_crt_ca_cb_t f_ca_cb;
void *p_ca_cb;
#endif /* MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK */
#endif /* MBEDTLS_X509_CRT_PARSE_C */
#if defined(MBEDTLS_SSL_ASYNC_PRIVATE)
#if defined(MBEDTLS_X509_CRT_PARSE_C)
mbedtls_ssl_async_sign_t *f_async_sign_start; /*!< start asynchronous signature operation */
mbedtls_ssl_async_decrypt_t *f_async_decrypt_start; /*!< start asynchronous decryption operation */
#endif /* MBEDTLS_X509_CRT_PARSE_C */
mbedtls_ssl_async_resume_t *f_async_resume; /*!< resume asynchronous operation */
mbedtls_ssl_async_cancel_t *f_async_cancel; /*!< cancel asynchronous operation */
void *p_async_config_data; /*!< Configuration data set by mbedtls_ssl_conf_async_private_cb(). */
#endif /* MBEDTLS_SSL_ASYNC_PRIVATE */
#if defined(MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED)
const uint8_t *sig_hashes; /*!< allowed signature hashes */
#endif
#if defined(MBEDTLS_ECP_C)
const mbedtls_ecp_group_id *curve_list; /*!< allowed curves */
#endif
#if defined(MBEDTLS_DHM_C)
mbedtls_mpi dhm_P; /*!< prime modulus for DHM */
mbedtls_mpi dhm_G; /*!< generator for DHM */
#endif
#if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED)
#if defined(MBEDTLS_USE_PSA_CRYPTO)
psa_key_id_t psk_opaque; /*!< PSA key slot holding opaque PSK. This field
* should only be set via
* mbedtls_ssl_conf_psk_opaque().
* If either no PSK or a raw PSK have been
* configured, this has value \c 0.
*/
#endif /* MBEDTLS_USE_PSA_CRYPTO */
unsigned char *psk; /*!< The raw pre-shared key. This field should
* only be set via mbedtls_ssl_conf_psk().
* If either no PSK or an opaque PSK
* have been configured, this has value NULL. */
size_t psk_len; /*!< The length of the raw pre-shared key.
* This field should only be set via
* mbedtls_ssl_conf_psk().
* Its value is non-zero if and only if
* \c psk is not \c NULL. */
unsigned char *psk_identity; /*!< The PSK identity for PSK negotiation.
* This field should only be set via
* mbedtls_ssl_conf_psk().
* This is set if and only if either
* \c psk or \c psk_opaque are set. */
size_t psk_identity_len;/*!< The length of PSK identity.
* This field should only be set via
* mbedtls_ssl_conf_psk().
* Its value is non-zero if and only if
* \c psk is not \c NULL or \c psk_opaque
* is not \c 0. */
#endif /* MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED */
#if defined(MBEDTLS_SSL_ALPN)
const char **alpn_list; /*!< ordered list of protocols */
#endif
#if defined(MBEDTLS_SSL_DTLS_SRTP)
/*! ordered list of supported srtp profile */
const mbedtls_ssl_srtp_profile *dtls_srtp_profile_list;
/*! number of supported profiles */
size_t dtls_srtp_profile_list_len;
#endif /* MBEDTLS_SSL_DTLS_SRTP */
/*
* Numerical settings (int then char)
*/
uint32_t read_timeout; /*!< timeout for mbedtls_ssl_read (ms) */
#if defined(MBEDTLS_SSL_PROTO_DTLS)
uint32_t hs_timeout_min; /*!< initial value of the handshake
retransmission timeout (ms) */
uint32_t hs_timeout_max; /*!< maximum value of the handshake
retransmission timeout (ms) */
#endif
#if defined(MBEDTLS_SSL_RENEGOTIATION)
int renego_max_records; /*!< grace period for renegotiation */
unsigned char renego_period[8]; /*!< value of the record counters
that triggers renegotiation */
#endif
#if defined(MBEDTLS_SSL_DTLS_BADMAC_LIMIT)
unsigned int badmac_limit; /*!< limit of records with a bad MAC */
#endif
#if defined(MBEDTLS_DHM_C) && defined(MBEDTLS_SSL_CLI_C)
unsigned int dhm_min_bitlen; /*!< min. bit length of the DHM prime */
#endif
unsigned char max_major_ver; /*!< max. major version used */
unsigned char max_minor_ver; /*!< max. minor version used */
unsigned char min_major_ver; /*!< min. major version used */
unsigned char min_minor_ver; /*!< min. minor version used */
/*
* Flags (bitfields)
*/
unsigned int endpoint : 1; /*!< 0: client, 1: server */
unsigned int transport : 1; /*!< stream (TLS) or datagram (DTLS) */
unsigned int authmode : 2; /*!< MBEDTLS_SSL_VERIFY_XXX */
/* needed even with renego disabled for LEGACY_BREAK_HANDSHAKE */
unsigned int allow_legacy_renegotiation : 2 ; /*!< MBEDTLS_LEGACY_XXX */
#if defined(MBEDTLS_ARC4_C)
unsigned int arc4_disabled : 1; /*!< blacklist RC4 ciphersuites? */
#endif
#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
unsigned int mfl_code : 3; /*!< desired fragment length */
#endif
#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
unsigned int encrypt_then_mac : 1 ; /*!< negotiate encrypt-then-mac? */
#endif
#if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
unsigned int extended_ms : 1; /*!< negotiate extended master secret? */
#endif
#if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY)
unsigned int anti_replay : 1; /*!< detect and prevent replay? */
#endif
#if defined(MBEDTLS_SSL_CBC_RECORD_SPLITTING)
unsigned int cbc_record_splitting : 1; /*!< do cbc record splitting */
#endif
#if defined(MBEDTLS_SSL_RENEGOTIATION)
unsigned int disable_renegotiation : 1; /*!< disable renegotiation? */
#endif
#if defined(MBEDTLS_SSL_SESSION_TICKETS)
unsigned int session_tickets : 1; /*!< use session tickets? */
#endif
#if defined(MBEDTLS_SSL_FALLBACK_SCSV) && defined(MBEDTLS_SSL_CLI_C)
unsigned int fallback : 1; /*!< is this a fallback? */
#endif
#if defined(MBEDTLS_SSL_SRV_C)
unsigned int cert_req_ca_list : 1; /*!< enable sending CA list in
Certificate Request messages? */
#endif
#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
unsigned int ignore_unexpected_cid : 1; /*!< Determines whether DTLS
* record with unexpected CID
* should lead to failure. */
#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
#if defined(MBEDTLS_SSL_DTLS_SRTP)
unsigned int dtls_srtp_mki_support : 1; /* support having mki_value
in the use_srtp extension */
#endif
bool disable_compression;
};
struct mbedtls_ssl_context
{
const mbedtls_ssl_config *conf; /*!< configuration information */
/*
* Miscellaneous
*/
int state; /*!< SSL handshake: current state */
#if defined(MBEDTLS_SSL_RENEGOTIATION)
int renego_status; /*!< Initial, in progress, pending? */
int renego_records_seen; /*!< Records since renego request, or with DTLS,
number of retransmissions of request if
renego_max_records is < 0 */
#endif /* MBEDTLS_SSL_RENEGOTIATION */
int major_ver; /*!< equal to MBEDTLS_SSL_MAJOR_VERSION_3 */
int minor_ver; /*!< either 0 (SSL3) or 1 (TLS1.0) */
#if defined(MBEDTLS_SSL_DTLS_BADMAC_LIMIT)
unsigned badmac_seen; /*!< records with a bad MAC received */
#endif /* MBEDTLS_SSL_DTLS_BADMAC_LIMIT */
#if defined(MBEDTLS_X509_CRT_PARSE_C)
/** Callback to customize X.509 certificate chain verification */
int (*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *);
void *p_vrfy; /*!< context for X.509 verify callback */
#endif
mbedtls_ssl_send_t *f_send; /*!< Callback for network send */
mbedtls_ssl_recv_t *f_recv; /*!< Callback for network receive */
mbedtls_ssl_recv_timeout_t *f_recv_timeout;
/*!< Callback for network receive with timeout */
void *p_bio; /*!< context for I/O operations */
/*
* Session layer
*/
mbedtls_ssl_session *session_in; /*!< current session data (in) */
mbedtls_ssl_session *session_out; /*!< current session data (out) */
mbedtls_ssl_session *session; /*!< negotiated session data */
mbedtls_ssl_session *session_negotiate; /*!< session data in negotiation */
mbedtls_ssl_handshake_params *handshake; /*!< params required only during
the handshake process */
const mbedtls_ecp_curve_info *curve;
/*
* Record layer transformations
*/
mbedtls_ssl_transform *transform_in; /*!< current transform params (in) */
mbedtls_ssl_transform *transform_out; /*!< current transform params (in) */
mbedtls_ssl_transform *transform; /*!< negotiated transform params */
mbedtls_ssl_transform *transform_negotiate; /*!< transform params in negotiation */
/*
* Timers
*/
void *p_timer; /*!< context for the timer callbacks */
mbedtls_ssl_set_timer_t *f_set_timer; /*!< set timer callback */
mbedtls_ssl_get_timer_t *f_get_timer; /*!< get timer callback */
/*
* Record layer (incoming data)
*/
unsigned char *in_buf; /*!< input buffer */
unsigned char *in_ctr; /*!< 64-bit incoming message counter
TLS: maintained by us
DTLS: read from peer */
unsigned char *in_hdr; /*!< start of record header */
#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
unsigned char *in_cid; /*!< The start of the CID;
* (the end is marked by in_len). */
#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
unsigned char *in_len; /*!< two-bytes message length field */
unsigned char *in_iv; /*!< ivlen-byte IV */
unsigned char *in_msg; /*!< message contents (in_iv+ivlen) */
unsigned char *in_offt; /*!< read offset in application data */
int in_msgtype; /*!< record header: message type */
size_t in_msglen; /*!< record header: message length */
size_t in_left; /*!< amount of data read so far */
#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
size_t in_buf_len; /*!< length of input buffer */
#endif
#if defined(MBEDTLS_SSL_PROTO_DTLS)
uint16_t in_epoch; /*!< DTLS epoch for incoming records */
size_t next_record_offset; /*!< offset of the next record in datagram
(equal to in_left if none) */
#endif /* MBEDTLS_SSL_PROTO_DTLS */
#if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY)
uint64_t in_window_top; /*!< last validated record seq_num */
uint64_t in_window; /*!< bitmask for replay detection */
#endif /* MBEDTLS_SSL_DTLS_ANTI_REPLAY */
size_t in_hslen; /*!< current handshake message length,
including the handshake header */
int nb_zero; /*!< # of 0-length encrypted messages */
int keep_current_message; /*!< drop or reuse current message
on next call to record layer? */
#if defined(MBEDTLS_SSL_PROTO_DTLS)
uint8_t disable_datagram_packing; /*!< Disable packing multiple records
* within a single datagram. */
#endif /* MBEDTLS_SSL_PROTO_DTLS */
/*
* Record layer (outgoing data)
*/
unsigned char *out_buf; /*!< output buffer */
unsigned char *out_ctr; /*!< 64-bit outgoing message counter */
unsigned char *out_hdr; /*!< start of record header */
#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
unsigned char *out_cid; /*!< The start of the CID;
* (the end is marked by in_len). */
#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
unsigned char *out_len; /*!< two-bytes message length field */
unsigned char *out_iv; /*!< ivlen-byte IV */
unsigned char *out_msg; /*!< message contents (out_iv+ivlen) */
int out_msgtype; /*!< record header: message type */
size_t out_msglen; /*!< record header: message length */
size_t out_left; /*!< amount of data not yet written */
#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
size_t out_buf_len; /*!< length of output buffer */
#endif
uint8_t fatal_alert;
unsigned char cur_out_ctr[8]; /*!< Outgoing record sequence number. */
#if defined(MBEDTLS_SSL_PROTO_DTLS)
uint16_t mtu; /*!< path mtu, used to fragment outgoing messages */
#endif /* MBEDTLS_SSL_PROTO_DTLS */
#if defined(MBEDTLS_ZLIB_SUPPORT)
unsigned char *compress_buf; /*!< zlib data buffer */
#endif /* MBEDTLS_ZLIB_SUPPORT */
#if defined(MBEDTLS_SSL_CBC_RECORD_SPLITTING)
signed char split_done; /*!< current record already splitted? */
#endif /* MBEDTLS_SSL_CBC_RECORD_SPLITTING */
/*
* PKI layer
*/
int client_auth; /*!< flag for client auth. */
/*
* User settings
*/
#if defined(MBEDTLS_X509_CRT_PARSE_C)
char *hostname; /*!< expected peer CN for verification
(and SNI if available) */
#endif /* MBEDTLS_X509_CRT_PARSE_C */
#if defined(MBEDTLS_SSL_ALPN)
const char *alpn_chosen; /*!< negotiated protocol */
#endif /* MBEDTLS_SSL_ALPN */
#if defined(MBEDTLS_SSL_DTLS_SRTP)
/*
* use_srtp extension
*/
mbedtls_dtls_srtp_info dtls_srtp_info;
#endif /* MBEDTLS_SSL_DTLS_SRTP */
/*
* Information for DTLS hello verify
*/
#if defined(MBEDTLS_SSL_DTLS_HELLO_VERIFY) && defined(MBEDTLS_SSL_SRV_C)
unsigned char *cli_id; /*!< transport-level ID of the client */
size_t cli_id_len; /*!< length of cli_id */
#endif /* MBEDTLS_SSL_DTLS_HELLO_VERIFY && MBEDTLS_SSL_SRV_C */
/*
* Secure renegotiation
*/
/* needed to know when to send extension on server */
int secure_renegotiation; /*!< does peer support legacy or
secure renegotiation */
#if defined(MBEDTLS_SSL_RENEGOTIATION)
size_t verify_data_len; /*!< length of verify data stored */
char own_verify_data[MBEDTLS_SSL_VERIFY_DATA_MAX_LEN]; /*!< previous handshake verify data */
char peer_verify_data[MBEDTLS_SSL_VERIFY_DATA_MAX_LEN]; /*!< previous handshake verify data */
#endif /* MBEDTLS_SSL_RENEGOTIATION */
#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
/* CID configuration to use in subsequent handshakes. */
/*! The next incoming CID, chosen by the user and applying to
* all subsequent handshakes. This may be different from the
* CID currently used in case the user has re-configured the CID
* after an initial handshake. */
unsigned char own_cid[ MBEDTLS_SSL_CID_IN_LEN_MAX ];
uint8_t own_cid_len; /*!< The length of \c own_cid. */
uint8_t negotiate_cid; /*!< This indicates whether the CID extension should
* be negotiated in the next handshake or not.
* Possible values are #MBEDTLS_SSL_CID_ENABLED
* and #MBEDTLS_SSL_CID_DISABLED. */
#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
uint16_t client_ciphers[16]; /* [jart] clarifies MBEDTLS_ERR_SSL_NO_USABLE_CIPHERSUITE */
};
/**
* \brief Callback type: generate and write session ticket
*
* \note This describes what a callback implementation should do.
* This callback should generate an encrypted and
* authenticated ticket for the session and write it to the
* output buffer. Here, ticket means the opaque ticket part
* of the NewSessionTicket structure of RFC 5077.
*
* \param p_ticket Context for the callback
* \param session SSL session to be written in the ticket
* \param start Start of the output buffer
* \param end End of the output buffer
* \param tlen On exit, holds the length written
* \param lifetime On exit, holds the lifetime of the ticket in seconds
*
* \return 0 if successful, or
* a specific MBEDTLS_ERR_XXX code.
*/
typedef int mbedtls_ssl_ticket_write_t( void *p_ticket,
const mbedtls_ssl_session *session,
unsigned char *start,
const unsigned char *end,
size_t *tlen,
uint32_t *lifetime );
/**
* \brief Callback type: Export key block and master secret
*
* \note This is required for certain uses of TLS, e.g. EAP-TLS
* (RFC 5216) and Thread. The key pointers are ephemeral and
* therefore must not be stored. The master secret and keys
* should not be used directly except as an input to a key
* derivation function.
*
* \param p_expkey Context for the callback
* \param ms Pointer to master secret (fixed length: 48 bytes)
* \param kb Pointer to key block, see RFC 5246 section 6.3
* (variable length: 2 * maclen + 2 * keylen + 2 * ivlen).
* \param maclen MAC length
* \param keylen Key length
* \param ivlen IV length
*
* \return 0 if successful, or
* a specific MBEDTLS_ERR_XXX code.
*/
typedef int mbedtls_ssl_export_keys_t( void *p_expkey,
const unsigned char *ms,
const unsigned char *kb,
size_t maclen,
size_t keylen,
size_t ivlen );
/**
* \brief Callback type: Export key block, master secret,
* handshake randbytes and the tls_prf function
* used to derive keys.
*
* \note This is required for certain uses of TLS, e.g. EAP-TLS
* (RFC 5216) and Thread. The key pointers are ephemeral and
* therefore must not be stored. The master secret and keys
* should not be used directly except as an input to a key
* derivation function.
*
* \param p_expkey Context for the callback.
* \param ms Pointer to master secret (fixed length: 48 bytes).
* \param kb Pointer to key block, see RFC 5246 section 6.3.
* (variable length: 2 * maclen + 2 * keylen + 2 * ivlen).
* \param maclen MAC length.
* \param keylen Key length.
* \param ivlen IV length.
* \param client_random The client random bytes.
* \param server_random The server random bytes.
* \param tls_prf_type The tls_prf enum type.
*
* \return 0 if successful, or
* a specific MBEDTLS_ERR_XXX code.
*/
typedef int mbedtls_ssl_export_keys_ext_t( void *p_expkey,
const unsigned char *ms,
const unsigned char *kb,
size_t maclen,
size_t keylen,
size_t ivlen,
const unsigned char client_random[32],
const unsigned char server_random[32],
mbedtls_tls_prf_types tls_prf_type );
/**
* \brief Callback type: parse and load session ticket
*
* \note This describes what a callback implementation should do.
* This callback should parse a session ticket as generated
* by the corresponding mbedtls_ssl_ticket_write_t function,
* and, if the ticket is authentic and valid, load the
* session.
*
* \note The implementation is allowed to modify the first len
* bytes of the input buffer, eg to use it as a temporary
* area for the decrypted ticket contents.
*
* \param p_ticket Context for the callback
* \param session SSL session to be loaded
* \param buf Start of the buffer containing the ticket
* \param len Length of the ticket.
*
* \return 0 if successful, or
* MBEDTLS_ERR_SSL_INVALID_MAC if not authentic, or
* MBEDTLS_ERR_SSL_SESSION_TICKET_EXPIRED if expired, or
* any other non-zero code for other failures.
*/
typedef int mbedtls_ssl_ticket_parse_t( void *p_ticket,
mbedtls_ssl_session *session,
unsigned char *buf,
size_t len );
/**
* \brief Callback type: generate a cookie
*
* \param ctx Context for the callback
* \param p Buffer to write to,
* must be updated to point right after the cookie
* \param end Pointer to one past the end of the output buffer
* \param info Client ID info that was passed to
* \c mbedtls_ssl_set_client_transport_id()
* \param ilen Length of info in bytes
*
* \return The callback must return 0 on success,
* or a negative error code.
*/
typedef int mbedtls_ssl_cookie_write_t( void *ctx,
unsigned char **p, unsigned char *end,
const unsigned char *info, size_t ilen );
/**
* \brief Callback type: verify a cookie
*
* \param ctx Context for the callback
* \param cookie Cookie to verify
* \param clen Length of cookie
* \param info Client ID info that was passed to
* \c mbedtls_ssl_set_client_transport_id()
* \param ilen Length of info in bytes
*
* \return The callback must return 0 if cookie is valid,
* or a negative error code.
*/
typedef int mbedtls_ssl_cookie_check_t( void *ctx,
const unsigned char *cookie, size_t clen,
const unsigned char *info, size_t ilen );
const char *mbedtls_sig_alg_name(int);
const char *mbedtls_ssl_get_alpn_protocol( const mbedtls_ssl_context * );
const char *mbedtls_ssl_get_ciphersuite( const mbedtls_ssl_context * );
const char *mbedtls_ssl_get_ciphersuite_name( const int );
const char *mbedtls_ssl_get_srtp_profile_as_string( mbedtls_ssl_srtp_profile );
const char *mbedtls_ssl_get_version( const mbedtls_ssl_context * );
const mbedtls_ssl_session *mbedtls_ssl_get_session_pointer( const mbedtls_ssl_context * );
const mbedtls_x509_crt *mbedtls_ssl_get_peer_cert( const mbedtls_ssl_context * );
int mbedtls_ssl_check_pending( const mbedtls_ssl_context * );
int mbedtls_ssl_check_record( mbedtls_ssl_context const *, unsigned char *, size_t );
int mbedtls_ssl_close_notify( mbedtls_ssl_context * );
int mbedtls_ssl_conf_alpn_protocols( mbedtls_ssl_config *, const char ** );
int mbedtls_ssl_conf_cid( mbedtls_ssl_config *, size_t, int );
int mbedtls_ssl_conf_dh_param_bin( mbedtls_ssl_config *, const unsigned char *, size_t, const unsigned char *, size_t );
int mbedtls_ssl_conf_dh_param_ctx( mbedtls_ssl_config *, mbedtls_dhm_context * );
int mbedtls_ssl_conf_dtls_srtp_protection_profiles( mbedtls_ssl_config *, const mbedtls_ssl_srtp_profile * );
int mbedtls_ssl_conf_max_frag_len( mbedtls_ssl_config *, unsigned char );
int mbedtls_ssl_conf_own_cert( mbedtls_ssl_config *, mbedtls_x509_crt *, mbedtls_pk_context * );
int mbedtls_ssl_conf_psk( mbedtls_ssl_config *, const void *, size_t, const void *, size_t );
int mbedtls_ssl_context_load( mbedtls_ssl_context *, const unsigned char *, size_t );
int mbedtls_ssl_context_save( mbedtls_ssl_context *, unsigned char *, size_t, size_t * );
int mbedtls_ssl_get_ciphersuite_id( const char * );
int mbedtls_ssl_get_max_out_record_payload( const mbedtls_ssl_context * );
int mbedtls_ssl_get_peer_cid( mbedtls_ssl_context *, int *, unsigned char[ MBEDTLS_SSL_CID_OUT_LEN_MAX ], size_t * );
int mbedtls_ssl_get_record_expansion( const mbedtls_ssl_context * );
int mbedtls_ssl_get_session( const mbedtls_ssl_context *, mbedtls_ssl_session * );
int mbedtls_ssl_handshake( mbedtls_ssl_context * );
int mbedtls_ssl_handshake_client_step( mbedtls_ssl_context * );
int mbedtls_ssl_handshake_server_step( mbedtls_ssl_context * );
int mbedtls_ssl_handshake_step( mbedtls_ssl_context * );
int mbedtls_ssl_read( mbedtls_ssl_context *, void *, size_t );
int mbedtls_ssl_renegotiate( mbedtls_ssl_context * );
int mbedtls_ssl_send_alert_message( mbedtls_ssl_context *, unsigned char, unsigned char );
int mbedtls_ssl_session_load( mbedtls_ssl_session *, const unsigned char *, size_t );
int mbedtls_ssl_session_reset( mbedtls_ssl_context * );
int mbedtls_ssl_session_save( const mbedtls_ssl_session *, unsigned char *, size_t, size_t * );
int mbedtls_ssl_set_cid( mbedtls_ssl_context *, int, unsigned char const *, size_t );
int mbedtls_ssl_set_client_transport_id( mbedtls_ssl_context *, const unsigned char *, size_t );
int mbedtls_ssl_set_hostname( mbedtls_ssl_context *, const char * );
int mbedtls_ssl_set_hs_ecjpake_password( mbedtls_ssl_context *, const unsigned char *, size_t );
int mbedtls_ssl_set_hs_own_cert( mbedtls_ssl_context *, mbedtls_x509_crt *, mbedtls_pk_context * );
int mbedtls_ssl_set_hs_psk( mbedtls_ssl_context *, const void *, size_t );
int mbedtls_ssl_set_session( mbedtls_ssl_context *, const mbedtls_ssl_session * );
int mbedtls_ssl_setup( mbedtls_ssl_context *, const mbedtls_ssl_config * );
int mbedtls_ssl_tls_prf( const mbedtls_tls_prf_types , const unsigned char *, size_t, const char *, const unsigned char *, size_t, unsigned char *, size_t );
int mbedtls_ssl_write( mbedtls_ssl_context *, const void *, size_t );
size_t mbedtls_ssl_get_bytes_avail( const mbedtls_ssl_context * );
size_t mbedtls_ssl_get_input_max_frag_len( const mbedtls_ssl_context * );
size_t mbedtls_ssl_get_output_max_frag_len( const mbedtls_ssl_context * );
uint32_t mbedtls_ssl_get_verify_result( const mbedtls_ssl_context * );
void *mbedtls_ssl_conf_get_async_config_data( const mbedtls_ssl_config * );
void *mbedtls_ssl_get_async_operation_data( const mbedtls_ssl_context * );
void mbedtls_ssl_conf_async_private_cb( mbedtls_ssl_config *, mbedtls_ssl_async_sign_t *, mbedtls_ssl_async_decrypt_t *, mbedtls_ssl_async_resume_t *, mbedtls_ssl_async_cancel_t *, void * );
void mbedtls_ssl_conf_authmode( mbedtls_ssl_config *, int );
void mbedtls_ssl_conf_ca_cb( mbedtls_ssl_config *, mbedtls_x509_crt_ca_cb_t, void * );
void mbedtls_ssl_conf_ca_chain( mbedtls_ssl_config *, mbedtls_x509_crt *, mbedtls_x509_crl * );
void mbedtls_ssl_conf_cbc_record_splitting( mbedtls_ssl_config *, char );
void mbedtls_ssl_conf_cert_profile( mbedtls_ssl_config *, const mbedtls_x509_crt_profile * );
void mbedtls_ssl_conf_cert_req_ca_list( mbedtls_ssl_config *, char );
void mbedtls_ssl_conf_ciphersuites( mbedtls_ssl_config *, const uint16_t * );
void mbedtls_ssl_conf_ciphersuites_for_version( mbedtls_ssl_config *, const uint16_t *, int, int );
void mbedtls_ssl_conf_curves( mbedtls_ssl_config *, const mbedtls_ecp_group_id * );
void mbedtls_ssl_conf_dbg( mbedtls_ssl_config *, void (*)(void *, int, const char *, int, const char *), void * );
void mbedtls_ssl_conf_dhm_min_bitlen( mbedtls_ssl_config *, unsigned int );
void mbedtls_ssl_conf_dtls_anti_replay( mbedtls_ssl_config *, char );
void mbedtls_ssl_conf_dtls_badmac_limit( mbedtls_ssl_config *, unsigned );
void mbedtls_ssl_conf_dtls_cookies( mbedtls_ssl_config *, mbedtls_ssl_cookie_write_t *, mbedtls_ssl_cookie_check_t *, void * );
void mbedtls_ssl_conf_encrypt_then_mac( mbedtls_ssl_config *, char );
void mbedtls_ssl_conf_endpoint( mbedtls_ssl_config *, int );
void mbedtls_ssl_conf_export_keys_cb( mbedtls_ssl_config *, mbedtls_ssl_export_keys_t *, void * );
void mbedtls_ssl_conf_export_keys_ext_cb( mbedtls_ssl_config *, mbedtls_ssl_export_keys_ext_t *, void * );
void mbedtls_ssl_conf_extended_master_secret( mbedtls_ssl_config *, char );
void mbedtls_ssl_conf_fallback( mbedtls_ssl_config *, char );
void mbedtls_ssl_conf_handshake_timeout( mbedtls_ssl_config *, uint32_t, uint32_t );
void mbedtls_ssl_conf_legacy_renegotiation( mbedtls_ssl_config *, int );
void mbedtls_ssl_conf_max_version( mbedtls_ssl_config *, int, int );
void mbedtls_ssl_conf_min_version( mbedtls_ssl_config *, int, int );
void mbedtls_ssl_conf_psk_cb( mbedtls_ssl_config *, int (*)(void *, mbedtls_ssl_context *, const unsigned char *, size_t), void * );
void mbedtls_ssl_conf_read_timeout( mbedtls_ssl_config *, uint32_t );
void mbedtls_ssl_conf_renegotiation( mbedtls_ssl_config *, int );
void mbedtls_ssl_conf_renegotiation_enforced( mbedtls_ssl_config *, int );
void mbedtls_ssl_conf_renegotiation_period( mbedtls_ssl_config *, const unsigned char[8] );
void mbedtls_ssl_conf_rng( mbedtls_ssl_config *, int (*)(void *, unsigned char *, size_t), void * );
void mbedtls_ssl_conf_session_cache( mbedtls_ssl_config *, void *, int (*)(void *, mbedtls_ssl_session *), int (*)(void *, const mbedtls_ssl_session *) );
void mbedtls_ssl_conf_session_tickets( mbedtls_ssl_config *, int );
void mbedtls_ssl_conf_session_tickets_cb( mbedtls_ssl_config *, mbedtls_ssl_ticket_write_t *, mbedtls_ssl_ticket_parse_t *, void * );
void mbedtls_ssl_conf_sig_hashes( mbedtls_ssl_config *, const uint8_t * );
void mbedtls_ssl_conf_sni( mbedtls_ssl_config *, int (*)(void *, mbedtls_ssl_context *, const unsigned char *, size_t), void *);
void mbedtls_ssl_conf_srtp_mki_value_supported( mbedtls_ssl_config *, int );
void mbedtls_ssl_conf_transport( mbedtls_ssl_config *, int );
void mbedtls_ssl_conf_verify( mbedtls_ssl_config *, int (*)(void *, mbedtls_x509_crt *, int, uint32_t *), void * );
void mbedtls_ssl_config_free( mbedtls_ssl_config * );
void mbedtls_ssl_config_init( mbedtls_ssl_config * );
void mbedtls_ssl_free( mbedtls_ssl_context * );
void mbedtls_ssl_get_dtls_srtp_negotiation_result( const mbedtls_ssl_context *, mbedtls_dtls_srtp_info * );
void mbedtls_ssl_init( mbedtls_ssl_context * );
void mbedtls_ssl_key_cert_free( mbedtls_ssl_key_cert * );
void mbedtls_ssl_session_free( mbedtls_ssl_session * );
void mbedtls_ssl_session_init( mbedtls_ssl_session * );
void mbedtls_ssl_set_async_operation_data( mbedtls_ssl_context *, void * );
void mbedtls_ssl_set_bio( mbedtls_ssl_context *, void *, mbedtls_ssl_send_t *, mbedtls_ssl_recv_t *, mbedtls_ssl_recv_timeout_t * );
void mbedtls_ssl_set_datagram_packing( mbedtls_ssl_context *, unsigned );
void mbedtls_ssl_set_hs_authmode( mbedtls_ssl_context *, int );
void mbedtls_ssl_set_hs_ca_chain( mbedtls_ssl_context *, mbedtls_x509_crt *, mbedtls_x509_crl * );
void mbedtls_ssl_set_mtu( mbedtls_ssl_context *, uint16_t );
void mbedtls_ssl_set_timer_cb( mbedtls_ssl_context *, void *, mbedtls_ssl_set_timer_t *, mbedtls_ssl_get_timer_t * );
void mbedtls_ssl_set_verify( mbedtls_ssl_context *, int (*)(void *, mbedtls_x509_crt *, int, uint32_t *), void * );
/**
* \brief Load reasonnable default SSL configuration values.
* (You need to call mbedtls_ssl_config_init() first.)
*
* \param conf SSL configuration context
* \param endpoint MBEDTLS_SSL_IS_CLIENT or MBEDTLS_SSL_IS_SERVER
* \param transport MBEDTLS_SSL_TRANSPORT_STREAM for TLS, or
* MBEDTLS_SSL_TRANSPORT_DATAGRAM for DTLS
* \param preset a MBEDTLS_SSL_PRESET_XXX value
*
* \note See \c mbedtls_ssl_conf_transport() for notes on DTLS.
*
* \return 0 if successful, or
* MBEDTLS_ERR_XXX_ALLOC_FAILED on memory allocation error.
*/
forceinline int mbedtls_ssl_config_defaults( mbedtls_ssl_config *conf,
int endpoint, int transport,
int preset ) {
int mbedtls_ssl_config_defaults_impl(mbedtls_ssl_config *, int, int, int,
int (*)(mbedtls_ssl_context *));
switch (endpoint) {
#if defined(MBEDTLS_SSL_CLI_C)
case MBEDTLS_SSL_IS_CLIENT:
return mbedtls_ssl_config_defaults_impl(
conf, endpoint, transport, preset,
mbedtls_ssl_handshake_client_step);
#endif
#if defined(MBEDTLS_SSL_SRV_C)
case MBEDTLS_SSL_IS_SERVER:
return mbedtls_ssl_config_defaults_impl(
conf, endpoint, transport, preset,
mbedtls_ssl_handshake_server_step);
#endif
default:
return MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
}
}
const char *GetSslStateName(mbedtls_ssl_states);
COSMOPOLITAN_C_END_
#endif /* COSMOPOLITAN_THIRD_PARTY_MBEDTLS_SSL_H_ */
| 81,218 | 1,543 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/ssl_srv.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:4;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright The Mbed TLS Contributors â
â â
â Licensed under the Apache License, Version 2.0 (the "License"); â
â you may not use this file except in compliance with the License. â
â You may obtain a copy of the License at â
â â
â http://www.apache.org/licenses/LICENSE-2.0 â
â â
â Unless required by applicable law or agreed to in writing, software â
â distributed under the License is distributed on an "AS IS" BASIS, â
â WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. â
â See the License for the specific language governing permissions and â
â limitations under the License. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/log/log.h"
#include "libc/macros.internal.h"
#include "libc/str/str.h"
#include "libc/time/time.h"
#include "third_party/mbedtls/common.h"
#include "third_party/mbedtls/debug.h"
#include "third_party/mbedtls/ecp.h"
#include "third_party/mbedtls/error.h"
#include "third_party/mbedtls/platform.h"
#include "third_party/mbedtls/profile.h"
#include "third_party/mbedtls/ssl.h"
#include "third_party/mbedtls/ssl_internal.h"
asm(".ident\t\"\\n\\n\
Mbed TLS (Apache 2.0)\\n\
Copyright ARM Limited\\n\
Copyright Mbed TLS Contributors\"");
asm(".include \"libc/disclaimer.inc\"");
/* clang-format off */
/*
* SSLv3/TLSv1 server-side functions
*
* Copyright The Mbed TLS Contributors
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#if defined(MBEDTLS_SSL_DTLS_HELLO_VERIFY)
/**
* \brief Set client's transport-level identification info.
* (Server only. DTLS only.)
*
* This is usually the IP address (and port), but could be
* anything identify the client depending on the underlying
* network stack. Used for HelloVerifyRequest with DTLS.
* This is *not* used to route the actual packets.
*
* \param ssl SSL context
* \param info Transport-level info identifying the client (eg IP + port)
* \param ilen Length of info in bytes
*
* \note An internal copy is made, so the info buffer can be reused.
*
* \return 0 on success,
* MBEDTLS_ERR_SSL_BAD_INPUT_DATA if used on client,
* MBEDTLS_ERR_SSL_ALLOC_FAILED if out of memory.
*/
int mbedtls_ssl_set_client_transport_id( mbedtls_ssl_context *ssl,
const unsigned char *info,
size_t ilen )
{
if( ssl->conf->endpoint != MBEDTLS_SSL_IS_SERVER )
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
mbedtls_free( ssl->cli_id );
if( ( ssl->cli_id = mbedtls_calloc( 1, ilen ) ) == NULL )
return( MBEDTLS_ERR_SSL_ALLOC_FAILED );
memcpy( ssl->cli_id, info, ilen );
ssl->cli_id_len = ilen;
return( 0 );
}
/**
* \brief Register callbacks for DTLS cookies
* (Server only. DTLS only.)
*
* Default: dummy callbacks that fail, in order to force you to
* register working callbacks (and initialize their context).
*
* To disable HelloVerifyRequest, register NULL callbacks.
*
* \warning Disabling hello verification allows your server to be used
* for amplification in DoS attacks against other hosts.
* Only disable if you known this can't happen in your
* particular environment.
*
* \note See comments on \c mbedtls_ssl_handshake() about handling
* the MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED that is expected
* on the first handshake attempt when this is enabled.
*
* \note This is also necessary to handle client reconnection from
* the same port as described in RFC 6347 section 4.2.8 (only
* the variant with cookies is supported currently). See
* comments on \c mbedtls_ssl_read() for details.
*
* \param conf SSL configuration
* \param f_cookie_write Cookie write callback
* \param f_cookie_check Cookie check callback
* \param p_cookie Context for both callbacks
*/
void mbedtls_ssl_conf_dtls_cookies( mbedtls_ssl_config *conf,
mbedtls_ssl_cookie_write_t *f_cookie_write,
mbedtls_ssl_cookie_check_t *f_cookie_check,
void *p_cookie )
{
conf->f_cookie_write = f_cookie_write;
conf->f_cookie_check = f_cookie_check;
conf->p_cookie = p_cookie;
}
#endif /* MBEDTLS_SSL_DTLS_HELLO_VERIFY */
#if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
static int ssl_parse_servername_ext( mbedtls_ssl_context *ssl,
const unsigned char *buf,
size_t len )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t servername_list_size, hostname_len;
const unsigned char *p;
MBEDTLS_SSL_DEBUG_MSG( 3, ( "parse ServerName extension" ) );
if( len < 2 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
servername_list_size = ( ( buf[0] << 8 ) | ( buf[1] ) );
if( servername_list_size + 2 != len )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
p = buf + 2;
while( servername_list_size > 2 )
{
hostname_len = ( ( p[1] << 8 ) | p[2] );
if( hostname_len + 3 > servername_list_size )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
if( p[0] == MBEDTLS_TLS_EXT_SERVERNAME_HOSTNAME )
{
ret = ssl->conf->f_sni( ssl->conf->p_sni,
ssl, p + 3, hostname_len );
if( ret != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "ssl_sni_wrapper", ret );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_UNRECOGNIZED_NAME );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
return( 0 );
}
servername_list_size -= hostname_len + 3;
p += hostname_len + 3;
}
if( servername_list_size != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_ILLEGAL_PARAMETER );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
return( 0 );
}
#endif /* MBEDTLS_SSL_SERVER_NAME_INDICATION */
#if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED)
static int ssl_conf_has_psk_or_cb( mbedtls_ssl_config const *conf )
{
if( conf->f_psk != NULL )
return( 1 );
if( conf->psk_identity_len == 0 || conf->psk_identity == NULL )
return( 0 );
if( conf->psk != NULL && conf->psk_len != 0 )
return( 1 );
return( 0 );
}
#endif /* MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED */
static int ssl_parse_renegotiation_info( mbedtls_ssl_context *ssl,
const unsigned char *buf,
size_t len )
{
#if defined(MBEDTLS_SSL_RENEGOTIATION)
if( ssl->renego_status != MBEDTLS_SSL_INITIAL_HANDSHAKE )
{
/* Check verify-data in constant-time. The length OTOH is no secret */
if( len != 1 + ssl->verify_data_len ||
buf[0] != ssl->verify_data_len ||
timingsafe_bcmp( buf + 1, ssl->peer_verify_data,
ssl->verify_data_len ) != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "non-matching renegotiation info" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
}
else
#endif /* MBEDTLS_SSL_RENEGOTIATION */
{
if( len != 1 || buf[0] != 0x0 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "non-zero length renegotiation info" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
ssl->secure_renegotiation = MBEDTLS_SSL_SECURE_RENEGOTIATION;
}
return( 0 );
}
#if defined(MBEDTLS_SSL_PROTO_TLS1_2) && \
defined(MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED)
/* Add a signature-hash-pair to a signature-hash set */
static inline void mbedtls_ssl_sig_hash_set_add( mbedtls_ssl_sig_hash_set_t *set,
mbedtls_pk_type_t sig_alg,
mbedtls_md_type_t md_alg )
{
switch( sig_alg )
{
case MBEDTLS_PK_RSA:
if( set->rsa == MBEDTLS_MD_NONE )
set->rsa = md_alg;
break;
case MBEDTLS_PK_ECDSA:
if( set->ecdsa == MBEDTLS_MD_NONE )
set->ecdsa = md_alg;
break;
default:
break;
}
}
/*
* Status of the implementation of signature-algorithms extension:
*
* Currently, we are only considering the signature-algorithm extension
* to pick a ciphersuite which allows us to send the ServerKeyExchange
* message with a signature-hash combination that the user allows.
*
* We do *not* check whether all certificates in our certificate
* chain are signed with an allowed signature-hash pair.
* This needs to be done at a later stage.
*
*/
static int ssl_parse_signature_algorithms_ext( mbedtls_ssl_context *ssl,
const unsigned char *buf,
size_t len )
{
size_t sig_alg_list_size;
const unsigned char *p;
const unsigned char *end = buf + len;
mbedtls_md_type_t md_cur;
mbedtls_pk_type_t sig_cur;
if ( len < 2 ) {
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
sig_alg_list_size = ( ( buf[0] << 8 ) | ( buf[1] ) );
if( sig_alg_list_size + 2 != len ||
sig_alg_list_size % 2 != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
/* Currently we only guarantee signing the ServerKeyExchange message according
* to the constraints specified in this extension (see above), so it suffices
* to remember only one suitable hash for each possible signature algorithm.
*
* This will change when we also consider certificate signatures,
* in which case we will need to remember the whole signature-hash
* pair list from the extension.
*/
for( p = buf + 2; p < end; p += 2 )
{
/* Silently ignore unknown signature or hash algorithms. */
if( ( sig_cur = mbedtls_ssl_pk_alg_from_sig( p[1] ) ) == MBEDTLS_PK_NONE )
{
MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello v3, signature_algorithm ext"
" unknown sig alg encoding %d (%s)", p[1],
mbedtls_sig_alg_name(p[1])) );
continue;
}
/* Check if we support the hash the user proposes */
md_cur = mbedtls_ssl_md_alg_from_hash( p[0] );
if( md_cur == MBEDTLS_MD_NONE )
{
MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello v3, signature_algorithm ext:"
" unknown hash alg encoding %d", p[0] ) );
continue;
}
if( mbedtls_ssl_check_sig_hash( ssl, md_cur ) == 0 )
{
mbedtls_ssl_sig_hash_set_add( &ssl->handshake->hash_algs, sig_cur, md_cur );
MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello v3, signature_algorithm ext:"
" match sig %u (%s) and hash %u (%s)",
sig_cur, mbedtls_pk_type_name(sig_cur),
md_cur, mbedtls_md_type_name(md_cur) ) );
}
else
{
MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello v3, signature_algorithm ext: "
"hash alg %u not supported", (unsigned) md_cur ) );
}
}
return( 0 );
}
#endif /* MBEDTLS_SSL_PROTO_TLS1_2 &&
MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED */
#if defined(MBEDTLS_ECDH_C) || defined(MBEDTLS_ECDSA_C) || \
defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
static int ssl_parse_supported_elliptic_curves( mbedtls_ssl_context *ssl,
const unsigned char *buf,
size_t len )
{
size_t list_size, our_size;
const unsigned char *p;
const mbedtls_ecp_curve_info *curve_info, **curves;
if ( len < 2 ) {
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
list_size = ( ( buf[0] << 8 ) | ( buf[1] ) );
if( list_size + 2 != len ||
list_size % 2 != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
/* Should never happen unless client duplicates the extension */
if( ssl->handshake->curves != NULL )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
/* Don't allow our peer to make us allocate too much memory,
* and leave room for a final 0 */
our_size = list_size / 2 + 1;
if( our_size > MBEDTLS_ECP_DP_MAX )
our_size = MBEDTLS_ECP_DP_MAX;
if( ( curves = mbedtls_calloc( our_size, sizeof( *curves ) ) ) == NULL )
{
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_INTERNAL_ERROR );
return( MBEDTLS_ERR_SSL_ALLOC_FAILED );
}
ssl->handshake->curves = curves;
p = buf + 2;
while( list_size > 0 && our_size > 1 )
{
curve_info = mbedtls_ecp_curve_info_from_tls_id( ( p[0] << 8 ) | p[1] );
if( curve_info != NULL )
{
*curves++ = curve_info;
our_size--;
}
list_size -= 2;
p += 2;
}
return( 0 );
}
static int ssl_parse_supported_point_formats( mbedtls_ssl_context *ssl,
const unsigned char *buf,
size_t len )
{
size_t list_size;
const unsigned char *p;
if( len == 0 || (size_t)( buf[0] + 1 ) != len )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
list_size = buf[0];
p = buf + 1;
while( list_size > 0 )
{
if( p[0] == MBEDTLS_ECP_PF_UNCOMPRESSED ||
p[0] == MBEDTLS_ECP_PF_COMPRESSED )
{
#if defined(MBEDTLS_ECDH_C) || defined(MBEDTLS_ECDSA_C)
ssl->handshake->ecdh_ctx.point_format = p[0];
#endif
#if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
ssl->handshake->ecjpake_ctx.point_format = p[0];
#endif
MBEDTLS_SSL_DEBUG_MSG( 4, ( "point format selected: %d", p[0] ) );
return( 0 );
}
list_size--;
p++;
}
return( 0 );
}
#endif /* MBEDTLS_ECDH_C || MBEDTLS_ECDSA_C ||
MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
static int ssl_parse_ecjpake_kkpp( mbedtls_ssl_context *ssl,
const unsigned char *buf,
size_t len )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
if( mbedtls_ecjpake_check( &ssl->handshake->ecjpake_ctx ) != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 3, ( "skip ecjpake kkpp extension" ) );
return( 0 );
}
if( ( ret = mbedtls_ecjpake_read_round_one( &ssl->handshake->ecjpake_ctx,
buf, len ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ecjpake_read_round_one", ret );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_ILLEGAL_PARAMETER );
return( ret );
}
/* Only mark the extension as OK when we're sure it is */
ssl->handshake->cli_exts |= MBEDTLS_TLS_EXT_ECJPAKE_KKPP_OK;
return( 0 );
}
#endif /* MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED */
#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
static int ssl_parse_max_fragment_length_ext( mbedtls_ssl_context *ssl,
const unsigned char *buf,
size_t len )
{
if( len != 1 || buf[0] >= MBEDTLS_SSL_MAX_FRAG_LEN_INVALID )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_ILLEGAL_PARAMETER );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
ssl->session_negotiate->mfl_code = buf[0];
return( 0 );
}
#endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */
#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
static int ssl_parse_cid_ext( mbedtls_ssl_context *ssl,
const unsigned char *buf,
size_t len )
{
size_t peer_cid_len;
/* CID extension only makes sense in DTLS */
if( ssl->conf->transport != MBEDTLS_SSL_TRANSPORT_DATAGRAM )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_ILLEGAL_PARAMETER );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
/*
* Quoting draft-ietf-tls-dtls-connection-id-05
* https://tools.ietf.org/html/draft-ietf-tls-dtls-connection-id-05
*
* struct {
* opaque cid<0..2^8-1>;
* } ConnectionId;
*/
if( len < 1 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_ILLEGAL_PARAMETER );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
peer_cid_len = *buf++;
len--;
if( len != peer_cid_len )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_ILLEGAL_PARAMETER );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
/* Ignore CID if the user has disabled its use. */
if( ssl->negotiate_cid == MBEDTLS_SSL_CID_DISABLED )
{
/* Leave ssl->handshake->cid_in_use in its default
* value of MBEDTLS_SSL_CID_DISABLED. */
MBEDTLS_SSL_DEBUG_MSG( 3, ( "Client sent CID extension, but CID disabled" ) );
return( 0 );
}
if( peer_cid_len > MBEDTLS_SSL_CID_OUT_LEN_MAX )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_ILLEGAL_PARAMETER );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
ssl->handshake->cid_in_use = MBEDTLS_SSL_CID_ENABLED;
ssl->handshake->peer_cid_len = (uint8_t) peer_cid_len;
memcpy( ssl->handshake->peer_cid, buf, peer_cid_len );
MBEDTLS_SSL_DEBUG_MSG( 3, ( "Use of CID extension negotiated" ) );
MBEDTLS_SSL_DEBUG_BUF( 3, "Client CID", buf, peer_cid_len );
return( 0 );
}
#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
static int ssl_parse_encrypt_then_mac_ext( mbedtls_ssl_context *ssl,
const unsigned char *buf,
size_t len )
{
if( len != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
((void) buf);
if( ssl->conf->encrypt_then_mac == MBEDTLS_SSL_ETM_ENABLED &&
ssl->minor_ver != MBEDTLS_SSL_MINOR_VERSION_0 )
{
ssl->session_negotiate->encrypt_then_mac = MBEDTLS_SSL_ETM_ENABLED;
}
return( 0 );
}
#endif /* MBEDTLS_SSL_ENCRYPT_THEN_MAC */
#if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
static int ssl_parse_extended_ms_ext( mbedtls_ssl_context *ssl,
const unsigned char *buf,
size_t len )
{
if( len != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
((void) buf);
if( ssl->conf->extended_ms == MBEDTLS_SSL_EXTENDED_MS_ENABLED &&
ssl->minor_ver != MBEDTLS_SSL_MINOR_VERSION_0 )
{
ssl->handshake->extended_ms = MBEDTLS_SSL_EXTENDED_MS_ENABLED;
}
return( 0 );
}
#endif /* MBEDTLS_SSL_EXTENDED_MASTER_SECRET */
#if defined(MBEDTLS_SSL_SESSION_TICKETS)
static int ssl_parse_session_ticket_ext( mbedtls_ssl_context *ssl,
unsigned char *buf,
size_t len )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
mbedtls_ssl_session session;
mbedtls_ssl_session_init( &session );
if( ssl->conf->f_ticket_parse == NULL ||
ssl->conf->f_ticket_write == NULL )
{
return( 0 );
}
/* Remember the client asked us to send a new ticket */
ssl->handshake->new_session_ticket = 1;
MBEDTLS_SSL_DEBUG_MSG( 3, ( "ticket length: %" MBEDTLS_PRINTF_SIZET, len ) );
if( len == 0 )
return( 0 );
#if defined(MBEDTLS_SSL_RENEGOTIATION)
if( ssl->renego_status != MBEDTLS_SSL_INITIAL_HANDSHAKE )
{
MBEDTLS_SSL_DEBUG_MSG( 3, ( "ticket rejected: renegotiating" ) );
return( 0 );
}
#endif /* MBEDTLS_SSL_RENEGOTIATION */
/*
* Failures are ok: just ignore the ticket and proceed.
*/
if( ( ret = ssl->conf->f_ticket_parse( ssl->conf->p_ticket, &session,
buf, len ) ) != 0 )
{
mbedtls_ssl_session_free( &session );
if( ret == MBEDTLS_ERR_SSL_INVALID_MAC )
MBEDTLS_SSL_DEBUG_MSG( 3, ( "ticket is not authentic" ) );
else if( ret == MBEDTLS_ERR_SSL_SESSION_TICKET_EXPIRED )
MBEDTLS_SSL_DEBUG_MSG( 3, ( "ticket is expired" ) );
else
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_ticket_parse", ret );
return( 0 );
}
/*
* Keep the session ID sent by the client, since we MUST send it back to
* inform them we're accepting the ticket (RFC 5077 section 3.4)
*/
session.id_len = ssl->session_negotiate->id_len;
memcpy( &session.id, ssl->session_negotiate->id, session.id_len );
mbedtls_ssl_session_free( ssl->session_negotiate );
memcpy( ssl->session_negotiate, &session, sizeof( mbedtls_ssl_session ) );
/* Zeroize instead of free as we copied the content */
mbedtls_platform_zeroize( &session, sizeof( mbedtls_ssl_session ) );
MBEDTLS_SSL_DEBUG_MSG( 3, ( "session successfully restored from ticket" ) );
ssl->handshake->resume = 1;
/* Don't send a new ticket after all, this one is OK */
ssl->handshake->new_session_ticket = 0;
return( 0 );
}
#endif /* MBEDTLS_SSL_SESSION_TICKETS */
#if defined(MBEDTLS_SSL_ALPN)
static int ssl_parse_alpn_ext( mbedtls_ssl_context *ssl,
const unsigned char *buf, size_t len )
{
size_t list_len, cur_len, ours_len;
const unsigned char *theirs, *start, *end;
const char **ours;
/* If ALPN not configured, just ignore the extension */
if( ssl->conf->alpn_list == NULL )
return( 0 );
/*
* opaque ProtocolName<1..2^8-1>;
*
* struct {
* ProtocolName protocol_name_list<2..2^16-1>
* } ProtocolNameList;
*/
/* Min length is 2 (list_len) + 1 (name_len) + 1 (name) */
if( len < 4 )
{
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
list_len = ( buf[0] << 8 ) | buf[1];
if( list_len != len - 2 )
{
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
/*
* Validate peer's list (lengths)
*/
start = buf + 2;
end = buf + len;
for( theirs = start; theirs != end; theirs += cur_len )
{
cur_len = *theirs++;
/* Current identifier must fit in list */
if( cur_len > (size_t)( end - theirs ) )
{
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
/* Empty strings MUST NOT be included */
if( cur_len == 0 )
{
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_ILLEGAL_PARAMETER );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
}
/*
* Use our order of preference
*/
for( ours = ssl->conf->alpn_list; *ours != NULL; ours++ )
{
ours_len = strlen( *ours );
for( theirs = start; theirs != end; theirs += cur_len )
{
cur_len = *theirs++;
if( cur_len == ours_len &&
timingsafe_bcmp( theirs, *ours, cur_len ) == 0 )
{
ssl->alpn_chosen = *ours;
return( 0 );
}
}
}
/* If we get there, no match was found */
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_NO_APPLICATION_PROTOCOL );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
#endif /* MBEDTLS_SSL_ALPN */
#if defined(MBEDTLS_SSL_DTLS_SRTP)
static int ssl_parse_use_srtp_ext( mbedtls_ssl_context *ssl,
const unsigned char *buf,
size_t len )
{
mbedtls_ssl_srtp_profile client_protection = MBEDTLS_TLS_SRTP_UNSET;
size_t i,j;
size_t profile_length;
uint16_t mki_length;
/*! 2 bytes for profile length and 1 byte for mki len */
const size_t size_of_lengths = 3;
/* If use_srtp is not configured, just ignore the extension */
if( ( ssl->conf->transport != MBEDTLS_SSL_TRANSPORT_DATAGRAM ) ||
( ssl->conf->dtls_srtp_profile_list == NULL ) ||
( ssl->conf->dtls_srtp_profile_list_len == 0 ) )
{
return( 0 );
}
/* RFC5764 section 4.1.1
* uint8 SRTPProtectionProfile[2];
*
* struct {
* SRTPProtectionProfiles SRTPProtectionProfiles;
* opaque srtp_mki<0..255>;
* } UseSRTPData;
* SRTPProtectionProfile SRTPProtectionProfiles<2..2^16-1>;
*/
/*
* Min length is 5: at least one protection profile(2 bytes)
* and length(2 bytes) + srtp_mki length(1 byte)
* Check here that we have at least 2 bytes of protection profiles length
* and one of srtp_mki length
*/
if( len < size_of_lengths )
{
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
ssl->dtls_srtp_info.chosen_dtls_srtp_profile = MBEDTLS_TLS_SRTP_UNSET;
/* first 2 bytes are protection profile length(in bytes) */
profile_length = ( buf[0] << 8 ) | buf[1];
buf += 2;
/* The profile length cannot be bigger than input buffer size - lengths fields */
if( profile_length > len - size_of_lengths ||
profile_length % 2 != 0 ) /* profiles are 2 bytes long, so the length must be even */
{
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
/*
* parse the extension list values are defined in
* http://www.iana.org/assignments/srtp-protection/srtp-protection.xhtml
*/
for( j = 0; j < profile_length; j += 2 )
{
uint16_t protection_profile_value = buf[j] << 8 | buf[j + 1];
client_protection = mbedtls_ssl_check_srtp_profile_value( protection_profile_value );
if( client_protection != MBEDTLS_TLS_SRTP_UNSET )
{
MBEDTLS_SSL_DEBUG_MSG( 3, ( "found srtp profile: %s",
mbedtls_ssl_get_srtp_profile_as_string(
client_protection ) ) );
}
else
{
continue;
}
/* check if suggested profile is in our list */
for( i = 0; i < ssl->conf->dtls_srtp_profile_list_len; i++)
{
if( client_protection == ssl->conf->dtls_srtp_profile_list[i] )
{
ssl->dtls_srtp_info.chosen_dtls_srtp_profile = ssl->conf->dtls_srtp_profile_list[i];
MBEDTLS_SSL_DEBUG_MSG( 3, ( "selected srtp profile: %s",
mbedtls_ssl_get_srtp_profile_as_string(
client_protection ) ) );
break;
}
}
if( ssl->dtls_srtp_info.chosen_dtls_srtp_profile != MBEDTLS_TLS_SRTP_UNSET )
break;
}
buf += profile_length; /* buf points to the mki length */
mki_length = *buf;
buf++;
if( mki_length > MBEDTLS_TLS_SRTP_MAX_MKI_LENGTH ||
mki_length + profile_length + size_of_lengths != len )
{
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
/* Parse the mki only if present and mki is supported locally */
if( ssl->conf->dtls_srtp_mki_support == MBEDTLS_SSL_DTLS_SRTP_MKI_SUPPORTED &&
mki_length > 0 )
{
ssl->dtls_srtp_info.mki_len = mki_length;
memcpy( ssl->dtls_srtp_info.mki_value, buf, mki_length );
MBEDTLS_SSL_DEBUG_BUF( 3, "using mki", ssl->dtls_srtp_info.mki_value,
ssl->dtls_srtp_info.mki_len );
}
return( 0 );
}
#endif /* MBEDTLS_SSL_DTLS_SRTP */
/*
* Auxiliary functions for ServerHello parsing and related actions
*/
#if defined(MBEDTLS_X509_CRT_PARSE_C)
/*
* Return 0 if the given key uses one of the acceptable curves, -1 otherwise
*/
#if defined(MBEDTLS_ECDSA_C)
static int ssl_check_key_curve( mbedtls_pk_context *pk,
const mbedtls_ecp_curve_info **curves )
{
const mbedtls_ecp_curve_info **crv = curves;
mbedtls_ecp_group_id grp_id = mbedtls_pk_ec( *pk )->grp.id;
while( *crv != NULL )
{
if( (*crv)->grp_id == grp_id )
return( 0 );
crv++;
}
return( -1 );
}
#endif /* MBEDTLS_ECDSA_C */
/*
* Try picking a certificate for this ciphersuite,
* return 0 on success and -1 on failure.
*/
static int ssl_pick_cert( mbedtls_ssl_context *ssl,
const mbedtls_ssl_ciphersuite_t * ciphersuite_info )
{
mbedtls_ssl_key_cert *cur, *list, *fallback = NULL;
mbedtls_pk_type_t pk_alg =
mbedtls_ssl_get_ciphersuite_sig_pk_alg( ciphersuite_info );
uint32_t flags;
#if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
if( ssl->handshake->sni_key_cert != NULL )
list = ssl->handshake->sni_key_cert;
else
#endif
list = ssl->conf->key_cert;
if( pk_alg == MBEDTLS_PK_NONE )
return( 0 );
MBEDTLS_SSL_DEBUG_MSG( 3, ( "ciphersuite requires certificate" ) );
if( list == NULL )
{
MBEDTLS_SSL_DEBUG_MSG( 3, ( "server has no certificate" ) );
return( -1 );
}
for( cur = list; cur != NULL; cur = cur->next )
{
flags = 0;
MBEDTLS_SSL_DEBUG_CRT( 3, "candidate certificate chain, certificate",
cur->cert );
if( ! mbedtls_pk_can_do( &cur->cert->pk, pk_alg ) )
{
MBEDTLS_SSL_DEBUG_MSG( 3, ( "certificate mismatch: key type" ) );
continue;
}
/*
* This avoids sending the client a cert it'll reject based on
* keyUsage or other extensions.
*
* It also allows the user to provision different certificates for
* different uses based on keyUsage, eg if they want to avoid signing
* and decrypting with the same RSA key.
*/
if( mbedtls_ssl_check_cert_usage( cur->cert, ciphersuite_info,
MBEDTLS_SSL_IS_SERVER, &flags ) != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 3, ( "certificate mismatch: "
"(extended) key usage extension" ) );
continue;
}
#if defined(MBEDTLS_ECDSA_C)
if( pk_alg == MBEDTLS_PK_ECDSA &&
ssl_check_key_curve( &cur->cert->pk, ssl->handshake->curves ) != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 3, ( "certificate mismatch: elliptic curve" ) );
continue;
}
#endif
/*
* Try to select a SHA-1 certificate for pre-1.2 clients, but still
* present them a SHA-higher cert rather than failing if it's the only
* one we got that satisfies the other conditions.
*/
if( ssl->minor_ver < MBEDTLS_SSL_MINOR_VERSION_3 &&
cur->cert->sig_md != MBEDTLS_MD_SHA1 )
{
if( fallback == NULL )
fallback = cur;
{
MBEDTLS_SSL_DEBUG_MSG( 3, ( "certificate not preferred: "
"sha-2 with pre-TLS 1.2 client" ) );
continue;
}
}
/* If we get there, we got a winner */
break;
}
if( cur == NULL )
cur = fallback;
/* Do not update ssl->handshake->key_cert unless there is a match */
if( cur != NULL )
{
ssl->handshake->key_cert = cur;
MBEDTLS_SSL_DEBUG_CRT( 3, "selected certificate chain, certificate",
ssl->handshake->key_cert->cert );
return( 0 );
}
return( -1 );
}
#endif /* MBEDTLS_X509_CRT_PARSE_C */
/*
* Check if a given ciphersuite is suitable for use with our config/keys/etc
* Sets ciphersuite_info only if the suite matches.
*/
static int ssl_ciphersuite_match( mbedtls_ssl_context *ssl, int suite_id,
const mbedtls_ssl_ciphersuite_t **ciphersuite_info )
{
const mbedtls_ssl_ciphersuite_t *suite_info;
#if defined(MBEDTLS_SSL_PROTO_TLS1_2) && \
defined(MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED)
mbedtls_pk_type_t sig_type;
#endif
suite_info = mbedtls_ssl_ciphersuite_from_id( suite_id );
if( suite_info == NULL )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
MBEDTLS_SSL_DEBUG_MSG( 3, ( "trying ciphersuite: %#04x (%s)",
(unsigned int) suite_id, suite_info->name ) );
if( suite_info->min_minor_ver > ssl->minor_ver ||
suite_info->max_minor_ver < ssl->minor_ver )
{
MBEDTLS_SSL_DEBUG_MSG( 3, ( "ciphersuite mismatch: version" ) );
return( 0 );
}
#if defined(MBEDTLS_SSL_PROTO_DTLS)
if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM &&
( suite_info->flags & MBEDTLS_CIPHERSUITE_NODTLS ) )
return( 0 );
#endif
#if defined(MBEDTLS_ARC4_C)
if( ssl->conf->arc4_disabled == MBEDTLS_SSL_ARC4_DISABLED &&
suite_info->cipher == MBEDTLS_CIPHER_ARC4_128 )
{
MBEDTLS_SSL_DEBUG_MSG( 3, ( "ciphersuite mismatch: rc4" ) );
return( 0 );
}
#endif
#if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
if( suite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECJPAKE &&
( ssl->handshake->cli_exts & MBEDTLS_TLS_EXT_ECJPAKE_KKPP_OK ) == 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 3, ( "ciphersuite mismatch: ecjpake "
"not configured or ext missing" ) );
return( 0 );
}
#endif
#if defined(MBEDTLS_ECDH_C) || defined(MBEDTLS_ECDSA_C)
if( mbedtls_ssl_ciphersuite_uses_ec( suite_info ) &&
( ssl->handshake->curves == NULL ||
ssl->handshake->curves[0] == NULL ) )
{
MBEDTLS_SSL_DEBUG_MSG( 3, ( "ciphersuite mismatch: "
"no common elliptic curve" ) );
return( 0 );
}
#endif
#if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED)
/* If the ciphersuite requires a pre-shared key and we don't
* have one, skip it now rather than failing later */
if( mbedtls_ssl_ciphersuite_uses_psk( suite_info ) &&
ssl_conf_has_psk_or_cb( ssl->conf ) == 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 3, ( "ciphersuite mismatch: no pre-shared key" ) );
return( 0 );
}
#endif
#if defined(MBEDTLS_SSL_PROTO_TLS1_2) && \
defined(MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED)
/* If the ciphersuite requires signing, check whether
* a suitable hash algorithm is present. */
if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_3 )
{
sig_type = mbedtls_ssl_get_ciphersuite_sig_alg( suite_info );
if( sig_type != MBEDTLS_PK_NONE &&
mbedtls_ssl_sig_hash_set_find( &ssl->handshake->hash_algs, sig_type ) == MBEDTLS_MD_NONE )
{
MBEDTLS_SSL_DEBUG_MSG( 3, ( "ciphersuite mismatch: no suitable hash algorithm "
"for signature algorithm %u", (unsigned) sig_type ) );
return( 0 );
}
}
#endif /* MBEDTLS_SSL_PROTO_TLS1_2 &&
MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED */
#if defined(MBEDTLS_X509_CRT_PARSE_C)
/*
* Final check: if ciphersuite requires us to have a
* certificate/key of a particular type:
* - select the appropriate certificate if we have one, or
* - try the next ciphersuite if we don't
* This must be done last since we modify the key_cert list.
*/
if( ssl_pick_cert( ssl, suite_info ) != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 3, ( "ciphersuite mismatch: "
"no suitable certificate" ) );
return( 0 );
}
#endif
*ciphersuite_info = suite_info;
return( 0 );
}
#if defined(MBEDTLS_SSL_SRV_SUPPORT_SSLV2_CLIENT_HELLO)
static int ssl_parse_client_hello_v2( mbedtls_ssl_context *ssl )
{
size_t n;
unsigned int i, j;
int ret, got_common_suite;
unsigned int ciph_len, sess_len, chal_len;
unsigned char *buf, *p;
const uint16_t *ciphersuites;
const mbedtls_ssl_ciphersuite_t *ciphersuite_info;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> parse client hello v2" ) );
#if defined(MBEDTLS_SSL_RENEGOTIATION)
if( ssl->renego_status != MBEDTLS_SSL_INITIAL_HANDSHAKE )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "client hello v2 illegal for renegotiation" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
#endif /* MBEDTLS_SSL_RENEGOTIATION */
buf = ssl->in_hdr;
MBEDTLS_SSL_DEBUG_BUF( 4, "record header", buf, 5 );
MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello v2, message type: %d",
buf[2] ) );
MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello v2, message len.: %d",
( ( buf[0] & 0x7F ) << 8 ) | buf[1] ) );
MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello v2, max. version: [%d:%d]",
buf[3], buf[4] ) );
/*
* SSLv2 Client Hello
*
* Record layer:
* 0 . 1 message length
*
* SSL layer:
* 2 . 2 message type
* 3 . 4 protocol version
*/
if( buf[2] != MBEDTLS_SSL_HS_CLIENT_HELLO ||
buf[3] != MBEDTLS_SSL_MAJOR_VERSION_3 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
n = ( ( buf[0] << 8 ) | buf[1] ) & 0x7FFF;
if( n < 17 || n > 512 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
ssl->major_ver = MBEDTLS_SSL_MAJOR_VERSION_3;
ssl->minor_ver = ( buf[4] <= ssl->conf->max_minor_ver )
? buf[4] : ssl->conf->max_minor_ver;
if( ssl->minor_ver < ssl->conf->min_minor_ver )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "client only supports ssl smaller than minimum"
" [%d:%d] < [%d:%d]",
ssl->major_ver, ssl->minor_ver,
ssl->conf->min_major_ver, ssl->conf->min_minor_ver ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_PROTOCOL_VERSION );
return( MBEDTLS_ERR_SSL_BAD_HS_PROTOCOL_VERSION );
}
ssl->handshake->max_major_ver = buf[3];
ssl->handshake->max_minor_ver = buf[4];
if( ( ret = mbedtls_ssl_fetch_input( ssl, 2 + n ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_fetch_input", ret );
return( ret );
}
ssl->handshake->update_checksum( ssl, buf + 2, n );
buf = ssl->in_msg;
n = ssl->in_left - 5;
/*
* 0 . 1 ciphersuitelist length
* 2 . 3 session id length
* 4 . 5 challenge length
* 6 . .. ciphersuitelist
* .. . .. session id
* .. . .. challenge
*/
MBEDTLS_SSL_DEBUG_BUF( 4, "record contents", buf, n );
ciph_len = ( buf[0] << 8 ) | buf[1];
sess_len = ( buf[2] << 8 ) | buf[3];
chal_len = ( buf[4] << 8 ) | buf[5];
MBEDTLS_SSL_DEBUG_MSG( 3, ( "ciph_len: %u, sess_len: %u, chal_len: %u",
ciph_len, sess_len, chal_len ) );
/*
* Make sure each parameter length is valid
*/
if( ciph_len < 3 || ( ciph_len % 3 ) != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
if( sess_len > 32 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
if( chal_len < 8 || chal_len > 32 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
if( n != 6 + ciph_len + sess_len + chal_len )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
MBEDTLS_SSL_DEBUG_BUF( 3, "client hello, ciphersuitelist",
buf + 6, ciph_len );
MBEDTLS_SSL_DEBUG_BUF( 3, "client hello, session id",
buf + 6 + ciph_len, sess_len );
MBEDTLS_SSL_DEBUG_BUF( 3, "client hello, challenge",
buf + 6 + ciph_len + sess_len, chal_len );
p = buf + 6 + ciph_len;
ssl->session_negotiate->id_len = sess_len;
memset( ssl->session_negotiate->id, 0,
sizeof( ssl->session_negotiate->id ) );
memcpy( ssl->session_negotiate->id, p, ssl->session_negotiate->id_len );
p += sess_len;
mbedtls_platform_zeroize( ssl->handshake->randbytes, 64 );
memcpy( ssl->handshake->randbytes + 32 - chal_len, p, chal_len );
/*
* Check for TLS_EMPTY_RENEGOTIATION_INFO_SCSV
*/
for( i = 0, p = buf + 6; i < ciph_len; i += 3, p += 3 )
{
if( p[0] == 0 && p[1] == 0 && p[2] == MBEDTLS_SSL_EMPTY_RENEGOTIATION_INFO )
{
MBEDTLS_SSL_DEBUG_MSG( 3, ( "received TLS_EMPTY_RENEGOTIATION_INFO " ) );
#if defined(MBEDTLS_SSL_RENEGOTIATION)
if( ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "received RENEGOTIATION SCSV "
"during renegotiation" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
#endif /* MBEDTLS_SSL_RENEGOTIATION */
ssl->secure_renegotiation = MBEDTLS_SSL_SECURE_RENEGOTIATION;
break;
}
}
#if defined(MBEDTLS_SSL_FALLBACK_SCSV)
for( i = 0, p = buf + 6; i < ciph_len; i += 3, p += 3 )
{
if( p[0] == 0 &&
p[1] == (unsigned char)( ( MBEDTLS_SSL_FALLBACK_SCSV_VALUE >> 8 ) & 0xff ) &&
p[2] == (unsigned char)( ( MBEDTLS_SSL_FALLBACK_SCSV_VALUE ) & 0xff ) )
{
MBEDTLS_SSL_DEBUG_MSG( 3, ( "received FALLBACK_SCSV" ) );
if( ssl->minor_ver < ssl->conf->max_minor_ver )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "inapropriate fallback" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_INAPROPRIATE_FALLBACK );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
break;
}
}
#endif /* MBEDTLS_SSL_FALLBACK_SCSV */
got_common_suite = 0;
ciphersuites = ssl->conf->ciphersuite_list[ssl->minor_ver];
ciphersuite_info = NULL;
/* [jart] grab some client ciphers for error messages */
bzero(ssl->client_ciphers, sizeof(ssl->client_ciphers));
for( i = j = 0, p = buf + 6; j < ciph_len; j += 3, p += 3 )
if( !p[0] && i+1 < ARRAYLEN( ssl->client_ciphers ) )
ssl->client_ciphers[i++] = p[1] << 8 | p[2];
#if defined(MBEDTLS_SSL_SRV_RESPECT_CLIENT_PREFERENCE)
for( j = 0, p = buf + 6; j < ciph_len; j += 3, p += 3 )
for( i = 0; ciphersuites[i] != 0; i++ )
#else
for( i = 0; ciphersuites[i] != 0; i++ )
for( j = 0, p = buf + 6; j < ciph_len; j += 3, p += 3 )
#endif
{
if( p[0] || (p[1] << 8 | p[2]) != ciphersuites[i] )
continue;
got_common_suite = 1;
if( ( ret = ssl_ciphersuite_match( ssl, ciphersuites[i],
&ciphersuite_info ) ) != 0 )
return( ret );
if( ciphersuite_info != NULL )
goto have_ciphersuite_v2;
}
if( got_common_suite )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "got ciphersuites in common, "
"but none of them usable" ) );
return( MBEDTLS_ERR_SSL_NO_USABLE_CIPHERSUITE );
}
else
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "got no ciphersuites in common" ) );
return( MBEDTLS_ERR_SSL_NO_CIPHER_CHOSEN );
}
have_ciphersuite_v2:
MBEDTLS_SSL_DEBUG_MSG( 2, ( "selected ciphersuite: %s", ciphersuite_info->name ) );
ssl->session_negotiate->ciphersuite = ciphersuites[i];
ssl->handshake->ciphersuite_info = ciphersuite_info;
/*
* SSLv2 Client Hello relevant renegotiation security checks
*/
if( ssl->secure_renegotiation == MBEDTLS_SSL_LEGACY_RENEGOTIATION &&
ssl->conf->allow_legacy_renegotiation == MBEDTLS_SSL_LEGACY_BREAK_HANDSHAKE )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "legacy renegotiation, breaking off handshake" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
ssl->in_left = 0;
ssl->state++;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= parse client hello v2" ) );
return( 0 );
}
#endif /* MBEDTLS_SSL_SRV_SUPPORT_SSLV2_CLIENT_HELLO */
/* This function doesn't alert on errors that happen early during
ClientHello parsing because they might indicate that the client is
not talking SSL/TLS at all and would not understand our alert. */
static int ssl_parse_client_hello( mbedtls_ssl_context *ssl )
{
int ret, got_common_suite;
size_t i, j;
size_t ciph_offset, comp_offset, ext_offset;
size_t msg_len, ciph_len, sess_len, comp_len, ext_len;
#if defined(MBEDTLS_SSL_PROTO_DTLS)
size_t cookie_offset, cookie_len;
#endif
unsigned char *buf, *p, *ext;
#if defined(MBEDTLS_SSL_RENEGOTIATION)
int renegotiation_info_seen = 0;
#endif
int handshake_failure = 0;
const uint16_t *ciphersuites;
const mbedtls_ssl_ciphersuite_t *ciphersuite_info;
int major, minor;
/* If there is no signature-algorithm extension present,
* we need to fall back to the default values for allowed
* signature-hash pairs. */
#if defined(MBEDTLS_SSL_PROTO_TLS1_2) && \
defined(MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED)
int sig_hash_alg_ext_present = 0;
#endif /* MBEDTLS_SSL_PROTO_TLS1_2 &&
MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED */
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> parse client hello" ) );
#if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY)
read_record_header:
#endif
/*
* If renegotiating, then the input was read with mbedtls_ssl_read_record(),
* otherwise read it ourselves manually in order to support SSLv2
* ClientHello, which doesn't use the same record layer format.
*/
#if defined(MBEDTLS_SSL_RENEGOTIATION)
if( ssl->renego_status == MBEDTLS_SSL_INITIAL_HANDSHAKE )
#endif
{
if( ( ret = mbedtls_ssl_fetch_input( ssl, 5 ) ) != 0 )
{
/* No alert on a read error. */
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_fetch_input", ret );
return( ret );
}
}
buf = ssl->in_hdr;
#if defined(MBEDTLS_SSL_SRV_SUPPORT_SSLV2_CLIENT_HELLO)
#if defined(MBEDTLS_SSL_PROTO_DTLS)
if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_STREAM )
#endif
if( ( buf[0] & 0x80 ) != 0 )
return( ssl_parse_client_hello_v2( ssl ) );
#endif
MBEDTLS_SSL_DEBUG_BUF( 4, "record header", buf, mbedtls_ssl_in_hdr_len( ssl ) );
/*
* SSLv3/TLS Client Hello
*
* Record layer:
* 0 . 0 message type
* 1 . 2 protocol version
* 3 . 11 DTLS: epoch + record sequence number
* 3 . 4 message length
*/
MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello v3, message type: %d",
buf[0] ) );
if( buf[0] != MBEDTLS_SSL_MSG_HANDSHAKE )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello v3, message len.: %d",
( ssl->in_len[0] << 8 ) | ssl->in_len[1] ) );
MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello v3, protocol version: [%d:%d]",
buf[1], buf[2] ) );
mbedtls_ssl_read_version( &major, &minor, ssl->conf->transport, buf + 1 );
/* According to RFC 5246 Appendix E.1, the version here is typically
* "{03,00}, the lowest version number supported by the client, [or] the
* value of ClientHello.client_version", so the only meaningful check here
* is the major version shouldn't be less than 3 */
if( major < MBEDTLS_SSL_MAJOR_VERSION_3 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
/* For DTLS if this is the initial handshake, remember the client sequence
* number to use it in our next message (RFC 6347 4.2.1) */
#if defined(MBEDTLS_SSL_PROTO_DTLS)
if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM
#if defined(MBEDTLS_SSL_RENEGOTIATION)
&& ssl->renego_status == MBEDTLS_SSL_INITIAL_HANDSHAKE
#endif
)
{
/* Epoch should be 0 for initial handshakes */
if( ssl->in_ctr[0] != 0 || ssl->in_ctr[1] != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
memcpy( ssl->cur_out_ctr + 2, ssl->in_ctr + 2, 6 );
#if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY)
if( mbedtls_ssl_dtls_replay_check( ssl ) != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "replayed record, discarding" ) );
ssl->next_record_offset = 0;
ssl->in_left = 0;
goto read_record_header;
}
/* No MAC to check yet, so we can update right now */
mbedtls_ssl_dtls_replay_update( ssl );
#endif
}
#endif /* MBEDTLS_SSL_PROTO_DTLS */
msg_len = ( ssl->in_len[0] << 8 ) | ssl->in_len[1];
#if defined(MBEDTLS_SSL_RENEGOTIATION)
if( ssl->renego_status != MBEDTLS_SSL_INITIAL_HANDSHAKE )
{
/* Set by mbedtls_ssl_read_record() */
msg_len = ssl->in_hslen;
}
else
#endif
{
if( msg_len > MBEDTLS_SSL_IN_CONTENT_LEN )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
if( ( ret = mbedtls_ssl_fetch_input( ssl,
mbedtls_ssl_in_hdr_len( ssl ) + msg_len ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_fetch_input", ret );
return( ret );
}
/* Done reading this record, get ready for the next one */
#if defined(MBEDTLS_SSL_PROTO_DTLS)
if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
ssl->next_record_offset = msg_len + mbedtls_ssl_in_hdr_len( ssl );
else
#endif
ssl->in_left = 0;
}
buf = ssl->in_msg;
MBEDTLS_SSL_DEBUG_BUF( 4, "record contents", buf, msg_len );
ssl->handshake->update_checksum( ssl, buf, msg_len );
/*
* Handshake layer:
* 0 . 0 handshake type
* 1 . 3 handshake length
* 4 . 5 DTLS only: message seqence number
* 6 . 8 DTLS only: fragment offset
* 9 . 11 DTLS only: fragment length
*/
if( msg_len < mbedtls_ssl_hs_hdr_len( ssl ) )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello v3, handshake type: %d", buf[0] ) );
if( buf[0] != MBEDTLS_SSL_HS_CLIENT_HELLO )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello v3, handshake len.: %d",
( buf[1] << 16 ) | ( buf[2] << 8 ) | buf[3] ) );
/* We don't support fragmentation of ClientHello (yet?) */
if( buf[1] != 0 ||
msg_len != mbedtls_ssl_hs_hdr_len( ssl ) + ( ( buf[2] << 8 ) | buf[3] ) )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
#if defined(MBEDTLS_SSL_PROTO_DTLS)
if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
{
/*
* Copy the client's handshake message_seq on initial handshakes,
* check sequence number on renego.
*/
#if defined(MBEDTLS_SSL_RENEGOTIATION)
if( ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS )
{
/* This couldn't be done in ssl_prepare_handshake_record() */
unsigned int cli_msg_seq = ( ssl->in_msg[4] << 8 ) |
ssl->in_msg[5];
if( cli_msg_seq != ssl->handshake->in_msg_seq )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message_seq: "
"%u (expected %u)", cli_msg_seq,
ssl->handshake->in_msg_seq ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
ssl->handshake->in_msg_seq++;
}
else
#endif /* MBEDTLS_SSL_RENEGOTIATION */
{
unsigned int cli_msg_seq = ( ssl->in_msg[4] << 8 ) |
ssl->in_msg[5];
ssl->handshake->out_msg_seq = cli_msg_seq;
ssl->handshake->in_msg_seq = cli_msg_seq + 1;
}
/*
* For now we don't support fragmentation, so make sure
* fragment_offset == 0 and fragment_length == length
*/
if( ssl->in_msg[6] != 0 || ssl->in_msg[7] != 0 || ssl->in_msg[8] != 0 ||
timingsafe_bcmp( ssl->in_msg + 1, ssl->in_msg + 9, 3 ) != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "ClientHello fragmentation not supported" ) );
return( MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE );
}
}
#endif /* MBEDTLS_SSL_PROTO_DTLS */
buf += mbedtls_ssl_hs_hdr_len( ssl );
msg_len -= mbedtls_ssl_hs_hdr_len( ssl );
/*
* ClientHello layer:
* 0 . 1 protocol version
* 2 . 33 random bytes (starting with 4 bytes of Unix time)
* 34 . 35 session id length (1 byte)
* 35 . 34+x session id
* 35+x . 35+x DTLS only: cookie length (1 byte)
* 36+x . .. DTLS only: cookie
* .. . .. ciphersuite list length (2 bytes)
* .. . .. ciphersuite list
* .. . .. compression alg. list length (1 byte)
* .. . .. compression alg. list
* .. . .. extensions length (2 bytes, optional)
* .. . .. extensions (optional)
*/
/*
* Minimal length (with everything empty and extensions omitted) is
* 2 + 32 + 1 + 2 + 1 = 38 bytes. Check that first, so that we can
* read at least up to session id length without worrying.
*/
if( msg_len < 38 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
/*
* Check and save the protocol version
*/
MBEDTLS_SSL_DEBUG_BUF( 3, "client hello, version", buf, 2 );
mbedtls_ssl_read_version( &ssl->major_ver, &ssl->minor_ver,
ssl->conf->transport, buf );
ssl->handshake->max_major_ver = ssl->major_ver;
ssl->handshake->max_minor_ver = ssl->minor_ver;
if( ssl->major_ver < ssl->conf->min_major_ver ||
ssl->minor_ver < ssl->conf->min_minor_ver )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "client only supports ssl smaller than minimum"
" [%d:%d] < [%d:%d]",
ssl->major_ver, ssl->minor_ver,
ssl->conf->min_major_ver, ssl->conf->min_minor_ver ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_PROTOCOL_VERSION );
return( MBEDTLS_ERR_SSL_BAD_HS_PROTOCOL_VERSION );
}
if( ssl->major_ver > ssl->conf->max_major_ver )
{
ssl->major_ver = ssl->conf->max_major_ver;
ssl->minor_ver = ssl->conf->max_minor_ver;
}
else if( ssl->minor_ver > ssl->conf->max_minor_ver )
ssl->minor_ver = ssl->conf->max_minor_ver;
/*
* Save client random (inc. Unix time)
*/
MBEDTLS_SSL_DEBUG_BUF( 3, "client hello, random bytes", buf + 2, 32 );
memcpy( ssl->handshake->randbytes, buf + 2, 32 );
/*
* Check the session ID length and save session ID
*/
sess_len = buf[34];
if( sess_len > sizeof( ssl->session_negotiate->id ) ||
sess_len + 34 + 2 > msg_len ) /* 2 for cipherlist length field */
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
MBEDTLS_SSL_DEBUG_BUF( 3, "client hello, session id", buf + 35, sess_len );
ssl->session_negotiate->id_len = sess_len;
mbedtls_platform_zeroize( ssl->session_negotiate->id,
sizeof( ssl->session_negotiate->id ) );
memcpy( ssl->session_negotiate->id, buf + 35,
ssl->session_negotiate->id_len );
/*
* Check the cookie length and content
*/
#if defined(MBEDTLS_SSL_PROTO_DTLS)
if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
{
cookie_offset = 35 + sess_len;
cookie_len = buf[cookie_offset];
if( cookie_offset + 1 + cookie_len + 2 > msg_len )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_PROTOCOL_VERSION );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
MBEDTLS_SSL_DEBUG_BUF( 3, "client hello, cookie",
buf + cookie_offset + 1, cookie_len );
#if defined(MBEDTLS_SSL_DTLS_HELLO_VERIFY)
if( ssl->conf->f_cookie_check != NULL
#if defined(MBEDTLS_SSL_RENEGOTIATION)
&& ssl->renego_status == MBEDTLS_SSL_INITIAL_HANDSHAKE
#endif
)
{
if( ssl->conf->f_cookie_check( ssl->conf->p_cookie,
buf + cookie_offset + 1, cookie_len,
ssl->cli_id, ssl->cli_id_len ) != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 2, ( "cookie verification failed" ) );
ssl->handshake->verify_cookie_len = 1;
}
else
{
MBEDTLS_SSL_DEBUG_MSG( 2, ( "cookie verification passed" ) );
ssl->handshake->verify_cookie_len = 0;
}
}
else
#endif /* MBEDTLS_SSL_DTLS_HELLO_VERIFY */
{
/* We know we didn't send a cookie, so it should be empty */
if( cookie_len != 0 )
{
/* This may be an attacker's probe, so don't send an alert */
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
MBEDTLS_SSL_DEBUG_MSG( 2, ( "cookie verification skipped" ) );
}
/*
* Check the ciphersuitelist length (will be parsed later)
*/
ciph_offset = cookie_offset + 1 + cookie_len;
}
else
#endif /* MBEDTLS_SSL_PROTO_DTLS */
ciph_offset = 35 + sess_len;
ciph_len = ( buf[ciph_offset + 0] << 8 )
| ( buf[ciph_offset + 1] );
if( ciph_len < 2 ||
ciph_len + 2 + ciph_offset + 1 > msg_len || /* 1 for comp. alg. len */
( ciph_len % 2 ) != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
MBEDTLS_SSL_DEBUG_BUF( 3, "client hello, ciphersuitelist",
buf + ciph_offset + 2, ciph_len );
/*
* Check the compression algorithms length and pick one
*/
comp_offset = ciph_offset + 2 + ciph_len;
comp_len = buf[comp_offset];
if( comp_len < 1 ||
comp_len > 16 ||
comp_len + comp_offset + 1 > msg_len )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
MBEDTLS_SSL_DEBUG_BUF( 3, "client hello, compression",
buf + comp_offset + 1, comp_len );
ssl->session_negotiate->compression = MBEDTLS_SSL_COMPRESS_NULL;
#if defined(MBEDTLS_ZLIB_SUPPORT)
if( !ssl->conf->disable_compression )
{
for( i = 0; i < comp_len; ++i )
{
if( buf[comp_offset + 1 + i] == MBEDTLS_SSL_COMPRESS_DEFLATE )
{
ssl->session_negotiate->compression = MBEDTLS_SSL_COMPRESS_DEFLATE;
break;
}
}
}
#endif
/* See comments in ssl_write_client_hello() */
#if defined(MBEDTLS_SSL_PROTO_DTLS)
if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
ssl->session_negotiate->compression = MBEDTLS_SSL_COMPRESS_NULL;
#endif
/* Do not parse the extensions if the protocol is SSLv3 */
#if defined(MBEDTLS_SSL_PROTO_SSL3)
if( ( ssl->major_ver != 3 ) || ( ssl->minor_ver != 0 ) )
{
#endif
/*
* Check the extension length
*/
ext_offset = comp_offset + 1 + comp_len;
if( msg_len > ext_offset )
{
if( msg_len < ext_offset + 2 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
ext_len = ( buf[ext_offset + 0] << 8 )
| ( buf[ext_offset + 1] );
if( ( ext_len > 0 && ext_len < 4 ) ||
msg_len != ext_offset + 2 + ext_len )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
}
else
ext_len = 0;
ext = buf + ext_offset + 2;
MBEDTLS_SSL_DEBUG_BUF( 3, "client hello extensions", ext, ext_len );
while( ext_len != 0 )
{
unsigned int ext_id;
unsigned int ext_size;
if ( ext_len < 4 ) {
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
ext_id = ( ( ext[0] << 8 ) | ( ext[1] ) );
ext_size = ( ( ext[2] << 8 ) | ( ext[3] ) );
if( ext_size + 4 > ext_len )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
switch( ext_id )
{
#if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
case MBEDTLS_TLS_EXT_SERVERNAME:
MBEDTLS_SSL_DEBUG_MSG( 3, ( "found ServerName extension" ) );
if( ssl->conf->f_sni == NULL )
break;
ret = ssl_parse_servername_ext( ssl, ext + 4, ext_size );
if( ret != 0 )
return( ret );
break;
#endif /* MBEDTLS_SSL_SERVER_NAME_INDICATION */
case MBEDTLS_TLS_EXT_RENEGOTIATION_INFO:
MBEDTLS_SSL_DEBUG_MSG( 3, ( "found renegotiation extension" ) );
#if defined(MBEDTLS_SSL_RENEGOTIATION)
renegotiation_info_seen = 1;
#endif
ret = ssl_parse_renegotiation_info( ssl, ext + 4, ext_size );
if( ret != 0 )
return( ret );
break;
#if defined(MBEDTLS_SSL_PROTO_TLS1_2) && \
defined(MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED)
case MBEDTLS_TLS_EXT_SIG_ALG:
MBEDTLS_SSL_DEBUG_MSG( 3, ( "found signature_algorithms extension" ) );
ret = ssl_parse_signature_algorithms_ext( ssl, ext + 4, ext_size );
if( ret != 0 )
return( ret );
sig_hash_alg_ext_present = 1;
break;
#endif /* MBEDTLS_SSL_PROTO_TLS1_2 &&
MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED */
#if defined(MBEDTLS_ECDH_C) || defined(MBEDTLS_ECDSA_C) || \
defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
case MBEDTLS_TLS_EXT_SUPPORTED_ELLIPTIC_CURVES:
MBEDTLS_SSL_DEBUG_MSG( 3, ( "found supported elliptic curves extension" ) );
ret = ssl_parse_supported_elliptic_curves( ssl, ext + 4, ext_size );
if( ret != 0 )
return( ret );
break;
case MBEDTLS_TLS_EXT_SUPPORTED_POINT_FORMATS:
MBEDTLS_SSL_DEBUG_MSG( 3, ( "found supported point formats extension" ) );
ssl->handshake->cli_exts |= MBEDTLS_TLS_EXT_SUPPORTED_POINT_FORMATS_PRESENT;
ret = ssl_parse_supported_point_formats( ssl, ext + 4, ext_size );
if( ret != 0 )
return( ret );
break;
#endif /* MBEDTLS_ECDH_C || MBEDTLS_ECDSA_C ||
MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
case MBEDTLS_TLS_EXT_ECJPAKE_KKPP:
MBEDTLS_SSL_DEBUG_MSG( 3, ( "found ecjpake kkpp extension" ) );
ret = ssl_parse_ecjpake_kkpp( ssl, ext + 4, ext_size );
if( ret != 0 )
return( ret );
break;
#endif /* MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED */
#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
case MBEDTLS_TLS_EXT_MAX_FRAGMENT_LENGTH:
MBEDTLS_SSL_DEBUG_MSG( 3, ( "found max fragment length extension" ) );
ret = ssl_parse_max_fragment_length_ext( ssl, ext + 4, ext_size );
if( ret != 0 )
return( ret );
break;
#endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */
#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
case MBEDTLS_TLS_EXT_CID:
MBEDTLS_SSL_DEBUG_MSG( 3, ( "found CID extension" ) );
#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
case MBEDTLS_TLS_EXT_ENCRYPT_THEN_MAC:
MBEDTLS_SSL_DEBUG_MSG( 3, ( "found encrypt then mac extension" ) );
ret = ssl_parse_encrypt_then_mac_ext( ssl, ext + 4, ext_size );
if( ret != 0 )
return( ret );
break;
#endif /* MBEDTLS_SSL_ENCRYPT_THEN_MAC */
#if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
case MBEDTLS_TLS_EXT_EXTENDED_MASTER_SECRET:
MBEDTLS_SSL_DEBUG_MSG( 3, ( "found extended master secret extension" ) );
ret = ssl_parse_extended_ms_ext( ssl, ext + 4, ext_size );
if( ret != 0 )
return( ret );
break;
#endif /* MBEDTLS_SSL_EXTENDED_MASTER_SECRET */
#if defined(MBEDTLS_SSL_SESSION_TICKETS)
case MBEDTLS_TLS_EXT_SESSION_TICKET:
MBEDTLS_SSL_DEBUG_MSG( 3, ( "found session ticket extension" ) );
ret = ssl_parse_session_ticket_ext( ssl, ext + 4, ext_size );
if( ret != 0 )
return( ret );
break;
#endif /* MBEDTLS_SSL_SESSION_TICKETS */
#if defined(MBEDTLS_SSL_ALPN)
case MBEDTLS_TLS_EXT_ALPN:
MBEDTLS_SSL_DEBUG_MSG( 3, ( "found alpn extension" ) );
ret = ssl_parse_alpn_ext( ssl, ext + 4, ext_size );
if( ret != 0 )
return( ret );
break;
#endif /* MBEDTLS_SSL_SESSION_TICKETS */
#if defined(MBEDTLS_SSL_DTLS_SRTP)
case MBEDTLS_TLS_EXT_USE_SRTP:
MBEDTLS_SSL_DEBUG_MSG( 3, ( "found use_srtp extension" ) );
ret = ssl_parse_use_srtp_ext( ssl, ext + 4, ext_size );
if( ret != 0 )
return( ret );
break;
#endif /* MBEDTLS_SSL_DTLS_SRTP */
default:
MBEDTLS_SSL_DEBUG_MSG( 3, ( "unknown extension found: %u (ignoring)",
ext_id ) );
}
ext_len -= 4 + ext_size;
ext += 4 + ext_size;
if( ext_len > 0 && ext_len < 4 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
}
#if defined(MBEDTLS_SSL_PROTO_SSL3)
}
#endif
#if defined(MBEDTLS_SSL_FALLBACK_SCSV)
for( i = 0, p = buf + ciph_offset + 2; i < ciph_len; i += 2, p += 2 )
{
if( p[0] == (unsigned char)( ( MBEDTLS_SSL_FALLBACK_SCSV_VALUE >> 8 ) & 0xff ) &&
p[1] == (unsigned char)( ( MBEDTLS_SSL_FALLBACK_SCSV_VALUE ) & 0xff ) )
{
MBEDTLS_SSL_DEBUG_MSG( 2, ( "received FALLBACK_SCSV" ) );
if( ssl->minor_ver < ssl->conf->max_minor_ver )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "inapropriate fallback" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_INAPROPRIATE_FALLBACK );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
break;
}
}
#endif /* MBEDTLS_SSL_FALLBACK_SCSV */
#if defined(MBEDTLS_SSL_PROTO_TLS1_2) && \
defined(MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED)
/*
* Try to fall back to default hash SHA1 if the client
* hasn't provided any preferred signature-hash combinations.
*/
if( sig_hash_alg_ext_present == 0 )
{
mbedtls_md_type_t md_default = MBEDTLS_MD_SHA1;
if( mbedtls_ssl_check_sig_hash( ssl, md_default ) != 0 )
md_default = MBEDTLS_MD_NONE;
mbedtls_ssl_sig_hash_set_const_hash( &ssl->handshake->hash_algs, md_default );
}
#endif /* MBEDTLS_SSL_PROTO_TLS1_2 &&
MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED */
/*
* Check for TLS_EMPTY_RENEGOTIATION_INFO_SCSV
*/
for( i = 0, p = buf + ciph_offset + 2; i < ciph_len; i += 2, p += 2 )
{
if( p[0] == 0 && p[1] == MBEDTLS_SSL_EMPTY_RENEGOTIATION_INFO )
{
MBEDTLS_SSL_DEBUG_MSG( 3, ( "received TLS_EMPTY_RENEGOTIATION_INFO " ) );
#if defined(MBEDTLS_SSL_RENEGOTIATION)
if( ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "received RENEGOTIATION SCSV "
"during renegotiation" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
#endif
ssl->secure_renegotiation = MBEDTLS_SSL_SECURE_RENEGOTIATION;
break;
}
}
/*
* Renegotiation security checks
*/
if( ssl->secure_renegotiation != MBEDTLS_SSL_SECURE_RENEGOTIATION &&
ssl->conf->allow_legacy_renegotiation == MBEDTLS_SSL_LEGACY_BREAK_HANDSHAKE )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "legacy renegotiation, breaking off handshake" ) );
handshake_failure = 1;
}
#if defined(MBEDTLS_SSL_RENEGOTIATION)
else if( ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS &&
ssl->secure_renegotiation == MBEDTLS_SSL_SECURE_RENEGOTIATION &&
renegotiation_info_seen == 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "renegotiation_info extension missing (secure)" ) );
handshake_failure = 1;
}
else if( ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS &&
ssl->secure_renegotiation == MBEDTLS_SSL_LEGACY_RENEGOTIATION &&
ssl->conf->allow_legacy_renegotiation == MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "legacy renegotiation not allowed" ) );
handshake_failure = 1;
}
else if( ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS &&
ssl->secure_renegotiation == MBEDTLS_SSL_LEGACY_RENEGOTIATION &&
renegotiation_info_seen == 1 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "renegotiation_info extension present (legacy)" ) );
handshake_failure = 1;
}
#endif /* MBEDTLS_SSL_RENEGOTIATION */
if( handshake_failure == 1 )
{
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO );
}
/* [jart] grab some client ciphers for error messages */
bzero(ssl->client_ciphers, sizeof(ssl->client_ciphers));
for( i = j = 0, p = buf + ciph_offset + 2; j < ciph_len; j += 2, p += 2 )
if( i+1 < ARRAYLEN( ssl->client_ciphers ) )
ssl->client_ciphers[i++] = p[0] << 8 | p[1];
/*
* Search for a matching ciphersuite
* (At the end because we need information from the EC-based extensions
* and certificate from the SNI callback triggered by the SNI extension.)
*/
got_common_suite = 0;
ciphersuites = ssl->conf->ciphersuite_list[ssl->minor_ver];
ciphersuite_info = NULL;
#if defined(MBEDTLS_SSL_SRV_RESPECT_CLIENT_PREFERENCE)
for( j = 0, p = buf + ciph_offset + 2; j < ciph_len; j += 2, p += 2 )
for( i = 0; ciphersuites[i] != 0; i++ )
#else
for( i = 0; ciphersuites[i] != 0; i++ )
for( j = 0, p = buf + ciph_offset + 2; j < ciph_len; j += 2, p += 2 )
#endif
{
if( p[0] != ( ( ciphersuites[i] >> 8 ) & 0xFF ) ||
p[1] != ( ( ciphersuites[i] ) & 0xFF ) )
continue;
got_common_suite = 1;
if( ( ret = ssl_ciphersuite_match( ssl, ciphersuites[i],
&ciphersuite_info ) ) != 0 )
return( ret );
if( ciphersuite_info != NULL )
goto have_ciphersuite;
}
if( got_common_suite )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "got ciphersuites in common, "
"but none of them usable" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE );
return( MBEDTLS_ERR_SSL_NO_USABLE_CIPHERSUITE );
}
else
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "got no ciphersuites in common" ) );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE );
return( MBEDTLS_ERR_SSL_NO_CIPHER_CHOSEN );
}
have_ciphersuite:
MBEDTLS_SSL_DEBUG_MSG( 2, ( "selected ciphersuite: %s", ciphersuite_info->name ) );
ssl->session_negotiate->ciphersuite = ciphersuites[i];
ssl->handshake->ciphersuite_info = ciphersuite_info;
ssl->state++;
#if defined(MBEDTLS_SSL_PROTO_DTLS)
if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
mbedtls_ssl_recv_flight_completed( ssl );
#endif
/* Debugging-only output for testsuite */
#if defined(MBEDTLS_DEBUG_C) && \
defined(MBEDTLS_SSL_PROTO_TLS1_2) && \
defined(MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED)
if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_3 )
{
mbedtls_pk_type_t sig_alg = mbedtls_ssl_get_ciphersuite_sig_alg( ciphersuite_info );
if( sig_alg != MBEDTLS_PK_NONE )
{
mbedtls_md_type_t md_alg = mbedtls_ssl_sig_hash_set_find( &ssl->handshake->hash_algs,
sig_alg );
MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello v3, signature_algorithm ext: %d",
mbedtls_ssl_hash_from_md_alg( md_alg ) ) );
}
else
{
MBEDTLS_SSL_DEBUG_MSG( 3, ( "no hash algorithm for signature algorithm "
"%u - should not happen", (unsigned) sig_alg ) );
}
}
#endif
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= parse client hello" ) );
return( 0 );
}
#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
static void ssl_write_cid_ext( mbedtls_ssl_context *ssl,
unsigned char *buf,
size_t *olen )
{
unsigned char *p = buf;
size_t ext_len;
const unsigned char *end = ssl->out_msg + MBEDTLS_SSL_OUT_CONTENT_LEN;
*olen = 0;
/* Skip writing the extension if we don't want to use it or if
* the client hasn't offered it. */
if( ssl->handshake->cid_in_use == MBEDTLS_SSL_CID_DISABLED )
return;
/* ssl->own_cid_len is at most MBEDTLS_SSL_CID_IN_LEN_MAX
* which is at most 255, so the increment cannot overflow. */
if( end < p || (size_t)( end - p ) < (unsigned)( ssl->own_cid_len + 5 ) )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "buffer too small" ) );
return;
}
MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, adding CID extension" ) );
/*
* Quoting draft-ietf-tls-dtls-connection-id-05
* https://tools.ietf.org/html/draft-ietf-tls-dtls-connection-id-05
*
* struct {
* opaque cid<0..2^8-1>;
* } ConnectionId;
*/
*p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_CID >> 8 ) & 0xFF );
*p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_CID ) & 0xFF );
ext_len = (size_t) ssl->own_cid_len + 1;
*p++ = (unsigned char)( ( ext_len >> 8 ) & 0xFF );
*p++ = (unsigned char)( ( ext_len ) & 0xFF );
*p++ = (uint8_t) ssl->own_cid_len;
memcpy( p, ssl->own_cid, ssl->own_cid_len );
*olen = ssl->own_cid_len + 5;
}
#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
static void ssl_write_encrypt_then_mac_ext( mbedtls_ssl_context *ssl,
unsigned char *buf,
size_t *olen )
{
unsigned char *p = buf;
const mbedtls_ssl_ciphersuite_t *suite = NULL;
const mbedtls_cipher_info_t *cipher = NULL;
if( ssl->session_negotiate->encrypt_then_mac == MBEDTLS_SSL_ETM_DISABLED ||
ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_0 )
{
*olen = 0;
return;
}
/*
* RFC 7366: "If a server receives an encrypt-then-MAC request extension
* from a client and then selects a stream or Authenticated Encryption
* with Associated Data (AEAD) ciphersuite, it MUST NOT send an
* encrypt-then-MAC response extension back to the client."
*/
if( ( suite = mbedtls_ssl_ciphersuite_from_id(
ssl->session_negotiate->ciphersuite ) ) == NULL ||
( cipher = mbedtls_cipher_info_from_type( suite->cipher ) ) == NULL ||
cipher->mode != MBEDTLS_MODE_CBC )
{
*olen = 0;
return;
}
MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, adding encrypt then mac extension" ) );
*p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_ENCRYPT_THEN_MAC >> 8 ) & 0xFF );
*p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_ENCRYPT_THEN_MAC ) & 0xFF );
*p++ = 0x00;
*p++ = 0x00;
*olen = 4;
}
#endif /* MBEDTLS_SSL_ENCRYPT_THEN_MAC */
#if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
static void ssl_write_extended_ms_ext( mbedtls_ssl_context *ssl,
unsigned char *buf,
size_t *olen )
{
unsigned char *p = buf;
if( ssl->handshake->extended_ms == MBEDTLS_SSL_EXTENDED_MS_DISABLED ||
ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_0 )
{
*olen = 0;
return;
}
MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, adding extended master secret "
"extension" ) );
*p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_EXTENDED_MASTER_SECRET >> 8 ) & 0xFF );
*p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_EXTENDED_MASTER_SECRET ) & 0xFF );
*p++ = 0x00;
*p++ = 0x00;
*olen = 4;
}
#endif /* MBEDTLS_SSL_EXTENDED_MASTER_SECRET */
#if defined(MBEDTLS_SSL_SESSION_TICKETS)
static void ssl_write_session_ticket_ext( mbedtls_ssl_context *ssl,
unsigned char *buf,
size_t *olen )
{
unsigned char *p = buf;
if( ssl->handshake->new_session_ticket == 0 )
{
*olen = 0;
return;
}
MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, adding session ticket extension" ) );
*p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_SESSION_TICKET >> 8 ) & 0xFF );
*p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_SESSION_TICKET ) & 0xFF );
*p++ = 0x00;
*p++ = 0x00;
*olen = 4;
}
#endif /* MBEDTLS_SSL_SESSION_TICKETS */
static void ssl_write_renegotiation_ext( mbedtls_ssl_context *ssl,
unsigned char *buf,
size_t *olen )
{
unsigned char *p = buf;
if( ssl->secure_renegotiation != MBEDTLS_SSL_SECURE_RENEGOTIATION )
{
*olen = 0;
return;
}
MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, secure renegotiation extension" ) );
*p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_RENEGOTIATION_INFO >> 8 ) & 0xFF );
*p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_RENEGOTIATION_INFO ) & 0xFF );
#if defined(MBEDTLS_SSL_RENEGOTIATION)
if( ssl->renego_status != MBEDTLS_SSL_INITIAL_HANDSHAKE )
{
*p++ = 0x00;
*p++ = ( ssl->verify_data_len * 2 + 1 ) & 0xFF;
*p++ = ssl->verify_data_len * 2 & 0xFF;
memcpy( p, ssl->peer_verify_data, ssl->verify_data_len );
p += ssl->verify_data_len;
memcpy( p, ssl->own_verify_data, ssl->verify_data_len );
p += ssl->verify_data_len;
}
else
#endif /* MBEDTLS_SSL_RENEGOTIATION */
{
*p++ = 0x00;
*p++ = 0x01;
*p++ = 0x00;
}
*olen = p - buf;
}
#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
static void ssl_write_max_fragment_length_ext( mbedtls_ssl_context *ssl,
unsigned char *buf,
size_t *olen )
{
unsigned char *p = buf;
if( ssl->session_negotiate->mfl_code == MBEDTLS_SSL_MAX_FRAG_LEN_NONE )
{
*olen = 0;
return;
}
MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, max_fragment_length extension" ) );
*p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_MAX_FRAGMENT_LENGTH >> 8 ) & 0xFF );
*p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_MAX_FRAGMENT_LENGTH ) & 0xFF );
*p++ = 0x00;
*p++ = 1;
*p++ = ssl->session_negotiate->mfl_code;
*olen = 5;
}
#endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */
#if defined(MBEDTLS_ECDH_C) || defined(MBEDTLS_ECDSA_C) || \
defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
static void ssl_write_supported_point_formats_ext( mbedtls_ssl_context *ssl,
unsigned char *buf,
size_t *olen )
{
unsigned char *p = buf;
((void) ssl);
if( ( ssl->handshake->cli_exts &
MBEDTLS_TLS_EXT_SUPPORTED_POINT_FORMATS_PRESENT ) == 0 )
{
*olen = 0;
return;
}
MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, supported_point_formats extension" ) );
*p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_SUPPORTED_POINT_FORMATS >> 8 ) & 0xFF );
*p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_SUPPORTED_POINT_FORMATS ) & 0xFF );
*p++ = 0x00;
*p++ = 2;
*p++ = 1;
*p++ = MBEDTLS_ECP_PF_UNCOMPRESSED;
*olen = 6;
}
#endif /* MBEDTLS_ECDH_C || MBEDTLS_ECDSA_C || MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
static void ssl_write_ecjpake_kkpp_ext( mbedtls_ssl_context *ssl,
unsigned char *buf,
size_t *olen )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
unsigned char *p = buf;
const unsigned char *end = ssl->out_msg + MBEDTLS_SSL_OUT_CONTENT_LEN;
size_t kkpp_len;
*olen = 0;
/* Skip costly computation if not needed */
if( ssl->handshake->ciphersuite_info->key_exchange !=
MBEDTLS_KEY_EXCHANGE_ECJPAKE )
return;
MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, ecjpake kkpp extension" ) );
if( end - p < 4 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "buffer too small" ) );
return;
}
*p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_ECJPAKE_KKPP >> 8 ) & 0xFF );
*p++ = (unsigned char)( ( MBEDTLS_TLS_EXT_ECJPAKE_KKPP ) & 0xFF );
ret = mbedtls_ecjpake_write_round_one( &ssl->handshake->ecjpake_ctx,
p + 2, end - p - 2, &kkpp_len,
ssl->conf->f_rng, ssl->conf->p_rng );
if( ret != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1 , "mbedtls_ecjpake_write_round_one", ret );
return;
}
*p++ = (unsigned char)( ( kkpp_len >> 8 ) & 0xFF );
*p++ = (unsigned char)( ( kkpp_len ) & 0xFF );
*olen = kkpp_len + 4;
}
#endif /* MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED */
#if defined(MBEDTLS_SSL_ALPN )
static void ssl_write_alpn_ext( mbedtls_ssl_context *ssl,
unsigned char *buf, size_t *olen )
{
if( ssl->alpn_chosen == NULL )
{
*olen = 0;
return;
}
MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, adding alpn extension" ) );
/*
* 0 . 1 ext identifier
* 2 . 3 ext length
* 4 . 5 protocol list length
* 6 . 6 protocol name length
* 7 . 7+n protocol name
*/
buf[0] = (unsigned char)( ( MBEDTLS_TLS_EXT_ALPN >> 8 ) & 0xFF );
buf[1] = (unsigned char)( ( MBEDTLS_TLS_EXT_ALPN ) & 0xFF );
*olen = 7 + strlen( ssl->alpn_chosen );
buf[2] = (unsigned char)( ( ( *olen - 4 ) >> 8 ) & 0xFF );
buf[3] = (unsigned char)( ( ( *olen - 4 ) ) & 0xFF );
buf[4] = (unsigned char)( ( ( *olen - 6 ) >> 8 ) & 0xFF );
buf[5] = (unsigned char)( ( ( *olen - 6 ) ) & 0xFF );
buf[6] = (unsigned char)( ( ( *olen - 7 ) ) & 0xFF );
memcpy( buf + 7, ssl->alpn_chosen, *olen - 7 );
}
#endif /* MBEDTLS_ECDH_C || MBEDTLS_ECDSA_C */
#if defined(MBEDTLS_SSL_DTLS_SRTP ) && defined(MBEDTLS_SSL_PROTO_DTLS)
static void ssl_write_use_srtp_ext( mbedtls_ssl_context *ssl,
unsigned char *buf,
size_t *olen )
{
size_t mki_len = 0, ext_len = 0;
uint16_t profile_value = 0;
const unsigned char *end = ssl->out_msg + MBEDTLS_SSL_OUT_CONTENT_LEN;
*olen = 0;
if( ( ssl->conf->transport != MBEDTLS_SSL_TRANSPORT_DATAGRAM ) ||
( ssl->dtls_srtp_info.chosen_dtls_srtp_profile == MBEDTLS_TLS_SRTP_UNSET ) )
{
return;
}
MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, adding use_srtp extension" ) );
if( ssl->conf->dtls_srtp_mki_support == MBEDTLS_SSL_DTLS_SRTP_MKI_SUPPORTED )
{
mki_len = ssl->dtls_srtp_info.mki_len;
}
/* The extension total size is 9 bytes :
* - 2 bytes for the extension tag
* - 2 bytes for the total size
* - 2 bytes for the protection profile length
* - 2 bytes for the protection profile
* - 1 byte for the mki length
* + the actual mki length
* Check we have enough room in the output buffer */
if( (size_t)( end - buf ) < mki_len + 9 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "buffer too small" ) );
return;
}
/* extension */
buf[0] = (unsigned char)( ( MBEDTLS_TLS_EXT_USE_SRTP >> 8 ) & 0xFF );
buf[1] = (unsigned char)( ( MBEDTLS_TLS_EXT_USE_SRTP ) & 0xFF );
/*
* total length 5 and mki value: only one profile(2 bytes)
* and length(2 bytes) and srtp_mki )
*/
ext_len = 5 + mki_len;
buf[2] = (unsigned char)( ( ext_len >> 8 ) & 0xFF );
buf[3] = (unsigned char)( ext_len & 0xFF );
/* protection profile length: 2 */
buf[4] = 0x00;
buf[5] = 0x02;
profile_value = mbedtls_ssl_check_srtp_profile_value(
ssl->dtls_srtp_info.chosen_dtls_srtp_profile );
if( profile_value != MBEDTLS_TLS_SRTP_UNSET )
{
buf[6] = (unsigned char)( ( profile_value >> 8 ) & 0xFF );
buf[7] = (unsigned char)( profile_value & 0xFF );
}
else
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "use_srtp extension invalid profile" ) );
return;
}
buf[8] = mki_len & 0xFF;
memcpy( &buf[9], ssl->dtls_srtp_info.mki_value, mki_len );
*olen = 9 + mki_len;
}
#endif /* MBEDTLS_SSL_DTLS_SRTP */
#if defined(MBEDTLS_SSL_DTLS_HELLO_VERIFY)
static int ssl_write_hello_verify_request( mbedtls_ssl_context *ssl )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
unsigned char *p = ssl->out_msg + 4;
unsigned char *cookie_len_byte;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write hello verify request" ) );
/*
* struct {
* ProtocolVersion server_version;
* opaque cookie<0..2^8-1>;
* } HelloVerifyRequest;
*/
/* The RFC is not clear on this point, but sending the actual negotiated
* version looks like the most interoperable thing to do. */
mbedtls_ssl_write_version( ssl->major_ver, ssl->minor_ver,
ssl->conf->transport, p );
MBEDTLS_SSL_DEBUG_BUF( 3, "server version", p, 2 );
p += 2;
/* If we get here, f_cookie_check is not null */
if( ssl->conf->f_cookie_write == NULL )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "inconsistent cookie callbacks" ) );
return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
/* Skip length byte until we know the length */
cookie_len_byte = p++;
if( ( ret = ssl->conf->f_cookie_write( ssl->conf->p_cookie,
&p, ssl->out_buf + MBEDTLS_SSL_OUT_BUFFER_LEN,
ssl->cli_id, ssl->cli_id_len ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "f_cookie_write", ret );
return( ret );
}
*cookie_len_byte = (unsigned char)( p - ( cookie_len_byte + 1 ) );
MBEDTLS_SSL_DEBUG_BUF( 3, "cookie sent", cookie_len_byte + 1, *cookie_len_byte );
ssl->out_msglen = p - ssl->out_msg;
ssl->out_msgtype = MBEDTLS_SSL_MSG_HANDSHAKE;
ssl->out_msg[0] = MBEDTLS_SSL_HS_HELLO_VERIFY_REQUEST;
ssl->state = MBEDTLS_SSL_SERVER_HELLO_VERIFY_REQUEST_SENT;
if( ( ret = mbedtls_ssl_write_handshake_msg( ssl ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_write_handshake_msg", ret );
return( ret );
}
#if defined(MBEDTLS_SSL_PROTO_DTLS)
if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM &&
( ret = mbedtls_ssl_flight_transmit( ssl ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_flight_transmit", ret );
return( ret );
}
#endif /* MBEDTLS_SSL_PROTO_DTLS */
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= write hello verify request" ) );
return( 0 );
}
#endif /* MBEDTLS_SSL_DTLS_HELLO_VERIFY */
static int ssl_write_server_hello( mbedtls_ssl_context *ssl )
{
#if defined(MBEDTLS_HAVE_TIME)
mbedtls_time_t t;
#endif
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t olen, ext_len = 0, n;
unsigned char *buf, *p;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write server hello" ) );
#if defined(MBEDTLS_SSL_DTLS_HELLO_VERIFY)
if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM &&
ssl->handshake->verify_cookie_len != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 2, ( "client hello was not authenticated" ) );
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= write server hello" ) );
return( ssl_write_hello_verify_request( ssl ) );
}
#endif /* MBEDTLS_SSL_DTLS_HELLO_VERIFY */
if( ssl->conf->f_rng == NULL )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "no RNG provided") );
return( MBEDTLS_ERR_SSL_NO_RNG );
}
/*
* 0 . 0 handshake type
* 1 . 3 handshake length
* 4 . 5 protocol version
* 6 . 9 UNIX time()
* 10 . 37 random bytes
*/
buf = ssl->out_msg;
p = buf + 4;
mbedtls_ssl_write_version( ssl->major_ver, ssl->minor_ver,
ssl->conf->transport, p );
p += 2;
MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, chosen version: [%d:%d]",
buf[4], buf[5] ) );
#if defined(MBEDTLS_HAVE_TIME)
t = mbedtls_time( NULL );
*p++ = (unsigned char)( t >> 24 );
*p++ = (unsigned char)( t >> 16 );
*p++ = (unsigned char)( t >> 8 );
*p++ = (unsigned char)( t );
MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, current time: %" MBEDTLS_PRINTF_LONGLONG,
(long long) t ) );
#else
if( ( ret = ssl->conf->f_rng( ssl->conf->p_rng, p, 4 ) ) != 0 )
return( ret );
p += 4;
#endif /* MBEDTLS_HAVE_TIME */
if( ( ret = ssl->conf->f_rng( ssl->conf->p_rng, p, 28 ) ) != 0 )
return( ret );
p += 28;
memcpy( ssl->handshake->randbytes + 32, buf + 6, 32 );
MBEDTLS_SSL_DEBUG_BUF( 3, "server hello, random bytes", buf + 6, 32 );
/*
* Resume is 0 by default, see ssl_handshake_init().
* It may be already set to 1 by ssl_parse_session_ticket_ext().
* If not, try looking up session ID in our cache.
*/
if( ssl->handshake->resume == 0 &&
#if defined(MBEDTLS_SSL_RENEGOTIATION)
ssl->renego_status == MBEDTLS_SSL_INITIAL_HANDSHAKE &&
#endif
ssl->session_negotiate->id_len != 0 &&
ssl->conf->f_get_cache != NULL &&
ssl->conf->f_get_cache( ssl->conf->p_cache, ssl->session_negotiate ) == 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 3, ( "session successfully restored from cache" ) );
ssl->handshake->resume = 1;
}
if( ssl->handshake->resume == 0 )
{
/*
* New session, create a new session id,
* unless we're about to issue a session ticket
*/
ssl->state++;
#if defined(MBEDTLS_HAVE_TIME)
ssl->session_negotiate->start = mbedtls_time( NULL );
#endif
#if defined(MBEDTLS_SSL_SESSION_TICKETS)
if( ssl->handshake->new_session_ticket != 0 )
{
ssl->session_negotiate->id_len = n = 0;
mbedtls_platform_zeroize( ssl->session_negotiate->id, 32 );
}
else
#endif /* MBEDTLS_SSL_SESSION_TICKETS */
{
ssl->session_negotiate->id_len = n = 32;
if( ( ret = ssl->conf->f_rng( ssl->conf->p_rng, ssl->session_negotiate->id,
n ) ) != 0 )
return( ret );
}
}
else
{
/*
* Resuming a session
*/
n = ssl->session_negotiate->id_len;
ssl->state = MBEDTLS_SSL_SERVER_CHANGE_CIPHER_SPEC;
if( ( ret = mbedtls_ssl_derive_keys( ssl ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_derive_keys", ret );
return( ret );
}
}
/*
* 38 . 38 session id length
* 39 . 38+n session id
* 39+n . 40+n chosen ciphersuite
* 41+n . 41+n chosen compression alg.
* 42+n . 43+n extensions length
* 44+n . 43+n+m extensions
*/
*p++ = (unsigned char) ssl->session_negotiate->id_len;
memcpy( p, ssl->session_negotiate->id, ssl->session_negotiate->id_len );
p += ssl->session_negotiate->id_len;
MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, session id len.: %" MBEDTLS_PRINTF_SIZET, n ) );
MBEDTLS_SSL_DEBUG_BUF( 3, "server hello, session id", buf + 39, n );
MBEDTLS_SSL_DEBUG_MSG( 3, ( "%s session has been resumed",
ssl->handshake->resume ? "a" : "no" ) );
*p++ = (unsigned char)( ssl->session_negotiate->ciphersuite >> 8 );
*p++ = (unsigned char)( ssl->session_negotiate->ciphersuite );
*p++ = (unsigned char)( ssl->session_negotiate->compression );
MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, chosen ciphersuite: %s",
mbedtls_ssl_get_ciphersuite_name( ssl->session_negotiate->ciphersuite ) ) );
MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, compress alg.: 0x%02X",
(unsigned int) ssl->session_negotiate->compression ) );
/* Do not write the extensions if the protocol is SSLv3 */
#if defined(MBEDTLS_SSL_PROTO_SSL3)
if( ( ssl->major_ver != 3 ) || ( ssl->minor_ver != 0 ) )
{
#endif
/*
* First write extensions, then the total length
*/
ssl_write_renegotiation_ext( ssl, p + 2 + ext_len, &olen );
ext_len += olen;
#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
ssl_write_max_fragment_length_ext( ssl, p + 2 + ext_len, &olen );
ext_len += olen;
#endif
#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
ssl_write_cid_ext( ssl, p + 2 + ext_len, &olen );
ext_len += olen;
#endif
#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
ssl_write_encrypt_then_mac_ext( ssl, p + 2 + ext_len, &olen );
ext_len += olen;
#endif
#if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
ssl_write_extended_ms_ext( ssl, p + 2 + ext_len, &olen );
ext_len += olen;
#endif
#if defined(MBEDTLS_SSL_SESSION_TICKETS)
ssl_write_session_ticket_ext( ssl, p + 2 + ext_len, &olen );
ext_len += olen;
#endif
#if defined(MBEDTLS_ECDH_C) || defined(MBEDTLS_ECDSA_C) || \
defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
if ( mbedtls_ssl_ciphersuite_uses_ec(
mbedtls_ssl_ciphersuite_from_id( ssl->session_negotiate->ciphersuite ) ) )
{
ssl_write_supported_point_formats_ext( ssl, p + 2 + ext_len, &olen );
ext_len += olen;
}
#endif
#if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
ssl_write_ecjpake_kkpp_ext( ssl, p + 2 + ext_len, &olen );
ext_len += olen;
#endif
#if defined(MBEDTLS_SSL_ALPN)
ssl_write_alpn_ext( ssl, p + 2 + ext_len, &olen );
ext_len += olen;
#endif
#if defined(MBEDTLS_SSL_DTLS_SRTP)
ssl_write_use_srtp_ext( ssl, p + 2 + ext_len, &olen );
ext_len += olen;
#endif
MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, total extension length: %" MBEDTLS_PRINTF_SIZET,
ext_len ) );
if( ext_len > 0 )
{
*p++ = (unsigned char)( ( ext_len >> 8 ) & 0xFF );
*p++ = (unsigned char)( ( ext_len ) & 0xFF );
p += ext_len;
}
#if defined(MBEDTLS_SSL_PROTO_SSL3)
}
#endif
ssl->out_msglen = p - buf;
ssl->out_msgtype = MBEDTLS_SSL_MSG_HANDSHAKE;
ssl->out_msg[0] = MBEDTLS_SSL_HS_SERVER_HELLO;
ret = mbedtls_ssl_write_handshake_msg( ssl );
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= write server hello" ) );
return( ret );
}
#if !defined(MBEDTLS_KEY_EXCHANGE_CERT_REQ_ALLOWED_ENABLED)
static int ssl_write_certificate_request( mbedtls_ssl_context *ssl )
{
const mbedtls_ssl_ciphersuite_t *ciphersuite_info =
ssl->handshake->ciphersuite_info;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write certificate request" ) );
if( !mbedtls_ssl_ciphersuite_cert_req_allowed( ciphersuite_info ) )
{
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip write certificate request" ) );
ssl->state++;
return( 0 );
}
MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
#else /* !MBEDTLS_KEY_EXCHANGE_CERT_REQ_ALLOWED_ENABLED */
static int ssl_write_certificate_request( mbedtls_ssl_context *ssl )
{
int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
const mbedtls_ssl_ciphersuite_t *ciphersuite_info =
ssl->handshake->ciphersuite_info;
uint16_t dn_size, total_dn_size; /* excluding length bytes */
size_t ct_len, sa_len; /* including length bytes */
unsigned char *buf, *p;
const unsigned char * const end = ssl->out_msg + MBEDTLS_SSL_OUT_CONTENT_LEN;
const mbedtls_x509_crt *crt;
int authmode;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write certificate request" ) );
ssl->state++;
#if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
if( ssl->handshake->sni_authmode != MBEDTLS_SSL_VERIFY_UNSET )
authmode = ssl->handshake->sni_authmode;
else
#endif
authmode = ssl->conf->authmode;
if( !mbedtls_ssl_ciphersuite_cert_req_allowed( ciphersuite_info ) ||
authmode == MBEDTLS_SSL_VERIFY_NONE )
{
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip write certificate request" ) );
return( 0 );
}
/*
* 0 . 0 handshake type
* 1 . 3 handshake length
* 4 . 4 cert type count
* 5 .. m-1 cert types
* m .. m+1 sig alg length (TLS 1.2 only)
* m+1 .. n-1 SignatureAndHashAlgorithms (TLS 1.2 only)
* n .. n+1 length of all DNs
* n+2 .. n+3 length of DN 1
* n+4 .. ... Distinguished Name #1
* ... .. ... length of DN 2, etc.
*/
buf = ssl->out_msg;
p = buf + 4;
/*
* Supported certificate types
*
* ClientCertificateType certificate_types<1..2^8-1>;
* enum { (255) } ClientCertificateType;
*/
ct_len = 0;
#if defined(MBEDTLS_RSA_C)
p[1 + ct_len++] = MBEDTLS_SSL_CERT_TYPE_RSA_SIGN;
#endif
#if defined(MBEDTLS_ECDSA_C)
p[1 + ct_len++] = MBEDTLS_SSL_CERT_TYPE_ECDSA_SIGN;
#endif
p[0] = (unsigned char) ct_len++;
p += ct_len;
sa_len = 0;
#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
/*
* Add signature_algorithms for verify (TLS 1.2)
*
* SignatureAndHashAlgorithm supported_signature_algorithms<2..2^16-2>;
*
* struct {
* HashAlgorithm hash;
* SignatureAlgorithm signature;
* } SignatureAndHashAlgorithm;
*
* enum { (255) } HashAlgorithm;
* enum { (255) } SignatureAlgorithm;
*/
if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_3 )
{
const uint8_t *cur;
/*
* Supported signature algorithms
*/
for( cur = ssl->conf->sig_hashes; *cur != MBEDTLS_MD_NONE; cur++ )
{
unsigned char hash = mbedtls_ssl_hash_from_md_alg( *cur );
if( MBEDTLS_SSL_HASH_NONE == hash || mbedtls_ssl_set_calc_verify_md( ssl, hash ) )
continue;
#if defined(MBEDTLS_RSA_C)
p[2 + sa_len++] = hash;
p[2 + sa_len++] = MBEDTLS_SSL_SIG_RSA;
#endif
#if defined(MBEDTLS_ECDSA_C)
p[2 + sa_len++] = hash;
p[2 + sa_len++] = MBEDTLS_SSL_SIG_ECDSA;
#endif
}
p[0] = (unsigned char)( sa_len >> 8 );
p[1] = (unsigned char)( sa_len );
sa_len += 2;
p += sa_len;
}
#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
/*
* DistinguishedName certificate_authorities<0..2^16-1>;
* opaque DistinguishedName<1..2^16-1>;
*/
p += 2;
total_dn_size = 0;
if( ssl->conf->cert_req_ca_list == MBEDTLS_SSL_CERT_REQ_CA_LIST_ENABLED )
{
/* NOTE: If trusted certificates are provisioned
* via a CA callback (configured through
* `mbedtls_ssl_conf_ca_cb()`, then the
* CertificateRequest is currently left empty. */
#if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
if( ssl->handshake->sni_ca_chain != NULL )
crt = ssl->handshake->sni_ca_chain;
else
#endif
crt = ssl->conf->ca_chain;
while( crt != NULL && crt->version != 0 )
{
/* It follows from RFC 5280 A.1 that this length
* can be represented in at most 11 bits. */
dn_size = (uint16_t) crt->subject_raw.len;
if( end < p || (size_t)( end - p ) < 2 + (size_t) dn_size )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "skipping CAs: buffer too short" ) );
break;
}
*p++ = (unsigned char)( dn_size >> 8 );
*p++ = (unsigned char)( dn_size );
memcpy( p, crt->subject_raw.p, dn_size );
p += dn_size;
MBEDTLS_SSL_DEBUG_BUF( 3, "requested DN", p - dn_size, dn_size );
total_dn_size += 2 + dn_size;
crt = crt->next;
}
}
ssl->out_msglen = p - buf;
ssl->out_msgtype = MBEDTLS_SSL_MSG_HANDSHAKE;
ssl->out_msg[0] = MBEDTLS_SSL_HS_CERTIFICATE_REQUEST;
ssl->out_msg[4 + ct_len + sa_len] = (unsigned char)( total_dn_size >> 8 );
ssl->out_msg[5 + ct_len + sa_len] = (unsigned char)( total_dn_size );
ret = mbedtls_ssl_write_handshake_msg( ssl );
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= write certificate request" ) );
return( ret );
}
#endif /* MBEDTLS_KEY_EXCHANGE_CERT_REQ_ALLOWED_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED) || \
defined(MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
static int ssl_get_ecdh_params_from_cert( mbedtls_ssl_context *ssl )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
if( ! mbedtls_pk_can_do( mbedtls_ssl_own_key( ssl ), MBEDTLS_PK_ECKEY ) )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "server key not ECDH capable" ) );
return( MBEDTLS_ERR_SSL_PK_TYPE_MISMATCH );
}
if( ( ret = mbedtls_ecdh_get_params( &ssl->handshake->ecdh_ctx,
mbedtls_pk_ec( *mbedtls_ssl_own_key( ssl ) ),
MBEDTLS_ECDH_OURS ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, ( "mbedtls_ecdh_get_params" ), ret );
return( ret );
}
return( 0 );
}
#endif /* MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED) ||
MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_WITH_SERVER_SIGNATURE_ENABLED) && \
defined(MBEDTLS_SSL_ASYNC_PRIVATE)
static int ssl_resume_server_key_exchange( mbedtls_ssl_context *ssl,
size_t *signature_len )
{
/* Append the signature to ssl->out_msg, leaving 2 bytes for the
* signature length which will be added in ssl_write_server_key_exchange
* after the call to ssl_prepare_server_key_exchange.
* ssl_write_server_key_exchange also takes care of incrementing
* ssl->out_msglen. */
unsigned char *sig_start = ssl->out_msg + ssl->out_msglen + 2;
size_t sig_max_len = ( ssl->out_buf + MBEDTLS_SSL_OUT_CONTENT_LEN
- sig_start );
int ret = ssl->conf->f_async_resume( ssl,
sig_start, signature_len, sig_max_len );
if( ret != MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS )
{
ssl->handshake->async_in_progress = 0;
mbedtls_ssl_set_async_operation_data( ssl, NULL );
}
MBEDTLS_SSL_DEBUG_RET( 2, "ssl_resume_server_key_exchange", ret );
return( ret );
}
#endif /* defined(MBEDTLS_KEY_EXCHANGE_WITH_SERVER_SIGNATURE_ENABLED) &&
defined(MBEDTLS_SSL_ASYNC_PRIVATE) */
/* Prepare the ServerKeyExchange message, up to and including
* calculating the signature if any, but excluding formatting the
* signature and sending the message. */
static int ssl_prepare_server_key_exchange( mbedtls_ssl_context *ssl,
size_t *signature_len )
{
const mbedtls_ssl_ciphersuite_t *ciphersuite_info =
ssl->handshake->ciphersuite_info;
#if defined(MBEDTLS_KEY_EXCHANGE_SOME_PFS_ENABLED)
#if defined(MBEDTLS_KEY_EXCHANGE_WITH_SERVER_SIGNATURE_ENABLED)
unsigned char *dig_signed = NULL;
#endif /* MBEDTLS_KEY_EXCHANGE_WITH_SERVER_SIGNATURE_ENABLED */
#endif /* MBEDTLS_KEY_EXCHANGE_SOME_PFS_ENABLED */
(void) ciphersuite_info; /* unused in some configurations */
#if !defined(MBEDTLS_KEY_EXCHANGE_WITH_SERVER_SIGNATURE_ENABLED)
(void) signature_len;
#endif /* MBEDTLS_KEY_EXCHANGE_WITH_SERVER_SIGNATURE_ENABLED */
ssl->out_msglen = 4; /* header (type:1, length:3) to be written later */
/*
*
* Part 1: Provide key exchange parameters for chosen ciphersuite.
*
*/
/*
* - ECJPAKE key exchanges
*/
#if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECJPAKE )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t len = 0;
ret = mbedtls_ecjpake_write_round_two(
&ssl->handshake->ecjpake_ctx,
ssl->out_msg + ssl->out_msglen,
MBEDTLS_SSL_OUT_CONTENT_LEN - ssl->out_msglen, &len,
ssl->conf->f_rng, ssl->conf->p_rng );
if( ret != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ecjpake_write_round_two", ret );
return( ret );
}
ssl->out_msglen += len;
}
#endif /* MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED */
/*
* For (EC)DHE key exchanges with PSK, parameters are prefixed by support
* identity hint (RFC 4279, Sec. 3). Until someone needs this feature,
* we use empty support identity hints here.
**/
#if defined(MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED) || \
defined(MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED)
if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_PSK ||
ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_PSK )
{
ssl->out_msg[ssl->out_msglen++] = 0x00;
ssl->out_msg[ssl->out_msglen++] = 0x00;
}
#endif /* MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED ||
MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED */
/*
* - DHE key exchanges
*/
#if defined(MBEDTLS_KEY_EXCHANGE_SOME_DHE_ENABLED)
if( mbedtls_ssl_ciphersuite_uses_dhe( ciphersuite_info ) )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t len = 0;
if( ssl->conf->dhm_P.p == NULL || ssl->conf->dhm_G.p == NULL )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "no DH parameters set" ) );
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
}
/*
* Ephemeral DH parameters:
*
* struct {
* opaque dh_p<1..2^16-1>;
* opaque dh_g<1..2^16-1>;
* opaque dh_Ys<1..2^16-1>;
* } ServerDHParams;
*/
if( ( ret = mbedtls_dhm_set_group( &ssl->handshake->dhm_ctx,
&ssl->conf->dhm_P,
&ssl->conf->dhm_G ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_dhm_set_group", ret );
return( ret );
}
if( ( ret = mbedtls_dhm_make_params(
&ssl->handshake->dhm_ctx,
(int) mbedtls_mpi_size( &ssl->handshake->dhm_ctx.P ),
ssl->out_msg + ssl->out_msglen, &len,
ssl->conf->f_rng, ssl->conf->p_rng ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_dhm_make_params", ret );
return( ret );
}
#if defined(MBEDTLS_KEY_EXCHANGE_WITH_SERVER_SIGNATURE_ENABLED)
dig_signed = ssl->out_msg + ssl->out_msglen;
#endif
ssl->out_msglen += len;
MBEDTLS_SSL_DEBUG_MPI( 3, "DHM: X ", &ssl->handshake->dhm_ctx.X );
MBEDTLS_SSL_DEBUG_MPI( 3, "DHM: P ", &ssl->handshake->dhm_ctx.P );
MBEDTLS_SSL_DEBUG_MPI( 3, "DHM: G ", &ssl->handshake->dhm_ctx.G );
MBEDTLS_SSL_DEBUG_MPI( 3, "DHM: GX", &ssl->handshake->dhm_ctx.GX );
}
#endif /* MBEDTLS_KEY_EXCHANGE_SOME_DHE_ENABLED */
/*
* - ECDHE key exchanges
*/
#if defined(MBEDTLS_KEY_EXCHANGE_SOME_ECDHE_ENABLED)
if( mbedtls_ssl_ciphersuite_uses_ecdhe( ciphersuite_info ) )
{
/*
* Ephemeral ECDH parameters:
*
* struct {
* ECParameters curve_params;
* ECPoint public;
* } ServerECDHParams;
*/
const mbedtls_ecp_curve_info **curve = NULL;
const mbedtls_ecp_group_id *gid;
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t len = 0;
/* Match our preference list against the offered curves */
for( gid = ssl->conf->curve_list; *gid != MBEDTLS_ECP_DP_NONE; gid++ )
for( curve = ssl->handshake->curves; *curve != NULL; curve++ )
if( (*curve)->grp_id == *gid )
goto curve_matching_done;
curve_matching_done:
if( curve == NULL || *curve == NULL )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "no matching curve for ECDHE" ) );
return( MBEDTLS_ERR_SSL_NO_CIPHER_CHOSEN );
}
MBEDTLS_SSL_DEBUG_MSG( 2, ( "ECDHE curve: %s", (*curve)->name ) );
ssl->curve = *curve;
if( ( ret = mbedtls_ecdh_setup( &ssl->handshake->ecdh_ctx,
(*curve)->grp_id ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ecp_group_load", ret );
return( ret );
}
if( ( ret = mbedtls_ecdh_make_params(
&ssl->handshake->ecdh_ctx, &len,
ssl->out_msg + ssl->out_msglen,
MBEDTLS_SSL_OUT_CONTENT_LEN - ssl->out_msglen,
ssl->conf->f_rng, ssl->conf->p_rng ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ecdh_make_params", ret );
return( ret );
}
#if defined(MBEDTLS_KEY_EXCHANGE_WITH_SERVER_SIGNATURE_ENABLED)
dig_signed = ssl->out_msg + ssl->out_msglen;
#endif
ssl->out_msglen += len;
MBEDTLS_SSL_DEBUG_ECDH( 3, &ssl->handshake->ecdh_ctx,
MBEDTLS_DEBUG_ECDH_Q );
}
#endif /* MBEDTLS_KEY_EXCHANGE_SOME_ECDHE_ENABLED */
/*
*
* Part 2: For key exchanges involving the server signing the
* exchange parameters, compute and add the signature here.
*
*/
#if defined(MBEDTLS_KEY_EXCHANGE_WITH_SERVER_SIGNATURE_ENABLED)
if( mbedtls_ssl_ciphersuite_uses_server_signature( ciphersuite_info ) )
{
size_t dig_signed_len = ssl->out_msg + ssl->out_msglen - dig_signed;
size_t hashlen = 0;
unsigned char hash[MBEDTLS_MD_MAX_SIZE];
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
/*
* 2.1: Choose hash algorithm:
* A: For TLS 1.2, obey signature-hash-algorithm extension
* to choose appropriate hash.
* B: For SSL3, TLS1.0, TLS1.1 and ECDHE_ECDSA, use SHA1
* (RFC 4492, Sec. 5.4)
* C: Otherwise, use MD5 + SHA1 (RFC 4346, Sec. 7.4.3)
*/
mbedtls_md_type_t md_alg;
#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
mbedtls_pk_type_t sig_alg =
mbedtls_ssl_get_ciphersuite_sig_pk_alg( ciphersuite_info );
if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_3 )
{
/* A: For TLS 1.2, obey signature-hash-algorithm extension
* (RFC 5246, Sec. 7.4.1.4.1). */
if( sig_alg == MBEDTLS_PK_NONE ||
( md_alg = mbedtls_ssl_sig_hash_set_find( &ssl->handshake->hash_algs,
sig_alg ) ) == MBEDTLS_MD_NONE )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
/* (... because we choose a cipher suite
* only if there is a matching hash.) */
return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
}
else
#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
#if defined(MBEDTLS_SSL_PROTO_SSL3) || defined(MBEDTLS_SSL_PROTO_TLS1) || \
defined(MBEDTLS_SSL_PROTO_TLS1_1)
if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA )
{
/* B: Default hash SHA1 */
md_alg = MBEDTLS_MD_SHA1;
}
else
#endif /* MBEDTLS_SSL_PROTO_SSL3 || MBEDTLS_SSL_PROTO_TLS1 || \
MBEDTLS_SSL_PROTO_TLS1_1 */
{
/* C: MD5 + SHA1 */
md_alg = MBEDTLS_MD_NONE;
}
MBEDTLS_SSL_DEBUG_MSG( 3, ( "pick hash algorithm %u for signing", (unsigned) md_alg ) );
/*
* 2.2: Compute the hash to be signed
*/
#if defined(MBEDTLS_SSL_PROTO_SSL3) || defined(MBEDTLS_SSL_PROTO_TLS1) || \
defined(MBEDTLS_SSL_PROTO_TLS1_1)
if( md_alg == MBEDTLS_MD_NONE )
{
hashlen = 36;
ret = mbedtls_ssl_get_key_exchange_md_ssl_tls( ssl, hash,
dig_signed,
dig_signed_len );
if( ret != 0 )
return( ret );
}
else
#endif /* MBEDTLS_SSL_PROTO_SSL3 || MBEDTLS_SSL_PROTO_TLS1 || \
MBEDTLS_SSL_PROTO_TLS1_1 */
#if defined(MBEDTLS_SSL_PROTO_TLS1) || defined(MBEDTLS_SSL_PROTO_TLS1_1) || \
defined(MBEDTLS_SSL_PROTO_TLS1_2)
if( md_alg != MBEDTLS_MD_NONE )
{
ret = mbedtls_ssl_get_key_exchange_md_tls1_2( ssl, hash, &hashlen,
dig_signed,
dig_signed_len,
md_alg );
if( ret != 0 )
return( ret );
}
else
#endif /* MBEDTLS_SSL_PROTO_TLS1 || MBEDTLS_SSL_PROTO_TLS1_1 || \
MBEDTLS_SSL_PROTO_TLS1_2 */
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
MBEDTLS_SSL_DEBUG_BUF( 3, "parameters hash", hash, hashlen );
/*
* 2.3: Compute and add the signature
*/
#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_3 )
{
/*
* For TLS 1.2, we need to specify signature and hash algorithm
* explicitly through a prefix to the signature.
*
* struct {
* HashAlgorithm hash;
* SignatureAlgorithm signature;
* } SignatureAndHashAlgorithm;
*
* struct {
* SignatureAndHashAlgorithm algorithm;
* opaque signature<0..2^16-1>;
* } DigitallySigned;
*
*/
ssl->out_msg[ssl->out_msglen++] =
mbedtls_ssl_hash_from_md_alg( md_alg );
ssl->out_msg[ssl->out_msglen++] =
mbedtls_ssl_sig_from_pk_alg( sig_alg );
}
#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
#if defined(MBEDTLS_SSL_ASYNC_PRIVATE)
if( ssl->conf->f_async_sign_start != NULL )
{
ret = ssl->conf->f_async_sign_start( ssl,
mbedtls_ssl_own_cert( ssl ),
md_alg, hash, hashlen );
switch( ret )
{
case MBEDTLS_ERR_SSL_HW_ACCEL_FALLTHROUGH:
/* act as if f_async_sign was null */
break;
case 0:
ssl->handshake->async_in_progress = 1;
return( ssl_resume_server_key_exchange( ssl, signature_len ) );
case MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS:
ssl->handshake->async_in_progress = 1;
return( MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS );
default:
MBEDTLS_SSL_DEBUG_RET( 1, "f_async_sign_start", ret );
return( ret );
}
}
#endif /* MBEDTLS_SSL_ASYNC_PRIVATE */
if( mbedtls_ssl_own_key( ssl ) == NULL )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "got no private key" ) );
return( MBEDTLS_ERR_SSL_PRIVATE_KEY_REQUIRED );
}
/* Append the signature to ssl->out_msg, leaving 2 bytes for the
* signature length which will be added in ssl_write_server_key_exchange
* after the call to ssl_prepare_server_key_exchange.
* ssl_write_server_key_exchange also takes care of incrementing
* ssl->out_msglen. */
if( ( ret = mbedtls_pk_sign( mbedtls_ssl_own_key( ssl ),
md_alg, hash, hashlen,
ssl->out_msg + ssl->out_msglen + 2,
signature_len,
ssl->conf->f_rng,
ssl->conf->p_rng ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_pk_sign", ret );
return( ret );
}
}
#endif /* MBEDTLS_KEY_EXCHANGE_WITH_SERVER_SIGNATURE_ENABLED */
return( 0 );
}
/* Prepare the ServerKeyExchange message and send it. For ciphersuites
* that do not include a ServerKeyExchange message, do nothing. Either
* way, if successful, move on to the next step in the SSL state
* machine. */
static int ssl_write_server_key_exchange( mbedtls_ssl_context *ssl )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t signature_len = 0;
#if defined(MBEDTLS_KEY_EXCHANGE_SOME_NON_PFS_ENABLED)
const mbedtls_ssl_ciphersuite_t *ciphersuite_info =
ssl->handshake->ciphersuite_info;
#endif /* MBEDTLS_KEY_EXCHANGE_SOME_NON_PFS_ENABLED */
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write server key exchange" ) );
#if defined(MBEDTLS_KEY_EXCHANGE_SOME_NON_PFS_ENABLED)
/* Extract static ECDH parameters and abort if ServerKeyExchange
* is not needed. */
if( mbedtls_ssl_ciphersuite_no_pfs( ciphersuite_info ) )
{
/* For suites involving ECDH, extract DH parameters
* from certificate at this point. */
#if defined(MBEDTLS_KEY_EXCHANGE_SOME_ECDH_ENABLED)
if( mbedtls_ssl_ciphersuite_uses_ecdh( ciphersuite_info ) )
{
ssl_get_ecdh_params_from_cert( ssl );
}
#endif /* MBEDTLS_KEY_EXCHANGE_SOME_ECDH_ENABLED */
/* Key exchanges not involving ephemeral keys don't use
* ServerKeyExchange, so end here. */
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip write server key exchange" ) );
ssl->state++;
return( 0 );
}
#endif /* MBEDTLS_KEY_EXCHANGE_SOME_NON_PFS_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_WITH_SERVER_SIGNATURE_ENABLED) && \
defined(MBEDTLS_SSL_ASYNC_PRIVATE)
/* If we have already prepared the message and there is an ongoing
* signature operation, resume signing. */
if( ssl->handshake->async_in_progress != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 2, ( "resuming signature operation" ) );
ret = ssl_resume_server_key_exchange( ssl, &signature_len );
}
else
#endif /* defined(MBEDTLS_KEY_EXCHANGE_WITH_SERVER_SIGNATURE_ENABLED) &&
defined(MBEDTLS_SSL_ASYNC_PRIVATE) */
{
/* ServerKeyExchange is needed. Prepare the message. */
ret = ssl_prepare_server_key_exchange( ssl, &signature_len );
}
if( ret != 0 )
{
/* If we're starting to write a new message, set ssl->out_msglen
* to 0. But if we're resuming after an asynchronous message,
* out_msglen is the amount of data written so far and mst be
* preserved. */
if( ret == MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS )
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= write server key exchange (pending)" ) );
else
ssl->out_msglen = 0;
return( ret );
}
/* If there is a signature, write its length.
* ssl_prepare_server_key_exchange already wrote the signature
* itself at its proper place in the output buffer. */
#if defined(MBEDTLS_KEY_EXCHANGE_WITH_SERVER_SIGNATURE_ENABLED)
if( signature_len != 0 )
{
ssl->out_msg[ssl->out_msglen++] = (unsigned char)( signature_len >> 8 );
ssl->out_msg[ssl->out_msglen++] = (unsigned char)( signature_len );
MBEDTLS_SSL_DEBUG_BUF( 3, "my signature",
ssl->out_msg + ssl->out_msglen,
signature_len );
/* Skip over the already-written signature */
ssl->out_msglen += signature_len;
}
#endif /* MBEDTLS_KEY_EXCHANGE_WITH_SERVER_SIGNATURE_ENABLED */
/* Add header and send. */
ssl->out_msgtype = MBEDTLS_SSL_MSG_HANDSHAKE;
ssl->out_msg[0] = MBEDTLS_SSL_HS_SERVER_KEY_EXCHANGE;
ssl->state++;
if( ( ret = mbedtls_ssl_write_handshake_msg( ssl ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_write_handshake_msg", ret );
return( ret );
}
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= write server key exchange" ) );
return( 0 );
}
static int ssl_write_server_hello_done( mbedtls_ssl_context *ssl )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write server hello done" ) );
ssl->out_msglen = 4;
ssl->out_msgtype = MBEDTLS_SSL_MSG_HANDSHAKE;
ssl->out_msg[0] = MBEDTLS_SSL_HS_SERVER_HELLO_DONE;
ssl->state++;
#if defined(MBEDTLS_SSL_PROTO_DTLS)
if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
mbedtls_ssl_send_flight_completed( ssl );
#endif
if( ( ret = mbedtls_ssl_write_handshake_msg( ssl ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_write_handshake_msg", ret );
return( ret );
}
#if defined(MBEDTLS_SSL_PROTO_DTLS)
if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM &&
( ret = mbedtls_ssl_flight_transmit( ssl ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_flight_transmit", ret );
return( ret );
}
#endif /* MBEDTLS_SSL_PROTO_DTLS */
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= write server hello done" ) );
return( 0 );
}
#if defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED) || \
defined(MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED)
static int ssl_parse_client_dh_public( mbedtls_ssl_context *ssl, unsigned char **p,
const unsigned char *end )
{
int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
size_t n;
/*
* Receive G^Y mod P, premaster = (G^Y)^X mod P
*/
if( *p + 2 > end )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client key exchange message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
}
n = ( (*p)[0] << 8 ) | (*p)[1];
*p += 2;
if( *p + n > end )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client key exchange message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
}
if( ( ret = mbedtls_dhm_read_public( &ssl->handshake->dhm_ctx, *p, n ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_dhm_read_public", ret );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_RP );
}
*p += n;
MBEDTLS_SSL_DEBUG_MPI( 3, "DHM: GY", &ssl->handshake->dhm_ctx.GY );
return( ret );
}
#endif /* MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED ||
MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED) || \
defined(MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED)
#if defined(MBEDTLS_SSL_ASYNC_PRIVATE)
static int ssl_resume_decrypt_pms( mbedtls_ssl_context *ssl,
unsigned char *peer_pms,
size_t *peer_pmslen,
size_t peer_pmssize )
{
int ret = ssl->conf->f_async_resume( ssl,
peer_pms, peer_pmslen, peer_pmssize );
if( ret != MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS )
{
ssl->handshake->async_in_progress = 0;
mbedtls_ssl_set_async_operation_data( ssl, NULL );
}
MBEDTLS_SSL_DEBUG_RET( 2, "ssl_decrypt_encrypted_pms", ret );
return( ret );
}
#endif /* MBEDTLS_SSL_ASYNC_PRIVATE */
static int ssl_decrypt_encrypted_pms( mbedtls_ssl_context *ssl,
const unsigned char *p,
const unsigned char *end,
unsigned char *peer_pms,
size_t *peer_pmslen,
size_t peer_pmssize )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
mbedtls_pk_context *private_key = mbedtls_ssl_own_key( ssl );
mbedtls_pk_context *public_key = &mbedtls_ssl_own_cert( ssl )->pk;
size_t len = mbedtls_pk_get_len( public_key );
#if defined(MBEDTLS_SSL_ASYNC_PRIVATE)
/* If we have already started decoding the message and there is an ongoing
* decryption operation, resume signing. */
if( ssl->handshake->async_in_progress != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 2, ( "resuming decryption operation" ) );
return( ssl_resume_decrypt_pms( ssl,
peer_pms, peer_pmslen, peer_pmssize ) );
}
#endif /* MBEDTLS_SSL_ASYNC_PRIVATE */
/*
* Prepare to decrypt the premaster using own private RSA key
*/
#if defined(MBEDTLS_SSL_PROTO_TLS1) || defined(MBEDTLS_SSL_PROTO_TLS1_1) || \
defined(MBEDTLS_SSL_PROTO_TLS1_2)
if( ssl->minor_ver != MBEDTLS_SSL_MINOR_VERSION_0 )
{
if ( p + 2 > end ) {
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client key exchange message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
}
if( *p++ != ( ( len >> 8 ) & 0xFF ) ||
*p++ != ( ( len ) & 0xFF ) )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client key exchange message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
}
}
#endif
if( p + len != end )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client key exchange message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
}
/*
* Decrypt the premaster secret
*/
#if defined(MBEDTLS_SSL_ASYNC_PRIVATE)
if( ssl->conf->f_async_decrypt_start != NULL )
{
ret = ssl->conf->f_async_decrypt_start( ssl,
mbedtls_ssl_own_cert( ssl ),
p, len );
switch( ret )
{
case MBEDTLS_ERR_SSL_HW_ACCEL_FALLTHROUGH:
/* act as if f_async_decrypt_start was null */
break;
case 0:
ssl->handshake->async_in_progress = 1;
return( ssl_resume_decrypt_pms( ssl,
peer_pms,
peer_pmslen,
peer_pmssize ) );
case MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS:
ssl->handshake->async_in_progress = 1;
return( MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS );
default:
MBEDTLS_SSL_DEBUG_RET( 1, "f_async_decrypt_start", ret );
return( ret );
}
}
#endif /* MBEDTLS_SSL_ASYNC_PRIVATE */
if( ! mbedtls_pk_can_do( private_key, MBEDTLS_PK_RSA ) )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "got no RSA private key" ) );
return( MBEDTLS_ERR_SSL_PRIVATE_KEY_REQUIRED );
}
ret = mbedtls_pk_decrypt( private_key, p, len,
peer_pms, peer_pmslen, peer_pmssize,
ssl->conf->f_rng, ssl->conf->p_rng );
return( ret );
}
static int ssl_parse_encrypted_pms( mbedtls_ssl_context *ssl,
const unsigned char *p,
const unsigned char *end,
size_t pms_offset )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
unsigned char *pms = ssl->handshake->premaster + pms_offset;
unsigned char ver[2];
unsigned char fake_pms[48], peer_pms[48];
unsigned char mask;
size_t i, peer_pmslen;
unsigned int diff;
/* In case of a failure in decryption, the decryption may write less than
* 2 bytes of output, but we always read the first two bytes. It doesn't
* matter in the end because diff will be nonzero in that case due to
* ret being nonzero, and we only care whether diff is 0.
* But do initialize peer_pms and peer_pmslen for robustness anyway. This
* also makes memory analyzers happy (don't access uninitialized memory,
* even if it's an unsigned char). */
peer_pms[0] = peer_pms[1] = ~0;
peer_pmslen = 0;
ret = ssl_decrypt_encrypted_pms( ssl, p, end,
peer_pms,
&peer_pmslen,
sizeof( peer_pms ) );
#if defined(MBEDTLS_SSL_ASYNC_PRIVATE)
if ( ret == MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS )
return( ret );
#endif /* MBEDTLS_SSL_ASYNC_PRIVATE */
mbedtls_ssl_write_version( ssl->handshake->max_major_ver,
ssl->handshake->max_minor_ver,
ssl->conf->transport, ver );
/* Avoid data-dependent branches while checking for invalid
* padding, to protect against timing-based Bleichenbacher-type
* attacks. */
diff = (unsigned int) ret;
diff |= peer_pmslen ^ 48;
diff |= peer_pms[0] ^ ver[0];
diff |= peer_pms[1] ^ ver[1];
/* mask = diff ? 0xff : 0x00 using bit operations to avoid branches */
/* MSVC has a warning about unary minus on unsigned, but this is
* well-defined and precisely what we want to do here */
#if defined(_MSC_VER)
#pragma warning( push )
#pragma warning( disable : 4146 )
#endif
mask = - ( ( diff | - diff ) >> ( sizeof( unsigned int ) * 8 - 1 ) );
#if defined(_MSC_VER)
#pragma warning( pop )
#endif
/*
* Protection against Bleichenbacher's attack: invalid PKCS#1 v1.5 padding
* must not cause the connection to end immediately; instead, send a
* bad_record_mac later in the handshake.
* To protect against timing-based variants of the attack, we must
* not have any branch that depends on whether the decryption was
* successful. In particular, always generate the fake premaster secret,
* regardless of whether it will ultimately influence the output or not.
*/
ret = ssl->conf->f_rng( ssl->conf->p_rng, fake_pms, sizeof( fake_pms ) );
if( ret != 0 )
{
/* It's ok to abort on an RNG failure, since this does not reveal
* anything about the RSA decryption. */
return( ret );
}
#if defined(MBEDTLS_SSL_DEBUG_ALL)
if( diff != 0 )
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client key exchange message" ) );
#endif
if( sizeof( ssl->handshake->premaster ) < pms_offset ||
sizeof( ssl->handshake->premaster ) - pms_offset < 48 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
ssl->handshake->pmslen = 48;
/* Set pms to either the true or the fake PMS, without
* data-dependent branches. */
for( i = 0; i < ssl->handshake->pmslen; i++ )
pms[i] = ( mask & fake_pms[i] ) | ( (~mask) & peer_pms[i] );
return( 0 );
}
#endif /* MBEDTLS_KEY_EXCHANGE_RSA_ENABLED ||
MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED)
static int ssl_parse_client_psk_identity( mbedtls_ssl_context *ssl, unsigned char **p,
const unsigned char *end )
{
int ret = 0;
uint16_t n;
if( ssl_conf_has_psk_or_cb( ssl->conf ) == 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "got no pre-shared key" ) );
return( MBEDTLS_ERR_SSL_PRIVATE_KEY_REQUIRED );
}
/*
* Receive client pre-shared key identity name
*/
if( end - *p < 2 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client key exchange message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
}
n = ( (*p)[0] << 8 ) | (*p)[1];
*p += 2;
if( n == 0 || n > end - *p )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client key exchange message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
}
if( ssl->conf->f_psk != NULL )
{
if( ssl->conf->f_psk( ssl->conf->p_psk, ssl, *p, n ) != 0 )
ret = MBEDTLS_ERR_SSL_UNKNOWN_IDENTITY;
}
else
{
/* Identity is not a big secret since clients send it in the clear,
* but treat it carefully anyway, just in case */
if( n != ssl->conf->psk_identity_len ||
timingsafe_bcmp( ssl->conf->psk_identity, *p, n ) != 0 )
{
ret = MBEDTLS_ERR_SSL_UNKNOWN_IDENTITY;
}
}
if( ret == MBEDTLS_ERR_SSL_UNKNOWN_IDENTITY )
{
MBEDTLS_SSL_DEBUG_BUF( 3, "Unknown PSK identity", *p, n );
mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
MBEDTLS_SSL_ALERT_MSG_UNKNOWN_PSK_IDENTITY );
return( MBEDTLS_ERR_SSL_UNKNOWN_IDENTITY );
}
*p += n;
return( 0 );
}
#endif /* MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED */
static int ssl_parse_client_key_exchange( mbedtls_ssl_context *ssl )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
const mbedtls_ssl_ciphersuite_t *ciphersuite_info;
unsigned char *p, *end;
ciphersuite_info = ssl->handshake->ciphersuite_info;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> parse client key exchange" ) );
#if defined(MBEDTLS_SSL_ASYNC_PRIVATE) && \
( defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED) || \
defined(MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED) )
if( ( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA_PSK ||
ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA ) &&
( ssl->handshake->async_in_progress != 0 ) )
{
/* We've already read a record and there is an asynchronous
* operation in progress to decrypt it. So skip reading the
* record. */
MBEDTLS_SSL_DEBUG_MSG( 3, ( "will resume decryption of previously-read record" ) );
}
else
#endif
if( ( ret = mbedtls_ssl_read_record( ssl, 1 ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_read_record", ret );
return( ret );
}
p = ssl->in_msg + mbedtls_ssl_hs_hdr_len( ssl );
end = ssl->in_msg + ssl->in_hslen;
if( ssl->in_msgtype != MBEDTLS_SSL_MSG_HANDSHAKE )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client key exchange message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
}
if( ssl->in_msg[0] != MBEDTLS_SSL_HS_CLIENT_KEY_EXCHANGE )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client key exchange message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
}
#if defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED)
if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_RSA )
{
if( ( ret = ssl_parse_client_dh_public( ssl, &p, end ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, ( "ssl_parse_client_dh_public" ), ret );
return( ret );
}
if( p != end )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client key exchange" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
}
if( ( ret = mbedtls_dhm_calc_secret( &ssl->handshake->dhm_ctx,
ssl->handshake->premaster,
MBEDTLS_PREMASTER_SIZE,
&ssl->handshake->pmslen,
ssl->conf->f_rng, ssl->conf->p_rng ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_dhm_calc_secret", ret );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_CS );
}
MBEDTLS_SSL_DEBUG_MPI( 3, "DHM: K ", &ssl->handshake->dhm_ctx.K );
}
else
#endif /* MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED) || \
defined(MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED) || \
defined(MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_RSA ||
ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA ||
ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDH_RSA ||
ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA )
{
if( ( ret = mbedtls_ecdh_read_public( &ssl->handshake->ecdh_ctx,
p, end - p) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ecdh_read_public", ret );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_RP );
}
MBEDTLS_SSL_DEBUG_ECDH( 3, &ssl->handshake->ecdh_ctx,
MBEDTLS_DEBUG_ECDH_QP );
if( ( ret = mbedtls_ecdh_calc_secret( &ssl->handshake->ecdh_ctx,
&ssl->handshake->pmslen,
ssl->handshake->premaster,
MBEDTLS_MPI_MAX_SIZE,
ssl->conf->f_rng, ssl->conf->p_rng ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ecdh_calc_secret", ret );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_CS );
}
MBEDTLS_SSL_DEBUG_ECDH( 3, &ssl->handshake->ecdh_ctx,
MBEDTLS_DEBUG_ECDH_Z );
}
else
#endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED ||
MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED ||
MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED ||
MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_PSK_ENABLED)
if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_PSK )
{
if( ( ret = ssl_parse_client_psk_identity( ssl, &p, end ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, ( "ssl_parse_client_psk_identity" ), ret );
return( ret );
}
if( p != end )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client key exchange" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
}
if( ( ret = mbedtls_ssl_psk_derive_premaster( ssl,
ciphersuite_info->key_exchange ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_psk_derive_premaster", ret );
return( ret );
}
}
else
#endif /* MBEDTLS_KEY_EXCHANGE_PSK_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED)
if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA_PSK )
{
#if defined(MBEDTLS_SSL_ASYNC_PRIVATE)
if ( ssl->handshake->async_in_progress != 0 )
{
/* There is an asynchronous operation in progress to
* decrypt the encrypted premaster secret, so skip
* directly to resuming this operation. */
MBEDTLS_SSL_DEBUG_MSG( 3, ( "PSK identity already parsed" ) );
/* Update p to skip the PSK identity. ssl_parse_encrypted_pms
* won't actually use it, but maintain p anyway for robustness. */
p += ssl->conf->psk_identity_len + 2;
}
else
#endif /* MBEDTLS_SSL_ASYNC_PRIVATE */
if( ( ret = ssl_parse_client_psk_identity( ssl, &p, end ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, ( "ssl_parse_client_psk_identity" ), ret );
return( ret );
}
if( ( ret = ssl_parse_encrypted_pms( ssl, p, end, 2 ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, ( "ssl_parse_encrypted_pms" ), ret );
return( ret );
}
if( ( ret = mbedtls_ssl_psk_derive_premaster( ssl,
ciphersuite_info->key_exchange ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_psk_derive_premaster", ret );
return( ret );
}
}
else
#endif /* MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED)
if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_PSK )
{
if( ( ret = ssl_parse_client_psk_identity( ssl, &p, end ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, ( "ssl_parse_client_psk_identity" ), ret );
return( ret );
}
if( ( ret = ssl_parse_client_dh_public( ssl, &p, end ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, ( "ssl_parse_client_dh_public" ), ret );
return( ret );
}
if( p != end )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client key exchange" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
}
if( ( ret = mbedtls_ssl_psk_derive_premaster( ssl,
ciphersuite_info->key_exchange ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_psk_derive_premaster", ret );
return( ret );
}
}
else
#endif /* MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED)
if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_PSK )
{
if( ( ret = ssl_parse_client_psk_identity( ssl, &p, end ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, ( "ssl_parse_client_psk_identity" ), ret );
return( ret );
}
if( ( ret = mbedtls_ecdh_read_public( &ssl->handshake->ecdh_ctx,
p, end - p ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ecdh_read_public", ret );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_RP );
}
MBEDTLS_SSL_DEBUG_ECDH( 3, &ssl->handshake->ecdh_ctx,
MBEDTLS_DEBUG_ECDH_QP );
if( ( ret = mbedtls_ssl_psk_derive_premaster( ssl,
ciphersuite_info->key_exchange ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_psk_derive_premaster", ret );
return( ret );
}
}
else
#endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED)
if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA )
{
if( ( ret = ssl_parse_encrypted_pms( ssl, p, end, 0 ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, ( "ssl_parse_parse_encrypted_pms_secret" ), ret );
return( ret );
}
}
else
#endif /* MBEDTLS_KEY_EXCHANGE_RSA_ENABLED */
#if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECJPAKE )
{
ret = mbedtls_ecjpake_read_round_two( &ssl->handshake->ecjpake_ctx,
p, end - p );
if( ret != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ecjpake_read_round_two", ret );
return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
}
ret = mbedtls_ecjpake_derive_secret( &ssl->handshake->ecjpake_ctx,
ssl->handshake->premaster, 32, &ssl->handshake->pmslen,
ssl->conf->f_rng, ssl->conf->p_rng );
if( ret != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ecjpake_derive_secret", ret );
return( ret );
}
}
else
#endif /* MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED */
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
if( ( ret = mbedtls_ssl_derive_keys( ssl ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_derive_keys", ret );
return( ret );
}
ssl->state++;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= parse client key exchange" ) );
return( 0 );
}
static int ssl_parse_certificate_verify( mbedtls_ssl_context *ssl )
{
#if !defined(MBEDTLS_KEY_EXCHANGE_CERT_REQ_ALLOWED_ENABLED)
const mbedtls_ssl_ciphersuite_t *ciphersuite_info =
ssl->handshake->ciphersuite_info;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> parse certificate verify" ) );
if( !mbedtls_ssl_ciphersuite_cert_req_allowed( ciphersuite_info ) )
{
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip parse certificate verify" ) );
ssl->state++;
return( 0 );
}
MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
#else /* !MBEDTLS_KEY_EXCHANGE_CERT_REQ_ALLOWED_ENABLED */
int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
size_t i, sig_len;
unsigned char hash[48];
unsigned char *hash_start = hash;
size_t hashlen;
#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
mbedtls_pk_type_t pk_alg;
#endif
mbedtls_md_type_t md_alg;
const mbedtls_ssl_ciphersuite_t *ciphersuite_info =
ssl->handshake->ciphersuite_info;
mbedtls_pk_context * peer_pk;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> parse certificate verify" ) );
if( !mbedtls_ssl_ciphersuite_cert_req_allowed( ciphersuite_info ) )
{
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip parse certificate verify" ) );
ssl->state++;
return( 0 );
}
#if defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
if( ssl->session_negotiate->peer_cert == NULL )
{
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip parse certificate verify" ) );
ssl->state++;
return( 0 );
}
#else /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
if( ssl->session_negotiate->peer_cert_digest == NULL )
{
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip parse certificate verify" ) );
ssl->state++;
return( 0 );
}
#endif /* !MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
/* Read the message without adding it to the checksum */
ret = mbedtls_ssl_read_record( ssl, 0 /* no checksum update */ );
if( 0 != ret )
{
MBEDTLS_SSL_DEBUG_RET( 1, ( "mbedtls_ssl_read_record" ), ret );
return( ret );
}
ssl->state++;
/* Process the message contents */
if( ssl->in_msgtype != MBEDTLS_SSL_MSG_HANDSHAKE ||
ssl->in_msg[0] != MBEDTLS_SSL_HS_CERTIFICATE_VERIFY )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad certificate verify message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_VERIFY );
}
i = mbedtls_ssl_hs_hdr_len( ssl );
#if !defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
peer_pk = &ssl->handshake->peer_pubkey;
#else /* !MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
if( ssl->session_negotiate->peer_cert == NULL )
{
/* Should never happen */
return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
peer_pk = &ssl->session_negotiate->peer_cert->pk;
#endif /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
/*
* struct {
* SignatureAndHashAlgorithm algorithm; -- TLS 1.2 only
* opaque signature<0..2^16-1>;
* } DigitallySigned;
*/
#if defined(MBEDTLS_SSL_PROTO_SSL3) || defined(MBEDTLS_SSL_PROTO_TLS1) || \
defined(MBEDTLS_SSL_PROTO_TLS1_1)
if( ssl->minor_ver != MBEDTLS_SSL_MINOR_VERSION_3 )
{
md_alg = MBEDTLS_MD_NONE;
hashlen = 36;
/* For ECDSA, use SHA-1, not MD-5 + SHA-1 */
if( mbedtls_pk_can_do( peer_pk, MBEDTLS_PK_ECDSA ) )
{
hash_start += 16;
hashlen -= 16;
md_alg = MBEDTLS_MD_SHA1;
}
}
else
#endif /* MBEDTLS_SSL_PROTO_SSL3 || MBEDTLS_SSL_PROTO_TLS1 ||
MBEDTLS_SSL_PROTO_TLS1_1 */
#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_3 )
{
if( i + 2 > ssl->in_hslen )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad certificate verify message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_VERIFY );
}
/*
* Hash
*/
md_alg = mbedtls_ssl_md_alg_from_hash( ssl->in_msg[i] );
if( md_alg == MBEDTLS_MD_NONE || mbedtls_ssl_set_calc_verify_md( ssl, ssl->in_msg[i] ) )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "peer not adhering to requested sig_alg"
" for verify message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_VERIFY );
}
#if !defined(MBEDTLS_MD_SHA1)
if( MBEDTLS_MD_SHA1 == md_alg )
hash_start += 16;
#endif
/* Info from md_alg will be used instead */
hashlen = 0;
i++;
/*
* Signature
*/
if( ( pk_alg = mbedtls_ssl_pk_alg_from_sig( ssl->in_msg[i] ) )
== MBEDTLS_PK_NONE )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "peer not adhering to requested sig_alg"
" for verify message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_VERIFY );
}
/*
* Check the certificate's key type matches the signature alg
*/
if( !mbedtls_pk_can_do( peer_pk, pk_alg ) )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "sig_alg doesn't match cert key" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_VERIFY );
}
i++;
}
else
#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
}
if( i + 2 > ssl->in_hslen )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad certificate verify message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_VERIFY );
}
sig_len = ( ssl->in_msg[i] << 8 ) | ssl->in_msg[i+1];
i += 2;
if( i + sig_len != ssl->in_hslen )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad certificate verify message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_VERIFY );
}
/* Calculate hash and verify signature */
{
size_t dummy_hlen;
ssl->handshake->calc_verify( ssl, hash, &dummy_hlen );
}
if( ( ret = mbedtls_pk_verify( peer_pk,
md_alg, hash_start, hashlen,
ssl->in_msg + i, sig_len ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_pk_verify", ret );
return( ret );
}
mbedtls_ssl_update_handshake_status( ssl );
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= parse certificate verify" ) );
return( ret );
#endif /* MBEDTLS_KEY_EXCHANGE_CERT_REQ_ALLOWED_ENABLED */
}
#if defined(MBEDTLS_SSL_SESSION_TICKETS)
static int ssl_write_new_session_ticket( mbedtls_ssl_context *ssl )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t tlen;
uint32_t lifetime;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write new session ticket" ) );
ssl->out_msgtype = MBEDTLS_SSL_MSG_HANDSHAKE;
ssl->out_msg[0] = MBEDTLS_SSL_HS_NEW_SESSION_TICKET;
/*
* struct {
* uint32 ticket_lifetime_hint;
* opaque ticket<0..2^16-1>;
* } NewSessionTicket;
*
* 4 . 7 ticket_lifetime_hint (0 = unspecified)
* 8 . 9 ticket_len (n)
* 10 . 9+n ticket content
*/
if( ( ret = ssl->conf->f_ticket_write( ssl->conf->p_ticket,
ssl->session_negotiate,
ssl->out_msg + 10,
ssl->out_msg + MBEDTLS_SSL_OUT_CONTENT_LEN,
&tlen, &lifetime ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_ticket_write", ret );
tlen = 0;
}
ssl->out_msg[4] = ( lifetime >> 24 ) & 0xFF;
ssl->out_msg[5] = ( lifetime >> 16 ) & 0xFF;
ssl->out_msg[6] = ( lifetime >> 8 ) & 0xFF;
ssl->out_msg[7] = ( lifetime ) & 0xFF;
ssl->out_msg[8] = (unsigned char)( ( tlen >> 8 ) & 0xFF );
ssl->out_msg[9] = (unsigned char)( ( tlen ) & 0xFF );
ssl->out_msglen = 10 + tlen;
/*
* Morally equivalent to updating ssl->state, but NewSessionTicket and
* ChangeCipherSpec share the same state.
*/
ssl->handshake->new_session_ticket = 0;
if( ( ret = mbedtls_ssl_write_handshake_msg( ssl ) ) != 0 )
{
MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_write_handshake_msg", ret );
return( ret );
}
MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= write new session ticket" ) );
return( 0 );
}
#endif /* MBEDTLS_SSL_SESSION_TICKETS */
/**
* \brief Perform a single step of the SSL server handshake
*
* \note The state of the context (ssl->state) will be at
* the next state after this function returns \c 0. Do not
* call this function if state is MBEDTLS_SSL_HANDSHAKE_OVER.
*
* \param ssl SSL context
*
* \return See mbedtls_ssl_handshake().
*
* \warning If this function returns something other than \c 0,
* #MBEDTLS_ERR_SSL_WANT_READ, #MBEDTLS_ERR_SSL_WANT_WRITE,
* #MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS or
* #MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS, you must stop using
* the SSL context for reading or writing, and either free it
* or call \c mbedtls_ssl_session_reset() on it before
* re-using it for a new connection; the current connection
* must be closed.
*/
int mbedtls_ssl_handshake_server_step( mbedtls_ssl_context *ssl )
{
int ret = 0;
if( ssl->state == MBEDTLS_SSL_HANDSHAKE_OVER || ssl->handshake == NULL )
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
MBEDTLS_SSL_DEBUG_MSG( 2, ( "server state: %d", ssl->state ) );
if( ( ret = mbedtls_ssl_flush_output( ssl ) ) != 0 )
return( ret );
#if defined(MBEDTLS_SSL_PROTO_DTLS)
if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM &&
ssl->handshake->retransmit_state == MBEDTLS_SSL_RETRANS_SENDING )
{
if( ( ret = mbedtls_ssl_flight_transmit( ssl ) ) != 0 )
return( ret );
}
#endif /* MBEDTLS_SSL_PROTO_DTLS */
/* INFOF("handshake step %s", GetSslStateName(ssl->state)); */
switch( ssl->state )
{
case MBEDTLS_SSL_HELLO_REQUEST:
ssl->state = MBEDTLS_SSL_CLIENT_HELLO;
break;
/*
* <== ClientHello
*/
case MBEDTLS_SSL_CLIENT_HELLO:
ret = ssl_parse_client_hello( ssl );
break;
#if defined(MBEDTLS_SSL_PROTO_DTLS)
case MBEDTLS_SSL_SERVER_HELLO_VERIFY_REQUEST_SENT:
return( MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED );
#endif
/*
* ==> ServerHello
* Certificate
* ( ServerKeyExchange )
* ( CertificateRequest )
* ServerHelloDone
*/
case MBEDTLS_SSL_SERVER_HELLO:
ret = ssl_write_server_hello( ssl );
break;
case MBEDTLS_SSL_SERVER_CERTIFICATE:
ret = mbedtls_ssl_write_certificate( ssl );
break;
case MBEDTLS_SSL_SERVER_KEY_EXCHANGE:
ret = ssl_write_server_key_exchange( ssl );
break;
case MBEDTLS_SSL_CERTIFICATE_REQUEST:
ret = ssl_write_certificate_request( ssl );
break;
case MBEDTLS_SSL_SERVER_HELLO_DONE:
ret = ssl_write_server_hello_done( ssl );
break;
/*
* <== ( Certificate/Alert )
* ClientKeyExchange
* ( CertificateVerify )
* ChangeCipherSpec
* Finished
*/
case MBEDTLS_SSL_CLIENT_CERTIFICATE:
ret = mbedtls_ssl_parse_certificate( ssl );
break;
case MBEDTLS_SSL_CLIENT_KEY_EXCHANGE:
ret = ssl_parse_client_key_exchange( ssl );
break;
case MBEDTLS_SSL_CERTIFICATE_VERIFY:
ret = ssl_parse_certificate_verify( ssl );
break;
case MBEDTLS_SSL_CLIENT_CHANGE_CIPHER_SPEC:
ret = mbedtls_ssl_parse_change_cipher_spec( ssl );
break;
case MBEDTLS_SSL_CLIENT_FINISHED:
ret = mbedtls_ssl_parse_finished( ssl );
break;
/*
* ==> ( NewSessionTicket )
* ChangeCipherSpec
* Finished
*/
case MBEDTLS_SSL_SERVER_CHANGE_CIPHER_SPEC:
#if defined(MBEDTLS_SSL_SESSION_TICKETS)
if( ssl->handshake->new_session_ticket != 0 )
ret = ssl_write_new_session_ticket( ssl );
else
#endif
ret = mbedtls_ssl_write_change_cipher_spec( ssl );
break;
case MBEDTLS_SSL_SERVER_FINISHED:
ret = mbedtls_ssl_write_finished( ssl );
break;
case MBEDTLS_SSL_FLUSH_BUFFERS:
MBEDTLS_SSL_DEBUG_MSG( 2, ( "handshake: done" ) );
ssl->state = MBEDTLS_SSL_HANDSHAKE_WRAPUP;
break;
case MBEDTLS_SSL_HANDSHAKE_WRAPUP:
mbedtls_ssl_handshake_wrapup( ssl );
break;
default:
MBEDTLS_SSL_DEBUG_MSG( 1, ( "invalid state %d", ssl->state ) );
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
}
return( ret );
}
| 168,365 | 4,579 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/asn1parse.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:4;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright The Mbed TLS Contributors â
â â
â Licensed under the Apache License, Version 2.0 (the "License"); â
â you may not use this file except in compliance with the License. â
â You may obtain a copy of the License at â
â â
â http://www.apache.org/licenses/LICENSE-2.0 â
â â
â Unless required by applicable law or agreed to in writing, software â
â distributed under the License is distributed on an "AS IS" BASIS, â
â WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. â
â See the License for the specific language governing permissions and â
â limitations under the License. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/str/str.h"
#include "third_party/mbedtls/asn1.h"
#include "third_party/mbedtls/bignum.h"
#include "third_party/mbedtls/common.h"
#include "third_party/mbedtls/error.h"
#include "third_party/mbedtls/platform.h"
asm(".ident\t\"\\n\\n\
Mbed TLS (Apache 2.0)\\n\
Copyright ARM Limited\\n\
Copyright Mbed TLS Contributors\"");
asm(".include \"libc/disclaimer.inc\"");
/* clang-format off */
#if defined(MBEDTLS_ASN1_PARSE_C)
/*
* ASN.1 DER decoding routines
*/
int mbedtls_asn1_get_len_impl( unsigned char **p,
const unsigned char *end,
size_t *len )
{
if( ( end - *p ) < 1 )
return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
if( ( **p & 0x80 ) == 0 )
*len = *(*p)++;
else
{
switch( **p & 0x7F )
{
case 1:
if( ( end - *p ) < 2 )
return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
*len = (*p)[1];
(*p) += 2;
break;
case 2:
if( ( end - *p ) < 3 )
return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
*len = ( (size_t)(*p)[1] << 8 ) | (*p)[2];
(*p) += 3;
break;
case 3:
if( ( end - *p ) < 4 )
return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
*len = ( (size_t)(*p)[1] << 16 ) |
( (size_t)(*p)[2] << 8 ) | (*p)[3];
(*p) += 4;
break;
case 4:
if( ( end - *p ) < 5 )
return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
*len = ( (size_t)(*p)[1] << 24 ) | ( (size_t)(*p)[2] << 16 ) |
( (size_t)(*p)[3] << 8 ) | (*p)[4];
(*p) += 5;
break;
default:
return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
}
}
if( *len > (size_t) ( end - *p ) )
return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
return( 0 );
}
int mbedtls_asn1_get_bool( unsigned char **p,
const unsigned char *end,
int *val )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t len;
if( ( ret = mbedtls_asn1_get_tag( p, end, &len, MBEDTLS_ASN1_BOOLEAN ) ) != 0 )
return( ret );
if( len != 1 )
return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
*val = ( **p != 0 ) ? 1 : 0;
(*p)++;
return( 0 );
}
static int asn1_get_tagged_int( unsigned char **p,
const unsigned char *end,
int tag, int *val )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t len;
if( ( ret = mbedtls_asn1_get_tag( p, end, &len, tag ) ) != 0 )
return( ret );
/*
* len==0 is malformed (0 must be represented as 020100 for INTEGER,
* or 0A0100 for ENUMERATED tags
*/
if( len == 0 )
return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
/* This is a cryptography library. Reject negative integers. */
if( ( **p & 0x80 ) != 0 )
return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
/* Skip leading zeros. */
while( len > 0 && **p == 0 )
{
++( *p );
--len;
}
/* Reject integers that don't fit in an int. This code assumes that
* the int type has no padding bit. */
if( len > sizeof( int ) )
return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
if( len == sizeof( int ) && ( **p & 0x80 ) != 0 )
return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
*val = 0;
while( len-- > 0 )
{
*val = ( *val << 8 ) | **p;
(*p)++;
}
return( 0 );
}
int mbedtls_asn1_get_int( unsigned char **p,
const unsigned char *end,
int *val )
{
return( asn1_get_tagged_int( p, end, MBEDTLS_ASN1_INTEGER, val) );
}
int mbedtls_asn1_get_enum( unsigned char **p,
const unsigned char *end,
int *val )
{
return( asn1_get_tagged_int( p, end, MBEDTLS_ASN1_ENUMERATED, val) );
}
int mbedtls_asn1_get_mpi( unsigned char **p,
const unsigned char *end,
mbedtls_mpi *X )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t len;
if( ( ret = mbedtls_asn1_get_tag( p, end, &len, MBEDTLS_ASN1_INTEGER ) ) != 0 )
return( ret );
ret = mbedtls_mpi_read_binary( X, *p, len );
*p += len;
return( ret );
}
int mbedtls_asn1_get_bitstring( unsigned char **p,
const unsigned char *end,
mbedtls_asn1_bitstring *bs)
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
/* Certificate type is a single byte bitstring */
if( ( ret = mbedtls_asn1_get_tag( p, end, &bs->len, MBEDTLS_ASN1_BIT_STRING ) ) != 0 )
return( ret );
/* Check length, subtract one for actual bit string length */
if( bs->len < 1 )
return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
bs->len -= 1;
/* Get number of unused bits, ensure unused bits <= 7 */
bs->unused_bits = **p;
if( bs->unused_bits > 7 )
return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
(*p)++;
/* Get actual bitstring */
bs->p = *p;
*p += bs->len;
if( *p != end )
return( MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
return( 0 );
}
/*
* Traverse an ASN.1 "SEQUENCE OF <tag>"
* and call a callback for each entry found.
*/
int mbedtls_asn1_traverse_sequence_of(
unsigned char **p,
const unsigned char *end,
unsigned char tag_must_mask, unsigned char tag_must_val,
unsigned char tag_may_mask, unsigned char tag_may_val,
int (*cb)( void *ctx, int tag,
unsigned char *start, size_t len ),
void *ctx )
{
int ret;
size_t len;
/* Get main sequence tag */
if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
{
return( ret );
}
if( *p + len != end )
return( MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
while( *p < end )
{
unsigned char const tag = *(*p)++;
if( ( tag & tag_must_mask ) != tag_must_val )
return( MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
if( ( ret = mbedtls_asn1_get_len( p, end, &len ) ) != 0 )
return( ret );
if( ( tag & tag_may_mask ) == tag_may_val )
{
if( cb )
{
ret = cb( ctx, tag, *p, len );
if( ret != 0 )
return( ret );
}
}
*p += len;
}
return( 0 );
}
/*
* Get a bit string without unused bits
*/
int mbedtls_asn1_get_bitstring_null( unsigned char **p,
const unsigned char *end,
size_t *len )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
if( ( ret = mbedtls_asn1_get_tag( p, end, len, MBEDTLS_ASN1_BIT_STRING ) ) != 0 )
return( ret );
if( !*len )
return( MBEDTLS_ERR_ASN1_INVALID_DATA );
--( *len );
if( **p != 0 )
return( MBEDTLS_ERR_ASN1_INVALID_DATA );
++( *p );
return( 0 );
}
void mbedtls_asn1_sequence_free( mbedtls_asn1_sequence *seq )
{
while( seq )
{
mbedtls_asn1_sequence *next = seq->next;
mbedtls_platform_zeroize( seq, sizeof( *seq ) );
mbedtls_free( seq );
seq = next;
}
}
typedef struct
{
int tag;
mbedtls_asn1_sequence *cur;
} asn1_get_sequence_of_cb_ctx_t;
static int asn1_get_sequence_of_cb( void *ctx,
int tag,
unsigned char *start,
size_t len )
{
asn1_get_sequence_of_cb_ctx_t *cb_ctx =
(asn1_get_sequence_of_cb_ctx_t *) ctx;
mbedtls_asn1_sequence *cur =
cb_ctx->cur;
if( cur->buf.p )
{
cur->next =
mbedtls_calloc( 1, sizeof( mbedtls_asn1_sequence ) );
if( !cur->next )
return( MBEDTLS_ERR_ASN1_ALLOC_FAILED );
cur = cur->next;
}
cur->buf.p = start;
cur->buf.len = len;
cur->buf.tag = tag;
cb_ctx->cur = cur;
return( 0 );
}
/*
* Parses and splits an ASN.1 "SEQUENCE OF <tag>"
*/
int mbedtls_asn1_get_sequence_of( unsigned char **p,
const unsigned char *end,
mbedtls_asn1_sequence *cur,
int tag)
{
asn1_get_sequence_of_cb_ctx_t cb_ctx = { tag, cur };
mbedtls_platform_zeroize( cur, sizeof( mbedtls_asn1_sequence ) );
return( mbedtls_asn1_traverse_sequence_of(
p, end, 0xFF, tag, 0, 0,
asn1_get_sequence_of_cb, &cb_ctx ) );
}
int mbedtls_asn1_get_alg( unsigned char **p,
const unsigned char *end,
mbedtls_asn1_buf *alg,
mbedtls_asn1_buf *params )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t len;
if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
return( ret );
if( ( end - *p ) < 1 )
return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
alg->tag = **p;
end = *p + len;
if( ( ret = mbedtls_asn1_get_tag( p, end, &alg->len, MBEDTLS_ASN1_OID ) ) != 0 )
return( ret );
alg->p = *p;
*p += alg->len;
if( *p == end )
{
mbedtls_platform_zeroize( params, sizeof(mbedtls_asn1_buf) );
return( 0 );
}
params->tag = **p;
(*p)++;
if( ( ret = mbedtls_asn1_get_len( p, end, ¶ms->len ) ) != 0 )
return( ret );
params->p = *p;
*p += params->len;
if( *p != end )
return( MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
return( 0 );
}
int mbedtls_asn1_get_alg_null( unsigned char **p,
const unsigned char *end,
mbedtls_asn1_buf *alg )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
mbedtls_asn1_buf params;
mbedtls_platform_zeroize( ¶ms, sizeof(mbedtls_asn1_buf) );
if( ( ret = mbedtls_asn1_get_alg( p, end, alg, ¶ms ) ) != 0 )
return( ret );
if( ( params.tag != MBEDTLS_ASN1_NULL && params.tag != 0 ) || params.len != 0 )
return( MBEDTLS_ERR_ASN1_INVALID_DATA );
return( 0 );
}
void mbedtls_asn1_free_named_data( mbedtls_asn1_named_data *cur )
{
if( !cur )
return;
mbedtls_free( cur->oid.p );
mbedtls_free( cur->val.p );
mbedtls_platform_zeroize( cur, sizeof( mbedtls_asn1_named_data ) );
}
void mbedtls_asn1_free_named_data_list( mbedtls_asn1_named_data **head )
{
mbedtls_asn1_named_data *cur;
while( ( cur = *head ) )
{
*head = cur->next;
mbedtls_asn1_free_named_data( cur );
mbedtls_free( cur );
}
}
mbedtls_asn1_named_data *
mbedtls_asn1_find_named_data(mbedtls_asn1_named_data *list,
const char *oid, size_t len )
{
while( list )
{
if( list->oid.len == len &&
timingsafe_bcmp( list->oid.p, oid, len ) == 0 )
{
break;
}
list = list->next;
}
return( list );
}
#endif /* MBEDTLS_ASN1_PARSE_C */
| 12,870 | 393 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/asn1write.h | #ifndef MBEDTLS_ASN1_WRITE_H_
#define MBEDTLS_ASN1_WRITE_H_
#include "third_party/mbedtls/asn1.h"
#include "third_party/mbedtls/config.h"
COSMOPOLITAN_C_START_
/* clang-format off */
#define MBEDTLS_ASN1_CHK_ADD(g, f) \
do \
{ \
if( ( ret = (f) ) < 0 ) \
return( ret ); \
else \
(g) += ret; \
} while( 0 )
int mbedtls_asn1_write_len( unsigned char **, unsigned char *, size_t );
int mbedtls_asn1_write_tag( unsigned char **, unsigned char *, unsigned char );
int mbedtls_asn1_write_raw_buffer( unsigned char **, unsigned char *, const unsigned char *, size_t );
int mbedtls_asn1_write_mpi( unsigned char **, unsigned char *, const mbedtls_mpi * );
int mbedtls_asn1_write_null( unsigned char **, unsigned char * );
int mbedtls_asn1_write_oid( unsigned char **, unsigned char *, const char *, size_t );
int mbedtls_asn1_write_algorithm_identifier( unsigned char **, unsigned char *, const char *, size_t, size_t );
int mbedtls_asn1_write_bool( unsigned char **, unsigned char *, int );
int mbedtls_asn1_write_int( unsigned char **, unsigned char *, int );
int mbedtls_asn1_write_enum( unsigned char **, unsigned char *, int );
int mbedtls_asn1_write_tagged_string( unsigned char **, unsigned char *, int, const char *, size_t );
int mbedtls_asn1_write_printable_string( unsigned char **, unsigned char *, const char *, size_t );
int mbedtls_asn1_write_utf8_string( unsigned char **, unsigned char *, const char *, size_t );
int mbedtls_asn1_write_ia5_string( unsigned char **, unsigned char *, const char *, size_t );
int mbedtls_asn1_write_bitstring( unsigned char **, unsigned char *, const unsigned char *, size_t );
int mbedtls_asn1_write_named_bitstring( unsigned char **, unsigned char *, const unsigned char *, size_t );
int mbedtls_asn1_write_octet_string( unsigned char **, unsigned char *, const unsigned char *, size_t );
mbedtls_asn1_named_data *mbedtls_asn1_store_named_data( mbedtls_asn1_named_data **, const char *, size_t, const unsigned char *, size_t );
COSMOPOLITAN_C_END_
#endif /* MBEDTLS_ASN1_WRITE_H_ */
| 2,328 | 38 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/sha1t.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:4;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright The Mbed TLS Contributors â
â â
â Licensed under the Apache License, Version 2.0 (the "License"); â
â you may not use this file except in compliance with the License. â
â You may obtain a copy of the License at â
â â
â http://www.apache.org/licenses/LICENSE-2.0 â
â â
â Unless required by applicable law or agreed to in writing, software â
â distributed under the License is distributed on an "AS IS" BASIS, â
â WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. â
â See the License for the specific language governing permissions and â
â limitations under the License. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/str/str.h"
#include "third_party/mbedtls/platform.h"
#include "third_party/mbedtls/sha1.h"
asm(".ident\t\"\\n\\n\
Mbed TLS (Apache 2.0)\\n\
Copyright ARM Limited\\n\
Copyright Mbed TLS Contributors\"");
asm(".include \"libc/disclaimer.inc\"");
// clang-format off
/*
* FIPS-180-1 test vectors
*/
static const unsigned char sha1_test_buf[3][57] =
{
{ "abc" },
{ "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" },
{ "" }
};
static const size_t sha1_test_buflen[3] =
{
3, 56, 1000
};
static const unsigned char sha1_test_sum[3][20] =
{
{ 0xA9, 0x99, 0x3E, 0x36, 0x47, 0x06, 0x81, 0x6A, 0xBA, 0x3E,
0x25, 0x71, 0x78, 0x50, 0xC2, 0x6C, 0x9C, 0xD0, 0xD8, 0x9D },
{ 0x84, 0x98, 0x3E, 0x44, 0x1C, 0x3B, 0xD2, 0x6E, 0xBA, 0xAE,
0x4A, 0xA1, 0xF9, 0x51, 0x29, 0xE5, 0xE5, 0x46, 0x70, 0xF1 },
{ 0x34, 0xAA, 0x97, 0x3C, 0xD4, 0xC4, 0xDA, 0xA4, 0xF6, 0x1E,
0xEB, 0x2B, 0xDB, 0xAD, 0x27, 0x31, 0x65, 0x34, 0x01, 0x6F }
};
/**
* \brief The SHA-1 checkup routine.
*
* \warning SHA-1 is considered a weak message digest and its use
* constitutes a security risk. We recommend considering
* stronger message digests instead.
*
* \return \c 0 on success.
* \return \c 1 on failure.
*
*/
int mbedtls_sha1_self_test( int verbose )
{
int i, j, buflen, ret = 0;
unsigned char buf[1024];
unsigned char sha1sum[20];
mbedtls_sha1_context ctx;
mbedtls_sha1_init( &ctx );
/*
* SHA-1
*/
for( i = 0; i < 3; i++ )
{
if( verbose != 0 )
mbedtls_printf( " SHA-1 test #%d: ", i + 1 );
if( ( ret = mbedtls_sha1_starts_ret( &ctx ) ) != 0 )
goto fail;
if( i == 2 )
{
memset( buf, 'a', buflen = 1000 );
for( j = 0; j < 1000; j++ )
{
ret = mbedtls_sha1_update_ret( &ctx, buf, buflen );
if( ret != 0 )
goto fail;
}
}
else
{
ret = mbedtls_sha1_update_ret( &ctx, sha1_test_buf[i],
sha1_test_buflen[i] );
if( ret != 0 )
goto fail;
}
if( ( ret = mbedtls_sha1_finish_ret( &ctx, sha1sum ) ) != 0 )
goto fail;
if( timingsafe_bcmp( sha1sum, sha1_test_sum[i], 20 ) != 0 )
{
ret = 1;
goto fail;
}
if( verbose != 0 )
mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
mbedtls_printf( "\n" );
goto exit;
fail:
if( verbose != 0 )
mbedtls_printf( "failed\n" );
exit:
mbedtls_sha1_free( &ctx );
return( ret );
}
| 4,501 | 118 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/asn1.h | #ifndef MBEDTLS_ASN1_H
#define MBEDTLS_ASN1_H
#include "libc/str/str.h"
#include "third_party/mbedtls/bignum.h"
#include "third_party/mbedtls/config.h"
/* clang-format off */
/**
* \addtogroup asn1_module
* \{
*/
/**
* \name ASN1 Error codes
* These error codes are OR'ed to X509 error codes for
* higher error granularity.
* ASN1 is a standard to specify data structures.
* \{
*/
#define MBEDTLS_ERR_ASN1_OUT_OF_DATA -0x0060 /*< Out of data when parsing an ASN1 data structure. */
#define MBEDTLS_ERR_ASN1_UNEXPECTED_TAG -0x0062 /*< ASN1 tag was of an unexpected value. */
#define MBEDTLS_ERR_ASN1_INVALID_LENGTH -0x0064 /*< Error when trying to determine the length or invalid length. */
#define MBEDTLS_ERR_ASN1_LENGTH_MISMATCH -0x0066 /*< Actual length differs from expected length. */
#define MBEDTLS_ERR_ASN1_INVALID_DATA -0x0068 /*< Data is invalid. */
#define MBEDTLS_ERR_ASN1_ALLOC_FAILED -0x006A /*< Memory allocation failed */
#define MBEDTLS_ERR_ASN1_BUF_TOO_SMALL -0x006C /*< Buffer too small when writing ASN.1 data structure. */
/* \} name */
/**
* \name DER constants
* These constants comply with the DER encoded ASN.1 type tags.
* DER encoding uses hexadecimal representation.
* An example DER sequence is:\n
* - 0x02 -- tag indicating INTEGER
* - 0x01 -- length in octets
* - 0x05 -- value
* Such sequences are typically read into \c ::mbedtls_x509_buf.
* \{
*/
#define MBEDTLS_ASN1_BOOLEAN 0x01
#define MBEDTLS_ASN1_INTEGER 0x02
#define MBEDTLS_ASN1_BIT_STRING 0x03
#define MBEDTLS_ASN1_OCTET_STRING 0x04
#define MBEDTLS_ASN1_NULL 0x05
#define MBEDTLS_ASN1_OID 0x06
#define MBEDTLS_ASN1_ENUMERATED 0x0A
#define MBEDTLS_ASN1_UTF8_STRING 0x0C
#define MBEDTLS_ASN1_SEQUENCE 0x10
#define MBEDTLS_ASN1_SET 0x11
#define MBEDTLS_ASN1_PRINTABLE_STRING 0x13
#define MBEDTLS_ASN1_T61_STRING 0x14
#define MBEDTLS_ASN1_IA5_STRING 0x16
#define MBEDTLS_ASN1_UTC_TIME 0x17
#define MBEDTLS_ASN1_GENERALIZED_TIME 0x18
#define MBEDTLS_ASN1_UNIVERSAL_STRING 0x1C
#define MBEDTLS_ASN1_BMP_STRING 0x1E
#define MBEDTLS_ASN1_PRIMITIVE 0x00
#define MBEDTLS_ASN1_CONSTRUCTED 0x20
#define MBEDTLS_ASN1_CONTEXT_SPECIFIC 0x80
/* Slightly smaller way to check if tag is a string tag
* compared to canonical implementation. */
#define MBEDTLS_ASN1_IS_STRING_TAG( tag ) \
( ( tag ) < 32u && ( \
( ( 1u << ( tag ) ) & ( ( 1u << MBEDTLS_ASN1_BMP_STRING ) | \
( 1u << MBEDTLS_ASN1_UTF8_STRING ) | \
( 1u << MBEDTLS_ASN1_T61_STRING ) | \
( 1u << MBEDTLS_ASN1_IA5_STRING ) | \
( 1u << MBEDTLS_ASN1_UNIVERSAL_STRING ) | \
( 1u << MBEDTLS_ASN1_PRINTABLE_STRING ) | \
( 1u << MBEDTLS_ASN1_BIT_STRING ) ) ) != 0 ) )
/*
* Bit masks for each of the components of an ASN.1 tag as specified in
* ITU X.690 (08/2015), section 8.1 "General rules for encoding",
* paragraph 8.1.2.2:
*
* Bit 8 7 6 5 1
* +-------+-----+------------+
* | Class | P/C | Tag number |
* +-------+-----+------------+
*/
#define MBEDTLS_ASN1_TAG_CLASS_MASK 0xC0
#define MBEDTLS_ASN1_TAG_PC_MASK 0x20
#define MBEDTLS_ASN1_TAG_VALUE_MASK 0x1F
/* \} name */
/* \} addtogroup asn1_module */
/** Returns the size of the binary string, without the trailing \\0 */
#define MBEDTLS_OID_SIZE(x) (sizeof(x) - 1)
/**
* Compares an mbedtls_asn1_buf structure to a reference OID.
*
* Only works for 'defined' oid_str values (MBEDTLS_OID_HMAC_SHA1), you cannot use a
* 'unsigned char *oid' here!
*/
#define MBEDTLS_OID_CMP(oid_str, oid_buf) \
( ( MBEDTLS_OID_SIZE(oid_str) != (oid_buf)->len ) || \
timingsafe_bcmp( (oid_str), (oid_buf)->p, (oid_buf)->len) != 0 )
#define MBEDTLS_OID_CMP_RAW(oid_str, oid_buf, oid_buf_len) \
( ( MBEDTLS_OID_SIZE(oid_str) != (oid_buf_len) ) || \
timingsafe_bcmp( (oid_str), (oid_buf), (oid_buf_len) ) != 0 )
#ifdef __cplusplus
extern "C" {
#endif
/**
* \name Functions to parse ASN.1 data structures
* \{
*/
/**
* Type-length-value structure that allows for ASN1 using DER.
*/
typedef struct mbedtls_asn1_buf
{
int tag; /*< ASN1 type, e.g. MBEDTLS_ASN1_UTF8_STRING. */
size_t len; /*< ASN1 length, in octets. */
unsigned char *p; /*< ASN1 data, e.g. in ASCII. */
}
mbedtls_asn1_buf;
/**
* Container for ASN1 bit strings.
*/
typedef struct mbedtls_asn1_bitstring
{
size_t len; /*< ASN1 length, in octets. */
unsigned char unused_bits; /*< Number of unused bits at the end of the string */
unsigned char *p; /*< Raw ASN1 data for the bit string */
}
mbedtls_asn1_bitstring;
/**
* Container for a sequence of ASN.1 items
*/
typedef struct mbedtls_asn1_sequence
{
mbedtls_asn1_buf buf; /*< Buffer containing the given ASN.1 item. */
struct mbedtls_asn1_sequence *next; /*< The next entry in the sequence. */
}
mbedtls_asn1_sequence;
/**
* Container for a sequence or list of 'named' ASN.1 data items
*/
typedef struct mbedtls_asn1_named_data
{
mbedtls_asn1_buf oid; /*< The object identifier. */
mbedtls_asn1_buf val; /*< The named value. */
struct mbedtls_asn1_named_data *next; /*< The next entry in the sequence. */
unsigned char next_merged; /*< Merge next item into the current one? */
}
mbedtls_asn1_named_data;
/**
* \brief Get the length of an ASN.1 element.
* Updates the pointer to immediately behind the length.
*
* \param p On entry, \c *p points to the first byte of the length,
* i.e. immediately after the tag.
* On successful completion, \c *p points to the first byte
* after the length, i.e. the first byte of the content.
* On error, the value of \c *p is undefined.
* \param end End of data.
* \param len On successful completion, \c *len contains the length
* read from the ASN.1 input.
*
* \return 0 if successful.
* \return #MBEDTLS_ERR_ASN1_OUT_OF_DATA if the ASN.1 element
* would end beyond \p end.
* \return #MBEDTLS_ERR_ASN1_INVALID_LENGTH if the length is unparseable.
*/
forceinline int mbedtls_asn1_get_len( unsigned char **p,
const unsigned char *end,
size_t *len ) {
int mbedtls_asn1_get_len_impl( unsigned char **, const unsigned char *, size_t * );
if( ( end - *p ) < 1 )
return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
if( **p & 0x80 )
return( mbedtls_asn1_get_len_impl( p, end, len ) );
*len = *(*p)++;
if( *len > (size_t) ( end - *p ) )
return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
return( 0 );
}
/**
* \brief Get the tag and length of the element.
* Check for the requested tag.
* Updates the pointer to immediately behind the tag and length.
*
* \param p On entry, \c *p points to the start of the ASN.1 element.
* On successful completion, \c *p points to the first byte
* after the length, i.e. the first byte of the content.
* On error, the value of \c *p is undefined.
* \param end End of data.
* \param len On successful completion, \c *len contains the length
* read from the ASN.1 input.
* \param tag The expected tag.
*
* \return 0 if successful.
* \return #MBEDTLS_ERR_ASN1_UNEXPECTED_TAG if the data does not start
* with the requested tag.
* \return #MBEDTLS_ERR_ASN1_OUT_OF_DATA if the ASN.1 element
* would end beyond \p end.
* \return #MBEDTLS_ERR_ASN1_INVALID_LENGTH if the length is unparseable.
*/
forceinline int mbedtls_asn1_get_tag( unsigned char **p,
const unsigned char *end,
size_t *len, int tag )
{
if( ( end - *p ) < 1 )
return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
if( **p != tag )
return( MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
(*p)++;
return( mbedtls_asn1_get_len( p, end, len ) );
}
/**
* \brief Retrieve a boolean ASN.1 tag and its value.
* Updates the pointer to immediately behind the full tag.
*
* \param p On entry, \c *p points to the start of the ASN.1 element.
* On successful completion, \c *p points to the first byte
* beyond the ASN.1 element.
* On error, the value of \c *p is undefined.
* \param end End of data.
* \param val On success, the parsed value (\c 0 or \c 1).
*
* \return 0 if successful.
* \return An ASN.1 error code if the input does not start with
* a valid ASN.1 BOOLEAN.
*/
int mbedtls_asn1_get_bool( unsigned char **p,
const unsigned char *end,
int *val );
/**
* \brief Retrieve an integer ASN.1 tag and its value.
* Updates the pointer to immediately behind the full tag.
*
* \param p On entry, \c *p points to the start of the ASN.1 element.
* On successful completion, \c *p points to the first byte
* beyond the ASN.1 element.
* On error, the value of \c *p is undefined.
* \param end End of data.
* \param val On success, the parsed value.
*
* \return 0 if successful.
* \return An ASN.1 error code if the input does not start with
* a valid ASN.1 INTEGER.
* \return #MBEDTLS_ERR_ASN1_INVALID_LENGTH if the parsed value does
* not fit in an \c int.
*/
int mbedtls_asn1_get_int( unsigned char **p,
const unsigned char *end,
int *val );
/**
* \brief Retrieve an enumerated ASN.1 tag and its value.
* Updates the pointer to immediately behind the full tag.
*
* \param p On entry, \c *p points to the start of the ASN.1 element.
* On successful completion, \c *p points to the first byte
* beyond the ASN.1 element.
* On error, the value of \c *p is undefined.
* \param end End of data.
* \param val On success, the parsed value.
*
* \return 0 if successful.
* \return An ASN.1 error code if the input does not start with
* a valid ASN.1 ENUMERATED.
* \return #MBEDTLS_ERR_ASN1_INVALID_LENGTH if the parsed value does
* not fit in an \c int.
*/
int mbedtls_asn1_get_enum( unsigned char **p,
const unsigned char *end,
int *val );
/**
* \brief Retrieve a bitstring ASN.1 tag and its value.
* Updates the pointer to immediately behind the full tag.
*
* \param p On entry, \c *p points to the start of the ASN.1 element.
* On successful completion, \c *p is equal to \p end.
* On error, the value of \c *p is undefined.
* \param end End of data.
* \param bs On success, ::mbedtls_asn1_bitstring information about
* the parsed value.
*
* \return 0 if successful.
* \return #MBEDTLS_ERR_ASN1_LENGTH_MISMATCH if the input contains
* extra data after a valid BIT STRING.
* \return An ASN.1 error code if the input does not start with
* a valid ASN.1 BIT STRING.
*/
int mbedtls_asn1_get_bitstring( unsigned char **p, const unsigned char *end,
mbedtls_asn1_bitstring *bs );
/**
* \brief Retrieve a bitstring ASN.1 tag without unused bits and its
* value.
* Updates the pointer to the beginning of the bit/octet string.
*
* \param p On entry, \c *p points to the start of the ASN.1 element.
* On successful completion, \c *p points to the first byte
* of the content of the BIT STRING.
* On error, the value of \c *p is undefined.
* \param end End of data.
* \param len On success, \c *len is the length of the content in bytes.
*
* \return 0 if successful.
* \return #MBEDTLS_ERR_ASN1_INVALID_DATA if the input starts with
* a valid BIT STRING with a nonzero number of unused bits.
* \return An ASN.1 error code if the input does not start with
* a valid ASN.1 BIT STRING.
*/
int mbedtls_asn1_get_bitstring_null( unsigned char **p,
const unsigned char *end,
size_t *len );
/**
* \brief Parses and splits an ASN.1 "SEQUENCE OF <tag>".
* Updates the pointer to immediately behind the full sequence tag.
*
* This function allocates memory for the sequence elements. You can free
* the allocated memory with mbedtls_asn1_sequence_free().
*
* \note On error, this function may return a partial list in \p cur.
* You must set `cur->next = NULL` before calling this function!
* Otherwise it is impossible to distinguish a previously non-null
* pointer from a pointer to an object allocated by this function.
*
* \note If the sequence is empty, this function does not modify
* \c *cur. If the sequence is valid and non-empty, this
* function sets `cur->buf.tag` to \p tag. This allows
* callers to distinguish between an empty sequence and
* a one-element sequence.
*
* \param p On entry, \c *p points to the start of the ASN.1 element.
* On successful completion, \c *p is equal to \p end.
* On error, the value of \c *p is undefined.
* \param end End of data.
* \param cur A ::mbedtls_asn1_sequence which this function fills.
* When this function returns, \c *cur is the head of a linked
* list. Each node in this list is allocated with
* mbedtls_calloc() apart from \p cur itself, and should
* therefore be freed with mbedtls_free().
* The list describes the content of the sequence.
* The head of the list (i.e. \c *cur itself) describes the
* first element, `*cur->next` describes the second element, etc.
* For each element, `buf.tag == tag`, `buf.len` is the length
* of the content of the content of the element, and `buf.p`
* points to the first byte of the content (i.e. immediately
* past the length of the element).
* Note that list elements may be allocated even on error.
* \param tag Each element of the sequence must have this tag.
*
* \return 0 if successful.
* \return #MBEDTLS_ERR_ASN1_LENGTH_MISMATCH if the input contains
* extra data after a valid SEQUENCE OF \p tag.
* \return #MBEDTLS_ERR_ASN1_UNEXPECTED_TAG if the input starts with
* an ASN.1 SEQUENCE in which an element has a tag that
* is different from \p tag.
* \return #MBEDTLS_ERR_ASN1_ALLOC_FAILED if a memory allocation failed.
* \return An ASN.1 error code if the input does not start with
* a valid ASN.1 SEQUENCE.
*/
int mbedtls_asn1_get_sequence_of( unsigned char **p,
const unsigned char *end,
mbedtls_asn1_sequence *cur,
int tag );
/**
* \brief Free a heap-allocated linked list presentation of
* an ASN.1 sequence, including the first element.
*
* There are two common ways to manage the memory used for the representation
* of a parsed ASN.1 sequence:
* - Allocate a head node `mbedtls_asn1_sequence *head` with mbedtls_calloc().
* Pass this node as the `cur` argument to mbedtls_asn1_get_sequence_of().
* When you have finished processing the sequence,
* call mbedtls_asn1_sequence_free() on `head`.
* - Allocate a head node `mbedtls_asn1_sequence *head` in any manner,
* for example on the stack. Make sure that `head->next == NULL`.
* Pass `head` as the `cur` argument to mbedtls_asn1_get_sequence_of().
* When you have finished processing the sequence,
* call mbedtls_asn1_sequence_free() on `head->cur`,
* then free `head` itself in the appropriate manner.
*
* \param seq The address of the first sequence component. This may
* be \c NULL, in which case this functions returns
* immediately.
*/
void mbedtls_asn1_sequence_free( mbedtls_asn1_sequence *seq );
/**
* \brief Traverse an ASN.1 SEQUENCE container and
* call a callback for each entry.
*
* This function checks that the input is a SEQUENCE of elements that
* each have a "must" tag, and calls a callback function on the elements
* that have a "may" tag.
*
* For example, to validate that the input is a SEQUENCE of `tag1` and call
* `cb` on each element, use
* ```
* mbedtls_asn1_traverse_sequence_of(&p, end, 0xff, tag1, 0, 0, cb, ctx);
* ```
*
* To validate that the input is a SEQUENCE of ANY and call `cb` on
* each element, use
* ```
* mbedtls_asn1_traverse_sequence_of(&p, end, 0, 0, 0, 0, cb, ctx);
* ```
*
* To validate that the input is a SEQUENCE of CHOICE {NULL, OCTET STRING}
* and call `cb` on each element that is an OCTET STRING, use
* ```
* mbedtls_asn1_traverse_sequence_of(&p, end, 0xfe, 0x04, 0xff, 0x04, cb, ctx);
* ```
*
* The callback is called on the elements with a "may" tag from left to
* right. If the input is not a valid SEQUENCE of elements with a "must" tag,
* the callback is called on the elements up to the leftmost point where
* the input is invalid.
*
* \warning This function is still experimental and may change
* at any time.
*
* \param p The address of the pointer to the beginning of
* the ASN.1 SEQUENCE header. This is updated to
* point to the end of the ASN.1 SEQUENCE container
* on a successful invocation.
* \param end The end of the ASN.1 SEQUENCE container.
* \param tag_must_mask A mask to be applied to the ASN.1 tags found within
* the SEQUENCE before comparing to \p tag_must_value.
* \param tag_must_val The required value of each ASN.1 tag found in the
* SEQUENCE, after masking with \p tag_must_mask.
* Mismatching tags lead to an error.
* For example, a value of \c 0 for both \p tag_must_mask
* and \p tag_must_val means that every tag is allowed,
* while a value of \c 0xFF for \p tag_must_mask means
* that \p tag_must_val is the only allowed tag.
* \param tag_may_mask A mask to be applied to the ASN.1 tags found within
* the SEQUENCE before comparing to \p tag_may_value.
* \param tag_may_val The desired value of each ASN.1 tag found in the
* SEQUENCE, after masking with \p tag_may_mask.
* Mismatching tags will be silently ignored.
* For example, a value of \c 0 for \p tag_may_mask and
* \p tag_may_val means that any tag will be considered,
* while a value of \c 0xFF for \p tag_may_mask means
* that all tags with value different from \p tag_may_val
* will be ignored.
* \param cb The callback to trigger for each component
* in the ASN.1 SEQUENCE that matches \p tag_may_val.
* The callback function is called with the following
* parameters:
* - \p ctx.
* - The tag of the current element.
* - A pointer to the start of the current element's
* content inside the input.
* - The length of the content of the current element.
* If the callback returns a non-zero value,
* the function stops immediately,
* forwarding the callback's return value.
* \param ctx The context to be passed to the callback \p cb.
*
* \return \c 0 if successful the entire ASN.1 SEQUENCE
* was traversed without parsing or callback errors.
* \return #MBEDTLS_ERR_ASN1_LENGTH_MISMATCH if the input
* contains extra data after a valid SEQUENCE
* of elements with an accepted tag.
* \return #MBEDTLS_ERR_ASN1_UNEXPECTED_TAG if the input starts
* with an ASN.1 SEQUENCE in which an element has a tag
* that is not accepted.
* \return An ASN.1 error code if the input does not start with
* a valid ASN.1 SEQUENCE.
* \return A non-zero error code forwarded from the callback
* \p cb in case the latter returns a non-zero value.
*/
int mbedtls_asn1_traverse_sequence_of(
unsigned char **p,
const unsigned char *end,
unsigned char tag_must_mask, unsigned char tag_must_val,
unsigned char tag_may_mask, unsigned char tag_may_val,
int (*cb)( void *ctx, int tag,
unsigned char* start, size_t len ),
void *ctx );
#if defined(MBEDTLS_BIGNUM_C)
/**
* \brief Retrieve an integer ASN.1 tag and its value.
* Updates the pointer to immediately behind the full tag.
*
* \param p On entry, \c *p points to the start of the ASN.1 element.
* On successful completion, \c *p points to the first byte
* beyond the ASN.1 element.
* On error, the value of \c *p is undefined.
* \param end End of data.
* \param X On success, the parsed value.
*
* \return 0 if successful.
* \return An ASN.1 error code if the input does not start with
* a valid ASN.1 INTEGER.
* \return #MBEDTLS_ERR_ASN1_INVALID_LENGTH if the parsed value does
* not fit in an \c int.
* \return An MPI error code if the parsed value is too large.
*/
int mbedtls_asn1_get_mpi( unsigned char **p,
const unsigned char *end,
mbedtls_mpi *X );
#endif /* MBEDTLS_BIGNUM_C */
/**
* \brief Retrieve an AlgorithmIdentifier ASN.1 sequence.
* Updates the pointer to immediately behind the full
* AlgorithmIdentifier.
*
* \param p On entry, \c *p points to the start of the ASN.1 element.
* On successful completion, \c *p points to the first byte
* beyond the AlgorithmIdentifier element.
* On error, the value of \c *p is undefined.
* \param end End of data.
* \param alg The buffer to receive the OID.
* \param params The buffer to receive the parameters.
* This is zeroized if there are no parameters.
*
* \return 0 if successful or a specific ASN.1 or MPI error code.
*/
int mbedtls_asn1_get_alg( unsigned char **p,
const unsigned char *end,
mbedtls_asn1_buf *alg, mbedtls_asn1_buf *params );
/**
* \brief Retrieve an AlgorithmIdentifier ASN.1 sequence with NULL or no
* params.
* Updates the pointer to immediately behind the full
* AlgorithmIdentifier.
*
* \param p On entry, \c *p points to the start of the ASN.1 element.
* On successful completion, \c *p points to the first byte
* beyond the AlgorithmIdentifier element.
* On error, the value of \c *p is undefined.
* \param end End of data.
* \param alg The buffer to receive the OID.
*
* \return 0 if successful or a specific ASN.1 or MPI error code.
*/
int mbedtls_asn1_get_alg_null( unsigned char **p,
const unsigned char *end,
mbedtls_asn1_buf *alg );
/**
* \brief Find a specific named_data entry in a sequence or list based on
* the OID.
*
* \param list The list to seek through
* \param oid The OID to look for
* \param len Size of the OID
*
* \return NULL if not found, or a pointer to the existing entry.
*/
mbedtls_asn1_named_data *mbedtls_asn1_find_named_data( mbedtls_asn1_named_data *list,
const char *oid, size_t len );
/**
* \brief Free a mbedtls_asn1_named_data entry
*
* \param entry The named data entry to free.
* This function calls mbedtls_free() on
* `entry->oid.p` and `entry->val.p`.
*/
void mbedtls_asn1_free_named_data( mbedtls_asn1_named_data *entry );
/**
* \brief Free all entries in a mbedtls_asn1_named_data list.
*
* \param head Pointer to the head of the list of named data entries to free.
* This function calls mbedtls_asn1_free_named_data() and
* mbedtls_free() on each list element and
* sets \c *head to \c NULL.
*/
void mbedtls_asn1_free_named_data_list( mbedtls_asn1_named_data **head );
#ifdef __cplusplus
}
#endif
#endif /* asn1.h */
| 26,120 | 597 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/getciphersuitename.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:4;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright The Mbed TLS Contributors â
â â
â Licensed under the Apache License, Version 2.0 (the "License"); â
â you may not use this file except in compliance with the License. â
â You may obtain a copy of the License at â
â â
â http://www.apache.org/licenses/LICENSE-2.0 â
â â
â Unless required by applicable law or agreed to in writing, software â
â distributed under the License is distributed on an "AS IS" BASIS, â
â WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. â
â See the License for the specific language governing permissions and â
â limitations under the License. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "third_party/mbedtls/iana.h"
/**
* Returns ciphersuite name.
*
* This contains a superset of what's actually supported. It should
* include all IANA assignments.
*/
const char *GetCipherSuiteName(uint16_t x) {
switch (x) {
case 0x0000:
return "NULL-NULL-NULL";
case 0x0001:
return "RSA-NULL-MD5";
case 0x0002:
return "RSA-NULL-SHA";
case 0x0003:
return "RSA-EXPORT-RC4-40-MD5";
case 0x0004:
return "RSA-RC4-128-MD5";
case 0x0005:
return "RSA-RC4-128-SHA";
case 0x0006:
return "RSA-EXPORT-RC2-CBC-40-MD5";
case 0x0007:
return "RSA-IDEA-CBC-SHA";
case 0x0008:
return "RSA-EXPORT-DES40-CBC-SHA";
case 0x0009:
return "RSA-DES-CBC-SHA";
case 0x000A:
return "RSA-3DES-EDE-CBC-SHA";
case 0x000B:
return "DH-DSS-EXPORT-DES40-CBC-SHA";
case 0x000C:
return "DH-DSS-DES-CBC-SHA";
case 0x000D:
return "DH-DSS-3DES-EDE-CBC-SHA";
case 0x000E:
return "DH-RSA-EXPORT-DES40-CBC-SHA";
case 0x000F:
return "DH-RSA-DES-CBC-SHA";
case 0x0010:
return "DH-RSA-3DES-EDE-CBC-SHA";
case 0x0011:
return "DHE-DSS-EXPORT-DES40-CBC-SHA";
case 0x0012:
return "DHE-DSS-DES-CBC-SHA";
case 0x0013:
return "DHE-DSS-3DES-EDE-CBC-SHA";
case 0x0014:
return "DHE-RSA-EXPORT-DES40-CBC-SHA";
case 0x0015:
return "DHE-RSA-DES-CBC-SHA";
case 0x0016:
return "DHE-RSA-3DES-EDE-CBC-SHA";
case 0x0017:
return "DH-anon-EXPORT-RC4-40-MD5";
case 0x0018:
return "DH-anon-RC4-128-MD5";
case 0x0019:
return "DH-anon-EXPORT-DES40-CBC-SHA";
case 0x001A:
return "DH-anon-DES-CBC-SHA";
case 0x001B:
return "DH-anon-3DES-EDE-CBC-SHA";
case 0x001E:
return "KRB5-DES-CBC-SHA";
case 0x001F:
return "KRB5-3DES-EDE-CBC-SHA";
case 0x0020:
return "KRB5-RC4-128-SHA";
case 0x0021:
return "KRB5-IDEA-CBC-SHA";
case 0x0022:
return "KRB5-DES-CBC-MD5";
case 0x0023:
return "KRB5-3DES-EDE-CBC-MD5";
case 0x0024:
return "KRB5-RC4-128-MD5";
case 0x0025:
return "KRB5-IDEA-CBC-MD5";
case 0x0026:
return "KRB5-EXPORT-DES-CBC-40-SHA";
case 0x0027:
return "KRB5-EXPORT-RC2-CBC-40-SHA";
case 0x0028:
return "KRB5-EXPORT-RC4-40-SHA";
case 0x0029:
return "KRB5-EXPORT-DES-CBC-40-MD5";
case 0x002A:
return "KRB5-EXPORT-RC2-CBC-40-MD5";
case 0x002B:
return "KRB5-EXPORT-RC4-40-MD5";
case 0x002C:
return "PSK-NULL-SHA";
case 0x002D:
return "DHE-PSK-NULL-SHA";
case 0x002E:
return "RSA-PSK-NULL-SHA";
case 0x002F:
return "RSA-AES128-CBC-SHA";
case 0x0030:
return "DH-DSS-AES128-CBC-SHA";
case 0x0031:
return "DH-RSA-AES128-CBC-SHA";
case 0x0032:
return "DHE-DSS-AES128-CBC-SHA";
case 0x0033:
return "DHE-RSA-AES128-CBC-SHA";
case 0x0034:
return "DH-anon-AES128-CBC-SHA";
case 0x0035:
return "RSA-AES256-CBC-SHA";
case 0x0036:
return "DH-DSS-AES256-CBC-SHA";
case 0x0037:
return "DH-RSA-AES256-CBC-SHA";
case 0x0038:
return "DHE-DSS-AES256-CBC-SHA";
case 0x0039:
return "DHE-RSA-AES256-CBC-SHA";
case 0x003A:
return "DH-anon-AES256-CBC-SHA";
case 0x003B:
return "RSA-NULL-SHA256";
case 0x003C:
return "RSA-AES128-CBC-SHA256";
case 0x003D:
return "RSA-AES256-CBC-SHA256";
case 0x003E:
return "DH-DSS-AES128-CBC-SHA256";
case 0x003F:
return "DH-RSA-AES128-CBC-SHA256";
case 0x0040:
return "DHE-DSS-AES128-CBC-SHA256";
case 0x0041:
return "RSA-CAMELLIA128-CBC-SHA";
case 0x0042:
return "DH-DSS-CAMELLIA128-CBC-SHA";
case 0x0043:
return "DH-RSA-CAMELLIA128-CBC-SHA";
case 0x0044:
return "DHE-DSS-CAMELLIA128-CBC-SHA";
case 0x0045:
return "DHE-RSA-CAMELLIA128-CBC-SHA";
case 0x0046:
return "DH-anon-CAMELLIA128-CBC-SHA";
case 0x0067:
return "DHE-RSA-AES128-CBC-SHA256";
case 0x0068:
return "DH-DSS-AES256-CBC-SHA256";
case 0x0069:
return "DH-RSA-AES256-CBC-SHA256";
case 0x006A:
return "DHE-DSS-AES256-CBC-SHA256";
case 0x006B:
return "DHE-RSA-AES256-CBC-SHA256";
case 0x006C:
return "DH-anon-AES128-CBC-SHA256";
case 0x006D:
return "DH-anon-AES256-CBC-SHA256";
case 0x0084:
return "RSA-CAMELLIA256-CBC-SHA";
case 0x0085:
return "DH-DSS-CAMELLIA256-CBC-SHA";
case 0x0086:
return "DH-RSA-CAMELLIA256-CBC-SHA";
case 0x0087:
return "DHE-DSS-CAMELLIA256-CBC-SHA";
case 0x0088:
return "DHE-RSA-CAMELLIA256-CBC-SHA";
case 0x0089:
return "DH-anon-CAMELLIA256-CBC-SHA";
case 0x008A:
return "PSK-RC4-128-SHA";
case 0x008B:
return "PSK-3DES-EDE-CBC-SHA";
case 0x008C:
return "PSK-AES128-CBC-SHA";
case 0x008D:
return "PSK-AES256-CBC-SHA";
case 0x008E:
return "DHE-PSK-RC4-128-SHA";
case 0x008F:
return "DHE-PSK-3DES-EDE-CBC-SHA";
case 0x0090:
return "DHE-PSK-AES128-CBC-SHA";
case 0x0091:
return "DHE-PSK-AES256-CBC-SHA";
case 0x0092:
return "RSA-PSK-RC4-128-SHA";
case 0x0093:
return "RSA-PSK-3DES-EDE-CBC-SHA";
case 0x0094:
return "RSA-PSK-AES128-CBC-SHA";
case 0x0095:
return "RSA-PSK-AES256-CBC-SHA";
case 0x0096:
return "RSA-SEED-CBC-SHA";
case 0x0097:
return "DH-DSS-SEED-CBC-SHA";
case 0x0098:
return "DH-RSA-SEED-CBC-SHA";
case 0x0099:
return "DHE-DSS-SEED-CBC-SHA";
case 0x009A:
return "DHE-RSA-SEED-CBC-SHA";
case 0x009B:
return "DH-anon-SEED-CBC-SHA";
case 0x009C:
return "RSA-AES128-GCM-SHA256";
case 0x009D:
return "RSA-AES256-GCM-SHA384";
case 0x009E:
return "DHE-RSA-AES128-GCM-SHA256";
case 0x009F:
return "DHE-RSA-AES256-GCM-SHA384";
case 0x00A0:
return "DH-RSA-AES128-GCM-SHA256";
case 0x00A1:
return "DH-RSA-AES256-GCM-SHA384";
case 0x00A2:
return "DHE-DSS-AES128-GCM-SHA256";
case 0x00A3:
return "DHE-DSS-AES256-GCM-SHA384";
case 0x00A4:
return "DH-DSS-AES128-GCM-SHA256";
case 0x00A5:
return "DH-DSS-AES256-GCM-SHA384";
case 0x00A6:
return "DH-anon-AES128-GCM-SHA256";
case 0x00A7:
return "DH-anon-AES256-GCM-SHA384";
case 0x00A8:
return "PSK-AES128-GCM-SHA256";
case 0x00A9:
return "PSK-AES256-GCM-SHA384";
case 0x00AA:
return "DHE-PSK-AES128-GCM-SHA256";
case 0x00AB:
return "DHE-PSK-AES256-GCM-SHA384";
case 0x00AC:
return "RSA-PSK-AES128-GCM-SHA256";
case 0x00AD:
return "RSA-PSK-AES256-GCM-SHA384";
case 0x00AE:
return "PSK-AES128-CBC-SHA256";
case 0x00AF:
return "PSK-AES256-CBC-SHA384";
case 0x00B0:
return "PSK-NULL-SHA256";
case 0x00B1:
return "PSK-NULL-SHA384";
case 0x00B2:
return "DHE-PSK-AES128-CBC-SHA256";
case 0x00B3:
return "DHE-PSK-AES256-CBC-SHA384";
case 0x00B4:
return "DHE-PSK-NULL-SHA256";
case 0x00B5:
return "DHE-PSK-NULL-SHA384";
case 0x00B6:
return "RSA-PSK-AES128-CBC-SHA256";
case 0x00B7:
return "RSA-PSK-AES256-CBC-SHA384";
case 0x00B8:
return "RSA-PSK-NULL-SHA256";
case 0x00B9:
return "RSA-PSK-NULL-SHA384";
case 0x00BA:
return "RSA-CAMELLIA128-CBC-SHA256";
case 0x00BB:
return "DH-DSS-CAMELLIA128-CBC-SHA256";
case 0x00BC:
return "DH-RSA-CAMELLIA128-CBC-SHA256";
case 0x00BD:
return "DHE-DSS-CAMELLIA128-CBC-SHA256";
case 0x00BE:
return "DHE-RSA-CAMELLIA128-CBC-SHA256";
case 0x00BF:
return "DH-anon-CAMELLIA128-CBC-SHA256";
case 0x00C0:
return "RSA-CAMELLIA256-CBC-SHA256";
case 0x00C1:
return "DH-DSS-CAMELLIA256-CBC-SHA256";
case 0x00C2:
return "DH-RSA-CAMELLIA256-CBC-SHA256";
case 0x00C3:
return "DHE-DSS-CAMELLIA256-CBC-SHA256";
case 0x00C4:
return "DHE-RSA-CAMELLIA256-CBC-SHA256";
case 0x00C5:
return "DH-anon-CAMELLIA256-CBC-SHA256";
case 0x00C6:
return "SM4-GCM-SM3";
case 0x00C7:
return "SM4-CCM-SM3";
case 0x00FF:
return "EMPTY-RENEGOTIATION-INFO-SCSV";
case 0x1301:
return "AES128-GCM-SHA256";
case 0x1302:
return "AES256-GCM-SHA384";
case 0x1303:
return "CHACHA20-POLY1305-SHA256";
case 0x1304:
return "AES128-CCM-SHA256";
case 0x1305:
return "AES128-CCM8-SHA256";
case 0x5600:
return "FALLBACK-SCSV";
case 0xC001:
return "ECDH-ECDSA-NULL-SHA";
case 0xC002:
return "ECDH-ECDSA-RC4-128-SHA";
case 0xC003:
return "ECDH-ECDSA-3DES-EDE-CBC-SHA";
case 0xC004:
return "ECDH-ECDSA-AES128-CBC-SHA";
case 0xC005:
return "ECDH-ECDSA-AES256-CBC-SHA";
case 0xC006:
return "ECDHE-ECDSA-NULL-SHA";
case 0xC007:
return "ECDHE-ECDSA-RC4-128-SHA";
case 0xC008:
return "ECDHE-ECDSA-3DES-EDE-CBC-SHA";
case 0xC009:
return "ECDHE-ECDSA-AES128-CBC-SHA";
case 0xC00A:
return "ECDHE-ECDSA-AES256-CBC-SHA";
case 0xC00B:
return "ECDH-RSA-NULL-SHA";
case 0xC00C:
return "ECDH-RSA-RC4-128-SHA";
case 0xC00D:
return "ECDH-RSA-3DES-EDE-CBC-SHA";
case 0xC00E:
return "ECDH-RSA-AES128-CBC-SHA";
case 0xC00F:
return "ECDH-RSA-AES256-CBC-SHA";
case 0xC010:
return "ECDHE-RSA-NULL-SHA";
case 0xC011:
return "ECDHE-RSA-RC4-128-SHA";
case 0xC012:
return "ECDHE-RSA-3DES-EDE-CBC-SHA";
case 0xC013:
return "ECDHE-RSA-AES128-CBC-SHA";
case 0xC014:
return "ECDHE-RSA-AES256-CBC-SHA";
case 0xC015:
return "ECDH-anon-NULL-SHA";
case 0xC016:
return "ECDH-anon-RC4-128-SHA";
case 0xC017:
return "ECDH-anon-3DES-EDE-CBC-SHA";
case 0xC018:
return "ECDH-anon-AES128-CBC-SHA";
case 0xC019:
return "ECDH-anon-AES256-CBC-SHA";
case 0xC01A:
return "SRP-SHA-3DES-EDE-CBC-SHA";
case 0xC01B:
return "SRP-SHA-RSA-3DES-EDE-CBC-SHA";
case 0xC01C:
return "SRP-SHA-DSS-3DES-EDE-CBC-SHA";
case 0xC01D:
return "SRP-SHA-AES128-CBC-SHA";
case 0xC01E:
return "SRP-SHA-RSA-AES128-CBC-SHA";
case 0xC01F:
return "SRP-SHA-DSS-AES128-CBC-SHA";
case 0xC020:
return "SRP-SHA-AES256-CBC-SHA";
case 0xC021:
return "SRP-SHA-RSA-AES256-CBC-SHA";
case 0xC022:
return "SRP-SHA-DSS-AES256-CBC-SHA";
case 0xC023:
return "ECDHE-ECDSA-AES128-CBC-SHA256";
case 0xC024:
return "ECDHE-ECDSA-AES256-CBC-SHA384";
case 0xC025:
return "ECDH-ECDSA-AES128-CBC-SHA256";
case 0xC026:
return "ECDH-ECDSA-AES256-CBC-SHA384";
case 0xC027:
return "ECDHE-RSA-AES128-CBC-SHA256";
case 0xC028:
return "ECDHE-RSA-AES256-CBC-SHA384";
case 0xC029:
return "ECDH-RSA-AES128-CBC-SHA256";
case 0xC02A:
return "ECDH-RSA-AES256-CBC-SHA384";
case 0xC02B:
return "ECDHE-ECDSA-AES128-GCM-SHA256";
case 0xC02C:
return "ECDHE-ECDSA-AES256-GCM-SHA384";
case 0xC02D:
return "ECDH-ECDSA-AES128-GCM-SHA256";
case 0xC02E:
return "ECDH-ECDSA-AES256-GCM-SHA384";
case 0xC02F:
return "ECDHE-RSA-AES128-GCM-SHA256";
case 0xC030:
return "ECDHE-RSA-AES256-GCM-SHA384";
case 0xC031:
return "ECDH-RSA-AES128-GCM-SHA256";
case 0xC032:
return "ECDH-RSA-AES256-GCM-SHA384";
case 0xC033:
return "ECDHE-PSK-RC4-128-SHA";
case 0xC034:
return "ECDHE-PSK-3DES-EDE-CBC-SHA";
case 0xC035:
return "ECDHE-PSK-AES128-CBC-SHA";
case 0xC036:
return "ECDHE-PSK-AES256-CBC-SHA";
case 0xC037:
return "ECDHE-PSK-AES128-CBC-SHA256";
case 0xC038:
return "ECDHE-PSK-AES256-CBC-SHA384";
case 0xC039:
return "ECDHE-PSK-NULL-SHA";
case 0xC03A:
return "ECDHE-PSK-NULL-SHA256";
case 0xC03B:
return "ECDHE-PSK-NULL-SHA384";
case 0xC03C:
return "RSA-ARIA128-CBC-SHA256";
case 0xC03D:
return "RSA-ARIA256-CBC-SHA384";
case 0xC03E:
return "DH-DSS-ARIA128-CBC-SHA256";
case 0xC03F:
return "DH-DSS-ARIA256-CBC-SHA384";
case 0xC040:
return "DH-RSA-ARIA128-CBC-SHA256";
case 0xC041:
return "DH-RSA-ARIA256-CBC-SHA384";
case 0xC042:
return "DHE-DSS-ARIA128-CBC-SHA256";
case 0xC043:
return "DHE-DSS-ARIA256-CBC-SHA384";
case 0xC044:
return "DHE-RSA-ARIA128-CBC-SHA256";
case 0xC045:
return "DHE-RSA-ARIA256-CBC-SHA384";
case 0xC046:
return "DH-anon-ARIA128-CBC-SHA256";
case 0xC047:
return "DH-anon-ARIA256-CBC-SHA384";
case 0xC048:
return "ECDHE-ECDSA-ARIA128-CBC-SHA256";
case 0xC049:
return "ECDHE-ECDSA-ARIA256-CBC-SHA384";
case 0xC04A:
return "ECDH-ECDSA-ARIA128-CBC-SHA256";
case 0xC04B:
return "ECDH-ECDSA-ARIA256-CBC-SHA384";
case 0xC04C:
return "ECDHE-RSA-ARIA128-CBC-SHA256";
case 0xC04D:
return "ECDHE-RSA-ARIA256-CBC-SHA384";
case 0xC04E:
return "ECDH-RSA-ARIA128-CBC-SHA256";
case 0xC04F:
return "ECDH-RSA-ARIA256-CBC-SHA384";
case 0xC050:
return "RSA-ARIA128-GCM-SHA256";
case 0xC051:
return "RSA-ARIA256-GCM-SHA384";
case 0xC052:
return "DHE-RSA-ARIA128-GCM-SHA256";
case 0xC053:
return "DHE-RSA-ARIA256-GCM-SHA384";
case 0xC054:
return "DH-RSA-ARIA128-GCM-SHA256";
case 0xC055:
return "DH-RSA-ARIA256-GCM-SHA384";
case 0xC056:
return "DHE-DSS-ARIA128-GCM-SHA256";
case 0xC057:
return "DHE-DSS-ARIA256-GCM-SHA384";
case 0xC058:
return "DH-DSS-ARIA128-GCM-SHA256";
case 0xC059:
return "DH-DSS-ARIA256-GCM-SHA384";
case 0xC05A:
return "DH-anon-ARIA128-GCM-SHA256";
case 0xC05B:
return "DH-anon-ARIA256-GCM-SHA384";
case 0xC05C:
return "ECDHE-ECDSA-ARIA128-GCM-SHA256";
case 0xC05D:
return "ECDHE-ECDSA-ARIA256-GCM-SHA384";
case 0xC05E:
return "ECDH-ECDSA-ARIA128-GCM-SHA256";
case 0xC05F:
return "ECDH-ECDSA-ARIA256-GCM-SHA384";
case 0xC060:
return "ECDHE-RSA-ARIA128-GCM-SHA256";
case 0xC061:
return "ECDHE-RSA-ARIA256-GCM-SHA384";
case 0xC062:
return "ECDH-RSA-ARIA128-GCM-SHA256";
case 0xC063:
return "ECDH-RSA-ARIA256-GCM-SHA384";
case 0xC064:
return "PSK-ARIA128-CBC-SHA256";
case 0xC065:
return "PSK-ARIA256-CBC-SHA384";
case 0xC066:
return "DHE-PSK-ARIA128-CBC-SHA256";
case 0xC067:
return "DHE-PSK-ARIA256-CBC-SHA384";
case 0xC068:
return "RSA-PSK-ARIA128-CBC-SHA256";
case 0xC069:
return "RSA-PSK-ARIA256-CBC-SHA384";
case 0xC06A:
return "PSK-ARIA128-GCM-SHA256";
case 0xC06B:
return "PSK-ARIA256-GCM-SHA384";
case 0xC06C:
return "DHE-PSK-ARIA128-GCM-SHA256";
case 0xC06D:
return "DHE-PSK-ARIA256-GCM-SHA384";
case 0xC06E:
return "RSA-PSK-ARIA128-GCM-SHA256";
case 0xC06F:
return "RSA-PSK-ARIA256-GCM-SHA384";
case 0xC070:
return "ECDHE-PSK-ARIA128-CBC-SHA256";
case 0xC071:
return "ECDHE-PSK-ARIA256-CBC-SHA384";
case 0xC072:
return "ECDHE-ECDSA-CAMELLIA128-CBC-SHA256";
case 0xC073:
return "ECDHE-ECDSA-CAMELLIA256-CBC-SHA384";
case 0xC074:
return "ECDH-ECDSA-CAMELLIA128-CBC-SHA256";
case 0xC075:
return "ECDH-ECDSA-CAMELLIA256-CBC-SHA384";
case 0xC076:
return "ECDHE-RSA-CAMELLIA128-CBC-SHA256";
case 0xC077:
return "ECDHE-RSA-CAMELLIA256-CBC-SHA384";
case 0xC078:
return "ECDH-RSA-CAMELLIA128-CBC-SHA256";
case 0xC079:
return "ECDH-RSA-CAMELLIA256-CBC-SHA384";
case 0xC07A:
return "RSA-CAMELLIA128-GCM-SHA256";
case 0xC07B:
return "RSA-CAMELLIA256-GCM-SHA384";
case 0xC07C:
return "DHE-RSA-CAMELLIA128-GCM-SHA256";
case 0xC07D:
return "DHE-RSA-CAMELLIA256-GCM-SHA384";
case 0xC07E:
return "DH-RSA-CAMELLIA128-GCM-SHA256";
case 0xC07F:
return "DH-RSA-CAMELLIA256-GCM-SHA384";
case 0xC080:
return "DHE-DSS-CAMELLIA128-GCM-SHA256";
case 0xC081:
return "DHE-DSS-CAMELLIA256-GCM-SHA384";
case 0xC082:
return "DH-DSS-CAMELLIA128-GCM-SHA256";
case 0xC083:
return "DH-DSS-CAMELLIA256-GCM-SHA384";
case 0xC084:
return "DH-anon-CAMELLIA128-GCM-SHA256";
case 0xC085:
return "DH-anon-CAMELLIA256-GCM-SHA384";
case 0xC086:
return "ECDHE-ECDSA-CAMELLIA128-GCM-SHA256";
case 0xC087:
return "ECDHE-ECDSA-CAMELLIA256-GCM-SHA384";
case 0xC088:
return "ECDH-ECDSA-CAMELLIA128-GCM-SHA256";
case 0xC089:
return "ECDH-ECDSA-CAMELLIA256-GCM-SHA384";
case 0xC08A:
return "ECDHE-RSA-CAMELLIA128-GCM-SHA256";
case 0xC08B:
return "ECDHE-RSA-CAMELLIA256-GCM-SHA384";
case 0xC08C:
return "ECDH-RSA-CAMELLIA128-GCM-SHA256";
case 0xC08D:
return "ECDH-RSA-CAMELLIA256-GCM-SHA384";
case 0xC08E:
return "PSK-CAMELLIA128-GCM-SHA256";
case 0xC08F:
return "PSK-CAMELLIA256-GCM-SHA384";
case 0xC090:
return "DHE-PSK-CAMELLIA128-GCM-SHA256";
case 0xC091:
return "DHE-PSK-CAMELLIA256-GCM-SHA384";
case 0xC092:
return "RSA-PSK-CAMELLIA128-GCM-SHA256";
case 0xC093:
return "RSA-PSK-CAMELLIA256-GCM-SHA384";
case 0xC094:
return "PSK-CAMELLIA128-CBC-SHA256";
case 0xC095:
return "PSK-CAMELLIA256-CBC-SHA384";
case 0xC096:
return "DHE-PSK-CAMELLIA128-CBC-SHA256";
case 0xC097:
return "DHE-PSK-CAMELLIA256-CBC-SHA384";
case 0xC098:
return "RSA-PSK-CAMELLIA128-CBC-SHA256";
case 0xC099:
return "RSA-PSK-CAMELLIA256-CBC-SHA384";
case 0xC09A:
return "ECDHE-PSK-CAMELLIA128-CBC-SHA256";
case 0xC09B:
return "ECDHE-PSK-CAMELLIA256-CBC-SHA384";
case 0xC09C:
return "RSA-AES128-CCM";
case 0xC09D:
return "RSA-AES256-CCM";
case 0xC09E:
return "DHE-RSA-AES128-CCM";
case 0xC09F:
return "DHE-RSA-AES256-CCM";
case 0xC0A0:
return "RSA-AES128-CCM8";
case 0xC0A1:
return "RSA-AES256-CCM8";
case 0xC0A2:
return "DHE-RSA-AES128-CCM8";
case 0xC0A3:
return "DHE-RSA-AES256-CCM8";
case 0xC0A4:
return "PSK-AES128-CCM";
case 0xC0A5:
return "PSK-AES256-CCM";
case 0xC0A6:
return "DHE-PSK-AES128-CCM";
case 0xC0A7:
return "DHE-PSK-AES256-CCM";
case 0xC0A8:
return "PSK-AES128-CCM8";
case 0xC0A9:
return "PSK-AES256-CCM8";
case 0xC0AA:
return "PSK-DHE-AES128-CCM8";
case 0xC0AB:
return "PSK-DHE-AES256-CCM8";
case 0xC0AC:
return "ECDHE-ECDSA-AES128-CCM";
case 0xC0AD:
return "ECDHE-ECDSA-AES256-CCM";
case 0xC0AE:
return "ECDHE-ECDSA-AES128-CCM8";
case 0xC0AF:
return "ECDHE-ECDSA-AES256-CCM8";
case 0xC0B0:
return "ECCPWD-AES128-GCM-SHA256";
case 0xC0B1:
return "ECCPWD-AES256-GCM-SHA384";
case 0xC0B2:
return "ECCPWD-AES128-CCM-SHA256";
case 0xC0B3:
return "ECCPWD-AES256-CCM-SHA384";
case 0xC0B4:
return "SHA256-SHA256";
case 0xC0B5:
return "SHA384-SHA384";
case 0xC100:
return "GOSTR341112-256-KUZNYECHIK-CTR-OMAC";
case 0xC101:
return "GOSTR341112-256-MAGMA-CTR-OMAC";
case 0xC102:
return "GOSTR341112-256-28147-CNT-IMIT";
case 0xC103:
return "GOSTR341112-256-KUZNYECHIK-MGM-L";
case 0xC104:
return "GOSTR341112-256-MAGMA-MGM-L";
case 0xC105:
return "GOSTR341112-256-KUZNYECHIK-MGM-S";
case 0xC106:
return "GOSTR341112-256-MAGMA-MGM-S";
case 0xCCA8:
return "ECDHE-RSA-CHACHA20-POLY1305-SHA256";
case 0xCCA9:
return "ECDHE-ECDSA-CHACHA20-POLY1305-SHA256";
case 0xCCAA:
return "DHE-RSA-CHACHA20-POLY1305-SHA256";
case 0xCCAB:
return "PSK-CHACHA20-POLY1305-SHA256";
case 0xCCAC:
return "ECDHE-PSK-CHACHA20-POLY1305-SHA256";
case 0xCCAD:
return "DHE-PSK-CHACHA20-POLY1305-SHA256";
case 0xCCAE:
return "RSA-PSK-CHACHA20-POLY1305-SHA256";
case 0xD001:
return "ECDHE-PSK-AES128-GCM-SHA256";
case 0xD002:
return "ECDHE-PSK-AES256-GCM-SHA384";
case 0xD003:
return "ECDHE-PSK-AES128-CCM8-SHA256";
case 0xD005:
return "ECDHE-PSK-AES128-CCM-SHA256";
case 0x0A0A:
case 0x1A1A:
case 0x2A2A:
case 0x3A3A:
case 0x4A4A:
case 0x5A5A:
case 0x6A6A:
case 0x7A7A:
case 0x8A8A:
case 0x9A9A:
case 0xAAAA:
case 0xBABA:
case 0xCACA:
case 0xDADA:
case 0xEAEA:
case 0xFAFA:
return "GREASE-RFC8701";
case 0x0047 ... 0x004F:
case 0x0050 ... 0x0058:
case 0x0059 ... 0x005C:
case 0x0060 ... 0x0066:
case 0xFEFE ... 0xFEFF:
return "RESERVED-NO-CONFLICT";
case 0x001C ... 0x001D:
return "RESERVED-SSLV3-RFC5246";
case 0xFF00 ... 0xFFFF:
return "PRIVATE-USE-RFC8446";
default:
return "UNASSIGNED";
}
}
| 23,033 | 759 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/hkdf.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:4;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright The Mbed TLS Contributors â
â â
â Licensed under the Apache License, Version 2.0 (the "License"); â
â you may not use this file except in compliance with the License. â
â You may obtain a copy of the License at â
â â
â http://www.apache.org/licenses/LICENSE-2.0 â
â â
â Unless required by applicable law or agreed to in writing, software â
â distributed under the License is distributed on an "AS IS" BASIS, â
â WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. â
â See the License for the specific language governing permissions and â
â limitations under the License. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/str/str.h"
#include "third_party/mbedtls/common.h"
#include "third_party/mbedtls/error.h"
#include "third_party/mbedtls/hkdf.h"
#include "third_party/mbedtls/platform.h"
asm(".ident\t\"\\n\\n\
Mbed TLS (Apache 2.0)\\n\
Copyright ARM Limited\\n\
Copyright Mbed TLS Contributors\"");
asm(".include \"libc/disclaimer.inc\"");
/* clang-format off */
/**
* @fileoverview HKDF implementation (RFC 5869)
*/
/**
* \brief HMAC-based Extract-and-Expand Key Derivation Function
*
* \param md A hash function; md.size denotes the length of the hash
* function output in bytes.
* \param salt An optional salt value (a non-secret random value);
* if the salt is not provided, a string of all zeros of
* md.size length is used as the salt.
* \param salt_len The length in bytes of the optional \p salt.
* \param ikm The input keying material.
* \param ikm_len The length in bytes of \p ikm.
* \param info An optional context and application specific information
* string. This can be a zero-length string.
* \param info_len The length of \p info in bytes.
* \param okm The output keying material of \p okm_len bytes.
* \param okm_len The length of the output keying material in bytes. This
* must be less than or equal to 255 * md.size bytes.
*
* \return 0 on success.
* \return #MBEDTLS_ERR_HKDF_BAD_INPUT_DATA when the parameters are invalid.
* \return An MBEDTLS_ERR_MD_* error for errors returned from the underlying
* MD layer.
*/
int mbedtls_hkdf( const mbedtls_md_info_t *md, const unsigned char *salt,
size_t salt_len, const unsigned char *ikm, size_t ikm_len,
const unsigned char *info, size_t info_len,
unsigned char *okm, size_t okm_len )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
unsigned char prk[MBEDTLS_MD_MAX_SIZE];
ret = mbedtls_hkdf_extract( md, salt, salt_len, ikm, ikm_len, prk );
if( ret == 0 )
{
ret = mbedtls_hkdf_expand( md, prk, mbedtls_md_get_size( md ),
info, info_len, okm, okm_len );
}
mbedtls_platform_zeroize( prk, sizeof( prk ) );
return( ret );
}
/**
* \brief Takes input keying material \p ikm and extract from it a
* fixed-length pseudorandom key \p prk.
*
* \warning This function should only be used if the security of it has been
* studied and established in that particular context (eg. TLS 1.3
* key schedule). For standard HKDF security guarantees use
* \c mbedtls_hkdf instead.
*
* \param md A hash function; md.size denotes the length of the
* hash function output in bytes.
* \param salt An optional salt value (a non-secret random value);
* if the salt is not provided, a string of all zeros
* of md.size length is used as the salt.
* \param salt_len The length in bytes of the optional \p salt.
* \param ikm The input keying material.
* \param ikm_len The length in bytes of \p ikm.
* \param[out] prk A pseudorandom key of at least md.size bytes.
*
* \return 0 on success.
* \return #MBEDTLS_ERR_HKDF_BAD_INPUT_DATA when the parameters are invalid.
* \return An MBEDTLS_ERR_MD_* error for errors returned from the underlying
* MD layer.
*/
int mbedtls_hkdf_extract( const mbedtls_md_info_t *md,
const unsigned char *salt, size_t salt_len,
const unsigned char *ikm, size_t ikm_len,
unsigned char *prk )
{
unsigned char null_salt[MBEDTLS_MD_MAX_SIZE] = { '\0' };
if( salt == NULL )
{
size_t hash_len;
if( salt_len != 0 )
{
return MBEDTLS_ERR_HKDF_BAD_INPUT_DATA;
}
hash_len = mbedtls_md_get_size( md );
if( hash_len == 0 )
{
return MBEDTLS_ERR_HKDF_BAD_INPUT_DATA;
}
salt = null_salt;
salt_len = hash_len;
}
return( mbedtls_md_hmac( md, salt, salt_len, ikm, ikm_len, prk ) );
}
/**
* \brief Expand the supplied \p prk into several additional
* pseudorandom keys, which is the output of the HKDF.
*
* \param md A hash function; md.size denotes the length of the hash
* function output in bytes.
* \param prk A pseudorandom key of at least md.size bytes. \p prk is
* usually the output from the HKDF extract step.
* \param prk_len The length in bytes of \p prk.
* \param info An optional context and application specific information
* string. This can be a zero-length string.
* \param info_len The length of \p info in bytes.
* \param okm The output keying material of \p okm_len bytes.
* \param okm_len The length of the output keying material in bytes. This
* must be less than or equal to 255 * md.size bytes.
*
* \return 0 on success
* \return #MBEDTLS_ERR_HKDF_BAD_INPUT_DATA when the
* parameters are invalid.
* \return An MBEDTLS_ERR_MD_* error for errors returned from
* the underlying MD layer.
*
* \warning This function should only be used if its security has
* been studied and established in that particular context
* (eg. TLS 1.3 key schedule). For standard HKDF security
* guarantees use \c mbedtls_hkdf instead.
*/
int mbedtls_hkdf_expand( const mbedtls_md_info_t *md, const unsigned char *prk,
size_t prk_len, const unsigned char *info,
size_t info_len, unsigned char *okm, size_t okm_len )
{
size_t hash_len;
size_t where = 0;
size_t n;
size_t t_len = 0;
size_t i;
int ret = 0;
mbedtls_md_context_t ctx;
unsigned char t[MBEDTLS_MD_MAX_SIZE];
if( !okm ) return( MBEDTLS_ERR_HKDF_BAD_INPUT_DATA );
hash_len = mbedtls_md_get_size( md );
if( prk_len < hash_len || hash_len == 0 )
{
return( MBEDTLS_ERR_HKDF_BAD_INPUT_DATA );
}
if( info == NULL )
{
info = (const unsigned char *) "";
info_len = 0;
}
n = okm_len / hash_len;
if( okm_len % hash_len != 0 )
{
n++;
}
/*
* Per RFC 5869 Section 2.3, okm_len must not exceed
* 255 times the hash length
*/
if( n > 255 ) return( MBEDTLS_ERR_HKDF_BAD_INPUT_DATA );
mbedtls_md_init( &ctx );
if(( ret = mbedtls_md_setup( &ctx, md, 1 ) )) goto exit;
mbedtls_platform_zeroize( t, hash_len );
/*
* Compute T = T(1) | T(2) | T(3) | ... | T(N)
* Where T(N) is defined in RFC 5869 Section 2.3
*/
for( i = 1; i <= n; i++ )
{
size_t num_to_copy;
unsigned char c = i & 0xff;
if(( ret = mbedtls_md_hmac_starts( &ctx, prk, prk_len ) )) goto exit;
if(( ret = mbedtls_md_hmac_update( &ctx, t, t_len ) )) goto exit;
if(( ret = mbedtls_md_hmac_update( &ctx, info, info_len ) )) goto exit;
if(( ret = mbedtls_md_hmac_update( &ctx, &c, 1 ) )) goto exit;
if(( ret = mbedtls_md_hmac_finish( &ctx, t ) )) goto exit;
num_to_copy = i != n ? hash_len : okm_len - where;
memcpy( okm + where, t, num_to_copy );
where += hash_len;
t_len = hash_len;
}
exit:
mbedtls_md_free( &ctx );
mbedtls_platform_zeroize( t, sizeof( t ) );
return( ret );
}
| 9,401 | 209 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/ssl_ticket.h | #ifndef MBEDTLS_SSL_TICKET_H
#define MBEDTLS_SSL_TICKET_H
#include "third_party/mbedtls/cipher.h"
#include "third_party/mbedtls/config.h"
#include "third_party/mbedtls/ssl.h"
/* clang-format off */
/*
* This implementation of the session ticket callbacks includes key
* management, rotating the keys periodically in order to preserve forward
* secrecy, when MBEDTLS_HAVE_TIME is defined.
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* \brief Information for session ticket protection
*/
typedef struct mbedtls_ssl_ticket_key
{
unsigned char name[4]; /*!< random key identifier */
uint32_t generation_time; /*!< key generation timestamp (seconds) */
mbedtls_cipher_context_t ctx; /*!< context for auth enc/decryption */
}
mbedtls_ssl_ticket_key;
/**
* \brief Context for session ticket handling functions
*/
typedef struct mbedtls_ssl_ticket_context
{
mbedtls_ssl_ticket_key keys[2]; /*!< ticket protection keys */
unsigned char active; /*!< index of the currently active key */
uint32_t ticket_lifetime; /*!< lifetime of tickets in seconds */
/** Callback for getting (pseudo-)random numbers */
int (*f_rng)(void *, unsigned char *, size_t);
void *p_rng; /*!< context for the RNG function */
}
mbedtls_ssl_ticket_context;
/**
* \brief Initialize a ticket context.
* (Just make it ready for mbedtls_ssl_ticket_setup()
* or mbedtls_ssl_ticket_free().)
*
* \param ctx Context to be initialized
*/
void mbedtls_ssl_ticket_init( mbedtls_ssl_ticket_context *ctx );
int mbedtls_ssl_ticket_setup( mbedtls_ssl_ticket_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t), void *p_rng,
mbedtls_cipher_type_t cipher,
uint32_t lifetime );
/**
* \brief Implementation of the ticket write callback
*
* \note See \c mbedtls_ssl_ticket_write_t for description
*/
extern mbedtls_ssl_ticket_write_t mbedtls_ssl_ticket_write;
/**
* \brief Implementation of the ticket parse callback
*
* \note See \c mbedtls_ssl_ticket_parse_t for description
*/
extern mbedtls_ssl_ticket_parse_t mbedtls_ssl_ticket_parse;
/**
* \brief Free a context's content and zeroize it.
*
* \param ctx Context to be cleaned up
*/
void mbedtls_ssl_ticket_free( mbedtls_ssl_ticket_context *ctx );
#ifdef __cplusplus
}
#endif
#endif /* ssl_ticket.h */
| 2,524 | 85 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/poly1305.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:4;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright The Mbed TLS Contributors â
â â
â Licensed under the Apache License, Version 2.0 (the "License"); â
â you may not use this file except in compliance with the License. â
â You may obtain a copy of the License at â
â â
â http://www.apache.org/licenses/LICENSE-2.0 â
â â
â Unless required by applicable law or agreed to in writing, software â
â distributed under the License is distributed on an "AS IS" BASIS, â
â WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. â
â See the License for the specific language governing permissions and â
â limitations under the License. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/intrin/bits.h"
#include "libc/str/str.h"
#include "third_party/mbedtls/common.h"
#include "third_party/mbedtls/error.h"
#include "third_party/mbedtls/platform.h"
#include "third_party/mbedtls/poly1305.h"
asm(".ident\t\"\\n\\n\
Mbed TLS (Apache 2.0)\\n\
Copyright ARM Limited\\n\
Copyright Mbed TLS Contributors\"");
asm(".include \"libc/disclaimer.inc\"");
/* clang-format off */
/**
* \file poly1305.c
*
* \brief Poly1305 authentication algorithm.
*
* Copyright The Mbed TLS Contributors
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#if defined(MBEDTLS_POLY1305_C)
#if !defined(MBEDTLS_POLY1305_ALT)
#if ( defined(__ARMCC_VERSION) || defined(_MSC_VER) ) && \
!defined(inline) && !defined(__cplusplus)
#define inline __inline
#endif
/* Parameter validation macros */
#define POLY1305_VALIDATE_RET( cond ) \
MBEDTLS_INTERNAL_VALIDATE_RET( cond, MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA )
#define POLY1305_VALIDATE( cond ) \
MBEDTLS_INTERNAL_VALIDATE( cond )
#define POLY1305_BLOCK_SIZE_BYTES ( 16U )
#define BYTES_TO_U32_LE( data, offset ) READ32LE((data) + (offset))
/*
* Our implementation is tuned for 32-bit platforms with a 64-bit multiplier.
* However we provided an alternative for platforms without such a multiplier.
*/
#if defined(MBEDTLS_NO_64BIT_MULTIPLICATION)
static uint64_t mul64( uint32_t a, uint32_t b )
{
/* a = al + 2**16 ah, b = bl + 2**16 bh */
const uint16_t al = (uint16_t) a;
const uint16_t bl = (uint16_t) b;
const uint16_t ah = a >> 16;
const uint16_t bh = b >> 16;
/* ab = al*bl + 2**16 (ah*bl + bl*bh) + 2**32 ah*bh */
const uint32_t lo = (uint32_t) al * bl;
const uint64_t me = (uint64_t)( (uint32_t) ah * bl ) + (uint32_t) al * bh;
const uint32_t hi = (uint32_t) ah * bh;
return( lo + ( me << 16 ) + ( (uint64_t) hi << 32 ) );
}
#else
static inline uint64_t mul64( uint32_t a, uint32_t b )
{
return( (uint64_t) a * b );
}
#endif
/**
* \brief Process blocks with Poly1305.
*
* \param ctx The Poly1305 context.
* \param nblocks Number of blocks to process. Note that this
* function only processes full blocks.
* \param input Buffer containing the input block(s).
* \param needs_padding Set to 0 if the padding bit has already been
* applied to the input data before calling this
* function. Otherwise, set this parameter to 1.
*/
static void poly1305_process( mbedtls_poly1305_context *ctx,
size_t nblocks,
const unsigned char *input,
uint32_t needs_padding )
{
uint64_t d0, d1, d2, d3;
uint32_t acc0, acc1, acc2, acc3, acc4;
uint32_t r0, r1, r2, r3;
uint32_t rs1, rs2, rs3;
size_t offset = 0U;
size_t i;
r0 = ctx->r[0];
r1 = ctx->r[1];
r2 = ctx->r[2];
r3 = ctx->r[3];
rs1 = r1 + ( r1 >> 2U );
rs2 = r2 + ( r2 >> 2U );
rs3 = r3 + ( r3 >> 2U );
acc0 = ctx->acc[0];
acc1 = ctx->acc[1];
acc2 = ctx->acc[2];
acc3 = ctx->acc[3];
acc4 = ctx->acc[4];
/* Process full blocks */
for( i = 0U; i < nblocks; i++ )
{
/* The input block is treated as a 128-bit little-endian integer */
d0 = BYTES_TO_U32_LE( input, offset + 0 );
d1 = BYTES_TO_U32_LE( input, offset + 4 );
d2 = BYTES_TO_U32_LE( input, offset + 8 );
d3 = BYTES_TO_U32_LE( input, offset + 12 );
/* Compute: acc += (padded) block as a 130-bit integer */
d0 += (uint64_t) acc0;
d1 += (uint64_t) acc1 + ( d0 >> 32U );
d2 += (uint64_t) acc2 + ( d1 >> 32U );
d3 += (uint64_t) acc3 + ( d2 >> 32U );
acc0 = (uint32_t) d0;
acc1 = (uint32_t) d1;
acc2 = (uint32_t) d2;
acc3 = (uint32_t) d3;
acc4 += (uint32_t) ( d3 >> 32U ) + needs_padding;
/* Compute: acc *= r */
d0 = mul64( acc0, r0 ) +
mul64( acc1, rs3 ) +
mul64( acc2, rs2 ) +
mul64( acc3, rs1 );
d1 = mul64( acc0, r1 ) +
mul64( acc1, r0 ) +
mul64( acc2, rs3 ) +
mul64( acc3, rs2 ) +
mul64( acc4, rs1 );
d2 = mul64( acc0, r2 ) +
mul64( acc1, r1 ) +
mul64( acc2, r0 ) +
mul64( acc3, rs3 ) +
mul64( acc4, rs2 );
d3 = mul64( acc0, r3 ) +
mul64( acc1, r2 ) +
mul64( acc2, r1 ) +
mul64( acc3, r0 ) +
mul64( acc4, rs3 );
acc4 *= r0;
/* Compute: acc %= (2^130 - 5) (partial remainder) */
d1 += ( d0 >> 32 );
d2 += ( d1 >> 32 );
d3 += ( d2 >> 32 );
acc0 = (uint32_t) d0;
acc1 = (uint32_t) d1;
acc2 = (uint32_t) d2;
acc3 = (uint32_t) d3;
acc4 = (uint32_t) ( d3 >> 32 ) + acc4;
d0 = (uint64_t) acc0 + ( acc4 >> 2 ) + ( acc4 & 0xFFFFFFFCU );
acc4 &= 3U;
acc0 = (uint32_t) d0;
d0 = (uint64_t) acc1 + ( d0 >> 32U );
acc1 = (uint32_t) d0;
d0 = (uint64_t) acc2 + ( d0 >> 32U );
acc2 = (uint32_t) d0;
d0 = (uint64_t) acc3 + ( d0 >> 32U );
acc3 = (uint32_t) d0;
d0 = (uint64_t) acc4 + ( d0 >> 32U );
acc4 = (uint32_t) d0;
offset += POLY1305_BLOCK_SIZE_BYTES;
}
ctx->acc[0] = acc0;
ctx->acc[1] = acc1;
ctx->acc[2] = acc2;
ctx->acc[3] = acc3;
ctx->acc[4] = acc4;
}
/**
* \brief Compute the Poly1305 MAC
*
* \param ctx The Poly1305 context.
* \param mac The buffer to where the MAC is written. Must be
* big enough to contain the 16-byte MAC.
*/
static void poly1305_compute_mac( const mbedtls_poly1305_context *ctx,
unsigned char mac[16] )
{
uint64_t d;
uint32_t g0, g1, g2, g3, g4;
uint32_t acc0, acc1, acc2, acc3, acc4;
uint32_t mask;
uint32_t mask_inv;
acc0 = ctx->acc[0];
acc1 = ctx->acc[1];
acc2 = ctx->acc[2];
acc3 = ctx->acc[3];
acc4 = ctx->acc[4];
/* Before adding 's' we ensure that the accumulator is mod 2^130 - 5.
* We do this by calculating acc - (2^130 - 5), then checking if
* the 131st bit is set. If it is, then reduce: acc -= (2^130 - 5)
*/
/* Calculate acc + -(2^130 - 5) */
d = ( (uint64_t) acc0 + 5U );
g0 = (uint32_t) d;
d = ( (uint64_t) acc1 + ( d >> 32 ) );
g1 = (uint32_t) d;
d = ( (uint64_t) acc2 + ( d >> 32 ) );
g2 = (uint32_t) d;
d = ( (uint64_t) acc3 + ( d >> 32 ) );
g3 = (uint32_t) d;
g4 = acc4 + (uint32_t) ( d >> 32U );
/* mask == 0xFFFFFFFF if 131st bit is set, otherwise mask == 0 */
mask = (uint32_t) 0U - ( g4 >> 2U );
mask_inv = ~mask;
/* If 131st bit is set then acc=g, otherwise, acc is unmodified */
acc0 = ( acc0 & mask_inv ) | ( g0 & mask );
acc1 = ( acc1 & mask_inv ) | ( g1 & mask );
acc2 = ( acc2 & mask_inv ) | ( g2 & mask );
acc3 = ( acc3 & mask_inv ) | ( g3 & mask );
/* Add 's' */
d = (uint64_t) acc0 + ctx->s[0];
acc0 = (uint32_t) d;
d = (uint64_t) acc1 + ctx->s[1] + ( d >> 32U );
acc1 = (uint32_t) d;
d = (uint64_t) acc2 + ctx->s[2] + ( d >> 32U );
acc2 = (uint32_t) d;
acc3 += ctx->s[3] + (uint32_t) ( d >> 32U );
/* Compute MAC (128 least significant bits of the accumulator) */
mac[ 0] = (unsigned char)( acc0 );
mac[ 1] = (unsigned char)( acc0 >> 8 );
mac[ 2] = (unsigned char)( acc0 >> 16 );
mac[ 3] = (unsigned char)( acc0 >> 24 );
mac[ 4] = (unsigned char)( acc1 );
mac[ 5] = (unsigned char)( acc1 >> 8 );
mac[ 6] = (unsigned char)( acc1 >> 16 );
mac[ 7] = (unsigned char)( acc1 >> 24 );
mac[ 8] = (unsigned char)( acc2 );
mac[ 9] = (unsigned char)( acc2 >> 8 );
mac[10] = (unsigned char)( acc2 >> 16 );
mac[11] = (unsigned char)( acc2 >> 24 );
mac[12] = (unsigned char)( acc3 );
mac[13] = (unsigned char)( acc3 >> 8 );
mac[14] = (unsigned char)( acc3 >> 16 );
mac[15] = (unsigned char)( acc3 >> 24 );
}
void mbedtls_poly1305_init( mbedtls_poly1305_context *ctx )
{
POLY1305_VALIDATE( ctx != NULL );
mbedtls_platform_zeroize( ctx, sizeof( mbedtls_poly1305_context ) );
}
void mbedtls_poly1305_free( mbedtls_poly1305_context *ctx )
{
if( ctx == NULL )
return;
mbedtls_platform_zeroize( ctx, sizeof( mbedtls_poly1305_context ) );
}
int mbedtls_poly1305_starts( mbedtls_poly1305_context *ctx,
const unsigned char key[32] )
{
POLY1305_VALIDATE_RET( ctx != NULL );
POLY1305_VALIDATE_RET( key != NULL );
/* r &= 0x0ffffffc0ffffffc0ffffffc0fffffff */
ctx->r[0] = BYTES_TO_U32_LE( key, 0 ) & 0x0FFFFFFFU;
ctx->r[1] = BYTES_TO_U32_LE( key, 4 ) & 0x0FFFFFFCU;
ctx->r[2] = BYTES_TO_U32_LE( key, 8 ) & 0x0FFFFFFCU;
ctx->r[3] = BYTES_TO_U32_LE( key, 12 ) & 0x0FFFFFFCU;
ctx->s[0] = BYTES_TO_U32_LE( key, 16 );
ctx->s[1] = BYTES_TO_U32_LE( key, 20 );
ctx->s[2] = BYTES_TO_U32_LE( key, 24 );
ctx->s[3] = BYTES_TO_U32_LE( key, 28 );
/* Initial accumulator state */
ctx->acc[0] = 0U;
ctx->acc[1] = 0U;
ctx->acc[2] = 0U;
ctx->acc[3] = 0U;
ctx->acc[4] = 0U;
/* Queue initially empty */
mbedtls_platform_zeroize( ctx->queue, sizeof( ctx->queue ) );
ctx->queue_len = 0U;
return( 0 );
}
int mbedtls_poly1305_update( mbedtls_poly1305_context *ctx,
const unsigned char *input,
size_t ilen )
{
size_t offset = 0U;
size_t remaining = ilen;
size_t queue_free_len;
size_t nblocks;
POLY1305_VALIDATE_RET( ctx != NULL );
POLY1305_VALIDATE_RET( ilen == 0 || input != NULL );
if( ( remaining > 0U ) && ( ctx->queue_len > 0U ) )
{
queue_free_len = ( POLY1305_BLOCK_SIZE_BYTES - ctx->queue_len );
if( ilen < queue_free_len )
{
/* Not enough data to complete the block.
* Store this data with the other leftovers.
*/
memcpy( &ctx->queue[ctx->queue_len],
input,
ilen );
ctx->queue_len += ilen;
remaining = 0U;
}
else
{
/* Enough data to produce a complete block */
memcpy( &ctx->queue[ctx->queue_len],
input,
queue_free_len );
ctx->queue_len = 0U;
poly1305_process( ctx, 1U, ctx->queue, 1U ); /* add padding bit */
offset += queue_free_len;
remaining -= queue_free_len;
}
}
if( remaining >= POLY1305_BLOCK_SIZE_BYTES )
{
nblocks = remaining / POLY1305_BLOCK_SIZE_BYTES;
poly1305_process( ctx, nblocks, &input[offset], 1U );
offset += nblocks * POLY1305_BLOCK_SIZE_BYTES;
remaining %= POLY1305_BLOCK_SIZE_BYTES;
}
if( remaining > 0U )
{
/* Store partial block */
ctx->queue_len = remaining;
memcpy( ctx->queue, &input[offset], remaining );
}
return( 0 );
}
int mbedtls_poly1305_finish( mbedtls_poly1305_context *ctx,
unsigned char mac[16] )
{
POLY1305_VALIDATE_RET( ctx != NULL );
POLY1305_VALIDATE_RET( mac != NULL );
/* Process any leftover data */
if( ctx->queue_len > 0U )
{
/* Add padding bit */
ctx->queue[ctx->queue_len] = 1U;
ctx->queue_len++;
/* Pad with zeroes */
memset( &ctx->queue[ctx->queue_len],
0,
POLY1305_BLOCK_SIZE_BYTES - ctx->queue_len );
poly1305_process( ctx, 1U, /* Process 1 block */
ctx->queue, 0U ); /* Already padded above */
}
poly1305_compute_mac( ctx, mac );
return( 0 );
}
int mbedtls_poly1305_mac( const unsigned char key[32],
const unsigned char *input,
size_t ilen,
unsigned char mac[16] )
{
mbedtls_poly1305_context ctx;
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
POLY1305_VALIDATE_RET( key != NULL );
POLY1305_VALIDATE_RET( mac != NULL );
POLY1305_VALIDATE_RET( ilen == 0 || input != NULL );
mbedtls_poly1305_init( &ctx );
ret = mbedtls_poly1305_starts( &ctx, key );
if( ret != 0 )
goto cleanup;
ret = mbedtls_poly1305_update( &ctx, input, ilen );
if( ret != 0 )
goto cleanup;
ret = mbedtls_poly1305_finish( &ctx, mac );
cleanup:
mbedtls_poly1305_free( &ctx );
return( ret );
}
#endif /* MBEDTLS_POLY1305_ALT */
#if defined(MBEDTLS_SELF_TEST)
static const unsigned char test_keys[2][32] =
{
{
0x85, 0xd6, 0xbe, 0x78, 0x57, 0x55, 0x6d, 0x33,
0x7f, 0x44, 0x52, 0xfe, 0x42, 0xd5, 0x06, 0xa8,
0x01, 0x03, 0x80, 0x8a, 0xfb, 0x0d, 0xb2, 0xfd,
0x4a, 0xbf, 0xf6, 0xaf, 0x41, 0x49, 0xf5, 0x1b
},
{
0x1c, 0x92, 0x40, 0xa5, 0xeb, 0x55, 0xd3, 0x8a,
0xf3, 0x33, 0x88, 0x86, 0x04, 0xf6, 0xb5, 0xf0,
0x47, 0x39, 0x17, 0xc1, 0x40, 0x2b, 0x80, 0x09,
0x9d, 0xca, 0x5c, 0xbc, 0x20, 0x70, 0x75, 0xc0
}
};
static const unsigned char test_data[2][127] =
{
{
0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x67, 0x72,
0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x46, 0x6f,
0x72, 0x75, 0x6d, 0x20, 0x52, 0x65, 0x73, 0x65,
0x61, 0x72, 0x63, 0x68, 0x20, 0x47, 0x72, 0x6f,
0x75, 0x70
},
{
0x27, 0x54, 0x77, 0x61, 0x73, 0x20, 0x62, 0x72,
0x69, 0x6c, 0x6c, 0x69, 0x67, 0x2c, 0x20, 0x61,
0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73,
0x6c, 0x69, 0x74, 0x68, 0x79, 0x20, 0x74, 0x6f,
0x76, 0x65, 0x73, 0x0a, 0x44, 0x69, 0x64, 0x20,
0x67, 0x79, 0x72, 0x65, 0x20, 0x61, 0x6e, 0x64,
0x20, 0x67, 0x69, 0x6d, 0x62, 0x6c, 0x65, 0x20,
0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x77,
0x61, 0x62, 0x65, 0x3a, 0x0a, 0x41, 0x6c, 0x6c,
0x20, 0x6d, 0x69, 0x6d, 0x73, 0x79, 0x20, 0x77,
0x65, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20,
0x62, 0x6f, 0x72, 0x6f, 0x67, 0x6f, 0x76, 0x65,
0x73, 0x2c, 0x0a, 0x41, 0x6e, 0x64, 0x20, 0x74,
0x68, 0x65, 0x20, 0x6d, 0x6f, 0x6d, 0x65, 0x20,
0x72, 0x61, 0x74, 0x68, 0x73, 0x20, 0x6f, 0x75,
0x74, 0x67, 0x72, 0x61, 0x62, 0x65, 0x2e
}
};
static const size_t test_data_len[2] =
{
34U,
127U
};
static const unsigned char test_mac[2][16] =
{
{
0xa8, 0x06, 0x1d, 0xc1, 0x30, 0x51, 0x36, 0xc6,
0xc2, 0x2b, 0x8b, 0xaf, 0x0c, 0x01, 0x27, 0xa9
},
{
0x45, 0x41, 0x66, 0x9a, 0x7e, 0xaa, 0xee, 0x61,
0xe7, 0x08, 0xdc, 0x7c, 0xbc, 0xc5, 0xeb, 0x62
}
};
/* Make sure no other definition is already present. */
#undef ASSERT
#define ASSERT( cond, args ) \
do \
{ \
if( ! ( cond ) ) \
{ \
if( verbose != 0 ) \
mbedtls_printf args; \
\
return( -1 ); \
} \
} \
while( 0 )
int mbedtls_poly1305_self_test( int verbose )
{
unsigned char mac[16];
unsigned i;
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
for( i = 0U; i < 2U; i++ )
{
if( verbose != 0 )
mbedtls_printf( " Poly1305 test %u ", i );
ret = mbedtls_poly1305_mac( test_keys[i],
test_data[i],
test_data_len[i],
mac );
ASSERT( 0 == ret, ( "error code: %i\n", ret ) );
ASSERT( 0 == timingsafe_bcmp( mac, test_mac[i], 16U ), ( "failed (mac)\n" ) );
if( verbose != 0 )
mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
mbedtls_printf( "\n" );
return( 0 );
}
#endif /* MBEDTLS_SELF_TEST */
#endif /* MBEDTLS_POLY1305_C */
| 18,704 | 568 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/x509.h | #ifndef MBEDTLS_X509_H_
#define MBEDTLS_X509_H_
#include "third_party/mbedtls/asn1.h"
#include "third_party/mbedtls/config.h"
#include "third_party/mbedtls/pk.h"
#include "third_party/mbedtls/rsa.h"
COSMOPOLITAN_C_START_
/* clang-format off */
#define MBEDTLS_ERR_X509_FEATURE_UNAVAILABLE -0x2080 /*< Unavailable feature, e.g. RSA hashing/encryption combination. */
#define MBEDTLS_ERR_X509_UNKNOWN_OID -0x2100 /*< Requested OID is unknown. */
#define MBEDTLS_ERR_X509_INVALID_FORMAT -0x2180 /*< The CRT/CRL/CSR format is invalid, e.g. different type expected. */
#define MBEDTLS_ERR_X509_INVALID_VERSION -0x2200 /*< The CRT/CRL/CSR version element is invalid. */
#define MBEDTLS_ERR_X509_INVALID_SERIAL -0x2280 /*< The serial tag or value is invalid. */
#define MBEDTLS_ERR_X509_INVALID_ALG -0x2300 /*< The algorithm tag or value is invalid. */
#define MBEDTLS_ERR_X509_INVALID_NAME -0x2380 /*< The name tag or value is invalid. */
#define MBEDTLS_ERR_X509_INVALID_DATE -0x2400 /*< The date tag or value is invalid. */
#define MBEDTLS_ERR_X509_INVALID_SIGNATURE -0x2480 /*< The signature tag or value invalid. */
#define MBEDTLS_ERR_X509_INVALID_EXTENSIONS -0x2500 /*< The extension tag or value is invalid. */
#define MBEDTLS_ERR_X509_UNKNOWN_VERSION -0x2580 /*< CRT/CRL/CSR has an unsupported version number. */
#define MBEDTLS_ERR_X509_UNKNOWN_SIG_ALG -0x2600 /*< Signature algorithm (oid) is unsupported. */
#define MBEDTLS_ERR_X509_SIG_MISMATCH -0x2680 /*< Signature algorithms do not match. (see \c ::mbedtls_x509_crt sig_oid) */
#define MBEDTLS_ERR_X509_CERT_VERIFY_FAILED -0x2700 /*< Certificate verification failed, e.g. CRL, CA or signature check failed. */
#define MBEDTLS_ERR_X509_CERT_UNKNOWN_FORMAT -0x2780 /*< Format not recognized as DER or PEM. */
#define MBEDTLS_ERR_X509_BAD_INPUT_DATA -0x2800 /*< Input invalid. */
#define MBEDTLS_ERR_X509_ALLOC_FAILED -0x2880 /*< Allocation of memory failed. */
#define MBEDTLS_ERR_X509_FILE_IO_ERROR -0x2900 /*< Read/write of file failed. */
#define MBEDTLS_ERR_X509_BUFFER_TOO_SMALL -0x2980 /*< Destination buffer is too small. */
#define MBEDTLS_ERR_X509_FATAL_ERROR -0x3000 /*< A fatal error occurred, eg the chain is too long or the vrfy callback failed. */
/* Reminder: update x509_crt_verify_strings[] in library/x509_crt.c */
#define MBEDTLS_X509_BADCERT_EXPIRED 0x01 /*< The certificate validity has expired. */
#define MBEDTLS_X509_BADCERT_REVOKED 0x02 /*< The certificate has been revoked (is on a CRL). */
#define MBEDTLS_X509_BADCERT_CN_MISMATCH 0x04 /*< The certificate Common Name (CN) does not match with the expected CN. */
#define MBEDTLS_X509_BADCERT_NOT_TRUSTED 0x08 /*< The certificate is not correctly signed by the trusted CA. */
#define MBEDTLS_X509_BADCRL_NOT_TRUSTED 0x10 /*< The CRL is not correctly signed by the trusted CA. */
#define MBEDTLS_X509_BADCRL_EXPIRED 0x20 /*< The CRL is expired. */
#define MBEDTLS_X509_BADCERT_MISSING 0x40 /*< Certificate was missing. */
#define MBEDTLS_X509_BADCERT_SKIP_VERIFY 0x80 /*< Certificate verification was skipped. */
#define MBEDTLS_X509_BADCERT_OTHER 0x0100 /*< Other reason (can be used by verify callback) */
#define MBEDTLS_X509_BADCERT_FUTURE 0x0200 /*< The certificate validity starts in the future. */
#define MBEDTLS_X509_BADCRL_FUTURE 0x0400 /*< The CRL is from the future */
#define MBEDTLS_X509_BADCERT_KEY_USAGE 0x0800 /*< Usage does not match the keyUsage extension. */
#define MBEDTLS_X509_BADCERT_EXT_KEY_USAGE 0x1000 /*< Usage does not match the extendedKeyUsage extension. */
#define MBEDTLS_X509_BADCERT_NS_CERT_TYPE 0x2000 /*< Usage does not match the nsCertType extension. */
#define MBEDTLS_X509_BADCERT_BAD_MD 0x4000 /*< The certificate is signed with an unacceptable hash. */
#define MBEDTLS_X509_BADCERT_BAD_PK 0x8000 /*< The certificate is signed with an unacceptable PK alg (eg RSA vs ECDSA). */
#define MBEDTLS_X509_BADCERT_BAD_KEY 0x010000 /*< The certificate is signed with an unacceptable key (eg bad curve, RSA too short). */
#define MBEDTLS_X509_BADCRL_BAD_MD 0x020000 /*< The CRL is signed with an unacceptable hash. */
#define MBEDTLS_X509_BADCRL_BAD_PK 0x040000 /*< The CRL is signed with an unacceptable PK alg (eg RSA vs ECDSA). */
#define MBEDTLS_X509_BADCRL_BAD_KEY 0x080000 /*< The CRL is signed with an unacceptable key (eg bad curve, RSA too short). */
/*
* X.509 v3 Subject Alternative Name types.
* otherName [0] OtherName,
* rfc822Name [1] IA5String,
* dNSName [2] IA5String,
* x400Address [3] ORAddress,
* directoryName [4] Name,
* ediPartyName [5] EDIPartyName,
* uniformResourceIdentifier [6] IA5String,
* iPAddress [7] OCTET STRING,
* registeredID [8] OBJECT IDENTIFIER
*/
#define MBEDTLS_X509_SAN_OTHER_NAME 0
#define MBEDTLS_X509_SAN_RFC822_NAME 1
#define MBEDTLS_X509_SAN_DNS_NAME 2
#define MBEDTLS_X509_SAN_X400_ADDRESS_NAME 3
#define MBEDTLS_X509_SAN_DIRECTORY_NAME 4
#define MBEDTLS_X509_SAN_EDI_PARTY_NAME 5
#define MBEDTLS_X509_SAN_UNIFORM_RESOURCE_IDENTIFIER 6
#define MBEDTLS_X509_SAN_IP_ADDRESS 7
#define MBEDTLS_X509_SAN_REGISTERED_ID 8
/*
* X.509 v3 Key Usage Extension flags
* Reminder: update x509_info_key_usage() when adding new flags.
*/
#define MBEDTLS_X509_KU_DIGITAL_SIGNATURE (0x80) /* bit 0 */
#define MBEDTLS_X509_KU_NON_REPUDIATION (0x40) /* bit 1 */
#define MBEDTLS_X509_KU_KEY_ENCIPHERMENT (0x20) /* bit 2 */
#define MBEDTLS_X509_KU_DATA_ENCIPHERMENT (0x10) /* bit 3 */
#define MBEDTLS_X509_KU_KEY_AGREEMENT (0x08) /* bit 4 */
#define MBEDTLS_X509_KU_KEY_CERT_SIGN (0x04) /* bit 5 */
#define MBEDTLS_X509_KU_CRL_SIGN (0x02) /* bit 6 */
#define MBEDTLS_X509_KU_ENCIPHER_ONLY (0x01) /* bit 7 */
#define MBEDTLS_X509_KU_DECIPHER_ONLY (0x8000) /* bit 8 */
/*
* Netscape certificate types
* (http://www.mozilla.org/projects/security/pki/nss/tech-notes/tn3.html)
*/
#define MBEDTLS_X509_NS_CERT_TYPE_SSL_CLIENT (0x80) /* bit 0 */
#define MBEDTLS_X509_NS_CERT_TYPE_SSL_SERVER (0x40) /* bit 1 */
#define MBEDTLS_X509_NS_CERT_TYPE_EMAIL (0x20) /* bit 2 */
#define MBEDTLS_X509_NS_CERT_TYPE_OBJECT_SIGNING (0x10) /* bit 3 */
#define MBEDTLS_X509_NS_CERT_TYPE_RESERVED (0x08) /* bit 4 */
#define MBEDTLS_X509_NS_CERT_TYPE_SSL_CA (0x04) /* bit 5 */
#define MBEDTLS_X509_NS_CERT_TYPE_EMAIL_CA (0x02) /* bit 6 */
#define MBEDTLS_X509_NS_CERT_TYPE_OBJECT_SIGNING_CA (0x01) /* bit 7 */
/*
* X.509 extension types
*
* Comments refer to the status for using certificates. Status can be
* different for writing certificates or reading CRLs or CSRs.
*
* Those are defined in oid.h as oid.c needs them in a data structure. Since
* these were previously defined here, let's have aliases for compatibility.
*/
#define MBEDTLS_X509_EXT_AUTHORITY_KEY_IDENTIFIER MBEDTLS_OID_X509_EXT_AUTHORITY_KEY_IDENTIFIER
#define MBEDTLS_X509_EXT_SUBJECT_KEY_IDENTIFIER MBEDTLS_OID_X509_EXT_SUBJECT_KEY_IDENTIFIER
#define MBEDTLS_X509_EXT_KEY_USAGE MBEDTLS_OID_X509_EXT_KEY_USAGE
#define MBEDTLS_X509_EXT_CERTIFICATE_POLICIES MBEDTLS_OID_X509_EXT_CERTIFICATE_POLICIES
#define MBEDTLS_X509_EXT_POLICY_MAPPINGS MBEDTLS_OID_X509_EXT_POLICY_MAPPINGS
#define MBEDTLS_X509_EXT_SUBJECT_ALT_NAME MBEDTLS_OID_X509_EXT_SUBJECT_ALT_NAME /* Supported (DNS) */
#define MBEDTLS_X509_EXT_ISSUER_ALT_NAME MBEDTLS_OID_X509_EXT_ISSUER_ALT_NAME
#define MBEDTLS_X509_EXT_SUBJECT_DIRECTORY_ATTRS MBEDTLS_OID_X509_EXT_SUBJECT_DIRECTORY_ATTRS
#define MBEDTLS_X509_EXT_BASIC_CONSTRAINTS MBEDTLS_OID_X509_EXT_BASIC_CONSTRAINTS /* Supported */
#define MBEDTLS_X509_EXT_NAME_CONSTRAINTS MBEDTLS_OID_X509_EXT_NAME_CONSTRAINTS
#define MBEDTLS_X509_EXT_POLICY_CONSTRAINTS MBEDTLS_OID_X509_EXT_POLICY_CONSTRAINTS
#define MBEDTLS_X509_EXT_EXTENDED_KEY_USAGE MBEDTLS_OID_X509_EXT_EXTENDED_KEY_USAGE
#define MBEDTLS_X509_EXT_CRL_DISTRIBUTION_POINTS MBEDTLS_OID_X509_EXT_CRL_DISTRIBUTION_POINTS
#define MBEDTLS_X509_EXT_INIHIBIT_ANYPOLICY MBEDTLS_OID_X509_EXT_INIHIBIT_ANYPOLICY
#define MBEDTLS_X509_EXT_FRESHEST_CRL MBEDTLS_OID_X509_EXT_FRESHEST_CRL
#define MBEDTLS_X509_EXT_NS_CERT_TYPE MBEDTLS_OID_X509_EXT_NS_CERT_TYPE
/*
* Storage format identifiers
* Recognized formats: PEM and DER
*/
#define MBEDTLS_X509_FORMAT_DER 1
#define MBEDTLS_X509_FORMAT_PEM 2
#define MBEDTLS_X509_MAX_DN_NAME_SIZE 256 /*< Maximum value size of a DN entry */
/**
* Type-length-value structure that allows for ASN1 using DER.
*/
typedef mbedtls_asn1_buf mbedtls_x509_buf;
/**
* Container for ASN1 bit strings.
*/
typedef mbedtls_asn1_bitstring mbedtls_x509_bitstring;
/**
* Container for ASN1 named information objects.
* It allows for Relative Distinguished Names (e.g. cn=localhost,ou=code,etc.).
*/
typedef mbedtls_asn1_named_data mbedtls_x509_name;
/**
* Container for a sequence of ASN.1 items
*/
typedef mbedtls_asn1_sequence mbedtls_x509_sequence;
/** Container for date and time (precision in seconds). */
typedef struct mbedtls_x509_time
{
int year, mon, day; /*< Date. */
int hour, min, sec; /*< Time. */
}
mbedtls_x509_time;
int mbedtls_x509_dn_gets( char *, size_t, const mbedtls_x509_name * );
int mbedtls_x509_get_alg( unsigned char **, const unsigned char *, mbedtls_x509_buf *, mbedtls_x509_buf * );
int mbedtls_x509_get_alg_null( unsigned char **, const unsigned char *, mbedtls_x509_buf * );
int mbedtls_x509_get_ext( unsigned char **, const unsigned char *, mbedtls_x509_buf *, int );
int mbedtls_x509_get_name( unsigned char **, const unsigned char *, mbedtls_x509_name * );
int mbedtls_x509_get_serial( unsigned char **, const unsigned char *, mbedtls_x509_buf * );
int mbedtls_x509_get_sig( unsigned char **, const unsigned char *, mbedtls_x509_buf * );
int mbedtls_x509_get_sig_alg( const mbedtls_x509_buf *, const mbedtls_x509_buf *, mbedtls_md_type_t *, mbedtls_pk_type_t *, void ** );
int mbedtls_x509_get_time( unsigned char **, const unsigned char *, mbedtls_x509_time * );
int mbedtls_x509_key_size_helper( char *, size_t, const char * );
int mbedtls_x509_self_test( int );
int mbedtls_x509_serial_gets( char *, size_t, const mbedtls_x509_buf * );
int mbedtls_x509_set_extension( mbedtls_asn1_named_data **, const char *, size_t, int, const unsigned char *, size_t );
int mbedtls_x509_sig_alg_gets( char *, size_t, const mbedtls_x509_buf *, mbedtls_pk_type_t, mbedtls_md_type_t, const void * );
int mbedtls_x509_string_to_names( mbedtls_asn1_named_data **, const char * );
int mbedtls_x509_time_is_future( const mbedtls_x509_time * );
int mbedtls_x509_time_is_past( const mbedtls_x509_time * );
int mbedtls_x509_write_extensions( unsigned char **, unsigned char *, mbedtls_asn1_named_data * );
int mbedtls_x509_write_names( unsigned char **, unsigned char *, mbedtls_asn1_named_data * );
int mbedtls_x509_write_sig( unsigned char **, unsigned char *, const char *, size_t, unsigned char *, size_t );
#define MBEDTLS_X509_SAFE_SNPRINTF \
do { \
if( ret < 0 || (size_t) ret >= n ) \
return( MBEDTLS_ERR_X509_BUFFER_TOO_SMALL ); \
n -= (size_t) ret; \
p += (size_t) ret; \
} while( 0 )
COSMOPOLITAN_C_END_
#endif /* MBEDTLS_X509_H_ */
| 12,519 | 198 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/bigmul.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:4;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright The Mbed TLS Contributors â
â â
â Licensed under the Apache License, Version 2.0 (the "License"); â
â you may not use this file except in compliance with the License. â
â You may obtain a copy of the License at â
â â
â http://www.apache.org/licenses/LICENSE-2.0 â
â â
â Unless required by applicable law or agreed to in writing, software â
â distributed under the License is distributed on an "AS IS" BASIS, â
â WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. â
â See the License for the specific language governing permissions and â
â limitations under the License. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/intrin/bits.h"
#include "libc/log/backtrace.internal.h"
#include "libc/log/check.h"
#include "libc/macros.internal.h"
#include "libc/mem/mem.h"
#include "libc/nexgen32e/x86feature.h"
#include "third_party/mbedtls/bignum.h"
#include "third_party/mbedtls/bignum_internal.h"
#include "third_party/mbedtls/profile.h"
/* clang-format off */
void Mul(uint64_t *c, uint64_t *A, unsigned n, uint64_t *B, unsigned m)
{
if (!m--) return;
mbedtls_platform_zeroize(c, m * ciL);
mbedtls_mpi_mul_hlp1(n, A, c + m, B[m]);
for (; m > 0; m--)
mbedtls_mpi_mul_hlp(n, A, c + m - 1, B[m - 1]);
}
/**
* Computes inner loop of multiplication algorithm.
*/
void mbedtls_mpi_mul_hlp1(size_t n, const uint64_t *s, uint64_t *d, uint64_t b)
{
size_t i;
uint128_t x;
uint64_t c, t, t1, t2;
i = c = 0;
#if defined(__x86_64__) && !defined(__STRICT_ANSI__)
if( X86_HAVE(BMI2) )
{
for( ; i + 8 <= n; i += 8 )
{
asm volatile("mulx\t(%2),%%rax,%%rbx\n\t"
"add\t%0,%%rax\n\t"
"mov\t%%rax,(%1)\n\t"
"mulx\t8(%2),%%rax,%0\n\t"
"adc\t%%rbx,%%rax\n\t"
"mov\t%%rax,8(%1)\n\t"
"mulx\t16(%2),%%rax,%%rbx\n\t"
"adc\t%0,%%rax\n\t"
"mov\t%%rax,16(%1)\n\t"
"mulx\t24(%2),%%rax,%0\n\t"
"adc\t%%rbx,%%rax\n\t"
"mov\t%%rax,24(%1)\n\t"
"mulx\t32(%2),%%rax,%%rbx\n\t"
"adc\t%0,%%rax\n\t"
"mov\t%%rax,32(%1)\n\t"
"mulx\t40(%2),%%rax,%0\n\t"
"adc\t%%rbx,%%rax\n\t"
"mov\t%%rax,40(%1)\n\t"
"mulx\t48(%2),%%rax,%%rbx\n\t"
"adc\t%0,%%rax\n\t"
"mov\t%%rax,48(%1)\n\t"
"mulx\t56(%2),%%rax,%0\n\t"
"adc\t%%rbx,%%rax\n\t"
"mov\t%%rax,56(%1)\n\t"
"adc\t$0,%0"
: "+r"(c)
: "r"(d + i), "r"(s + i), "d"(b)
: "rax", "rbx", "memory", "cc");
}
for( ; i + 4 <= n; i += 4 )
{
asm volatile("mulx\t(%2),%%rax,%%rbx\n\t"
"add\t%0,%%rax\n\t"
"mov\t%%rax,(%1)\n\t"
"mulx\t8(%2),%%rax,%0\n\t"
"adc\t%%rbx,%%rax\n\t"
"mov\t%%rax,8(%1)\n\t"
"mulx\t16(%2),%%rax,%%rbx\n\t"
"adc\t%0,%%rax\n\t"
"mov\t%%rax,16(%1)\n\t"
"mulx\t24(%2),%%rax,%0\n\t"
"adc\t%%rbx,%%rax\n\t"
"mov\t%%rax,24(%1)\n\t"
"adc\t$0,%0"
: "+r"(c)
: "r"(d + i), "r"(s + i), "d"(b)
: "rax", "rbx", "memory", "cc");
}
}
#endif
for( ; i < n; ++i )
{
x = s[i];
x *= b;
x += c;
c = x >> 64;
d[i] = x;
}
d[i] = c;
}
/**
* Computes inner loop of multiplication algorithm.
*/
void mbedtls_mpi_mul_hlp(size_t n, uint64_t *s, uint64_t *d, uint64_t b)
{
size_t i;
uint128_t x;
uint64_t c, l, h, t;
i = c = 0;
#if defined(__x86_64__) && !defined(__STRICT_ANSI__)
if (X86_HAVE(BMI2) && X86_HAVE(ADX))
{
for( ; i + 8 <= n; i += 8 )
{
asm volatile("xor\t%%r8d,%%r8d\n\t"
"mulx\t(%2),%%rax,%%rbx\n\t"
"adcx\t(%1),%%rax\n\t"
"adox\t%0,%%rax\n\t"
"mov\t%%rax,(%1)\n\t"
"mulx\t8(%2),%%rax,%0\n\t"
"adcx\t8(%1),%%rax\n\t"
"adox\t%%rbx,%%rax\n\t"
"mov\t%%rax,8(%1)\n\t"
"mulx\t16(%2),%%rax,%%rbx\n\t"
"adcx\t16(%1),%%rax\n\t"
"adox\t%0,%%rax\n\t"
"mov\t%%rax,16(%1)\n\t"
"mulx\t24(%2),%%rax,%0\n\t"
"adcx\t24(%1),%%rax\n\t"
"adox\t%%rbx,%%rax\n\t"
"mov\t%%rax,24(%1)\n\t"
"mulx\t32(%2),%%rax,%%rbx\n\t"
"adcx\t32(%1),%%rax\n\t"
"adox\t%0,%%rax\n\t"
"mov\t%%rax,32(%1)\n\t"
"mulx\t40(%2),%%rax,%0\n\t"
"adcx\t40(%1),%%rax\n\t"
"adox\t%%rbx,%%rax\n\t"
"mov\t%%rax,40(%1)\n\t"
"mulx\t48(%2),%%rax,%%rbx\n\t"
"adcx\t48(%1),%%rax\n\t"
"adox\t%0,%%rax\n\t"
"mov\t%%rax,48(%1)\n\t"
"mulx\t56(%2),%%rax,%0\n\t"
"adcx\t56(%1),%%rax\n\t"
"adox\t%%rbx,%%rax\n\t"
"mov\t%%rax,56(%1)\n\t"
"adcx\t%%r8,%0\n\t"
"adox\t%%r8,%0"
: "+r"(c)
: "r"(d + i), "r"(s + i), "d"(b)
: "rax", "rbx", "r8", "memory", "cc");
}
for( ; i + 4 <= n; i += 4 )
{
asm volatile("xor\t%%r8d,%%r8d\n\t"
"mulx\t(%2),%%rax,%%rbx\n\t"
"adcx\t(%1),%%rax\n\t"
"adox\t%0,%%rax\n\t"
"mov\t%%rax,(%1)\n\t"
"mulx\t8(%2),%%rax,%0\n\t"
"adcx\t8(%1),%%rax\n\t"
"adox\t%%rbx,%%rax\n\t"
"mov\t%%rax,8(%1)\n\t"
"mulx\t16(%2),%%rax,%%rbx\n\t"
"adcx\t16(%1),%%rax\n\t"
"adox\t%0,%%rax\n\t"
"mov\t%%rax,16(%1)\n\t"
"mulx\t24(%2),%%rax,%0\n\t"
"adcx\t24(%1),%%rax\n\t"
"adox\t%%rbx,%%rax\n\t"
"mov\t%%rax,24(%1)\n\t"
"adcx\t%%r8,%0\n\t"
"adox\t%%r8,%0"
: "+r"(c)
: "r"(d + i), "r"(s + i), "d"(b)
: "rax", "rbx", "r8", "memory", "cc");
}
}
#endif
for( ; i < n; ++i )
{
x = s[i];
x *= b;
x += c;
l = x;
h = x >> 64;
t = d[i];
d[i] = t + l;
c = (t + l < t) + h;
}
do
{
d[i] += c;
} while ((c = d[i++] < c));
}
/**
* Multiplies big number with unsigned scalar: X = A Ã b
*
* @param X receives result w/ aliasing permitted
* @param A is left-hand side big number
* @param B is left-hand side unsigned scalar
* @return 0 on success or negative on error
*/
int mbedtls_mpi_mul_int(mbedtls_mpi *X, const mbedtls_mpi *A,
mbedtls_mpi_uint b)
{
int r;
size_t n;
MPI_VALIDATE_RET(X);
MPI_VALIDATE_RET(A);
n = mbedtls_mpi_limbs(A);
if ((r = mbedtls_mpi_grow(X, n + 1))) return r;
mbedtls_mpi_mul_hlp1(n, A->p, X->p, b);
X->s = A->s;
X->n = n + 1;
return 0;
}
/**
* Multiplies big numbers: X = A * B
*
* @param X is destination mpi
* @param A is first factor
* @param B is second factor
* @return 0 on success or <0 on error
*/
int mbedtls_mpi_mul_mpi(mbedtls_mpi *X, const mbedtls_mpi *A,
const mbedtls_mpi *B)
{
int i, j, t, k, ret;
mbedtls_mpi_uint *K;
mbedtls_mpi TA, TB, *T;
MPI_VALIDATE_RET(X);
MPI_VALIDATE_RET(A);
MPI_VALIDATE_RET(B);
i = mbedtls_mpi_limbs(A);
j = mbedtls_mpi_limbs(B);
if (!i || !j)
return mbedtls_mpi_lset(X, 0);
if( j > i )
T = A,
A = B,
B = T,
t = i,
i = j,
j = t;
if (!IsTiny() && j == 1) {
if (X->n < i + 1) {
if ((ret = mbedtls_mpi_grow(X, i + 1))) return ret;
} else if (X->n > i + 1) {
mbedtls_platform_zeroize(X->p + i + 1, (X->n - (i + 1)) * ciL);
}
mbedtls_mpi_mul_hlp1(i, A->p, X->p, B->p[0]);
X->s = A->s * B->s;
return 0;
}
#ifdef __x86_64__
if (!IsTiny() && i == j) {
if (X->n < i * 2) {
if ((ret = mbedtls_mpi_grow(X, i * 2))) return ret;
} else if (X->n > i * 2) {
mbedtls_platform_zeroize(X->p + i * 2, (X->n - (i * 2)) * ciL);
}
if (i == 4) {
Mul4x4(X->p, A->p, B->p);
X->s = A->s * B->s;
return 0;
} else if (i == 6 && X86_HAVE(BMI2) && X86_HAVE(ADX)) {
Mul6x6Adx(X->p, A->p, B->p);
X->s = A->s * B->s;
return 0;
} else if (i == 8 && X86_HAVE(BMI2) && X86_HAVE(ADX)) {
Mul8x8Adx(X->p, A->p, B->p);
X->s = A->s * B->s;
return 0;
}
}
#endif /* __x86_64__ */
mbedtls_mpi_init( &TA );
mbedtls_mpi_init( &TB );
if (X->n < i + j)
MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, i + j ) );
else if (X->n > i + j)
mbedtls_platform_zeroize( X->p + i + j, (X->n - (i + j)) * ciL );
if (X == A) {
MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TA, A ) );
A = &TA;
}
if (X == B) {
MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TB, B ) );
B = &TB;
}
if (!IsTiny() &&
i >= 16 && i == j && !(i & (i - 1)) &&
(K = malloc(i * 4 * sizeof(*K)))) {
Karatsuba(X->p, A->p, B->p, i, K);
free(K);
} else {
Mul(X->p, A->p, i, B->p, j);
}
X->s = A->s * B->s;
ret = 0;
cleanup:
mbedtls_mpi_free(&TB);
mbedtls_mpi_free(&TA);
return ret;
}
| 11,910 | 330 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/secp384r1.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2021 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/log/check.h"
#include "third_party/mbedtls/bignum.h"
#include "third_party/mbedtls/ecp_internal.h"
#include "third_party/mbedtls/math.h"
#define Q(i) p[i >> 1]
/**
* Fastest quasi-reduction modulo â384.
*
* p = 2³â¸â´ â 2¹²⸠â 2ⶠ+ 2³² â 1
* B = T + 2ÃSâ + Sâ + Sâ + Sâ + Sâ
+ Sâ â Dâ â Dâ â Dâ mod p
* T = (AâââAâââAâ âAâ âAâ âAâ âAâ
âAâ âAâ âAâ âAâ âAâ )
* Sâ = (0 â0 â0 â0 â0 âAâââAâââAâââ0 â0 â0 â0 )
* Sâ = (AâââAâââAâââAâââAâââAâââAâââAâââAââ
âAâââAâââAââ)
* Sâ = (AâââAâââAâââAâââAâââAââ
âAâââAâââAâââAâââAâââAââ)
* Sâ = (AâââAâââAâââAâââAââ
âAâââAâââAâââAâââ0 âAâââ0 )
* Sâ
= (0 â0 â0 â0 âAâââAâââAâââAâââ0 â0 â0 â0 )
* Sâ = (0 â0 â0 â0 â0 â0 âAâââAâââAâââ0 â0 âAââ)
* Dâ = (AâââAâââAâââAâââAâââAâââAâââAââ
âAâââAâââAâââAââ)
* Dâ = (0 â0 â0 â0 â0 â0 â0 âAâââAâââAâââAâââ0 )
* Dâ = (0 â0 â0 â0 â0 â0 â0 âAâââAâââ0 â0 â0 )
*
* @see FIPS 186-3 §D.2.4
*/
void secp384r1(uint64_t p[12]) {
uint64_t A, B, C, D, E, F, G, a, b, o;
A = Q(0);
B = Q(2);
C = Q(4);
D = Q(6);
E = Q(8);
F = Q(10);
G = 0;
#if !defined(__x86_64__) || defined(__STRICT_ANSI__)
a = Q(22) << 32 | Q(21) >> 32;
b = Q(23) >> 32;
ADC(C, C, a << 1, 0, o);
ADC(D, D, b << 1 | a >> 63, o, o);
ADC(E, E, b >> 63, o, o);
ADC(F, F, 0, o, o);
G += o;
ADC(A, A, Q(12), 0, o);
ADC(B, B, Q(14), o, o);
ADC(C, C, Q(16), o, o);
ADC(D, D, Q(18), o, o);
ADC(E, E, Q(20), o, o);
ADC(F, F, Q(22), o, o);
G += o;
ADC(A, A, Q(22) << 32 | Q(21) >> 32, 0, o);
ADC(B, B, Q(12) << 32 | Q(23) >> 32, o, o);
ADC(C, C, Q(14) << 32 | Q(13) >> 32, o, o);
ADC(D, D, Q(16) << 32 | Q(15) >> 32, o, o);
ADC(E, E, Q(18) << 32 | Q(17) >> 32, o, o);
ADC(F, F, Q(20) << 32 | Q(19) >> 32, o, o);
G += o;
ADC(A, A, Q(23) >> 32 << 32, 0, o);
ADC(B, B, Q(20) << 32, o, o);
ADC(C, C, Q(12), o, o);
ADC(D, D, Q(14), o, o);
ADC(E, E, Q(16), o, o);
ADC(F, F, Q(18), o, o);
G += o;
ADC(C, C, Q(20), 0, o);
ADC(D, D, Q(22), o, o);
ADC(E, E, 0, o, o);
ADC(F, F, 0, o, o);
G += o;
ADC(A, A, Q(20) & 0xffffffff, 0, o);
ADC(B, B, Q(21) >> 32 << 32, o, o);
ADC(C, C, Q(22), o, o);
ADC(D, D, 0, o, o);
ADC(E, E, 0, o, o);
ADC(F, F, 0, o, o);
G += o;
SBB(A, A, Q(12) << 32 | Q(23) >> 32, 0, o);
SBB(B, B, Q(14) << 32 | Q(13) >> 32, o, o);
SBB(C, C, Q(16) << 32 | Q(15) >> 32, o, o);
SBB(D, D, Q(18) << 32 | Q(17) >> 32, o, o);
SBB(E, E, Q(20) << 32 | Q(19) >> 32, o, o);
SBB(F, F, Q(22) << 32 | Q(21) >> 32, o, o);
G -= o;
SBB(A, A, Q(20) << 32, 0, o);
SBB(B, B, Q(22) << 32 | Q(21) >> 32, o, o);
SBB(C, C, Q(23) >> 32, o, o);
SBB(D, D, 0, o, o);
SBB(E, E, 0, o, o);
SBB(F, F, 0, o, o);
G -= o;
SBB(B, B, Q(23) >> 32 << 32, 0, o);
SBB(C, C, Q(23) >> 32, o, o);
SBB(D, D, 0, o, o);
SBB(E, E, 0, o, o);
SBB(F, F, 0, o, o);
G -= o;
#else
asm volatile(/* Sâ = (0 â0 â0 â0 â0 âAâââAâââAâââ0 â0 â0 â0 ) */
"mov\t21*4(%9),%7\n\t"
"mov\t23*4(%9),%k8\n\t"
"mov\t%7,%%r12\n\t"
"shr\t$63,%%r12\n\t"
"shl\t%7\n\t"
"shl\t%8\n\t"
"or\t%%r12,%8\n\t"
"mov\t13*4(%9),%%r12\n\t"
"add\t%7,%2\n\t"
"mov\t23*4(%9),%k7\n\t"
"adc\t%8,%3\n\t"
"mov\t15*4(%9),%%r13\n\t"
"adc\t$0,%4\n\t"
"mov\t12*4(%9),%k8\n\t"
"adc\t$0,%5\n\t"
"mov\t17*4(%9),%%r14\n\t"
"adc\t$0,%6\n\t"
"mov\t19*4(%9),%%r15\n\t"
/* Dâ = (AâââAâââAâââAâââAâââAâââAâââAââ
âAâââAâââAâââAââ) */
"shl\t$32,%8\n\t"
"or\t%8,%7\n\t"
"mov\t23*4(%9),%k8\n\t"
"sub\t%7,%0\n\t"
"mov\t21*4(%9),%7\n\t"
"sbb\t%%r12,%1\n\t"
"sbb\t%%r13,%2\n\t"
"sbb\t%%r14,%3\n\t"
"sbb\t%%r15,%4\n\t"
"sbb\t%7,%5\n\t"
"mov\t12*4(%9),%k7\n\t"
"sbb\t$0,%6\n\t"
/* Sâ = (AâââAâââAâââAâââAâââAââ
âAâââAâââAâââAâââAâââAââ) */
"shl\t$32,%7\n\t"
"or\t%7,%8\n\t"
"add\t21*4(%9),%0\n\t"
"mov\t23*4(%9),%k7\n\t"
"adc\t%8,%1\n\t"
"mov\t20*4(%9),%k8\n\t"
"adc\t%%r12,%2\n\t"
"mov\t12*4(%9),%%r12\n\t"
"adc\t%%r13,%3\n\t"
"mov\t14*4(%9),%%r13\n\t"
"adc\t%%r14,%4\n\t"
"mov\t16*4(%9),%%r14\n\t"
"adc\t%%r15,%5\n\t"
"mov\t18*4(%9),%%r15\n\t"
"adc\t$0,%6\n\t"
/* Sâ = (AâââAâââAâââAâââAââ
âAâââAâââAâââAâââ0 âAâââ0 ) */
"shl\t$32,%7\n\t"
"shl\t$32,%8\n\t"
"add\t%7,%0\n\t"
"adc\t%8,%1\n\t"
"adc\t%%r12,%2\n\t"
"adc\t%%r13,%3\n\t"
"adc\t%%r14,%4\n\t"
"adc\t%%r15,%5\n\t"
"adc\t$0,%6\n\t"
/* Sâ = (AâââAâââAâââAâââAâââAâââAâââAâââAââ
âAâââAâââAââ) */
"add\t%%r12,%0\n\t"
"mov\t20*4(%9),%%r12\n\t"
"adc\t%%r13,%1\n\t"
"mov\t22*4(%9),%%r13\n\t"
"adc\t%%r14,%2\n\t"
"adc\t%%r15,%3\n\t"
"adc\t%%r12,%4\n\t"
"adc\t%%r13,%5\n\t"
"adc\t$0,%6\n\t"
/* Sâ
= (0 â0 â0 â0 âAâââAâââAâââAâââ0 â0 â0 â0 ) */
"add\t%%r12,%2\n\t"
"adc\t%%r13,%3\n\t"
"adc\t$0,%4\n\t"
"adc\t$0,%5\n\t"
"adc\t$0,%6\n\t"
/* Sâ = (0 â0 â0 â0 â0 â0 âAâââAâââAâââ0 â0 âAââ) */
"mov\t%%r12d,%k7\n\t"
"mov\t%%r12,%8\n\t"
"shr\t$32,%8\n\t"
"shl\t$32,%8\n\t"
"add\t%7,%0\n\t"
"adc\t%8,%1\n\t"
"adc\t%%r13,%2\n\t"
"adc\t$0,%3\n\t"
"adc\t$0,%4\n\t"
"adc\t$0,%5\n\t"
"adc\t$0,%6\n\t"
/* Dâ = (0 â0 â0 â0 â0 â0 â0 âAâââAâââAâââAâââ0 ) */
"mov\t%%r12d,%k7\n\t"
"mov\t21*4(%9),%%r12\n\t"
"mov\t%%r13,%8\n\t"
"shr\t$32,%8\n\t"
"shl\t$32,%7\n\t"
"sub\t%7,%0\n\t"
"sbb\t%%r12,%1\n\t"
"sbb\t%8,%2\n\t"
"sbb\t$0,%3\n\t"
"sbb\t$0,%4\n\t"
"sbb\t$0,%5\n\t"
"sbb\t$0,%6\n\t"
/* Dâ = (0 â0 â0 â0 â0 â0 â0 âAâââAâââ0 â0 â0 ) */
"mov\t%%r13,%7\n\t"
"shr\t$32,%7\n\t"
"mov\t%k7,%k8\n\t"
"shl\t$32,%7\n\t"
"sub\t%7,%1\n\t"
"sbb\t%8,%2\n\t"
"sbb\t$0,%3\n\t"
"sbb\t$0,%4\n\t"
"sbb\t$0,%5\n\t"
"sbb\t$0,%6"
: "+r"(A), "+r"(B), "+r"(C), "+r"(D), "+r"(E), "+r"(F), "+q"(G),
"=&r"(a), "=&r"(b)
: "r"(p)
: "memory", "r12", "r13", "r14", "r15");
#endif
p[0] = A;
p[1] = B;
p[2] = C;
p[3] = D;
p[4] = E;
p[5] = F;
p[6] = G;
G = CONCEAL("r", 0L);
p[7] = G;
p[8] = G;
p[9] = G;
p[10] = G;
p[11] = G;
}
int ecp_mod_p384(mbedtls_mpi *N) {
int r;
char o;
if (N->n < 12 && (r = mbedtls_mpi_grow(N, 12))) return r;
secp384r1(N->p);
if ((int64_t)N->p[6] < 0) {
N->s = -1;
SBB(N->p[0], 0, N->p[0], 0, o);
SBB(N->p[1], 0, N->p[1], o, o);
SBB(N->p[2], 0, N->p[2], o, o);
SBB(N->p[3], 0, N->p[3], o, o);
SBB(N->p[4], 0, N->p[4], o, o);
SBB(N->p[5], 0, N->p[5], o, o);
N->p[6] = 0 - (N->p[6] + o);
} else {
N->s = 1;
}
return 0;
}
/*
Instructions: 115
Total Cycles: 46
Total uOps: 116
uOps Per Cycle: 2.52
IPC: 2.50
Block RThroughput: 31.0
SIMULATION 0123456789 0123456789
Index 0123456789 0123456789 012345
[0,0] DR . . . . . . . . . xorl %r10d, %r10d
[0,1] DeeeeeER . . . . . . . . movq (%rdi), %r9
[0,2] DeeeeeER . . . . . . . . movq 8(%rdi), %r8
[0,3] D=eeeeeER . . . . . . . . movq 16(%rdi), %rsi
[0,4] D=eeeeeER . . . . . . . . movq 24(%rdi), %rcx
[0,5] D==eeeeeER. . . . . . . . movq 32(%rdi), %rdx
[0,6] .D==eeeeeER . . . . . . . movq 40(%rdi), %rax
[0,7] .D=eeeeeE-R . . . . . . . movq 84(%rdi), %r11
[0,8] .D==eeeeeER . . . . . . . movl 92(%rdi), %ebx
[0,9] .D======eER . . . . . . . movq %r11, %r12
[0,10] .D=======eER . . . . . . . shrq $63, %r12
[0,11] .D======eE-R . . . . . . . shlq %r11
[0,12] . D======eER . . . . . . . shlq %rbx
[0,13] . D=======eER . . . . . . . orq %r12, %rbx
[0,14] . D==eeeeeE-R . . . . . . . movq 52(%rdi), %r12
[0,15] . D======eE-R . . . . . . . addq %r11, %rsi
[0,16] . D==eeeeeE-R . . . . . . . movl 92(%rdi), %r11d
[0,17] . D========eER . . . . . . . adcq %rbx, %rcx
[0,18] . D==eeeeeE-R . . . . . . . movq 60(%rdi), %r13
[0,19] . D========eER. . . . . . . adcq $0, %rdx
[0,20] . D==eeeeeE--R. . . . . . . movl 48(%rdi), %ebx
[0,21] . D=========eER . . . . . . adcq $0, %rax
[0,22] . D===eeeeeE--R . . . . . . movq 68(%rdi), %r14
[0,23] . D==========eER . . . . . . adcq $0, %r10
[0,24] . D==eeeeeE---R . . . . . . movq 76(%rdi), %r15
[0,25] . D======eE---R . . . . . . shlq $32, %rbx
[0,26] . D=======eE--R . . . . . . orq %rbx, %r11
[0,27] . D===eeeeeE--R . . . . . . movl 92(%rdi), %ebx
[0,28] . D========eE-R . . . . . . subq %r11, %r9
[0,29] . D===eeeeeE--R . . . . . . movq 84(%rdi), %r11
[0,30] . D========eER . . . . . . sbbq %r12, %r8
[0,31] . D=========eER . . . . . . sbbq %r13, %rsi
[0,32] . D==========eER . . . . . . sbbq %r14, %rcx
[0,33] . D===========eER. . . . . . sbbq %r15, %rdx
[0,34] . D============eER . . . . . sbbq %r11, %rax
[0,35] . D===eeeeeE-----R . . . . . movl 48(%rdi), %r11d
[0,36] . .D============eER . . . . . sbbq $0, %r10
[0,37] . .D========eE----R . . . . . shlq $32, %r11
[0,38] . .D=========eE---R . . . . . orq %r11, %rbx
[0,39] . .D==eeeeeE------R . . . . . movl 92(%rdi), %r11d
[0,40] . .D======eeeeeeE-R . . . . . addq 84(%rdi), %r9
[0,41] . . D===========eER . . . . . adcq %rbx, %r8
[0,42] . . D==eeeeeE-----R . . . . . movl 80(%rdi), %ebx
[0,43] . . D============eER . . . . . adcq %r12, %rsi
[0,44] . . D==eeeeeE------R . . . . . movq 48(%rdi), %r12
[0,45] . . D=============eER . . . . . adcq %r13, %rcx
[0,46] . . D===eeeeeE------R . . . . . movq 56(%rdi), %r13
[0,47] . . D=============eER. . . . . adcq %r14, %rdx
[0,48] . . D==eeeeeE-------R. . . . . movq 64(%rdi), %r14
[0,49] . . D==============eER . . . . adcq %r15, %rax
[0,50] . . D===eeeeeE-------R . . . . movq 72(%rdi), %r15
[0,51] . . D===============eER . . . . adcq $0, %r10
[0,52] . . D=======eE--------R . . . . shlq $32, %r11
[0,53] . . D=======eE-------R . . . . shlq $32, %rbx
[0,54] . . D=========eE-----R . . . . addq %r11, %r9
[0,55] . . D==========eE----R . . . . adcq %rbx, %r8
[0,56] . . D===========eE---R . . . . adcq %r12, %rsi
[0,57] . . D============eE--R . . . . adcq %r13, %rcx
[0,58] . . D=============eE-R . . . . adcq %r14, %rdx
[0,59] . . D=============eER . . . . adcq %r15, %rax
[0,60] . . D==============eER . . . . adcq $0, %r10
[0,61] . . D=========eE-----R . . . . addq %r12, %r9
[0,62] . . D=eeeeeE---------R . . . . movq 80(%rdi), %r12
[0,63] . . D==============eER . . . . adcq %r13, %r8
[0,64] . . D==eeeeeE--------R . . . . movq 88(%rdi), %r13
[0,65] . . .D==============eER . . . . adcq %r14, %rsi
[0,66] . . .D===============eER. . . . adcq %r15, %rcx
[0,67] . . .D================eER . . . adcq %r12, %rdx
[0,68] . . .D=================eER . . . adcq %r13, %rax
[0,69] . . .D==================eER . . . adcq $0, %r10
[0,70] . . .D===============eE---R . . . addq %r12, %rsi
[0,71] . . . D===============eE--R . . . adcq %r13, %rcx
[0,72] . . . D================eE-R . . . adcq $0, %rdx
[0,73] . . . D=================eER . . . adcq $0, %rax
[0,74] . . . D==================eER . . . adcq $0, %r10
[0,75] . . . D====eE--------------R . . . movl %r12d, %r11d
[0,76] . . . D====eE--------------R . . . movq %r12, %rbx
[0,77] . . . D====eE-------------R . . . shrq $32, %rbx
[0,78] . . . D============eE-----R . . . shlq $32, %rbx
[0,79] . . . D=======eE----------R . . . addq %r11, %r9
[0,80] . . . D=============eE----R . . . adcq %rbx, %r8
[0,81] . . . D=================eER . . . adcq %r13, %rsi
[0,82] . . . D==================eER. . . adcq $0, %rcx
[0,83] . . . D==================eER . . adcq $0, %rdx
[0,84] . . . D===================eER . . adcq $0, %rax
[0,85] . . . D====================eER . . adcq $0, %r10
[0,86] . . . D===eE-----------------R . . movl %r12d, %r11d
[0,87] . . . DeeeeeE----------------R . . movq 84(%rdi), %r12
[0,88] . . . D===eE-----------------R . . movq %r13, %rbx
[0,89] . . . D================eE---R . . shrq $32, %rbx
[0,90] . . . D=================eE--R . . shlq $32, %r11
[0,91] . . . D==================eE-R . . subq %r11, %r9
[0,92] . . . D===================eER . . sbbq %r12, %r8
[0,93] . . . D====================eER . . sbbq %rbx, %rsi
[0,94] . . . D=====================eER. . sbbq $0, %rcx
[0,95] . . . .D=====================eER . sbbq $0, %rdx
[0,96] . . . .D======================eER . sbbq $0, %rax
[0,97] . . . .D=======================eER . sbbq $0, %r10
[0,98] . . . .D==eE---------------------R . movq %r13, %r11
[0,99] . . . .D=================eE------R . shrq $32, %r11
[0,100] . . . .D==================eE-----R . movl %r11d, %ebx
[0,101] . . . . D==================eE----R . shlq $32, %r11
[0,102] . . . . D===================eE---R . subq %r11, %r8
[0,103] . . . . D====================eE--R . sbbq %rbx, %rsi
[0,104] . . . . D=====================eE-R . sbbq $0, %rcx
[0,105] . . . . D======================eER . sbbq $0, %rdx
[0,106] . . . . D=======================eER . sbbq $0, %rax
[0,107] . . . . D=======================eER. sbbq $0, %r10
[0,108] . . . . D================eE-------R. movq %r9, (%rdi)
[0,109] . . . . D===================eE----R. movq %r8, 8(%rdi)
[0,110] . . . . D====================eE---R. movq %rsi, 16(%rdi)
[0,111] . . . . D=====================eE--R. movq %rcx, 24(%rdi)
[0,112] . . . . D======================eE-R. movq %rdx, 32(%rdi)
[0,113] . . . . D======================eER. movq %rax, 40(%rdi)
[0,114] . . . . D=======================eER movq %r10, 48(%rdi)
*/
| 19,738 | 391 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/x509_crl.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:4;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright The Mbed TLS Contributors â
â â
â Licensed under the Apache License, Version 2.0 (the "License"); â
â you may not use this file except in compliance with the License. â
â You may obtain a copy of the License at â
â â
â http://www.apache.org/licenses/LICENSE-2.0 â
â â
â Unless required by applicable law or agreed to in writing, software â
â distributed under the License is distributed on an "AS IS" BASIS, â
â WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. â
â See the License for the specific language governing permissions and â
â limitations under the License. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "third_party/mbedtls/common.h"
#include "third_party/mbedtls/error.h"
#include "third_party/mbedtls/oid.h"
#include "third_party/mbedtls/pem.h"
#include "third_party/mbedtls/platform.h"
#include "third_party/mbedtls/x509_crl.h"
asm(".ident\t\"\\n\\n\
Mbed TLS (Apache 2.0)\\n\
Copyright ARM Limited\\n\
Copyright Mbed TLS Contributors\"");
asm(".include \"libc/disclaimer.inc\"");
/* clang-format off */
/**
* @fileoverview X.509 Certidicate Revocation List (CRL) parsing
*
* The ITU-T X.509 standard defines a certificate format for PKI.
*
* @see http://www.ietf.org/rfc/rfc5280.txt (Certificates and CRLs)
* @see http://www.ietf.org/rfc/rfc3279.txt (Alg IDs for CRLs)
* @see http://www.ietf.org/rfc/rfc2986.txt (CSRs, aka PKCS#10)
* @see http://www.itu.int/ITU-T/studygroups/com17/languages/X.680-0207.pdf
* @see http://www.itu.int/ITU-T/studygroups/com17/languages/X.690-0207.pdf
*/
#if defined(MBEDTLS_X509_CRL_PARSE_C)
/*
* Version ::= INTEGER { v1(0), v2(1) }
*/
static int x509_crl_get_version( unsigned char **p,
const unsigned char *end,
int *ver )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
if( ( ret = mbedtls_asn1_get_int( p, end, ver ) ) != 0 )
{
if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
{
*ver = 0;
return( 0 );
}
return( MBEDTLS_ERR_X509_INVALID_VERSION + ret );
}
return( 0 );
}
/*
* X.509 CRL v2 extensions
*
* We currently don't parse any extension's content, but we do check that the
* list of extensions is well-formed and abort on critical extensions (that
* are unsupported as we don't support any extension so far)
*/
static int x509_get_crl_ext( unsigned char **p,
const unsigned char *end,
mbedtls_x509_buf *ext )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
if( *p == end )
return( 0 );
/*
* crlExtensions [0] EXPLICIT Extensions OPTIONAL
* -- if present, version MUST be v2
*/
if( ( ret = mbedtls_x509_get_ext( p, end, ext, 0 ) ) != 0 )
return( ret );
end = ext->p + ext->len;
while( *p < end )
{
/*
* Extension ::= SEQUENCE {
* extnID OBJECT IDENTIFIER,
* critical BOOLEAN DEFAULT FALSE,
* extnValue OCTET STRING }
*/
int is_critical = 0;
const unsigned char *end_ext_data;
size_t len;
/* Get enclosing sequence tag */
if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
end_ext_data = *p + len;
/* Get OID (currently ignored) */
if( ( ret = mbedtls_asn1_get_tag( p, end_ext_data, &len,
MBEDTLS_ASN1_OID ) ) != 0 )
{
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
}
*p += len;
/* Get optional critical */
if( ( ret = mbedtls_asn1_get_bool( p, end_ext_data,
&is_critical ) ) != 0 &&
( ret != MBEDTLS_ERR_ASN1_UNEXPECTED_TAG ) )
{
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
}
/* Data should be octet string type */
if( ( ret = mbedtls_asn1_get_tag( p, end_ext_data, &len,
MBEDTLS_ASN1_OCTET_STRING ) ) != 0 )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
/* Ignore data so far and just check its length */
*p += len;
if( *p != end_ext_data )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
/* Abort on (unsupported) critical extensions */
if( is_critical )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
}
if( *p != end )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
return( 0 );
}
/*
* X.509 CRL v2 entry extensions (no extensions parsed yet.)
*/
static int x509_get_crl_entry_ext( unsigned char **p,
const unsigned char *end,
mbedtls_x509_buf *ext )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t len = 0;
/* OPTIONAL */
if( end <= *p )
return( 0 );
ext->tag = **p;
ext->p = *p;
/*
* Get CRL-entry extension sequence header
* crlEntryExtensions Extensions OPTIONAL -- if present, MUST be v2
*/
if( ( ret = mbedtls_asn1_get_tag( p, end, &ext->len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
{
if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
{
ext->p = NULL;
return( 0 );
}
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
}
end = *p + ext->len;
if( end != *p + ext->len )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
while( *p < end )
{
if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
*p += len;
}
if( *p != end )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
return( 0 );
}
/*
* X.509 CRL Entries
*/
static int x509_get_entries( unsigned char **p,
const unsigned char *end,
mbedtls_x509_crl_entry *entry )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t entry_len;
mbedtls_x509_crl_entry *cur_entry = entry;
if( *p == end )
return( 0 );
if( ( ret = mbedtls_asn1_get_tag( p, end, &entry_len,
MBEDTLS_ASN1_SEQUENCE | MBEDTLS_ASN1_CONSTRUCTED ) ) != 0 )
{
if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
return( 0 );
return( ret );
}
end = *p + entry_len;
while( *p < end )
{
size_t len2;
const unsigned char *end2;
cur_entry->raw.tag = **p;
if( ( ret = mbedtls_asn1_get_tag( p, end, &len2,
MBEDTLS_ASN1_SEQUENCE | MBEDTLS_ASN1_CONSTRUCTED ) ) != 0 )
{
return( ret );
}
cur_entry->raw.p = *p;
cur_entry->raw.len = len2;
end2 = *p + len2;
if( ( ret = mbedtls_x509_get_serial( p, end2, &cur_entry->serial ) ) != 0 )
return( ret );
if( ( ret = mbedtls_x509_get_time( p, end2,
&cur_entry->revocation_date ) ) != 0 )
return( ret );
if( ( ret = x509_get_crl_entry_ext( p, end2,
&cur_entry->entry_ext ) ) != 0 )
return( ret );
if( *p < end )
{
cur_entry->next = mbedtls_calloc( 1, sizeof( mbedtls_x509_crl_entry ) );
if( cur_entry->next == NULL )
return( MBEDTLS_ERR_X509_ALLOC_FAILED );
cur_entry = cur_entry->next;
}
}
return( 0 );
}
/*
* Parse one CRLs in DER format and append it to the chained list
*/
int mbedtls_x509_crl_parse_der( mbedtls_x509_crl *chain,
const unsigned char *buf, size_t buflen )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t len;
unsigned char *p = NULL, *end = NULL;
mbedtls_x509_buf sig_params1, sig_params2, sig_oid2;
mbedtls_x509_crl *crl = chain;
/*
* Check for valid input
*/
if( crl == NULL || buf == NULL )
return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
mbedtls_platform_zeroize( &sig_params1, sizeof( mbedtls_x509_buf ) );
mbedtls_platform_zeroize( &sig_params2, sizeof( mbedtls_x509_buf ) );
mbedtls_platform_zeroize( &sig_oid2, sizeof( mbedtls_x509_buf ) );
/*
* Add new CRL on the end of the chain if needed.
*/
while( crl->version != 0 && crl->next != NULL )
crl = crl->next;
if( crl->version != 0 && crl->next == NULL )
{
crl->next = mbedtls_calloc( 1, sizeof( mbedtls_x509_crl ) );
if( crl->next == NULL )
{
mbedtls_x509_crl_free( crl );
return( MBEDTLS_ERR_X509_ALLOC_FAILED );
}
mbedtls_x509_crl_init( crl->next );
crl = crl->next;
}
/*
* Copy raw DER-encoded CRL
*/
if( buflen == 0 )
return( MBEDTLS_ERR_X509_INVALID_FORMAT );
p = mbedtls_calloc( 1, buflen );
if( p == NULL )
return( MBEDTLS_ERR_X509_ALLOC_FAILED );
memcpy( p, buf, buflen );
crl->raw.p = p;
crl->raw.len = buflen;
end = p + buflen;
/*
* CertificateList ::= SEQUENCE {
* tbsCertList TBSCertList,
* signatureAlgorithm AlgorithmIdentifier,
* signatureValue BIT STRING }
*/
if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
{
mbedtls_x509_crl_free( crl );
return( MBEDTLS_ERR_X509_INVALID_FORMAT );
}
if( len != (size_t) ( end - p ) )
{
mbedtls_x509_crl_free( crl );
return( MBEDTLS_ERR_X509_INVALID_FORMAT +
MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
}
/*
* TBSCertList ::= SEQUENCE {
*/
crl->tbs.p = p;
if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
{
mbedtls_x509_crl_free( crl );
return( MBEDTLS_ERR_X509_INVALID_FORMAT + ret );
}
end = p + len;
crl->tbs.len = end - crl->tbs.p;
/*
* Version ::= INTEGER OPTIONAL { v1(0), v2(1) }
* -- if present, MUST be v2
*
* signature AlgorithmIdentifier
*/
if( ( ret = x509_crl_get_version( &p, end, &crl->version ) ) != 0 ||
( ret = mbedtls_x509_get_alg( &p, end, &crl->sig_oid, &sig_params1 ) ) != 0 )
{
mbedtls_x509_crl_free( crl );
return( ret );
}
if( crl->version < 0 || crl->version > 1 )
{
mbedtls_x509_crl_free( crl );
return( MBEDTLS_ERR_X509_UNKNOWN_VERSION );
}
crl->version++;
if( ( ret = mbedtls_x509_get_sig_alg( &crl->sig_oid, &sig_params1,
&crl->sig_md, &crl->sig_pk,
&crl->sig_opts ) ) != 0 )
{
mbedtls_x509_crl_free( crl );
return( MBEDTLS_ERR_X509_UNKNOWN_SIG_ALG );
}
/*
* issuer Name
*/
crl->issuer_raw.p = p;
if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
{
mbedtls_x509_crl_free( crl );
return( MBEDTLS_ERR_X509_INVALID_FORMAT + ret );
}
if( ( ret = mbedtls_x509_get_name( &p, p + len, &crl->issuer ) ) != 0 )
{
mbedtls_x509_crl_free( crl );
return( ret );
}
crl->issuer_raw.len = p - crl->issuer_raw.p;
/*
* thisUpdate Time
* nextUpdate Time OPTIONAL
*/
if( ( ret = mbedtls_x509_get_time( &p, end, &crl->this_update ) ) != 0 )
{
mbedtls_x509_crl_free( crl );
return( ret );
}
if( ( ret = mbedtls_x509_get_time( &p, end, &crl->next_update ) ) != 0 )
{
if( ret != ( MBEDTLS_ERR_X509_INVALID_DATE +
MBEDTLS_ERR_ASN1_UNEXPECTED_TAG ) &&
ret != ( MBEDTLS_ERR_X509_INVALID_DATE +
MBEDTLS_ERR_ASN1_OUT_OF_DATA ) )
{
mbedtls_x509_crl_free( crl );
return( ret );
}
}
/*
* revokedCertificates SEQUENCE OF SEQUENCE {
* userCertificate CertificateSerialNumber,
* revocationDate Time,
* crlEntryExtensions Extensions OPTIONAL
* -- if present, MUST be v2
* } OPTIONAL
*/
if( ( ret = x509_get_entries( &p, end, &crl->entry ) ) != 0 )
{
mbedtls_x509_crl_free( crl );
return( ret );
}
/*
* crlExtensions EXPLICIT Extensions OPTIONAL
* -- if present, MUST be v2
*/
if( crl->version == 2 )
{
ret = x509_get_crl_ext( &p, end, &crl->crl_ext );
if( ret != 0 )
{
mbedtls_x509_crl_free( crl );
return( ret );
}
}
if( p != end )
{
mbedtls_x509_crl_free( crl );
return( MBEDTLS_ERR_X509_INVALID_FORMAT +
MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
}
end = crl->raw.p + crl->raw.len;
/*
* signatureAlgorithm AlgorithmIdentifier,
* signatureValue BIT STRING
*/
if( ( ret = mbedtls_x509_get_alg( &p, end, &sig_oid2, &sig_params2 ) ) != 0 )
{
mbedtls_x509_crl_free( crl );
return( ret );
}
if( crl->sig_oid.len != sig_oid2.len ||
timingsafe_bcmp( crl->sig_oid.p, sig_oid2.p, crl->sig_oid.len ) != 0 ||
sig_params1.len != sig_params2.len ||
( sig_params1.len != 0 &&
timingsafe_bcmp( sig_params1.p, sig_params2.p, sig_params1.len ) != 0 ) )
{
mbedtls_x509_crl_free( crl );
return( MBEDTLS_ERR_X509_SIG_MISMATCH );
}
if( ( ret = mbedtls_x509_get_sig( &p, end, &crl->sig ) ) != 0 )
{
mbedtls_x509_crl_free( crl );
return( ret );
}
if( p != end )
{
mbedtls_x509_crl_free( crl );
return( MBEDTLS_ERR_X509_INVALID_FORMAT +
MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
}
return( 0 );
}
/*
* Parse one or more CRLs and add them to the chained list
*/
int mbedtls_x509_crl_parse( mbedtls_x509_crl *chain, const unsigned char *buf, size_t buflen )
{
#if defined(MBEDTLS_PEM_PARSE_C)
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t use_len = 0;
mbedtls_pem_context pem;
int is_pem = 0;
if( chain == NULL || buf == NULL )
return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
do
{
mbedtls_pem_init( &pem );
// Avoid calling mbedtls_pem_read_buffer() on non-null-terminated
// string
if( buflen == 0 || buf[buflen - 1] != '\0' )
ret = MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT;
else
ret = mbedtls_pem_read_buffer( &pem,
"-----BEGIN X509 CRL-----",
"-----END X509 CRL-----",
buf, NULL, 0, &use_len );
if( ret == 0 )
{
/*
* Was PEM encoded
*/
is_pem = 1;
buflen -= use_len;
buf += use_len;
if( ( ret = mbedtls_x509_crl_parse_der( chain,
pem.buf, pem.buflen ) ) != 0 )
{
mbedtls_pem_free( &pem );
return( ret );
}
}
else if( is_pem )
{
mbedtls_pem_free( &pem );
return( ret );
}
mbedtls_pem_free( &pem );
}
/* In the PEM case, buflen is 1 at the end, for the terminated NULL byte.
* And a valid CRL cannot be less than 1 byte anyway. */
while( is_pem && buflen > 1 );
if( is_pem )
return( 0 );
else
#endif /* MBEDTLS_PEM_PARSE_C */
return( mbedtls_x509_crl_parse_der( chain, buf, buflen ) );
}
/*
* Load one or more CRLs and add them to the chained list
*/
int mbedtls_x509_crl_parse_file( mbedtls_x509_crl *chain, const char *path )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t n;
unsigned char *buf;
if( ( ret = mbedtls_pk_load_file( path, &buf, &n ) ) != 0 )
return( ret );
ret = mbedtls_x509_crl_parse( chain, buf, n );
mbedtls_platform_zeroize( buf, n );
mbedtls_free( buf );
return( ret );
}
/*
* Return an informational string about the certificate.
*/
#define BEFORE_COLON 14
#define BC "14"
/*
* Return an informational string about the CRL.
*/
int mbedtls_x509_crl_info( char *buf, size_t size, const char *prefix,
const mbedtls_x509_crl *crl )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t n;
char *p;
const mbedtls_x509_crl_entry *entry;
p = buf;
n = size;
ret = mbedtls_snprintf( p, n, "%sCRL version : %d",
prefix, crl->version );
MBEDTLS_X509_SAFE_SNPRINTF;
ret = mbedtls_snprintf( p, n, "\n%sissuer name : ", prefix );
MBEDTLS_X509_SAFE_SNPRINTF;
ret = mbedtls_x509_dn_gets( p, n, &crl->issuer );
MBEDTLS_X509_SAFE_SNPRINTF;
ret = mbedtls_snprintf( p, n, "\n%sthis update : " \
"%04d-%02d-%02d %02d:%02d:%02d", prefix,
crl->this_update.year, crl->this_update.mon,
crl->this_update.day, crl->this_update.hour,
crl->this_update.min, crl->this_update.sec );
MBEDTLS_X509_SAFE_SNPRINTF;
ret = mbedtls_snprintf( p, n, "\n%snext update : " \
"%04d-%02d-%02d %02d:%02d:%02d", prefix,
crl->next_update.year, crl->next_update.mon,
crl->next_update.day, crl->next_update.hour,
crl->next_update.min, crl->next_update.sec );
MBEDTLS_X509_SAFE_SNPRINTF;
entry = &crl->entry;
ret = mbedtls_snprintf( p, n, "\n%sRevoked certificates:",
prefix );
MBEDTLS_X509_SAFE_SNPRINTF;
while( entry != NULL && entry->raw.len != 0 )
{
ret = mbedtls_snprintf( p, n, "\n%sserial number: ",
prefix );
MBEDTLS_X509_SAFE_SNPRINTF;
ret = mbedtls_x509_serial_gets( p, n, &entry->serial );
MBEDTLS_X509_SAFE_SNPRINTF;
ret = mbedtls_snprintf( p, n, " revocation date: " \
"%04d-%02d-%02d %02d:%02d:%02d",
entry->revocation_date.year, entry->revocation_date.mon,
entry->revocation_date.day, entry->revocation_date.hour,
entry->revocation_date.min, entry->revocation_date.sec );
MBEDTLS_X509_SAFE_SNPRINTF;
entry = entry->next;
}
ret = mbedtls_snprintf( p, n, "\n%ssigned using : ", prefix );
MBEDTLS_X509_SAFE_SNPRINTF;
ret = mbedtls_x509_sig_alg_gets( p, n, &crl->sig_oid, crl->sig_pk, crl->sig_md,
crl->sig_opts );
MBEDTLS_X509_SAFE_SNPRINTF;
ret = mbedtls_snprintf( p, n, "\n" );
MBEDTLS_X509_SAFE_SNPRINTF;
return( (int) ( size - n ) );
}
/*
* Initialize a CRL chain
*/
void mbedtls_x509_crl_init( mbedtls_x509_crl *crl )
{
mbedtls_platform_zeroize( crl, sizeof(mbedtls_x509_crl) );
}
/*
* Unallocate all CRL data
*/
void mbedtls_x509_crl_free( mbedtls_x509_crl *crl )
{
mbedtls_x509_crl *crl_cur = crl;
mbedtls_x509_crl *crl_prv;
mbedtls_x509_name *name_cur;
mbedtls_x509_name *name_prv;
mbedtls_x509_crl_entry *entry_cur;
mbedtls_x509_crl_entry *entry_prv;
if( crl == NULL )
return;
do
{
name_cur = crl_cur->issuer.next;
while( name_cur != NULL )
{
name_prv = name_cur;
name_cur = name_cur->next;
mbedtls_platform_zeroize( name_prv, sizeof( mbedtls_x509_name ) );
mbedtls_free( name_prv );
}
entry_cur = crl_cur->entry.next;
while( entry_cur != NULL )
{
entry_prv = entry_cur;
entry_cur = entry_cur->next;
mbedtls_platform_zeroize( entry_prv,
sizeof( mbedtls_x509_crl_entry ) );
mbedtls_free( entry_prv );
}
if( crl_cur->raw.p != NULL )
{
mbedtls_platform_zeroize( crl_cur->raw.p, crl_cur->raw.len );
mbedtls_free( crl_cur->raw.p );
}
crl_cur = crl_cur->next;
}
while( crl_cur != NULL );
crl_cur = crl;
do
{
crl_prv = crl_cur;
crl_cur = crl_cur->next;
mbedtls_platform_zeroize( crl_prv, sizeof( mbedtls_x509_crl ) );
if( crl_prv != crl )
mbedtls_free( crl_prv );
}
while( crl_cur != NULL );
}
#endif /* MBEDTLS_X509_CRL_PARSE_C */
| 22,418 | 744 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/param.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2021 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/calls/calls.h"
#include "libc/fmt/itoa.h"
#include "libc/mem/mem.h"
#include "libc/runtime/runtime.h"
#include "libc/str/str.h"
#include "third_party/mbedtls/platform.h"
void mbedtls_param_failed(const char *msg, const char *file, int line) {
char *p, *q;
if ((p = q = malloc(128 + strlen(msg) + strlen(file)))) {
p = stpcpy(p, file), *p++ = ':';
p = FormatInt32(p, line);
p = stpcpy(p, ": error: ");
p = stpcpy(p, msg);
p = stpcpy(p, "\r\n");
write(2, q, p - q);
free(q);
}
exit(1);
}
| 2,374 | 39 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/getciphersuite.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2021 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "third_party/mbedtls/ssl_ciphersuites.h"
#define S32(S) (S[0] << 24 | S[1] << 16 | S[2] << 8 | S[3])
/**
* Returns ciphersuite info by IANA name.
*
* This API provides some wiggle room for naming, e.g.
*
* - ECDHE-ECDSA-AES256-GCM-SHA384 (preferred)
* - ECDHE-ECDSA-WITH-AES-256-GCM-SHA384
* - TLS-ECDHE-ECDSA-WITH-AES-256-GCM-SHA384
* - TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 (canonical)
*
* All of the above are acceptable names for 0xC02C.
*/
const mbedtls_ssl_ciphersuite_t *GetCipherSuite(const char *s) {
int i, j;
char b[50];
uint32_t w;
unsigned char c;
for (i = j = w = 0; (c = s[i++]);) {
if (c == '_') c = '-'; // _ â -
if ('a' <= c && c <= 'z') c -= 'a' - 'A'; // a-z â A-Z
if (c == '-' && w == S32("WITH")) j -= 5; // WITH- â -
if (w == S32("TLS-")) j -= 4; // TLS- â
w = w << 8 | c; // ------- ------
if (w == S32("AES-")) continue; // AES-XXX â AESXXX
if (w == S32("SHA1")) continue; // SHA1 â SHA
if (!(0 <= j && j + 1 < sizeof(b))) return 0;
b[j++] = c;
}
b[j++] = 0;
return mbedtls_ssl_ciphersuite_from_string(b);
}
| 3,061 | 54 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/ctr_drbg.h | #ifndef MBEDTLS_CTR_DRBG_H_
#define MBEDTLS_CTR_DRBG_H_
#include "third_party/mbedtls/aes.h"
#include "third_party/mbedtls/config.h"
COSMOPOLITAN_C_START_
/* clang-format off */
#define MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED -0x0034 /*< The entropy source failed. */
#define MBEDTLS_ERR_CTR_DRBG_REQUEST_TOO_BIG -0x0036 /*< The requested random buffer length is too big. */
#define MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG -0x0038 /*< The input (entropy + additional data) is too large. */
#define MBEDTLS_ERR_CTR_DRBG_FILE_IO_ERROR -0x003A /*< Read or write error in file. */
#define MBEDTLS_CTR_DRBG_BLOCKSIZE 16 /*< The block size used by the cipher. */
#if defined(MBEDTLS_CTR_DRBG_USE_128_BIT_KEY)
#define MBEDTLS_CTR_DRBG_KEYSIZE 16
/*< The key size in bytes used by the cipher.
*
* Compile-time choice: 16 bytes (128 bits)
* because #MBEDTLS_CTR_DRBG_USE_128_BIT_KEY is enabled.
*/
#else
#define MBEDTLS_CTR_DRBG_KEYSIZE 32
/*< The key size in bytes used by the cipher.
*
* Compile-time choice: 32 bytes (256 bits)
* because \c MBEDTLS_CTR_DRBG_USE_128_BIT_KEY is disabled.
*/
#endif
#define MBEDTLS_CTR_DRBG_KEYBITS ( MBEDTLS_CTR_DRBG_KEYSIZE * 8 ) /*< The key size for the DRBG operation, in bits. */
#define MBEDTLS_CTR_DRBG_SEEDLEN ( MBEDTLS_CTR_DRBG_KEYSIZE + MBEDTLS_CTR_DRBG_BLOCKSIZE ) /*< The seed length, calculated as (counter + AES key). */
/**
* \name SECTION: Module settings
*
* The configuration options you can set for this module are in this section.
* Either change them in config.h or define them using the compiler command
* line.
* \{
*/
/** \def MBEDTLS_CTR_DRBG_ENTROPY_LEN
*
* \brief The amount of entropy used per seed by default, in bytes.
*/
#if !defined(MBEDTLS_CTR_DRBG_ENTROPY_LEN)
#if defined(MBEDTLS_SHA512_C) && !defined(MBEDTLS_ENTROPY_FORCE_SHA256)
/** This is 48 bytes because the entropy module uses SHA-512
* (\c MBEDTLS_ENTROPY_FORCE_SHA256 is disabled).
*/
#define MBEDTLS_CTR_DRBG_ENTROPY_LEN 48
#else /* defined(MBEDTLS_SHA512_C) && !defined(MBEDTLS_ENTROPY_FORCE_SHA256) */
/** This is 32 bytes because the entropy module uses SHA-256
* (the SHA512 module is disabled or
* \c MBEDTLS_ENTROPY_FORCE_SHA256 is enabled).
*/
#if !defined(MBEDTLS_CTR_DRBG_USE_128_BIT_KEY)
/** \warning To achieve a 256-bit security strength, you must pass a nonce
* to mbedtls_ctr_drbg_seed().
*/
#endif /* !defined(MBEDTLS_CTR_DRBG_USE_128_BIT_KEY) */
#define MBEDTLS_CTR_DRBG_ENTROPY_LEN 32
#endif /* defined(MBEDTLS_SHA512_C) && !defined(MBEDTLS_ENTROPY_FORCE_SHA256) */
#endif /* !defined(MBEDTLS_CTR_DRBG_ENTROPY_LEN) */
#if !defined(MBEDTLS_CTR_DRBG_RESEED_INTERVAL)
#define MBEDTLS_CTR_DRBG_RESEED_INTERVAL 10000
/*< The interval before reseed is performed by default. */
#endif
#if !defined(MBEDTLS_CTR_DRBG_MAX_INPUT)
#define MBEDTLS_CTR_DRBG_MAX_INPUT 256
/*< The maximum number of additional input Bytes. */
#endif
#if !defined(MBEDTLS_CTR_DRBG_MAX_REQUEST)
#define MBEDTLS_CTR_DRBG_MAX_REQUEST 1024
/*< The maximum number of requested Bytes per call. */
#endif
#if !defined(MBEDTLS_CTR_DRBG_MAX_SEED_INPUT)
#define MBEDTLS_CTR_DRBG_MAX_SEED_INPUT 384
/*< The maximum size of seed or reseed buffer in bytes. */
#endif
/* \} name SECTION: Module settings */
#define MBEDTLS_CTR_DRBG_PR_OFF 0
/*< Prediction resistance is disabled. */
#define MBEDTLS_CTR_DRBG_PR_ON 1
/*< Prediction resistance is enabled. */
#if MBEDTLS_CTR_DRBG_ENTROPY_LEN >= MBEDTLS_CTR_DRBG_KEYSIZE * 3 / 2
/** The default length of the nonce read from the entropy source.
*
* This is \c 0 because a single read from the entropy source is sufficient
* to include a nonce.
* See the documentation of mbedtls_ctr_drbg_seed() for more information.
*/
#define MBEDTLS_CTR_DRBG_ENTROPY_NONCE_LEN 0
#else
/** The default length of the nonce read from the entropy source.
*
* This is half of the default entropy length because a single read from
* the entropy source does not provide enough material to form a nonce.
* See the documentation of mbedtls_ctr_drbg_seed() for more information.
*/
#define MBEDTLS_CTR_DRBG_ENTROPY_NONCE_LEN ( MBEDTLS_CTR_DRBG_ENTROPY_LEN + 1 ) / 2
#endif
/**
* \brief The CTR_DRBG context structure.
*/
typedef struct mbedtls_ctr_drbg_context
{
unsigned char counter[16]; /*!< The counter (V). */
int reseed_counter; /*!< The reseed counter.
* This is the number of requests that have
* been made since the last (re)seeding,
* minus one.
* Before the initial seeding, this field
* contains the amount of entropy in bytes
* to use as a nonce for the initial seeding,
* or -1 if no nonce length has been explicitly
* set (see mbedtls_ctr_drbg_set_nonce_len()).
*/
int prediction_resistance; /*!< This determines whether prediction
resistance is enabled, that is
whether to systematically reseed before
each random generation. */
size_t entropy_len; /*!< The amount of entropy grabbed on each
seed or reseed operation, in bytes. */
int reseed_interval; /*!< The reseed interval.
* This is the maximum number of requests
* that can be made between reseedings. */
mbedtls_aes_context aes_ctx; /*!< The AES context. */
/*
* Callbacks (Entropy)
*/
int (*f_entropy)(void *, unsigned char *, size_t);
/*!< The entropy callback function. */
void *p_entropy; /*!< The context for the entropy function. */
}
mbedtls_ctr_drbg_context;
void mbedtls_ctr_drbg_init( mbedtls_ctr_drbg_context * );
/**
* \brief This function seeds and sets up the CTR_DRBG
* entropy source for future reseeds.
*
* A typical choice for the \p f_entropy and \p p_entropy parameters is
* to use the entropy module:
* - \p f_entropy is mbedtls_entropy_func();
* - \p p_entropy is an instance of ::mbedtls_entropy_context initialized
* with mbedtls_entropy_init() (which registers the platform's default
* entropy sources).
*
* The entropy length is #MBEDTLS_CTR_DRBG_ENTROPY_LEN by default.
* You can override it by calling mbedtls_ctr_drbg_set_entropy_len().
*
* The entropy nonce length is:
* - \c 0 if the entropy length is at least 3/2 times the entropy length,
* which guarantees that the security strength is the maximum permitted
* by the key size and entropy length according to NIST SP 800-90A §10.2.1;
* - Half the entropy length otherwise.
* You can override it by calling mbedtls_ctr_drbg_set_nonce_len().
* With the default entropy length, the entropy nonce length is
* #MBEDTLS_CTR_DRBG_ENTROPY_NONCE_LEN.
*
* You can provide a nonce and personalization string in addition to the
* entropy source, to make this instantiation as unique as possible.
* See SP 800-90A §8.6.7 for more details about nonces.
*
* The _seed_material_ value passed to the derivation function in
* the CTR_DRBG Instantiate Process described in NIST SP 800-90A §10.2.1.3.2
* is the concatenation of the following strings:
* - A string obtained by calling \p f_entropy function for the entropy
* length.
*/
#if MBEDTLS_CTR_DRBG_ENTROPY_NONCE_LEN == 0
/**
* - If mbedtls_ctr_drbg_set_nonce_len() has been called, a string
* obtained by calling \p f_entropy function for the specified length.
*/
#else
/**
* - A string obtained by calling \p f_entropy function for the entropy nonce
* length. If the entropy nonce length is \c 0, this function does not
* make a second call to \p f_entropy.
*/
#endif
/**
* - The \p custom string.
*
* \note To achieve the nominal security strength permitted
* by CTR_DRBG, the entropy length must be:
* - at least 16 bytes for a 128-bit strength
* (maximum achievable strength when using AES-128);
* - at least 32 bytes for a 256-bit strength
* (maximum achievable strength when using AES-256).
*
* In addition, if you do not pass a nonce in \p custom,
* the sum of the entropy length
* and the entropy nonce length must be:
* - at least 24 bytes for a 128-bit strength
* (maximum achievable strength when using AES-128);
* - at least 48 bytes for a 256-bit strength
* (maximum achievable strength when using AES-256).
*
* \param ctx The CTR_DRBG context to seed.
* It must have been initialized with
* mbedtls_ctr_drbg_init().
* After a successful call to mbedtls_ctr_drbg_seed(),
* you may not call mbedtls_ctr_drbg_seed() again on
* the same context unless you call
* mbedtls_ctr_drbg_free() and mbedtls_ctr_drbg_init()
* again first.
* After a failed call to mbedtls_ctr_drbg_seed(),
* you must call mbedtls_ctr_drbg_free().
* \param f_entropy The entropy callback, taking as arguments the
* \p p_entropy context, the buffer to fill, and the
* length of the buffer.
* \p f_entropy is always called with a buffer size
* less than or equal to the entropy length.
* \param p_entropy The entropy context to pass to \p f_entropy.
* \param custom The personalization string.
* This can be \c NULL, in which case the personalization
* string is empty regardless of the value of \p len.
* \param len The length of the personalization string.
* This must be at most
* #MBEDTLS_CTR_DRBG_MAX_SEED_INPUT
* - #MBEDTLS_CTR_DRBG_ENTROPY_LEN.
*
* \return \c 0 on success.
* \return #MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED on failure.
*/
int mbedtls_ctr_drbg_seed( mbedtls_ctr_drbg_context *ctx,
int (*f_entropy)(void *, unsigned char *, size_t),
void *p_entropy,
const void *custom,
size_t len );
/**
* \brief This function resets CTR_DRBG context to the state immediately
* after initial call of mbedtls_ctr_drbg_init().
*
* \param ctx The CTR_DRBG context to clear.
*/
void mbedtls_ctr_drbg_free( mbedtls_ctr_drbg_context *ctx );
/**
* \brief This function turns prediction resistance on or off.
* The default value is off.
*
* \note If enabled, entropy is gathered at the beginning of
* every call to mbedtls_ctr_drbg_random_with_add()
* or mbedtls_ctr_drbg_random().
* Only use this if your entropy source has sufficient
* throughput.
*
* \param ctx The CTR_DRBG context.
* \param resistance #MBEDTLS_CTR_DRBG_PR_ON or #MBEDTLS_CTR_DRBG_PR_OFF.
*/
void mbedtls_ctr_drbg_set_prediction_resistance( mbedtls_ctr_drbg_context *ctx,
int resistance );
/**
* \brief This function sets the amount of entropy grabbed on each
* seed or reseed.
*
* The default value is #MBEDTLS_CTR_DRBG_ENTROPY_LEN.
*
* \note The security strength of CTR_DRBG is bounded by the
* entropy length. Thus:
* - When using AES-256
* (\c MBEDTLS_CTR_DRBG_USE_128_BIT_KEY is disabled,
* which is the default),
* \p len must be at least 32 (in bytes)
* to achieve a 256-bit strength.
* - When using AES-128
* (\c MBEDTLS_CTR_DRBG_USE_128_BIT_KEY is enabled)
* \p len must be at least 16 (in bytes)
* to achieve a 128-bit strength.
*
* \param ctx The CTR_DRBG context.
* \param len The amount of entropy to grab, in bytes.
* This must be at most #MBEDTLS_CTR_DRBG_MAX_SEED_INPUT
* and at most the maximum length accepted by the
* entropy function that is set in the context.
*/
void mbedtls_ctr_drbg_set_entropy_len( mbedtls_ctr_drbg_context *ctx,
size_t len );
/**
* \brief This function sets the amount of entropy grabbed
* as a nonce for the initial seeding.
*
* Call this function before calling mbedtls_ctr_drbg_seed() to read
* a nonce from the entropy source during the initial seeding.
*
* \param ctx The CTR_DRBG context.
* \param len The amount of entropy to grab for the nonce, in bytes.
* This must be at most #MBEDTLS_CTR_DRBG_MAX_SEED_INPUT
* and at most the maximum length accepted by the
* entropy function that is set in the context.
*
* \return \c 0 on success.
* \return #MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG if \p len is
* more than #MBEDTLS_CTR_DRBG_MAX_SEED_INPUT.
* \return #MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED
* if the initial seeding has already taken place.
*/
int mbedtls_ctr_drbg_set_nonce_len( mbedtls_ctr_drbg_context *ctx,
size_t len );
/**
* \brief This function sets the reseed interval.
*
* The reseed interval is the number of calls to mbedtls_ctr_drbg_random()
* or mbedtls_ctr_drbg_random_with_add() after which the entropy function
* is called again.
*
* The default value is #MBEDTLS_CTR_DRBG_RESEED_INTERVAL.
*
* \param ctx The CTR_DRBG context.
* \param interval The reseed interval.
*/
void mbedtls_ctr_drbg_set_reseed_interval( mbedtls_ctr_drbg_context *ctx,
int interval );
/**
* \brief This function reseeds the CTR_DRBG context, that is
* extracts data from the entropy source.
*
* \note This function is not thread-safe. It is not safe
* to call this function if another thread might be
* concurrently obtaining random numbers from the same
* context or updating or reseeding the same context.
*
* \param ctx The CTR_DRBG context.
* \param additional Additional data to add to the state. Can be \c NULL.
* \param len The length of the additional data.
* This must be less than
* #MBEDTLS_CTR_DRBG_MAX_SEED_INPUT - \c entropy_len
* where \c entropy_len is the entropy length
* configured for the context.
*
* \return \c 0 on success.
* \return #MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED on failure.
*/
int mbedtls_ctr_drbg_reseed( mbedtls_ctr_drbg_context *ctx,
const void *additional, size_t len );
/**
* \brief This function updates the state of the CTR_DRBG context.
*
* \note This function is not thread-safe. It is not safe
* to call this function if another thread might be
* concurrently obtaining random numbers from the same
* context or updating or reseeding the same context.
*
* \param ctx The CTR_DRBG context.
* \param additional The data to update the state with. This must not be
* \c NULL unless \p add_len is \c 0.
* \param add_len Length of \p additional in bytes. This must be at
* most #MBEDTLS_CTR_DRBG_MAX_SEED_INPUT.
*
* \return \c 0 on success.
* \return #MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG if
* \p add_len is more than
* #MBEDTLS_CTR_DRBG_MAX_SEED_INPUT.
* \return An error from the underlying AES cipher on failure.
*/
int mbedtls_ctr_drbg_update_ret( mbedtls_ctr_drbg_context *ctx,
const unsigned char *additional,
size_t add_len );
/**
* \brief This function updates a CTR_DRBG instance with additional
* data and uses it to generate random data.
*
* This function automatically reseeds if the reseed counter is exceeded
* or prediction resistance is enabled.
*
* \note This function is not thread-safe. It is not safe
* to call this function if another thread might be
* concurrently obtaining random numbers from the same
* context or updating or reseeding the same context.
*
* \param p_rng The CTR_DRBG context. This must be a pointer to a
* #mbedtls_ctr_drbg_context structure.
* \param output The buffer to fill.
* \param output_len The length of the buffer in bytes.
* \param additional Additional data to update. Can be \c NULL, in which
* case the additional data is empty regardless of
* the value of \p add_len.
* \param add_len The length of the additional data
* if \p additional is not \c NULL.
* This must be less than #MBEDTLS_CTR_DRBG_MAX_INPUT
* and less than
* #MBEDTLS_CTR_DRBG_MAX_SEED_INPUT - \c entropy_len
* where \c entropy_len is the entropy length
* configured for the context.
*
* \return \c 0 on success.
* \return #MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED or
* #MBEDTLS_ERR_CTR_DRBG_REQUEST_TOO_BIG on failure.
*/
int mbedtls_ctr_drbg_random_with_add( void *p_rng,
unsigned char *output, size_t output_len,
const unsigned char *additional, size_t add_len );
int mbedtls_ctr_drbg_random( void *p_rng, unsigned char *output, size_t output_len );
/**
* \brief This function writes a seed file.
*
* \param ctx The CTR_DRBG context.
* \param path The name of the file.
*
* \return \c 0 on success.
* \return #MBEDTLS_ERR_CTR_DRBG_FILE_IO_ERROR on file error.
* \return #MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED on reseed
* failure.
*/
int mbedtls_ctr_drbg_write_seed_file( mbedtls_ctr_drbg_context *ctx, const char *path );
/**
* \brief This function reads and updates a seed file. The seed
* is added to this instance.
*
* \param ctx The CTR_DRBG context.
* \param path The name of the file.
*
* \return \c 0 on success.
* \return #MBEDTLS_ERR_CTR_DRBG_FILE_IO_ERROR on file error.
* \return #MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED on
* reseed failure.
* \return #MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG if the existing
* seed file is too large.
*/
int mbedtls_ctr_drbg_update_seed_file( mbedtls_ctr_drbg_context *ctx, const char *path );
/**
* \brief The CTR_DRBG checkup routine.
*
* \return \c 0 on success.
* \return \c 1 on failure.
*/
int mbedtls_ctr_drbg_self_test( int verbose );
COSMOPOLITAN_C_END_
#endif /* CTR_DRBG_H_ */
| 20,407 | 462 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/sha512t.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:4;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright The Mbed TLS Contributors â
â â
â Licensed under the Apache License, Version 2.0 (the "License"); â
â you may not use this file except in compliance with the License. â
â You may obtain a copy of the License at â
â â
â http://www.apache.org/licenses/LICENSE-2.0 â
â â
â Unless required by applicable law or agreed to in writing, software â
â distributed under the License is distributed on an "AS IS" BASIS, â
â WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. â
â See the License for the specific language governing permissions and â
â limitations under the License. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/macros.internal.h"
#include "libc/str/str.h"
#include "third_party/mbedtls/platform.h"
#include "third_party/mbedtls/sha512.h"
asm(".ident\t\"\\n\\n\
Mbed TLS (Apache 2.0)\\n\
Copyright ARM Limited\\n\
Copyright Mbed TLS Contributors\"");
asm(".include \"libc/disclaimer.inc\"");
// clang-format off
/*
* FIPS-180-2 test vectors
*/
static const unsigned char sha512_test_buf[3][113] =
{
{ "abc" },
{ "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn"
"hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu" },
{ "" }
};
static const size_t sha512_test_buflen[3] =
{
3, 112, 1000
};
static const unsigned char sha512_test_sum[][64] =
{
#if !defined(MBEDTLS_SHA512_NO_SHA384)
/*
* SHA-384 test vectors
*/
{ 0xCB, 0x00, 0x75, 0x3F, 0x45, 0xA3, 0x5E, 0x8B,
0xB5, 0xA0, 0x3D, 0x69, 0x9A, 0xC6, 0x50, 0x07,
0x27, 0x2C, 0x32, 0xAB, 0x0E, 0xDE, 0xD1, 0x63,
0x1A, 0x8B, 0x60, 0x5A, 0x43, 0xFF, 0x5B, 0xED,
0x80, 0x86, 0x07, 0x2B, 0xA1, 0xE7, 0xCC, 0x23,
0x58, 0xBA, 0xEC, 0xA1, 0x34, 0xC8, 0x25, 0xA7 },
{ 0x09, 0x33, 0x0C, 0x33, 0xF7, 0x11, 0x47, 0xE8,
0x3D, 0x19, 0x2F, 0xC7, 0x82, 0xCD, 0x1B, 0x47,
0x53, 0x11, 0x1B, 0x17, 0x3B, 0x3B, 0x05, 0xD2,
0x2F, 0xA0, 0x80, 0x86, 0xE3, 0xB0, 0xF7, 0x12,
0xFC, 0xC7, 0xC7, 0x1A, 0x55, 0x7E, 0x2D, 0xB9,
0x66, 0xC3, 0xE9, 0xFA, 0x91, 0x74, 0x60, 0x39 },
{ 0x9D, 0x0E, 0x18, 0x09, 0x71, 0x64, 0x74, 0xCB,
0x08, 0x6E, 0x83, 0x4E, 0x31, 0x0A, 0x4A, 0x1C,
0xED, 0x14, 0x9E, 0x9C, 0x00, 0xF2, 0x48, 0x52,
0x79, 0x72, 0xCE, 0xC5, 0x70, 0x4C, 0x2A, 0x5B,
0x07, 0xB8, 0xB3, 0xDC, 0x38, 0xEC, 0xC4, 0xEB,
0xAE, 0x97, 0xDD, 0xD8, 0x7F, 0x3D, 0x89, 0x85 },
#endif /* !MBEDTLS_SHA512_NO_SHA384 */
/*
* SHA-512 test vectors
*/
{ 0xDD, 0xAF, 0x35, 0xA1, 0x93, 0x61, 0x7A, 0xBA,
0xCC, 0x41, 0x73, 0x49, 0xAE, 0x20, 0x41, 0x31,
0x12, 0xE6, 0xFA, 0x4E, 0x89, 0xA9, 0x7E, 0xA2,
0x0A, 0x9E, 0xEE, 0xE6, 0x4B, 0x55, 0xD3, 0x9A,
0x21, 0x92, 0x99, 0x2A, 0x27, 0x4F, 0xC1, 0xA8,
0x36, 0xBA, 0x3C, 0x23, 0xA3, 0xFE, 0xEB, 0xBD,
0x45, 0x4D, 0x44, 0x23, 0x64, 0x3C, 0xE8, 0x0E,
0x2A, 0x9A, 0xC9, 0x4F, 0xA5, 0x4C, 0xA4, 0x9F },
{ 0x8E, 0x95, 0x9B, 0x75, 0xDA, 0xE3, 0x13, 0xDA,
0x8C, 0xF4, 0xF7, 0x28, 0x14, 0xFC, 0x14, 0x3F,
0x8F, 0x77, 0x79, 0xC6, 0xEB, 0x9F, 0x7F, 0xA1,
0x72, 0x99, 0xAE, 0xAD, 0xB6, 0x88, 0x90, 0x18,
0x50, 0x1D, 0x28, 0x9E, 0x49, 0x00, 0xF7, 0xE4,
0x33, 0x1B, 0x99, 0xDE, 0xC4, 0xB5, 0x43, 0x3A,
0xC7, 0xD3, 0x29, 0xEE, 0xB6, 0xDD, 0x26, 0x54,
0x5E, 0x96, 0xE5, 0x5B, 0x87, 0x4B, 0xE9, 0x09 },
{ 0xE7, 0x18, 0x48, 0x3D, 0x0C, 0xE7, 0x69, 0x64,
0x4E, 0x2E, 0x42, 0xC7, 0xBC, 0x15, 0xB4, 0x63,
0x8E, 0x1F, 0x98, 0xB1, 0x3B, 0x20, 0x44, 0x28,
0x56, 0x32, 0xA8, 0x03, 0xAF, 0xA9, 0x73, 0xEB,
0xDE, 0x0F, 0xF2, 0x44, 0x87, 0x7E, 0xA6, 0x0A,
0x4C, 0xB0, 0x43, 0x2C, 0xE5, 0x77, 0xC3, 0x1B,
0xEB, 0x00, 0x9C, 0x5C, 0x2C, 0x49, 0xAA, 0x2E,
0x4E, 0xAD, 0xB2, 0x17, 0xAD, 0x8C, 0xC0, 0x9B }
};
/**
* \brief The SHA-384 or SHA-512 checkup routine.
*
* \return \c 0 on success.
* \return \c 1 on failure.
*/
int mbedtls_sha512_self_test( int verbose )
{
int i, j, k, buflen, ret = 0;
unsigned char *buf;
unsigned char sha512sum[64];
mbedtls_sha512_context ctx;
buf = mbedtls_calloc( 1024, sizeof(unsigned char) );
if( NULL == buf )
{
if( verbose != 0 )
mbedtls_printf( "Buffer allocation failed\n" );
return( 1 );
}
mbedtls_sha512_init( &ctx );
for( i = 0; i < (int) ARRAYLEN(sha512_test_sum); i++ )
{
j = i % 3;
#ifndef MBEDTLS_SHA512_NO_SHA384
k = i < 3;
#else
k = 0;
#endif
if( verbose != 0 )
mbedtls_printf( " SHA-%d test #%d: ", 512 - k * 128, j + 1 );
if( ( ret = mbedtls_sha512_starts_ret( &ctx, k ) ) != 0 )
goto fail;
if( j == 2 )
{
memset( buf, 'a', buflen = 1000 );
for( j = 0; j < 1000; j++ )
{
ret = mbedtls_sha512_update_ret( &ctx, buf, buflen );
if( ret != 0 )
goto fail;
}
}
else
{
ret = mbedtls_sha512_update_ret( &ctx, sha512_test_buf[j],
sha512_test_buflen[j] );
if( ret != 0 )
goto fail;
}
if( ( ret = mbedtls_sha512_finish_ret( &ctx, sha512sum ) ) != 0 )
goto fail;
if( timingsafe_bcmp( sha512sum, sha512_test_sum[i], 64 - k * 16 ) != 0 )
{
ret = 1;
goto fail;
}
if( verbose != 0 )
mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
mbedtls_printf( "\n" );
goto exit;
fail:
if( verbose != 0 )
mbedtls_printf( "failed\n" );
exit:
mbedtls_sha512_free( &ctx );
mbedtls_free( buf );
return( ret );
}
| 6,840 | 170 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/shiftright-avx.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2021 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "third_party/mbedtls/bignum_internal.h"
#include "third_party/mbedtls/platform.h"
#ifdef __x86_64__
typedef uint64_t xmm_t __attribute__((__vector_size__(16), __aligned__(1)));
void ShiftRightAvx(uint64_t *p, size_t n, unsigned char k) {
uint64_t p1;
xmm_t cv = {0};
xmm_t i0, i1, i2, i3;
xmm_t o0, o1, o2, o3;
MBEDTLS_ASSERT(!(k & ~63));
p1 = n > 1 ? p[1] : 0;
while (n >= 4) {
n -= 4;
i0 = *(xmm_t *)(p + n + 2);
i1 = *(xmm_t *)(p + n + 0);
o0 = i0 >> k | (xmm_t){i0[1], cv[0]} << (64 - k);
o1 = i1 >> k | (xmm_t){i1[1], i0[0]} << (64 - k);
cv = i1;
*(xmm_t *)(p + n + 2) = o0;
*(xmm_t *)(p + n + 0) = o1;
}
if (n >= 2) {
n -= 2;
i0 = *(xmm_t *)(p + n);
o0 = i0 >> k | (xmm_t){i0[1], cv[0]} << (64 - k);
cv = i0;
*(xmm_t *)(p + n) = o0;
}
if (n) {
p[0] = p[0] >> k | p1 << (64 - k);
}
}
#endif /* __x86_64__ */
| 2,742 | 56 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/x509_crt.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:4;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright The Mbed TLS Contributors â
â â
â Licensed under the Apache License, Version 2.0 (the "License"); â
â you may not use this file except in compliance with the License. â
â You may obtain a copy of the License at â
â â
â http://www.apache.org/licenses/LICENSE-2.0 â
â â
â Unless required by applicable law or agreed to in writing, software â
â distributed under the License is distributed on an "AS IS" BASIS, â
â WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. â
â See the License for the specific language governing permissions and â
â limitations under the License. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/calls/calls.h"
#include "libc/calls/struct/dirent.h"
#include "libc/calls/struct/stat.h"
#include "libc/fmt/fmt.h"
#include "libc/intrin/bits.h"
#include "libc/limits.h"
#include "libc/log/log.h"
#include "libc/mem/mem.h"
#include "libc/stdio/stdio.h"
#include "libc/sysv/consts/s.h"
#include "net/http/http.h"
#include "net/http/ip.h"
#include "third_party/mbedtls/common.h"
#include "third_party/mbedtls/error.h"
#include "third_party/mbedtls/oid.h"
#include "third_party/mbedtls/pem.h"
#include "third_party/mbedtls/platform.h"
#include "third_party/mbedtls/x509_crt.h"
/* clang-format off */
asm(".ident\t\"\\n\\n\
Mbed TLS (Apache 2.0)\\n\
Copyright ARM Limited\\n\
Copyright Mbed TLS Contributors\"");
asm(".include \"libc/disclaimer.inc\"");
/*
* X.509 certificate parsing and verification
*
* Copyright The Mbed TLS Contributors
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* The ITU-T X.509 standard defines a certificate format for PKI.
*
* http://www.ietf.org/rfc/rfc5280.txt (Certificates and CRLs)
* http://www.ietf.org/rfc/rfc3279.txt (Alg IDs for CRLs)
* http://www.ietf.org/rfc/rfc2986.txt (CSRs, aka PKCS#10)
*
* http://www.itu.int/ITU-T/studygroups/com17/languages/X.680-0207.pdf
* http://www.itu.int/ITU-T/studygroups/com17/languages/X.690-0207.pdf
*
* [SIRO] https://cabforum.org/wp-content/uploads/Chunghwatelecom201503cabforumV4.pdf
*/
#if defined(MBEDTLS_X509_CRT_PARSE_C)
/*
* Item in a verification chain: cert and flags for it
*/
typedef struct {
mbedtls_x509_crt *crt;
uint32_t flags;
} x509_crt_verify_chain_item;
/*
* Max size of verification chain: end-entity + intermediates + trusted root
*/
#define X509_MAX_VERIFY_CHAIN_SIZE ( MBEDTLS_X509_MAX_INTERMEDIATE_CA + 2 )
/*
* Default profile
*/
const mbedtls_x509_crt_profile mbedtls_x509_crt_profile_default = {
#if defined(MBEDTLS_TLS_DEFAULT_ALLOW_SHA1_IN_CERTIFICATES)
/* Allow SHA-1 (weak, but still safe in controlled environments) */
MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA1 ) |
#endif
/* Only SHA-2 hashes */
MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA224 ) |
MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA256 ) |
MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA384 ) |
MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA512 ),
0xFFFFFFF, /* Any PK alg */
0xFFFFFFF, /* Any curve */
2048,
};
/*
* Next-default profile
*/
const mbedtls_x509_crt_profile mbedtls_x509_crt_profile_next = {
/* Hashes from SHA-256 and above */
MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA256 ) |
MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA384 ) |
MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA512 ),
0xFFFFFFF, /* Any PK alg */
#if defined(MBEDTLS_ECP_C)
/* Curves at or above 128-bit security level */
MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_SECP256R1 ) |
MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_SECP384R1 ) |
MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_SECP521R1 ) |
MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_BP256R1 ) |
MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_BP384R1 ) |
MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_BP512R1 ) |
MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_SECP256K1 ),
#else
0,
#endif
2048,
};
/*
* NSA Suite B Profile
*/
const mbedtls_x509_crt_profile mbedtls_x509_crt_profile_suiteb = {
/* Only SHA-256 and 384 */
MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA256 ) |
MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA384 ),
/* Only ECDSA */
MBEDTLS_X509_ID_FLAG( MBEDTLS_PK_ECDSA ) |
MBEDTLS_X509_ID_FLAG( MBEDTLS_PK_ECKEY ),
#if defined(MBEDTLS_ECP_C)
/* Only NIST P-256 and P-384 */
MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_SECP256R1 ) |
MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_SECP384R1 ),
#else
0,
#endif
0,
};
/*
* Check md_alg against profile
* Return 0 if md_alg is acceptable for this profile, -1 otherwise
*/
static int x509_profile_check_md_alg( const mbedtls_x509_crt_profile *profile,
mbedtls_md_type_t md_alg )
{
if( md_alg == MBEDTLS_MD_NONE )
return -1;
if( ( profile->allowed_mds & MBEDTLS_X509_ID_FLAG( md_alg ) ) )
return 0;
return -1;
}
/*
* Check pk_alg against profile
* Return 0 if pk_alg is acceptable for this profile, -1 otherwise
*/
static int x509_profile_check_pk_alg( const mbedtls_x509_crt_profile *profile,
mbedtls_pk_type_t pk_alg )
{
if( pk_alg == MBEDTLS_PK_NONE )
return -1;
if( ( profile->allowed_pks & MBEDTLS_X509_ID_FLAG( pk_alg ) ) )
return 0;
return -1;
}
/*
* Check key against profile
* Return 0 if pk is acceptable for this profile, -1 otherwise
*/
static int x509_profile_check_key( const mbedtls_x509_crt_profile *profile,
const mbedtls_pk_context *pk )
{
const mbedtls_pk_type_t pk_alg = mbedtls_pk_get_type( pk );
#if defined(MBEDTLS_RSA_C)
if( pk_alg == MBEDTLS_PK_RSA || pk_alg == MBEDTLS_PK_RSASSA_PSS )
{
if( mbedtls_pk_get_bitlen( pk ) >= profile->rsa_min_bitlen )
return 0;
return -1;
}
#endif
#if defined(MBEDTLS_ECP_C)
if( pk_alg == MBEDTLS_PK_ECDSA ||
pk_alg == MBEDTLS_PK_ECKEY ||
pk_alg == MBEDTLS_PK_ECKEY_DH )
{
const mbedtls_ecp_group_id gid = mbedtls_pk_ec( *pk )->grp.id;
if( gid == MBEDTLS_ECP_DP_NONE )
return -1;
if( ( profile->allowed_curves & MBEDTLS_X509_ID_FLAG( gid ) ) )
return 0;
return -1;
}
#endif
return -1;
}
/*
* Return 0 if name matches wildcard, -1 otherwise
*/
static int x509_check_wildcard( const char *cn, const mbedtls_x509_buf *name )
{
size_t i;
size_t cn_idx = 0, cn_len = strlen( cn );
/* We can't have a match if there is no wildcard to match */
if( name->len < 3 || name->p[0] != '*' || name->p[1] != '.' )
return -1;
for( i = 0; i < cn_len; ++i )
{
if( cn[i] == '.' )
{
cn_idx = i;
break;
}
}
if( cn_idx == 0 )
return -1;
if( cn_len - cn_idx == name->len - 1 &&
memcasecmp( name->p + 1, cn + cn_idx, name->len - 1 ) == 0 )
{
return 0;
}
return -1;
}
/*
* Compare two X.509 strings, case-insensitive, and allowing for some encoding
* variations (but not all).
*
* Return 0 if equal, -1 otherwise.
*/
static int x509_string_cmp( const mbedtls_x509_buf *a, const mbedtls_x509_buf *b )
{
if( a->tag == b->tag &&
a->len == b->len &&
timingsafe_bcmp( a->p, b->p, b->len ) == 0 )
{
return 0;
}
if( ( a->tag == MBEDTLS_ASN1_UTF8_STRING || a->tag == MBEDTLS_ASN1_PRINTABLE_STRING ) &&
( b->tag == MBEDTLS_ASN1_UTF8_STRING || b->tag == MBEDTLS_ASN1_PRINTABLE_STRING ) &&
a->len == b->len &&
memcasecmp( a->p, b->p, b->len ) == 0 )
{
return 0;
}
return -1;
}
/*
* Compare two X.509 Names (aka rdnSequence).
*
* See RFC 5280 section 7.1, though we don't implement the whole algorithm:
* we sometimes return unequal when the full algorithm would return equal,
* but never the other way. (In particular, we don't do Unicode normalisation
* or space folding.)
*
* Return 0 if equal, -1 otherwise.
*/
int mbedtls_x509_name_cmp( const mbedtls_x509_name *a, const mbedtls_x509_name *b )
{
/* Avoid recursion, it might not be optimised by the compiler */
while( a != NULL || b != NULL )
{
if( a == NULL || b == NULL )
return -1;
/* type */
if( a->oid.tag != b->oid.tag ||
a->oid.len != b->oid.len ||
timingsafe_bcmp( a->oid.p, b->oid.p, b->oid.len ) )
{
return -1;
}
/* value */
if( x509_string_cmp( &a->val, &b->val ) )
return -1;
/* structure of the list of sets */
if( a->next_merged != b->next_merged )
return -1;
a = a->next;
b = b->next;
}
/* a == NULL == b */
return 0;
}
/*
* Reset (init or clear) a verify_chain
*/
static void x509_crt_verify_chain_reset(
mbedtls_x509_crt_verify_chain *ver_chain )
{
size_t i;
for( i = 0; i < MBEDTLS_X509_MAX_VERIFY_CHAIN_SIZE; i++ )
{
ver_chain->items[i].crt = NULL;
ver_chain->items[i].flags = (uint32_t) -1;
}
ver_chain->len = 0;
#if defined(MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK)
ver_chain->trust_ca_cb_result = NULL;
#endif /* MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK */
}
/*
* Version ::= INTEGER { v1(0), v2(1), v3(2) }
*/
static int x509_get_version( unsigned char **p,
const unsigned char *end,
int *ver )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t len;
if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | 0 ) ) )
{
if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
{
*ver = 0;
return 0;
}
return( MBEDTLS_ERR_X509_INVALID_FORMAT + ret );
}
end = *p + len;
if( ( ret = mbedtls_asn1_get_int( p, end, ver ) ) )
return( MBEDTLS_ERR_X509_INVALID_VERSION + ret );
if( *p != end )
return( MBEDTLS_ERR_X509_INVALID_VERSION +
MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
return 0;
}
/*
* Validity ::= SEQUENCE {
* notBefore Time,
* notAfter Time }
*/
static int x509_get_dates( unsigned char **p,
const unsigned char *end,
mbedtls_x509_time *from,
mbedtls_x509_time *to )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t len;
if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) )
return( MBEDTLS_ERR_X509_INVALID_DATE + ret );
end = *p + len;
if( ( ret = mbedtls_x509_get_time( p, end, from ) ) )
return ret;
if( ( ret = mbedtls_x509_get_time( p, end, to ) ) )
return ret;
if( *p != end )
return( MBEDTLS_ERR_X509_INVALID_DATE +
MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
return 0;
}
/*
* X.509 v2/v3 unique identifier (not parsed)
*/
static int x509_get_uid( unsigned char **p,
const unsigned char *end,
mbedtls_x509_buf *uid, int n )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
if( *p == end )
return 0;
uid->tag = **p;
if( ( ret = mbedtls_asn1_get_tag( p, end, &uid->len,
MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | n ) ) )
{
if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
return 0;
return( MBEDTLS_ERR_X509_INVALID_FORMAT + ret );
}
uid->p = *p;
*p += uid->len;
return 0;
}
static int x509_get_basic_constraints( unsigned char **p,
const unsigned char *end,
int *ca_istrue,
int *max_pathlen )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t len;
/*
* BasicConstraints ::= SEQUENCE {
* cA BOOLEAN DEFAULT FALSE,
* pathLenConstraint INTEGER (0..MAX) OPTIONAL }
*/
*ca_istrue = 0; /* DEFAULT FALSE */
*max_pathlen = 0; /* endless */
if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
if( *p == end )
return 0;
if( ( ret = mbedtls_asn1_get_bool( p, end, ca_istrue ) ) )
{
if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
ret = mbedtls_asn1_get_int( p, end, ca_istrue );
if( ret )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
if( *ca_istrue )
*ca_istrue = 1;
}
if( *p == end )
return 0;
if( ( ret = mbedtls_asn1_get_int( p, end, max_pathlen ) ) )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
if( *p != end )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
/* Do not accept max_pathlen equal to INT_MAX to avoid a signed integer
* overflow, which is an undefined behavior. */
if( *max_pathlen == INT_MAX )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
MBEDTLS_ERR_ASN1_INVALID_LENGTH );
(*max_pathlen)++;
return 0;
}
static int x509_get_ns_cert_type( unsigned char **p,
const unsigned char *end,
unsigned char *ns_cert_type)
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
mbedtls_x509_bitstring bs = { 0, 0, NULL };
if( ( ret = mbedtls_asn1_get_bitstring( p, end, &bs ) ) )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
if( bs.len != 1 )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
MBEDTLS_ERR_ASN1_INVALID_LENGTH );
/* Get actual bitstring */
*ns_cert_type = *bs.p;
return 0;
}
static int x509_get_key_usage( unsigned char **p,
const unsigned char *end,
unsigned int *key_usage)
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t i;
mbedtls_x509_bitstring bs = { 0, 0, NULL };
if( ( ret = mbedtls_asn1_get_bitstring( p, end, &bs ) ) )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
if( bs.len < 1 )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
MBEDTLS_ERR_ASN1_INVALID_LENGTH );
/* Get actual bitstring */
*key_usage = 0;
for( i = 0; i < bs.len && i < sizeof( unsigned int ); i++ )
{
*key_usage |= (unsigned int) bs.p[i] << (8*i);
}
return 0;
}
/*
* ExtKeyUsageSyntax ::= SEQUENCE SIZE (1..MAX) OF KeyPurposeId
*
* KeyPurposeId ::= OBJECT IDENTIFIER
*/
static int x509_get_ext_key_usage( unsigned char **p,
const unsigned char *end,
mbedtls_x509_sequence *ext_key_usage)
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
if( ( ret = mbedtls_asn1_get_sequence_of( p, end, ext_key_usage, MBEDTLS_ASN1_OID ) ) )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
/* Sequence length must be >= 1 */
if( ext_key_usage->buf.p == NULL )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
MBEDTLS_ERR_ASN1_INVALID_LENGTH );
return 0;
}
/*
* SubjectAltName ::= GeneralNames
*
* GeneralNames ::= SEQUENCE SIZE (1..MAX) OF GeneralName
*
* GeneralName ::= CHOICE {
* otherName [0] OtherName,
* rfc822Name [1] IA5String,
* dNSName [2] IA5String,
* x400Address [3] ORAddress,
* directoryName [4] Name,
* ediPartyName [5] EDIPartyName,
* uniformResourceIdentifier [6] IA5String,
* iPAddress [7] OCTET STRING,
* registeredID [8] OBJECT IDENTIFIER }
*
* OtherName ::= SEQUENCE {
* type-id OBJECT IDENTIFIER,
* value [0] EXPLICIT ANY DEFINED BY type-id }
*
* EDIPartyName ::= SEQUENCE {
* nameAssigner [0] DirectoryString OPTIONAL,
* partyName [1] DirectoryString }
*
* NOTE: we list all types, but only use dNSName and otherName
* of type HwModuleName, as defined in RFC 4108, at this point.
*/
static int x509_get_subject_alt_name( unsigned char **p,
const unsigned char *end,
mbedtls_x509_sequence *subject_alt_name )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t len, tag_len;
mbedtls_asn1_buf *buf;
unsigned char tag;
mbedtls_asn1_sequence *cur = subject_alt_name;
/* Get main sequence tag */
if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
if( *p + len != end )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
while( *p < end )
{
mbedtls_x509_subject_alternative_name dummy_san_buf;
mbedtls_platform_zeroize( &dummy_san_buf, sizeof( dummy_san_buf ) );
tag = **p;
(*p)++;
if( ( ret = mbedtls_asn1_get_len( p, end, &tag_len ) ) )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
if( ( tag & MBEDTLS_ASN1_TAG_CLASS_MASK ) !=
MBEDTLS_ASN1_CONTEXT_SPECIFIC )
{
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
}
/*
* Check that the SAN is structured correctly.
*/
ret = mbedtls_x509_parse_subject_alt_name( &(cur->buf), &dummy_san_buf );
/*
* In case the extension is malformed, return an error,
* and clear the allocated sequences.
*/
if( ret && ret != MBEDTLS_ERR_X509_FEATURE_UNAVAILABLE )
{
mbedtls_x509_sequence *seq_cur = subject_alt_name->next;
mbedtls_x509_sequence *seq_prv;
while( seq_cur != NULL )
{
seq_prv = seq_cur;
seq_cur = seq_cur->next;
mbedtls_platform_zeroize( seq_prv,
sizeof( mbedtls_x509_sequence ) );
mbedtls_free( seq_prv );
}
subject_alt_name->next = NULL;
return ret;
}
/* Allocate and assign next pointer */
if( cur->buf.p != NULL )
{
if( cur->next != NULL )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS );
cur->next = mbedtls_calloc( 1, sizeof( mbedtls_asn1_sequence ) );
if( cur->next == NULL )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
MBEDTLS_ERR_ASN1_ALLOC_FAILED );
cur = cur->next;
}
buf = &(cur->buf);
buf->tag = tag;
buf->p = *p;
buf->len = tag_len;
*p += buf->len;
}
/* Set final sequence entry's next pointer to NULL */
cur->next = NULL;
if( *p != end )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
return 0;
}
/*
* id-ce-certificatePolicies OBJECT IDENTIFIER ::= { id-ce 32 }
*
* anyPolicy OBJECT IDENTIFIER ::= { id-ce-certificatePolicies 0 }
*
* certificatePolicies ::= SEQUENCE SIZE (1..MAX) OF PolicyInformation
*
* PolicyInformation ::= SEQUENCE {
* policyIdentifier CertPolicyId,
* policyQualifiers SEQUENCE SIZE (1..MAX) OF
* PolicyQualifierInfo OPTIONAL }
*
* CertPolicyId ::= OBJECT IDENTIFIER
*
* PolicyQualifierInfo ::= SEQUENCE {
* policyQualifierId PolicyQualifierId,
* qualifier ANY DEFINED BY policyQualifierId }
*
* -- policyQualifierIds for Internet policy qualifiers
*
* id-qt OBJECT IDENTIFIER ::= { id-pkix 2 }
* id-qt-cps OBJECT IDENTIFIER ::= { id-qt 1 }
* id-qt-unotice OBJECT IDENTIFIER ::= { id-qt 2 }
*
* PolicyQualifierId ::= OBJECT IDENTIFIER ( id-qt-cps | id-qt-unotice )
*
* Qualifier ::= CHOICE {
* cPSuri CPSuri,
* userNotice UserNotice }
*
* CPSuri ::= IA5String
*
* UserNotice ::= SEQUENCE {
* noticeRef NoticeReference OPTIONAL,
* explicitText DisplayText OPTIONAL }
*
* NoticeReference ::= SEQUENCE {
* organization DisplayText,
* noticeNumbers SEQUENCE OF INTEGER }
*
* DisplayText ::= CHOICE {
* ia5String IA5String (SIZE (1..200)),
* visibleString VisibleString (SIZE (1..200)),
* bmpString BMPString (SIZE (1..200)),
* utf8String UTF8String (SIZE (1..200)) }
*
* NOTE: we only parse and use anyPolicy without qualifiers at this point
* as defined in RFC 5280.
*/
static int x509_get_certificate_policies( unsigned char **p,
const unsigned char *end,
mbedtls_x509_sequence *certificate_policies )
{
int ret, parse_ret = 0;
size_t len;
mbedtls_asn1_buf *buf;
mbedtls_asn1_sequence *cur = certificate_policies;
/* Get main sequence tag */
ret = mbedtls_asn1_get_tag( p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE );
if( ret )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
if( *p + len != end )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
/*
* Cannot be an empty sequence.
*/
if( len == 0 )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
while( *p < end )
{
mbedtls_x509_buf policy_oid;
const unsigned char *policy_end;
/*
* Get the policy sequence
*/
if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
policy_end = *p + len;
if( ( ret = mbedtls_asn1_get_tag( p, policy_end, &len,
MBEDTLS_ASN1_OID ) ) )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
policy_oid.tag = MBEDTLS_ASN1_OID;
policy_oid.len = len;
policy_oid.p = *p;
/*
* Only AnyPolicy is currently supported when enforcing policy.
*/
if( MBEDTLS_OID_CMP( MBEDTLS_OID_ANY_POLICY, &policy_oid ) )
{
/*
* Set the parsing return code but continue parsing, in case this
* extension is critical and MBEDTLS_X509_ALLOW_UNSUPPORTED_CRITICAL_EXTENSION
* is configured.
*/
parse_ret = MBEDTLS_ERR_X509_FEATURE_UNAVAILABLE;
}
/* Allocate and assign next pointer */
if( cur->buf.p != NULL )
{
if( cur->next != NULL )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS );
cur->next = mbedtls_calloc( 1, sizeof( mbedtls_asn1_sequence ) );
if( cur->next == NULL )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
MBEDTLS_ERR_ASN1_ALLOC_FAILED );
cur = cur->next;
}
buf = &( cur->buf );
buf->tag = policy_oid.tag;
buf->p = policy_oid.p;
buf->len = policy_oid.len;
*p += len;
/*
* If there is an optional qualifier, then *p < policy_end
* Check the Qualifier len to verify it doesn't exceed policy_end.
*/
if( *p < policy_end )
{
if( ( ret = mbedtls_asn1_get_tag( p, policy_end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
/*
* Skip the optional policy qualifiers.
*/
*p += len;
}
if( *p != policy_end )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
}
/* Set final sequence entry's next pointer to NULL */
cur->next = NULL;
if( *p != end )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
return( parse_ret );
}
/*
* X.509 v3 extensions
*/
static int x509_get_crt_ext( unsigned char **p,
const unsigned char *end,
mbedtls_x509_crt *crt,
mbedtls_x509_crt_ext_cb_t cb,
void *p_ctx )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t len;
unsigned char *end_ext_data, *start_ext_octet, *end_ext_octet;
if( *p == end )
return 0;
if( ( ret = mbedtls_x509_get_ext( p, end, &crt->v3_ext, 3 ) ) )
return ret;
end = crt->v3_ext.p + crt->v3_ext.len;
while( *p < end )
{
/*
* Extension ::= SEQUENCE {
* extnID OBJECT IDENTIFIER,
* critical BOOLEAN DEFAULT FALSE,
* extnValue OCTET STRING }
*/
mbedtls_x509_buf extn_oid = {0, 0, NULL};
int is_critical = 0; /* DEFAULT FALSE */
int ext_type = 0;
if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
end_ext_data = *p + len;
/* Get extension ID */
if( ( ret = mbedtls_asn1_get_tag( p, end_ext_data, &extn_oid.len,
MBEDTLS_ASN1_OID ) ) )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
extn_oid.tag = MBEDTLS_ASN1_OID;
extn_oid.p = *p;
*p += extn_oid.len;
/* Get optional critical */
if( ( ret = mbedtls_asn1_get_bool( p, end_ext_data, &is_critical ) ) &&
( ret != MBEDTLS_ERR_ASN1_UNEXPECTED_TAG ) )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
/* Data should be octet string type */
if( ( ret = mbedtls_asn1_get_tag( p, end_ext_data, &len,
MBEDTLS_ASN1_OCTET_STRING ) ) )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
start_ext_octet = *p;
end_ext_octet = *p + len;
if( end_ext_octet != end_ext_data )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
/*
* Detect supported extensions
*/
ret = mbedtls_oid_get_x509_ext_type( &extn_oid, &ext_type );
if( ret )
{
/* Give the callback (if any) a chance to handle the extension */
if( cb != NULL )
{
ret = cb( p_ctx, crt, &extn_oid, is_critical, *p, end_ext_octet );
if( ret && is_critical )
return ret;
*p = end_ext_octet;
continue;
}
/* No parser found, skip extension */
*p = end_ext_octet;
#if !defined(MBEDTLS_X509_ALLOW_UNSUPPORTED_CRITICAL_EXTENSION)
if( is_critical )
{
/* Data is marked as critical: fail */
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
}
#endif
continue;
}
/* Forbid repeated extensions */
if( ( crt->ext_types & ext_type ) )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS );
crt->ext_types |= ext_type;
switch( ext_type )
{
case MBEDTLS_X509_EXT_BASIC_CONSTRAINTS:
/* Parse basic constraints */
if( ( ret = x509_get_basic_constraints( p, end_ext_octet,
&crt->ca_istrue, &crt->max_pathlen ) ) )
return ret;
break;
case MBEDTLS_X509_EXT_KEY_USAGE:
/* Parse key usage */
if( ( ret = x509_get_key_usage( p, end_ext_octet,
&crt->key_usage ) ) )
return ret;
break;
case MBEDTLS_X509_EXT_EXTENDED_KEY_USAGE:
/* Parse extended key usage */
if( ( ret = x509_get_ext_key_usage( p, end_ext_octet,
&crt->ext_key_usage ) ) )
return ret;
break;
case MBEDTLS_X509_EXT_SUBJECT_ALT_NAME:
/* Parse subject alt name */
if( ( ret = x509_get_subject_alt_name( p, end_ext_octet,
&crt->subject_alt_names ) ) )
return ret;
break;
case MBEDTLS_X509_EXT_NS_CERT_TYPE:
/* Parse netscape certificate type */
if( ( ret = x509_get_ns_cert_type( p, end_ext_octet,
&crt->ns_cert_type ) ) )
return ret;
break;
case MBEDTLS_OID_X509_EXT_CERTIFICATE_POLICIES:
/* Parse certificate policies type */
if( ( ret = x509_get_certificate_policies( p, end_ext_octet,
&crt->certificate_policies ) ) )
{
/* Give the callback (if any) a chance to handle the extension
* if it contains unsupported policies */
if( ret == MBEDTLS_ERR_X509_FEATURE_UNAVAILABLE && cb != NULL &&
cb( p_ctx, crt, &extn_oid, is_critical,
start_ext_octet, end_ext_octet ) == 0 )
break;
#if !defined(MBEDTLS_X509_ALLOW_UNSUPPORTED_CRITICAL_EXTENSION)
if( is_critical )
return ret;
else
#endif
/*
* If MBEDTLS_ERR_X509_FEATURE_UNAVAILABLE is returned, then we
* cannot interpret or enforce the policy. However, it is up to
* the user to choose how to enforce the policies,
* unless the extension is critical.
*/
if( ret != MBEDTLS_ERR_X509_FEATURE_UNAVAILABLE )
return ret;
}
break;
default:
/*
* If this is a non-critical extension, which the oid layer
* supports, but there isn't an x509 parser for it,
* skip the extension.
*/
#if !defined(MBEDTLS_X509_ALLOW_UNSUPPORTED_CRITICAL_EXTENSION)
if( is_critical )
return( MBEDTLS_ERR_X509_FEATURE_UNAVAILABLE );
else
#endif
*p = end_ext_octet;
}
}
if( *p != end )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
return 0;
}
/*
* Parse and fill a single X.509 certificate in DER format
*/
static int x509_crt_parse_der_core( mbedtls_x509_crt *crt,
const unsigned char *buf,
size_t buflen,
int make_copy,
mbedtls_x509_crt_ext_cb_t cb,
void *p_ctx )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t len;
unsigned char *p, *end, *crt_end;
mbedtls_x509_buf sig_params1, sig_params2, sig_oid2;
mbedtls_platform_zeroize( &sig_params1, sizeof( mbedtls_x509_buf ) );
mbedtls_platform_zeroize( &sig_params2, sizeof( mbedtls_x509_buf ) );
mbedtls_platform_zeroize( &sig_oid2, sizeof( mbedtls_x509_buf ) );
/*
* Check for valid input
*/
if( crt == NULL || buf == NULL )
return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
/* Use the original buffer until we figure out actual length. */
p = (unsigned char*) buf;
len = buflen;
end = p + len;
/*
* Certificate ::= SEQUENCE {
* tbsCertificate TBSCertificate,
* signatureAlgorithm AlgorithmIdentifier,
* signatureValue BIT STRING }
*/
if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) )
{
mbedtls_x509_crt_free( crt );
return( MBEDTLS_ERR_X509_INVALID_FORMAT );
}
end = crt_end = p + len;
crt->raw.len = crt_end - buf;
if( make_copy )
{
/* Create and populate a new buffer for the raw field. */
crt->raw.p = p = mbedtls_calloc( 1, crt->raw.len );
if( crt->raw.p == NULL )
return( MBEDTLS_ERR_X509_ALLOC_FAILED );
memcpy( crt->raw.p, buf, crt->raw.len );
crt->own_buffer = 1;
p += crt->raw.len - len;
end = crt_end = p + len;
}
else
{
crt->raw.p = (unsigned char*) buf;
crt->own_buffer = 0;
}
/*
* TBSCertificate ::= SEQUENCE {
*/
crt->tbs.p = p;
if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) )
{
mbedtls_x509_crt_free( crt );
return( MBEDTLS_ERR_X509_INVALID_FORMAT + ret );
}
end = p + len;
crt->tbs.len = end - crt->tbs.p;
/*
* Version ::= INTEGER { v1(0), v2(1), v3(2) }
*
* CertificateSerialNumber ::= INTEGER
*
* signature AlgorithmIdentifier
*/
if( ( ret = x509_get_version( &p, end, &crt->version ) ) ||
( ret = mbedtls_x509_get_serial( &p, end, &crt->serial ) ) ||
( ret = mbedtls_x509_get_alg( &p, end, &crt->sig_oid,
&sig_params1 ) ) )
{
mbedtls_x509_crt_free( crt );
return ret;
}
if( crt->version < 0 || crt->version > 2 )
{
mbedtls_x509_crt_free( crt );
return( MBEDTLS_ERR_X509_UNKNOWN_VERSION );
}
crt->version++;
if( ( ret = mbedtls_x509_get_sig_alg( &crt->sig_oid, &sig_params1,
&crt->sig_md, &crt->sig_pk,
&crt->sig_opts ) ) )
{
mbedtls_x509_crt_free( crt );
return ret;
}
/*
* issuer Name
*/
crt->issuer_raw.p = p;
if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) )
{
mbedtls_x509_crt_free( crt );
return( MBEDTLS_ERR_X509_INVALID_FORMAT + ret );
}
if( ( ret = mbedtls_x509_get_name( &p, p + len, &crt->issuer ) ) )
{
mbedtls_x509_crt_free( crt );
return ret;
}
crt->issuer_raw.len = p - crt->issuer_raw.p;
/*
* Validity ::= SEQUENCE {
* notBefore Time,
* notAfter Time }
*
*/
if( ( ret = x509_get_dates( &p, end, &crt->valid_from,
&crt->valid_to ) ) )
{
mbedtls_x509_crt_free( crt );
return ret;
}
/*
* subject Name
*/
crt->subject_raw.p = p;
if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) )
{
mbedtls_x509_crt_free( crt );
return( MBEDTLS_ERR_X509_INVALID_FORMAT + ret );
}
if( len && ( ret = mbedtls_x509_get_name( &p, p + len, &crt->subject ) ) )
{
mbedtls_x509_crt_free( crt );
return ret;
}
crt->subject_raw.len = p - crt->subject_raw.p;
/*
* SubjectPublicKeyInfo
*/
crt->pk_raw.p = p;
if( ( ret = mbedtls_pk_parse_subpubkey( &p, end, &crt->pk ) ) )
{
mbedtls_x509_crt_free( crt );
return ret;
}
crt->pk_raw.len = p - crt->pk_raw.p;
/*
* issuerUniqueID [1] IMPLICIT UniqueIdentifier OPTIONAL,
* -- If present, version shall be v2 or v3
* subjectUniqueID [2] IMPLICIT UniqueIdentifier OPTIONAL,
* -- If present, version shall be v2 or v3
* extensions [3] EXPLICIT Extensions OPTIONAL
* -- If present, version shall be v3
*/
if( crt->version == 2 || crt->version == 3 )
{
ret = x509_get_uid( &p, end, &crt->issuer_id, 1 );
if( ret )
{
mbedtls_x509_crt_free( crt );
return ret;
}
}
if( crt->version == 2 || crt->version == 3 )
{
ret = x509_get_uid( &p, end, &crt->subject_id, 2 );
if( ret )
{
mbedtls_x509_crt_free( crt );
return ret;
}
}
#if !defined(MBEDTLS_X509_ALLOW_EXTENSIONS_NON_V3)
if( crt->version == 3 )
#endif
{
ret = x509_get_crt_ext( &p, end, crt, cb, p_ctx );
if( ret )
{
mbedtls_x509_crt_free( crt );
return ret;
}
}
if( p != end )
{
mbedtls_x509_crt_free( crt );
return( MBEDTLS_ERR_X509_INVALID_FORMAT +
MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
}
end = crt_end;
/*
* }
* -- end of TBSCertificate
*
* signatureAlgorithm AlgorithmIdentifier,
* signatureValue BIT STRING
*/
if( ( ret = mbedtls_x509_get_alg( &p, end, &sig_oid2, &sig_params2 ) ) )
{
mbedtls_x509_crt_free( crt );
return ret;
}
if( crt->sig_oid.len != sig_oid2.len ||
timingsafe_bcmp( crt->sig_oid.p, sig_oid2.p, crt->sig_oid.len ) ||
sig_params1.tag != sig_params2.tag ||
sig_params1.len != sig_params2.len ||
( sig_params1.len &&
timingsafe_bcmp( sig_params1.p, sig_params2.p, sig_params1.len ) ) )
{
mbedtls_x509_crt_free( crt );
return( MBEDTLS_ERR_X509_SIG_MISMATCH );
}
if( ( ret = mbedtls_x509_get_sig( &p, end, &crt->sig ) ) )
{
mbedtls_x509_crt_free( crt );
return ret;
}
if( p != end )
{
mbedtls_x509_crt_free( crt );
return( MBEDTLS_ERR_X509_INVALID_FORMAT +
MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
}
return 0;
}
/*
* Parse one X.509 certificate in DER format from a buffer and add them to a
* chained list
*/
static int mbedtls_x509_crt_parse_der_internal( mbedtls_x509_crt *chain,
const unsigned char *buf,
size_t buflen,
int make_copy,
mbedtls_x509_crt_ext_cb_t cb,
void *p_ctx )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
mbedtls_x509_crt *crt = chain, *prev = NULL;
/*
* Check for valid input
*/
if( crt == NULL || buf == NULL )
return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
while( crt->version && crt->next != NULL )
{
prev = crt;
crt = crt->next;
}
/*
* Add new certificate on the end of the chain if needed.
*/
if( crt->version && crt->next == NULL )
{
crt->next = mbedtls_calloc( 1, sizeof( mbedtls_x509_crt ) );
if( crt->next == NULL )
return( MBEDTLS_ERR_X509_ALLOC_FAILED );
prev = crt;
mbedtls_x509_crt_init( crt->next );
crt = crt->next;
}
ret = x509_crt_parse_der_core( crt, buf, buflen, make_copy, cb, p_ctx );
if( ret )
{
if( prev )
prev->next = NULL;
if( crt != chain )
mbedtls_free( crt );
return ret;
}
return 0;
}
/**
* \brief Parse a single DER formatted certificate and add it
* to the end of the provided chained list. This is a
* variant of mbedtls_x509_crt_parse_der() which takes
* temporary ownership of the CRT buffer until the CRT
* is destroyed.
*
* \param chain The pointer to the start of the CRT chain to attach to.
* When parsing the first CRT in a chain, this should point
* to an instance of ::mbedtls_x509_crt initialized through
* mbedtls_x509_crt_init().
* \param buf The address of the readable buffer holding the DER encoded
* certificate to use. On success, this buffer must be
* retained and not be changed for the liftetime of the
* CRT chain \p chain, that is, until \p chain is destroyed
* through a call to mbedtls_x509_crt_free().
* \param buflen The size in Bytes of \p buf.
*
* \note This call is functionally equivalent to
* mbedtls_x509_crt_parse_der(), but it avoids creating a
* copy of the input buffer at the cost of stronger lifetime
* constraints. This is useful in constrained environments
* where duplication of the CRT cannot be tolerated.
*
* \return \c 0 if successful.
* \return A negative error code on failure.
*/
int mbedtls_x509_crt_parse_der_nocopy( mbedtls_x509_crt *chain,
const unsigned char *buf,
size_t buflen )
{
return( mbedtls_x509_crt_parse_der_internal( chain, buf, buflen, 0, NULL, NULL ) );
}
/**
* \brief Parse a single DER formatted certificate and add it
* to the end of the provided chained list.
*
* \param chain The pointer to the start of the CRT chain to attach to.
* When parsing the first CRT in a chain, this should point
* to an instance of ::mbedtls_x509_crt initialized through
* mbedtls_x509_crt_init().
* \param buf The buffer holding the DER encoded certificate.
* \param buflen The size in Bytes of \p buf.
* \param make_copy When not zero this function makes an internal copy of the
* CRT buffer \p buf. In particular, \p buf may be destroyed
* or reused after this call returns.
* When zero this function avoids duplicating the CRT buffer
* by taking temporary ownership thereof until the CRT
* is destroyed (like mbedtls_x509_crt_parse_der_nocopy())
* \param cb A callback invoked for every unsupported certificate
* extension.
* \param p_ctx An opaque context passed to the callback.
*
* \note This call is functionally equivalent to
* mbedtls_x509_crt_parse_der(), and/or
* mbedtls_x509_crt_parse_der_nocopy()
* but it calls the callback with every unsupported
* certificate extension and additionally the
* "certificate policies" extension if it contains any
* unsupported certificate policies.
* The callback must return a negative error code if it
* does not know how to handle such an extension.
* When the callback fails to parse a critical extension
* mbedtls_x509_crt_parse_der_with_ext_cb() also fails.
* When the callback fails to parse a non critical extension
* mbedtls_x509_crt_parse_der_with_ext_cb() simply skips
* the extension and continues parsing.
* Future versions of the library may invoke the callback
* in other cases, if and when the need arises.
*
* \return \c 0 if successful.
* \return A negative error code on failure.
*/
int mbedtls_x509_crt_parse_der_with_ext_cb( mbedtls_x509_crt *chain,
const unsigned char *buf,
size_t buflen,
int make_copy,
mbedtls_x509_crt_ext_cb_t cb,
void *p_ctx )
{
return( mbedtls_x509_crt_parse_der_internal( chain, buf, buflen, make_copy, cb, p_ctx ) );
}
/**
* \brief Parse a single DER formatted certificate and add it
* to the end of the provided chained list.
*
* \param chain The pointer to the start of the CRT chain to attach to.
* When parsing the first CRT in a chain, this should point
* to an instance of ::mbedtls_x509_crt initialized through
* mbedtls_x509_crt_init().
* \param buf The buffer holding the DER encoded certificate.
* \param buflen The size in Bytes of \p buf.
*
* \note This function makes an internal copy of the CRT buffer
* \p buf. In particular, \p buf may be destroyed or reused
* after this call returns. To avoid duplicating the CRT
* buffer (at the cost of stricter lifetime constraints),
* use mbedtls_x509_crt_parse_der_nocopy() instead.
*
* \return \c 0 if successful.
* \return A negative error code on failure.
*/
int mbedtls_x509_crt_parse_der( mbedtls_x509_crt *chain,
const unsigned char *buf,
size_t buflen )
{
return( mbedtls_x509_crt_parse_der_internal( chain, buf, buflen, 1, NULL, NULL ) );
}
/**
* \brief Parse one DER-encoded or one or more concatenated PEM-encoded
* certificates and add them to the chained list.
*
* For CRTs in PEM encoding, the function parses permissively:
* if at least one certificate can be parsed, the function
* returns the number of certificates for which parsing failed
* (hence \c 0 if all certificates were parsed successfully).
* If no certificate could be parsed, the function returns
* the first (negative) error encountered during parsing.
*
* PEM encoded certificates may be interleaved by other data
* such as human readable descriptions of their content, as
* long as the certificates are enclosed in the PEM specific
* '-----{BEGIN/END} CERTIFICATE-----' delimiters.
*
* \param chain The chain to which to add the parsed certificates.
* \param buf The buffer holding the certificate data in PEM or DER format.
* For certificates in PEM encoding, this may be a concatenation
* of multiple certificates; for DER encoding, the buffer must
* comprise exactly one certificate.
* \param buflen The size of \p buf, including the terminating \c NULL byte
* in case of PEM encoded data.
*
* \return \c 0 if all certificates were parsed successfully.
* \return The (positive) number of certificates that couldn't
* be parsed if parsing was partly successful (see above).
* \return A negative X509 or PEM error code otherwise.
*
*/
int mbedtls_x509_crt_parse( mbedtls_x509_crt *chain,
const unsigned char *buf,
size_t buflen )
{
#if defined(MBEDTLS_PEM_PARSE_C)
int success = 0, first_error = 0, total_failed = 0;
int buf_format = MBEDTLS_X509_FORMAT_DER;
#endif
/*
* Check for valid input
*/
if( chain == NULL || buf == NULL )
return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
/*
* Determine buffer content. Buffer contains either one DER certificate or
* one or more PEM certificates.
*/
#if defined(MBEDTLS_PEM_PARSE_C)
if( buflen && buf[buflen - 1] == '\0' &&
strstr( (const char *) buf, "-----BEGIN CERTIFICATE-----" ) != NULL )
{
buf_format = MBEDTLS_X509_FORMAT_PEM;
}
if( buf_format == MBEDTLS_X509_FORMAT_DER )
return mbedtls_x509_crt_parse_der( chain, buf, buflen );
#else
return mbedtls_x509_crt_parse_der( chain, buf, buflen );
#endif
#if defined(MBEDTLS_PEM_PARSE_C)
if( buf_format == MBEDTLS_X509_FORMAT_PEM )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
mbedtls_pem_context pem;
/* 1 rather than 0 since the terminating NULL byte is counted in */
while( buflen > 1 )
{
size_t use_len;
mbedtls_pem_init( &pem );
/* If we get there, we know the string is null-terminated */
ret = mbedtls_pem_read_buffer( &pem,
"-----BEGIN CERTIFICATE-----",
"-----END CERTIFICATE-----",
buf, NULL, 0, &use_len );
if( ret == 0 )
{
/*
* Was PEM encoded
*/
buflen -= use_len;
buf += use_len;
}
else if( ret == MBEDTLS_ERR_PEM_BAD_INPUT_DATA )
{
return ret;
}
else if( ret != MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
{
mbedtls_pem_free( &pem );
/*
* PEM header and footer were found
*/
buflen -= use_len;
buf += use_len;
if( first_error == 0 )
first_error = ret;
total_failed++;
continue;
}
else
break;
ret = mbedtls_x509_crt_parse_der( chain, pem.buf, pem.buflen );
mbedtls_pem_free( &pem );
if( ret )
{
/*
* Quit parsing on a memory error
*/
if( ret == MBEDTLS_ERR_X509_ALLOC_FAILED )
return ret;
if( first_error == 0 )
first_error = ret;
total_failed++;
continue;
}
success = 1;
}
}
if( success )
return( total_failed );
else if( first_error )
return( first_error );
else
return( MBEDTLS_ERR_X509_CERT_UNKNOWN_FORMAT );
#endif /* MBEDTLS_PEM_PARSE_C */
}
/**
* \brief Load one or more certificates and add them
* to the chained list. Parses permissively. If some
* certificates can be parsed, the result is the number
* of failed certificates it encountered. If none complete
* correctly, the first error is returned.
*
* \param chain points to the start of the chain
* \param path filename to read the certificates from
*
* \return 0 if all certificates parsed successfully, a positive number
* if partly successful or a specific X509 or PEM error code
*/
int mbedtls_x509_crt_parse_file( mbedtls_x509_crt *chain, const char *path )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t n;
unsigned char *buf;
if( ( ret = mbedtls_pk_load_file( path, &buf, &n ) ) )
return ret;
ret = mbedtls_x509_crt_parse( chain, buf, n );
mbedtls_platform_zeroize( buf, n );
mbedtls_free( buf );
return ret;
}
/**
* \brief Load one or more certificate files from a path and add them
* to the chained list. Parses permissively. If some
* certificates can be parsed, the result is the number
* of failed certificates it encountered. If none complete
* correctly, the first error is returned.
*
* \param chain points to the start of the chain
* \param path directory / folder to read the certificate files from
*
* \return 0 if all certificates parsed successfully, a positive number
* if partly successful or a specific X509 or PEM error code
*/
int mbedtls_x509_crt_parse_path( mbedtls_x509_crt *chain, const char *path )
{
int ret = 0;
int t_ret;
int snp_ret;
struct stat sb;
struct dirent *entry;
char entry_name[MBEDTLS_X509_MAX_FILE_PATH_LEN];
DIR *dir = opendir( path );
if( dir == NULL )
return( MBEDTLS_ERR_X509_FILE_IO_ERROR );
mbedtls_platform_zeroize( &sb, sizeof( sb ) );
while( ( entry = readdir( dir ) ) != NULL )
{
snp_ret = mbedtls_snprintf( entry_name, sizeof entry_name,
"%s/%s", path, entry->d_name );
if( snp_ret < 0 || (size_t)snp_ret >= sizeof entry_name )
{
ret = MBEDTLS_ERR_X509_BUFFER_TOO_SMALL;
goto cleanup;
}
else if( stat( entry_name, &sb ) == -1 )
{
ret = MBEDTLS_ERR_X509_FILE_IO_ERROR;
goto cleanup;
}
if( !S_ISREG( sb.st_mode ) )
continue;
// Ignore parse errors
//
t_ret = mbedtls_x509_crt_parse_file( chain, entry_name );
if( t_ret < 0 )
ret++;
else
ret += t_ret;
}
cleanup:
closedir( dir );
return ret;
}
/*
* OtherName ::= SEQUENCE {
* type-id OBJECT IDENTIFIER,
* value [0] EXPLICIT ANY DEFINED BY type-id }
*
* HardwareModuleName ::= SEQUENCE {
* hwType OBJECT IDENTIFIER,
* hwSerialNum OCTET STRING }
*
* NOTE: we currently only parse and use otherName of type HwModuleName,
* as defined in RFC 4108.
*/
static int x509_get_other_name( const mbedtls_x509_buf *subject_alt_name,
mbedtls_x509_san_other_name *other_name )
{
int ret = 0;
size_t len;
unsigned char *p = subject_alt_name->p;
const unsigned char *end = p + subject_alt_name->len;
mbedtls_x509_buf cur_oid;
if( ( subject_alt_name->tag &
( MBEDTLS_ASN1_TAG_CLASS_MASK | MBEDTLS_ASN1_TAG_VALUE_MASK ) ) !=
( MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_X509_SAN_OTHER_NAME ) )
{
/*
* The given subject alternative name is not of type "othername".
*/
return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
}
if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
MBEDTLS_ASN1_OID ) ) )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
cur_oid.tag = MBEDTLS_ASN1_OID;
cur_oid.p = p;
cur_oid.len = len;
/*
* Only HwModuleName is currently supported.
*/
if( MBEDTLS_OID_CMP( MBEDTLS_OID_ON_HW_MODULE_NAME, &cur_oid ) )
{
return( MBEDTLS_ERR_X509_FEATURE_UNAVAILABLE );
}
if( p + len >= end )
{
mbedtls_platform_zeroize( other_name, sizeof( *other_name ) );
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
}
p += len;
if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_CONTEXT_SPECIFIC ) ) )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
if( ( ret = mbedtls_asn1_get_tag( &p, end, &len, MBEDTLS_ASN1_OID ) ) )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
other_name->value.hardware_module_name.oid.tag = MBEDTLS_ASN1_OID;
other_name->value.hardware_module_name.oid.p = p;
other_name->value.hardware_module_name.oid.len = len;
if( p + len >= end )
{
mbedtls_platform_zeroize( other_name, sizeof( *other_name ) );
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
}
p += len;
if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
MBEDTLS_ASN1_OCTET_STRING ) ) )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
other_name->value.hardware_module_name.val.tag = MBEDTLS_ASN1_OCTET_STRING;
other_name->value.hardware_module_name.val.p = p;
other_name->value.hardware_module_name.val.len = len;
p += len;
if( p != end )
{
mbedtls_platform_zeroize( other_name,
sizeof( *other_name ) );
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
}
return 0;
}
static int x509_info_subject_alt_name( char **buf, size_t *size,
const mbedtls_x509_sequence
*subject_alt_name,
const char *prefix )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t n = *size;
char *p = *buf;
const mbedtls_x509_sequence *cur = subject_alt_name;
mbedtls_x509_subject_alternative_name san;
int parse_ret;
while( cur != NULL )
{
mbedtls_platform_zeroize( &san, sizeof( san ) );
parse_ret = mbedtls_x509_parse_subject_alt_name( &cur->buf, &san );
if( parse_ret )
{
if( parse_ret == MBEDTLS_ERR_X509_FEATURE_UNAVAILABLE )
{
ret = mbedtls_snprintf( p, n, "\n%s <unsupported>", prefix );
MBEDTLS_X509_SAFE_SNPRINTF;
}
else
{
ret = mbedtls_snprintf( p, n, "\n%s <malformed>", prefix );
MBEDTLS_X509_SAFE_SNPRINTF;
}
cur = cur->next;
continue;
}
switch( san.type )
{
/*
* otherName
*/
case MBEDTLS_X509_SAN_OTHER_NAME:
{
mbedtls_x509_san_other_name *other_name = &san.san.other_name;
ret = mbedtls_snprintf( p, n, "\n%s otherName :", prefix );
MBEDTLS_X509_SAFE_SNPRINTF;
if( MBEDTLS_OID_CMP( MBEDTLS_OID_ON_HW_MODULE_NAME,
&other_name->value.hardware_module_name.oid ) )
{
ret = mbedtls_snprintf( p, n, "\n%s hardware module name :", prefix );
MBEDTLS_X509_SAFE_SNPRINTF;
ret = mbedtls_snprintf( p, n, "\n%s hardware type : ", prefix );
MBEDTLS_X509_SAFE_SNPRINTF;
ret = mbedtls_oid_get_numeric_string( p, n, &other_name->value.hardware_module_name.oid );
MBEDTLS_X509_SAFE_SNPRINTF;
ret = mbedtls_snprintf( p, n, "\n%s hardware serial number : ", prefix );
MBEDTLS_X509_SAFE_SNPRINTF;
if( other_name->value.hardware_module_name.val.len >= n )
{
*p = '\0';
return( MBEDTLS_ERR_X509_BUFFER_TOO_SMALL );
}
memcpy( p, other_name->value.hardware_module_name.val.p,
other_name->value.hardware_module_name.val.len );
p += other_name->value.hardware_module_name.val.len;
n -= other_name->value.hardware_module_name.val.len;
}/* MBEDTLS_OID_ON_HW_MODULE_NAME */
}
break;
/*
* dNSName
*/
case MBEDTLS_X509_SAN_DNS_NAME: {
ret = mbedtls_snprintf( p, n, "\n%s dNSName : ", prefix );
MBEDTLS_X509_SAFE_SNPRINTF;
if( san.san.unstructured_name.len >= n ) {
*p = '\0';
return( MBEDTLS_ERR_X509_BUFFER_TOO_SMALL );
}
memcpy( p, san.san.unstructured_name.p, san.san.unstructured_name.len );
p += san.san.unstructured_name.len;
n -= san.san.unstructured_name.len;
}
break;
/*
* rfc822Name
*/
case MBEDTLS_X509_SAN_RFC822_NAME: {
ret = mbedtls_snprintf( p, n, "\n%s rfc822Name : ", prefix );
MBEDTLS_X509_SAFE_SNPRINTF;
if( san.san.unstructured_name.len >= n ) {
*p = '\0';
return( MBEDTLS_ERR_X509_BUFFER_TOO_SMALL );
}
memcpy( p, san.san.unstructured_name.p, san.san.unstructured_name.len );
p += san.san.unstructured_name.len;
n -= san.san.unstructured_name.len;
}
break;
/*
* uniformResourceIdentifier
*/
case MBEDTLS_X509_SAN_UNIFORM_RESOURCE_IDENTIFIER: {
ret = mbedtls_snprintf( p, n, "\n%s uniformResourceIdentifier : ", prefix );
MBEDTLS_X509_SAFE_SNPRINTF;
if( san.san.unstructured_name.len >= n ) {
*p = '\0';
return( MBEDTLS_ERR_X509_BUFFER_TOO_SMALL );
}
memcpy( p, san.san.unstructured_name.p, san.san.unstructured_name.len );
p += san.san.unstructured_name.len;
n -= san.san.unstructured_name.len;
}
break;
/*
* iPAddress
*/
case MBEDTLS_X509_SAN_IP_ADDRESS:
{
ret = mbedtls_snprintf( p, n, "\n%s iPAddress : %hhu.%hhu.%hhu.%hhu",
prefix, san.san.ip>>24,
san.san.ip>>16,
san.san.ip>>8,
san.san.ip);
MBEDTLS_X509_SAFE_SNPRINTF;
}
break;
/*
* Type not supported, skip item.
*/
default:
ret = mbedtls_snprintf( p, n, "\n%s <unsupported:%d>", prefix, san.type );
MBEDTLS_X509_SAFE_SNPRINTF;
break;
}
cur = cur->next;
}
*p = '\0';
*size = n;
*buf = p;
return 0;
}
/**
* \brief This function parses an item in the SubjectAlternativeNames
* extension.
*
* \param san_buf The buffer holding the raw data item of the subject
* alternative name.
* \param san The target structure to populate with the parsed presentation
* of the subject alternative name encoded in \p san_raw.
*
* \note Only "dnsName" and "otherName" of type hardware_module_name
* as defined in RFC 4180 is supported.
*
* \note This function should be called on a single raw data of
* subject alternative name. For example, after successful
* certificate parsing, one must iterate on every item in the
* \p crt->subject_alt_names sequence, and pass it to
* this function.
*
* \warning The target structure contains pointers to the raw data of the
* parsed certificate, and its lifetime is restricted by the
* lifetime of the certificate.
*
* \return \c 0 on success
* \return #MBEDTLS_ERR_X509_FEATURE_UNAVAILABLE for an unsupported
* SAN type.
* \return Another negative value for any other failure.
*/
int mbedtls_x509_parse_subject_alt_name( const mbedtls_x509_buf *san_buf,
mbedtls_x509_subject_alternative_name *san )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
switch( san_buf->tag &
( MBEDTLS_ASN1_TAG_CLASS_MASK |
MBEDTLS_ASN1_TAG_VALUE_MASK ) )
{
/*
* otherName
*/
case( MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_X509_SAN_OTHER_NAME ):
{
mbedtls_x509_san_other_name other_name;
ret = x509_get_other_name( san_buf, &other_name );
if( ret )
return ret;
mbedtls_platform_zeroize( san, sizeof( mbedtls_x509_subject_alternative_name ) );
san->type = MBEDTLS_X509_SAN_OTHER_NAME;
memcpy( &san->san.other_name,
&other_name, sizeof( other_name ) );
}
break;
/*
* dNSName
*/
case( MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_X509_SAN_DNS_NAME ):
{
mbedtls_platform_zeroize( san, sizeof( mbedtls_x509_subject_alternative_name ) );
san->type = MBEDTLS_X509_SAN_DNS_NAME;
memcpy( &san->san.unstructured_name, san_buf, sizeof( *san_buf ) );
}
break;
/*
* uniformResourceIdentifier
*/
case( MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_X509_SAN_UNIFORM_RESOURCE_IDENTIFIER ):
{
mbedtls_platform_zeroize( san, sizeof( mbedtls_x509_subject_alternative_name ) );
san->type = MBEDTLS_X509_SAN_UNIFORM_RESOURCE_IDENTIFIER;
memcpy( &san->san.unstructured_name, san_buf, sizeof( *san_buf ) );
}
break;
/*
* rfc822Name
*/
case( MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_X509_SAN_RFC822_NAME ):
{
mbedtls_platform_zeroize( san, sizeof( mbedtls_x509_subject_alternative_name ) );
san->type = MBEDTLS_X509_SAN_RFC822_NAME;
memcpy( &san->san.unstructured_name, san_buf, sizeof( *san_buf ) );
}
break;
/*
* iPAddress
*/
case( MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_X509_SAN_IP_ADDRESS ):
{
mbedtls_platform_zeroize( san, sizeof( mbedtls_x509_subject_alternative_name ) );
san->type = MBEDTLS_X509_SAN_IP_ADDRESS;
san->san.ip = READ32BE(san_buf->p);
}
break;
/*
* Type not supported
*/
default:
return( MBEDTLS_ERR_X509_FEATURE_UNAVAILABLE );
}
return 0;
}
#define PRINT_ITEM(i) \
{ \
ret = mbedtls_snprintf( p, n, "%s" i, sep ); \
MBEDTLS_X509_SAFE_SNPRINTF; \
sep = ", "; \
}
#define CERT_TYPE(type,name) \
if( ns_cert_type & (type) ) \
PRINT_ITEM( name );
static int x509_info_cert_type( char **buf, size_t *size,
unsigned char ns_cert_type )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t n = *size;
char *p = *buf;
const char *sep = "";
CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_SSL_CLIENT, "SSL Client" );
CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_SSL_SERVER, "SSL Server" );
CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_EMAIL, "Email" );
CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_OBJECT_SIGNING, "Object Signing" );
CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_RESERVED, "Reserved" );
CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_SSL_CA, "SSL CA" );
CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_EMAIL_CA, "Email CA" );
CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_OBJECT_SIGNING_CA, "Object Signing CA" );
*size = n;
*buf = p;
return 0;
}
#define KEY_USAGE(code,name) \
if( key_usage & (code) ) \
PRINT_ITEM( name );
static int x509_info_key_usage( char **buf, size_t *size,
unsigned int key_usage )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t n = *size;
char *p = *buf;
const char *sep = "";
KEY_USAGE( MBEDTLS_X509_KU_DIGITAL_SIGNATURE, "Digital Signature" );
KEY_USAGE( MBEDTLS_X509_KU_NON_REPUDIATION, "Non Repudiation" );
KEY_USAGE( MBEDTLS_X509_KU_KEY_ENCIPHERMENT, "Key Encipherment" );
KEY_USAGE( MBEDTLS_X509_KU_DATA_ENCIPHERMENT, "Data Encipherment" );
KEY_USAGE( MBEDTLS_X509_KU_KEY_AGREEMENT, "Key Agreement" );
KEY_USAGE( MBEDTLS_X509_KU_KEY_CERT_SIGN, "Key Cert Sign" );
KEY_USAGE( MBEDTLS_X509_KU_CRL_SIGN, "CRL Sign" );
KEY_USAGE( MBEDTLS_X509_KU_ENCIPHER_ONLY, "Encipher Only" );
KEY_USAGE( MBEDTLS_X509_KU_DECIPHER_ONLY, "Decipher Only" );
*size = n;
*buf = p;
return 0;
}
static int x509_info_ext_key_usage( char **buf, size_t *size,
const mbedtls_x509_sequence *extended_key_usage )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
const char *desc;
size_t n = *size;
char *p = *buf;
char tmp[48];
const mbedtls_x509_sequence *cur = extended_key_usage;
const char *sep = "";
while( cur )
{
if( mbedtls_oid_get_extended_key_usage( &cur->buf, &desc ) )
{
mbedtls_oid_get_numeric_string(tmp, sizeof(tmp), &cur->buf);
desc = tmp;
}
ret = mbedtls_snprintf( p, n, "%s%s", sep, desc );
MBEDTLS_X509_SAFE_SNPRINTF;
sep = ", ";
cur = cur->next;
}
*size = n;
*buf = p;
return 0;
}
static int x509_info_cert_policies( char **buf, size_t *size,
const mbedtls_x509_sequence *certificate_policies )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
const char *desc;
size_t n = *size;
char *p = *buf;
char tmp[48];
const mbedtls_x509_sequence *cur = certificate_policies;
const char *sep = "";
while( cur ) {
if( mbedtls_oid_get_certificate_policies( &cur->buf, &desc ) )
{
mbedtls_oid_get_numeric_string(tmp, sizeof(tmp), &cur->buf);
desc = tmp;
}
ret = mbedtls_snprintf( p, n, "%s%s", sep, desc );
MBEDTLS_X509_SAFE_SNPRINTF;
sep = ", ";
cur = cur->next;
}
*size = n;
*buf = p;
return 0;
}
#define BEFORE_COLON 18
#define BC "18"
/**
* \brief Returns an informational string about the
* certificate.
*
* \param buf Buffer to write to
* \param size Maximum size of buffer
* \param prefix A line prefix
* \param crt The X509 certificate to represent
*
* \return The length of the string written (not including the
* terminated nul byte), or a negative error code.
*/
int mbedtls_x509_crt_info( char *buf, size_t size, const char *prefix,
const mbedtls_x509_crt *crt )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
size_t n;
char *p;
char key_size_str[BEFORE_COLON];
p = buf;
n = size;
if( !crt ) {
ret = mbedtls_snprintf( p, n, "\nCertificate is uninitialised!\n" );
MBEDTLS_X509_SAFE_SNPRINTF;
return( (int) ( size - n ) );
}
ret = mbedtls_snprintf( p, n, "%scert. version : %d\n",
prefix, crt->version );
MBEDTLS_X509_SAFE_SNPRINTF;
ret = mbedtls_snprintf( p, n, "%sserial number : ",
prefix );
MBEDTLS_X509_SAFE_SNPRINTF;
ret = mbedtls_x509_serial_gets( p, n, &crt->serial );
MBEDTLS_X509_SAFE_SNPRINTF;
ret = mbedtls_snprintf( p, n, "\n%sissuer name : ", prefix );
MBEDTLS_X509_SAFE_SNPRINTF;
ret = mbedtls_x509_dn_gets( p, n, &crt->issuer );
MBEDTLS_X509_SAFE_SNPRINTF;
ret = mbedtls_snprintf( p, n, "\n%ssubject name : ", prefix );
MBEDTLS_X509_SAFE_SNPRINTF;
ret = mbedtls_x509_dn_gets( p, n, &crt->subject );
MBEDTLS_X509_SAFE_SNPRINTF;
ret = mbedtls_snprintf( p, n, "\n%sissued on : " \
"%04d-%02d-%02d %02d:%02d:%02d", prefix,
crt->valid_from.year, crt->valid_from.mon,
crt->valid_from.day, crt->valid_from.hour,
crt->valid_from.min, crt->valid_from.sec );
MBEDTLS_X509_SAFE_SNPRINTF;
ret = mbedtls_snprintf( p, n, "\n%sexpires on : " \
"%04d-%02d-%02d %02d:%02d:%02d", prefix,
crt->valid_to.year, crt->valid_to.mon,
crt->valid_to.day, crt->valid_to.hour,
crt->valid_to.min, crt->valid_to.sec );
MBEDTLS_X509_SAFE_SNPRINTF;
ret = mbedtls_snprintf( p, n, "\n%ssigned using : ", prefix );
MBEDTLS_X509_SAFE_SNPRINTF;
ret = mbedtls_x509_sig_alg_gets( p, n, &crt->sig_oid, crt->sig_pk,
crt->sig_md, crt->sig_opts );
MBEDTLS_X509_SAFE_SNPRINTF;
/* Key size */
if( ( ret = mbedtls_x509_key_size_helper( key_size_str, BEFORE_COLON,
mbedtls_pk_get_name( &crt->pk ) ) ) )
{
return ret;
}
ret = mbedtls_snprintf( p, n, "\n%s%-" BC "s: %d bits", prefix, key_size_str,
(int) mbedtls_pk_get_bitlen( &crt->pk ) );
MBEDTLS_X509_SAFE_SNPRINTF;
/*
* Optional extensions
*/
if( crt->ext_types & MBEDTLS_X509_EXT_BASIC_CONSTRAINTS )
{
ret = mbedtls_snprintf( p, n, "\n%sbasic constraints : CA=%s", prefix,
crt->ca_istrue ? "true" : "false" );
MBEDTLS_X509_SAFE_SNPRINTF;
if( crt->max_pathlen > 0 )
{
ret = mbedtls_snprintf( p, n, ", max_pathlen=%d", crt->max_pathlen - 1 );
MBEDTLS_X509_SAFE_SNPRINTF;
}
}
if( crt->ext_types & MBEDTLS_X509_EXT_SUBJECT_ALT_NAME )
{
ret = mbedtls_snprintf( p, n, "\n%ssubject alt name :", prefix );
MBEDTLS_X509_SAFE_SNPRINTF;
if( ( ret = x509_info_subject_alt_name( &p, &n,
&crt->subject_alt_names,
prefix ) ) )
return ret;
}
if( crt->ext_types & MBEDTLS_X509_EXT_NS_CERT_TYPE )
{
ret = mbedtls_snprintf( p, n, "\n%scert. type : ", prefix );
MBEDTLS_X509_SAFE_SNPRINTF;
if( ( ret = x509_info_cert_type( &p, &n, crt->ns_cert_type ) ) )
return ret;
}
if( crt->ext_types & MBEDTLS_X509_EXT_KEY_USAGE )
{
ret = mbedtls_snprintf( p, n, "\n%skey usage : ", prefix );
MBEDTLS_X509_SAFE_SNPRINTF;
if( ( ret = x509_info_key_usage( &p, &n, crt->key_usage ) ) )
return ret;
}
if( crt->ext_types & MBEDTLS_X509_EXT_EXTENDED_KEY_USAGE )
{
ret = mbedtls_snprintf( p, n, "\n%sext key usage : ", prefix );
MBEDTLS_X509_SAFE_SNPRINTF;
if( ( ret = x509_info_ext_key_usage( &p, &n,
&crt->ext_key_usage ) ) )
return ret;
}
if( crt->ext_types & MBEDTLS_OID_X509_EXT_CERTIFICATE_POLICIES )
{
ret = mbedtls_snprintf( p, n, "\n%scert policies : ", prefix );
MBEDTLS_X509_SAFE_SNPRINTF;
if( ( ret = x509_info_cert_policies( &p, &n,
&crt->certificate_policies ) ) )
return ret;
}
ret = mbedtls_snprintf( p, n, "\n" );
MBEDTLS_X509_SAFE_SNPRINTF;
return( (int) ( size - n ) );
}
struct x509_crt_verify_string {
int code;
const char *string;
};
static const struct x509_crt_verify_string x509_crt_verify_strings[] = {
{ MBEDTLS_X509_BADCERT_EXPIRED, "The certificate validity has expired" },
{ MBEDTLS_X509_BADCERT_REVOKED, "The certificate has been revoked (is on a CRL)" },
{ MBEDTLS_X509_BADCERT_CN_MISMATCH, "The certificate Common Name (CN) does not match with the expected CN" },
{ MBEDTLS_X509_BADCERT_NOT_TRUSTED, "The certificate is not correctly signed by the trusted CA" },
{ MBEDTLS_X509_BADCRL_NOT_TRUSTED, "The CRL is not correctly signed by the trusted CA" },
{ MBEDTLS_X509_BADCRL_EXPIRED, "The CRL is expired" },
{ MBEDTLS_X509_BADCERT_MISSING, "Certificate was missing" },
{ MBEDTLS_X509_BADCERT_SKIP_VERIFY, "Certificate verification was skipped" },
{ MBEDTLS_X509_BADCERT_OTHER, "Other reason (can be used by verify callback)" },
{ MBEDTLS_X509_BADCERT_FUTURE, "The certificate validity starts in the future" },
{ MBEDTLS_X509_BADCRL_FUTURE, "The CRL is from the future" },
{ MBEDTLS_X509_BADCERT_KEY_USAGE, "Usage does not match the keyUsage extension" },
{ MBEDTLS_X509_BADCERT_EXT_KEY_USAGE, "Usage does not match the extendedKeyUsage extension" },
{ MBEDTLS_X509_BADCERT_NS_CERT_TYPE, "Usage does not match the nsCertType extension" },
{ MBEDTLS_X509_BADCERT_BAD_MD, "The certificate is signed with an unacceptable hash." },
{ MBEDTLS_X509_BADCERT_BAD_PK, "The certificate is signed with an unacceptable PK alg (eg RSA vs ECDSA)." },
{ MBEDTLS_X509_BADCERT_BAD_KEY, "The certificate is signed with an unacceptable key (eg bad curve, RSA too short)." },
{ MBEDTLS_X509_BADCRL_BAD_MD, "The CRL is signed with an unacceptable hash." },
{ MBEDTLS_X509_BADCRL_BAD_PK, "The CRL is signed with an unacceptable PK alg (eg RSA vs ECDSA)." },
{ MBEDTLS_X509_BADCRL_BAD_KEY, "The CRL is signed with an unacceptable key (eg bad curve, RSA too short)." },
{ 0, NULL }
};
/**
* \brief Returns an informational string about the
* verification status of a certificate.
*
* \param buf Buffer to write to
* \param size Maximum size of buffer
* \param prefix A line prefix
* \param flags Verification flags created by mbedtls_x509_crt_verify()
*
* \return The length of the string written (not including the
* terminated nul byte), or a negative error code.
*/
int mbedtls_x509_crt_verify_info( char *buf, size_t size, const char *prefix,
uint32_t flags )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
const struct x509_crt_verify_string *cur;
char *p = buf;
size_t n = size;
for( cur = x509_crt_verify_strings; cur->string != NULL ; cur++ )
{
if( ( flags & cur->code ) == 0 )
continue;
ret = mbedtls_snprintf( p, n, "%s%s\n", prefix, cur->string );
MBEDTLS_X509_SAFE_SNPRINTF;
flags ^= cur->code;
}
if( flags )
{
ret = mbedtls_snprintf( p, n, "%sUnknown reason "
"(this should not happen)\n", prefix );
MBEDTLS_X509_SAFE_SNPRINTF;
}
return( (int) ( size - n ) );
}
/**
* \brief Check usage of certificate against keyUsage extension.
*
* \param crt Leaf certificate used.
* \param usage Intended usage(s) (eg MBEDTLS_X509_KU_KEY_ENCIPHERMENT
* before using the certificate to perform an RSA key
* exchange).
*
* \note Except for decipherOnly and encipherOnly, a bit set in the
* usage argument means this bit MUST be set in the
* certificate. For decipherOnly and encipherOnly, it means
* that bit MAY be set.
*
* \return 0 is these uses of the certificate are allowed,
* MBEDTLS_ERR_X509_BAD_INPUT_DATA if the keyUsage extension
* is present but does not match the usage argument.
*
* \note You should only call this function on leaf certificates, on
* (intermediate) CAs the keyUsage extension is automatically
* checked by \c mbedtls_x509_crt_verify().
*/
int mbedtls_x509_crt_check_key_usage( const mbedtls_x509_crt *crt,
unsigned int usage )
{
unsigned int usage_must, usage_may;
unsigned int may_mask = MBEDTLS_X509_KU_ENCIPHER_ONLY
| MBEDTLS_X509_KU_DECIPHER_ONLY;
if( ( crt->ext_types & MBEDTLS_X509_EXT_KEY_USAGE ) == 0 )
return 0;
usage_must = usage & ~may_mask;
if( ( ( crt->key_usage & ~may_mask ) & usage_must ) != usage_must )
return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
usage_may = usage & may_mask;
if( ( ( crt->key_usage & may_mask ) | usage_may ) != usage_may )
return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
return 0;
}
/**
* \brief Check usage of certificate against extendedKeyUsage.
*
* \param crt Leaf certificate used.
* \param usage_oid Intended usage (eg MBEDTLS_OID_SERVER_AUTH or
* MBEDTLS_OID_CLIENT_AUTH).
* \param usage_len Length of usage_oid (eg given by MBEDTLS_OID_SIZE()).
*
* \return 0 if this use of the certificate is allowed,
* MBEDTLS_ERR_X509_BAD_INPUT_DATA if not.
*
* \note Usually only makes sense on leaf certificates.
*/
int mbedtls_x509_crt_check_extended_key_usage( const mbedtls_x509_crt *crt,
const char *usage_oid,
size_t usage_len )
{
const mbedtls_x509_sequence *cur;
/* Extension is not mandatory, absent means no restriction */
if( ( crt->ext_types & MBEDTLS_X509_EXT_EXTENDED_KEY_USAGE ) == 0 )
return 0;
/*
* Look for the requested usage (or wildcard ANY) in our list
*/
for( cur = &crt->ext_key_usage; cur != NULL; cur = cur->next )
{
const mbedtls_x509_buf *cur_oid = &cur->buf;
if( cur_oid->len == usage_len &&
timingsafe_bcmp( cur_oid->p, usage_oid, usage_len ) == 0 )
{
return 0;
}
if( MBEDTLS_OID_CMP( MBEDTLS_OID_ANY_EXTENDED_KEY_USAGE, cur_oid ) == 0 )
return 0;
}
return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
}
/**
* \brief Verify the certificate revocation status
*
* \param crt a certificate to be verified
* \param crl the CRL to verify against
*
* \return 1 if the certificate is revoked, 0 otherwise
*
*/
int mbedtls_x509_crt_is_revoked( const mbedtls_x509_crt *crt, const mbedtls_x509_crl *crl )
{
const mbedtls_x509_crl_entry *cur = &crl->entry;
while( cur && cur->serial.len )
{
if( crt->serial.len == cur->serial.len &&
timingsafe_bcmp( crt->serial.p, cur->serial.p, crt->serial.len ) == 0 )
{
return( 1 );
}
cur = cur->next;
}
return 0;
}
/*
* Check that the given certificate is not revoked according to the CRL.
* Skip validation if no CRL for the given CA is present.
*/
static int x509_crt_verifycrl( mbedtls_x509_crt *crt, mbedtls_x509_crt *ca,
mbedtls_x509_crl *crl_list,
const mbedtls_x509_crt_profile *profile )
{
int flags = 0;
unsigned char hash[MBEDTLS_MD_MAX_SIZE];
const mbedtls_md_info_t *md_info;
if( ca == NULL )
return( flags );
while( crl_list )
{
if( crl_list->version == 0 ||
mbedtls_x509_name_cmp( &crl_list->issuer, &ca->subject ) )
{
crl_list = crl_list->next;
continue;
}
/*
* Check if the CA is configured to sign CRLs
*/
#if defined(MBEDTLS_X509_CHECK_KEY_USAGE)
if( mbedtls_x509_crt_check_key_usage( ca,
MBEDTLS_X509_KU_CRL_SIGN ) )
{
flags |= MBEDTLS_X509_BADCRL_NOT_TRUSTED;
break;
}
#endif
/*
* Check if CRL is correctly signed by the trusted CA
*/
if( x509_profile_check_md_alg( profile, crl_list->sig_md ) )
flags |= MBEDTLS_X509_BADCRL_BAD_MD;
if( x509_profile_check_pk_alg( profile, crl_list->sig_pk ) )
flags |= MBEDTLS_X509_BADCRL_BAD_PK;
md_info = mbedtls_md_info_from_type( crl_list->sig_md );
if( mbedtls_md( md_info, crl_list->tbs.p, crl_list->tbs.len, hash ) )
{
/* Note: this can't happen except after an internal error */
flags |= MBEDTLS_X509_BADCRL_NOT_TRUSTED;
break;
}
if( x509_profile_check_key( profile, &ca->pk ) )
flags |= MBEDTLS_X509_BADCERT_BAD_KEY;
if( mbedtls_pk_verify_ext( crl_list->sig_pk, crl_list->sig_opts, &ca->pk,
crl_list->sig_md, hash, mbedtls_md_get_size( md_info ),
crl_list->sig.p, crl_list->sig.len ) )
{
flags |= MBEDTLS_X509_BADCRL_NOT_TRUSTED;
break;
}
/*
* Check for validity of CRL (Do not drop out)
*/
if( mbedtls_x509_time_is_past( &crl_list->next_update ) )
flags |= MBEDTLS_X509_BADCRL_EXPIRED;
if( mbedtls_x509_time_is_future( &crl_list->this_update ) )
flags |= MBEDTLS_X509_BADCRL_FUTURE;
/*
* Check if certificate is revoked
*/
if( mbedtls_x509_crt_is_revoked( crt, crl_list ) )
{
flags |= MBEDTLS_X509_BADCERT_REVOKED;
break;
}
crl_list = crl_list->next;
}
return( flags );
}
/*
* Check the signature of a certificate by its parent
*/
int mbedtls_x509_crt_check_signature( const mbedtls_x509_crt *child,
mbedtls_x509_crt *parent,
mbedtls_x509_crt_restart_ctx *rs_ctx )
{
unsigned char hash[MBEDTLS_MD_MAX_SIZE];
size_t hash_len;
const mbedtls_md_info_t *md_info;
md_info = mbedtls_md_info_from_type( child->sig_md );
hash_len = mbedtls_md_get_size( md_info );
/* Note: hash errors can happen only after an internal error */
if( mbedtls_md( md_info, child->tbs.p, child->tbs.len, hash ) != 0 )
return( -1 );
/* Skip expensive computation on obvious mismatch */
if( ! mbedtls_pk_can_do( &parent->pk, child->sig_pk ) )
return -1;
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
if( rs_ctx && child->sig_pk == MBEDTLS_PK_ECDSA )
{
return( mbedtls_pk_verify_restartable( &parent->pk,
child->sig_md, hash, hash_len,
child->sig.p, child->sig.len, &rs_ctx->pk ) );
}
#else
(void) rs_ctx;
#endif
return( mbedtls_pk_verify_ext( child->sig_pk, child->sig_opts, &parent->pk,
child->sig_md, hash, hash_len,
child->sig.p, child->sig.len ) );
}
/*
* Checks if 'parent' is a suitable parent (signing CA) for 'child'.
* Return 0 if yes, -1 if not.
*
* top means parent is a locally-trusted certificate
*/
int mbedtls_x509_crt_check_parent( const mbedtls_x509_crt *child,
const mbedtls_x509_crt *parent,
int top )
{
int need_ca_bit;
/* Parent must be the issuer */
if( mbedtls_x509_name_cmp( &child->issuer, &parent->subject ) )
return -1;
/* Parent must have the basicConstraints CA bit set as a general rule */
need_ca_bit = 1;
/* Exception: v1/v2 certificates that are locally trusted. */
if( top && parent->version < 3 )
need_ca_bit = 0;
if( need_ca_bit && ! parent->ca_istrue )
return -1;
#if defined(MBEDTLS_X509_CHECK_KEY_USAGE)
if( need_ca_bit &&
mbedtls_x509_crt_check_key_usage( parent, MBEDTLS_X509_KU_KEY_CERT_SIGN ) )
{
return -1;
}
#endif
return 0;
}
/*
* Find a suitable parent for child in candidates, or return NULL.
*
* Here suitable is defined as:
* 1. subject name matches child's issuer
* 2. if necessary, the CA bit is set and key usage allows signing certs
* 3. for trusted roots, the signature is correct
* (for intermediates, the signature is checked and the result reported)
* 4. pathlen constraints are satisfied
*
* If there's a suitable candidate which is also time-valid, return the first
* such. Otherwise, return the first suitable candidate (or NULL if there is
* none).
*
* The rationale for this rule is that someone could have a list of trusted
* roots with two versions on the same root with different validity periods.
* (At least one user reported having such a list and wanted it to just work.)
* The reason we don't just require time-validity is that generally there is
* only one version, and if it's expired we want the flags to state that
* rather than NOT_TRUSTED, as would be the case if we required it here.
*
* The rationale for rule 3 (signature for trusted roots) is that users might
* have two versions of the same CA with different keys in their list, and the
* way we select the correct one is by checking the signature (as we don't
* rely on key identifier extensions). (This is one way users might choose to
* handle key rollover, another relies on self-issued certs, see [SIRO].)
*
* Arguments:
* - [in] child: certificate for which we're looking for a parent
* - [in] candidates: chained list of potential parents
* - [out] r_parent: parent found (or NULL)
* - [out] r_signature_is_good: 1 if child signature by parent is valid, or 0
* - [in] top: 1 if candidates consists of trusted roots, ie we're at the top
* of the chain, 0 otherwise
* - [in] path_cnt: number of intermediates seen so far
* - [in] self_cnt: number of self-signed intermediates seen so far
* (will never be greater than path_cnt)
* - [in-out] rs_ctx: context for restarting operations
*
* Return value:
* - 0 on success
* - MBEDTLS_ERR_ECP_IN_PROGRESS otherwise
*/
static int x509_crt_find_parent_in(
mbedtls_x509_crt *child,
mbedtls_x509_crt *candidates,
mbedtls_x509_crt **r_parent,
int *r_signature_is_good,
int top,
unsigned path_cnt,
unsigned self_cnt,
mbedtls_x509_crt_restart_ctx *rs_ctx )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
mbedtls_x509_crt *parent, *fallback_parent;
int signature_is_good = 0, fallback_signature_is_good;
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
/* did we have something in progress? */
if( rs_ctx && rs_ctx->parent )
{
/* restore saved state */
parent = rs_ctx->parent;
fallback_parent = rs_ctx->fallback_parent;
fallback_signature_is_good = rs_ctx->fallback_signature_is_good;
/* clear saved state */
rs_ctx->parent = NULL;
rs_ctx->fallback_parent = NULL;
rs_ctx->fallback_signature_is_good = 0;
/* resume where we left */
goto check_signature;
}
#endif
fallback_parent = NULL;
fallback_signature_is_good = 0;
for( parent = candidates; parent; parent = parent->next )
{
/* basic parenting skills (name, CA bit, key usage) */
if( mbedtls_x509_crt_check_parent( child, parent, top ) )
continue;
/* +1 because stored max_pathlen is 1 higher that the actual value */
if( parent->max_pathlen > 0 &&
(size_t) parent->max_pathlen < 1 + path_cnt - self_cnt )
{
continue;
}
/* Signature */
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
check_signature:
#endif
ret = mbedtls_x509_crt_check_signature( child, parent, rs_ctx );
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
if( rs_ctx && ret == MBEDTLS_ERR_ECP_IN_PROGRESS )
{
/* save state */
rs_ctx->parent = parent;
rs_ctx->fallback_parent = fallback_parent;
rs_ctx->fallback_signature_is_good = fallback_signature_is_good;
return ret;
}
#else
(void) ret;
#endif
signature_is_good = ret == 0;
if( top && ! signature_is_good )
continue;
/* optional time check */
if( mbedtls_x509_time_is_past( &parent->valid_to ) ||
mbedtls_x509_time_is_future( &parent->valid_from ) )
{
if( fallback_parent == NULL )
{
fallback_parent = parent;
fallback_signature_is_good = signature_is_good;
}
continue;
}
*r_parent = parent;
*r_signature_is_good = signature_is_good;
break;
}
if( parent == NULL )
{
*r_parent = fallback_parent;
*r_signature_is_good = fallback_signature_is_good;
}
return 0;
}
/*
* Find a parent in trusted CAs or the provided chain, or return NULL.
*
* Searches in trusted CAs first, and return the first suitable parent found
* (see find_parent_in() for definition of suitable).
*
* Arguments:
* - [in] child: certificate for which we're looking for a parent, followed
* by a chain of possible intermediates
* - [in] trust_ca: list of locally trusted certificates
* - [out] parent: parent found (or NULL)
* - [out] parent_is_trusted: 1 if returned `parent` is trusted, or 0
* - [out] signature_is_good: 1 if child signature by parent is valid, or 0
* - [in] path_cnt: number of links in the chain so far (EE -> ... -> child)
* - [in] self_cnt: number of self-signed certs in the chain so far
* (will always be no greater than path_cnt)
* - [in-out] rs_ctx: context for restarting operations
*
* Return value:
* - 0 on success
* - MBEDTLS_ERR_ECP_IN_PROGRESS otherwise
*/
static int x509_crt_find_parent(
mbedtls_x509_crt *child,
mbedtls_x509_crt *trust_ca,
mbedtls_x509_crt **parent,
int *parent_is_trusted,
int *signature_is_good,
unsigned path_cnt,
unsigned self_cnt,
mbedtls_x509_crt_restart_ctx *rs_ctx )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
mbedtls_x509_crt *search_list;
*parent_is_trusted = 1;
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
/* restore then clear saved state if we have some stored */
if( rs_ctx && rs_ctx->parent_is_trusted != -1 )
{
*parent_is_trusted = rs_ctx->parent_is_trusted;
rs_ctx->parent_is_trusted = -1;
}
#endif
while( 1 ) {
search_list = *parent_is_trusted ? trust_ca : child->next;
ret = x509_crt_find_parent_in( child, search_list,
parent, signature_is_good,
*parent_is_trusted,
path_cnt, self_cnt, rs_ctx );
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
if( rs_ctx && ret == MBEDTLS_ERR_ECP_IN_PROGRESS )
{
/* save state */
rs_ctx->parent_is_trusted = *parent_is_trusted;
return ret;
}
#else
(void) ret;
#endif
/* stop here if found or already in second iteration */
if( *parent || *parent_is_trusted == 0 )
break;
/* prepare second iteration */
*parent_is_trusted = 0;
}
/* extra precaution against mistakes in the caller */
if( *parent == NULL )
{
*parent_is_trusted = 0;
*signature_is_good = 0;
}
return 0;
}
/*
* Check if an end-entity certificate is locally trusted
*
* Currently we require such certificates to be self-signed (actually only
* check for self-issued as self-signatures are not checked)
*/
static int x509_crt_check_ee_locally_trusted(
mbedtls_x509_crt *crt,
mbedtls_x509_crt *trust_ca )
{
mbedtls_x509_crt *cur;
/* must be self-issued */
if( mbedtls_x509_name_cmp( &crt->issuer, &crt->subject ) )
return -1;
/* look for an exact match with trusted cert */
for( cur = trust_ca; cur; cur = cur->next )
{
if( crt->raw.len == cur->raw.len &&
timingsafe_bcmp( crt->raw.p, cur->raw.p, crt->raw.len ) == 0 )
{
return 0;
}
}
/* too bad */
return -1;
}
/*
* Build and verify a certificate chain
*
* Given a peer-provided list of certificates EE, C1, ..., Cn and
* a list of trusted certs R1, ... Rp, try to build and verify a chain
* EE, Ci1, ... Ciq [, Rj]
* such that every cert in the chain is a child of the next one,
* jumping to a trusted root as early as possible.
*
* Verify that chain and return it with flags for all issues found.
*
* Special cases:
* - EE == Rj -> return a one-element list containing it
* - EE, Ci1, ..., Ciq cannot be continued with a trusted root
* -> return that chain with NOT_TRUSTED set on Ciq
*
* Tests for (aspects of) this function should include at least:
* - trusted EE
* - EE -> trusted root
* - EE -> intermediate CA -> trusted root
* - if relevant: EE untrusted
* - if relevant: EE -> intermediate, untrusted
* with the aspect under test checked at each relevant level (EE, int, root).
* For some aspects longer chains are required, but usually length 2 is
* enough (but length 1 is not in general).
*
* Arguments:
* - [in] crt: the cert list EE, C1, ..., Cn
* - [in] trust_ca: the trusted list R1, ..., Rp
* - [in] ca_crl, profile: as in verify_with_profile()
* - [out] ver_chain: the built and verified chain
* Only valid when return value is 0, may contain garbage otherwise!
* Restart note: need not be the same when calling again to resume.
* - [in-out] rs_ctx: context for restarting operations
*
* Return value:
* - non-zero if the chain could not be fully built and examined
* - 0 is the chain was successfully built and examined,
* even if it was found to be invalid
*/
static int x509_crt_verify_chain(
mbedtls_x509_crt *crt,
mbedtls_x509_crt *trust_ca,
mbedtls_x509_crl *ca_crl,
mbedtls_x509_crt_ca_cb_t f_ca_cb,
void *p_ca_cb,
const mbedtls_x509_crt_profile *profile,
mbedtls_x509_crt_verify_chain *ver_chain,
mbedtls_x509_crt_restart_ctx *rs_ctx )
{
/* Don't initialize any of those variables here, so that the compiler can
* catch potential issues with jumping ahead when restarting */
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
uint32_t *flags;
mbedtls_x509_crt_verify_chain_item *cur;
mbedtls_x509_crt *child;
mbedtls_x509_crt *parent;
int parent_is_trusted;
int child_is_trusted;
int signature_is_good;
unsigned self_cnt;
mbedtls_x509_crt *cur_trust_ca = NULL;
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
/* resume if we had an operation in progress */
if( rs_ctx && rs_ctx->in_progress == x509_crt_rs_find_parent )
{
/* restore saved state */
*ver_chain = rs_ctx->ver_chain; /* struct copy */
self_cnt = rs_ctx->self_cnt;
/* restore derived state */
cur = &ver_chain->items[ver_chain->len - 1];
child = cur->crt;
flags = &cur->flags;
goto find_parent;
}
#endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
child = crt;
self_cnt = 0;
parent_is_trusted = 0;
child_is_trusted = 0;
while( 1 ) {
/* Add certificate to the verification chain */
cur = &ver_chain->items[ver_chain->len];
cur->crt = child;
cur->flags = 0;
ver_chain->len++;
flags = &cur->flags;
/* Check time-validity (all certificates) */
if( mbedtls_x509_time_is_past( &child->valid_to ) )
*flags |= MBEDTLS_X509_BADCERT_EXPIRED;
if( mbedtls_x509_time_is_future( &child->valid_from ) )
*flags |= MBEDTLS_X509_BADCERT_FUTURE;
/* Stop here for trusted roots (but not for trusted EE certs) */
if( child_is_trusted )
return 0;
/* Check signature algorithm: MD & PK algs */
if( x509_profile_check_md_alg( profile, child->sig_md ) )
*flags |= MBEDTLS_X509_BADCERT_BAD_MD;
if( x509_profile_check_pk_alg( profile, child->sig_pk ) )
*flags |= MBEDTLS_X509_BADCERT_BAD_PK;
/* Special case: EE certs that are locally trusted */
if( ver_chain->len == 1 &&
x509_crt_check_ee_locally_trusted( child, trust_ca ) == 0 )
{
return 0;
}
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
find_parent:
#endif
/* Obtain list of potential trusted signers from CA callback,
* or use statically provided list. */
#if defined(MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK)
if( f_ca_cb )
{
mbedtls_x509_crt_free( ver_chain->trust_ca_cb_result );
mbedtls_free( ver_chain->trust_ca_cb_result );
ver_chain->trust_ca_cb_result = NULL;
ret = f_ca_cb( p_ca_cb, child, &ver_chain->trust_ca_cb_result );
if( ret )
return( MBEDTLS_ERR_X509_FATAL_ERROR );
cur_trust_ca = ver_chain->trust_ca_cb_result;
}
else
#endif /* MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK */
{
((void) f_ca_cb);
((void) p_ca_cb);
cur_trust_ca = trust_ca;
}
/* Look for a parent in trusted CAs or up the chain */
ret = x509_crt_find_parent( child, cur_trust_ca, &parent,
&parent_is_trusted, &signature_is_good,
ver_chain->len - 1, self_cnt, rs_ctx );
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
if( rs_ctx && ret == MBEDTLS_ERR_ECP_IN_PROGRESS )
{
/* save state */
rs_ctx->in_progress = x509_crt_rs_find_parent;
rs_ctx->self_cnt = self_cnt;
rs_ctx->ver_chain = *ver_chain; /* struct copy */
return ret;
}
#else
(void) ret;
#endif
/* No parent? We're done here */
if( parent == NULL )
{
*flags |= MBEDTLS_X509_BADCERT_NOT_TRUSTED;
return 0;
}
/* Count intermediate self-issued (not necessarily self-signed) certs.
* These can occur with some strategies for key rollover, see [SIRO],
* and should be excluded from max_pathlen checks. */
if( ver_chain->len != 1 &&
mbedtls_x509_name_cmp( &child->issuer, &child->subject ) == 0 )
{
self_cnt++;
}
/* path_cnt is 0 for the first intermediate CA,
* and if parent is trusted it's not an intermediate CA */
if( ! parent_is_trusted &&
ver_chain->len > MBEDTLS_X509_MAX_INTERMEDIATE_CA )
{
/* return immediately to avoid overflow the chain array */
return( MBEDTLS_ERR_X509_FATAL_ERROR );
}
/* signature was checked while searching parent */
if( ! signature_is_good )
*flags |= MBEDTLS_X509_BADCERT_NOT_TRUSTED;
/* check size of signing key */
if( x509_profile_check_key( profile, &parent->pk ) )
*flags |= MBEDTLS_X509_BADCERT_BAD_KEY;
#if defined(MBEDTLS_X509_CRL_PARSE_C)
/* Check trusted CA's CRL for the given crt */
*flags |= x509_crt_verifycrl( child, parent, ca_crl, profile );
#else
(void) ca_crl;
#endif
/* prepare for next iteration */
child = parent;
parent = NULL;
child_is_trusted = parent_is_trusted;
signature_is_good = 0;
}
}
/*
* Check for CN match
*/
static int x509_crt_check_cn( const mbedtls_x509_buf *name,
const char *cn, size_t cn_len )
{
/* try exact match */
if( name->len == cn_len &&
memcasecmp( cn, name->p, cn_len ) == 0 )
{
return 0;
}
/* try wildcard match */
if( x509_check_wildcard( cn, name ) == 0 )
{
return 0;
}
return -1;
}
/*
* Check for SAN match, see RFC 5280 Section 4.2.1.6
*/
static int x509_crt_check_san( const mbedtls_x509_buf *name,
const char *cn, size_t cn_len )
{
int64_t ip;
const unsigned char san_type = (unsigned char) name->tag &
MBEDTLS_ASN1_TAG_VALUE_MASK;
/* dNSName */
if( san_type == MBEDTLS_X509_SAN_DNS_NAME )
return( x509_crt_check_cn( name, cn, cn_len ) );
if( san_type == MBEDTLS_X509_SAN_IP_ADDRESS &&
name->len == 4 && ( ip = ParseIp( cn, cn_len ) ) != -1 &&
ip == READ32BE( name->p ) ) {
return( 0 );
}
/* (We may handle other types here later.) */
/* Unrecognized type */
return -1;
}
/*
* Verify the requested CN - only call this if cn is not NULL!
*/
static void x509_crt_verify_name( const mbedtls_x509_crt *crt,
const char *cn,
uint32_t *flags )
{
const mbedtls_x509_name *name;
const mbedtls_x509_sequence *cur;
size_t cn_len = strlen( cn );
if( crt->ext_types & MBEDTLS_X509_EXT_SUBJECT_ALT_NAME )
{
for( cur = &crt->subject_alt_names; cur; cur = cur->next )
{
if( x509_crt_check_san( &cur->buf, cn, cn_len ) == 0 )
break;
}
if( cur == NULL )
*flags |= MBEDTLS_X509_BADCERT_CN_MISMATCH;
}
else
{
for( name = &crt->subject; name; name = name->next )
{
if( MBEDTLS_OID_CMP( MBEDTLS_OID_AT_CN, &name->oid ) == 0 &&
x509_crt_check_cn( &name->val, cn, cn_len ) == 0 )
{
break;
}
}
if( name == NULL )
*flags |= MBEDTLS_X509_BADCERT_CN_MISMATCH;
}
}
/*
* Merge the flags for all certs in the chain, after calling callback
*/
static int x509_crt_merge_flags_with_cb(
uint32_t *flags,
const mbedtls_x509_crt_verify_chain *ver_chain,
int (*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *),
void *p_vrfy )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
unsigned i;
uint32_t cur_flags;
const mbedtls_x509_crt_verify_chain_item *cur;
for( i = ver_chain->len; i; --i )
{
cur = &ver_chain->items[i-1];
cur_flags = cur->flags;
if( NULL != f_vrfy )
if( ( ret = f_vrfy( p_vrfy, cur->crt, (int) i-1, &cur_flags ) ) )
return ret;
*flags |= cur_flags;
}
return 0;
}
/*
* Verify the certificate validity, with profile, restartable version
*
* This function:
* - checks the requested CN (if any)
* - checks the type and size of the EE cert's key,
* as that isn't done as part of chain building/verification currently
* - builds and verifies the chain
* - then calls the callback and merges the flags
*
* The parameters pairs `trust_ca`, `ca_crl` and `f_ca_cb`, `p_ca_cb`
* are mutually exclusive: If `f_ca_cb`, it will be used by the
* verification routine to search for trusted signers, and CRLs will
* be disabled. Otherwise, `trust_ca` will be used as the static list
* of trusted signers, and `ca_crl` will be use as the static list
* of CRLs.
*/
static int x509_crt_verify_restartable_ca_cb(
mbedtls_x509_crt *crt,
mbedtls_x509_crt *trust_ca,
mbedtls_x509_crl *ca_crl,
mbedtls_x509_crt_ca_cb_t f_ca_cb,
void *p_ca_cb,
const mbedtls_x509_crt_profile *profile,
const char *cn, uint32_t *flags,
int (*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *),
void *p_vrfy,
mbedtls_x509_crt_restart_ctx *rs_ctx )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
mbedtls_pk_type_t pk_type;
mbedtls_x509_crt_verify_chain ver_chain;
uint32_t ee_flags;
*flags = 0;
ee_flags = 0;
x509_crt_verify_chain_reset( &ver_chain );
if( profile == NULL )
{
ret = MBEDTLS_ERR_X509_BAD_INPUT_DATA;
goto exit;
}
/* check name if requested */
if( cn )
x509_crt_verify_name( crt, cn, &ee_flags );
/* Check the type and size of the key */
pk_type = mbedtls_pk_get_type( &crt->pk );
if( x509_profile_check_pk_alg( profile, pk_type ) )
ee_flags |= MBEDTLS_X509_BADCERT_BAD_PK;
if( x509_profile_check_key( profile, &crt->pk ) )
ee_flags |= MBEDTLS_X509_BADCERT_BAD_KEY;
/* Check the chain */
ret = x509_crt_verify_chain( crt, trust_ca, ca_crl,
f_ca_cb, p_ca_cb, profile,
&ver_chain, rs_ctx );
if( ret )
goto exit;
/* Merge end-entity flags */
ver_chain.items[0].flags |= ee_flags;
/* Build final flags, calling callback on the way if any */
ret = x509_crt_merge_flags_with_cb( flags, &ver_chain, f_vrfy, p_vrfy );
exit:
#if defined(MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK)
mbedtls_x509_crt_free( ver_chain.trust_ca_cb_result );
mbedtls_free( ver_chain.trust_ca_cb_result );
ver_chain.trust_ca_cb_result = NULL;
#endif /* MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK */
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
if( rs_ctx && ret != MBEDTLS_ERR_ECP_IN_PROGRESS )
mbedtls_x509_crt_restart_free( rs_ctx );
#endif
/* prevent misuse of the vrfy callback - VERIFY_FAILED would be ignored by
* the SSL module for authmode optional, but non-zero return from the
* callback means a fatal error so it shouldn't be ignored */
if( ret == MBEDTLS_ERR_X509_CERT_VERIFY_FAILED )
ret = MBEDTLS_ERR_X509_FATAL_ERROR;
if( ret ) {
*flags = (uint32_t) -1;
return ret;
}
if( *flags )
return( MBEDTLS_ERR_X509_CERT_VERIFY_FAILED );
return 0;
}
/**
* \brief Verify a chain of certificates.
*
* The verify callback is a user-supplied callback that
* can clear / modify / add flags for a certificate. If set,
* the verification callback is called for each
* certificate in the chain (from the trust-ca down to the
* presented crt). The parameters for the callback are:
* (void *parameter, mbedtls_x509_crt *crt, int certificate_depth,
* int *flags). With the flags representing current flags for
* that specific certificate and the certificate depth from
* the bottom (Peer cert depth = 0).
*
* All flags left after returning from the callback
* are also returned to the application. The function should
* return 0 for anything (including invalid certificates)
* other than fatal error, as a non-zero return code
* immediately aborts the verification process. For fatal
* errors, a specific error code should be used (different
* from MBEDTLS_ERR_X509_CERT_VERIFY_FAILED which should not
* be returned at this point), or MBEDTLS_ERR_X509_FATAL_ERROR
* can be used if no better code is available.
*
* \note In case verification failed, the results can be displayed
* using \c mbedtls_x509_crt_verify_info()
*
* \note Same as \c mbedtls_x509_crt_verify_with_profile() with the
* default security profile.
*
* \note It is your responsibility to provide up-to-date CRLs for
* all trusted CAs. If no CRL is provided for the CA that was
* used to sign the certificate, CRL verification is skipped
* silently, that is *without* setting any flag.
*
* \note The \c trust_ca list can contain two types of certificates:
* (1) those of trusted root CAs, so that certificates
* chaining up to those CAs will be trusted, and (2)
* self-signed end-entity certificates to be trusted (for
* specific peers you know) - in that case, the self-signed
* certificate doesn't need to have the CA bit set.
*
* \param crt The certificate chain to be verified.
* \param trust_ca The list of trusted CAs.
* \param ca_crl The list of CRLs for trusted CAs.
* \param cn The expected Common Name. This will be checked to be
* present in the certificate's subjectAltNames extension or,
* if this extension is absent, as a CN component in its
* Subject name. Currently only DNS names are supported. This
* may be \c NULL if the CN need not be verified.
* \param flags The address at which to store the result of the verification.
* If the verification couldn't be completed, the flag value is
* set to (uint32_t) -1.
* \param f_vrfy The verification callback to use. See the documentation
* of mbedtls_x509_crt_verify() for more information.
* \param p_vrfy The context to be passed to \p f_vrfy.
*
* \return \c 0 if the chain is valid with respect to the
* passed CN, CAs, CRLs and security profile.
* \return #MBEDTLS_ERR_X509_CERT_VERIFY_FAILED in case the
* certificate chain verification failed. In this case,
* \c *flags will have one or more
* \c MBEDTLS_X509_BADCERT_XXX or \c MBEDTLS_X509_BADCRL_XXX
* flags set.
* \return Another negative error code in case of a fatal error
* encountered during the verification process.
*/
int mbedtls_x509_crt_verify( mbedtls_x509_crt *crt,
mbedtls_x509_crt *trust_ca,
mbedtls_x509_crl *ca_crl,
const char *cn, uint32_t *flags,
int (*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *),
void *p_vrfy)
{
return( x509_crt_verify_restartable_ca_cb( crt, trust_ca, ca_crl,
NULL, NULL,
&mbedtls_x509_crt_profile_default,
cn, flags,
f_vrfy, p_vrfy, NULL ) );
}
/**
* \brief Verify a chain of certificates with respect to
* a configurable security profile.
*
* \note Same as \c mbedtls_x509_crt_verify(), but with explicit
* security profile.
*
* \note The restrictions on keys (RSA minimum size, allowed curves
* for ECDSA) apply to all certificates: trusted root,
* intermediate CAs if any, and end entity certificate.
*
* \param crt The certificate chain to be verified.
* \param trust_ca The list of trusted CAs.
* \param ca_crl The list of CRLs for trusted CAs.
* \param profile The security profile to use for the verification.
* \param cn The expected Common Name. This may be \c NULL if the
* CN need not be verified.
* \param flags The address at which to store the result of the verification.
* If the verification couldn't be completed, the flag value is
* set to (uint32_t) -1.
* \param f_vrfy The verification callback to use. See the documentation
* of mbedtls_x509_crt_verify() for more information.
* \param p_vrfy The context to be passed to \p f_vrfy.
*
* \return \c 0 if the chain is valid with respect to the
* passed CN, CAs, CRLs and security profile.
* \return #MBEDTLS_ERR_X509_CERT_VERIFY_FAILED in case the
* certificate chain verification failed. In this case,
* \c *flags will have one or more
* \c MBEDTLS_X509_BADCERT_XXX or \c MBEDTLS_X509_BADCRL_XXX
* flags set.
* \return Another negative error code in case of a fatal error
* encountered during the verification process.
*/
int mbedtls_x509_crt_verify_with_profile( mbedtls_x509_crt *crt,
mbedtls_x509_crt *trust_ca,
mbedtls_x509_crl *ca_crl,
const mbedtls_x509_crt_profile *profile,
const char *cn, uint32_t *flags,
int (*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *),
void *p_vrfy )
{
return( x509_crt_verify_restartable_ca_cb( crt, trust_ca, ca_crl,
NULL, NULL,
profile, cn, flags,
f_vrfy, p_vrfy, NULL ) );
}
#if defined(MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK)
/**
* \brief Version of \c mbedtls_x509_crt_verify_with_profile() which
* uses a callback to acquire the list of trusted CA
* certificates.
*
* \param crt The certificate chain to be verified.
* \param f_ca_cb The callback to be used to query for potential signers
* of a given child certificate. See the documentation of
* ::mbedtls_x509_crt_ca_cb_t for more information.
* \param p_ca_cb The opaque context to be passed to \p f_ca_cb.
* \param profile The security profile for the verification.
* \param cn The expected Common Name. This may be \c NULL if the
* CN need not be verified.
* \param flags The address at which to store the result of the verification.
* If the verification couldn't be completed, the flag value is
* set to (uint32_t) -1.
* \param f_vrfy The verification callback to use. See the documentation
* of mbedtls_x509_crt_verify() for more information.
* \param p_vrfy The context to be passed to \p f_vrfy.
*
* \return See \c mbedtls_crt_verify_with_profile().
*/
int mbedtls_x509_crt_verify_with_ca_cb( mbedtls_x509_crt *crt,
mbedtls_x509_crt_ca_cb_t f_ca_cb,
void *p_ca_cb,
const mbedtls_x509_crt_profile *profile,
const char *cn, uint32_t *flags,
int (*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *),
void *p_vrfy )
{
return( x509_crt_verify_restartable_ca_cb( crt, NULL, NULL,
f_ca_cb, p_ca_cb,
profile, cn, flags,
f_vrfy, p_vrfy, NULL ) );
}
#endif /* MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK */
/**
* \brief Restartable version of \c mbedtls_crt_verify_with_profile()
*
* \note Performs the same job as \c mbedtls_crt_verify_with_profile()
* but can return early and restart according to the limit
* set with \c mbedtls_ecp_set_max_ops() to reduce blocking.
*
* \param crt The certificate chain to be verified.
* \param trust_ca The list of trusted CAs.
* \param ca_crl The list of CRLs for trusted CAs.
* \param profile The security profile to use for the verification.
* \param cn The expected Common Name. This may be \c NULL if the
* CN need not be verified.
* \param flags The address at which to store the result of the verification.
* If the verification couldn't be completed, the flag value is
* set to (uint32_t) -1.
* \param f_vrfy The verification callback to use. See the documentation
* of mbedtls_x509_crt_verify() for more information.
* \param p_vrfy The context to be passed to \p f_vrfy.
* \param rs_ctx The restart context to use. This may be set to \c NULL
* to disable restartable ECC.
*
* \return See \c mbedtls_crt_verify_with_profile(), or
* \return #MBEDTLS_ERR_ECP_IN_PROGRESS if maximum number of
* operations was reached: see \c mbedtls_ecp_set_max_ops().
*/
int mbedtls_x509_crt_verify_restartable( mbedtls_x509_crt *crt,
mbedtls_x509_crt *trust_ca,
mbedtls_x509_crl *ca_crl,
const mbedtls_x509_crt_profile *profile,
const char *cn, uint32_t *flags,
int (*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *),
void *p_vrfy,
mbedtls_x509_crt_restart_ctx *rs_ctx )
{
return( x509_crt_verify_restartable_ca_cb( crt, trust_ca, ca_crl,
NULL, NULL,
profile, cn, flags,
f_vrfy, p_vrfy, rs_ctx ) );
}
/**
* \brief Initialize a certificate (chain)
*
* \param crt Certificate chain to initialize
*/
void mbedtls_x509_crt_init( mbedtls_x509_crt *crt )
{
mbedtls_platform_zeroize( crt, sizeof(mbedtls_x509_crt) );
}
/**
* \brief Unallocate all certificate data
*
* \param crt Certificate chain to free
*/
void mbedtls_x509_crt_free( mbedtls_x509_crt *crt )
{
mbedtls_x509_crt *cert_cur = crt;
mbedtls_x509_crt *cert_prv;
mbedtls_x509_name *name_cur;
mbedtls_x509_name *name_prv;
mbedtls_x509_sequence *seq_cur;
mbedtls_x509_sequence *seq_prv;
if( crt == NULL )
return;
do
{
mbedtls_pk_free( &cert_cur->pk );
name_cur = cert_cur->issuer.next;
while( name_cur )
{
name_prv = name_cur;
name_cur = name_cur->next;
mbedtls_platform_zeroize( name_prv, sizeof( mbedtls_x509_name ) );
mbedtls_free( name_prv );
}
name_cur = cert_cur->subject.next;
while( name_cur )
{
name_prv = name_cur;
name_cur = name_cur->next;
mbedtls_platform_zeroize( name_prv, sizeof( mbedtls_x509_name ) );
mbedtls_free( name_prv );
}
seq_cur = cert_cur->ext_key_usage.next;
while( seq_cur )
{
seq_prv = seq_cur;
seq_cur = seq_cur->next;
mbedtls_platform_zeroize( seq_prv,
sizeof( mbedtls_x509_sequence ) );
mbedtls_free( seq_prv );
}
seq_cur = cert_cur->subject_alt_names.next;
while( seq_cur )
{
seq_prv = seq_cur;
seq_cur = seq_cur->next;
mbedtls_platform_zeroize( seq_prv,
sizeof( mbedtls_x509_sequence ) );
mbedtls_free( seq_prv );
}
seq_cur = cert_cur->certificate_policies.next;
while( seq_cur )
{
seq_prv = seq_cur;
seq_cur = seq_cur->next;
mbedtls_platform_zeroize( seq_prv,
sizeof( mbedtls_x509_sequence ) );
mbedtls_free( seq_prv );
}
if( cert_cur->raw.p && cert_cur->own_buffer )
{
mbedtls_platform_zeroize( cert_cur->raw.p, cert_cur->raw.len );
mbedtls_free( cert_cur->raw.p );
}
cert_cur = cert_cur->next;
}
while( cert_cur );
cert_cur = crt;
do
{
cert_prv = cert_cur;
cert_cur = cert_cur->next;
mbedtls_platform_zeroize( cert_prv, sizeof( mbedtls_x509_crt ) );
if( cert_prv != crt )
mbedtls_free( cert_prv );
}
while( cert_cur );
}
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
/**
* \brief Initialize a restart context
*/
void mbedtls_x509_crt_restart_init( mbedtls_x509_crt_restart_ctx *ctx )
{
mbedtls_pk_restart_init( &ctx->pk );
ctx->parent = NULL;
ctx->fallback_parent = NULL;
ctx->fallback_signature_is_good = 0;
ctx->parent_is_trusted = -1;
ctx->in_progress = x509_crt_rs_none;
ctx->self_cnt = 0;
x509_crt_verify_chain_reset( &ctx->ver_chain );
}
/**
* \brief Free the components of a restart context
*/
void mbedtls_x509_crt_restart_free( mbedtls_x509_crt_restart_ctx *ctx ) {
if( ctx == NULL )
return;
mbedtls_pk_restart_free( &ctx->pk );
mbedtls_x509_crt_restart_init( ctx );
}
#endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
#endif /* MBEDTLS_X509_CRT_PARSE_C */
| 125,634 | 3,289 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/pem.h | #ifndef MBEDTLS_PEM_H
#define MBEDTLS_PEM_H
#include "third_party/mbedtls/config.h"
/* clang-format off */
/**
* \name PEM Error codes
* These error codes are returned in case of errors reading the
* PEM data.
* \{
*/
#define MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT -0x1080 /*< No PEM header or footer found. */
#define MBEDTLS_ERR_PEM_INVALID_DATA -0x1100 /*< PEM string is not as expected. */
#define MBEDTLS_ERR_PEM_ALLOC_FAILED -0x1180 /*< Failed to allocate memory. */
#define MBEDTLS_ERR_PEM_INVALID_ENC_IV -0x1200 /*< RSA IV is not in hex-format. */
#define MBEDTLS_ERR_PEM_UNKNOWN_ENC_ALG -0x1280 /*< Unsupported key encryption algorithm. */
#define MBEDTLS_ERR_PEM_PASSWORD_REQUIRED -0x1300 /*< Private key password can't be empty. */
#define MBEDTLS_ERR_PEM_PASSWORD_MISMATCH -0x1380 /*< Given private key password does not allow for correct decryption. */
#define MBEDTLS_ERR_PEM_FEATURE_UNAVAILABLE -0x1400 /*< Unavailable feature, e.g. hashing/encryption combination. */
#define MBEDTLS_ERR_PEM_BAD_INPUT_DATA -0x1480 /*< Bad input parameters to function. */
/* \} name */
#ifdef __cplusplus
extern "C" {
#endif
#if defined(MBEDTLS_PEM_PARSE_C)
/**
* \brief PEM context structure
*/
typedef struct mbedtls_pem_context
{
unsigned char *buf; /*!< buffer for decoded data */
size_t buflen; /*!< length of the buffer */
unsigned char *info; /*!< buffer for extra header information */
}
mbedtls_pem_context;
/**
* \brief PEM context setup
*
* \param ctx context to be initialized
*/
void mbedtls_pem_init( mbedtls_pem_context *ctx );
/**
* \brief Read a buffer for PEM information and store the resulting
* data into the specified context buffers.
*
* \param ctx context to use
* \param header header string to seek and expect
* \param footer footer string to seek and expect
* \param data source data to look in (must be nul-terminated)
* \param pwd password for decryption (can be NULL)
* \param pwdlen length of password
* \param use_len destination for total length used (set after header is
* correctly read, so unless you get
* MBEDTLS_ERR_PEM_BAD_INPUT_DATA or
* MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT, use_len is
* the length to skip)
*
* \note Attempts to check password correctness by verifying if
* the decrypted text starts with an ASN.1 sequence of
* appropriate length
*
* \return 0 on success, or a specific PEM error code
*/
int mbedtls_pem_read_buffer( mbedtls_pem_context *ctx, const char *header, const char *footer,
const unsigned char *data,
const unsigned char *pwd,
size_t pwdlen, size_t *use_len );
/**
* \brief PEM context memory freeing
*
* \param ctx context to be freed
*/
void mbedtls_pem_free( mbedtls_pem_context *ctx );
#endif /* MBEDTLS_PEM_PARSE_C */
#if defined(MBEDTLS_PEM_WRITE_C)
/**
* \brief Write a buffer of PEM information from a DER encoded
* buffer.
*
* \param header The header string to write.
* \param footer The footer string to write.
* \param der_data The DER data to encode.
* \param der_len The length of the DER data \p der_data in Bytes.
* \param buf The buffer to write to.
* \param buf_len The length of the output buffer \p buf in Bytes.
* \param olen The address at which to store the total length written
* or required (if \p buf_len is not enough).
*
* \note You may pass \c NULL for \p buf and \c 0 for \p buf_len
* to request the length of the resulting PEM buffer in
* `*olen`.
*
* \note This function may be called with overlapping \p der_data
* and \p buf buffers.
*
* \return \c 0 on success.
* \return #MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL if \p buf isn't large
* enough to hold the PEM buffer. In this case, `*olen` holds
* the required minimum size of \p buf.
* \return Another PEM or BASE64 error code on other kinds of failure.
*/
int mbedtls_pem_write_buffer( const char *header, const char *footer,
const unsigned char *der_data, size_t der_len,
unsigned char *buf, size_t buf_len, size_t *olen );
#endif /* MBEDTLS_PEM_WRITE_C */
#ifdef __cplusplus
}
#endif
#endif /* pem.h */
| 4,748 | 118 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/chachapoly.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:4;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright The Mbed TLS Contributors â
â â
â Licensed under the Apache License, Version 2.0 (the "License"); â
â you may not use this file except in compliance with the License. â
â You may obtain a copy of the License at â
â â
â http://www.apache.org/licenses/LICENSE-2.0 â
â â
â Unless required by applicable law or agreed to in writing, software â
â distributed under the License is distributed on an "AS IS" BASIS, â
â WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. â
â See the License for the specific language governing permissions and â
â limitations under the License. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/str/str.h"
#include "third_party/mbedtls/chachapoly.h"
#include "third_party/mbedtls/chk.h"
#include "third_party/mbedtls/common.h"
#include "third_party/mbedtls/error.h"
#include "third_party/mbedtls/platform.h"
asm(".ident\t\"\\n\\n\
Mbed TLS (Apache 2.0)\\n\
Copyright ARM Limited\\n\
Copyright Mbed TLS Contributors\"");
asm(".include \"libc/disclaimer.inc\"");
/* clang-format off */
/**
* @fileoverview ChaCha20-Poly1305 AEAD construction based on RFC 7539.
*/
#if defined(MBEDTLS_CHACHAPOLY_C)
#if !defined(MBEDTLS_CHACHAPOLY_ALT)
/* Parameter validation macros */
#define CHACHAPOLY_VALIDATE_RET( cond ) \
MBEDTLS_INTERNAL_VALIDATE_RET( cond, MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA )
#define CHACHAPOLY_VALIDATE( cond ) \
MBEDTLS_INTERNAL_VALIDATE( cond )
#define CHACHAPOLY_STATE_INIT ( 0 )
#define CHACHAPOLY_STATE_AAD ( 1 )
#define CHACHAPOLY_STATE_CIPHERTEXT ( 2 ) /* Encrypting or decrypting */
#define CHACHAPOLY_STATE_FINISHED ( 3 )
/**
* \brief Adds nul bytes to pad the AAD for Poly1305.
*
* \param ctx The ChaCha20-Poly1305 context.
*/
static int chachapoly_pad_aad( mbedtls_chachapoly_context *ctx )
{
uint32_t partial_block_len = (uint32_t) ( ctx->aad_len % 16U );
unsigned char zeroes[15];
if( partial_block_len == 0U )
return( 0 );
mbedtls_platform_zeroize( zeroes, sizeof( zeroes ) );
return( mbedtls_poly1305_update( &ctx->poly1305_ctx,
zeroes,
16U - partial_block_len ) );
}
/**
* \brief Adds nul bytes to pad the ciphertext for Poly1305.
*
* \param ctx The ChaCha20-Poly1305 context.
*/
static int chachapoly_pad_ciphertext( mbedtls_chachapoly_context *ctx )
{
uint32_t partial_block_len = (uint32_t) ( ctx->ciphertext_len % 16U );
unsigned char zeroes[15];
if( partial_block_len == 0U )
return( 0 );
mbedtls_platform_zeroize( zeroes, sizeof( zeroes ) );
return( mbedtls_poly1305_update( &ctx->poly1305_ctx,
zeroes,
16U - partial_block_len ) );
}
void mbedtls_chachapoly_init( mbedtls_chachapoly_context *ctx )
{
CHACHAPOLY_VALIDATE( ctx );
mbedtls_chacha20_init( &ctx->chacha20_ctx );
mbedtls_poly1305_init( &ctx->poly1305_ctx );
ctx->aad_len = 0U;
ctx->ciphertext_len = 0U;
ctx->state = CHACHAPOLY_STATE_INIT;
ctx->mode = MBEDTLS_CHACHAPOLY_ENCRYPT;
}
void mbedtls_chachapoly_free( mbedtls_chachapoly_context *ctx )
{
if( ctx == NULL )
return;
mbedtls_chacha20_free( &ctx->chacha20_ctx );
mbedtls_poly1305_free( &ctx->poly1305_ctx );
ctx->aad_len = 0U;
ctx->ciphertext_len = 0U;
ctx->state = CHACHAPOLY_STATE_INIT;
ctx->mode = MBEDTLS_CHACHAPOLY_ENCRYPT;
}
int mbedtls_chachapoly_setkey( mbedtls_chachapoly_context *ctx,
const unsigned char key[32] )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
CHACHAPOLY_VALIDATE_RET( ctx );
CHACHAPOLY_VALIDATE_RET( key );
ret = mbedtls_chacha20_setkey( &ctx->chacha20_ctx, key );
return( ret );
}
int mbedtls_chachapoly_starts( mbedtls_chachapoly_context *ctx,
const unsigned char nonce[12],
mbedtls_chachapoly_mode_t mode )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
unsigned char poly1305_key[64];
CHACHAPOLY_VALIDATE_RET( ctx );
CHACHAPOLY_VALIDATE_RET( nonce );
/* Set counter = 0, will be update to 1 when generating Poly1305 key */
MBEDTLS_CHK( mbedtls_chacha20_starts( &ctx->chacha20_ctx, nonce, 0U ) );
/* Generate the Poly1305 key by getting the ChaCha20 keystream output with
* counter = 0. This is the same as encrypting a buffer of zeroes.
* Only the first 256-bits (32 bytes) of the key is used for Poly1305.
* The other 256 bits are discarded.
*/
mbedtls_platform_zeroize( poly1305_key, sizeof( poly1305_key ) );
MBEDTLS_CHK( mbedtls_chacha20_update( &ctx->chacha20_ctx, sizeof( poly1305_key ),
poly1305_key, poly1305_key ) );
ret = mbedtls_poly1305_starts( &ctx->poly1305_ctx, poly1305_key );
if( ret == 0 )
{
ctx->aad_len = 0U;
ctx->ciphertext_len = 0U;
ctx->state = CHACHAPOLY_STATE_AAD;
ctx->mode = mode;
}
cleanup:
mbedtls_platform_zeroize( poly1305_key, 64U );
return( ret );
}
int mbedtls_chachapoly_update_aad( mbedtls_chachapoly_context *ctx,
const unsigned char *aad,
size_t aad_len )
{
CHACHAPOLY_VALIDATE_RET( ctx );
CHACHAPOLY_VALIDATE_RET( aad_len == 0 || aad );
if( ctx->state != CHACHAPOLY_STATE_AAD )
return( MBEDTLS_ERR_CHACHAPOLY_BAD_STATE );
ctx->aad_len += aad_len;
return( mbedtls_poly1305_update( &ctx->poly1305_ctx, aad, aad_len ) );
}
int mbedtls_chachapoly_update( mbedtls_chachapoly_context *ctx,
size_t len,
const unsigned char *input,
unsigned char *output )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
CHACHAPOLY_VALIDATE_RET( ctx );
CHACHAPOLY_VALIDATE_RET( len == 0 || input );
CHACHAPOLY_VALIDATE_RET( len == 0 || output );
if( ( ctx->state != CHACHAPOLY_STATE_AAD ) &&
( ctx->state != CHACHAPOLY_STATE_CIPHERTEXT ) )
{
return( MBEDTLS_ERR_CHACHAPOLY_BAD_STATE );
}
if( ctx->state == CHACHAPOLY_STATE_AAD )
{
ctx->state = CHACHAPOLY_STATE_CIPHERTEXT;
ret = chachapoly_pad_aad( ctx );
if( ret != 0 )
return( ret );
}
ctx->ciphertext_len += len;
if( ctx->mode == MBEDTLS_CHACHAPOLY_ENCRYPT )
{
ret = mbedtls_chacha20_update( &ctx->chacha20_ctx, len, input, output );
if( ret != 0 )
return( ret );
ret = mbedtls_poly1305_update( &ctx->poly1305_ctx, output, len );
if( ret != 0 )
return( ret );
}
else /* DECRYPT */
{
ret = mbedtls_poly1305_update( &ctx->poly1305_ctx, input, len );
if( ret != 0 )
return( ret );
ret = mbedtls_chacha20_update( &ctx->chacha20_ctx, len, input, output );
if( ret != 0 )
return( ret );
}
return( 0 );
}
int mbedtls_chachapoly_finish( mbedtls_chachapoly_context *ctx,
unsigned char mac[16] )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
unsigned char len_block[16];
CHACHAPOLY_VALIDATE_RET( ctx );
CHACHAPOLY_VALIDATE_RET( mac );
if( ctx->state == CHACHAPOLY_STATE_INIT )
{
return( MBEDTLS_ERR_CHACHAPOLY_BAD_STATE );
}
if( ctx->state == CHACHAPOLY_STATE_AAD )
{
ret = chachapoly_pad_aad( ctx );
if( ret != 0 )
return( ret );
}
else if( ctx->state == CHACHAPOLY_STATE_CIPHERTEXT )
{
ret = chachapoly_pad_ciphertext( ctx );
if( ret != 0 )
return( ret );
}
ctx->state = CHACHAPOLY_STATE_FINISHED;
/* The lengths of the AAD and ciphertext are processed by
* Poly1305 as the final 128-bit block, encoded as little-endian integers.
*/
len_block[ 0] = (unsigned char)( ctx->aad_len );
len_block[ 1] = (unsigned char)( ctx->aad_len >> 8 );
len_block[ 2] = (unsigned char)( ctx->aad_len >> 16 );
len_block[ 3] = (unsigned char)( ctx->aad_len >> 24 );
len_block[ 4] = (unsigned char)( ctx->aad_len >> 32 );
len_block[ 5] = (unsigned char)( ctx->aad_len >> 40 );
len_block[ 6] = (unsigned char)( ctx->aad_len >> 48 );
len_block[ 7] = (unsigned char)( ctx->aad_len >> 56 );
len_block[ 8] = (unsigned char)( ctx->ciphertext_len );
len_block[ 9] = (unsigned char)( ctx->ciphertext_len >> 8 );
len_block[10] = (unsigned char)( ctx->ciphertext_len >> 16 );
len_block[11] = (unsigned char)( ctx->ciphertext_len >> 24 );
len_block[12] = (unsigned char)( ctx->ciphertext_len >> 32 );
len_block[13] = (unsigned char)( ctx->ciphertext_len >> 40 );
len_block[14] = (unsigned char)( ctx->ciphertext_len >> 48 );
len_block[15] = (unsigned char)( ctx->ciphertext_len >> 56 );
ret = mbedtls_poly1305_update( &ctx->poly1305_ctx, len_block, 16U );
if( ret != 0 )
return( ret );
ret = mbedtls_poly1305_finish( &ctx->poly1305_ctx, mac );
return( ret );
}
static int chachapoly_crypt_and_tag( mbedtls_chachapoly_context *ctx,
mbedtls_chachapoly_mode_t mode,
size_t length,
const unsigned char nonce[12],
const unsigned char *aad,
size_t aad_len,
const unsigned char *input,
unsigned char *output,
unsigned char tag[16] )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
MBEDTLS_CHK( mbedtls_chachapoly_starts( ctx, nonce, mode ) );
MBEDTLS_CHK( mbedtls_chachapoly_update_aad( ctx, aad, aad_len ) );
MBEDTLS_CHK( mbedtls_chachapoly_update( ctx, length, input, output ) );
MBEDTLS_CHK( mbedtls_chachapoly_finish( ctx, tag ) );
cleanup:
return( ret );
}
int mbedtls_chachapoly_encrypt_and_tag( mbedtls_chachapoly_context *ctx,
size_t length,
const unsigned char nonce[12],
const unsigned char *aad,
size_t aad_len,
const unsigned char *input,
unsigned char *output,
unsigned char tag[16] )
{
CHACHAPOLY_VALIDATE_RET( ctx );
CHACHAPOLY_VALIDATE_RET( nonce );
CHACHAPOLY_VALIDATE_RET( tag );
CHACHAPOLY_VALIDATE_RET( aad || !aad_len );
CHACHAPOLY_VALIDATE_RET( input || !length );
CHACHAPOLY_VALIDATE_RET( output || !length );
return( chachapoly_crypt_and_tag( ctx, MBEDTLS_CHACHAPOLY_ENCRYPT,
length, nonce, aad, aad_len,
input, output, tag ) );
}
int mbedtls_chachapoly_auth_decrypt( mbedtls_chachapoly_context *ctx,
size_t length,
const unsigned char nonce[12],
const unsigned char *aad,
size_t aad_len,
const unsigned char tag[16],
const unsigned char *input,
unsigned char *output )
{
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
unsigned char check_tag[16];
size_t i;
int diff;
CHACHAPOLY_VALIDATE_RET( ctx );
CHACHAPOLY_VALIDATE_RET( nonce );
CHACHAPOLY_VALIDATE_RET( tag );
CHACHAPOLY_VALIDATE_RET( aad_len == 0 || aad );
CHACHAPOLY_VALIDATE_RET( length == 0 || input );
CHACHAPOLY_VALIDATE_RET( length == 0 || output );
if( ( ret = chachapoly_crypt_and_tag( ctx,
MBEDTLS_CHACHAPOLY_DECRYPT, length, nonce,
aad, aad_len, input, output, check_tag ) ) != 0 )
{
return( ret );
}
/* Check tag in "constant-time" */
for( diff = 0, i = 0; i < sizeof( check_tag ); i++ )
diff |= tag[i] ^ check_tag[i];
if( diff != 0 )
{
mbedtls_platform_zeroize( output, length );
return( MBEDTLS_ERR_CHACHAPOLY_AUTH_FAILED );
}
return( 0 );
}
#endif /* MBEDTLS_CHACHAPOLY_ALT */
#if defined(MBEDTLS_SELF_TEST)
static const unsigned char test_key[1][32] =
{
{
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f
}
};
static const unsigned char test_nonce[1][12] =
{
{
0x07, 0x00, 0x00, 0x00, /* 32-bit common part */
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47 /* 64-bit IV */
}
};
static const unsigned char test_aad[1][12] =
{
{
0x50, 0x51, 0x52, 0x53, 0xc0, 0xc1, 0xc2, 0xc3,
0xc4, 0xc5, 0xc6, 0xc7
}
};
static const size_t test_aad_len[1] =
{
12U
};
static const unsigned char test_input[1][114] =
{
{
0x4c, 0x61, 0x64, 0x69, 0x65, 0x73, 0x20, 0x61,
0x6e, 0x64, 0x20, 0x47, 0x65, 0x6e, 0x74, 0x6c,
0x65, 0x6d, 0x65, 0x6e, 0x20, 0x6f, 0x66, 0x20,
0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x61, 0x73,
0x73, 0x20, 0x6f, 0x66, 0x20, 0x27, 0x39, 0x39,
0x3a, 0x20, 0x49, 0x66, 0x20, 0x49, 0x20, 0x63,
0x6f, 0x75, 0x6c, 0x64, 0x20, 0x6f, 0x66, 0x66,
0x65, 0x72, 0x20, 0x79, 0x6f, 0x75, 0x20, 0x6f,
0x6e, 0x6c, 0x79, 0x20, 0x6f, 0x6e, 0x65, 0x20,
0x74, 0x69, 0x70, 0x20, 0x66, 0x6f, 0x72, 0x20,
0x74, 0x68, 0x65, 0x20, 0x66, 0x75, 0x74, 0x75,
0x72, 0x65, 0x2c, 0x20, 0x73, 0x75, 0x6e, 0x73,
0x63, 0x72, 0x65, 0x65, 0x6e, 0x20, 0x77, 0x6f,
0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x69,
0x74, 0x2e
}
};
static const unsigned char test_output[1][114] =
{
{
0xd3, 0x1a, 0x8d, 0x34, 0x64, 0x8e, 0x60, 0xdb,
0x7b, 0x86, 0xaf, 0xbc, 0x53, 0xef, 0x7e, 0xc2,
0xa4, 0xad, 0xed, 0x51, 0x29, 0x6e, 0x08, 0xfe,
0xa9, 0xe2, 0xb5, 0xa7, 0x36, 0xee, 0x62, 0xd6,
0x3d, 0xbe, 0xa4, 0x5e, 0x8c, 0xa9, 0x67, 0x12,
0x82, 0xfa, 0xfb, 0x69, 0xda, 0x92, 0x72, 0x8b,
0x1a, 0x71, 0xde, 0x0a, 0x9e, 0x06, 0x0b, 0x29,
0x05, 0xd6, 0xa5, 0xb6, 0x7e, 0xcd, 0x3b, 0x36,
0x92, 0xdd, 0xbd, 0x7f, 0x2d, 0x77, 0x8b, 0x8c,
0x98, 0x03, 0xae, 0xe3, 0x28, 0x09, 0x1b, 0x58,
0xfa, 0xb3, 0x24, 0xe4, 0xfa, 0xd6, 0x75, 0x94,
0x55, 0x85, 0x80, 0x8b, 0x48, 0x31, 0xd7, 0xbc,
0x3f, 0xf4, 0xde, 0xf0, 0x8e, 0x4b, 0x7a, 0x9d,
0xe5, 0x76, 0xd2, 0x65, 0x86, 0xce, 0xc6, 0x4b,
0x61, 0x16
}
};
static const size_t test_input_len[1] =
{
114U
};
static const unsigned char test_mac[1][16] =
{
{
0x1a, 0xe1, 0x0b, 0x59, 0x4f, 0x09, 0xe2, 0x6a,
0x7e, 0x90, 0x2e, 0xcb, 0xd0, 0x60, 0x06, 0x91
}
};
/* Make sure no other definition is already present. */
#undef ASSERT
#define ASSERT( cond, args ) \
do \
{ \
if( ! ( cond ) ) \
{ \
if( verbose != 0 ) \
mbedtls_printf args; \
\
return( -1 ); \
} \
} \
while( 0 )
int mbedtls_chachapoly_self_test( int verbose )
{
mbedtls_chachapoly_context ctx;
unsigned i;
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
unsigned char output[200];
unsigned char mac[16];
for( i = 0U; i < 1U; i++ )
{
if( verbose != 0 )
mbedtls_printf( " ChaCha20-Poly1305 test %u ", i );
mbedtls_chachapoly_init( &ctx );
ret = mbedtls_chachapoly_setkey( &ctx, test_key[i] );
ASSERT( 0 == ret, ( "setkey() error code: %i\n", ret ) );
ret = mbedtls_chachapoly_encrypt_and_tag( &ctx,
test_input_len[i],
test_nonce[i],
test_aad[i],
test_aad_len[i],
test_input[i],
output,
mac );
ASSERT( 0 == ret, ( "crypt_and_tag() error code: %i\n", ret ) );
ASSERT( 0 == timingsafe_bcmp( output, test_output[i], test_input_len[i] ),
( "failure (wrong output)\n" ) );
ASSERT( 0 == timingsafe_bcmp( mac, test_mac[i], 16U ),
( "failure (wrong MAC)\n" ) );
mbedtls_chachapoly_free( &ctx );
if( verbose != 0 )
mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
mbedtls_printf( "\n" );
return( 0 );
}
#endif /* MBEDTLS_SELF_TEST */
#endif /* MBEDTLS_CHACHAPOLY_C */
| 18,568 | 497 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/shiftright.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2021 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/nexgen32e/x86feature.h"
#include "third_party/mbedtls/bignum_internal.h"
void (*ShiftRight)(uint64_t *, size_t, unsigned char);
static textstartup void ShiftRightInit(void) {
ShiftRight = 0 && X86_HAVE(AVX) ? ShiftRightAvx : ShiftRightPure;
}
const void *const ShiftRightCtor[] initarray = {ShiftRightInit};
| 2,164 | 29 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/ssl_cache.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:4;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright The Mbed TLS Contributors â
â â
â Licensed under the Apache License, Version 2.0 (the "License"); â
â you may not use this file except in compliance with the License. â
â You may obtain a copy of the License at â
â â
â http://www.apache.org/licenses/LICENSE-2.0 â
â â
â Unless required by applicable law or agreed to in writing, software â
â distributed under the License is distributed on an "AS IS" BASIS, â
â WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. â
â See the License for the specific language governing permissions and â
â limitations under the License. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/log/log.h"
#include "libc/time/time.h"
#include "third_party/mbedtls/common.h"
#include "third_party/mbedtls/platform.h"
#include "third_party/mbedtls/ssl_cache.h"
#include "third_party/mbedtls/ssl_internal.h"
asm(".ident\t\"\\n\\n\
Mbed TLS (Apache 2.0)\\n\
Copyright ARM Limited\\n\
Copyright Mbed TLS Contributors\"");
asm(".include \"libc/disclaimer.inc\"");
/* clang-format off */
/*
* SSL session cache implementation
*
* Copyright The Mbed TLS Contributors
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* These session callbacks use a simple chained list
* to store and retrieve the session information.
*/
#if defined(MBEDTLS_SSL_CACHE_C)
void mbedtls_ssl_cache_init( mbedtls_ssl_cache_context *cache )
{
mbedtls_platform_zeroize( cache, sizeof( mbedtls_ssl_cache_context ) );
cache->timeout = MBEDTLS_SSL_CACHE_DEFAULT_TIMEOUT;
cache->max_entries = MBEDTLS_SSL_CACHE_DEFAULT_MAX_ENTRIES;
}
int mbedtls_ssl_cache_get( void *data, mbedtls_ssl_session *session )
{
int ret = 1;
#if defined(MBEDTLS_HAVE_TIME)
mbedtls_time_t t = mbedtls_time( NULL );
#endif
mbedtls_ssl_cache_context *cache = (mbedtls_ssl_cache_context *) data;
mbedtls_ssl_cache_entry *cur, *entry;
cur = cache->chain;
entry = NULL;
while( cur != NULL )
{
entry = cur;
cur = cur->next;
#if defined(MBEDTLS_HAVE_TIME)
if( cache->timeout != 0 &&
(int) ( t - entry->timestamp ) > cache->timeout )
continue;
#endif
if( session->ciphersuite != entry->session.ciphersuite ||
session->compression != entry->session.compression ||
session->id_len != entry->session.id_len )
continue;
if( timingsafe_bcmp( session->id, entry->session.id,
entry->session.id_len ) != 0 )
continue;
ret = mbedtls_ssl_session_copy( session, &entry->session );
if( ret != 0 )
{
ret = 1;
goto exit;
}
#if defined(MBEDTLS_X509_CRT_PARSE_C) && \
defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
/*
* Restore peer certificate (without rest of the original chain)
*/
if( entry->peer_cert.p != NULL )
{
/* `session->peer_cert` is NULL after the call to
* mbedtls_ssl_session_copy(), because cache entries
* have the `peer_cert` field set to NULL. */
if( ( session->peer_cert = mbedtls_calloc( 1,
sizeof(mbedtls_x509_crt) ) ) == NULL )
{
ret = 1;
goto exit;
}
mbedtls_x509_crt_init( session->peer_cert );
if( mbedtls_x509_crt_parse( session->peer_cert, entry->peer_cert.p,
entry->peer_cert.len ) != 0 )
{
mbedtls_free( session->peer_cert );
session->peer_cert = NULL;
ret = 1;
goto exit;
}
}
#endif /* MBEDTLS_X509_CRT_PARSE_C && MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
ret = 0;
goto exit;
}
exit:
return( ret );
}
int mbedtls_ssl_cache_set( void *data, const mbedtls_ssl_session *session )
{
int ret = 1;
#if defined(MBEDTLS_HAVE_TIME)
mbedtls_time_t t = mbedtls_time( NULL ), oldest = 0;
mbedtls_ssl_cache_entry *old = NULL;
#endif
mbedtls_ssl_cache_context *cache = (mbedtls_ssl_cache_context *) data;
mbedtls_ssl_cache_entry *cur, *prv;
int count = 0;
cur = cache->chain;
prv = NULL;
while( cur != NULL )
{
count++;
#if defined(MBEDTLS_HAVE_TIME)
if( cache->timeout != 0 &&
(int) ( t - cur->timestamp ) > cache->timeout )
{
cur->timestamp = t;
break; /* expired, reuse this slot, update timestamp */
}
#endif
if( timingsafe_bcmp( session->id, cur->session.id, cur->session.id_len ) == 0 )
break; /* client reconnected, keep timestamp for session id */
#if defined(MBEDTLS_HAVE_TIME)
if( oldest == 0 || cur->timestamp < oldest )
{
oldest = cur->timestamp;
old = cur;
}
#endif
prv = cur;
cur = cur->next;
}
if( cur == NULL )
{
#if defined(MBEDTLS_HAVE_TIME)
/*
* Reuse oldest entry if max_entries reached
*/
if( count >= cache->max_entries )
{
if( old == NULL )
{
ret = 1;
goto exit;
}
cur = old;
}
#else /* MBEDTLS_HAVE_TIME */
/*
* Reuse first entry in chain if max_entries reached,
* but move to last place
*/
if( count >= cache->max_entries )
{
if( cache->chain == NULL )
{
ret = 1;
goto exit;
}
cur = cache->chain;
cache->chain = cur->next;
cur->next = NULL;
prv->next = cur;
}
#endif /* MBEDTLS_HAVE_TIME */
else
{
/*
* max_entries not reached, create new entry
*/
cur = mbedtls_calloc( 1, sizeof(mbedtls_ssl_cache_entry) );
if( cur == NULL )
{
ret = 1;
goto exit;
}
if( prv == NULL )
cache->chain = cur;
else
prv->next = cur;
}
#if defined(MBEDTLS_HAVE_TIME)
cur->timestamp = t;
#endif
}
#if defined(MBEDTLS_X509_CRT_PARSE_C) && \
defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
/*
* If we're reusing an entry, free its certificate first
*/
if( cur->peer_cert.p != NULL )
{
mbedtls_free( cur->peer_cert.p );
mbedtls_platform_zeroize( &cur->peer_cert, sizeof(mbedtls_x509_buf) );
}
#endif /* MBEDTLS_X509_CRT_PARSE_C && MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
/* Copy the entire session; this temporarily makes a copy of the
* X.509 CRT structure even though we only want to store the raw CRT.
* This inefficiency will go away as soon as we implement on-demand
* parsing of CRTs, in which case there's no need for the `peer_cert`
* field anymore in the first place, and we're done after this call. */
ret = mbedtls_ssl_session_copy( &cur->session, session );
if( ret != 0 )
{
ret = 1;
goto exit;
}
#if defined(MBEDTLS_X509_CRT_PARSE_C) && \
defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
/* If present, free the X.509 structure and only store the raw CRT data. */
if( cur->session.peer_cert != NULL )
{
cur->peer_cert.p =
mbedtls_calloc( 1, cur->session.peer_cert->raw.len );
if( cur->peer_cert.p == NULL )
{
ret = 1;
goto exit;
}
memcpy( cur->peer_cert.p,
cur->session.peer_cert->raw.p,
cur->session.peer_cert->raw.len );
cur->peer_cert.len = session->peer_cert->raw.len;
mbedtls_x509_crt_free( cur->session.peer_cert );
mbedtls_free( cur->session.peer_cert );
cur->session.peer_cert = NULL;
}
#endif /* MBEDTLS_X509_CRT_PARSE_C && MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
ret = 0;
exit:
return( ret );
}
#if defined(MBEDTLS_HAVE_TIME)
void mbedtls_ssl_cache_set_timeout( mbedtls_ssl_cache_context *cache, int timeout )
{
if( timeout < 0 ) timeout = 0;
cache->timeout = timeout;
}
#endif /* MBEDTLS_HAVE_TIME */
void mbedtls_ssl_cache_set_max_entries( mbedtls_ssl_cache_context *cache, int max )
{
if( max < 0 ) max = 0;
cache->max_entries = max;
}
void mbedtls_ssl_cache_free( mbedtls_ssl_cache_context *cache )
{
mbedtls_ssl_cache_entry *cur, *prv;
cur = cache->chain;
while( cur != NULL )
{
prv = cur;
cur = cur->next;
mbedtls_ssl_session_free( &prv->session );
#if defined(MBEDTLS_X509_CRT_PARSE_C) && \
defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
mbedtls_free( prv->peer_cert.p );
#endif /* MBEDTLS_X509_CRT_PARSE_C && MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
mbedtls_free( prv );
}
cache->chain = NULL;
}
#endif /* MBEDTLS_SSL_CACHE_C */
| 10,618 | 336 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/gcm.h | #ifndef MBEDTLS_GCM_H_
#define MBEDTLS_GCM_H_
#include "third_party/mbedtls/cipher.h"
#include "third_party/mbedtls/config.h"
COSMOPOLITAN_C_START_
/* clang-format off */
#define MBEDTLS_GCM_ENCRYPT 1
#define MBEDTLS_GCM_DECRYPT 0
#define MBEDTLS_ERR_GCM_AUTH_FAILED -0x0012 /*< Authenticated decryption failed. */
#define MBEDTLS_ERR_GCM_BAD_INPUT -0x0014 /*< Bad input parameters to function. */
typedef struct mbedtls_gcm_context {
mbedtls_cipher_context_t cipher_ctx; /*!< The cipher context used. */
uint64_t len; /*!< The total length of the encrypted data. */
uint64_t add_len; /*!< The total length of the additional data. */
unsigned char base_ectr[16]; /*!< The first ECTR for tag. */
unsigned char y[16]; /*!< The Y working value. */
unsigned char buf[16]; /*!< The buf working value. */
int mode; /*!< The operation to perform: #MBEDTLS_GCM_ENCRYPT or #MBEDTLS_GCM_DECRYPT. */
uint64_t H8[2]; /*!< For AES-NI. */
uint64_t HL[16]; /*!< Precalculated HTable low. */
uint64_t HH[16]; /*!< Precalculated HTable high. */
mbedtls_cipher_id_t cipher; /*!< The cipher being used. */
} mbedtls_gcm_context;
void mbedtls_gcm_init( mbedtls_gcm_context * );
int mbedtls_gcm_setkey( mbedtls_gcm_context *, mbedtls_cipher_id_t, const unsigned char *, unsigned int );
int mbedtls_gcm_crypt_and_tag( mbedtls_gcm_context *, int, size_t, const unsigned char *, size_t, const unsigned char *, size_t, const unsigned char *, unsigned char *, size_t, unsigned char * );
int mbedtls_gcm_auth_decrypt( mbedtls_gcm_context *, size_t, const unsigned char *, size_t, const unsigned char *, size_t, const unsigned char *, size_t, const unsigned char *, unsigned char * );
int mbedtls_gcm_starts( mbedtls_gcm_context *, int, const unsigned char *, size_t, const unsigned char *, size_t );
int mbedtls_gcm_update( mbedtls_gcm_context *, size_t, const unsigned char *, unsigned char * );
int mbedtls_gcm_finish( mbedtls_gcm_context *, unsigned char *, size_t );
void mbedtls_gcm_free( mbedtls_gcm_context * );
int mbedtls_gcm_self_test( int );
COSMOPOLITAN_C_END_
#endif /* MBEDTLS_GCM_H_ */
| 2,367 | 40 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/pk.h | #ifndef COSMOPOLITAN_THIRD_PARTY_MBEDTLS_PK_H_
#define COSMOPOLITAN_THIRD_PARTY_MBEDTLS_PK_H_
#include "third_party/mbedtls/config.h"
#include "third_party/mbedtls/ecdsa.h"
#include "third_party/mbedtls/ecp.h"
#include "third_party/mbedtls/md.h"
#include "third_party/mbedtls/rsa.h"
COSMOPOLITAN_C_START_
/* clang-format off */
#define MBEDTLS_ERR_PK_ALLOC_FAILED -0x3F80 /*< Memory allocation failed. */
#define MBEDTLS_ERR_PK_TYPE_MISMATCH -0x3F00 /*< Type mismatch, eg attempt to encrypt with an ECDSA key */
#define MBEDTLS_ERR_PK_BAD_INPUT_DATA -0x3E80 /*< Bad input parameters to function. */
#define MBEDTLS_ERR_PK_FILE_IO_ERROR -0x3E00 /*< Read/write of file failed. */
#define MBEDTLS_ERR_PK_KEY_INVALID_VERSION -0x3D80 /*< Unsupported key version */
#define MBEDTLS_ERR_PK_KEY_INVALID_FORMAT -0x3D00 /*< Invalid key tag or value. */
#define MBEDTLS_ERR_PK_UNKNOWN_PK_ALG -0x3C80 /*< Key algorithm is unsupported (only RSA and EC are supported). */
#define MBEDTLS_ERR_PK_PASSWORD_REQUIRED -0x3C00 /*< Private key password can't be empty. */
#define MBEDTLS_ERR_PK_PASSWORD_MISMATCH -0x3B80 /*< Given private key password does not allow for correct decryption. */
#define MBEDTLS_ERR_PK_INVALID_PUBKEY -0x3B00 /*< The pubkey tag or value is invalid (only RSA and EC are supported). */
#define MBEDTLS_ERR_PK_INVALID_ALG -0x3A80 /*< The algorithm tag or value is invalid. */
#define MBEDTLS_ERR_PK_UNKNOWN_NAMED_CURVE -0x3A00 /*< Elliptic curve is unsupported (only NIST curves are supported). */
#define MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE -0x3980 /*< Unavailable feature, e.g. RSA disabled for RSA key. */
#define MBEDTLS_ERR_PK_SIG_LEN_MISMATCH -0x3900 /*< The buffer contains a valid signature followed by more data. */
/* MBEDTLS_ERR_PK_HW_ACCEL_FAILED is deprecated and should not be used. */
#define MBEDTLS_ERR_PK_HW_ACCEL_FAILED -0x3880 /*< PK hardware accelerator failed. */
/**
* \brief Public key types
*/
typedef enum {
MBEDTLS_PK_NONE=0,
MBEDTLS_PK_RSA,
MBEDTLS_PK_ECKEY,
MBEDTLS_PK_ECKEY_DH,
MBEDTLS_PK_ECDSA,
MBEDTLS_PK_RSA_ALT,
MBEDTLS_PK_RSASSA_PSS,
MBEDTLS_PK_OPAQUE,
} mbedtls_pk_type_t;
/**
* \brief Options for RSASSA-PSS signature verification.
* See \c mbedtls_rsa_rsassa_pss_verify_ext()
*/
typedef struct mbedtls_pk_rsassa_pss_options
{
mbedtls_md_type_t mgf1_hash_id;
int expected_salt_len;
} mbedtls_pk_rsassa_pss_options;
/**
* \brief Maximum size of a signature made by mbedtls_pk_sign().
*/
/* We need to set MBEDTLS_PK_SIGNATURE_MAX_SIZE to the maximum signature
* size among the supported signature types. Do it by starting at 0,
* then incrementally increasing to be large enough for each supported
* signature mechanism.
*
* The resulting value can be 0, for example if MBEDTLS_ECDH_C is enabled
* (which allows the pk module to be included) but neither MBEDTLS_ECDSA_C
* nor MBEDTLS_RSA_C nor any opaque signature mechanism (PSA or RSA_ALT).
*/
#define MBEDTLS_PK_SIGNATURE_MAX_SIZE 0
#if ( defined(MBEDTLS_RSA_C) || defined(MBEDTLS_PK_RSA_ALT_SUPPORT) ) && \
MBEDTLS_MPI_MAX_SIZE > MBEDTLS_PK_SIGNATURE_MAX_SIZE
/* For RSA, the signature can be as large as the bignum module allows.
* For RSA_ALT, the signature size is not necessarily tied to what the
* bignum module can do, but in the absence of any specific setting,
* we use that (rsa_alt_sign_wrap in pk_wrap will check). */
#undef MBEDTLS_PK_SIGNATURE_MAX_SIZE
#define MBEDTLS_PK_SIGNATURE_MAX_SIZE MBEDTLS_MPI_MAX_SIZE
#endif
#if defined(MBEDTLS_ECDSA_C) && \
MBEDTLS_ECDSA_MAX_LEN > MBEDTLS_PK_SIGNATURE_MAX_SIZE
/* For ECDSA, the ecdsa module exports a constant for the maximum
* signature size. */
#undef MBEDTLS_PK_SIGNATURE_MAX_SIZE
#define MBEDTLS_PK_SIGNATURE_MAX_SIZE MBEDTLS_ECDSA_MAX_LEN
#endif
#if defined(MBEDTLS_USE_PSA_CRYPTO)
#if PSA_SIGNATURE_MAX_SIZE > MBEDTLS_PK_SIGNATURE_MAX_SIZE
/* PSA_SIGNATURE_MAX_SIZE is the maximum size of a signature made
* through the PSA API in the PSA representation. */
#undef MBEDTLS_PK_SIGNATURE_MAX_SIZE
#define MBEDTLS_PK_SIGNATURE_MAX_SIZE PSA_SIGNATURE_MAX_SIZE
#endif
#if PSA_VENDOR_ECDSA_SIGNATURE_MAX_SIZE + 11 > MBEDTLS_PK_SIGNATURE_MAX_SIZE
/* The Mbed TLS representation is different for ECDSA signatures:
* PSA uses the raw concatenation of r and s,
* whereas Mbed TLS uses the ASN.1 representation (SEQUENCE of two INTEGERs).
* Add the overhead of ASN.1: up to (1+2) + 2 * (1+2+1) for the
* types, lengths (represented by up to 2 bytes), and potential leading
* zeros of the INTEGERs and the SEQUENCE. */
#undef MBEDTLS_PK_SIGNATURE_MAX_SIZE
#define MBEDTLS_PK_SIGNATURE_MAX_SIZE ( PSA_VENDOR_ECDSA_SIGNATURE_MAX_SIZE + 11 )
#endif
#endif /* defined(MBEDTLS_USE_PSA_CRYPTO) */
/**
* \brief Types for interfacing with the debug module
*/
typedef enum
{
MBEDTLS_PK_DEBUG_NONE = 0,
MBEDTLS_PK_DEBUG_MPI,
MBEDTLS_PK_DEBUG_ECP,
} mbedtls_pk_debug_type;
/**
* \brief Item to send to the debug module
*/
typedef struct mbedtls_pk_debug_item
{
mbedtls_pk_debug_type type;
const char *name;
void *value;
} mbedtls_pk_debug_item;
/** Maximum number of item send for debugging, plus 1 */
#define MBEDTLS_PK_DEBUG_MAX_ITEMS 3
/**
* \brief Public key information and operations
*/
typedef struct mbedtls_pk_info_t mbedtls_pk_info_t;
/**
* \brief Public key container
*/
typedef struct mbedtls_pk_context
{
const mbedtls_pk_info_t * pk_info; /*< Public key information */
void * pk_ctx; /*< Underlying public key context */
} mbedtls_pk_context;
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
/**
* \brief Context for resuming operations
*/
typedef struct
{
const mbedtls_pk_info_t * pk_info; /*< Public key information */
void * rs_ctx; /*< Underlying restart context */
} mbedtls_pk_restart_ctx;
#else /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
/* Now we can declare functions that take a pointer to that */
typedef void mbedtls_pk_restart_ctx;
#endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
/**
* Quick access to an RSA context inside a PK context.
*
* \warning You must make sure the PK context actually holds an RSA context
* before using this function!
*/
static inline mbedtls_rsa_context *mbedtls_pk_rsa( const mbedtls_pk_context pk )
{
return( (mbedtls_rsa_context *) (pk).pk_ctx );
}
/**
* Quick access to an EC context inside a PK context.
*
* \warning You must make sure the PK context actually holds an EC context
* before using this function!
*/
static inline mbedtls_ecp_keypair *mbedtls_pk_ec( const mbedtls_pk_context pk )
{
return( (mbedtls_ecp_keypair *) (pk).pk_ctx );
}
/**
* \brief Types for RSA-alt abstraction
*/
typedef int (*mbedtls_pk_rsa_alt_decrypt_func)( void *ctx, int mode, size_t *olen,
const unsigned char *input, unsigned char *output,
size_t output_max_len );
typedef int (*mbedtls_pk_rsa_alt_sign_func)( void *ctx,
int (*f_rng)(void *, unsigned char *, size_t), void *p_rng,
int mode, mbedtls_md_type_t md_alg, unsigned int hashlen,
const unsigned char *hash, unsigned char *sig );
typedef size_t (*mbedtls_pk_rsa_alt_key_len_func)( void *ctx );
const mbedtls_pk_info_t *mbedtls_pk_info_from_type( mbedtls_pk_type_t );
void mbedtls_pk_init( mbedtls_pk_context * );
void mbedtls_pk_free( mbedtls_pk_context * );
void mbedtls_pk_restart_init( mbedtls_pk_restart_ctx * );
void mbedtls_pk_restart_free( mbedtls_pk_restart_ctx * );
int mbedtls_pk_setup( mbedtls_pk_context *, const mbedtls_pk_info_t * );
int mbedtls_pk_setup_rsa_alt( mbedtls_pk_context *, void *, mbedtls_pk_rsa_alt_decrypt_func, mbedtls_pk_rsa_alt_sign_func, mbedtls_pk_rsa_alt_key_len_func );
size_t mbedtls_pk_get_bitlen( const mbedtls_pk_context * );
const char * mbedtls_pk_get_name( const mbedtls_pk_context * );
const char *mbedtls_pk_type_name(mbedtls_pk_type_t);
int mbedtls_pk_can_do( const mbedtls_pk_context *, mbedtls_pk_type_t );
int mbedtls_pk_check_pair( const mbedtls_pk_context *, const mbedtls_pk_context * );
int mbedtls_pk_debug( const mbedtls_pk_context *, mbedtls_pk_debug_item * );
int mbedtls_pk_decrypt( mbedtls_pk_context *, const unsigned char *, size_t, unsigned char *, size_t *, size_t, int (*)(void *, unsigned char *, size_t), void * );
int mbedtls_pk_encrypt( mbedtls_pk_context *, const unsigned char *, size_t, unsigned char *, size_t *, size_t, int (*)(void *, unsigned char *, size_t), void * );
int mbedtls_pk_load_file( const char *, unsigned char **, size_t * );
int mbedtls_pk_parse_key( mbedtls_pk_context *, const unsigned char *, size_t, const unsigned char *, size_t );
int mbedtls_pk_parse_keyfile( mbedtls_pk_context *, const char *, const char * );
int mbedtls_pk_parse_public_key( mbedtls_pk_context *, const unsigned char *, size_t );
int mbedtls_pk_parse_public_keyfile( mbedtls_pk_context *, const char * );
int mbedtls_pk_parse_subpubkey( unsigned char **, const unsigned char *, mbedtls_pk_context * );
int mbedtls_pk_sign( mbedtls_pk_context *, mbedtls_md_type_t, const unsigned char *, size_t, unsigned char *, size_t *, int (*)(void *, unsigned char *, size_t), void * );
int mbedtls_pk_sign_restartable( mbedtls_pk_context *, mbedtls_md_type_t, const unsigned char *, size_t, unsigned char *, size_t *, int (*)(void *, unsigned char *, size_t), void *, mbedtls_pk_restart_ctx * );
int mbedtls_pk_verify( mbedtls_pk_context *, mbedtls_md_type_t, const unsigned char *, size_t, const unsigned char *, size_t );
int mbedtls_pk_verify_ext( mbedtls_pk_type_t, const void *, mbedtls_pk_context *, mbedtls_md_type_t, const unsigned char *, size_t, const unsigned char *, size_t );
int mbedtls_pk_verify_restartable( mbedtls_pk_context *, mbedtls_md_type_t, const unsigned char *, size_t, const unsigned char *, size_t, mbedtls_pk_restart_ctx * );
int mbedtls_pk_write_key_der( mbedtls_pk_context *, unsigned char *, size_t );
int mbedtls_pk_write_key_pem( mbedtls_pk_context *, unsigned char *, size_t );
int mbedtls_pk_write_pubkey( unsigned char **, unsigned char *, const mbedtls_pk_context * );
int mbedtls_pk_write_pubkey_der( mbedtls_pk_context *, unsigned char *, size_t );
int mbedtls_pk_write_pubkey_pem( mbedtls_pk_context *, unsigned char *, size_t );
mbedtls_pk_type_t mbedtls_pk_get_type( const mbedtls_pk_context * );
/**
* \brief Get the length in bytes of the underlying key
*
* \param ctx The context to query. It must have been initialized.
*
* \return Key length in bytes, or 0 on error
*/
static inline size_t mbedtls_pk_get_len( const mbedtls_pk_context *ctx )
{
return( ( mbedtls_pk_get_bitlen( ctx ) + 7 ) / 8 );
}
COSMOPOLITAN_C_END_
#endif /* COSMOPOLITAN_THIRD_PARTY_MBEDTLS_PK_H_ */
| 11,024 | 238 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_ssl.c | /* clang-format off */
/*
* Copyright The Mbed TLS Contributors
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "third_party/mbedtls/test/test.inc"
#include "third_party/mbedtls/ssl_invasive.h"
#include "libc/testlib/testlib.h"
#include "libc/log/log.h"
#include "libc/time/time.h"
#include "libc/stdio/rand.h"
#include "libc/intrin/safemacros.internal.h"
#include "third_party/mbedtls/test/test.inc"
/*
* *** THIS FILE WAS MACHINE GENERATED ***
*
* This file has been machine generated using the script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* Test file : ./test_suite_ssl.c
*
* The following files were used to create this file.
*
* Main code file : suites/main_test.function
* Platform code file : suites/host_test.function
* Helper file : suites/helpers.function
* Test suite file : suites/test_suite_ssl.function
* Test suite data : suites/test_suite_ssl.data
*
*/
#define TEST_SUITE_ACTIVE
#if defined(MBEDTLS_SSL_TLS_C)
#include "third_party/mbedtls/ssl.h"
#include "third_party/mbedtls/ssl_internal.h"
#include "third_party/mbedtls/ctr_drbg.h"
#include "third_party/mbedtls/entropy.h"
#include "third_party/mbedtls/certs.h"
#include "third_party/mbedtls/debug.h"
#include "third_party/mbedtls/ssl_tls13_keys.h"
enum
{
#define MBEDTLS_SSL_TLS1_3_LABEL( name, string ) \
tls1_3_label_ ## name,
MBEDTLS_SSL_TLS1_3_LABEL_LIST
#undef MBEDTLS_SSL_TLS1_3_LABEL
};
typedef struct log_pattern
{
const char *pattern;
size_t counter;
} log_pattern;
/*
* This function can be passed to mbedtls to receive output logs from it. In
* this case, it will count the instances of a log_pattern in the received
* logged messages.
*/
void log_analyzer( void *ctx, int level,
const char *file, int line,
const char *str )
{
log_pattern *p = (log_pattern *) ctx;
(void) level;
(void) line;
(void) file;
if( NULL != p &&
NULL != p->pattern &&
NULL != strstr( str, p->pattern ) )
{
p->counter++;
}
}
/* Invalid minor version used when not specifying a min/max version or expecting a test to fail */
#define TEST_SSL_MINOR_VERSION_NONE -1
typedef struct handshake_test_options
{
const char *cipher;
int client_min_version;
int client_max_version;
int server_min_version;
int server_max_version;
int expected_negotiated_version;
int pk_alg;
data_t *psk_str;
int dtls;
int srv_auth_mode;
int serialize;
int mfl;
int cli_msg_len;
int srv_msg_len;
int expected_cli_fragments;
int expected_srv_fragments;
int renegotiate;
int legacy_renegotiation;
void *srv_log_obj;
void *cli_log_obj;
void (*srv_log_fun)(void *, int, const char *, int, const char *);
void (*cli_log_fun)(void *, int, const char *, int, const char *);
int resize_buffers;
} handshake_test_options;
void init_handshake_options( handshake_test_options *opts )
{
opts->cipher = "";
opts->client_min_version = TEST_SSL_MINOR_VERSION_NONE;
opts->client_max_version = TEST_SSL_MINOR_VERSION_NONE;
opts->server_min_version = TEST_SSL_MINOR_VERSION_NONE;
opts->server_max_version = TEST_SSL_MINOR_VERSION_NONE;
opts->expected_negotiated_version = MBEDTLS_SSL_MINOR_VERSION_3;
opts->pk_alg = MBEDTLS_PK_RSA;
opts->psk_str = NULL;
opts->dtls = 0;
opts->srv_auth_mode = MBEDTLS_SSL_VERIFY_NONE;
opts->serialize = 0;
opts->mfl = MBEDTLS_SSL_MAX_FRAG_LEN_NONE;
opts->cli_msg_len = 100;
opts->srv_msg_len = 100;
opts->expected_cli_fragments = 1;
opts->expected_srv_fragments = 1;
opts->renegotiate = 0;
opts->legacy_renegotiation = MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION;
opts->srv_log_obj = NULL;
opts->srv_log_obj = NULL;
opts->srv_log_fun = NULL;
opts->cli_log_fun = NULL;
opts->resize_buffers = 1;
}
/*
* Buffer structure for custom I/O callbacks.
*/
typedef struct mbedtls_test_buffer
{
size_t start;
size_t content_length;
size_t capacity;
unsigned char *buffer;
} mbedtls_test_buffer;
/*
* Initialises \p buf. After calling this function it is safe to call
* `mbedtls_test_buffer_free()` on \p buf.
*/
void mbedtls_test_buffer_init( mbedtls_test_buffer *buf )
{
memset( buf, 0, sizeof( *buf ) );
}
/*
* Sets up \p buf. After calling this function it is safe to call
* `mbedtls_test_buffer_put()` and `mbedtls_test_buffer_get()` on \p buf.
*/
int mbedtls_test_buffer_setup( mbedtls_test_buffer *buf, size_t capacity )
{
buf->buffer = (unsigned char*) mbedtls_calloc( capacity,
sizeof(unsigned char) );
if( NULL == buf->buffer )
return MBEDTLS_ERR_SSL_ALLOC_FAILED;
buf->capacity = capacity;
return 0;
}
void mbedtls_test_buffer_free( mbedtls_test_buffer *buf )
{
if( buf->buffer != NULL )
mbedtls_free( buf->buffer );
memset( buf, 0, sizeof( *buf ) );
}
/*
* Puts \p input_len bytes from the \p input buffer into the ring buffer \p buf.
*
* \p buf must have been initialized and set up by calling
* `mbedtls_test_buffer_init()` and `mbedtls_test_buffer_setup()`.
*
* \retval \p input_len, if the data fits.
* \retval 0 <= value < \p input_len, if the data does not fit.
* \retval -1, if \p buf is NULL, it hasn't been set up or \p input_len is not
* zero and \p input is NULL.
*/
int mbedtls_test_buffer_put( mbedtls_test_buffer *buf,
const unsigned char *input, size_t input_len )
{
size_t overflow = 0;
if( ( buf == NULL ) || ( buf->buffer == NULL ) )
return -1;
/* Reduce input_len to a number that fits in the buffer. */
if ( ( buf->content_length + input_len ) > buf->capacity )
{
input_len = buf->capacity - buf->content_length;
}
if( input == NULL )
{
return ( input_len == 0 ) ? 0 : -1;
}
/* Check if the buffer has not come full circle and free space is not in
* the middle */
if( buf->start + buf->content_length < buf->capacity )
{
/* Calculate the number of bytes that need to be placed at lower memory
* address */
if( buf->start + buf->content_length + input_len
> buf->capacity )
{
overflow = ( buf->start + buf->content_length + input_len )
% buf->capacity;
}
memcpy( buf->buffer + buf->start + buf->content_length, input,
input_len - overflow );
memcpy( buf->buffer, input + input_len - overflow, overflow );
}
else
{
/* The buffer has come full circle and free space is in the middle */
memcpy( buf->buffer + buf->start + buf->content_length - buf->capacity,
input, input_len );
}
buf->content_length += input_len;
return input_len;
}
/*
* Gets \p output_len bytes from the ring buffer \p buf into the
* \p output buffer. The output buffer can be NULL, in this case a part of the
* ring buffer will be dropped, if the requested length is available.
*
* \p buf must have been initialized and set up by calling
* `mbedtls_test_buffer_init()` and `mbedtls_test_buffer_setup()`.
*
* \retval \p output_len, if the data is available.
* \retval 0 <= value < \p output_len, if the data is not available.
* \retval -1, if \buf is NULL or it hasn't been set up.
*/
int mbedtls_test_buffer_get( mbedtls_test_buffer *buf,
unsigned char* output, size_t output_len )
{
size_t overflow = 0;
if( ( buf == NULL ) || ( buf->buffer == NULL ) )
return -1;
if( output == NULL && output_len == 0 )
return 0;
if( buf->content_length < output_len )
output_len = buf->content_length;
/* Calculate the number of bytes that need to be drawn from lower memory
* address */
if( buf->start + output_len > buf->capacity )
{
overflow = ( buf->start + output_len ) % buf->capacity;
}
if( output != NULL )
{
memcpy( output, buf->buffer + buf->start, output_len - overflow );
memcpy( output + output_len - overflow, buf->buffer, overflow );
}
buf->content_length -= output_len;
buf->start = ( buf->start + output_len ) % buf->capacity;
return output_len;
}
/*
* Errors used in the message transport mock tests
*/
#define MBEDTLS_TEST_ERROR_ARG_NULL -11
#define MBEDTLS_TEST_ERROR_MESSAGE_TRUNCATED -44
/*
* Context for a message metadata queue (fifo) that is on top of the ring buffer.
*/
typedef struct mbedtls_test_message_queue
{
size_t *messages;
int pos;
int num;
int capacity;
} mbedtls_test_message_queue;
/*
* Setup and free functions for the message metadata queue.
*
* \p capacity describes the number of message metadata chunks that can be held
* within the queue.
*
* \retval 0, if a metadata queue of a given length can be allocated.
* \retval MBEDTLS_ERR_SSL_ALLOC_FAILED, if allocation failed.
*/
int mbedtls_test_message_queue_setup( mbedtls_test_message_queue *queue,
size_t capacity )
{
queue->messages = (size_t*) mbedtls_calloc( capacity, sizeof(size_t) );
if( NULL == queue->messages )
return MBEDTLS_ERR_SSL_ALLOC_FAILED;
queue->capacity = capacity;
queue->pos = 0;
queue->num = 0;
return 0;
}
void mbedtls_test_message_queue_free( mbedtls_test_message_queue *queue )
{
if( queue == NULL )
return;
if( queue->messages != NULL )
mbedtls_free( queue->messages );
memset( queue, 0, sizeof( *queue ) );
}
/*
* Push message length information onto the message metadata queue.
* This will become the last element to leave it (fifo).
*
* \retval MBEDTLS_TEST_ERROR_ARG_NULL, if the queue is null.
* \retval MBEDTLS_ERR_SSL_WANT_WRITE, if the queue is full.
* \retval \p len, if the push was successful.
*/
int mbedtls_test_message_queue_push_info( mbedtls_test_message_queue *queue,
size_t len )
{
int place;
if( queue == NULL )
return MBEDTLS_TEST_ERROR_ARG_NULL;
if( queue->num >= queue->capacity )
return MBEDTLS_ERR_SSL_WANT_WRITE;
place = ( queue->pos + queue->num ) % queue->capacity;
queue->messages[place] = len;
queue->num++;
return len;
}
/*
* Pop information about the next message length from the queue. This will be
* the oldest inserted message length(fifo). \p msg_len can be null, in which
* case the data will be popped from the queue but not copied anywhere.
*
* \retval MBEDTLS_TEST_ERROR_ARG_NULL, if the queue is null.
* \retval MBEDTLS_ERR_SSL_WANT_READ, if the queue is empty.
* \retval message length, if the pop was successful, up to the given
\p buf_len.
*/
int mbedtls_test_message_queue_pop_info( mbedtls_test_message_queue *queue,
size_t buf_len )
{
size_t message_length;
if( queue == NULL )
return MBEDTLS_TEST_ERROR_ARG_NULL;
if( queue->num == 0 )
return MBEDTLS_ERR_SSL_WANT_READ;
message_length = queue->messages[queue->pos];
queue->messages[queue->pos] = 0;
queue->num--;
queue->pos++;
queue->pos %= queue->capacity;
if( queue->pos < 0 )
queue->pos += queue->capacity;
return ( message_length > buf_len ) ? buf_len : message_length;
}
/*
* Take a peek on the info about the next message length from the queue.
* This will be the oldest inserted message length(fifo).
*
* \retval MBEDTLS_TEST_ERROR_ARG_NULL, if the queue is null.
* \retval MBEDTLS_ERR_SSL_WANT_READ, if the queue is empty.
* \retval 0, if the peek was successful.
* \retval MBEDTLS_TEST_ERROR_MESSAGE_TRUNCATED, if the given buffer length is
* too small to fit the message. In this case the \p msg_len will be
* set to the full message length so that the
* caller knows what portion of the message can be dropped.
*/
int mbedtls_test_message_queue_peek_info( mbedtls_test_message_queue *queue,
size_t buf_len, size_t* msg_len )
{
if( queue == NULL || msg_len == NULL )
return MBEDTLS_TEST_ERROR_ARG_NULL;
if( queue->num == 0 )
return MBEDTLS_ERR_SSL_WANT_READ;
*msg_len = queue->messages[queue->pos];
return ( *msg_len > buf_len ) ? MBEDTLS_TEST_ERROR_MESSAGE_TRUNCATED : 0;
}
/*
* Context for the I/O callbacks simulating network connection.
*/
#define MBEDTLS_MOCK_SOCKET_CONNECTED 1
typedef struct mbedtls_mock_socket
{
int status;
mbedtls_test_buffer *input;
mbedtls_test_buffer *output;
struct mbedtls_mock_socket *peer;
} mbedtls_mock_socket;
/*
* Setup and teardown functions for mock sockets.
*/
void mbedtls_mock_socket_init( mbedtls_mock_socket *socket )
{
memset( socket, 0, sizeof( *socket ) );
}
/*
* Closes the socket \p socket.
*
* \p socket must have been previously initialized by calling
* mbedtls_mock_socket_init().
*
* This function frees all allocated resources and both sockets are aware of the
* new connection state.
*
* That is, this function does not simulate half-open TCP connections and the
* phenomenon that when closing a UDP connection the peer is not aware of the
* connection having been closed.
*/
void mbedtls_mock_socket_close( mbedtls_mock_socket* socket )
{
if( socket == NULL )
return;
if( socket->input != NULL )
{
mbedtls_test_buffer_free( socket->input );
mbedtls_free( socket->input );
}
if( socket->output != NULL )
{
mbedtls_test_buffer_free( socket->output );
mbedtls_free( socket->output );
}
if( socket->peer != NULL )
memset( socket->peer, 0, sizeof( *socket->peer ) );
memset( socket, 0, sizeof( *socket ) );
}
/*
* Establishes a connection between \p peer1 and \p peer2.
*
* \p peer1 and \p peer2 must have been previously initialized by calling
* mbedtls_mock_socket_init().
*
* The capacites of the internal buffers are set to \p bufsize. Setting this to
* the correct value allows for simulation of MTU, sanity testing the mock
* implementation and mocking TCP connections with lower memory cost.
*/
int mbedtls_mock_socket_connect( mbedtls_mock_socket* peer1,
mbedtls_mock_socket* peer2,
size_t bufsize )
{
int ret = -1;
peer1->output =
(mbedtls_test_buffer*) mbedtls_calloc( 1, sizeof(mbedtls_test_buffer) );
if( peer1->output == NULL )
{
ret = MBEDTLS_ERR_SSL_ALLOC_FAILED;
goto exit;
}
mbedtls_test_buffer_init( peer1->output );
if( 0 != ( ret = mbedtls_test_buffer_setup( peer1->output, bufsize ) ) )
{
goto exit;
}
peer2->output =
(mbedtls_test_buffer*) mbedtls_calloc( 1, sizeof(mbedtls_test_buffer) );
if( peer2->output == NULL )
{
ret = MBEDTLS_ERR_SSL_ALLOC_FAILED;
goto exit;
}
mbedtls_test_buffer_init( peer2->output );
if( 0 != ( ret = mbedtls_test_buffer_setup( peer2->output, bufsize ) ) )
{
goto exit;
}
peer1->peer = peer2;
peer2->peer = peer1;
peer1->input = peer2->output;
peer2->input = peer1->output;
peer1->status = peer2->status = MBEDTLS_MOCK_SOCKET_CONNECTED;
ret = 0;
exit:
if( ret != 0 )
{
mbedtls_mock_socket_close( peer1 );
mbedtls_mock_socket_close( peer2 );
}
return ret;
}
/*
* Callbacks for simulating blocking I/O over connection-oriented transport.
*/
int mbedtls_mock_tcp_send_b( void *ctx, const unsigned char *buf, size_t len )
{
mbedtls_mock_socket *socket = (mbedtls_mock_socket*) ctx;
if( socket == NULL || socket->status != MBEDTLS_MOCK_SOCKET_CONNECTED )
return -1;
return mbedtls_test_buffer_put( socket->output, buf, len );
}
int mbedtls_mock_tcp_recv_b( void *ctx, unsigned char *buf, size_t len )
{
mbedtls_mock_socket *socket = (mbedtls_mock_socket*) ctx;
if( socket == NULL || socket->status != MBEDTLS_MOCK_SOCKET_CONNECTED )
return -1;
return mbedtls_test_buffer_get( socket->input, buf, len );
}
/*
* Callbacks for simulating non-blocking I/O over connection-oriented transport.
*/
int mbedtls_mock_tcp_send_nb( void *ctx, const unsigned char *buf, size_t len )
{
mbedtls_mock_socket *socket = (mbedtls_mock_socket*) ctx;
if( socket == NULL || socket->status != MBEDTLS_MOCK_SOCKET_CONNECTED )
return -1;
if( socket->output->capacity == socket->output->content_length )
{
return MBEDTLS_ERR_SSL_WANT_WRITE;
}
return mbedtls_test_buffer_put( socket->output, buf, len );
}
int mbedtls_mock_tcp_recv_nb( void *ctx, unsigned char *buf, size_t len )
{
mbedtls_mock_socket *socket = (mbedtls_mock_socket*) ctx;
if( socket == NULL || socket->status != MBEDTLS_MOCK_SOCKET_CONNECTED )
return -1;
if( socket->input->content_length == 0 )
{
return MBEDTLS_ERR_SSL_WANT_READ;
}
return mbedtls_test_buffer_get( socket->input, buf, len );
}
/* Errors used in the message socket mocks */
#define MBEDTLS_TEST_ERROR_CONTEXT_ERROR -55
#define MBEDTLS_TEST_ERROR_SEND_FAILED -66
#define MBEDTLS_TEST_ERROR_RECV_FAILED -77
/*
* Structure used as an addon, or a wrapper, around the mocked sockets.
* Contains an input queue, to which the other socket pushes metadata,
* and an output queue, to which this one pushes metadata. This context is
* considered as an owner of the input queue only, which is initialized and
* freed in the respective setup and free calls.
*/
typedef struct mbedtls_test_message_socket_context
{
mbedtls_test_message_queue* queue_input;
mbedtls_test_message_queue* queue_output;
mbedtls_mock_socket* socket_;
} mbedtls_test_message_socket_context;
void mbedtls_message_socket_init( mbedtls_test_message_socket_context *ctx )
{
ctx->queue_input = NULL;
ctx->queue_output = NULL;
ctx->socket_ = NULL;
}
/*
* Setup a given mesasge socket context including initialization of
* input/output queues to a chosen capacity of messages. Also set the
* corresponding mock socket.
*
* \retval 0, if everything succeeds.
* \retval MBEDTLS_ERR_SSL_ALLOC_FAILED, if allocation of a message
* queue failed.
*/
int mbedtls_message_socket_setup( mbedtls_test_message_queue* queue_input,
mbedtls_test_message_queue* queue_output,
size_t queue_capacity,
mbedtls_mock_socket* socket,
mbedtls_test_message_socket_context* ctx )
{
int ret = mbedtls_test_message_queue_setup( queue_input, queue_capacity );
if( ret != 0 )
return ret;
ctx->queue_input = queue_input;
ctx->queue_output = queue_output;
ctx->socket_ = socket;
mbedtls_mock_socket_init( socket );
return 0;
}
/*
* Close a given message socket context, along with the socket itself. Free the
* memory allocated by the input queue.
*/
void mbedtls_message_socket_close( mbedtls_test_message_socket_context* ctx )
{
if( ctx == NULL )
return;
mbedtls_test_message_queue_free( ctx->queue_input );
mbedtls_mock_socket_close( ctx->socket_ );
memset( ctx, 0, sizeof( *ctx ) );
}
/*
* Send one message through a given message socket context.
*
* \retval \p len, if everything succeeds.
* \retval MBEDTLS_TEST_ERROR_CONTEXT_ERROR, if any of the needed context
* elements or the context itself is null.
* \retval MBEDTLS_TEST_ERROR_SEND_FAILED if mbedtls_mock_tcp_send_b failed.
* \retval MBEDTLS_ERR_SSL_WANT_WRITE, if the output queue is full.
*
* This function will also return any error from
* mbedtls_test_message_queue_push_info.
*/
int mbedtls_mock_tcp_send_msg( void *ctx, const unsigned char *buf, size_t len )
{
mbedtls_test_message_queue* queue;
mbedtls_mock_socket* socket;
mbedtls_test_message_socket_context *context = (mbedtls_test_message_socket_context*) ctx;
if( context == NULL || context->socket_ == NULL
|| context->queue_output == NULL )
{
return MBEDTLS_TEST_ERROR_CONTEXT_ERROR;
}
queue = context->queue_output;
socket = context->socket_;
if( queue->num >= queue->capacity )
return MBEDTLS_ERR_SSL_WANT_WRITE;
if( mbedtls_mock_tcp_send_b( socket, buf, len ) != (int) len )
return MBEDTLS_TEST_ERROR_SEND_FAILED;
return mbedtls_test_message_queue_push_info( queue, len );
}
/*
* Receive one message from a given message socket context and return message
* length or an error.
*
* \retval message length, if everything succeeds.
* \retval MBEDTLS_TEST_ERROR_CONTEXT_ERROR, if any of the needed context
* elements or the context itself is null.
* \retval MBEDTLS_TEST_ERROR_RECV_FAILED if mbedtls_mock_tcp_recv_b failed.
*
* This function will also return any error other than
* MBEDTLS_TEST_ERROR_MESSAGE_TRUNCATED from mbedtls_test_message_queue_peek_info.
*/
int mbedtls_mock_tcp_recv_msg( void *ctx, unsigned char *buf, size_t buf_len )
{
mbedtls_test_message_queue* queue;
mbedtls_mock_socket* socket;
mbedtls_test_message_socket_context *context = (mbedtls_test_message_socket_context*) ctx;
size_t drop_len = 0;
size_t msg_len;
int ret;
if( context == NULL || context->socket_ == NULL
|| context->queue_input == NULL )
{
return MBEDTLS_TEST_ERROR_CONTEXT_ERROR;
}
queue = context->queue_input;
socket = context->socket_;
/* Peek first, so that in case of a socket error the data remains in
* the queue. */
ret = mbedtls_test_message_queue_peek_info( queue, buf_len, &msg_len );
if( ret == MBEDTLS_TEST_ERROR_MESSAGE_TRUNCATED )
{
/* Calculate how much to drop */
drop_len = msg_len - buf_len;
/* Set the requested message len to be buffer length */
msg_len = buf_len;
} else if( ret != 0 )
{
return ret;
}
if( mbedtls_mock_tcp_recv_b( socket, buf, msg_len ) != (int) msg_len )
return MBEDTLS_TEST_ERROR_RECV_FAILED;
if( ret == MBEDTLS_TEST_ERROR_MESSAGE_TRUNCATED )
{
/* Drop the remaining part of the message */
if( mbedtls_mock_tcp_recv_b( socket, NULL, drop_len ) != (int) drop_len )
{
/* Inconsistent state - part of the message was read,
* and a part couldn't. Not much we can do here, but it should not
* happen in test environment, unless forced manually. */
}
}
mbedtls_test_message_queue_pop_info( queue, buf_len );
return msg_len;
}
#if defined(MBEDTLS_X509_CRT_PARSE_C) && \
defined(MBEDTLS_ENTROPY_C) && \
defined(MBEDTLS_CTR_DRBG_C)
/*
* Structure with endpoint's certificates for SSL communication tests.
*/
typedef struct mbedtls_endpoint_certificate
{
mbedtls_x509_crt ca_cert;
mbedtls_x509_crt cert;
mbedtls_pk_context pkey;
} mbedtls_endpoint_certificate;
/*
* Endpoint structure for SSL communication tests.
*/
typedef struct mbedtls_endpoint
{
const char *name;
mbedtls_ssl_context ssl;
mbedtls_ssl_config conf;
mbedtls_ctr_drbg_context ctr_drbg;
mbedtls_entropy_context entropy;
mbedtls_mock_socket socket_;
mbedtls_endpoint_certificate cert;
} mbedtls_endpoint;
/*
* Initializes \p ep_cert structure and assigns it to endpoint
* represented by \p ep.
*
* \retval 0 on success, otherwise error code.
*/
int mbedtls_endpoint_certificate_init( mbedtls_endpoint *ep, int pk_alg )
{
int i = 0;
int ret = -1;
mbedtls_endpoint_certificate *cert;
if( ep == NULL )
{
return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
}
cert = &( ep->cert );
mbedtls_x509_crt_init( &( cert->ca_cert ) );
mbedtls_x509_crt_init( &( cert->cert ) );
mbedtls_pk_init( &( cert->pkey ) );
/* Load the trusted CA */
for( i = 0; mbedtls_test_cas_der[i] != NULL; i++ )
{
ret = mbedtls_x509_crt_parse_der( &( cert->ca_cert ),
(const unsigned char *) mbedtls_test_cas_der[i],
mbedtls_test_cas_der_len[i] );
TEST_ASSERT( ret == 0 );
}
/* Load own certificate and private key */
if( ep->conf.endpoint == MBEDTLS_SSL_IS_SERVER )
{
if( pk_alg == MBEDTLS_PK_RSA )
{
ret = mbedtls_x509_crt_parse( &( cert->cert ),
(const unsigned char*) mbedtls_test_srv_crt_rsa_sha256_der,
mbedtls_test_srv_crt_rsa_sha256_der_len );
TEST_ASSERT( ret == 0 );
ret = mbedtls_pk_parse_key( &( cert->pkey ),
(const unsigned char*) mbedtls_test_srv_key_rsa_der,
mbedtls_test_srv_key_rsa_der_len, NULL, 0 );
TEST_ASSERT( ret == 0 );
}
else
{
ret = mbedtls_x509_crt_parse( &( cert->cert ),
(const unsigned char*) mbedtls_test_srv_crt_ec_der,
mbedtls_test_srv_crt_ec_der_len );
TEST_ASSERT( ret == 0 );
ret = mbedtls_pk_parse_key( &( cert->pkey ),
(const unsigned char*) mbedtls_test_srv_key_ec_der,
mbedtls_test_srv_key_ec_der_len, NULL, 0 );
TEST_ASSERT( ret == 0 );
}
}
else
{
if( pk_alg == MBEDTLS_PK_RSA )
{
ret = mbedtls_x509_crt_parse( &( cert->cert ),
(const unsigned char *) mbedtls_test_cli_crt_rsa_der,
mbedtls_test_cli_crt_rsa_der_len );
TEST_ASSERT( ret == 0 );
ret = mbedtls_pk_parse_key( &( cert->pkey ),
(const unsigned char *) mbedtls_test_cli_key_rsa_der,
mbedtls_test_cli_key_rsa_der_len, NULL, 0 );
TEST_ASSERT( ret == 0 );
}
else
{
ret = mbedtls_x509_crt_parse( &( cert->cert ),
(const unsigned char *) mbedtls_test_cli_crt_ec_der,
mbedtls_test_cli_crt_ec_len );
TEST_ASSERT( ret == 0 );
ret = mbedtls_pk_parse_key( &( cert->pkey ),
(const unsigned char *) mbedtls_test_cli_key_ec_der,
mbedtls_test_cli_key_ec_der_len, NULL, 0 );
TEST_ASSERT( ret == 0 );
}
}
mbedtls_ssl_conf_ca_chain( &( ep->conf ), &( cert->ca_cert ), NULL );
ret = mbedtls_ssl_conf_own_cert( &( ep->conf ), &( cert->cert ),
&( cert->pkey ) );
TEST_ASSERT( ret == 0 );
exit:
if( ret != 0 )
{
mbedtls_x509_crt_free( &( cert->ca_cert ) );
mbedtls_x509_crt_free( &( cert->cert ) );
mbedtls_pk_free( &( cert->pkey ) );
}
return ret;
}
/*
* Initializes \p ep structure. It is important to call `mbedtls_endpoint_free()`
* after calling this function even if it fails.
*
* \p endpoint_type must be set as MBEDTLS_SSL_IS_SERVER or
* MBEDTLS_SSL_IS_CLIENT.
* \p pk_alg the algorithm to use, currently only MBEDTLS_PK_RSA and
* MBEDTLS_PK_ECDSA are supported.
* \p dtls_context - in case of DTLS - this is the context handling metadata.
* \p input_queue - used only in case of DTLS.
* \p output_queue - used only in case of DTLS.
*
* \retval 0 on success, otherwise error code.
*/
int mbedtls_endpoint_init( mbedtls_endpoint *ep, int endpoint_type, int pk_alg,
mbedtls_test_message_socket_context *dtls_context,
mbedtls_test_message_queue *input_queue,
mbedtls_test_message_queue *output_queue )
{
int ret = -1;
if( dtls_context != NULL && ( input_queue == NULL || output_queue == NULL ) )
return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
if( ep == NULL )
return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
memset( ep, 0, sizeof( *ep ) );
ep->name = ( endpoint_type == MBEDTLS_SSL_IS_SERVER ) ? "Server" : "Client";
mbedtls_ssl_init( &( ep->ssl ) );
mbedtls_ssl_config_init( &( ep->conf ) );
mbedtls_ctr_drbg_init( &( ep->ctr_drbg ) );
mbedtls_ssl_conf_rng( &( ep->conf ),
mbedtls_ctr_drbg_random,
&( ep->ctr_drbg ) );
mbedtls_entropy_init( &( ep->entropy ) );
if( dtls_context != NULL )
{
TEST_ASSERT( mbedtls_message_socket_setup( input_queue, output_queue,
100, &( ep->socket_ ),
dtls_context ) == 0 );
}
else
{
mbedtls_mock_socket_init( &( ep->socket_ ) );
}
ret = mbedtls_ctr_drbg_seed( &( ep->ctr_drbg ), mbedtls_entropy_func,
&( ep->entropy ), (const unsigned char *) ( ep->name ),
strlen( ep->name ) );
TEST_ASSERT( ret == 0 );
/* Non-blocking callbacks without timeout */
if( dtls_context != NULL )
{
mbedtls_ssl_set_bio( &( ep->ssl ), dtls_context,
mbedtls_mock_tcp_send_msg,
mbedtls_mock_tcp_recv_msg,
NULL );
}
else
{
mbedtls_ssl_set_bio( &( ep->ssl ), &( ep->socket_ ),
mbedtls_mock_tcp_send_nb,
mbedtls_mock_tcp_recv_nb,
NULL );
}
ret = mbedtls_ssl_config_defaults( &( ep->conf ), endpoint_type,
( dtls_context != NULL ) ?
MBEDTLS_SSL_TRANSPORT_DATAGRAM :
MBEDTLS_SSL_TRANSPORT_STREAM,
MBEDTLS_SSL_PRESET_DEFAULT );
TEST_ASSERT( ret == 0 );
ret = mbedtls_ssl_setup( &( ep->ssl ), &( ep->conf ) );
TEST_ASSERT( ret == 0 );
#if defined(MBEDTLS_SSL_PROTO_DTLS) && defined(MBEDTLS_SSL_SRV_C)
if( endpoint_type == MBEDTLS_SSL_IS_SERVER && dtls_context != NULL )
mbedtls_ssl_conf_dtls_cookies( &( ep->conf ), NULL, NULL, NULL );
#endif
ret = mbedtls_endpoint_certificate_init( ep, pk_alg );
TEST_ASSERT( ret == 0 );
exit:
return ret;
}
/*
* Deinitializes certificates from endpoint represented by \p ep.
*/
void mbedtls_endpoint_certificate_free( mbedtls_endpoint *ep )
{
mbedtls_endpoint_certificate *cert = &( ep->cert );
mbedtls_x509_crt_free( &( cert->ca_cert ) );
mbedtls_x509_crt_free( &( cert->cert ) );
mbedtls_pk_free( &( cert->pkey ) );
}
/*
* Deinitializes endpoint represented by \p ep.
*/
void mbedtls_endpoint_free( mbedtls_endpoint *ep,
mbedtls_test_message_socket_context *context )
{
mbedtls_endpoint_certificate_free( ep );
mbedtls_ssl_free( &( ep->ssl ) );
mbedtls_ssl_config_free( &( ep->conf ) );
mbedtls_ctr_drbg_free( &( ep->ctr_drbg ) );
mbedtls_entropy_free( &( ep->entropy ) );
if( context != NULL )
{
mbedtls_message_socket_close( context );
}
else
{
mbedtls_mock_socket_close( &( ep->socket_ ) );
}
}
/*
* This function moves ssl handshake from \p ssl to prescribed \p state.
* /p second_ssl is used as second endpoint and their sockets have to be
* connected before calling this function.
*
* \retval 0 on success, otherwise error code.
*/
int mbedtls_move_handshake_to_state( mbedtls_ssl_context *ssl,
mbedtls_ssl_context *second_ssl,
int state )
{
enum { BUFFSIZE = 1024 };
int max_steps = 1000;
int ret = 0;
if( ssl == NULL || second_ssl == NULL )
{
return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
}
/* Perform communication via connected sockets */
while( ( ssl->state != state ) && ( --max_steps >= 0 ) )
{
/* If /p second_ssl ends the handshake procedure before /p ssl then
* there is no need to call the next step */
if( second_ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER )
{
ret = mbedtls_ssl_handshake_step( second_ssl );
if( ret != 0 && ret != MBEDTLS_ERR_SSL_WANT_READ &&
ret != MBEDTLS_ERR_SSL_WANT_WRITE )
{
return ret;
}
}
/* We only care about the \p ssl state and returns, so we call it last,
* to leave the iteration as soon as the state is as expected. */
ret = mbedtls_ssl_handshake_step( ssl );
if( ret != 0 && ret != MBEDTLS_ERR_SSL_WANT_READ &&
ret != MBEDTLS_ERR_SSL_WANT_WRITE )
{
return ret;
}
}
return ( max_steps >= 0 ) ? ret : -1;
}
#endif /* MBEDTLS_X509_CRT_PARSE_C && MBEDTLS_ENTROPY_C && MBEDTLS_CTR_DRBG_C */
/*
* Write application data. Increase write counter if necessary.
*/
int mbedtls_ssl_write_fragment( mbedtls_ssl_context *ssl, unsigned char *buf,
int buf_len, int *written,
const int expected_fragments )
{
int ret = mbedtls_ssl_write( ssl, buf + *written, buf_len - *written );
if( ret > 0 )
{
*written += ret;
}
if( expected_fragments == 0 )
{
/* Used for DTLS and the message size larger than MFL. In that case
* the message can not be fragmented and the library should return
* MBEDTLS_ERR_SSL_BAD_INPUT_DATA error. This error must be returned
* to prevent a dead loop inside mbedtls_exchange_data(). */
return ret;
}
else if( expected_fragments == 1 )
{
/* Used for TLS/DTLS and the message size lower than MFL */
TEST_ASSERT( ret == buf_len ||
ret == MBEDTLS_ERR_SSL_WANT_READ ||
ret == MBEDTLS_ERR_SSL_WANT_WRITE );
}
else
{
/* Used for TLS and the message size larger than MFL */
TEST_ASSERT( expected_fragments > 1 );
TEST_ASSERT( ( ret >= 0 && ret <= buf_len ) ||
ret == MBEDTLS_ERR_SSL_WANT_READ ||
ret == MBEDTLS_ERR_SSL_WANT_WRITE );
}
return 0;
exit:
/* Some of the tests failed */
return -1;
}
/*
* Read application data and increase read counter and fragments counter if necessary.
*/
int mbedtls_ssl_read_fragment( mbedtls_ssl_context *ssl, unsigned char *buf,
int buf_len, int *read,
int *fragments, const int expected_fragments )
{
int ret = mbedtls_ssl_read( ssl, buf + *read, buf_len - *read );
if( ret > 0 )
{
( *fragments )++;
*read += ret;
}
if( expected_fragments == 0 )
{
TEST_ASSERT( ret == 0 );
}
else if( expected_fragments == 1 )
{
TEST_ASSERT( ret == buf_len ||
ret == MBEDTLS_ERR_SSL_WANT_READ ||
ret == MBEDTLS_ERR_SSL_WANT_WRITE );
}
else
{
TEST_ASSERT( expected_fragments > 1 );
TEST_ASSERT( ( ret >= 0 && ret <= buf_len ) ||
ret == MBEDTLS_ERR_SSL_WANT_READ ||
ret == MBEDTLS_ERR_SSL_WANT_WRITE );
}
return 0;
exit:
/* Some of the tests failed */
return -1;
}
/*
* Helper function setting up inverse record transformations
* using given cipher, hash, EtM mode, authentication tag length,
* and version.
*/
#define CHK( x ) \
do \
{ \
if( !( x ) ) \
{ \
ret = -1; \
goto cleanup; \
} \
} while( 0 )
void set_ciphersuite( mbedtls_ssl_config *conf, const char *cipher,
uint16_t* forced_ciphersuite )
{
const mbedtls_ssl_ciphersuite_t *ciphersuite_info;
forced_ciphersuite[0] = mbedtls_ssl_get_ciphersuite_id( cipher );
forced_ciphersuite[1] = 0;
ciphersuite_info =
mbedtls_ssl_ciphersuite_from_id( forced_ciphersuite[0] );
TEST_ASSERT( ciphersuite_info != NULL );
TEST_ASSERT( ciphersuite_info->min_minor_ver <= conf->max_minor_ver );
TEST_ASSERT( ciphersuite_info->max_minor_ver >= conf->min_minor_ver );
if( conf->max_minor_ver > ciphersuite_info->max_minor_ver )
{
conf->max_minor_ver = ciphersuite_info->max_minor_ver;
}
if( conf->min_minor_ver < ciphersuite_info->min_minor_ver )
{
conf->min_minor_ver = ciphersuite_info->min_minor_ver;
}
mbedtls_ssl_conf_ciphersuites( conf, forced_ciphersuite );
exit:
return;
}
int psk_dummy_callback( void *p_info, mbedtls_ssl_context *ssl,
const unsigned char *name, size_t name_len )
{
(void) p_info;
(void) ssl;
(void) name;
(void) name_len;
return ( 0 );
}
#if MBEDTLS_SSL_CID_OUT_LEN_MAX > MBEDTLS_SSL_CID_IN_LEN_MAX
#define SSL_CID_LEN_MIN MBEDTLS_SSL_CID_IN_LEN_MAX
#else
#define SSL_CID_LEN_MIN MBEDTLS_SSL_CID_OUT_LEN_MAX
#endif
static int build_transforms( mbedtls_ssl_transform *t_in,
mbedtls_ssl_transform *t_out,
int cipher_type, int hash_id,
int etm, int tag_mode, int ver,
size_t cid0_len,
size_t cid1_len )
{
mbedtls_cipher_info_t const *cipher_info;
int ret = 0;
size_t keylen, maclen, ivlen;
unsigned char *key0 = NULL, *key1 = NULL;
unsigned char *md0 = NULL, *md1 = NULL;
unsigned char iv_enc[16], iv_dec[16];
#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
unsigned char cid0[ SSL_CID_LEN_MIN ];
unsigned char cid1[ SSL_CID_LEN_MIN ];
mbedtls_test_rnd_std_rand( NULL, cid0, sizeof( cid0 ) );
mbedtls_test_rnd_std_rand( NULL, cid1, sizeof( cid1 ) );
#else
((void) cid0_len);
((void) cid1_len);
#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
maclen = 0;
/* Pick cipher */
cipher_info = mbedtls_cipher_info_from_type( cipher_type );
CHK( cipher_info != NULL );
CHK( cipher_info->iv_size <= 16 );
CHK( cipher_info->key_bitlen % 8 == 0 );
/* Pick keys */
keylen = cipher_info->key_bitlen / 8;
/* Allocate `keylen + 1` bytes to ensure that we get
* a non-NULL pointers from `mbedtls_calloc` even if
* `keylen == 0` in the case of the NULL cipher. */
CHK( ( key0 = mbedtls_calloc( 1, keylen + 1 ) ) != NULL );
CHK( ( key1 = mbedtls_calloc( 1, keylen + 1 ) ) != NULL );
memset( key0, 0x1, keylen );
memset( key1, 0x2, keylen );
/* Setup cipher contexts */
CHK( mbedtls_cipher_setup( &t_in->cipher_ctx_enc, cipher_info ) == 0 );
CHK( mbedtls_cipher_setup( &t_in->cipher_ctx_dec, cipher_info ) == 0 );
CHK( mbedtls_cipher_setup( &t_out->cipher_ctx_enc, cipher_info ) == 0 );
CHK( mbedtls_cipher_setup( &t_out->cipher_ctx_dec, cipher_info ) == 0 );
#if defined(MBEDTLS_CIPHER_MODE_CBC)
if( cipher_info->mode == MBEDTLS_MODE_CBC )
{
CHK( mbedtls_cipher_set_padding_mode( &t_in->cipher_ctx_enc,
MBEDTLS_PADDING_NONE ) == 0 );
CHK( mbedtls_cipher_set_padding_mode( &t_in->cipher_ctx_dec,
MBEDTLS_PADDING_NONE ) == 0 );
CHK( mbedtls_cipher_set_padding_mode( &t_out->cipher_ctx_enc,
MBEDTLS_PADDING_NONE ) == 0 );
CHK( mbedtls_cipher_set_padding_mode( &t_out->cipher_ctx_dec,
MBEDTLS_PADDING_NONE ) == 0 );
}
#endif /* MBEDTLS_CIPHER_MODE_CBC */
CHK( mbedtls_cipher_setkey( &t_in->cipher_ctx_enc, key0,
keylen << 3, MBEDTLS_ENCRYPT ) == 0 );
CHK( mbedtls_cipher_setkey( &t_in->cipher_ctx_dec, key1,
keylen << 3, MBEDTLS_DECRYPT ) == 0 );
CHK( mbedtls_cipher_setkey( &t_out->cipher_ctx_enc, key1,
keylen << 3, MBEDTLS_ENCRYPT ) == 0 );
CHK( mbedtls_cipher_setkey( &t_out->cipher_ctx_dec, key0,
keylen << 3, MBEDTLS_DECRYPT ) == 0 );
/* Setup MAC contexts */
#if defined(MBEDTLS_SSL_SOME_MODES_USE_MAC)
if( cipher_info->mode == MBEDTLS_MODE_CBC ||
cipher_info->mode == MBEDTLS_MODE_STREAM )
{
mbedtls_md_info_t const *md_info;
/* Pick hash */
md_info = mbedtls_md_info_from_type( hash_id );
CHK( md_info != NULL );
/* Pick hash keys */
maclen = mbedtls_md_get_size( md_info );
CHK( ( md0 = mbedtls_calloc( 1, maclen ) ) != NULL );
CHK( ( md1 = mbedtls_calloc( 1, maclen ) ) != NULL );
memset( md0, 0x5, maclen );
memset( md1, 0x6, maclen );
CHK( mbedtls_md_setup( &t_out->md_ctx_enc, md_info, 1 ) == 0 );
CHK( mbedtls_md_setup( &t_out->md_ctx_dec, md_info, 1 ) == 0 );
CHK( mbedtls_md_setup( &t_in->md_ctx_enc, md_info, 1 ) == 0 );
CHK( mbedtls_md_setup( &t_in->md_ctx_dec, md_info, 1 ) == 0 );
if( ver > MBEDTLS_SSL_MINOR_VERSION_0 )
{
CHK( mbedtls_md_hmac_starts( &t_in->md_ctx_enc,
md0, maclen ) == 0 );
CHK( mbedtls_md_hmac_starts( &t_in->md_ctx_dec,
md1, maclen ) == 0 );
CHK( mbedtls_md_hmac_starts( &t_out->md_ctx_enc,
md1, maclen ) == 0 );
CHK( mbedtls_md_hmac_starts( &t_out->md_ctx_dec,
md0, maclen ) == 0 );
}
#if defined(MBEDTLS_SSL_PROTO_SSL3)
else
{
memcpy( &t_in->mac_enc, md0, maclen );
memcpy( &t_in->mac_dec, md1, maclen );
memcpy( &t_out->mac_enc, md1, maclen );
memcpy( &t_out->mac_dec, md0, maclen );
}
#endif
}
#else
((void) hash_id);
#endif /* MBEDTLS_SSL_SOME_MODES_USE_MAC */
/* Pick IV's (regardless of whether they
* are being used by the transform). */
ivlen = cipher_info->iv_size;
memset( iv_enc, 0x3, sizeof( iv_enc ) );
memset( iv_dec, 0x4, sizeof( iv_dec ) );
/*
* Setup transforms
*/
#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC) && \
defined(MBEDTLS_SSL_SOME_MODES_USE_MAC)
t_out->encrypt_then_mac = etm;
t_in->encrypt_then_mac = etm;
#else
((void) etm);
#endif
t_out->minor_ver = ver;
t_in->minor_ver = ver;
t_out->ivlen = ivlen;
t_in->ivlen = ivlen;
switch( cipher_info->mode )
{
case MBEDTLS_MODE_GCM:
case MBEDTLS_MODE_CCM:
#if defined(MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL)
if( ver == MBEDTLS_SSL_MINOR_VERSION_4 )
{
t_out->fixed_ivlen = 12;
t_in->fixed_ivlen = 12;
}
else
#endif /* MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL */
{
t_out->fixed_ivlen = 4;
t_in->fixed_ivlen = 4;
}
t_out->maclen = 0;
t_in->maclen = 0;
switch( tag_mode )
{
case 0: /* Full tag */
t_out->taglen = 16;
t_in->taglen = 16;
break;
case 1: /* Partial tag */
t_out->taglen = 8;
t_in->taglen = 8;
break;
default:
ret = 1;
goto cleanup;
}
break;
case MBEDTLS_MODE_CHACHAPOLY:
t_out->fixed_ivlen = 12;
t_in->fixed_ivlen = 12;
t_out->maclen = 0;
t_in->maclen = 0;
switch( tag_mode )
{
case 0: /* Full tag */
t_out->taglen = 16;
t_in->taglen = 16;
break;
case 1: /* Partial tag */
t_out->taglen = 8;
t_in->taglen = 8;
break;
default:
ret = 1;
goto cleanup;
}
break;
case MBEDTLS_MODE_STREAM:
case MBEDTLS_MODE_CBC:
t_out->fixed_ivlen = 0; /* redundant, must be 0 */
t_in->fixed_ivlen = 0; /* redundant, must be 0 */
t_out->taglen = 0;
t_in->taglen = 0;
switch( tag_mode )
{
case 0: /* Full tag */
t_out->maclen = maclen;
t_in->maclen = maclen;
break;
case 1: /* Partial tag */
t_out->maclen = 10;
t_in->maclen = 10;
break;
default:
ret = 1;
goto cleanup;
}
break;
default:
ret = 1;
goto cleanup;
break;
}
/* Setup IV's */
memcpy( &t_in->iv_dec, iv_dec, sizeof( iv_dec ) );
memcpy( &t_in->iv_enc, iv_enc, sizeof( iv_enc ) );
memcpy( &t_out->iv_dec, iv_enc, sizeof( iv_enc ) );
memcpy( &t_out->iv_enc, iv_dec, sizeof( iv_dec ) );
#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
/* Add CID */
memcpy( &t_in->in_cid, cid0, cid0_len );
memcpy( &t_in->out_cid, cid1, cid1_len );
t_in->in_cid_len = cid0_len;
t_in->out_cid_len = cid1_len;
memcpy( &t_out->in_cid, cid1, cid1_len );
memcpy( &t_out->out_cid, cid0, cid0_len );
t_out->in_cid_len = cid1_len;
t_out->out_cid_len = cid0_len;
#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
cleanup:
mbedtls_free( key0 );
mbedtls_free( key1 );
mbedtls_free( md0 );
mbedtls_free( md1 );
return( ret );
}
/*
* Populate a session structure for serialization tests.
* Choose dummy values, mostly non-0 to distinguish from the init default.
*/
static int ssl_populate_session( mbedtls_ssl_session *session,
int ticket_len,
const char *crt_file )
{
#if defined(MBEDTLS_HAVE_TIME)
session->start = mbedtls_time( NULL ) - 42;
#endif
session->ciphersuite = 0xabcd;
session->compression = 1;
session->id_len = sizeof( session->id );
memset( session->id, 66, session->id_len );
memset( session->master, 17, sizeof( session->master ) );
#if defined(MBEDTLS_X509_CRT_PARSE_C) && defined(MBEDTLS_FS_IO)
if( strlen( crt_file ) != 0 )
{
mbedtls_x509_crt tmp_crt;
int ret;
mbedtls_x509_crt_init( &tmp_crt );
ret = mbedtls_x509_crt_parse_file( &tmp_crt, crt_file );
if( ret != 0 )
return( ret );
#if defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
/* Move temporary CRT. */
session->peer_cert = mbedtls_calloc( 1, sizeof( *session->peer_cert ) );
if( session->peer_cert == NULL )
return( -1 );
*session->peer_cert = tmp_crt;
memset( &tmp_crt, 0, sizeof( tmp_crt ) );
#else /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
/* Calculate digest of temporary CRT. */
session->peer_cert_digest =
mbedtls_calloc( 1, MBEDTLS_SSL_PEER_CERT_DIGEST_DFL_LEN );
if( session->peer_cert_digest == NULL )
return( -1 );
ret = mbedtls_md( mbedtls_md_info_from_type(
MBEDTLS_SSL_PEER_CERT_DIGEST_DFL_TYPE ),
tmp_crt.raw.p, tmp_crt.raw.len,
session->peer_cert_digest );
if( ret != 0 )
return( ret );
session->peer_cert_digest_type =
MBEDTLS_SSL_PEER_CERT_DIGEST_DFL_TYPE;
session->peer_cert_digest_len =
MBEDTLS_SSL_PEER_CERT_DIGEST_DFL_LEN;
#endif /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
mbedtls_x509_crt_free( &tmp_crt );
}
#else /* MBEDTLS_X509_CRT_PARSE_C && MBEDTLS_FS_IO */
(void) crt_file;
#endif /* MBEDTLS_X509_CRT_PARSE_C && MBEDTLS_FS_IO */
session->verify_result = 0xdeadbeef;
#if defined(MBEDTLS_SSL_SESSION_TICKETS) && defined(MBEDTLS_SSL_CLI_C)
if( ticket_len != 0 )
{
session->ticket = mbedtls_calloc( 1, ticket_len );
if( session->ticket == NULL )
return( -1 );
memset( session->ticket, 33, ticket_len );
}
session->ticket_len = ticket_len;
session->ticket_lifetime = 86401;
#else
(void) ticket_len;
#endif
#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
session->mfl_code = 1;
#endif
#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
session->encrypt_then_mac = 1;
#endif
return( 0 );
}
/*
* Perform data exchanging between \p ssl_1 and \p ssl_2 and check if the
* message was sent in the correct number of fragments.
*
* /p ssl_1 and /p ssl_2 Endpoints represented by mbedtls_ssl_context. Both
* of them must be initialized and connected beforehand.
* /p msg_len_1 and /p msg_len_2 specify the size of the message to send.
* /p expected_fragments_1 and /p expected_fragments_2 determine in how many
* fragments the message should be sent.
* expected_fragments is 0: can be used for DTLS testing while the message
* size is larger than MFL. In that case the message
* cannot be fragmented and sent to the second endpoint.
* This value can be used for negative tests.
* expected_fragments is 1: can be used for TLS/DTLS testing while the
* message size is below MFL
* expected_fragments > 1: can be used for TLS testing while the message
* size is larger than MFL
*
* \retval 0 on success, otherwise error code.
*/
int mbedtls_exchange_data( mbedtls_ssl_context *ssl_1,
int msg_len_1, const int expected_fragments_1,
mbedtls_ssl_context *ssl_2,
int msg_len_2, const int expected_fragments_2 )
{
unsigned char *msg_buf_1 = malloc( msg_len_1 );
unsigned char *msg_buf_2 = malloc( msg_len_2 );
unsigned char *in_buf_1 = malloc( msg_len_2 );
unsigned char *in_buf_2 = malloc( msg_len_1 );
int msg_type, ret = -1;
/* Perform this test with two message types. At first use a message
* consisting of only 0x00 for the client and only 0xFF for the server.
* At the second time use message with generated data */
for( msg_type = 0; msg_type < 2; msg_type++ )
{
int written_1 = 0;
int written_2 = 0;
int read_1 = 0;
int read_2 = 0;
int fragments_1 = 0;
int fragments_2 = 0;
if( msg_type == 0 )
{
memset( msg_buf_1, 0x00, msg_len_1 );
memset( msg_buf_2, 0xff, msg_len_2 );
}
else
{
int i, j = 0;
for( i = 0; i < msg_len_1; i++ )
{
msg_buf_1[i] = j++ & 0xFF;
}
for( i = 0; i < msg_len_2; i++ )
{
msg_buf_2[i] = ( j -= 5 ) & 0xFF;
}
}
while( read_1 < msg_len_2 || read_2 < msg_len_1 )
{
/* ssl_1 sending */
if( msg_len_1 > written_1 )
{
ret = mbedtls_ssl_write_fragment( ssl_1, msg_buf_1,
msg_len_1, &written_1,
expected_fragments_1 );
if( expected_fragments_1 == 0 )
{
/* This error is expected when the message is too large and
* cannot be fragmented */
TEST_ASSERT( ret == MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
msg_len_1 = 0;
}
else
{
TEST_ASSERT( ret == 0 );
}
}
/* ssl_2 sending */
if( msg_len_2 > written_2 )
{
ret = mbedtls_ssl_write_fragment( ssl_2, msg_buf_2,
msg_len_2, &written_2,
expected_fragments_2 );
if( expected_fragments_2 == 0 )
{
/* This error is expected when the message is too large and
* cannot be fragmented */
TEST_ASSERT( ret == MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
msg_len_2 = 0;
}
else
{
TEST_ASSERT( ret == 0 );
}
}
/* ssl_1 reading */
if( read_1 < msg_len_2 )
{
ret = mbedtls_ssl_read_fragment( ssl_1, in_buf_1,
msg_len_2, &read_1,
&fragments_2,
expected_fragments_2 );
TEST_ASSERT( ret == 0 );
}
/* ssl_2 reading */
if( read_2 < msg_len_1 )
{
ret = mbedtls_ssl_read_fragment( ssl_2, in_buf_2,
msg_len_1, &read_2,
&fragments_1,
expected_fragments_1 );
TEST_ASSERT( ret == 0 );
}
}
ret = -1;
TEST_ASSERT( 0 == memcmp( msg_buf_1, in_buf_2, msg_len_1 ) );
TEST_ASSERT( 0 == memcmp( msg_buf_2, in_buf_1, msg_len_2 ) );
TEST_ASSERT( fragments_1 == expected_fragments_1 );
TEST_ASSERT( fragments_2 == expected_fragments_2 );
}
ret = 0;
exit:
free( msg_buf_1 );
free( in_buf_1 );
free( msg_buf_2 );
free( in_buf_2 );
return ret;
}
/*
* Perform data exchanging between \p ssl_1 and \p ssl_2. Both of endpoints
* must be initialized and connected beforehand.
*
* \retval 0 on success, otherwise error code.
*/
int exchange_data( mbedtls_ssl_context *ssl_1,
mbedtls_ssl_context *ssl_2 )
{
return mbedtls_exchange_data( ssl_1, 256, 1,
ssl_2, 256, 1 );
}
#if defined(MBEDTLS_X509_CRT_PARSE_C) && \
defined(MBEDTLS_ENTROPY_C) && \
defined(MBEDTLS_CTR_DRBG_C)
void perform_handshake( handshake_test_options* options )
{
/* forced_ciphersuite needs to last until the end of the handshake */
uint16_t forced_ciphersuite[2];
enum { BUFFSIZE = 17000 };
mbedtls_endpoint client, server;
#if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED)
const char *psk_identity = "foo";
#endif
#if defined(MBEDTLS_TIMING_C)
mbedtls_timing_delay_context timer_client, timer_server;
#endif
#if defined(MBEDTLS_SSL_CONTEXT_SERIALIZATION)
unsigned char *context_buf = NULL;
size_t context_buf_len;
#endif
#if defined(MBEDTLS_SSL_RENEGOTIATION)
int ret = -1;
#endif
int expected_handshake_result = 0;
mbedtls_test_message_queue server_queue, client_queue;
mbedtls_test_message_socket_context server_context, client_context;
mbedtls_message_socket_init( &server_context );
mbedtls_message_socket_init( &client_context );
/* Client side */
if( options->dtls != 0 )
{
TEST_ASSERT( mbedtls_endpoint_init( &client, MBEDTLS_SSL_IS_CLIENT,
options->pk_alg, &client_context,
&client_queue,
&server_queue ) == 0 );
#if defined(MBEDTLS_TIMING_C)
mbedtls_ssl_set_timer_cb( &client.ssl, &timer_client,
mbedtls_timing_set_delay,
mbedtls_timing_get_delay );
#endif
}
else
{
TEST_ASSERT( mbedtls_endpoint_init( &client, MBEDTLS_SSL_IS_CLIENT,
options->pk_alg, NULL, NULL,
NULL ) == 0 );
}
if( options->client_min_version != TEST_SSL_MINOR_VERSION_NONE )
{
mbedtls_ssl_conf_min_version( &client.conf, MBEDTLS_SSL_MAJOR_VERSION_3,
options->client_min_version );
}
if( options->client_max_version != TEST_SSL_MINOR_VERSION_NONE )
{
mbedtls_ssl_conf_max_version( &client.conf, MBEDTLS_SSL_MAJOR_VERSION_3,
options->client_max_version );
}
if( strlen( options->cipher ) > 0 )
{
set_ciphersuite( &client.conf, options->cipher, forced_ciphersuite );
}
#if defined (MBEDTLS_DEBUG_C)
if( options->cli_log_fun )
{
mbedtls_debug_set_threshold( 4 );
mbedtls_ssl_conf_dbg( &client.conf, options->cli_log_fun,
options->cli_log_obj );
}
#endif
/* Server side */
if( options->dtls != 0 )
{
TEST_ASSERT( mbedtls_endpoint_init( &server, MBEDTLS_SSL_IS_SERVER,
options->pk_alg, &server_context,
&server_queue,
&client_queue) == 0 );
#if defined(MBEDTLS_TIMING_C)
mbedtls_ssl_set_timer_cb( &server.ssl, &timer_server,
mbedtls_timing_set_delay,
mbedtls_timing_get_delay );
#endif
}
else
{
TEST_ASSERT( mbedtls_endpoint_init( &server, MBEDTLS_SSL_IS_SERVER,
options->pk_alg, NULL, NULL, NULL ) == 0 );
}
mbedtls_ssl_conf_authmode( &server.conf, options->srv_auth_mode );
if( options->server_min_version != TEST_SSL_MINOR_VERSION_NONE )
{
mbedtls_ssl_conf_min_version( &server.conf, MBEDTLS_SSL_MAJOR_VERSION_3,
options->server_min_version );
}
if( options->server_max_version != TEST_SSL_MINOR_VERSION_NONE )
{
mbedtls_ssl_conf_max_version( &server.conf, MBEDTLS_SSL_MAJOR_VERSION_3,
options->server_max_version );
}
#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
TEST_ASSERT( mbedtls_ssl_conf_max_frag_len( &(server.conf),
(unsigned char) options->mfl ) == 0 );
TEST_ASSERT( mbedtls_ssl_conf_max_frag_len( &(client.conf),
(unsigned char) options->mfl ) == 0 );
#else
TEST_ASSERT( MBEDTLS_SSL_MAX_FRAG_LEN_NONE == options->mfl );
#endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */
#if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED)
if( options->psk_str != NULL && options->psk_str->len > 0 )
{
TEST_ASSERT( mbedtls_ssl_conf_psk( &client.conf, options->psk_str->x,
options->psk_str->len,
(const unsigned char *) psk_identity,
strlen( psk_identity ) ) == 0 );
TEST_ASSERT( mbedtls_ssl_conf_psk( &server.conf, options->psk_str->x,
options->psk_str->len,
(const unsigned char *) psk_identity,
strlen( psk_identity ) ) == 0 );
mbedtls_ssl_conf_psk_cb( &server.conf, psk_dummy_callback, NULL );
}
#endif
#if defined(MBEDTLS_SSL_RENEGOTIATION)
if( options->renegotiate )
{
mbedtls_ssl_conf_renegotiation( &(server.conf),
MBEDTLS_SSL_RENEGOTIATION_ENABLED );
mbedtls_ssl_conf_renegotiation( &(client.conf),
MBEDTLS_SSL_RENEGOTIATION_ENABLED );
mbedtls_ssl_conf_legacy_renegotiation( &(server.conf),
options->legacy_renegotiation );
mbedtls_ssl_conf_legacy_renegotiation( &(client.conf),
options->legacy_renegotiation );
}
#endif /* MBEDTLS_SSL_RENEGOTIATION */
#if defined (MBEDTLS_DEBUG_C)
if( options->srv_log_fun )
{
mbedtls_debug_set_threshold( 4 );
mbedtls_ssl_conf_dbg( &server.conf, options->srv_log_fun,
options->srv_log_obj );
}
#endif
TEST_ASSERT( mbedtls_mock_socket_connect( &(client.socket_),
&(server.socket_),
BUFFSIZE ) == 0 );
#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
if( options->resize_buffers != 0 )
{
/* Ensure that the buffer sizes are appropriate before resizes */
TEST_ASSERT( client.ssl.out_buf_len == MBEDTLS_SSL_OUT_BUFFER_LEN );
TEST_ASSERT( client.ssl.in_buf_len == MBEDTLS_SSL_IN_BUFFER_LEN );
TEST_ASSERT( server.ssl.out_buf_len == MBEDTLS_SSL_OUT_BUFFER_LEN );
TEST_ASSERT( server.ssl.in_buf_len == MBEDTLS_SSL_IN_BUFFER_LEN );
}
#endif
if( options->expected_negotiated_version == TEST_SSL_MINOR_VERSION_NONE )
{
expected_handshake_result = MBEDTLS_ERR_SSL_BAD_HS_PROTOCOL_VERSION;
}
TEST_ASSERT( mbedtls_move_handshake_to_state( &(client.ssl),
&(server.ssl),
MBEDTLS_SSL_HANDSHAKE_OVER )
== expected_handshake_result );
if( expected_handshake_result != 0 )
{
/* Connection will have failed by this point, skip to cleanup */
goto exit;
}
TEST_ASSERT( client.ssl.state == MBEDTLS_SSL_HANDSHAKE_OVER );
TEST_ASSERT( server.ssl.state == MBEDTLS_SSL_HANDSHAKE_OVER );
/* Check that we agree on the version... */
TEST_ASSERT( client.ssl.minor_ver == server.ssl.minor_ver );
/* And check that the version negotiated is the expected one. */
TEST_EQUAL( client.ssl.minor_ver, options->expected_negotiated_version );
#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
if( options->resize_buffers != 0 )
{
if( options->expected_negotiated_version != MBEDTLS_SSL_MINOR_VERSION_0 &&
options->expected_negotiated_version != MBEDTLS_SSL_MINOR_VERSION_1 )
{
/* A server, when using DTLS, might delay a buffer resize to happen
* after it receives a message, so we force it. */
TEST_ASSERT( exchange_data( &(client.ssl), &(server.ssl) ) == 0 );
TEST_ASSERT( client.ssl.out_buf_len ==
mbedtls_ssl_get_output_buflen( &client.ssl ) );
TEST_ASSERT( client.ssl.in_buf_len ==
mbedtls_ssl_get_input_buflen( &client.ssl ) );
TEST_ASSERT( server.ssl.out_buf_len ==
mbedtls_ssl_get_output_buflen( &server.ssl ) );
TEST_ASSERT( server.ssl.in_buf_len ==
mbedtls_ssl_get_input_buflen( &server.ssl ) );
}
}
#endif
if( options->cli_msg_len != 0 || options->srv_msg_len != 0 )
{
/* Start data exchanging test */
TEST_ASSERT( mbedtls_exchange_data( &(client.ssl), options->cli_msg_len,
options->expected_cli_fragments,
&(server.ssl), options->srv_msg_len,
options->expected_srv_fragments )
== 0 );
}
#if defined(MBEDTLS_SSL_CONTEXT_SERIALIZATION)
if( options->serialize == 1 )
{
TEST_ASSERT( options->dtls == 1 );
TEST_ASSERT( mbedtls_ssl_context_save( &(server.ssl), NULL,
0, &context_buf_len )
== MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
context_buf = mbedtls_calloc( 1, context_buf_len );
TEST_ASSERT( context_buf != NULL );
TEST_ASSERT( mbedtls_ssl_context_save( &(server.ssl), context_buf,
context_buf_len,
&context_buf_len ) == 0 );
mbedtls_ssl_free( &(server.ssl) );
mbedtls_ssl_init( &(server.ssl) );
TEST_ASSERT( mbedtls_ssl_setup( &(server.ssl), &(server.conf) ) == 0 );
mbedtls_ssl_set_bio( &( server.ssl ), &server_context,
mbedtls_mock_tcp_send_msg,
mbedtls_mock_tcp_recv_msg,
NULL );
#if defined(MBEDTLS_TIMING_C)
mbedtls_ssl_set_timer_cb( &server.ssl, &timer_server,
mbedtls_timing_set_delay,
mbedtls_timing_get_delay );
#endif
#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
if( options->resize_buffers != 0 )
{
/* Ensure that the buffer sizes are appropriate before resizes */
TEST_ASSERT( server.ssl.out_buf_len == MBEDTLS_SSL_OUT_BUFFER_LEN );
TEST_ASSERT( server.ssl.in_buf_len == MBEDTLS_SSL_IN_BUFFER_LEN );
}
#endif
TEST_ASSERT( mbedtls_ssl_context_load( &( server.ssl ), context_buf,
context_buf_len ) == 0 );
#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
/* Validate buffer sizes after context deserialization */
if( options->resize_buffers != 0 )
{
TEST_ASSERT( server.ssl.out_buf_len ==
mbedtls_ssl_get_output_buflen( &server.ssl ) );
TEST_ASSERT( server.ssl.in_buf_len ==
mbedtls_ssl_get_input_buflen( &server.ssl ) );
}
#endif
/* Retest writing/reading */
if( options->cli_msg_len != 0 || options->srv_msg_len != 0 )
{
TEST_ASSERT( mbedtls_exchange_data( &(client.ssl),
options->cli_msg_len,
options->expected_cli_fragments,
&(server.ssl),
options->srv_msg_len,
options->expected_srv_fragments )
== 0 );
}
}
#endif /* MBEDTLS_SSL_CONTEXT_SERIALIZATION */
#if defined(MBEDTLS_SSL_RENEGOTIATION)
if( options->renegotiate )
{
/* Start test with renegotiation */
TEST_ASSERT( server.ssl.renego_status ==
MBEDTLS_SSL_INITIAL_HANDSHAKE );
TEST_ASSERT( client.ssl.renego_status ==
MBEDTLS_SSL_INITIAL_HANDSHAKE );
/* After calling this function for the server, it only sends a handshake
* request. All renegotiation should happen during data exchanging */
TEST_ASSERT( mbedtls_ssl_renegotiate( &(server.ssl) ) == 0 );
TEST_ASSERT( server.ssl.renego_status ==
MBEDTLS_SSL_RENEGOTIATION_PENDING );
TEST_ASSERT( client.ssl.renego_status ==
MBEDTLS_SSL_INITIAL_HANDSHAKE );
TEST_ASSERT( exchange_data( &(client.ssl), &(server.ssl) ) == 0 );
TEST_ASSERT( server.ssl.renego_status ==
MBEDTLS_SSL_RENEGOTIATION_DONE );
TEST_ASSERT( client.ssl.renego_status ==
MBEDTLS_SSL_RENEGOTIATION_DONE );
/* After calling mbedtls_ssl_renegotiate for the client all renegotiation
* should happen inside this function. However in this test, we cannot
* perform simultaneous communication betwen client and server so this
* function will return waiting error on the socket. All rest of
* renegotiation should happen during data exchanging */
ret = mbedtls_ssl_renegotiate( &(client.ssl) );
#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
if( options->resize_buffers != 0 )
{
/* Ensure that the buffer sizes are appropriate before resizes */
TEST_ASSERT( client.ssl.out_buf_len == MBEDTLS_SSL_OUT_BUFFER_LEN );
TEST_ASSERT( client.ssl.in_buf_len == MBEDTLS_SSL_IN_BUFFER_LEN );
}
#endif
TEST_ASSERT( ret == 0 ||
ret == MBEDTLS_ERR_SSL_WANT_READ ||
ret == MBEDTLS_ERR_SSL_WANT_WRITE );
TEST_ASSERT( server.ssl.renego_status ==
MBEDTLS_SSL_RENEGOTIATION_DONE );
TEST_ASSERT( client.ssl.renego_status ==
MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS );
TEST_ASSERT( exchange_data( &(client.ssl), &(server.ssl) ) == 0 );
TEST_ASSERT( server.ssl.renego_status ==
MBEDTLS_SSL_RENEGOTIATION_DONE );
TEST_ASSERT( client.ssl.renego_status ==
MBEDTLS_SSL_RENEGOTIATION_DONE );
#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
/* Validate buffer sizes after renegotiation */
if( options->resize_buffers != 0 )
{
TEST_ASSERT( client.ssl.out_buf_len ==
mbedtls_ssl_get_output_buflen( &client.ssl ) );
TEST_ASSERT( client.ssl.in_buf_len ==
mbedtls_ssl_get_input_buflen( &client.ssl ) );
TEST_ASSERT( server.ssl.out_buf_len ==
mbedtls_ssl_get_output_buflen( &server.ssl ) );
TEST_ASSERT( server.ssl.in_buf_len ==
mbedtls_ssl_get_input_buflen( &server.ssl ) );
}
#endif /* MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH */
}
#endif /* MBEDTLS_SSL_RENEGOTIATION */
exit:
mbedtls_endpoint_free( &client, options->dtls != 0 ? &client_context : NULL );
mbedtls_endpoint_free( &server, options->dtls != 0 ? &server_context : NULL );
#if defined (MBEDTLS_DEBUG_C)
if( options->cli_log_fun || options->srv_log_fun )
{
mbedtls_debug_set_threshold( 0 );
}
#endif
#if defined(MBEDTLS_SSL_CONTEXT_SERIALIZATION)
if( context_buf != NULL )
mbedtls_free( context_buf );
#endif
}
#endif /* MBEDTLS_X509_CRT_PARSE_C && MBEDTLS_ENTROPY_C && MBEDTLS_CTR_DRBG_C */
void test_test_callback_buffer_sanity()
{
enum { MSGLEN = 10 };
mbedtls_test_buffer buf;
unsigned char input[MSGLEN];
unsigned char output[MSGLEN];
memset( input, 0, sizeof(input) );
/* Make sure calling put and get on NULL buffer results in error. */
TEST_ASSERT( mbedtls_test_buffer_put( NULL, input, sizeof( input ) )
== -1 );
TEST_ASSERT( mbedtls_test_buffer_get( NULL, output, sizeof( output ) )
== -1 );
TEST_ASSERT( mbedtls_test_buffer_put( NULL, NULL, sizeof( input ) ) == -1 );
TEST_ASSERT( mbedtls_test_buffer_put( NULL, NULL, 0 ) == -1 );
TEST_ASSERT( mbedtls_test_buffer_get( NULL, NULL, 0 ) == -1 );
/* Make sure calling put and get on a buffer that hasn't been set up results
* in eror. */
mbedtls_test_buffer_init( &buf );
TEST_ASSERT( mbedtls_test_buffer_put( &buf, input, sizeof( input ) ) == -1 );
TEST_ASSERT( mbedtls_test_buffer_get( &buf, output, sizeof( output ) )
== -1 );
TEST_ASSERT( mbedtls_test_buffer_put( &buf, NULL, sizeof( input ) ) == -1 );
TEST_ASSERT( mbedtls_test_buffer_put( &buf, NULL, 0 ) == -1 );
TEST_ASSERT( mbedtls_test_buffer_get( &buf, NULL, 0 ) == -1 );
/* Make sure calling put and get on NULL input only results in
* error if the length is not zero, and that a NULL output is valid for data
* dropping.
*/
TEST_ASSERT( mbedtls_test_buffer_setup( &buf, sizeof( input ) ) == 0 );
TEST_ASSERT( mbedtls_test_buffer_put( &buf, NULL, sizeof( input ) ) == -1 );
TEST_ASSERT( mbedtls_test_buffer_get( &buf, NULL, sizeof( output ) )
== 0 );
TEST_ASSERT( mbedtls_test_buffer_put( &buf, NULL, 0 ) == 0 );
TEST_ASSERT( mbedtls_test_buffer_get( &buf, NULL, 0 ) == 0 );
/* Make sure calling put several times in the row is safe */
TEST_ASSERT( mbedtls_test_buffer_put( &buf, input, sizeof( input ) )
== sizeof( input ) );
TEST_ASSERT( mbedtls_test_buffer_get( &buf, output, 2 ) == 2 );
TEST_ASSERT( mbedtls_test_buffer_put( &buf, input, 1 ) == 1 );
TEST_ASSERT( mbedtls_test_buffer_put( &buf, input, 2 ) == 1 );
TEST_ASSERT( mbedtls_test_buffer_put( &buf, input, 2 ) == 0 );
exit:
mbedtls_test_buffer_free( &buf );
}
void test_test_callback_buffer_sanity_wrapper( void ** params )
{
(void)params;
test_test_callback_buffer_sanity( );
}
void test_test_callback_buffer( int size, int put1, int put1_ret,
int get1, int get1_ret, int put2, int put2_ret,
int get2, int get2_ret )
{
enum { ROUNDS = 2 };
size_t put[ROUNDS];
int put_ret[ROUNDS];
size_t get[ROUNDS];
int get_ret[ROUNDS];
mbedtls_test_buffer buf;
unsigned char* input = NULL;
size_t input_len;
unsigned char* output = NULL;
size_t output_len;
size_t i, j, written, read;
mbedtls_test_buffer_init( &buf );
TEST_ASSERT( mbedtls_test_buffer_setup( &buf, size ) == 0 );
/* Check the sanity of input parameters and initialise local variables. That
* is, ensure that the amount of data is not negative and that we are not
* expecting more to put or get than we actually asked for. */
TEST_ASSERT( put1 >= 0 );
put[0] = put1;
put_ret[0] = put1_ret;
TEST_ASSERT( put1_ret <= put1 );
TEST_ASSERT( put2 >= 0 );
put[1] = put2;
put_ret[1] = put2_ret;
TEST_ASSERT( put2_ret <= put2 );
TEST_ASSERT( get1 >= 0 );
get[0] = get1;
get_ret[0] = get1_ret;
TEST_ASSERT( get1_ret <= get1 );
TEST_ASSERT( get2 >= 0 );
get[1] = get2;
get_ret[1] = get2_ret;
TEST_ASSERT( get2_ret <= get2 );
input_len = 0;
/* Calculate actual input and output lengths */
for( j = 0; j < ROUNDS; j++ )
{
if( put_ret[j] > 0 )
{
input_len += put_ret[j];
}
}
/* In order to always have a valid pointer we always allocate at least 1
* byte. */
if( input_len == 0 )
input_len = 1;
ASSERT_ALLOC( input, input_len );
output_len = 0;
for( j = 0; j < ROUNDS; j++ )
{
if( get_ret[j] > 0 )
{
output_len += get_ret[j];
}
}
TEST_ASSERT( output_len <= input_len );
/* In order to always have a valid pointer we always allocate at least 1
* byte. */
if( output_len == 0 )
output_len = 1;
ASSERT_ALLOC( output, output_len );
/* Fill up the buffer with structured data so that unwanted changes
* can be detected */
for( i = 0; i < input_len; i++ )
{
input[i] = i & 0xFF;
}
written = read = 0;
for( j = 0; j < ROUNDS; j++ )
{
TEST_ASSERT( put_ret[j] == mbedtls_test_buffer_put( &buf,
input + written, put[j] ) );
written += put_ret[j];
TEST_ASSERT( get_ret[j] == mbedtls_test_buffer_get( &buf,
output + read, get[j] ) );
read += get_ret[j];
TEST_ASSERT( read <= written );
if( get_ret[j] > 0 )
{
TEST_ASSERT( memcmp( output + read - get_ret[j],
input + read - get_ret[j], get_ret[j] )
== 0 );
}
}
exit:
mbedtls_free( input );
mbedtls_free( output );
mbedtls_test_buffer_free( &buf );
}
void test_test_callback_buffer_wrapper( void ** params )
{
test_test_callback_buffer( *( (int *) params[0] ), *( (int *) params[1] ), *( (int *) params[2] ), *( (int *) params[3] ), *( (int *) params[4] ), *( (int *) params[5] ), *( (int *) params[6] ), *( (int *) params[7] ), *( (int *) params[8] ) );
}
void test_ssl_mock_sanity( )
{
enum { MSGLEN = 105 };
unsigned char message[MSGLEN];
unsigned char received[MSGLEN];
mbedtls_mock_socket socket;
mbedtls_mock_socket_init( &socket );
TEST_ASSERT( mbedtls_mock_tcp_send_b( &socket, message, MSGLEN ) < 0 );
mbedtls_mock_socket_close( &socket );
mbedtls_mock_socket_init( &socket );
TEST_ASSERT( mbedtls_mock_tcp_recv_b( &socket, received, MSGLEN ) < 0 );
mbedtls_mock_socket_close( &socket );
mbedtls_mock_socket_init( &socket );
TEST_ASSERT( mbedtls_mock_tcp_send_nb( &socket, message, MSGLEN ) < 0 );
mbedtls_mock_socket_close( &socket );
mbedtls_mock_socket_init( &socket );
TEST_ASSERT( mbedtls_mock_tcp_recv_nb( &socket, received, MSGLEN ) < 0 );
mbedtls_mock_socket_close( &socket );
exit:
mbedtls_mock_socket_close( &socket );
}
void test_ssl_mock_sanity_wrapper( void ** params )
{
(void)params;
test_ssl_mock_sanity( );
}
void test_ssl_mock_tcp( int blocking )
{
enum { MSGLEN = 105 };
enum { BUFLEN = MSGLEN / 5 };
unsigned char message[MSGLEN];
unsigned char received[MSGLEN];
mbedtls_mock_socket client;
mbedtls_mock_socket server;
size_t written, read;
int send_ret, recv_ret;
mbedtls_ssl_send_t *send;
mbedtls_ssl_recv_t *recv;
unsigned i;
if( blocking == 0 )
{
send = mbedtls_mock_tcp_send_nb;
recv = mbedtls_mock_tcp_recv_nb;
}
else
{
send = mbedtls_mock_tcp_send_b;
recv = mbedtls_mock_tcp_recv_b;
}
mbedtls_mock_socket_init( &client );
mbedtls_mock_socket_init( &server );
/* Fill up the buffer with structured data so that unwanted changes
* can be detected */
for( i = 0; i < MSGLEN; i++ )
{
message[i] = i & 0xFF;
}
/* Make sure that sending a message takes a few iterations. */
TEST_ASSERT( 0 == mbedtls_mock_socket_connect( &client, &server, BUFLEN ) );
/* Send the message to the server */
send_ret = recv_ret = 1;
written = read = 0;
while( send_ret != 0 || recv_ret != 0 )
{
send_ret = send( &client, message + written, MSGLEN - written );
TEST_ASSERT( send_ret >= 0 );
TEST_ASSERT( send_ret <= BUFLEN );
written += send_ret;
/* If the buffer is full we can test blocking and non-blocking send */
if ( send_ret == BUFLEN )
{
int blocking_ret = send( &client, message , 1 );
if ( blocking )
{
TEST_ASSERT( blocking_ret == 0 );
}
else
{
TEST_ASSERT( blocking_ret == MBEDTLS_ERR_SSL_WANT_WRITE );
}
}
recv_ret = recv( &server, received + read, MSGLEN - read );
/* The result depends on whether any data was sent */
if ( send_ret > 0 )
{
TEST_ASSERT( recv_ret > 0 );
TEST_ASSERT( recv_ret <= BUFLEN );
read += recv_ret;
}
else if( blocking )
{
TEST_ASSERT( recv_ret == 0 );
}
else
{
TEST_ASSERT( recv_ret == MBEDTLS_ERR_SSL_WANT_READ );
recv_ret = 0;
}
/* If the buffer is empty we can test blocking and non-blocking read */
if ( recv_ret == BUFLEN )
{
int blocking_ret = recv( &server, received, 1 );
if ( blocking )
{
TEST_ASSERT( blocking_ret == 0 );
}
else
{
TEST_ASSERT( blocking_ret == MBEDTLS_ERR_SSL_WANT_READ );
}
}
}
TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
exit:
mbedtls_mock_socket_close( &client );
mbedtls_mock_socket_close( &server );
}
void test_ssl_mock_tcp_wrapper( void ** params )
{
test_ssl_mock_tcp( *( (int *) params[0] ) );
}
void test_ssl_mock_tcp_interleaving( int blocking )
{
enum { ROUNDS = 2 };
enum { MSGLEN = 105 };
enum { BUFLEN = MSGLEN / 5 };
unsigned char message[ROUNDS][MSGLEN];
unsigned char received[ROUNDS][MSGLEN];
mbedtls_mock_socket client;
mbedtls_mock_socket server;
size_t written[ROUNDS];
size_t read[ROUNDS];
int send_ret[ROUNDS];
int recv_ret[ROUNDS];
unsigned i, j, progress;
mbedtls_ssl_send_t *send;
mbedtls_ssl_recv_t *recv;
if( blocking == 0 )
{
send = mbedtls_mock_tcp_send_nb;
recv = mbedtls_mock_tcp_recv_nb;
}
else
{
send = mbedtls_mock_tcp_send_b;
recv = mbedtls_mock_tcp_recv_b;
}
mbedtls_mock_socket_init( &client );
mbedtls_mock_socket_init( &server );
/* Fill up the buffers with structured data so that unwanted changes
* can be detected */
for( i = 0; i < ROUNDS; i++ )
{
for( j = 0; j < MSGLEN; j++ )
{
message[i][j] = ( i * MSGLEN + j ) & 0xFF;
}
}
/* Make sure that sending a message takes a few iterations. */
TEST_ASSERT( 0 == mbedtls_mock_socket_connect( &client, &server, BUFLEN ) );
/* Send the message from both sides, interleaving. */
progress = 1;
for( i = 0; i < ROUNDS; i++ )
{
written[i] = 0;
read[i] = 0;
}
/* This loop does not stop as long as there was a successful write or read
* of at least one byte on either side. */
while( progress != 0 )
{
mbedtls_mock_socket *socket;
for( i = 0; i < ROUNDS; i++ )
{
/* First sending is from the client */
socket = ( i % 2 == 0 ) ? ( &client ) : ( &server );
send_ret[i] = send( socket, message[i] + written[i],
MSGLEN - written[i] );
TEST_ASSERT( send_ret[i] >= 0 );
TEST_ASSERT( send_ret[i] <= BUFLEN );
written[i] += send_ret[i];
/* If the buffer is full we can test blocking and non-blocking
* send */
if ( send_ret[i] == BUFLEN )
{
int blocking_ret = send( socket, message[i] , 1 );
if ( blocking )
{
TEST_ASSERT( blocking_ret == 0 );
}
else
{
TEST_ASSERT( blocking_ret == MBEDTLS_ERR_SSL_WANT_WRITE );
}
}
}
for( i = 0; i < ROUNDS; i++ )
{
/* First receiving is from the server */
socket = ( i % 2 == 0 ) ? ( &server ) : ( &client );
recv_ret[i] = recv( socket, received[i] + read[i],
MSGLEN - read[i] );
/* The result depends on whether any data was sent */
if ( send_ret[i] > 0 )
{
TEST_ASSERT( recv_ret[i] > 0 );
TEST_ASSERT( recv_ret[i] <= BUFLEN );
read[i] += recv_ret[i];
}
else if( blocking )
{
TEST_ASSERT( recv_ret[i] == 0 );
}
else
{
TEST_ASSERT( recv_ret[i] == MBEDTLS_ERR_SSL_WANT_READ );
recv_ret[i] = 0;
}
/* If the buffer is empty we can test blocking and non-blocking
* read */
if ( recv_ret[i] == BUFLEN )
{
int blocking_ret = recv( socket, received[i], 1 );
if ( blocking )
{
TEST_ASSERT( blocking_ret == 0 );
}
else
{
TEST_ASSERT( blocking_ret == MBEDTLS_ERR_SSL_WANT_READ );
}
}
}
progress = 0;
for( i = 0; i < ROUNDS; i++ )
{
progress += send_ret[i] + recv_ret[i];
}
}
for( i = 0; i < ROUNDS; i++ )
TEST_ASSERT( memcmp( message[i], received[i], MSGLEN ) == 0 );
exit:
mbedtls_mock_socket_close( &client );
mbedtls_mock_socket_close( &server );
}
void test_ssl_mock_tcp_interleaving_wrapper( void ** params )
{
test_ssl_mock_tcp_interleaving( *( (int *) params[0] ) );
}
void test_ssl_message_queue_sanity( )
{
mbedtls_test_message_queue queue;
/* Trying to push/pull to an empty queue */
TEST_ASSERT( mbedtls_test_message_queue_push_info( NULL, 1 )
== MBEDTLS_TEST_ERROR_ARG_NULL );
TEST_ASSERT( mbedtls_test_message_queue_pop_info( NULL, 1 )
== MBEDTLS_TEST_ERROR_ARG_NULL );
TEST_ASSERT( mbedtls_test_message_queue_setup( &queue, 3 ) == 0 );
TEST_ASSERT( queue.capacity == 3 );
TEST_ASSERT( queue.num == 0 );
exit:
mbedtls_test_message_queue_free( &queue );
}
void test_ssl_message_queue_sanity_wrapper( void ** params )
{
(void)params;
test_ssl_message_queue_sanity( );
}
void test_ssl_message_queue_basic( )
{
mbedtls_test_message_queue queue;
TEST_ASSERT( mbedtls_test_message_queue_setup( &queue, 3 ) == 0 );
/* Sanity test - 3 pushes and 3 pops with sufficient space */
TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 1 ) == 1 );
TEST_ASSERT( queue.capacity == 3 );
TEST_ASSERT( queue.num == 1 );
TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 1 ) == 1 );
TEST_ASSERT( queue.capacity == 3 );
TEST_ASSERT( queue.num == 2 );
TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 2 ) == 2 );
TEST_ASSERT( queue.capacity == 3 );
TEST_ASSERT( queue.num == 3 );
TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 1 ) == 1 );
TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 1 ) == 1 );
TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 2 ) == 2 );
exit:
mbedtls_test_message_queue_free( &queue );
}
void test_ssl_message_queue_basic_wrapper( void ** params )
{
(void)params;
test_ssl_message_queue_basic( );
}
void test_ssl_message_queue_overflow_underflow( )
{
mbedtls_test_message_queue queue;
TEST_ASSERT( mbedtls_test_message_queue_setup( &queue, 3 ) == 0 );
/* 4 pushes (last one with an error), 4 pops (last one with an error) */
TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 1 ) == 1 );
TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 1 ) == 1 );
TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 2 ) == 2 );
TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 3 )
== MBEDTLS_ERR_SSL_WANT_WRITE );
TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 1 ) == 1 );
TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 1 ) == 1 );
TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 2 ) == 2 );
TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 1 )
== MBEDTLS_ERR_SSL_WANT_READ );
exit:
mbedtls_test_message_queue_free( &queue );
}
void test_ssl_message_queue_overflow_underflow_wrapper( void ** params )
{
(void)params;
test_ssl_message_queue_overflow_underflow( );
}
void test_ssl_message_queue_interleaved( )
{
mbedtls_test_message_queue queue;
TEST_ASSERT( mbedtls_test_message_queue_setup( &queue, 3 ) == 0 );
/* Interleaved test - [2 pushes, 1 pop] twice, and then two pops
* (to wrap around the buffer) */
TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 1 ) == 1 );
TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 1 ) == 1 );
TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 1 ) == 1 );
TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 2 ) == 2 );
TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 3 ) == 3 );
TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 1 ) == 1 );
TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 2 ) == 2 );
TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 5 ) == 5 );
TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 8 ) == 8 );
TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 3 ) == 3 );
TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 5 ) == 5 );
TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 8 ) == 8 );
exit:
mbedtls_test_message_queue_free( &queue );
}
void test_ssl_message_queue_interleaved_wrapper( void ** params )
{
(void)params;
test_ssl_message_queue_interleaved( );
}
void test_ssl_message_queue_insufficient_buffer( )
{
mbedtls_test_message_queue queue;
size_t message_len = 10;
size_t buffer_len = 5;
TEST_ASSERT( mbedtls_test_message_queue_setup( &queue, 1 ) == 0 );
/* Popping without a sufficient buffer */
TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, message_len )
== (int) message_len );
TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, buffer_len )
== (int) buffer_len );
exit:
mbedtls_test_message_queue_free( &queue );
}
void test_ssl_message_queue_insufficient_buffer_wrapper( void ** params )
{
(void)params;
test_ssl_message_queue_insufficient_buffer( );
}
void test_ssl_message_mock_uninitialized( )
{
enum { MSGLEN = 10 };
unsigned char message[MSGLEN] = {0}, received[MSGLEN];
mbedtls_mock_socket client, server;
mbedtls_test_message_queue server_queue, client_queue;
mbedtls_test_message_socket_context server_context, client_context;
mbedtls_message_socket_init( &server_context );
mbedtls_message_socket_init( &client_context );
/* Send with a NULL context */
TEST_ASSERT( mbedtls_mock_tcp_send_msg( NULL, message, MSGLEN )
== MBEDTLS_TEST_ERROR_CONTEXT_ERROR );
TEST_ASSERT( mbedtls_mock_tcp_recv_msg( NULL, message, MSGLEN )
== MBEDTLS_TEST_ERROR_CONTEXT_ERROR );
TEST_ASSERT( mbedtls_message_socket_setup( &server_queue, &client_queue, 1,
&server,
&server_context ) == 0 );
TEST_ASSERT( mbedtls_message_socket_setup( &client_queue, &server_queue, 1,
&client,
&client_context ) == 0 );
TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message, MSGLEN )
== MBEDTLS_TEST_ERROR_SEND_FAILED );
TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN )
== MBEDTLS_ERR_SSL_WANT_READ );
/* Push directly to a queue to later simulate a disconnected behavior */
TEST_ASSERT( mbedtls_test_message_queue_push_info( &server_queue, MSGLEN )
== MSGLEN );
/* Test if there's an error when trying to read from a disconnected
* socket */
TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN )
== MBEDTLS_TEST_ERROR_RECV_FAILED );
exit:
mbedtls_message_socket_close( &server_context );
mbedtls_message_socket_close( &client_context );
}
void test_ssl_message_mock_uninitialized_wrapper( void ** params )
{
(void)params;
test_ssl_message_mock_uninitialized( );
}
void test_ssl_message_mock_basic( )
{
enum { MSGLEN = 10 };
unsigned char message[MSGLEN], received[MSGLEN];
mbedtls_mock_socket client, server;
unsigned i;
mbedtls_test_message_queue server_queue, client_queue;
mbedtls_test_message_socket_context server_context, client_context;
mbedtls_message_socket_init( &server_context );
mbedtls_message_socket_init( &client_context );
TEST_ASSERT( mbedtls_message_socket_setup( &server_queue, &client_queue, 1,
&server,
&server_context ) == 0 );
TEST_ASSERT( mbedtls_message_socket_setup( &client_queue, &server_queue, 1,
&client,
&client_context ) == 0 );
/* Fill up the buffer with structured data so that unwanted changes
* can be detected */
for( i = 0; i < MSGLEN; i++ )
{
message[i] = i & 0xFF;
}
TEST_ASSERT( 0 == mbedtls_mock_socket_connect( &client, &server,
MSGLEN ) );
/* Send the message to the server */
TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
MSGLEN ) == MSGLEN );
/* Read from the server */
TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN )
== MSGLEN );
TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
memset( received, 0, MSGLEN );
/* Send the message to the client */
TEST_ASSERT( mbedtls_mock_tcp_send_msg( &server_context, message,
MSGLEN ) == MSGLEN );
/* Read from the client */
TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &client_context, received, MSGLEN )
== MSGLEN );
TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
exit:
mbedtls_message_socket_close( &server_context );
mbedtls_message_socket_close( &client_context );
}
void test_ssl_message_mock_basic_wrapper( void ** params )
{
(void)params;
test_ssl_message_mock_basic( );
}
void test_ssl_message_mock_queue_overflow_underflow( )
{
enum { MSGLEN = 10 };
unsigned char message[MSGLEN], received[MSGLEN];
mbedtls_mock_socket client, server;
unsigned i;
mbedtls_test_message_queue server_queue, client_queue;
mbedtls_test_message_socket_context server_context, client_context;
mbedtls_message_socket_init( &server_context );
mbedtls_message_socket_init( &client_context );
TEST_ASSERT( mbedtls_message_socket_setup( &server_queue, &client_queue, 2,
&server,
&server_context ) == 0 );
TEST_ASSERT( mbedtls_message_socket_setup( &client_queue, &server_queue, 2,
&client,
&client_context ) == 0 );
/* Fill up the buffer with structured data so that unwanted changes
* can be detected */
for( i = 0; i < MSGLEN; i++ )
{
message[i] = i & 0xFF;
}
TEST_ASSERT( 0 == mbedtls_mock_socket_connect( &client, &server,
MSGLEN*2 ) );
/* Send three message to the server, last one with an error */
TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
MSGLEN - 1 ) == MSGLEN - 1 );
TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
MSGLEN ) == MSGLEN );
TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
MSGLEN )
== MBEDTLS_ERR_SSL_WANT_WRITE );
/* Read three messages from the server, last one with an error */
TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received,
MSGLEN - 1 ) == MSGLEN - 1 );
TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN )
== MSGLEN );
TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN )
== MBEDTLS_ERR_SSL_WANT_READ );
exit:
mbedtls_message_socket_close( &server_context );
mbedtls_message_socket_close( &client_context );
}
void test_ssl_message_mock_queue_overflow_underflow_wrapper( void ** params )
{
(void)params;
test_ssl_message_mock_queue_overflow_underflow( );
}
void test_ssl_message_mock_socket_overflow( )
{
enum { MSGLEN = 10 };
unsigned char message[MSGLEN], received[MSGLEN];
mbedtls_mock_socket client, server;
unsigned i;
mbedtls_test_message_queue server_queue, client_queue;
mbedtls_test_message_socket_context server_context, client_context;
mbedtls_message_socket_init( &server_context );
mbedtls_message_socket_init( &client_context );
TEST_ASSERT( mbedtls_message_socket_setup( &server_queue, &client_queue, 2,
&server,
&server_context ) == 0 );
TEST_ASSERT( mbedtls_message_socket_setup( &client_queue, &server_queue, 2,
&client,
&client_context ) == 0 );
/* Fill up the buffer with structured data so that unwanted changes
* can be detected */
for( i = 0; i < MSGLEN; i++ )
{
message[i] = i & 0xFF;
}
TEST_ASSERT( 0 == mbedtls_mock_socket_connect( &client, &server,
MSGLEN ) );
/* Send two message to the server, second one with an error */
TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
MSGLEN ) == MSGLEN );
TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
MSGLEN )
== MBEDTLS_TEST_ERROR_SEND_FAILED );
/* Read the only message from the server */
TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN )
== MSGLEN );
TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
exit:
mbedtls_message_socket_close( &server_context );
mbedtls_message_socket_close( &client_context );
}
void test_ssl_message_mock_socket_overflow_wrapper( void ** params )
{
(void)params;
test_ssl_message_mock_socket_overflow( );
}
void test_ssl_message_mock_truncated( )
{
enum { MSGLEN = 10 };
unsigned char message[MSGLEN], received[MSGLEN];
mbedtls_mock_socket client, server;
unsigned i;
mbedtls_test_message_queue server_queue, client_queue;
mbedtls_test_message_socket_context server_context, client_context;
mbedtls_message_socket_init( &server_context );
mbedtls_message_socket_init( &client_context );
TEST_ASSERT( mbedtls_message_socket_setup( &server_queue, &client_queue, 2,
&server,
&server_context ) == 0 );
TEST_ASSERT( mbedtls_message_socket_setup( &client_queue, &server_queue, 2,
&client,
&client_context ) == 0 );
memset( received, 0, MSGLEN );
/* Fill up the buffer with structured data so that unwanted changes
* can be detected */
for( i = 0; i < MSGLEN; i++ )
{
message[i] = i & 0xFF;
}
TEST_ASSERT( 0 == mbedtls_mock_socket_connect( &client, &server,
2 * MSGLEN ) );
/* Send two messages to the server, the second one small enough to fit in the
* receiver's buffer. */
TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
MSGLEN ) == MSGLEN );
TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
MSGLEN / 2 ) == MSGLEN / 2 );
/* Read a truncated message from the server */
TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN/2 )
== MSGLEN/2 );
/* Test that the first half of the message is valid, and second one isn't */
TEST_ASSERT( memcmp( message, received, MSGLEN/2 ) == 0 );
TEST_ASSERT( memcmp( message + MSGLEN/2, received + MSGLEN/2, MSGLEN/2 )
!= 0 );
memset( received, 0, MSGLEN );
/* Read a full message from the server */
TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN/2 )
== MSGLEN / 2 );
/* Test that the first half of the message is valid */
TEST_ASSERT( memcmp( message, received, MSGLEN/2 ) == 0 );
exit:
mbedtls_message_socket_close( &server_context );
mbedtls_message_socket_close( &client_context );
}
void test_ssl_message_mock_truncated_wrapper( void ** params )
{
(void)params;
test_ssl_message_mock_truncated( );
}
void test_ssl_message_mock_socket_read_error( )
{
enum { MSGLEN = 10 };
unsigned char message[MSGLEN], received[MSGLEN];
mbedtls_mock_socket client, server;
unsigned i;
mbedtls_test_message_queue server_queue, client_queue;
mbedtls_test_message_socket_context server_context, client_context;
mbedtls_message_socket_init( &server_context );
mbedtls_message_socket_init( &client_context );
TEST_ASSERT( mbedtls_message_socket_setup( &server_queue, &client_queue, 1,
&server,
&server_context ) == 0 );
TEST_ASSERT( mbedtls_message_socket_setup( &client_queue, &server_queue, 1,
&client,
&client_context ) == 0 );
/* Fill up the buffer with structured data so that unwanted changes
* can be detected */
for( i = 0; i < MSGLEN; i++ )
{
message[i] = i & 0xFF;
}
TEST_ASSERT( 0 == mbedtls_mock_socket_connect( &client, &server,
MSGLEN ) );
TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
MSGLEN ) == MSGLEN );
/* Force a read error by disconnecting the socket by hand */
server.status = 0;
TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN )
== MBEDTLS_TEST_ERROR_RECV_FAILED );
/* Return to a valid state */
server.status = MBEDTLS_MOCK_SOCKET_CONNECTED;
memset( received, 0, sizeof( received ) );
/* Test that even though the server tried to read once disconnected, the
* continuity is preserved */
TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN )
== MSGLEN );
TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
exit:
mbedtls_message_socket_close( &server_context );
mbedtls_message_socket_close( &client_context );
}
void test_ssl_message_mock_socket_read_error_wrapper( void ** params )
{
(void)params;
test_ssl_message_mock_socket_read_error( );
}
void test_ssl_message_mock_interleaved_one_way( )
{
enum { MSGLEN = 10 };
unsigned char message[MSGLEN], received[MSGLEN];
mbedtls_mock_socket client, server;
unsigned i;
mbedtls_test_message_queue server_queue, client_queue;
mbedtls_test_message_socket_context server_context, client_context;
mbedtls_message_socket_init( &server_context );
mbedtls_message_socket_init( &client_context );
TEST_ASSERT( mbedtls_message_socket_setup( &server_queue, &client_queue, 3,
&server,
&server_context ) == 0 );
TEST_ASSERT( mbedtls_message_socket_setup( &client_queue, &server_queue, 3,
&client,
&client_context ) == 0 );
/* Fill up the buffer with structured data so that unwanted changes
* can be detected */
for( i = 0; i < MSGLEN; i++ )
{
message[i] = i & 0xFF;
}
TEST_ASSERT( 0 == mbedtls_mock_socket_connect( &client, &server,
MSGLEN*3 ) );
/* Interleaved test - [2 sends, 1 read] twice, and then two reads
* (to wrap around the buffer) */
for( i = 0; i < 2; i++ )
{
TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
MSGLEN ) == MSGLEN );
TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
MSGLEN ) == MSGLEN );
TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received,
MSGLEN ) == MSGLEN );
TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
memset( received, 0, sizeof( received ) );
}
for( i = 0; i < 2; i++ )
{
TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received,
MSGLEN ) == MSGLEN );
TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
}
TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN )
== MBEDTLS_ERR_SSL_WANT_READ );
exit:
mbedtls_message_socket_close( &server_context );
mbedtls_message_socket_close( &client_context );
}
void test_ssl_message_mock_interleaved_one_way_wrapper( void ** params )
{
(void)params;
test_ssl_message_mock_interleaved_one_way( );
}
void test_ssl_message_mock_interleaved_two_ways( )
{
enum { MSGLEN = 10 };
unsigned char message[MSGLEN], received[MSGLEN];
mbedtls_mock_socket client, server;
unsigned i;
mbedtls_test_message_queue server_queue, client_queue;
mbedtls_test_message_socket_context server_context, client_context;
mbedtls_message_socket_init( &server_context );
mbedtls_message_socket_init( &client_context );
TEST_ASSERT( mbedtls_message_socket_setup( &server_queue, &client_queue, 3,
&server,
&server_context ) == 0 );
TEST_ASSERT( mbedtls_message_socket_setup( &client_queue, &server_queue, 3,
&client,
&client_context ) == 0 );
/* Fill up the buffer with structured data so that unwanted changes
* can be detected */
for( i = 0; i < MSGLEN; i++ )
{
message[i] = i & 0xFF;
}
TEST_ASSERT( 0 == mbedtls_mock_socket_connect( &client, &server,
MSGLEN*3 ) );
/* Interleaved test - [2 sends, 1 read] twice, both ways, and then two reads
* (to wrap around the buffer) both ways. */
for( i = 0; i < 2; i++ )
{
TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
MSGLEN ) == MSGLEN );
TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
MSGLEN ) == MSGLEN );
TEST_ASSERT( mbedtls_mock_tcp_send_msg( &server_context, message,
MSGLEN ) == MSGLEN );
TEST_ASSERT( mbedtls_mock_tcp_send_msg( &server_context, message,
MSGLEN ) == MSGLEN );
TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received,
MSGLEN ) == MSGLEN );
TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
memset( received, 0, sizeof( received ) );
TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &client_context, received,
MSGLEN ) == MSGLEN );
TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
memset( received, 0, sizeof( received ) );
}
for( i = 0; i < 2; i++ )
{
TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received,
MSGLEN ) == MSGLEN );
TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
memset( received, 0, sizeof( received ) );
TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &client_context, received,
MSGLEN ) == MSGLEN );
TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
memset( received, 0, sizeof( received ) );
}
TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN )
== MBEDTLS_ERR_SSL_WANT_READ );
TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &client_context, received, MSGLEN )
== MBEDTLS_ERR_SSL_WANT_READ );
exit:
mbedtls_message_socket_close( &server_context );
mbedtls_message_socket_close( &client_context );
}
void test_ssl_message_mock_interleaved_two_ways_wrapper( void ** params )
{
(void)params;
test_ssl_message_mock_interleaved_two_ways( );
}
#if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY)
void test_ssl_dtls_replay( data_t * prevs, data_t * new, int ret )
{
uint32_t len = 0;
mbedtls_ssl_context ssl;
mbedtls_ssl_config conf;
mbedtls_ssl_init( &ssl );
mbedtls_ssl_config_init( &conf );
TEST_ASSERT( mbedtls_ssl_config_defaults( &conf,
MBEDTLS_SSL_IS_CLIENT,
MBEDTLS_SSL_TRANSPORT_DATAGRAM,
MBEDTLS_SSL_PRESET_DEFAULT ) == 0 );
TEST_ASSERT( mbedtls_ssl_setup( &ssl, &conf ) == 0 );
/* Read previous record numbers */
for( len = 0; len < prevs->len; len += 6 )
{
memcpy( ssl.in_ctr + 2, prevs->x + len, 6 );
mbedtls_ssl_dtls_replay_update( &ssl );
}
/* Check new number */
memcpy( ssl.in_ctr + 2, new->x, 6 );
TEST_ASSERT( mbedtls_ssl_dtls_replay_check( &ssl ) == ret );
mbedtls_ssl_free( &ssl );
mbedtls_ssl_config_free( &conf );
exit:
;
}
void test_ssl_dtls_replay_wrapper( void ** params )
{
data_t data0 = {(uint8_t *) params[0], *( (uint32_t *) params[1] )};
data_t data2 = {(uint8_t *) params[2], *( (uint32_t *) params[3] )};
test_ssl_dtls_replay( &data0, &data2, *( (int *) params[4] ) );
}
#endif /* MBEDTLS_SSL_DTLS_ANTI_REPLAY */
#if defined(MBEDTLS_X509_CRT_PARSE_C)
void test_ssl_set_hostname_twice( char *hostname0, char *hostname1 )
{
mbedtls_ssl_context ssl;
mbedtls_ssl_init( &ssl );
TEST_ASSERT( mbedtls_ssl_set_hostname( &ssl, hostname0 ) == 0 );
TEST_ASSERT( mbedtls_ssl_set_hostname( &ssl, hostname1 ) == 0 );
mbedtls_ssl_free( &ssl );
exit:
;
}
void test_ssl_set_hostname_twice_wrapper( void ** params )
{
test_ssl_set_hostname_twice( (char *) params[0], (char *) params[1] );
}
#endif /* MBEDTLS_X509_CRT_PARSE_C */
void test_ssl_crypt_record( int cipher_type, int hash_id,
int etm, int tag_mode, int ver,
int cid0_len, int cid1_len )
{
/*
* Test several record encryptions and decryptions
* with plenty of space before and after the data
* within the record buffer.
*/
int ret;
int num_records = 16;
mbedtls_ssl_context ssl; /* ONLY for debugging */
mbedtls_ssl_transform t0, t1;
unsigned char *buf = NULL;
size_t const buflen = 512;
mbedtls_record rec, rec_backup;
mbedtls_ssl_init( &ssl );
mbedtls_ssl_transform_init( &t0 );
mbedtls_ssl_transform_init( &t1 );
TEST_ASSERT( build_transforms( &t0, &t1, cipher_type, hash_id,
etm, tag_mode, ver,
(size_t) cid0_len,
(size_t) cid1_len ) == 0 );
TEST_ASSERT( ( buf = mbedtls_calloc( 1, buflen ) ) != NULL );
while( num_records-- > 0 )
{
mbedtls_ssl_transform *t_dec, *t_enc;
/* Take turns in who's sending and who's receiving. */
if( num_records % 3 == 0 )
{
t_dec = &t0;
t_enc = &t1;
}
else
{
t_dec = &t1;
t_enc = &t0;
}
/*
* The record header affects the transformation in two ways:
* 1) It determines the AEAD additional data
* 2) The record counter sometimes determines the IV.
*
* Apart from that, the fields don't have influence.
* In particular, it is currently not the responsibility
* of ssl_encrypt/decrypt_buf to check if the transform
* version matches the record version, or that the
* type is sensible.
*/
memset( rec.ctr, num_records, sizeof( rec.ctr ) );
rec.type = 42;
rec.ver[0] = num_records;
rec.ver[1] = num_records;
#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
rec.cid_len = 0;
#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
rec.buf = buf;
rec.buf_len = buflen;
rec.data_offset = 16;
/* Make sure to vary the length to exercise different
* paddings. */
rec.data_len = 1 + num_records;
memset( rec.buf + rec.data_offset, 42, rec.data_len );
/* Make a copy for later comparison */
rec_backup = rec;
/* Encrypt record */
ret = mbedtls_ssl_encrypt_buf( &ssl, t_enc, &rec,
mbedtls_test_rnd_std_rand, NULL );
TEST_ASSERT( ret == 0 || ret == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
if( ret != 0 )
{
continue;
}
#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
if( rec.cid_len != 0 )
{
/* DTLS 1.2 + CID hides the real content type and
* uses a special CID content type in the protected
* record. Double-check this. */
TEST_ASSERT( rec.type == MBEDTLS_SSL_MSG_CID );
}
#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
#if defined(MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL)
if( t_enc->minor_ver == MBEDTLS_SSL_MINOR_VERSION_4 )
{
/* TLS 1.3 hides the real content type and
* always uses Application Data as the content type
* for protected records. Double-check this. */
TEST_ASSERT( rec.type == MBEDTLS_SSL_MSG_APPLICATION_DATA );
}
#endif /* MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL */
/* Decrypt record with t_dec */
TEST_EQUAL( 0, mbedtls_ssl_decrypt_buf( &ssl, t_dec, &rec ) );
/* Compare results */
TEST_ASSERT( rec.type == rec_backup.type );
TEST_ASSERT( memcmp( rec.ctr, rec_backup.ctr, 8 ) == 0 );
TEST_ASSERT( rec.ver[0] == rec_backup.ver[0] );
TEST_ASSERT( rec.ver[1] == rec_backup.ver[1] );
TEST_ASSERT( rec.data_len == rec_backup.data_len );
TEST_ASSERT( rec.data_offset == rec_backup.data_offset );
TEST_ASSERT( memcmp( rec.buf + rec.data_offset,
rec_backup.buf + rec_backup.data_offset,
rec.data_len ) == 0 );
}
exit:
/* Cleanup */
mbedtls_ssl_free( &ssl );
mbedtls_ssl_transform_free( &t0 );
mbedtls_ssl_transform_free( &t1 );
mbedtls_free( buf );
}
void test_ssl_crypt_record_wrapper( void ** params )
{
test_ssl_crypt_record( *( (int *) params[0] ), *( (int *) params[1] ), *( (int *) params[2] ), *( (int *) params[3] ), *( (int *) params[4] ), *( (int *) params[5] ), *( (int *) params[6] ) );
}
void test_ssl_crypt_record_small( int cipher_type, int hash_id,
int etm, int tag_mode, int ver,
int cid0_len, int cid1_len )
{
/*
* Test pairs of encryption and decryption with an increasing
* amount of space in the record buffer - in more detail:
* 1) Try to encrypt with 0, 1, 2, ... bytes available
* in front of the plaintext, and expect the encryption
* to succeed starting from some offset. Always keep
* enough space in the end of the buffer.
* 2) Try to encrypt with 0, 1, 2, ... bytes available
* at the end of the plaintext, and expect the encryption
* to succeed starting from some offset. Always keep
* enough space at the beginning of the buffer.
* 3) Try to encrypt with 0, 1, 2, ... bytes available
* both at the front and end of the plaintext,
* and expect the encryption to succeed starting from
* some offset.
*
* If encryption succeeds, check that decryption succeeds
* and yields the original record.
*/
mbedtls_ssl_context ssl; /* ONLY for debugging */
mbedtls_ssl_transform t0, t1;
unsigned char *buf = NULL;
size_t const buflen = 256;
mbedtls_record rec, rec_backup;
int ret;
int mode; /* Mode 1, 2 or 3 as explained above */
size_t offset; /* Available space at beginning/end/both */
size_t threshold = 96; /* Maximum offset to test against */
size_t default_pre_padding = 64; /* Pre-padding to use in mode 2 */
size_t default_post_padding = 128; /* Post-padding to use in mode 1 */
int seen_success; /* Indicates if in the current mode we've
* already seen a successful test. */
mbedtls_ssl_init( &ssl );
mbedtls_ssl_transform_init( &t0 );
mbedtls_ssl_transform_init( &t1 );
TEST_ASSERT( build_transforms( &t0, &t1, cipher_type, hash_id,
etm, tag_mode, ver,
(size_t) cid0_len,
(size_t) cid1_len ) == 0 );
TEST_ASSERT( ( buf = mbedtls_calloc( 1, buflen ) ) != NULL );
for( mode=1; mode <= 3; mode++ )
{
seen_success = 0;
for( offset=0; offset <= threshold; offset++ )
{
mbedtls_ssl_transform *t_dec, *t_enc;
t_dec = &t0;
t_enc = &t1;
memset( rec.ctr, offset, sizeof( rec.ctr ) );
rec.type = 42;
rec.ver[0] = offset;
rec.ver[1] = offset;
rec.buf = buf;
rec.buf_len = buflen;
#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
rec.cid_len = 0;
#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
switch( mode )
{
case 1: /* Space in the beginning */
rec.data_offset = offset;
rec.data_len = buflen - offset - default_post_padding;
break;
case 2: /* Space in the end */
rec.data_offset = default_pre_padding;
rec.data_len = buflen - default_pre_padding - offset;
break;
case 3: /* Space in the beginning and end */
rec.data_offset = offset;
rec.data_len = buflen - 2 * offset;
break;
default:
TEST_ASSERT( 0 );
break;
}
memset( rec.buf + rec.data_offset, 42, rec.data_len );
/* Make a copy for later comparison */
rec_backup = rec;
/* Encrypt record */
ret = mbedtls_ssl_encrypt_buf( &ssl, t_enc, &rec,
mbedtls_test_rnd_std_rand, NULL );
if( ( mode == 1 || mode == 2 ) && seen_success )
{
TEST_ASSERT( ret == 0 );
}
else
{
TEST_ASSERT( ret == 0 || ret == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
if( ret == 0 )
seen_success = 1;
}
if( ret != 0 )
continue;
#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
if( rec.cid_len != 0 )
{
/* DTLS 1.2 + CID hides the real content type and
* uses a special CID content type in the protected
* record. Double-check this. */
TEST_ASSERT( rec.type == MBEDTLS_SSL_MSG_CID );
}
#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
#if defined(MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL)
if( t_enc->minor_ver == MBEDTLS_SSL_MINOR_VERSION_4 )
{
/* TLS 1.3 hides the real content type and
* always uses Application Data as the content type
* for protected records. Double-check this. */
TEST_ASSERT( rec.type == MBEDTLS_SSL_MSG_APPLICATION_DATA );
}
#endif /* MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL */
/* Decrypt record with t_dec */
TEST_EQUAL( 0, mbedtls_ssl_decrypt_buf( &ssl, t_dec, &rec ) );
/* Compare results */
TEST_ASSERT( rec.type == rec_backup.type );
TEST_ASSERT( memcmp( rec.ctr, rec_backup.ctr, 8 ) == 0 );
TEST_ASSERT( rec.ver[0] == rec_backup.ver[0] );
TEST_ASSERT( rec.ver[1] == rec_backup.ver[1] );
TEST_ASSERT( rec.data_len == rec_backup.data_len );
TEST_ASSERT( rec.data_offset == rec_backup.data_offset );
TEST_ASSERT( memcmp( rec.buf + rec.data_offset,
rec_backup.buf + rec_backup.data_offset,
rec.data_len ) == 0 );
}
TEST_ASSERT( seen_success == 1 );
}
exit:
/* Cleanup */
mbedtls_ssl_free( &ssl );
mbedtls_ssl_transform_free( &t0 );
mbedtls_ssl_transform_free( &t1 );
mbedtls_free( buf );
}
void test_ssl_crypt_record_small_wrapper( void ** params )
{
test_ssl_crypt_record_small( *( (int *) params[0] ), *( (int *) params[1] ), *( (int *) params[2] ), *( (int *) params[3] ), *( (int *) params[4] ), *( (int *) params[5] ), *( (int *) params[6] ) );
}
#if defined(MBEDTLS_CIPHER_MODE_CBC)
#if defined(MBEDTLS_AES_C)
#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
void test_ssl_decrypt_non_etm_cbc( int cipher_type, int hash_id, int trunc_hmac,
int length_selector )
{
/*
* Test record decryption for CBC without EtM, focused on the verification
* of padding and MAC.
*
* Actually depends on TLS >= 1.0 (SSL 3.0 computes the MAC differently),
* and either AES, ARIA, Camellia or DES, but since the test framework
* doesn't support alternation in dependency statements, just depend on
* TLS 1.2 and AES.
*
* The length_selector argument is interpreted as follows:
* - if it's -1, the plaintext length is 0 and minimal padding is applied
* - if it's -2, the plaintext length is 0 and maximal padding is applied
* - otherwise it must be in [0, 255] and is padding_length from RFC 5246:
* it's the length of the rest of the padding, that is, excluding the
* byte that encodes the length. The minimal non-zero plaintext length
* that gives this padding_length is automatically selected.
*/
mbedtls_ssl_context ssl; /* ONLY for debugging */
mbedtls_ssl_transform t0, t1;
mbedtls_record rec, rec_save;
unsigned char *buf = NULL, *buf_save = NULL;
size_t buflen, olen = 0;
size_t plaintext_len, block_size, i;
unsigned char padlen; /* excluding the padding_length byte */
unsigned char add_data[13];
unsigned char mac[MBEDTLS_MD_MAX_SIZE];
int exp_ret;
const unsigned char pad_max_len = 255; /* Per the standard */
mbedtls_ssl_init( &ssl );
mbedtls_ssl_transform_init( &t0 );
mbedtls_ssl_transform_init( &t1 );
/* Set up transforms with dummy keys */
TEST_ASSERT( build_transforms( &t0, &t1, cipher_type, hash_id,
0, trunc_hmac,
MBEDTLS_SSL_MINOR_VERSION_3,
0 , 0 ) == 0 );
/* Determine padding/plaintext length */
TEST_ASSERT( length_selector >= -2 && length_selector <= 255 );
block_size = t0.ivlen;
if( length_selector < 0 )
{
plaintext_len = 0;
/* Minimal padding
* The +1 is for the padding_length byte, not counted in padlen. */
padlen = block_size - ( t0.maclen + 1 ) % block_size;
/* Maximal padding? */
if( length_selector == -2 )
padlen += block_size * ( ( pad_max_len - padlen ) / block_size );
}
else
{
padlen = length_selector;
/* Minimal non-zero plaintext_length giving desired padding.
* The +1 is for the padding_length byte, not counted in padlen. */
plaintext_len = block_size - ( padlen + t0.maclen + 1 ) % block_size;
}
/* Prepare a buffer for record data */
buflen = block_size
+ plaintext_len
+ t0.maclen
+ padlen + 1;
ASSERT_ALLOC( buf, buflen );
ASSERT_ALLOC( buf_save, buflen );
/* Prepare a dummy record header */
memset( rec.ctr, 0, sizeof( rec.ctr ) );
rec.type = MBEDTLS_SSL_MSG_APPLICATION_DATA;
rec.ver[0] = MBEDTLS_SSL_MAJOR_VERSION_3;
rec.ver[1] = MBEDTLS_SSL_MINOR_VERSION_3;
#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
rec.cid_len = 0;
#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
/* Prepare dummy record content */
rec.buf = buf;
rec.buf_len = buflen;
rec.data_offset = block_size;
rec.data_len = plaintext_len;
memset( rec.buf + rec.data_offset, 42, rec.data_len );
/* Serialized version of record header for MAC purposes */
memcpy( add_data, rec.ctr, 8 );
add_data[8] = rec.type;
add_data[9] = rec.ver[0];
add_data[10] = rec.ver[1];
add_data[11] = ( rec.data_len >> 8 ) & 0xff;
add_data[12] = ( rec.data_len >> 0 ) & 0xff;
/* Set dummy IV */
memset( t0.iv_enc, 0x55, t0.ivlen );
memcpy( rec.buf, t0.iv_enc, t0.ivlen );
/*
* Prepare a pre-encryption record (with MAC and padding), and save it.
*/
/* MAC with additional data */
TEST_EQUAL( 0, mbedtls_md_hmac_update( &t0.md_ctx_enc, add_data, 13 ) );
TEST_EQUAL( 0, mbedtls_md_hmac_update( &t0.md_ctx_enc,
rec.buf + rec.data_offset,
rec.data_len ) );
TEST_EQUAL( 0, mbedtls_md_hmac_finish( &t0.md_ctx_enc, mac ) );
memcpy( rec.buf + rec.data_offset + rec.data_len, mac, t0.maclen );
rec.data_len += t0.maclen;
/* Pad */
memset( rec.buf + rec.data_offset + rec.data_len, padlen, padlen + 1 );
rec.data_len += padlen + 1;
/* Save correct pre-encryption record */
rec_save = rec;
rec_save.buf = buf_save;
memcpy( buf_save, buf, buflen );
/*
* Encrypt and decrypt the correct record, expecting success
*/
TEST_EQUAL( 0, mbedtls_cipher_crypt( &t0.cipher_ctx_enc,
t0.iv_enc, t0.ivlen,
rec.buf + rec.data_offset, rec.data_len,
rec.buf + rec.data_offset, &olen ) );
rec.data_offset -= t0.ivlen;
rec.data_len += t0.ivlen;
TEST_EQUAL( 0, mbedtls_ssl_decrypt_buf( &ssl, &t1, &rec ) );
/*
* Modify each byte of the pre-encryption record before encrypting and
* decrypting it, expecting failure every time.
*
* We use RANDOMMNESS because this loop runs hundreds of times and this
* function runs hundreds of times. So it can very easily contribute to
* hundreds of milliseconds of latency, which we can't have in our pure
* testing infrastructure.
*/
for( i = block_size; i < buflen; i += max( 1, _rand64() & 31 ) )
{
mbedtls_test_set_step( i );
/* Restore correct pre-encryption record */
rec = rec_save;
rec.buf = buf;
memcpy( buf, buf_save, buflen );
/* Corrupt one byte of the data (could be plaintext, MAC or padding) */
rec.buf[i] ^= 0x01;
/* Encrypt */
TEST_EQUAL( 0, mbedtls_cipher_crypt( &t0.cipher_ctx_enc,
t0.iv_enc, t0.ivlen,
rec.buf + rec.data_offset, rec.data_len,
rec.buf + rec.data_offset, &olen ) );
rec.data_offset -= t0.ivlen;
rec.data_len += t0.ivlen;
/* Decrypt and expect failure */
TEST_EQUAL( MBEDTLS_ERR_SSL_INVALID_MAC,
mbedtls_ssl_decrypt_buf( &ssl, &t1, &rec ) );
}
/*
* Use larger values of the padding bytes - with small buffers, this tests
* the case where the announced padlen would be larger than the buffer
* (and before that, than the buffer minus the size of the MAC), to make
* sure our padding checking code does not perform any out-of-bounds reads
* in this case. (With larger buffers, ie when the plaintext is long or
* maximal length padding is used, this is less relevant but still doesn't
* hurt to test.)
*
* (Start the loop with correct padding, just to double-check that record
* saving did work, and that we're overwriting the correct bytes.)
*
* We use RANDOMMNESS because this loop runs hundreds of times and this
* function runs hundreds of times. So it can very easily contribute to
* hundreds of milliseconds of latency, which we can't have in our pure
* testing infrastructure.
*/
for( i = padlen; i <= pad_max_len; i += max( 1, _rand64() & 31 ) )
{
mbedtls_test_set_step( i );
/* Restore correct pre-encryption record */
rec = rec_save;
rec.buf = buf;
memcpy( buf, buf_save, buflen );
/* Set padding bytes to new value */
memset( buf + buflen - padlen - 1, i, padlen + 1 );
/* Encrypt */
TEST_EQUAL( 0, mbedtls_cipher_crypt( &t0.cipher_ctx_enc,
t0.iv_enc, t0.ivlen,
rec.buf + rec.data_offset, rec.data_len,
rec.buf + rec.data_offset, &olen ) );
rec.data_offset -= t0.ivlen;
rec.data_len += t0.ivlen;
/* Decrypt and expect failure except the first time */
exp_ret = ( i == padlen ) ? 0 : MBEDTLS_ERR_SSL_INVALID_MAC;
TEST_EQUAL( exp_ret, mbedtls_ssl_decrypt_buf( &ssl, &t1, &rec ) );
}
exit:
mbedtls_ssl_free( &ssl );
mbedtls_ssl_transform_free( &t0 );
mbedtls_ssl_transform_free( &t1 );
mbedtls_free( buf );
mbedtls_free( buf_save );
}
void test_ssl_decrypt_non_etm_cbc_wrapper( void ** params )
{
test_ssl_decrypt_non_etm_cbc( *( (int *) params[0] ), *( (int *) params[1] ), *( (int *) params[2] ), *( (int *) params[3] ) );
}
#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
#endif /* MBEDTLS_AES_C */
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#if defined(MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL)
void test_ssl_tls1_3_hkdf_expand_label( int hash_alg,
data_t *secret,
int label_idx,
data_t *ctx,
int desired_length,
data_t *expected )
{
unsigned char dst[ 100 ];
unsigned char const *lbl = NULL;
size_t lbl_len;
#define MBEDTLS_SSL_TLS1_3_LABEL( name, string ) \
if( label_idx == (int) tls1_3_label_ ## name ) \
{ \
lbl = mbedtls_ssl_tls1_3_labels.name; \
lbl_len = sizeof( mbedtls_ssl_tls1_3_labels.name ); \
}
MBEDTLS_SSL_TLS1_3_LABEL_LIST
#undef MBEDTLS_SSL_TLS1_3_LABEL
TEST_ASSERT( lbl != NULL );
/* Check sanity of test parameters. */
TEST_ASSERT( (size_t) desired_length <= sizeof(dst) );
TEST_ASSERT( (size_t) desired_length == expected->len );
TEST_ASSERT( mbedtls_ssl_tls1_3_hkdf_expand_label(
(mbedtls_md_type_t) hash_alg,
secret->x, secret->len,
lbl, lbl_len,
ctx->x, ctx->len,
dst, desired_length ) == 0 );
ASSERT_COMPARE( dst, (size_t) desired_length,
expected->x, (size_t) expected->len );
exit:
;
}
void test_ssl_tls1_3_hkdf_expand_label_wrapper( void ** params )
{
data_t data1 = {(uint8_t *) params[1], *( (uint32_t *) params[2] )};
data_t data4 = {(uint8_t *) params[4], *( (uint32_t *) params[5] )};
data_t data7 = {(uint8_t *) params[7], *( (uint32_t *) params[8] )};
test_ssl_tls1_3_hkdf_expand_label( *( (int *) params[0] ), &data1, *( (int *) params[3] ), &data4, *( (int *) params[6] ), &data7 );
}
#endif /* MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL */
#if defined(MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL)
void test_ssl_tls1_3_traffic_key_generation( int hash_alg,
data_t *server_secret,
data_t *client_secret,
int desired_iv_len,
int desired_key_len,
data_t *expected_server_write_key,
data_t *expected_server_write_iv,
data_t *expected_client_write_key,
data_t *expected_client_write_iv )
{
mbedtls_ssl_key_set keys;
/* Check sanity of test parameters. */
TEST_ASSERT( client_secret->len == server_secret->len );
TEST_ASSERT( expected_client_write_iv->len == expected_server_write_iv->len &&
expected_client_write_iv->len == (size_t) desired_iv_len );
TEST_ASSERT( expected_client_write_key->len == expected_server_write_key->len &&
expected_client_write_key->len == (size_t) desired_key_len );
TEST_ASSERT( mbedtls_ssl_tls1_3_make_traffic_keys(
(mbedtls_md_type_t) hash_alg,
client_secret->x,
server_secret->x,
client_secret->len /* == server_secret->len */,
desired_key_len, desired_iv_len,
&keys ) == 0 );
ASSERT_COMPARE( keys.client_write_key,
keys.key_len,
expected_client_write_key->x,
(size_t) desired_key_len );
ASSERT_COMPARE( keys.server_write_key,
keys.key_len,
expected_server_write_key->x,
(size_t) desired_key_len );
ASSERT_COMPARE( keys.client_write_iv,
keys.iv_len,
expected_client_write_iv->x,
(size_t) desired_iv_len );
ASSERT_COMPARE( keys.server_write_iv,
keys.iv_len,
expected_server_write_iv->x,
(size_t) desired_iv_len );
exit:
;
}
void test_ssl_tls1_3_traffic_key_generation_wrapper( void ** params )
{
data_t data1 = {(uint8_t *) params[1], *( (uint32_t *) params[2] )};
data_t data3 = {(uint8_t *) params[3], *( (uint32_t *) params[4] )};
data_t data7 = {(uint8_t *) params[7], *( (uint32_t *) params[8] )};
data_t data9 = {(uint8_t *) params[9], *( (uint32_t *) params[10] )};
data_t data11 = {(uint8_t *) params[11], *( (uint32_t *) params[12] )};
data_t data13 = {(uint8_t *) params[13], *( (uint32_t *) params[14] )};
test_ssl_tls1_3_traffic_key_generation( *( (int *) params[0] ), &data1, &data3, *( (int *) params[5] ), *( (int *) params[6] ), &data7, &data9, &data11, &data13 );
}
#endif /* MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL */
#if defined(MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL)
void test_ssl_tls1_3_derive_secret( int hash_alg,
data_t *secret,
int label_idx,
data_t *ctx,
int desired_length,
int already_hashed,
data_t *expected )
{
unsigned char dst[ 100 ];
unsigned char const *lbl = NULL;
size_t lbl_len;
#define MBEDTLS_SSL_TLS1_3_LABEL( name, string ) \
if( label_idx == (int) tls1_3_label_ ## name ) \
{ \
lbl = mbedtls_ssl_tls1_3_labels.name; \
lbl_len = sizeof( mbedtls_ssl_tls1_3_labels.name ); \
}
MBEDTLS_SSL_TLS1_3_LABEL_LIST
#undef MBEDTLS_SSL_TLS1_3_LABEL
TEST_ASSERT( lbl != NULL );
/* Check sanity of test parameters. */
TEST_ASSERT( (size_t) desired_length <= sizeof(dst) );
TEST_ASSERT( (size_t) desired_length == expected->len );
TEST_ASSERT( mbedtls_ssl_tls1_3_derive_secret(
(mbedtls_md_type_t) hash_alg,
secret->x, secret->len,
lbl, lbl_len,
ctx->x, ctx->len,
already_hashed,
dst, desired_length ) == 0 );
ASSERT_COMPARE( dst, desired_length,
expected->x, desired_length );
exit:
;
}
void test_ssl_tls1_3_derive_secret_wrapper( void ** params )
{
data_t data1 = {(uint8_t *) params[1], *( (uint32_t *) params[2] )};
data_t data4 = {(uint8_t *) params[4], *( (uint32_t *) params[5] )};
data_t data8 = {(uint8_t *) params[8], *( (uint32_t *) params[9] )};
test_ssl_tls1_3_derive_secret( *( (int *) params[0] ), &data1, *( (int *) params[3] ), &data4, *( (int *) params[6] ), *( (int *) params[7] ), &data8 );
}
#endif /* MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL */
#if defined(MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL)
void test_ssl_tls1_3_key_evolution( int hash_alg,
data_t *secret,
data_t *input,
data_t *expected )
{
unsigned char secret_new[ MBEDTLS_MD_MAX_SIZE ];
TEST_ASSERT( mbedtls_ssl_tls1_3_evolve_secret(
(mbedtls_md_type_t) hash_alg,
secret->len ? secret->x : NULL,
input->len ? input->x : NULL, input->len,
secret_new ) == 0 );
ASSERT_COMPARE( secret_new, (size_t) expected->len,
expected->x, (size_t) expected->len );
exit:
;
}
void test_ssl_tls1_3_key_evolution_wrapper( void ** params )
{
data_t data1 = {(uint8_t *) params[1], *( (uint32_t *) params[2] )};
data_t data3 = {(uint8_t *) params[3], *( (uint32_t *) params[4] )};
data_t data5 = {(uint8_t *) params[5], *( (uint32_t *) params[6] )};
test_ssl_tls1_3_key_evolution( *( (int *) params[0] ), &data1, &data3, &data5 );
}
#endif /* MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL */
void test_ssl_tls_prf( int type, data_t * secret, data_t * random,
char *label, data_t *result_str, int exp_ret )
{
unsigned char *output;
output = mbedtls_calloc( 1, result_str->len );
if( output == NULL )
goto exit;
USE_PSA_INIT( );
TEST_ASSERT( mbedtls_ssl_tls_prf( type, secret->x, secret->len,
label, random->x, random->len,
output, result_str->len ) == exp_ret );
if( exp_ret == 0 )
{
TEST_ASSERT( mbedtls_test_hexcmp( output, result_str->x,
result_str->len, result_str->len ) == 0 );
}
exit:
mbedtls_free( output );
USE_PSA_DONE( );
}
void test_ssl_tls_prf_wrapper( void ** params )
{
data_t data1 = {(uint8_t *) params[1], *( (uint32_t *) params[2] )};
data_t data3 = {(uint8_t *) params[3], *( (uint32_t *) params[4] )};
data_t data6 = {(uint8_t *) params[6], *( (uint32_t *) params[7] )};
test_ssl_tls_prf( *( (int *) params[0] ), &data1, &data3, (char *) params[5], &data6, *( (int *) params[8] ) );
}
void test_ssl_serialize_session_save_load( int ticket_len, char *crt_file )
{
mbedtls_ssl_session original, restored;
unsigned char *buf = NULL;
size_t len;
/*
* Test that a save-load pair is the identity
*/
mbedtls_ssl_session_init( &original );
mbedtls_ssl_session_init( &restored );
/* Prepare a dummy session to work on */
TEST_ASSERT( ssl_populate_session( &original, ticket_len, crt_file ) == 0 );
/* Serialize it */
TEST_ASSERT( mbedtls_ssl_session_save( &original, NULL, 0, &len )
== MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
TEST_ASSERT( ( buf = mbedtls_calloc( 1, len ) ) != NULL );
TEST_ASSERT( mbedtls_ssl_session_save( &original, buf, len, &len )
== 0 );
/* Restore session from serialized data */
TEST_ASSERT( mbedtls_ssl_session_load( &restored, buf, len) == 0 );
/*
* Make sure both session structures are identical
*/
#if defined(MBEDTLS_HAVE_TIME)
TEST_ASSERT( original.start == restored.start );
#endif
TEST_ASSERT( original.ciphersuite == restored.ciphersuite );
TEST_ASSERT( original.compression == restored.compression );
TEST_ASSERT( original.id_len == restored.id_len );
TEST_ASSERT( memcmp( original.id,
restored.id, sizeof( original.id ) ) == 0 );
TEST_ASSERT( memcmp( original.master,
restored.master, sizeof( original.master ) ) == 0 );
#if defined(MBEDTLS_X509_CRT_PARSE_C)
#if defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
TEST_ASSERT( ( original.peer_cert == NULL ) ==
( restored.peer_cert == NULL ) );
if( original.peer_cert != NULL )
{
TEST_ASSERT( original.peer_cert->raw.len ==
restored.peer_cert->raw.len );
TEST_ASSERT( memcmp( original.peer_cert->raw.p,
restored.peer_cert->raw.p,
original.peer_cert->raw.len ) == 0 );
}
#else /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
TEST_ASSERT( original.peer_cert_digest_type ==
restored.peer_cert_digest_type );
TEST_ASSERT( original.peer_cert_digest_len ==
restored.peer_cert_digest_len );
TEST_ASSERT( ( original.peer_cert_digest == NULL ) ==
( restored.peer_cert_digest == NULL ) );
if( original.peer_cert_digest != NULL )
{
TEST_ASSERT( memcmp( original.peer_cert_digest,
restored.peer_cert_digest,
original.peer_cert_digest_len ) == 0 );
}
#endif /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
#endif /* MBEDTLS_X509_CRT_PARSE_C */
TEST_ASSERT( original.verify_result == restored.verify_result );
#if defined(MBEDTLS_SSL_SESSION_TICKETS) && defined(MBEDTLS_SSL_CLI_C)
TEST_ASSERT( original.ticket_len == restored.ticket_len );
if( original.ticket_len != 0 )
{
TEST_ASSERT( original.ticket != NULL );
TEST_ASSERT( restored.ticket != NULL );
TEST_ASSERT( memcmp( original.ticket,
restored.ticket, original.ticket_len ) == 0 );
}
TEST_ASSERT( original.ticket_lifetime == restored.ticket_lifetime );
#endif
#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
TEST_ASSERT( original.mfl_code == restored.mfl_code );
#endif
#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
TEST_ASSERT( original.encrypt_then_mac == restored.encrypt_then_mac );
#endif
exit:
mbedtls_ssl_session_free( &original );
mbedtls_ssl_session_free( &restored );
mbedtls_free( buf );
}
void test_ssl_serialize_session_save_load_wrapper( void ** params )
{
test_ssl_serialize_session_save_load( *( (int *) params[0] ), (char *) params[1] );
}
void test_ssl_serialize_session_load_save( int ticket_len, char *crt_file )
{
mbedtls_ssl_session session;
unsigned char *buf1 = NULL, *buf2 = NULL;
size_t len0, len1, len2;
/*
* Test that a load-save pair is the identity
*/
mbedtls_ssl_session_init( &session );
/* Prepare a dummy session to work on */
TEST_ASSERT( ssl_populate_session( &session, ticket_len, crt_file ) == 0 );
/* Get desired buffer size for serializing */
TEST_ASSERT( mbedtls_ssl_session_save( &session, NULL, 0, &len0 )
== MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
/* Allocate first buffer */
buf1 = mbedtls_calloc( 1, len0 );
TEST_ASSERT( buf1 != NULL );
/* Serialize to buffer and free live session */
TEST_ASSERT( mbedtls_ssl_session_save( &session, buf1, len0, &len1 )
== 0 );
TEST_ASSERT( len0 == len1 );
mbedtls_ssl_session_free( &session );
/* Restore session from serialized data */
TEST_ASSERT( mbedtls_ssl_session_load( &session, buf1, len1 ) == 0 );
/* Allocate second buffer and serialize to it */
buf2 = mbedtls_calloc( 1, len0 );
TEST_ASSERT( buf2 != NULL );
TEST_ASSERT( mbedtls_ssl_session_save( &session, buf2, len0, &len2 )
== 0 );
/* Make sure both serialized versions are identical */
TEST_ASSERT( len1 == len2 );
TEST_ASSERT( memcmp( buf1, buf2, len1 ) == 0 );
exit:
mbedtls_ssl_session_free( &session );
mbedtls_free( buf1 );
mbedtls_free( buf2 );
}
void test_ssl_serialize_session_load_save_wrapper( void ** params )
{
test_ssl_serialize_session_load_save( *( (int *) params[0] ), (char *) params[1] );
}
void test_ssl_serialize_session_save_buf_size( int ticket_len, char *crt_file )
{
mbedtls_ssl_session session;
unsigned char *buf = NULL;
size_t good_len, bad_len, test_len;
/*
* Test that session_save() fails cleanly on small buffers
*/
mbedtls_ssl_session_init( &session );
/* Prepare dummy session and get serialized size */
TEST_ASSERT( ssl_populate_session( &session, ticket_len, crt_file ) == 0 );
TEST_ASSERT( mbedtls_ssl_session_save( &session, NULL, 0, &good_len )
== MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
/* Try all possible bad lengths */
for( bad_len = 1; bad_len < good_len; bad_len++ )
{
/* Allocate exact size so that asan/valgrind can detect any overwrite */
mbedtls_free( buf );
TEST_ASSERT( ( buf = mbedtls_calloc( 1, bad_len ) ) != NULL );
TEST_ASSERT( mbedtls_ssl_session_save( &session, buf, bad_len,
&test_len )
== MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
TEST_ASSERT( test_len == good_len );
}
exit:
mbedtls_ssl_session_free( &session );
mbedtls_free( buf );
}
void test_ssl_serialize_session_save_buf_size_wrapper( void ** params )
{
test_ssl_serialize_session_save_buf_size( *( (int *) params[0] ), (char *) params[1] );
}
void test_ssl_serialize_session_load_buf_size( int ticket_len, char *crt_file )
{
mbedtls_ssl_session session;
unsigned char *good_buf = NULL, *bad_buf = NULL;
size_t good_len, bad_len;
/*
* Test that session_load() fails cleanly on small buffers
*/
mbedtls_ssl_session_init( &session );
/* Prepare serialized session data */
TEST_ASSERT( ssl_populate_session( &session, ticket_len, crt_file ) == 0 );
TEST_ASSERT( mbedtls_ssl_session_save( &session, NULL, 0, &good_len )
== MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
TEST_ASSERT( ( good_buf = mbedtls_calloc( 1, good_len ) ) != NULL );
TEST_ASSERT( mbedtls_ssl_session_save( &session, good_buf, good_len,
&good_len ) == 0 );
mbedtls_ssl_session_free( &session );
/* Try all possible bad lengths */
for( bad_len = 0; bad_len < good_len; bad_len++ )
{
/* Allocate exact size so that asan/valgrind can detect any overread */
mbedtls_free( bad_buf );
bad_buf = mbedtls_calloc( 1, bad_len ? bad_len : 1 );
TEST_ASSERT( bad_buf != NULL );
memcpy( bad_buf, good_buf, bad_len );
TEST_ASSERT( mbedtls_ssl_session_load( &session, bad_buf, bad_len )
== MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
}
exit:
mbedtls_ssl_session_free( &session );
mbedtls_free( good_buf );
mbedtls_free( bad_buf );
}
void test_ssl_serialize_session_load_buf_size_wrapper( void ** params )
{
test_ssl_serialize_session_load_buf_size( *( (int *) params[0] ), (char *) params[1] );
}
void test_ssl_session_serialize_version_check( int corrupt_major,
int corrupt_minor,
int corrupt_patch,
int corrupt_config )
{
unsigned char serialized_session[ 2048 ];
size_t serialized_session_len;
unsigned cur_byte;
mbedtls_ssl_session session;
uint8_t should_corrupt_byte[] = { corrupt_major == 1,
corrupt_minor == 1,
corrupt_patch == 1,
corrupt_config == 1,
corrupt_config == 1 };
mbedtls_ssl_session_init( &session );
/* Infer length of serialized session. */
TEST_ASSERT( mbedtls_ssl_session_save( &session,
serialized_session,
sizeof( serialized_session ),
&serialized_session_len ) == 0 );
mbedtls_ssl_session_free( &session );
/* Without any modification, we should be able to successfully
* de-serialize the session - double-check that. */
TEST_ASSERT( mbedtls_ssl_session_load( &session,
serialized_session,
serialized_session_len ) == 0 );
mbedtls_ssl_session_free( &session );
/* Go through the bytes in the serialized session header and
* corrupt them bit-by-bit. */
for( cur_byte = 0; cur_byte < sizeof( should_corrupt_byte ); cur_byte++ )
{
int cur_bit;
unsigned char * const byte = &serialized_session[ cur_byte ];
if( should_corrupt_byte[ cur_byte ] == 0 )
continue;
for( cur_bit = 0; cur_bit < CHAR_BIT; cur_bit++ )
{
unsigned char const corrupted_bit = 0x1u << cur_bit;
/* Modify a single bit in the serialized session. */
*byte ^= corrupted_bit;
/* Attempt to deserialize */
TEST_ASSERT( mbedtls_ssl_session_load( &session,
serialized_session,
serialized_session_len ) ==
MBEDTLS_ERR_SSL_VERSION_MISMATCH );
/* Undo the change */
*byte ^= corrupted_bit;
}
}
exit:
;
}
void test_ssl_session_serialize_version_check_wrapper( void ** params )
{
test_ssl_session_serialize_version_check( *( (int *) params[0] ), *( (int *) params[1] ), *( (int *) params[2] ), *( (int *) params[3] ) );
}
#if defined(MBEDTLS_X509_CRT_PARSE_C)
#if defined(MBEDTLS_RSA_C)
#if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
#if !defined(MBEDTLS_USE_PSA_CRYPTO)
#if defined(MBEDTLS_PKCS1_V15)
#if defined(MBEDTLS_ENTROPY_C)
#if defined(MBEDTLS_ENTROPY_C)
#if defined(MBEDTLS_CTR_DRBG_C)
void test_mbedtls_endpoint_sanity( int endpoint_type )
{
enum { BUFFSIZE = 1024 };
mbedtls_endpoint ep;
int ret = -1;
ret = mbedtls_endpoint_init( NULL, endpoint_type, MBEDTLS_PK_RSA,
NULL, NULL, NULL );
TEST_ASSERT( MBEDTLS_ERR_SSL_BAD_INPUT_DATA == ret );
ret = mbedtls_endpoint_certificate_init( NULL, MBEDTLS_PK_RSA );
TEST_ASSERT( MBEDTLS_ERR_SSL_BAD_INPUT_DATA == ret );
ret = mbedtls_endpoint_init( &ep, endpoint_type, MBEDTLS_PK_RSA,
NULL, NULL, NULL );
TEST_ASSERT( ret == 0 );
exit:
mbedtls_endpoint_free( &ep, NULL );
}
void test_mbedtls_endpoint_sanity_wrapper( void ** params )
{
test_mbedtls_endpoint_sanity( *( (int *) params[0] ) );
}
#endif /* MBEDTLS_CTR_DRBG_C */
#endif /* MBEDTLS_ENTROPY_C */
#endif /* MBEDTLS_ENTROPY_C */
#endif /* MBEDTLS_PKCS1_V15 */
#endif /* !MBEDTLS_USE_PSA_CRYPTO */
#endif /* MBEDTLS_ECP_DP_SECP384R1_ENABLED */
#endif /* MBEDTLS_RSA_C */
#endif /* MBEDTLS_X509_CRT_PARSE_C */
#if defined(MBEDTLS_X509_CRT_PARSE_C)
#if defined(MBEDTLS_RSA_C)
#if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
#if !defined(MBEDTLS_USE_PSA_CRYPTO)
#if defined(MBEDTLS_PKCS1_V15)
#if defined(MBEDTLS_ENTROPY_C)
#if defined(MBEDTLS_ENTROPY_C)
#if defined(MBEDTLS_CTR_DRBG_C)
void test_move_handshake_to_state(int endpoint_type, int state, int need_pass)
{
enum { BUFFSIZE = 1024 };
mbedtls_endpoint base_ep, second_ep;
int ret = -1;
ret = mbedtls_endpoint_init( &base_ep, endpoint_type, MBEDTLS_PK_RSA,
NULL, NULL, NULL );
TEST_ASSERT( ret == 0 );
ret = mbedtls_endpoint_init( &second_ep,
( endpoint_type == MBEDTLS_SSL_IS_SERVER ) ?
MBEDTLS_SSL_IS_CLIENT : MBEDTLS_SSL_IS_SERVER,
MBEDTLS_PK_RSA, NULL, NULL, NULL );
TEST_ASSERT( ret == 0 );
ret = mbedtls_mock_socket_connect( &(base_ep.socket_),
&(second_ep.socket_),
BUFFSIZE );
TEST_ASSERT( ret == 0 );
ret = mbedtls_move_handshake_to_state( &(base_ep.ssl),
&(second_ep.ssl),
state );
if( need_pass )
{
TEST_ASSERT( ret == 0 );
TEST_ASSERT( base_ep.ssl.state == state );
}
else
{
TEST_ASSERT( ret != 0 );
TEST_ASSERT( base_ep.ssl.state != state );
}
exit:
mbedtls_endpoint_free( &base_ep, NULL );
mbedtls_endpoint_free( &second_ep, NULL );
}
void test_move_handshake_to_state_wrapper( void ** params )
{
test_move_handshake_to_state( *( (int *) params[0] ), *( (int *) params[1] ), *( (int *) params[2] ) );
}
#endif /* MBEDTLS_CTR_DRBG_C */
#endif /* MBEDTLS_ENTROPY_C */
#endif /* MBEDTLS_ENTROPY_C */
#endif /* MBEDTLS_PKCS1_V15 */
#endif /* !MBEDTLS_USE_PSA_CRYPTO */
#endif /* MBEDTLS_ECP_DP_SECP384R1_ENABLED */
#endif /* MBEDTLS_RSA_C */
#endif /* MBEDTLS_X509_CRT_PARSE_C */
#if defined(MBEDTLS_X509_CRT_PARSE_C)
#if !defined(MBEDTLS_USE_PSA_CRYPTO)
#if defined(MBEDTLS_PKCS1_V15)
#if defined(MBEDTLS_RSA_C)
#if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
#if defined(MBEDTLS_ENTROPY_C)
#if defined(MBEDTLS_CTR_DRBG_C)
void test_handshake_version( int dtls, int client_min_version, int client_max_version,
int server_min_version, int server_max_version,
int expected_negotiated_version )
{
handshake_test_options options;
init_handshake_options( &options );
options.client_min_version = client_min_version;
options.client_max_version = client_max_version;
options.server_min_version = server_min_version;
options.server_max_version = server_max_version;
options.expected_negotiated_version = expected_negotiated_version;
options.dtls = dtls;
/* By default, SSLv3.0 and TLSv1.0 use 1/n-1 splitting when sending data, so
* the number of fragments will be twice as big. */
if( expected_negotiated_version == MBEDTLS_SSL_MINOR_VERSION_0 ||
expected_negotiated_version == MBEDTLS_SSL_MINOR_VERSION_1 )
{
options.expected_cli_fragments = 2;
options.expected_srv_fragments = 2;
}
perform_handshake( &options );
/* The goto below is used to avoid an "unused label" warning.*/
goto exit;
exit:
;
}
void test_handshake_version_wrapper( void ** params )
{
test_handshake_version( *( (int *) params[0] ), *( (int *) params[1] ), *( (int *) params[2] ), *( (int *) params[3] ), *( (int *) params[4] ), *( (int *) params[5] ) );
}
#endif /* MBEDTLS_CTR_DRBG_C */
#endif /* MBEDTLS_ENTROPY_C */
#endif /* MBEDTLS_ECP_DP_SECP384R1_ENABLED */
#endif /* MBEDTLS_RSA_C */
#endif /* MBEDTLS_PKCS1_V15 */
#endif /* !MBEDTLS_USE_PSA_CRYPTO */
#endif /* MBEDTLS_X509_CRT_PARSE_C */
#if defined(MBEDTLS_X509_CRT_PARSE_C)
#if !defined(MBEDTLS_USE_PSA_CRYPTO)
#if defined(MBEDTLS_PKCS1_V15)
#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
#if defined(MBEDTLS_ENTROPY_C)
#if defined(MBEDTLS_CTR_DRBG_C)
void test_handshake_psk_cipher( char* cipher, int pk_alg, data_t *psk_str, int dtls )
{
handshake_test_options options;
init_handshake_options( &options );
options.cipher = cipher;
options.dtls = dtls;
options.psk_str = psk_str;
options.pk_alg = pk_alg;
perform_handshake( &options );
/* The goto below is used to avoid an "unused label" warning.*/
goto exit;
exit:
;
}
void test_handshake_psk_cipher_wrapper( void ** params )
{
data_t data2 = {(uint8_t *) params[2], *( (uint32_t *) params[3] )};
test_handshake_psk_cipher( (char *) params[0], *( (int *) params[1] ), &data2, *( (int *) params[4] ) );
}
#endif /* MBEDTLS_CTR_DRBG_C */
#endif /* MBEDTLS_ENTROPY_C */
#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
#endif /* MBEDTLS_PKCS1_V15 */
#endif /* !MBEDTLS_USE_PSA_CRYPTO */
#endif /* MBEDTLS_X509_CRT_PARSE_C */
#if defined(MBEDTLS_X509_CRT_PARSE_C)
#if !defined(MBEDTLS_USE_PSA_CRYPTO)
#if defined(MBEDTLS_PKCS1_V15)
#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
#if defined(MBEDTLS_ENTROPY_C)
#if defined(MBEDTLS_CTR_DRBG_C)
void test_handshake_cipher( char* cipher, int pk_alg, int dtls )
{
test_handshake_psk_cipher( cipher, pk_alg, NULL, dtls );
/* The goto below is used to avoid an "unused label" warning.*/
goto exit;
exit:
;
}
void test_handshake_cipher_wrapper( void ** params )
{
test_handshake_cipher( (char *) params[0], *( (int *) params[1] ), *( (int *) params[2] ) );
}
#endif /* MBEDTLS_CTR_DRBG_C */
#endif /* MBEDTLS_ENTROPY_C */
#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
#endif /* MBEDTLS_PKCS1_V15 */
#endif /* !MBEDTLS_USE_PSA_CRYPTO */
#endif /* MBEDTLS_X509_CRT_PARSE_C */
#if defined(MBEDTLS_X509_CRT_PARSE_C)
#if !defined(MBEDTLS_USE_PSA_CRYPTO)
#if defined(MBEDTLS_PKCS1_V15)
#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
#if defined(MBEDTLS_RSA_C)
#if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
#if defined(MBEDTLS_ENTROPY_C)
#if defined(MBEDTLS_CTR_DRBG_C)
void test_app_data( int mfl, int cli_msg_len, int srv_msg_len,
int expected_cli_fragments,
int expected_srv_fragments, int dtls )
{
handshake_test_options options;
init_handshake_options( &options );
options.mfl = mfl;
options.cli_msg_len = cli_msg_len;
options.srv_msg_len = srv_msg_len;
options.expected_cli_fragments = expected_cli_fragments;
options.expected_srv_fragments = expected_srv_fragments;
options.dtls = dtls;
perform_handshake( &options );
/* The goto below is used to avoid an "unused label" warning.*/
goto exit;
exit:
;
}
void test_app_data_wrapper( void ** params )
{
test_app_data( *( (int *) params[0] ), *( (int *) params[1] ), *( (int *) params[2] ), *( (int *) params[3] ), *( (int *) params[4] ), *( (int *) params[5] ) );
}
#endif /* MBEDTLS_CTR_DRBG_C */
#endif /* MBEDTLS_ENTROPY_C */
#endif /* MBEDTLS_ECP_DP_SECP384R1_ENABLED */
#endif /* MBEDTLS_RSA_C */
#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
#endif /* MBEDTLS_PKCS1_V15 */
#endif /* !MBEDTLS_USE_PSA_CRYPTO */
#endif /* MBEDTLS_X509_CRT_PARSE_C */
#if defined(MBEDTLS_X509_CRT_PARSE_C)
#if !defined(MBEDTLS_USE_PSA_CRYPTO)
#if defined(MBEDTLS_PKCS1_V15)
#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
#if defined(MBEDTLS_RSA_C)
#if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
#if defined(MBEDTLS_ENTROPY_C)
#if defined(MBEDTLS_CTR_DRBG_C)
void test_app_data_tls( int mfl, int cli_msg_len, int srv_msg_len,
int expected_cli_fragments,
int expected_srv_fragments )
{
test_app_data( mfl, cli_msg_len, srv_msg_len, expected_cli_fragments,
expected_srv_fragments, 0 );
/* The goto below is used to avoid an "unused label" warning.*/
goto exit;
exit:
;
}
void test_app_data_tls_wrapper( void ** params )
{
test_app_data_tls( *( (int *) params[0] ), *( (int *) params[1] ), *( (int *) params[2] ), *( (int *) params[3] ), *( (int *) params[4] ) );
}
#endif /* MBEDTLS_CTR_DRBG_C */
#endif /* MBEDTLS_ENTROPY_C */
#endif /* MBEDTLS_ECP_DP_SECP384R1_ENABLED */
#endif /* MBEDTLS_RSA_C */
#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
#endif /* MBEDTLS_PKCS1_V15 */
#endif /* !MBEDTLS_USE_PSA_CRYPTO */
#endif /* MBEDTLS_X509_CRT_PARSE_C */
#if defined(MBEDTLS_X509_CRT_PARSE_C)
#if !defined(MBEDTLS_USE_PSA_CRYPTO)
#if defined(MBEDTLS_PKCS1_V15)
#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
#if defined(MBEDTLS_RSA_C)
#if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
#if defined(MBEDTLS_SSL_PROTO_DTLS)
#if defined(MBEDTLS_ENTROPY_C)
#if defined(MBEDTLS_CTR_DRBG_C)
void test_app_data_dtls( int mfl, int cli_msg_len, int srv_msg_len,
int expected_cli_fragments,
int expected_srv_fragments )
{
test_app_data( mfl, cli_msg_len, srv_msg_len, expected_cli_fragments,
expected_srv_fragments, 1 );
/* The goto below is used to avoid an "unused label" warning.*/
goto exit;
exit:
;
}
void test_app_data_dtls_wrapper( void ** params )
{
test_app_data_dtls( *( (int *) params[0] ), *( (int *) params[1] ), *( (int *) params[2] ), *( (int *) params[3] ), *( (int *) params[4] ) );
}
#endif /* MBEDTLS_CTR_DRBG_C */
#endif /* MBEDTLS_ENTROPY_C */
#endif /* MBEDTLS_SSL_PROTO_DTLS */
#endif /* MBEDTLS_ECP_DP_SECP384R1_ENABLED */
#endif /* MBEDTLS_RSA_C */
#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
#endif /* MBEDTLS_PKCS1_V15 */
#endif /* !MBEDTLS_USE_PSA_CRYPTO */
#endif /* MBEDTLS_X509_CRT_PARSE_C */
#if defined(MBEDTLS_X509_CRT_PARSE_C)
#if !defined(MBEDTLS_USE_PSA_CRYPTO)
#if defined(MBEDTLS_PKCS1_V15)
#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
#if defined(MBEDTLS_RSA_C)
#if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
#if defined(MBEDTLS_SSL_PROTO_DTLS)
#if defined(MBEDTLS_SSL_RENEGOTIATION)
#if defined(MBEDTLS_SSL_CONTEXT_SERIALIZATION)
#if defined(MBEDTLS_ENTROPY_C)
#if defined(MBEDTLS_CTR_DRBG_C)
void test_handshake_serialization( )
{
handshake_test_options options;
init_handshake_options( &options );
options.serialize = 1;
options.dtls = 1;
perform_handshake( &options );
/* The goto below is used to avoid an "unused label" warning.*/
goto exit;
exit:
;
}
void test_handshake_serialization_wrapper( void ** params )
{
(void)params;
test_handshake_serialization( );
}
#endif /* MBEDTLS_CTR_DRBG_C */
#endif /* MBEDTLS_ENTROPY_C */
#endif /* MBEDTLS_SSL_CONTEXT_SERIALIZATION */
#endif /* MBEDTLS_SSL_RENEGOTIATION */
#endif /* MBEDTLS_SSL_PROTO_DTLS */
#endif /* MBEDTLS_ECP_DP_SECP384R1_ENABLED */
#endif /* MBEDTLS_RSA_C */
#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
#endif /* MBEDTLS_PKCS1_V15 */
#endif /* !MBEDTLS_USE_PSA_CRYPTO */
#endif /* MBEDTLS_X509_CRT_PARSE_C */
#if defined(MBEDTLS_X509_CRT_PARSE_C)
#if !defined(MBEDTLS_USE_PSA_CRYPTO)
#if defined(MBEDTLS_PKCS1_V15)
#if defined(MBEDTLS_RSA_C)
#if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
#if defined(MBEDTLS_DEBUG_C)
#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
#if defined(MBEDTLS_CIPHER_MODE_CBC)
#if defined(MBEDTLS_ENTROPY_C)
#if defined(MBEDTLS_CTR_DRBG_C)
void test_handshake_fragmentation( int mfl, int expected_srv_hs_fragmentation, int expected_cli_hs_fragmentation)
{
handshake_test_options options;
log_pattern srv_pattern, cli_pattern;
srv_pattern.pattern = cli_pattern.pattern = "found fragmented DTLS handshake";
srv_pattern.counter = 0;
cli_pattern.counter = 0;
init_handshake_options( &options );
options.dtls = 1;
options.mfl = mfl;
/* Set cipher to one using CBC so that record splitting can be tested */
options.cipher = "DHE-RSA-AES256-CBC-SHA256";
options.srv_auth_mode = MBEDTLS_SSL_VERIFY_REQUIRED;
options.srv_log_obj = &srv_pattern;
options.cli_log_obj = &cli_pattern;
options.srv_log_fun = log_analyzer;
options.cli_log_fun = log_analyzer;
perform_handshake( &options );
/* Test if the server received a fragmented handshake */
if( expected_srv_hs_fragmentation )
{
TEST_ASSERT( srv_pattern.counter >= 1 );
}
/* Test if the client received a fragmented handshake */
if( expected_cli_hs_fragmentation )
{
TEST_ASSERT( cli_pattern.counter >= 1 );
}
exit:
;
}
void test_handshake_fragmentation_wrapper( void ** params )
{
test_handshake_fragmentation( *( (int *) params[0] ), *( (int *) params[1] ), *( (int *) params[2] ) );
}
#endif /* MBEDTLS_CTR_DRBG_C */
#endif /* MBEDTLS_ENTROPY_C */
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */
#endif /* MBEDTLS_DEBUG_C */
#endif /* MBEDTLS_ECP_DP_SECP384R1_ENABLED */
#endif /* MBEDTLS_RSA_C */
#endif /* MBEDTLS_PKCS1_V15 */
#endif /* !MBEDTLS_USE_PSA_CRYPTO */
#endif /* MBEDTLS_X509_CRT_PARSE_C */
#if defined(MBEDTLS_X509_CRT_PARSE_C)
#if !defined(MBEDTLS_USE_PSA_CRYPTO)
#if defined(MBEDTLS_PKCS1_V15)
#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
#if defined(MBEDTLS_RSA_C)
#if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
#if defined(MBEDTLS_SSL_PROTO_DTLS)
#if defined(MBEDTLS_SSL_RENEGOTIATION)
#if defined(MBEDTLS_ENTROPY_C)
#if defined(MBEDTLS_CTR_DRBG_C)
void test_renegotiation( int legacy_renegotiation )
{
handshake_test_options options;
init_handshake_options( &options );
options.renegotiate = 1;
options.legacy_renegotiation = legacy_renegotiation;
options.dtls = 1;
perform_handshake( &options );
/* The goto below is used to avoid an "unused label" warning.*/
goto exit;
exit:
;
}
void test_renegotiation_wrapper( void ** params )
{
test_renegotiation( *( (int *) params[0] ) );
}
#endif /* MBEDTLS_CTR_DRBG_C */
#endif /* MBEDTLS_ENTROPY_C */
#endif /* MBEDTLS_SSL_RENEGOTIATION */
#endif /* MBEDTLS_SSL_PROTO_DTLS */
#endif /* MBEDTLS_ECP_DP_SECP384R1_ENABLED */
#endif /* MBEDTLS_RSA_C */
#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
#endif /* MBEDTLS_PKCS1_V15 */
#endif /* !MBEDTLS_USE_PSA_CRYPTO */
#endif /* MBEDTLS_X509_CRT_PARSE_C */
#if defined(MBEDTLS_X509_CRT_PARSE_C)
#if !defined(MBEDTLS_USE_PSA_CRYPTO)
#if defined(MBEDTLS_PKCS1_V15)
#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
#if defined(MBEDTLS_RSA_C)
#if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
#if defined(MBEDTLS_ENTROPY_C)
#if defined(MBEDTLS_CTR_DRBG_C)
void test_resize_buffers( int mfl, int renegotiation, int legacy_renegotiation,
int serialize, int dtls, char *cipher )
{
handshake_test_options options;
init_handshake_options( &options );
options.mfl = mfl;
options.cipher = cipher;
options.renegotiate = renegotiation;
options.legacy_renegotiation = legacy_renegotiation;
options.serialize = serialize;
options.dtls = dtls;
options.resize_buffers = 1;
perform_handshake( &options );
/* The goto below is used to avoid an "unused label" warning.*/
goto exit;
exit:
;
}
void test_resize_buffers_wrapper( void ** params )
{
test_resize_buffers( *( (int *) params[0] ), *( (int *) params[1] ), *( (int *) params[2] ), *( (int *) params[3] ), *( (int *) params[4] ), (char *) params[5] );
}
#endif /* MBEDTLS_CTR_DRBG_C */
#endif /* MBEDTLS_ENTROPY_C */
#endif /* MBEDTLS_ECP_DP_SECP384R1_ENABLED */
#endif /* MBEDTLS_RSA_C */
#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
#endif /* MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH */
#endif /* MBEDTLS_PKCS1_V15 */
#endif /* !MBEDTLS_USE_PSA_CRYPTO */
#endif /* MBEDTLS_X509_CRT_PARSE_C */
#if defined(MBEDTLS_X509_CRT_PARSE_C)
#if !defined(MBEDTLS_USE_PSA_CRYPTO)
#if defined(MBEDTLS_PKCS1_V15)
#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
#if defined(MBEDTLS_SSL_CONTEXT_SERIALIZATION)
#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
#if defined(MBEDTLS_RSA_C)
#if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
#if defined(MBEDTLS_SSL_PROTO_DTLS)
#if defined(MBEDTLS_ENTROPY_C)
#if defined(MBEDTLS_CTR_DRBG_C)
void test_resize_buffers_serialize_mfl( int mfl )
{
test_resize_buffers( mfl, 0, MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION, 1, 1,
(char *) "" );
/* The goto below is used to avoid an "unused label" warning.*/
goto exit;
exit:
;
}
void test_resize_buffers_serialize_mfl_wrapper( void ** params )
{
test_resize_buffers_serialize_mfl( *( (int *) params[0] ) );
}
#endif /* MBEDTLS_CTR_DRBG_C */
#endif /* MBEDTLS_ENTROPY_C */
#endif /* MBEDTLS_SSL_PROTO_DTLS */
#endif /* MBEDTLS_ECP_DP_SECP384R1_ENABLED */
#endif /* MBEDTLS_RSA_C */
#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
#endif /* MBEDTLS_SSL_CONTEXT_SERIALIZATION */
#endif /* MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH */
#endif /* MBEDTLS_PKCS1_V15 */
#endif /* !MBEDTLS_USE_PSA_CRYPTO */
#endif /* MBEDTLS_X509_CRT_PARSE_C */
#if defined(MBEDTLS_X509_CRT_PARSE_C)
#if !defined(MBEDTLS_USE_PSA_CRYPTO)
#if defined(MBEDTLS_PKCS1_V15)
#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
#if defined(MBEDTLS_SSL_RENEGOTIATION)
#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
#if defined(MBEDTLS_RSA_C)
#if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
#if defined(MBEDTLS_ENTROPY_C)
#if defined(MBEDTLS_CTR_DRBG_C)
void test_resize_buffers_renegotiate_mfl( int mfl, int legacy_renegotiation,
char *cipher )
{
test_resize_buffers( mfl, 1, legacy_renegotiation, 0, 1, cipher );
/* The goto below is used to avoid an "unused label" warning.*/
goto exit;
exit:
;
}
void test_resize_buffers_renegotiate_mfl_wrapper( void ** params )
{
test_resize_buffers_renegotiate_mfl( *( (int *) params[0] ), *( (int *) params[1] ), (char *) params[2] );
}
#endif /* MBEDTLS_CTR_DRBG_C */
#endif /* MBEDTLS_ENTROPY_C */
#endif /* MBEDTLS_ECP_DP_SECP384R1_ENABLED */
#endif /* MBEDTLS_RSA_C */
#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
#endif /* MBEDTLS_SSL_RENEGOTIATION */
#endif /* MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH */
#endif /* MBEDTLS_PKCS1_V15 */
#endif /* !MBEDTLS_USE_PSA_CRYPTO */
#endif /* MBEDTLS_X509_CRT_PARSE_C */
#if defined(MBEDTLS_SSL_SOME_SUITES_USE_TLS_CBC)
#if defined(MBEDTLS_TEST_HOOKS)
void test_ssl_cf_hmac( int hash )
{
/*
* Test the function mbedtls_ssl_cf_hmac() against a reference
* implementation.
*/
mbedtls_md_context_t ctx, ref_ctx;
const mbedtls_md_info_t *md_info;
size_t out_len, block_size;
size_t min_in_len, in_len, max_in_len, i;
/* TLS additional data is 13 bytes (hence the "lucky 13" name) */
unsigned char add_data[13];
unsigned char ref_out[MBEDTLS_MD_MAX_SIZE];
unsigned char *data = NULL;
unsigned char *out = NULL;
unsigned char rec_num = 0;
mbedtls_md_init( &ctx );
mbedtls_md_init( &ref_ctx );
md_info = mbedtls_md_info_from_type( hash );
TEST_ASSERT( md_info != NULL );
out_len = mbedtls_md_get_size( md_info );
TEST_ASSERT( out_len != 0 );
block_size = hash == MBEDTLS_MD_SHA384 ? 128 : 64;
/* Use allocated out buffer to catch overwrites */
ASSERT_ALLOC( out, out_len );
/* Set up contexts with the given hash and a dummy key */
TEST_EQUAL( 0, mbedtls_md_setup( &ctx, md_info, 1 ) );
TEST_EQUAL( 0, mbedtls_md_setup( &ref_ctx, md_info, 1 ) );
memset( ref_out, 42, sizeof( ref_out ) );
TEST_EQUAL( 0, mbedtls_md_hmac_starts( &ctx, ref_out, out_len ) );
TEST_EQUAL( 0, mbedtls_md_hmac_starts( &ref_ctx, ref_out, out_len ) );
memset( ref_out, 0, sizeof( ref_out ) );
/*
* Test all possible lengths up to a point. The difference between
* max_in_len and min_in_len is at most 255, and make sure they both vary
* by at least one block size.
*/
for( max_in_len = 0; max_in_len <= 255 + block_size; max_in_len++ )
{
mbedtls_test_set_step( max_in_len * 10000 );
/* Use allocated in buffer to catch overreads */
ASSERT_ALLOC( data, max_in_len );
min_in_len = max_in_len > 255 ? max_in_len - 255 : 0;
for( in_len = min_in_len; in_len <= max_in_len; in_len++ )
{
mbedtls_test_set_step( max_in_len * 10000 + in_len );
/* Set up dummy data and add_data */
rec_num++;
memset( add_data, rec_num, sizeof( add_data ) );
for( i = 0; i < in_len; i++ )
data[i] = ( i & 0xff ) ^ rec_num;
/* Get the function's result */
TEST_CF_SECRET( &in_len, sizeof( in_len ) );
TEST_EQUAL( 0, mbedtls_ssl_cf_hmac( &ctx, add_data, sizeof( add_data ),
data, in_len,
min_in_len, max_in_len,
out ) );
TEST_CF_PUBLIC( &in_len, sizeof( in_len ) );
TEST_CF_PUBLIC( out, out_len );
/* Compute the reference result */
TEST_EQUAL( 0, mbedtls_md_hmac_update( &ref_ctx, add_data,
sizeof( add_data ) ) );
TEST_EQUAL( 0, mbedtls_md_hmac_update( &ref_ctx, data, in_len ) );
TEST_EQUAL( 0, mbedtls_md_hmac_finish( &ref_ctx, ref_out ) );
TEST_EQUAL( 0, mbedtls_md_hmac_reset( &ref_ctx ) );
/* Compare */
ASSERT_COMPARE( out, out_len, ref_out, out_len );
}
mbedtls_free( data );
data = NULL;
}
exit:
mbedtls_md_free( &ref_ctx );
mbedtls_md_free( &ctx );
mbedtls_free( data );
mbedtls_free( out );
}
void test_ssl_cf_hmac_wrapper( void ** params )
{
test_ssl_cf_hmac( *( (int *) params[0] ) );
}
#endif /* MBEDTLS_TEST_HOOKS */
#endif /* MBEDTLS_SSL_SOME_SUITES_USE_TLS_CBC */
#if defined(MBEDTLS_SSL_SOME_SUITES_USE_TLS_CBC)
#if defined(MBEDTLS_TEST_HOOKS)
void test_ssl_cf_memcpy_offset( int offset_min, int offset_max, int len )
{
unsigned char *dst = NULL;
unsigned char *src = NULL;
size_t src_len = offset_max + len;
size_t secret;
ASSERT_ALLOC( dst, len );
ASSERT_ALLOC( src, src_len );
/* Fill src in a way that we can detect if we copied the right bytes */
mbedtls_test_rnd_std_rand( NULL, src, src_len );
for( secret = offset_min; secret <= (size_t) offset_max; secret++ )
{
mbedtls_test_set_step( (int) secret );
TEST_CF_SECRET( &secret, sizeof( secret ) );
mbedtls_ssl_cf_memcpy_offset( dst, src, secret,
offset_min, offset_max, len );
TEST_CF_PUBLIC( &secret, sizeof( secret ) );
TEST_CF_PUBLIC( dst, len );
ASSERT_COMPARE( dst, len, src + secret, len );
}
exit:
mbedtls_free( dst );
mbedtls_free( src );
}
void test_ssl_cf_memcpy_offset_wrapper( void ** params )
{
test_ssl_cf_memcpy_offset( *( (int *) params[0] ), *( (int *) params[1] ), *( (int *) params[2] ) );
}
#endif /* MBEDTLS_TEST_HOOKS */
#endif /* MBEDTLS_SSL_SOME_SUITES_USE_TLS_CBC */
#endif /* MBEDTLS_SSL_TLS_C */
/*----------------------------------------------------------------------------*/
/* Test dispatch code */
/**
* \brief Evaluates an expression/macro into its literal integer value.
* For optimizing space for embedded targets each expression/macro
* is identified by a unique identifier instead of string literals.
* Identifiers and evaluation code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param exp_id Expression identifier.
* \param out_value Pointer to int to hold the integer.
*
* \return 0 if exp_id is found. 1 otherwise.
*/
int get_expression( int32_t exp_id, int32_t * out_value )
{
int ret = KEY_VALUE_MAPPING_FOUND;
(void) exp_id;
(void) out_value;
switch( exp_id )
{
#if defined(MBEDTLS_SSL_TLS_C)
case 0:
{
*out_value = MBEDTLS_SSL_IS_CLIENT;
}
break;
case 1:
{
*out_value = MBEDTLS_SSL_IS_SERVER;
}
break;
case 2:
{
*out_value = MBEDTLS_SSL_HELLO_REQUEST;
}
break;
case 3:
{
*out_value = MBEDTLS_SSL_CLIENT_HELLO;
}
break;
case 4:
{
*out_value = MBEDTLS_SSL_SERVER_HELLO;
}
break;
case 5:
{
*out_value = MBEDTLS_SSL_SERVER_CERTIFICATE;
}
break;
case 6:
{
*out_value = MBEDTLS_SSL_SERVER_KEY_EXCHANGE;
}
break;
case 7:
{
*out_value = MBEDTLS_SSL_CERTIFICATE_REQUEST;
}
break;
case 8:
{
*out_value = MBEDTLS_SSL_SERVER_HELLO_DONE;
}
break;
case 9:
{
*out_value = MBEDTLS_SSL_CLIENT_CERTIFICATE;
}
break;
case 10:
{
*out_value = MBEDTLS_SSL_CLIENT_KEY_EXCHANGE;
}
break;
case 11:
{
*out_value = MBEDTLS_SSL_CERTIFICATE_VERIFY;
}
break;
case 12:
{
*out_value = MBEDTLS_SSL_CLIENT_CHANGE_CIPHER_SPEC;
}
break;
case 13:
{
*out_value = MBEDTLS_SSL_CLIENT_FINISHED;
}
break;
case 14:
{
*out_value = MBEDTLS_SSL_SERVER_CHANGE_CIPHER_SPEC;
}
break;
case 15:
{
*out_value = MBEDTLS_SSL_SERVER_FINISHED;
}
break;
case 16:
{
*out_value = MBEDTLS_SSL_FLUSH_BUFFERS;
}
break;
case 17:
{
*out_value = MBEDTLS_SSL_HANDSHAKE_WRAPUP;
}
break;
case 18:
{
*out_value = MBEDTLS_SSL_HANDSHAKE_OVER;
}
break;
case 19:
{
*out_value = MBEDTLS_SSL_SERVER_HELLO_VERIFY_REQUEST_SENT;
}
break;
case 20:
{
*out_value = MBEDTLS_SSL_SERVER_NEW_SESSION_TICKET;
}
break;
case 21:
{
*out_value = MBEDTLS_SSL_MINOR_VERSION_0;
}
break;
case 22:
{
*out_value = MBEDTLS_SSL_MINOR_VERSION_1;
}
break;
case 23:
{
*out_value = MBEDTLS_SSL_MINOR_VERSION_2;
}
break;
case 24:
{
*out_value = MBEDTLS_SSL_MINOR_VERSION_3;
}
break;
case 25:
{
*out_value = MBEDTLS_PK_RSA;
}
break;
case 26:
{
*out_value = MBEDTLS_PK_ECDSA;
}
break;
case 27:
{
*out_value = MBEDTLS_SSL_MAX_FRAG_LEN_512;
}
break;
case 28:
{
*out_value = MBEDTLS_SSL_MAX_FRAG_LEN_1024;
}
break;
case 29:
{
*out_value = TEST_SSL_MINOR_VERSION_NONE;
}
break;
case 30:
{
*out_value = MBEDTLS_SSL_MAX_FRAG_LEN_2048;
}
break;
case 31:
{
*out_value = MBEDTLS_SSL_MAX_FRAG_LEN_4096;
}
break;
case 32:
{
*out_value = MBEDTLS_SSL_MAX_FRAG_LEN_NONE;
}
break;
case 33:
{
*out_value = MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION;
}
break;
case 34:
{
*out_value = MBEDTLS_SSL_LEGACY_ALLOW_RENEGOTIATION;
}
break;
case 35:
{
*out_value = MBEDTLS_SSL_LEGACY_BREAK_HANDSHAKE;
}
break;
case 36:
{
*out_value = -1;
}
break;
case 37:
{
*out_value = MBEDTLS_CIPHER_AES_128_CBC;
}
break;
case 38:
{
*out_value = MBEDTLS_MD_SHA384;
}
break;
case 39:
{
*out_value = MBEDTLS_MD_SHA256;
}
break;
case 40:
{
*out_value = MBEDTLS_MD_SHA1;
}
break;
case 41:
{
*out_value = MBEDTLS_MD_MD5;
}
break;
case 42:
{
*out_value = MBEDTLS_CIPHER_AES_192_CBC;
}
break;
case 43:
{
*out_value = MBEDTLS_CIPHER_AES_256_CBC;
}
break;
case 44:
{
*out_value = MBEDTLS_CIPHER_ARIA_128_CBC;
}
break;
case 45:
{
*out_value = MBEDTLS_CIPHER_ARIA_192_CBC;
}
break;
case 46:
{
*out_value = MBEDTLS_CIPHER_ARIA_256_CBC;
}
break;
case 47:
{
*out_value = MBEDTLS_CIPHER_CAMELLIA_128_CBC;
}
break;
case 48:
{
*out_value = MBEDTLS_CIPHER_CAMELLIA_192_CBC;
}
break;
case 49:
{
*out_value = MBEDTLS_CIPHER_CAMELLIA_256_CBC;
}
break;
case 50:
{
*out_value = MBEDTLS_CIPHER_BLOWFISH_CBC;
}
break;
case 51:
{
*out_value = MBEDTLS_CIPHER_AES_128_GCM;
}
break;
case 52:
{
*out_value = MBEDTLS_SSL_MINOR_VERSION_4;
}
break;
case 53:
{
*out_value = MBEDTLS_CIPHER_AES_192_GCM;
}
break;
case 54:
{
*out_value = MBEDTLS_CIPHER_AES_256_GCM;
}
break;
case 55:
{
*out_value = MBEDTLS_CIPHER_CAMELLIA_128_GCM;
}
break;
case 56:
{
*out_value = MBEDTLS_CIPHER_CAMELLIA_192_GCM;
}
break;
case 57:
{
*out_value = MBEDTLS_CIPHER_CAMELLIA_256_GCM;
}
break;
case 58:
{
*out_value = MBEDTLS_CIPHER_AES_128_CCM;
}
break;
case 59:
{
*out_value = MBEDTLS_CIPHER_AES_192_CCM;
}
break;
case 60:
{
*out_value = MBEDTLS_CIPHER_AES_256_CCM;
}
break;
case 61:
{
*out_value = MBEDTLS_CIPHER_CAMELLIA_128_CCM;
}
break;
case 62:
{
*out_value = MBEDTLS_CIPHER_CAMELLIA_192_CCM;
}
break;
case 63:
{
*out_value = MBEDTLS_CIPHER_CAMELLIA_256_CCM;
}
break;
case 64:
{
*out_value = MBEDTLS_CIPHER_ARC4_128;
}
break;
case 65:
{
*out_value = MBEDTLS_CIPHER_NULL;
}
break;
case 66:
{
*out_value = MBEDTLS_CIPHER_CHACHA20_POLY1305;
}
break;
case 67:
{
*out_value = -2;
}
break;
case 68:
{
*out_value = MBEDTLS_CIPHER_DES_EDE3_CBC;
}
break;
case 69:
{
*out_value = tls1_3_label_key;
}
break;
case 70:
{
*out_value = tls1_3_label_iv;
}
break;
case 71:
{
*out_value = tls1_3_label_finished;
}
break;
case 72:
{
*out_value = tls1_3_label_resumption;
}
break;
case 73:
{
*out_value = tls1_3_label_derived;
}
break;
case 74:
{
*out_value = MBEDTLS_SSL_TLS1_3_CONTEXT_UNHASHED;
}
break;
case 75:
{
*out_value = tls1_3_label_s_ap_traffic;
}
break;
case 76:
{
*out_value = MBEDTLS_SSL_TLS1_3_CONTEXT_HASHED;
}
break;
case 77:
{
*out_value = tls1_3_label_c_e_traffic;
}
break;
case 78:
{
*out_value = tls1_3_label_e_exp_master;
}
break;
case 79:
{
*out_value = tls1_3_label_c_hs_traffic;
}
break;
case 80:
{
*out_value = tls1_3_label_s_hs_traffic;
}
break;
case 81:
{
*out_value = tls1_3_label_c_ap_traffic;
}
break;
case 82:
{
*out_value = tls1_3_label_exp_master;
}
break;
case 83:
{
*out_value = tls1_3_label_res_master;
}
break;
case 84:
{
*out_value = MBEDTLS_SSL_TLS_PRF_NONE;
}
break;
case 85:
{
*out_value = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
}
break;
case 86:
{
*out_value = MBEDTLS_SSL_TLS_PRF_SSL3;
}
break;
case 87:
{
*out_value = MBEDTLS_SSL_TLS_PRF_TLS1;
}
break;
case 88:
{
*out_value = MBEDTLS_SSL_TLS_PRF_SHA384;
}
break;
case 89:
{
*out_value = MBEDTLS_SSL_TLS_PRF_SHA256;
}
break;
#endif
default:
{
ret = KEY_VALUE_MAPPING_NOT_FOUND;
}
break;
}
return( ret );
}
/**
* \brief Checks if the dependency i.e. the compile flag is set.
* For optimizing space for embedded targets each dependency
* is identified by a unique identifier instead of string literals.
* Identifiers and check code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param dep_id Dependency identifier.
*
* \return DEPENDENCY_SUPPORTED if set else DEPENDENCY_NOT_SUPPORTED
*/
int dep_check( int dep_id )
{
int ret = DEPENDENCY_NOT_SUPPORTED;
(void) dep_id;
switch( dep_id )
{
#if defined(MBEDTLS_SSL_TLS_C)
case 0:
{
#if defined(MBEDTLS_SSL_PROTO_SSL3)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 1:
{
#if defined(MBEDTLS_RSA_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 2:
{
#if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 3:
{
#if defined(MBEDTLS_SSL_PROTO_TLS1)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 4:
{
#if defined(MBEDTLS_CIPHER_MODE_CBC)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 5:
{
#if defined(MBEDTLS_SSL_PROTO_TLS1_1)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 6:
{
#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 7:
{
#if defined(MBEDTLS_SHA512_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 8:
{
#if !defined(MBEDTLS_SHA512_NO_SHA384)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 9:
{
#if defined(MBEDTLS_AES_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 10:
{
#if defined(MBEDTLS_GCM_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 11:
{
#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 12:
{
#if defined(MBEDTLS_CCM_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 13:
{
#if defined(MBEDTLS_SHA256_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 14:
{
#if defined(MBEDTLS_ECDSA_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 15:
{
#if defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 16:
{
#if defined(MBEDTLS_CAMELLIA_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 17:
{
#if defined(MBEDTLS_SSL_PROTO_DTLS)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 18:
{
#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 19:
{
#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 20:
{
#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 21:
{
#if defined(MBEDTLS_SHA1_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 22:
{
#if defined(MBEDTLS_MD5_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 23:
{
#if defined(MBEDTLS_ARIA_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 24:
{
#if defined(MBEDTLS_BLOWFISH_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 25:
{
#if defined(MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 26:
{
#if defined(MBEDTLS_ARC4_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 27:
{
#if defined(MBEDTLS_CIPHER_NULL_CIPHER)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 28:
{
#if defined(MBEDTLS_CHACHAPOLY_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 29:
{
#if defined(MBEDTLS_DES_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 30:
{
#if !defined(MBEDTLS_SSL_PROTO_SSL3)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 31:
{
#if !defined(MBEDTLS_SSL_PROTO_TLS1)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 32:
{
#if !defined(MBEDTLS_SSL_PROTO_TLS1_1)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 33:
{
#if !defined(MBEDTLS_SHA512_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 34:
{
#if !defined(MBEDTLS_SHA256_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 35:
{
#if defined(MBEDTLS_SSL_SESSION_TICKETS)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 36:
{
#if defined(MBEDTLS_SSL_CLI_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 37:
{
#if defined(MBEDTLS_X509_USE_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 38:
{
#if defined(MBEDTLS_PEM_PARSE_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 39:
{
#if defined(MBEDTLS_FS_IO)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 40:
{
#if defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 41:
{
#if defined(MBEDTLS_KEY_EXCHANGE_PSK_ENABLED)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
#endif
default:
break;
}
return( ret );
}
/**
* \brief Function pointer type for test function wrappers.
*
* A test function wrapper decodes the parameters and passes them to the
* underlying test function. Both the wrapper and the underlying function
* return void. Test wrappers assume that they are passed a suitable
* parameter array and do not perform any error detection.
*
* \param param_array The array of parameters. Each element is a `void *`
* which the wrapper casts to the correct type and
* dereferences. Each wrapper function hard-codes the
* number and types of the parameters.
*/
typedef void (*TestWrapper_t)( void **param_array );
/**
* \brief Table of test function wrappers. Used by dispatch_test().
* This table is populated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
*/
TestWrapper_t test_funcs[] =
{
/* Function Id: 0 */
#if defined(MBEDTLS_SSL_TLS_C)
test_test_callback_buffer_sanity_wrapper,
#else
NULL,
#endif
/* Function Id: 1 */
#if defined(MBEDTLS_SSL_TLS_C)
test_test_callback_buffer_wrapper,
#else
NULL,
#endif
/* Function Id: 2 */
#if defined(MBEDTLS_SSL_TLS_C)
test_ssl_mock_sanity_wrapper,
#else
NULL,
#endif
/* Function Id: 3 */
#if defined(MBEDTLS_SSL_TLS_C)
test_ssl_mock_tcp_wrapper,
#else
NULL,
#endif
/* Function Id: 4 */
#if defined(MBEDTLS_SSL_TLS_C)
test_ssl_mock_tcp_interleaving_wrapper,
#else
NULL,
#endif
/* Function Id: 5 */
#if defined(MBEDTLS_SSL_TLS_C)
test_ssl_message_queue_sanity_wrapper,
#else
NULL,
#endif
/* Function Id: 6 */
#if defined(MBEDTLS_SSL_TLS_C)
test_ssl_message_queue_basic_wrapper,
#else
NULL,
#endif
/* Function Id: 7 */
#if defined(MBEDTLS_SSL_TLS_C)
test_ssl_message_queue_overflow_underflow_wrapper,
#else
NULL,
#endif
/* Function Id: 8 */
#if defined(MBEDTLS_SSL_TLS_C)
test_ssl_message_queue_interleaved_wrapper,
#else
NULL,
#endif
/* Function Id: 9 */
#if defined(MBEDTLS_SSL_TLS_C)
test_ssl_message_queue_insufficient_buffer_wrapper,
#else
NULL,
#endif
/* Function Id: 10 */
#if defined(MBEDTLS_SSL_TLS_C)
test_ssl_message_mock_uninitialized_wrapper,
#else
NULL,
#endif
/* Function Id: 11 */
#if defined(MBEDTLS_SSL_TLS_C)
test_ssl_message_mock_basic_wrapper,
#else
NULL,
#endif
/* Function Id: 12 */
#if defined(MBEDTLS_SSL_TLS_C)
test_ssl_message_mock_queue_overflow_underflow_wrapper,
#else
NULL,
#endif
/* Function Id: 13 */
#if defined(MBEDTLS_SSL_TLS_C)
test_ssl_message_mock_socket_overflow_wrapper,
#else
NULL,
#endif
/* Function Id: 14 */
#if defined(MBEDTLS_SSL_TLS_C)
test_ssl_message_mock_truncated_wrapper,
#else
NULL,
#endif
/* Function Id: 15 */
#if defined(MBEDTLS_SSL_TLS_C)
test_ssl_message_mock_socket_read_error_wrapper,
#else
NULL,
#endif
/* Function Id: 16 */
#if defined(MBEDTLS_SSL_TLS_C)
test_ssl_message_mock_interleaved_one_way_wrapper,
#else
NULL,
#endif
/* Function Id: 17 */
#if defined(MBEDTLS_SSL_TLS_C)
test_ssl_message_mock_interleaved_two_ways_wrapper,
#else
NULL,
#endif
/* Function Id: 18 */
#if defined(MBEDTLS_SSL_TLS_C) && defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY)
test_ssl_dtls_replay_wrapper,
#else
NULL,
#endif
/* Function Id: 19 */
#if defined(MBEDTLS_SSL_TLS_C) && defined(MBEDTLS_X509_CRT_PARSE_C)
test_ssl_set_hostname_twice_wrapper,
#else
NULL,
#endif
/* Function Id: 20 */
#if defined(MBEDTLS_SSL_TLS_C)
test_ssl_crypt_record_wrapper,
#else
NULL,
#endif
/* Function Id: 21 */
#if defined(MBEDTLS_SSL_TLS_C)
test_ssl_crypt_record_small_wrapper,
#else
NULL,
#endif
/* Function Id: 22 */
#if defined(MBEDTLS_SSL_TLS_C) && defined(MBEDTLS_CIPHER_MODE_CBC) && defined(MBEDTLS_AES_C) && defined(MBEDTLS_SSL_PROTO_TLS1_2)
test_ssl_decrypt_non_etm_cbc_wrapper,
#else
NULL,
#endif
/* Function Id: 23 */
#if defined(MBEDTLS_SSL_TLS_C) && defined(MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL)
test_ssl_tls1_3_hkdf_expand_label_wrapper,
#else
NULL,
#endif
/* Function Id: 24 */
#if defined(MBEDTLS_SSL_TLS_C) && defined(MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL)
test_ssl_tls1_3_traffic_key_generation_wrapper,
#else
NULL,
#endif
/* Function Id: 25 */
#if defined(MBEDTLS_SSL_TLS_C) && defined(MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL)
test_ssl_tls1_3_derive_secret_wrapper,
#else
NULL,
#endif
/* Function Id: 26 */
#if defined(MBEDTLS_SSL_TLS_C) && defined(MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL)
test_ssl_tls1_3_key_evolution_wrapper,
#else
NULL,
#endif
/* Function Id: 27 */
#if defined(MBEDTLS_SSL_TLS_C)
test_ssl_tls_prf_wrapper,
#else
NULL,
#endif
/* Function Id: 28 */
#if defined(MBEDTLS_SSL_TLS_C)
test_ssl_serialize_session_save_load_wrapper,
#else
NULL,
#endif
/* Function Id: 29 */
#if defined(MBEDTLS_SSL_TLS_C)
test_ssl_serialize_session_load_save_wrapper,
#else
NULL,
#endif
/* Function Id: 30 */
#if defined(MBEDTLS_SSL_TLS_C)
test_ssl_serialize_session_save_buf_size_wrapper,
#else
NULL,
#endif
/* Function Id: 31 */
#if defined(MBEDTLS_SSL_TLS_C)
test_ssl_serialize_session_load_buf_size_wrapper,
#else
NULL,
#endif
/* Function Id: 32 */
#if defined(MBEDTLS_SSL_TLS_C)
test_ssl_session_serialize_version_check_wrapper,
#else
NULL,
#endif
/* Function Id: 33 */
#if defined(MBEDTLS_SSL_TLS_C) && defined(MBEDTLS_X509_CRT_PARSE_C) && defined(MBEDTLS_RSA_C) && defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED) && !defined(MBEDTLS_USE_PSA_CRYPTO) && defined(MBEDTLS_PKCS1_V15) && defined(MBEDTLS_ENTROPY_C) && defined(MBEDTLS_ENTROPY_C) && defined(MBEDTLS_CTR_DRBG_C)
test_mbedtls_endpoint_sanity_wrapper,
#else
NULL,
#endif
/* Function Id: 34 */
#if defined(MBEDTLS_SSL_TLS_C) && defined(MBEDTLS_X509_CRT_PARSE_C) && defined(MBEDTLS_RSA_C) && defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED) && !defined(MBEDTLS_USE_PSA_CRYPTO) && defined(MBEDTLS_PKCS1_V15) && defined(MBEDTLS_ENTROPY_C) && defined(MBEDTLS_ENTROPY_C) && defined(MBEDTLS_CTR_DRBG_C)
test_move_handshake_to_state_wrapper,
#else
NULL,
#endif
/* Function Id: 35 */
#if defined(MBEDTLS_SSL_TLS_C) && defined(MBEDTLS_X509_CRT_PARSE_C) && !defined(MBEDTLS_USE_PSA_CRYPTO) && defined(MBEDTLS_PKCS1_V15) && defined(MBEDTLS_RSA_C) && defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED) && defined(MBEDTLS_ENTROPY_C) && defined(MBEDTLS_CTR_DRBG_C)
test_handshake_version_wrapper,
#else
NULL,
#endif
/* Function Id: 36 */
#if defined(MBEDTLS_SSL_TLS_C) && defined(MBEDTLS_X509_CRT_PARSE_C) && !defined(MBEDTLS_USE_PSA_CRYPTO) && defined(MBEDTLS_PKCS1_V15) && defined(MBEDTLS_SSL_PROTO_TLS1_2) && defined(MBEDTLS_ENTROPY_C) && defined(MBEDTLS_CTR_DRBG_C)
test_handshake_psk_cipher_wrapper,
#else
NULL,
#endif
/* Function Id: 37 */
#if defined(MBEDTLS_SSL_TLS_C) && defined(MBEDTLS_X509_CRT_PARSE_C) && !defined(MBEDTLS_USE_PSA_CRYPTO) && defined(MBEDTLS_PKCS1_V15) && defined(MBEDTLS_SSL_PROTO_TLS1_2) && defined(MBEDTLS_ENTROPY_C) && defined(MBEDTLS_CTR_DRBG_C)
test_handshake_cipher_wrapper,
#else
NULL,
#endif
/* Function Id: 38 */
#if defined(MBEDTLS_SSL_TLS_C) && defined(MBEDTLS_X509_CRT_PARSE_C) && !defined(MBEDTLS_USE_PSA_CRYPTO) && defined(MBEDTLS_PKCS1_V15) && defined(MBEDTLS_SSL_PROTO_TLS1_2) && defined(MBEDTLS_RSA_C) && defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED) && defined(MBEDTLS_ENTROPY_C) && defined(MBEDTLS_CTR_DRBG_C)
test_app_data_wrapper,
#else
NULL,
#endif
/* Function Id: 39 */
#if defined(MBEDTLS_SSL_TLS_C) && defined(MBEDTLS_X509_CRT_PARSE_C) && !defined(MBEDTLS_USE_PSA_CRYPTO) && defined(MBEDTLS_PKCS1_V15) && defined(MBEDTLS_SSL_PROTO_TLS1_2) && defined(MBEDTLS_RSA_C) && defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED) && defined(MBEDTLS_ENTROPY_C) && defined(MBEDTLS_CTR_DRBG_C)
test_app_data_tls_wrapper,
#else
NULL,
#endif
/* Function Id: 40 */
#if defined(MBEDTLS_SSL_TLS_C) && defined(MBEDTLS_X509_CRT_PARSE_C) && !defined(MBEDTLS_USE_PSA_CRYPTO) && defined(MBEDTLS_PKCS1_V15) && defined(MBEDTLS_SSL_PROTO_TLS1_2) && defined(MBEDTLS_RSA_C) && defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED) && defined(MBEDTLS_SSL_PROTO_DTLS) && defined(MBEDTLS_ENTROPY_C) && defined(MBEDTLS_CTR_DRBG_C)
test_app_data_dtls_wrapper,
#else
NULL,
#endif
/* Function Id: 41 */
#if defined(MBEDTLS_SSL_TLS_C) && defined(MBEDTLS_X509_CRT_PARSE_C) && !defined(MBEDTLS_USE_PSA_CRYPTO) && defined(MBEDTLS_PKCS1_V15) && defined(MBEDTLS_SSL_PROTO_TLS1_2) && defined(MBEDTLS_RSA_C) && defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED) && defined(MBEDTLS_SSL_PROTO_DTLS) && defined(MBEDTLS_SSL_RENEGOTIATION) && defined(MBEDTLS_SSL_CONTEXT_SERIALIZATION) && defined(MBEDTLS_ENTROPY_C) && defined(MBEDTLS_CTR_DRBG_C)
test_handshake_serialization_wrapper,
#else
NULL,
#endif
/* Function Id: 42 */
#if defined(MBEDTLS_SSL_TLS_C) && defined(MBEDTLS_X509_CRT_PARSE_C) && !defined(MBEDTLS_USE_PSA_CRYPTO) && defined(MBEDTLS_PKCS1_V15) && defined(MBEDTLS_RSA_C) && defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED) && defined(MBEDTLS_DEBUG_C) && defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH) && defined(MBEDTLS_CIPHER_MODE_CBC) && defined(MBEDTLS_ENTROPY_C) && defined(MBEDTLS_CTR_DRBG_C)
test_handshake_fragmentation_wrapper,
#else
NULL,
#endif
/* Function Id: 43 */
#if defined(MBEDTLS_SSL_TLS_C) && defined(MBEDTLS_X509_CRT_PARSE_C) && !defined(MBEDTLS_USE_PSA_CRYPTO) && defined(MBEDTLS_PKCS1_V15) && defined(MBEDTLS_SSL_PROTO_TLS1_2) && defined(MBEDTLS_RSA_C) && defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED) && defined(MBEDTLS_SSL_PROTO_DTLS) && defined(MBEDTLS_SSL_RENEGOTIATION) && defined(MBEDTLS_ENTROPY_C) && defined(MBEDTLS_CTR_DRBG_C)
test_renegotiation_wrapper,
#else
NULL,
#endif
/* Function Id: 44 */
#if defined(MBEDTLS_SSL_TLS_C) && defined(MBEDTLS_X509_CRT_PARSE_C) && !defined(MBEDTLS_USE_PSA_CRYPTO) && defined(MBEDTLS_PKCS1_V15) && defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH) && defined(MBEDTLS_SSL_PROTO_TLS1_2) && defined(MBEDTLS_RSA_C) && defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED) && defined(MBEDTLS_ENTROPY_C) && defined(MBEDTLS_CTR_DRBG_C)
test_resize_buffers_wrapper,
#else
NULL,
#endif
/* Function Id: 45 */
#if defined(MBEDTLS_SSL_TLS_C) && defined(MBEDTLS_X509_CRT_PARSE_C) && !defined(MBEDTLS_USE_PSA_CRYPTO) && defined(MBEDTLS_PKCS1_V15) && defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH) && defined(MBEDTLS_SSL_CONTEXT_SERIALIZATION) && defined(MBEDTLS_SSL_PROTO_TLS1_2) && defined(MBEDTLS_RSA_C) && defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED) && defined(MBEDTLS_SSL_PROTO_DTLS) && defined(MBEDTLS_ENTROPY_C) && defined(MBEDTLS_CTR_DRBG_C)
test_resize_buffers_serialize_mfl_wrapper,
#else
NULL,
#endif
/* Function Id: 46 */
#if defined(MBEDTLS_SSL_TLS_C) && defined(MBEDTLS_X509_CRT_PARSE_C) && !defined(MBEDTLS_USE_PSA_CRYPTO) && defined(MBEDTLS_PKCS1_V15) && defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH) && defined(MBEDTLS_SSL_RENEGOTIATION) && defined(MBEDTLS_SSL_PROTO_TLS1_2) && defined(MBEDTLS_RSA_C) && defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED) && defined(MBEDTLS_ENTROPY_C) && defined(MBEDTLS_CTR_DRBG_C)
test_resize_buffers_renegotiate_mfl_wrapper,
#else
NULL,
#endif
/* Function Id: 47 */
#if defined(MBEDTLS_SSL_TLS_C) && defined(MBEDTLS_SSL_SOME_SUITES_USE_TLS_CBC) && defined(MBEDTLS_TEST_HOOKS)
test_ssl_cf_hmac_wrapper,
#else
NULL,
#endif
/* Function Id: 48 */
#if defined(MBEDTLS_SSL_TLS_C) && defined(MBEDTLS_SSL_SOME_SUITES_USE_TLS_CBC) && defined(MBEDTLS_TEST_HOOKS)
test_ssl_cf_memcpy_offset_wrapper,
#else
NULL,
#endif
};
/**
* \brief Execute the test function.
*
* This is a wrapper function around the test function execution
* to allow the setjmp() call used to catch any calls to the
* parameter failure callback, to be used. Calls to setjmp()
* can invalidate the state of any local auto variables.
*
* \param fp Function pointer to the test function.
* \param params Parameters to pass to the #TestWrapper_t wrapper function.
*
*/
void execute_function_ptr(TestWrapper_t fp, void **params)
{
#if defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG)
mbedtls_test_enable_insecure_external_rng( );
#endif
#if defined(MBEDTLS_CHECK_PARAMS)
mbedtls_test_param_failed_location_record_t location_record;
if ( setjmp( mbedtls_test_param_failed_get_state_buf( ) ) == 0 )
{
fp( params );
}
else
{
/* Unexpected parameter validation error */
mbedtls_test_param_failed_get_location_record( &location_record );
mbedtls_test_fail( location_record.failure_condition,
location_record.line,
location_record.file );
}
mbedtls_test_param_failed_reset_state( );
#else
fp( params );
#endif
#if defined(MBEDTLS_TEST_MUTEX_USAGE)
mbedtls_test_mutex_usage_check( );
#endif /* MBEDTLS_TEST_MUTEX_USAGE */
}
/**
* \brief Dispatches test functions based on function index.
*
* \param func_idx Test function index.
* \param params The array of parameters to pass to the test function.
* It will be decoded by the #TestWrapper_t wrapper function.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int dispatch_test( size_t func_idx, void ** params )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof( test_funcs ) / sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp )
execute_function_ptr(fp, params);
else
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
/**
* \brief Checks if test function is supported in this build-time
* configuration.
*
* \param func_idx Test function index.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int check_test( size_t func_idx )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof(test_funcs)/sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp == NULL )
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
int main( int argc, const char *argv[] )
{
int ret;
mbedtls_test_platform_setup();
ret = execute_tests( argc, argv, "/zip/third_party/mbedtls/test/test_suite_ssl.datax" );
mbedtls_test_platform_teardown();
return( ret );
}
| 211,137 | 6,430 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_hkdf.c | /* clang-format off */
/*
* Copyright The Mbed TLS Contributors
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "third_party/mbedtls/test/test.inc"
/*
* *** THIS FILE WAS MACHINE GENERATED ***
*
* This file has been machine generated using the script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* Test file : ./test_suite_hkdf.c
*
* The following files were used to create this file.
*
* Main code file : suites/main_test.function
* Platform code file : suites/host_test.function
* Helper file : suites/helpers.function
* Test suite file : suites/test_suite_hkdf.function
* Test suite data : suites/test_suite_hkdf.data
*
*/
#define TEST_SUITE_ACTIVE
#if defined(MBEDTLS_HKDF_C)
#include "third_party/mbedtls/hkdf.h"
void test_test_hkdf( int md_alg, data_t *ikm, data_t *salt, data_t *info,
data_t *expected_okm )
{
int ret;
unsigned char okm[128] = { '\0' };
const mbedtls_md_info_t *md = mbedtls_md_info_from_type( md_alg );
TEST_ASSERT( md != NULL );
TEST_ASSERT( expected_okm->len <= sizeof( okm ) );
ret = mbedtls_hkdf( md, salt->x, salt->len, ikm->x, ikm->len,
info->x, info->len, okm, expected_okm->len );
TEST_ASSERT( ret == 0 );
ASSERT_COMPARE( okm , expected_okm->len,
expected_okm->x, expected_okm->len );
}
void test_test_hkdf_wrapper( void ** params )
{
data_t data1 = {(uint8_t *) params[1], *( (uint32_t *) params[2] )};
data_t data3 = {(uint8_t *) params[3], *( (uint32_t *) params[4] )};
data_t data5 = {(uint8_t *) params[5], *( (uint32_t *) params[6] )};
data_t data7 = {(uint8_t *) params[7], *( (uint32_t *) params[8] )};
test_test_hkdf( *( (int *) params[0] ), &data1, &data3, &data5, &data7 );
}
void test_test_hkdf_extract( int md_alg, char *hex_ikm_string,
char *hex_salt_string, char *hex_prk_string )
{
int ret;
unsigned char *ikm = NULL;
unsigned char *salt = NULL;
unsigned char *prk = NULL;
unsigned char *output_prk = NULL;
size_t ikm_len, salt_len, prk_len, output_prk_len;
const mbedtls_md_info_t *md = mbedtls_md_info_from_type( md_alg );
TEST_ASSERT( md != NULL );
output_prk_len = mbedtls_md_get_size( md );
output_prk = mbedtls_calloc( 1, output_prk_len );
ikm = mbedtls_test_unhexify_alloc( hex_ikm_string, &ikm_len );
salt = mbedtls_test_unhexify_alloc( hex_salt_string, &salt_len );
prk = mbedtls_test_unhexify_alloc( hex_prk_string, &prk_len );
ret = mbedtls_hkdf_extract( md, salt, salt_len, ikm, ikm_len, output_prk );
TEST_ASSERT( ret == 0 );
ASSERT_COMPARE( output_prk, output_prk_len, prk, prk_len );
exit:
mbedtls_free(ikm);
mbedtls_free(salt);
mbedtls_free(prk);
mbedtls_free(output_prk);
}
void test_test_hkdf_extract_wrapper( void ** params )
{
test_test_hkdf_extract( *( (int *) params[0] ),
(char *) params[1],
(char *) params[2],
(char *) params[3] );
}
void test_test_hkdf_expand( int md_alg, char *hex_info_string,
char *hex_prk_string, char *hex_okm_string )
{
enum { OKM_LEN = 1024 };
int ret;
unsigned char *info = NULL;
unsigned char *prk = NULL;
unsigned char *okm = NULL;
unsigned char *output_okm = NULL;
size_t info_len, prk_len, okm_len;
const mbedtls_md_info_t *md = mbedtls_md_info_from_type( md_alg );
TEST_ASSERT( md != NULL );
output_okm = mbedtls_calloc( OKM_LEN, 1 );
prk = mbedtls_test_unhexify_alloc( hex_prk_string, &prk_len );
info = mbedtls_test_unhexify_alloc( hex_info_string, &info_len );
okm = mbedtls_test_unhexify_alloc( hex_okm_string, &okm_len );
TEST_ASSERT( prk_len == mbedtls_md_get_size( md ) );
TEST_ASSERT( okm_len < OKM_LEN );
ret = mbedtls_hkdf_expand( md, prk, prk_len, info, info_len,
output_okm, OKM_LEN );
TEST_ASSERT( ret == 0 );
ASSERT_COMPARE( output_okm, okm_len, okm, okm_len );
exit:
mbedtls_free(info);
mbedtls_free(prk);
mbedtls_free(okm);
mbedtls_free(output_okm);
}
void test_test_hkdf_expand_wrapper( void ** params )
{
test_test_hkdf_expand( *( (int *) params[0] ),
(char *) params[1],
(char *) params[2],
(char *) params[3] );
}
void test_test_hkdf_extract_ret( int hash_len, int ret )
{
int output_ret;
unsigned char *salt = NULL;
unsigned char *ikm = NULL;
unsigned char *prk = NULL;
size_t salt_len, ikm_len;
struct mbedtls_md_info_t fake_md_info;
memset( &fake_md_info, 0, sizeof( fake_md_info ) );
fake_md_info.type = MBEDTLS_MD_NONE;
fake_md_info.size = hash_len;
prk = mbedtls_calloc( MBEDTLS_MD_MAX_SIZE, 1 );
salt_len = 0;
ikm_len = 0;
output_ret = mbedtls_hkdf_extract( &fake_md_info, salt, salt_len,
ikm, ikm_len, prk );
TEST_ASSERT( output_ret == ret );
exit:
mbedtls_free(prk);
}
void test_test_hkdf_extract_ret_wrapper( void ** params )
{
test_test_hkdf_extract_ret( *( (int *) params[0] ),
*( (int *) params[1] ) );
}
void test_test_hkdf_expand_ret( int hash_len, int prk_len, int okm_len, int ret )
{
int output_ret;
unsigned char *info = NULL;
unsigned char *prk = NULL;
unsigned char *okm = NULL;
size_t info_len;
struct mbedtls_md_info_t fake_md_info;
memset( &fake_md_info, 0, sizeof( fake_md_info ) );
fake_md_info.type = MBEDTLS_MD_NONE;
fake_md_info.size = hash_len;
info_len = 0;
if (prk_len > 0)
prk = mbedtls_calloc( prk_len, 1 );
if (okm_len > 0)
okm = mbedtls_calloc( okm_len, 1 );
output_ret = mbedtls_hkdf_expand( &fake_md_info, prk, prk_len,
info, info_len, okm, okm_len );
TEST_ASSERT( output_ret == ret );
exit:
mbedtls_free(prk);
mbedtls_free(okm);
}
void test_test_hkdf_expand_ret_wrapper( void ** params )
{
test_test_hkdf_expand_ret( *( (int *) params[0] ), *( (int *) params[1] ), *( (int *) params[2] ), *( (int *) params[3] ) );
}
#endif /* MBEDTLS_HKDF_C */
/**
* \brief Evaluates an expression/macro into its literal integer value.
* For optimizing space for embedded targets each expression/macro
* is identified by a unique identifier instead of string literals.
* Identifiers and evaluation code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param exp_id Expression identifier.
* \param out_value Pointer to int to hold the integer.
*
* \return 0 if exp_id is found. 1 otherwise.
*/
int get_expression( int32_t exp_id, int32_t * out_value )
{
int ret = KEY_VALUE_MAPPING_FOUND;
switch( exp_id )
{
#if defined(MBEDTLS_HKDF_C)
case 0:
*out_value = MBEDTLS_ERR_HKDF_BAD_INPUT_DATA;
break;
#endif
default:
ret = KEY_VALUE_MAPPING_NOT_FOUND;
break;
}
return( ret );
}
/**
* \brief Checks if the dependency i.e. the compile flag is set.
* For optimizing space for embedded targets each dependency
* is identified by a unique identifier instead of string literals.
* Identifiers and check code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param dep_id Dependency identifier.
*
* \return DEPENDENCY_SUPPORTED if set else DEPENDENCY_NOT_SUPPORTED
*/
int dep_check( int dep_id )
{
int ret = DEPENDENCY_NOT_SUPPORTED;
switch( dep_id )
{
#if defined(MBEDTLS_HKDF_C)
case 0:
{
#if defined(MBEDTLS_SHA256_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 1:
{
#if defined(MBEDTLS_SHA1_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
#endif
default:
break;
}
return( ret );
}
/**
* \brief Function pointer type for test function wrappers.
*
* A test function wrapper decodes the parameters and passes them to the
* underlying test function. Both the wrapper and the underlying function
* return void. Test wrappers assume that they are passed a suitable
* parameter array and do not perform any error detection.
*
* \param param_array The array of parameters. Each element is a `void *`
* which the wrapper casts to the correct type and
* dereferences. Each wrapper function hard-codes the
* number and types of the parameters.
*/
typedef void (*TestWrapper_t)( void **param_array );
/**
* \brief Table of test function wrappers. Used by dispatch_test().
* This table is populated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
*/
TestWrapper_t test_funcs[] =
{
/* Function Id: 0 */
#if defined(MBEDTLS_HKDF_C)
test_test_hkdf_wrapper,
#else
NULL,
#endif
/* Function Id: 1 */
#if defined(MBEDTLS_HKDF_C)
test_test_hkdf_extract_wrapper,
#else
NULL,
#endif
/* Function Id: 2 */
#if defined(MBEDTLS_HKDF_C)
test_test_hkdf_expand_wrapper,
#else
NULL,
#endif
/* Function Id: 3 */
#if defined(MBEDTLS_HKDF_C)
test_test_hkdf_extract_ret_wrapper,
#else
NULL,
#endif
/* Function Id: 4 */
#if defined(MBEDTLS_HKDF_C)
test_test_hkdf_expand_ret_wrapper,
#else
NULL,
#endif
};
/**
* \brief Execute the test function.
*
* This is a wrapper function around the test function execution
* to allow the setjmp() call used to catch any calls to the
* parameter failure callback, to be used. Calls to setjmp()
* can invalidate the state of any local auto variables.
*
* \param fp Function pointer to the test function.
* \param params Parameters to pass to the #TestWrapper_t wrapper function.
*
*/
void execute_function_ptr(TestWrapper_t fp, void **params)
{
#if defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG)
mbedtls_test_enable_insecure_external_rng( );
#endif
#if defined(MBEDTLS_CHECK_PARAMS)
mbedtls_test_param_failed_location_record_t location_record;
if ( setjmp( mbedtls_test_param_failed_get_state_buf( ) ) == 0 )
{
fp( params );
}
else
{
/* Unexpected parameter validation error */
mbedtls_test_param_failed_get_location_record( &location_record );
mbedtls_test_fail( location_record.failure_condition,
location_record.line,
location_record.file );
}
mbedtls_test_param_failed_reset_state( );
#else
fp( params );
#endif
#if defined(MBEDTLS_TEST_MUTEX_USAGE)
mbedtls_test_mutex_usage_check( );
#endif /* MBEDTLS_TEST_MUTEX_USAGE */
}
/**
* \brief Dispatches test functions based on function index.
*
* \param func_idx Test function index.
* \param params The array of parameters to pass to the test function.
* It will be decoded by the #TestWrapper_t wrapper function.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int dispatch_test( size_t func_idx, void ** params )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof( test_funcs ) / sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp )
execute_function_ptr(fp, params);
else
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
/**
* \brief Checks if test function is supported in this build-time
* configuration.
*
* \param func_idx Test function index.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int check_test( size_t func_idx )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof(test_funcs)/sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp == NULL )
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
int main( int argc, const char *argv[] )
{
int ret;
mbedtls_test_platform_setup();
ret = execute_tests( argc, argv, "/zip/third_party/mbedtls/test/test_suite_hkdf.datax" );
mbedtls_test_platform_teardown();
return( ret );
}
| 13,729 | 426 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_pkwrite.c | /* clang-format off */
/*
* Copyright The Mbed TLS Contributors
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "third_party/mbedtls/test/test.inc"
/*
* *** THIS FILE WAS MACHINE GENERATED ***
*
* This file has been machine generated using the script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* Test file : ./test_suite_pkwrite.c
*
* The following files were used to create this file.
*
* Main code file : suites/main_test.function
* Platform code file : suites/host_test.function
* Helper file : suites/helpers.function
* Test suite file : suites/test_suite_pkwrite.function
* Test suite data : suites/test_suite_pkwrite.data
*
*/
#define TEST_SUITE_ACTIVE
#if defined(MBEDTLS_PK_PARSE_C)
#if defined(MBEDTLS_PK_WRITE_C)
#if defined(MBEDTLS_BIGNUM_C)
#if defined(MBEDTLS_FS_IO)
#include "third_party/mbedtls/pk.h"
#include "third_party/mbedtls/pem.h"
#include "third_party/mbedtls/oid.h"
#if defined(MBEDTLS_PEM_WRITE_C)
void test_pk_write_pubkey_check( char * key_file )
{
mbedtls_pk_context key;
unsigned char buf[5000];
unsigned char check_buf[5000];
int ret;
FILE *f;
size_t ilen, pem_len, buf_index;
memset( buf, 0, sizeof( buf ) );
memset( check_buf, 0, sizeof( check_buf ) );
mbedtls_pk_init( &key );
TEST_ASSERT( mbedtls_pk_parse_public_keyfile( &key, key_file ) == 0 );
ret = mbedtls_pk_write_pubkey_pem( &key, buf, sizeof( buf ));
TEST_ASSERT( ret == 0 );
pem_len = strlen( (char *) buf );
// check that the rest of the buffer remains clear
for( buf_index = pem_len; buf_index < sizeof( buf ); ++buf_index )
{
TEST_ASSERT( buf[buf_index] == 0 );
}
f = fopen( key_file, "r" );
TEST_ASSERT( f != NULL );
ilen = fread( check_buf, 1, sizeof( check_buf ), f );
fclose( f );
TEST_ASSERT( ilen == pem_len );
TEST_ASSERT( memcmp( (char *) buf, (char *) check_buf, ilen ) == 0 );
exit:
mbedtls_pk_free( &key );
}
void test_pk_write_pubkey_check_wrapper( void ** params )
{
test_pk_write_pubkey_check( (char *) params[0] );
}
#endif /* MBEDTLS_PEM_WRITE_C */
#if defined(MBEDTLS_PEM_WRITE_C)
void test_pk_write_key_check( char * key_file )
{
mbedtls_pk_context key;
unsigned char buf[5000];
unsigned char check_buf[5000];
int ret;
FILE *f;
size_t ilen, pem_len, buf_index;
memset( buf, 0, sizeof( buf ) );
memset( check_buf, 0, sizeof( check_buf ) );
mbedtls_pk_init( &key );
TEST_ASSERT( mbedtls_pk_parse_keyfile( &key, key_file, NULL ) == 0 );
ret = mbedtls_pk_write_key_pem( &key, buf, sizeof( buf ));
TEST_ASSERT( ret == 0 );
pem_len = strlen( (char *) buf );
// check that the rest of the buffer remains clear
for( buf_index = pem_len; buf_index < sizeof( buf ); ++buf_index )
{
TEST_ASSERT( buf[buf_index] == 0 );
}
f = fopen( key_file, "r" );
TEST_ASSERT( f != NULL );
ilen = fread( check_buf, 1, sizeof( check_buf ), f );
fclose( f );
TEST_ASSERT( ilen == strlen( (char *) buf ) );
TEST_ASSERT( memcmp( (char *) buf, (char *) check_buf, ilen ) == 0 );
exit:
mbedtls_pk_free( &key );
}
void test_pk_write_key_check_wrapper( void ** params )
{
test_pk_write_key_check( (char *) params[0] );
}
#endif /* MBEDTLS_PEM_WRITE_C */
#endif /* MBEDTLS_FS_IO */
#endif /* MBEDTLS_BIGNUM_C */
#endif /* MBEDTLS_PK_WRITE_C */
#endif /* MBEDTLS_PK_PARSE_C */
/*----------------------------------------------------------------------------*/
/* Test dispatch code */
/**
* \brief Evaluates an expression/macro into its literal integer value.
* For optimizing space for embedded targets each expression/macro
* is identified by a unique identifier instead of string literals.
* Identifiers and evaluation code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param exp_id Expression identifier.
* \param out_value Pointer to int to hold the integer.
*
* \return 0 if exp_id is found. 1 otherwise.
*/
int get_expression( int32_t exp_id, int32_t * out_value )
{
int ret = KEY_VALUE_MAPPING_FOUND;
(void) exp_id;
(void) out_value;
switch( exp_id )
{
#if defined(MBEDTLS_PK_PARSE_C) && defined(MBEDTLS_PK_WRITE_C) && defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_FS_IO)
#endif
default:
{
ret = KEY_VALUE_MAPPING_NOT_FOUND;
}
break;
}
return( ret );
}
/**
* \brief Checks if the dependency i.e. the compile flag is set.
* For optimizing space for embedded targets each dependency
* is identified by a unique identifier instead of string literals.
* Identifiers and check code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param dep_id Dependency identifier.
*
* \return DEPENDENCY_SUPPORTED if set else DEPENDENCY_NOT_SUPPORTED
*/
int dep_check( int dep_id )
{
int ret = DEPENDENCY_NOT_SUPPORTED;
(void) dep_id;
switch( dep_id )
{
#if defined(MBEDTLS_PK_PARSE_C) && defined(MBEDTLS_PK_WRITE_C) && defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_FS_IO)
case 0:
{
#if defined(MBEDTLS_RSA_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 1:
{
#if defined(MBEDTLS_BASE64_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 2:
{
#if defined(MBEDTLS_ECP_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 3:
{
#if defined(MBEDTLS_ECP_DP_SECP192R1_ENABLED)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 4:
{
#if defined(MBEDTLS_ECP_DP_SECP521R1_ENABLED)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 5:
{
#if defined(MBEDTLS_ECP_DP_BP512R1_ENABLED)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 6:
{
#if defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
#endif
default:
break;
}
return( ret );
}
/**
* \brief Function pointer type for test function wrappers.
*
* A test function wrapper decodes the parameters and passes them to the
* underlying test function. Both the wrapper and the underlying function
* return void. Test wrappers assume that they are passed a suitable
* parameter array and do not perform any error detection.
*
* \param param_array The array of parameters. Each element is a `void *`
* which the wrapper casts to the correct type and
* dereferences. Each wrapper function hard-codes the
* number and types of the parameters.
*/
typedef void (*TestWrapper_t)( void **param_array );
/**
* \brief Table of test function wrappers. Used by dispatch_test().
* This table is populated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
*/
TestWrapper_t test_funcs[] =
{
/* Function Id: 0 */
#if defined(MBEDTLS_PK_PARSE_C) && defined(MBEDTLS_PK_WRITE_C) && defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_FS_IO) && defined(MBEDTLS_PEM_WRITE_C)
test_pk_write_pubkey_check_wrapper,
#else
NULL,
#endif
/* Function Id: 1 */
#if defined(MBEDTLS_PK_PARSE_C) && defined(MBEDTLS_PK_WRITE_C) && defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_FS_IO) && defined(MBEDTLS_PEM_WRITE_C)
test_pk_write_key_check_wrapper,
#else
NULL,
#endif
};
/**
* \brief Execute the test function.
*
* This is a wrapper function around the test function execution
* to allow the setjmp() call used to catch any calls to the
* parameter failure callback, to be used. Calls to setjmp()
* can invalidate the state of any local auto variables.
*
* \param fp Function pointer to the test function.
* \param params Parameters to pass to the #TestWrapper_t wrapper function.
*
*/
void execute_function_ptr(TestWrapper_t fp, void **params)
{
#if defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG)
mbedtls_test_enable_insecure_external_rng( );
#endif
#if defined(MBEDTLS_CHECK_PARAMS)
mbedtls_test_param_failed_location_record_t location_record;
if ( setjmp( mbedtls_test_param_failed_get_state_buf( ) ) == 0 )
{
fp( params );
}
else
{
/* Unexpected parameter validation error */
mbedtls_test_param_failed_get_location_record( &location_record );
mbedtls_test_fail( location_record.failure_condition,
location_record.line,
location_record.file );
}
mbedtls_test_param_failed_reset_state( );
#else
fp( params );
#endif
#if defined(MBEDTLS_TEST_MUTEX_USAGE)
mbedtls_test_mutex_usage_check( );
#endif /* MBEDTLS_TEST_MUTEX_USAGE */
}
/**
* \brief Dispatches test functions based on function index.
*
* \param func_idx Test function index.
* \param params The array of parameters to pass to the test function.
* It will be decoded by the #TestWrapper_t wrapper function.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int dispatch_test( size_t func_idx, void ** params )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof( test_funcs ) / sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp )
execute_function_ptr(fp, params);
else
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
/**
* \brief Checks if test function is supported in this build-time
* configuration.
*
* \param func_idx Test function index.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int check_test( size_t func_idx )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof(test_funcs)/sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp == NULL )
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
int main( int argc, const char *argv[] )
{
int ret;
mbedtls_test_platform_setup();
ret = execute_tests( argc, argv, "/zip/third_party/mbedtls/test/test_suite_pkwrite.datax" );
mbedtls_test_platform_teardown();
return( ret );
}
| 12,162 | 431 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_cipher.chacha20.c | /* clang-format off */
/*
* Copyright The Mbed TLS Contributors
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "third_party/mbedtls/test/test.inc"
/*
* *** THIS FILE WAS MACHINE GENERATED ***
*
* This file has been machine generated using the script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* Test file : ./test_suite_cipher.chacha20.c
*
* The following files were used to create this file.
*
* Main code file : suites/main_test.function
* Platform code file : suites/host_test.function
* Helper file : suites/helpers.function
* Test suite file : suites/test_suite_cipher.function
* Test suite data : suites/test_suite_cipher.chacha20.data
*
*/
#define TEST_SUITE_ACTIVE
#if defined(MBEDTLS_CIPHER_C)
#include "third_party/mbedtls/cipher.h"
#if defined(MBEDTLS_AES_C)
#include "third_party/mbedtls/aes.h"
#endif
#if defined(MBEDTLS_GCM_C)
#include "third_party/mbedtls/gcm.h"
#endif
#if defined(MBEDTLS_CIPHER_MODE_AEAD) || defined(MBEDTLS_NIST_KW_C)
#define MBEDTLS_CIPHER_AUTH_CRYPT
#endif
#if defined(MBEDTLS_CIPHER_AUTH_CRYPT)
/* Helper for resetting key/direction
*
* The documentation doesn't explicitly say whether calling
* mbedtls_cipher_setkey() twice is allowed or not. This currently works with
* the default software implementation, but only by accident. It isn't
* guaranteed to work with new ciphers or with alternative implementations of
* individual ciphers, and it doesn't work with the PSA wrappers. So don't do
* it, and instead start with a fresh context.
*/
static int cipher_reset_key( mbedtls_cipher_context_t *ctx, int cipher_id,
int use_psa, size_t tag_len, const data_t *key, int direction )
{
mbedtls_cipher_free( ctx );
mbedtls_cipher_init( ctx );
#if !defined(MBEDTLS_USE_PSA_CRYPTO)
(void) use_psa;
(void) tag_len;
#else
if( use_psa == 1 )
{
TEST_ASSERT( 0 == mbedtls_cipher_setup_psa( ctx,
mbedtls_cipher_info_from_type( cipher_id ),
tag_len ) );
}
else
#endif /* MBEDTLS_USE_PSA_CRYPTO */
{
TEST_ASSERT( 0 == mbedtls_cipher_setup( ctx,
mbedtls_cipher_info_from_type( cipher_id ) ) );
}
TEST_ASSERT( 0 == mbedtls_cipher_setkey( ctx, key->x, 8 * key->len,
direction ) );
return( 1 );
exit:
return( 0 );
}
/*
* Check if a buffer is all-0 bytes:
* return 1 if it is,
* 0 if it isn't.
*/
int buffer_is_all_zero( const uint8_t *buf, size_t size )
{
for( size_t i = 0; i < size; i++ )
if( buf[i] != 0 )
return 0;
return 1;
}
#endif /* MBEDTLS_CIPHER_AUTH_CRYPT */
void test_mbedtls_cipher_list( )
{
const int *cipher_type;
for( cipher_type = mbedtls_cipher_list(); *cipher_type != 0; cipher_type++ )
TEST_ASSERT( mbedtls_cipher_info_from_type( *cipher_type ) != NULL );
exit:
;
}
void test_mbedtls_cipher_list_wrapper( void ** params )
{
(void)params;
test_mbedtls_cipher_list( );
}
void test_cipher_invalid_param_unconditional( )
{
mbedtls_cipher_context_t valid_ctx;
mbedtls_cipher_context_t invalid_ctx;
mbedtls_operation_t valid_operation = MBEDTLS_ENCRYPT;
mbedtls_cipher_padding_t valid_mode = MBEDTLS_PADDING_ZEROS;
unsigned char valid_buffer[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
int valid_size = sizeof(valid_buffer);
int valid_bitlen = valid_size * 8;
const mbedtls_cipher_info_t *valid_info = mbedtls_cipher_info_from_type(
*( mbedtls_cipher_list() ) );
size_t size_t_var;
(void)valid_mode; /* In some configurations this is unused */
mbedtls_cipher_init( &valid_ctx );
mbedtls_cipher_setup( &valid_ctx, valid_info );
mbedtls_cipher_init( &invalid_ctx );
/* mbedtls_cipher_setup() */
TEST_ASSERT( mbedtls_cipher_setup( &valid_ctx, NULL ) ==
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
/* mbedtls_cipher_get_block_size() */
TEST_ASSERT( mbedtls_cipher_get_block_size( &invalid_ctx ) == 0 );
/* mbedtls_cipher_get_cipher_mode() */
TEST_ASSERT( mbedtls_cipher_get_cipher_mode( &invalid_ctx ) ==
MBEDTLS_MODE_NONE );
/* mbedtls_cipher_get_iv_size() */
TEST_ASSERT( mbedtls_cipher_get_iv_size( &invalid_ctx ) == 0 );
/* mbedtls_cipher_get_type() */
TEST_ASSERT(
mbedtls_cipher_get_type( &invalid_ctx ) ==
MBEDTLS_CIPHER_NONE);
/* mbedtls_cipher_get_name() */
TEST_ASSERT( mbedtls_cipher_get_name( &invalid_ctx ) == 0 );
/* mbedtls_cipher_get_key_bitlen() */
TEST_ASSERT( mbedtls_cipher_get_key_bitlen( &invalid_ctx ) ==
MBEDTLS_KEY_LENGTH_NONE );
/* mbedtls_cipher_get_operation() */
TEST_ASSERT( mbedtls_cipher_get_operation( &invalid_ctx ) ==
MBEDTLS_OPERATION_NONE );
/* mbedtls_cipher_setkey() */
TEST_ASSERT(
mbedtls_cipher_setkey( &invalid_ctx,
valid_buffer,
valid_bitlen,
valid_operation ) ==
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
/* mbedtls_cipher_set_iv() */
TEST_ASSERT(
mbedtls_cipher_set_iv( &invalid_ctx,
valid_buffer,
valid_size ) ==
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
/* mbedtls_cipher_reset() */
TEST_ASSERT( mbedtls_cipher_reset( &invalid_ctx ) ==
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
/* mbedtls_cipher_update_ad() */
TEST_ASSERT(
mbedtls_cipher_update_ad( &invalid_ctx,
valid_buffer,
valid_size ) ==
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
#endif /* defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C) */
#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
/* mbedtls_cipher_set_padding_mode() */
TEST_ASSERT( mbedtls_cipher_set_padding_mode( &invalid_ctx, valid_mode ) ==
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
#endif
/* mbedtls_cipher_update() */
TEST_ASSERT(
mbedtls_cipher_update( &invalid_ctx,
valid_buffer,
valid_size,
valid_buffer,
&size_t_var ) ==
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
/* mbedtls_cipher_finish() */
TEST_ASSERT(
mbedtls_cipher_finish( &invalid_ctx,
valid_buffer,
&size_t_var ) ==
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
/* mbedtls_cipher_write_tag() */
TEST_ASSERT(
mbedtls_cipher_write_tag( &invalid_ctx,
valid_buffer,
valid_size ) ==
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
/* mbedtls_cipher_check_tag() */
TEST_ASSERT(
mbedtls_cipher_check_tag( &invalid_ctx,
valid_buffer,
valid_size ) ==
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
#endif /* defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C) */
exit:
mbedtls_cipher_free( &invalid_ctx );
mbedtls_cipher_free( &valid_ctx );
}
void test_cipher_invalid_param_unconditional_wrapper( void ** params )
{
(void)params;
test_cipher_invalid_param_unconditional( );
}
#if defined(MBEDTLS_CHECK_PARAMS)
#if !defined(MBEDTLS_PARAM_FAILED_ALT)
void test_cipher_invalid_param_conditional( )
{
mbedtls_cipher_context_t valid_ctx;
mbedtls_operation_t valid_operation = MBEDTLS_ENCRYPT;
mbedtls_operation_t invalid_operation = 100;
mbedtls_cipher_padding_t valid_mode = MBEDTLS_PADDING_ZEROS;
unsigned char valid_buffer[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
int valid_size = sizeof(valid_buffer);
int valid_bitlen = valid_size * 8;
const mbedtls_cipher_info_t *valid_info = mbedtls_cipher_info_from_type(
*( mbedtls_cipher_list() ) );
size_t size_t_var;
(void)valid_mode; /* In some configurations this is unused */
/* mbedtls_cipher_init() */
TEST_VALID_PARAM( mbedtls_cipher_init( &valid_ctx ) );
TEST_INVALID_PARAM( mbedtls_cipher_init( NULL ) );
/* mbedtls_cipher_setup() */
TEST_VALID_PARAM( mbedtls_cipher_setup( &valid_ctx, valid_info ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_setup( NULL, valid_info ) );
/* mbedtls_cipher_get_block_size() */
TEST_INVALID_PARAM_RET( 0, mbedtls_cipher_get_block_size( NULL ) );
/* mbedtls_cipher_get_cipher_mode() */
TEST_INVALID_PARAM_RET(
MBEDTLS_MODE_NONE,
mbedtls_cipher_get_cipher_mode( NULL ) );
/* mbedtls_cipher_get_iv_size() */
TEST_INVALID_PARAM_RET( 0, mbedtls_cipher_get_iv_size( NULL ) );
/* mbedtls_cipher_get_type() */
TEST_INVALID_PARAM_RET(
MBEDTLS_CIPHER_NONE,
mbedtls_cipher_get_type( NULL ) );
/* mbedtls_cipher_get_name() */
TEST_INVALID_PARAM_RET( 0, mbedtls_cipher_get_name( NULL ) );
/* mbedtls_cipher_get_key_bitlen() */
TEST_INVALID_PARAM_RET(
MBEDTLS_KEY_LENGTH_NONE,
mbedtls_cipher_get_key_bitlen( NULL ) );
/* mbedtls_cipher_get_operation() */
TEST_INVALID_PARAM_RET(
MBEDTLS_OPERATION_NONE,
mbedtls_cipher_get_operation( NULL ) );
/* mbedtls_cipher_setkey() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_setkey( NULL,
valid_buffer,
valid_bitlen,
valid_operation ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_setkey( &valid_ctx,
NULL,
valid_bitlen,
valid_operation ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_setkey( &valid_ctx,
valid_buffer,
valid_bitlen,
invalid_operation ) );
/* mbedtls_cipher_set_iv() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_set_iv( NULL,
valid_buffer,
valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_set_iv( &valid_ctx,
NULL,
valid_size ) );
/* mbedtls_cipher_reset() */
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_reset( NULL ) );
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
/* mbedtls_cipher_update_ad() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_update_ad( NULL,
valid_buffer,
valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_update_ad( &valid_ctx,
NULL,
valid_size ) );
#endif /* defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C) */
#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
/* mbedtls_cipher_set_padding_mode() */
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_set_padding_mode( NULL, valid_mode ) );
#endif
/* mbedtls_cipher_update() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_update( NULL,
valid_buffer,
valid_size,
valid_buffer,
&size_t_var ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_update( &valid_ctx,
NULL, valid_size,
valid_buffer,
&size_t_var ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_update( &valid_ctx,
valid_buffer, valid_size,
NULL,
&size_t_var ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_update( &valid_ctx,
valid_buffer, valid_size,
valid_buffer,
NULL ) );
/* mbedtls_cipher_finish() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_finish( NULL,
valid_buffer,
&size_t_var ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_finish( &valid_ctx,
NULL,
&size_t_var ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_finish( &valid_ctx,
valid_buffer,
NULL ) );
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
/* mbedtls_cipher_write_tag() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_write_tag( NULL,
valid_buffer,
valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_write_tag( &valid_ctx,
NULL,
valid_size ) );
/* mbedtls_cipher_check_tag() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_check_tag( NULL,
valid_buffer,
valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_check_tag( &valid_ctx,
NULL,
valid_size ) );
#endif /* defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C) */
/* mbedtls_cipher_crypt() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_crypt( NULL,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, &size_t_var ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_crypt( &valid_ctx,
NULL, valid_size,
valid_buffer, valid_size,
valid_buffer, &size_t_var ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_crypt( &valid_ctx,
valid_buffer, valid_size,
NULL, valid_size,
valid_buffer, &size_t_var ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_crypt( &valid_ctx,
valid_buffer, valid_size,
valid_buffer, valid_size,
NULL, &size_t_var ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_crypt( &valid_ctx,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, NULL ) );
#if defined(MBEDTLS_CIPHER_MODE_AEAD)
/* mbedtls_cipher_auth_encrypt() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_encrypt( NULL,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, &size_t_var,
valid_buffer, valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_encrypt( &valid_ctx,
NULL, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, &size_t_var,
valid_buffer, valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_encrypt( &valid_ctx,
valid_buffer, valid_size,
NULL, valid_size,
valid_buffer, valid_size,
valid_buffer, &size_t_var,
valid_buffer, valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_encrypt( &valid_ctx,
valid_buffer, valid_size,
valid_buffer, valid_size,
NULL, valid_size,
valid_buffer, &size_t_var,
valid_buffer, valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_encrypt( &valid_ctx,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
NULL, &size_t_var,
valid_buffer, valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_encrypt( &valid_ctx,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, NULL,
valid_buffer, valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_encrypt( &valid_ctx,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, &size_t_var,
NULL, valid_size ) );
/* mbedtls_cipher_auth_decrypt() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_decrypt( NULL,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, &size_t_var,
valid_buffer, valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_decrypt( &valid_ctx,
NULL, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, &size_t_var,
valid_buffer, valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_decrypt( &valid_ctx,
valid_buffer, valid_size,
NULL, valid_size,
valid_buffer, valid_size,
valid_buffer, &size_t_var,
valid_buffer, valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_decrypt( &valid_ctx,
valid_buffer, valid_size,
valid_buffer, valid_size,
NULL, valid_size,
valid_buffer, &size_t_var,
valid_buffer, valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_decrypt( &valid_ctx,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
NULL, &size_t_var,
valid_buffer, valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_decrypt( &valid_ctx,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, NULL,
valid_buffer, valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_decrypt( &valid_ctx,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, &size_t_var,
NULL, valid_size ) );
#endif /* defined(MBEDTLS_CIPHER_MODE_AEAD) */
#if defined(MBEDTLS_CIPHER_MODE_AEAD) || defined(MBEDTLS_NIST_KW_C)
/* mbedtls_cipher_auth_encrypt_ext */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_encrypt_ext( NULL,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size, &size_t_var,
valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_encrypt_ext( &valid_ctx,
NULL, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size, &size_t_var,
valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_encrypt_ext( &valid_ctx,
valid_buffer, valid_size,
NULL, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size, &size_t_var,
valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_encrypt_ext( &valid_ctx,
valid_buffer, valid_size,
valid_buffer, valid_size,
NULL, valid_size,
valid_buffer, valid_size, &size_t_var,
valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_encrypt_ext( &valid_ctx,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
NULL, valid_size, &size_t_var,
valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_encrypt_ext( &valid_ctx,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size, NULL,
valid_size ) );
/* mbedtls_cipher_auth_decrypt_ext */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_decrypt_ext( NULL,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size, &size_t_var,
valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_decrypt_ext( &valid_ctx,
NULL, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size, &size_t_var,
valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_decrypt_ext( &valid_ctx,
valid_buffer, valid_size,
NULL, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size, &size_t_var,
valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_decrypt_ext( &valid_ctx,
valid_buffer, valid_size,
valid_buffer, valid_size,
NULL, valid_size,
valid_buffer, valid_size, &size_t_var,
valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_decrypt_ext( &valid_ctx,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
NULL, valid_size, &size_t_var,
valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_decrypt_ext( &valid_ctx,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size, NULL,
valid_size ) );
#endif /* MBEDTLS_CIPHER_MODE_AEAD || MBEDTLS_NIST_KW_C */
/* mbedtls_cipher_free() */
TEST_VALID_PARAM( mbedtls_cipher_free( NULL ) );
exit:
TEST_VALID_PARAM( mbedtls_cipher_free( &valid_ctx ) );
}
void test_cipher_invalid_param_conditional_wrapper( void ** params )
{
(void)params;
test_cipher_invalid_param_conditional( );
}
#endif /* !MBEDTLS_PARAM_FAILED_ALT */
#endif /* MBEDTLS_CHECK_PARAMS */
#if defined(MBEDTLS_AES_C)
void test_cipher_special_behaviours( )
{
const mbedtls_cipher_info_t *cipher_info;
mbedtls_cipher_context_t ctx;
unsigned char input[32];
unsigned char output[32];
#if defined (MBEDTLS_CIPHER_MODE_CBC)
unsigned char iv[32];
#endif
size_t olen = 0;
mbedtls_cipher_init( &ctx );
memset( input, 0, sizeof( input ) );
memset( output, 0, sizeof( output ) );
#if defined(MBEDTLS_CIPHER_MODE_CBC)
memset( iv, 0, sizeof( iv ) );
/* Check and get info structures */
cipher_info = mbedtls_cipher_info_from_type( MBEDTLS_CIPHER_AES_128_CBC );
TEST_ASSERT( NULL != cipher_info );
TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx, cipher_info ) );
/* IV too big */
TEST_ASSERT( mbedtls_cipher_set_iv( &ctx, iv, MBEDTLS_MAX_IV_LENGTH + 1 )
== MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
/* IV too small */
TEST_ASSERT( mbedtls_cipher_set_iv( &ctx, iv, 0 )
== MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
mbedtls_cipher_free( &ctx );
mbedtls_cipher_init( &ctx );
#endif /* MBEDTLS_CIPHER_MODE_CBC */
cipher_info = mbedtls_cipher_info_from_type( MBEDTLS_CIPHER_AES_128_ECB );
TEST_ASSERT( NULL != cipher_info );
TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx, cipher_info ) );
/* Update ECB with partial block */
TEST_ASSERT( mbedtls_cipher_update( &ctx, input, 1, output, &olen )
== MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED );
exit:
mbedtls_cipher_free( &ctx );
}
void test_cipher_special_behaviours_wrapper( void ** params )
{
(void)params;
test_cipher_special_behaviours( );
}
#endif /* MBEDTLS_AES_C */
void test_enc_dec_buf( int cipher_id, char * cipher_string, int key_len,
int length_val, int pad_mode )
{
size_t length = length_val, outlen, total_len, i, block_size;
unsigned char key[64];
unsigned char iv[16];
unsigned char ad[13];
unsigned char tag[16];
unsigned char inbuf[64];
unsigned char encbuf[64];
unsigned char decbuf[64];
const mbedtls_cipher_info_t *cipher_info;
mbedtls_cipher_context_t ctx_dec;
mbedtls_cipher_context_t ctx_enc;
/*
* Prepare contexts
*/
mbedtls_cipher_init( &ctx_dec );
mbedtls_cipher_init( &ctx_enc );
memset( key, 0x2a, sizeof( key ) );
/* Check and get info structures */
cipher_info = mbedtls_cipher_info_from_type( cipher_id );
TEST_ASSERT( NULL != cipher_info );
TEST_ASSERT( mbedtls_cipher_info_from_string( cipher_string ) == cipher_info );
/* Initialise enc and dec contexts */
TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_dec, cipher_info ) );
TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_enc, cipher_info ) );
TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_dec, key, key_len, MBEDTLS_DECRYPT ) );
TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_enc, key, key_len, MBEDTLS_ENCRYPT ) );
#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
if( -1 != pad_mode )
{
TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx_dec, pad_mode ) );
TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx_enc, pad_mode ) );
}
#else
(void) pad_mode;
#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
/*
* Do a few encode/decode cycles
*/
for( i = 0; i < 3; i++ )
{
memset( iv , 0x00 + i, sizeof( iv ) );
memset( ad, 0x10 + i, sizeof( ad ) );
memset( inbuf, 0x20 + i, sizeof( inbuf ) );
memset( encbuf, 0, sizeof( encbuf ) );
memset( decbuf, 0, sizeof( decbuf ) );
memset( tag, 0, sizeof( tag ) );
TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_dec, iv, sizeof( iv ) ) );
TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_enc, iv, sizeof( iv ) ) );
TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_dec ) );
TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_enc ) );
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_dec, ad, sizeof( ad ) - i ) );
TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_enc, ad, sizeof( ad ) - i ) );
#endif
block_size = mbedtls_cipher_get_block_size( &ctx_enc );
TEST_ASSERT( block_size != 0 );
/* encode length number of bytes from inbuf */
TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_enc, inbuf, length, encbuf, &outlen ) );
total_len = outlen;
TEST_ASSERT( total_len == length ||
( total_len % block_size == 0 &&
total_len < length &&
total_len + block_size > length ) );
TEST_ASSERT( 0 == mbedtls_cipher_finish( &ctx_enc, encbuf + outlen, &outlen ) );
total_len += outlen;
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
TEST_ASSERT( 0 == mbedtls_cipher_write_tag( &ctx_enc, tag, sizeof( tag ) ) );
#endif
TEST_ASSERT( total_len == length ||
( total_len % block_size == 0 &&
total_len > length &&
total_len <= length + block_size ) );
/* decode the previously encoded string */
TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_dec, encbuf, total_len, decbuf, &outlen ) );
total_len = outlen;
TEST_ASSERT( total_len == length ||
( total_len % block_size == 0 &&
total_len < length &&
total_len + block_size >= length ) );
TEST_ASSERT( 0 == mbedtls_cipher_finish( &ctx_dec, decbuf + outlen, &outlen ) );
total_len += outlen;
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
TEST_ASSERT( 0 == mbedtls_cipher_check_tag( &ctx_dec, tag, sizeof( tag ) ) );
#endif
/* check result */
TEST_ASSERT( total_len == length );
TEST_ASSERT( 0 == timingsafe_bcmp(inbuf, decbuf, length) );
}
/*
* Done
*/
exit:
mbedtls_cipher_free( &ctx_dec );
mbedtls_cipher_free( &ctx_enc );
}
void test_enc_dec_buf_wrapper( void ** params )
{
test_enc_dec_buf( *( (int *) params[0] ), (char *) params[1], *( (int *) params[2] ), *( (int *) params[3] ), *( (int *) params[4] ) );
}
void test_enc_fail( int cipher_id, int pad_mode, int key_len, int length_val,
int ret )
{
size_t length = length_val;
unsigned char key[32];
unsigned char iv[16];
const mbedtls_cipher_info_t *cipher_info;
mbedtls_cipher_context_t ctx;
unsigned char inbuf[64];
unsigned char encbuf[64];
size_t outlen = 0;
memset( key, 0, 32 );
memset( iv , 0, 16 );
mbedtls_cipher_init( &ctx );
memset( inbuf, 5, 64 );
memset( encbuf, 0, 64 );
/* Check and get info structures */
cipher_info = mbedtls_cipher_info_from_type( cipher_id );
TEST_ASSERT( NULL != cipher_info );
/* Initialise context */
TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx, cipher_info ) );
TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key, key_len, MBEDTLS_ENCRYPT ) );
#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx, pad_mode ) );
#else
(void) pad_mode;
#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx, iv, 16 ) );
TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx ) );
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx, NULL, 0 ) );
#endif
/* encode length number of bytes from inbuf */
TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx, inbuf, length, encbuf, &outlen ) );
TEST_ASSERT( ret == mbedtls_cipher_finish( &ctx, encbuf + outlen, &outlen ) );
/* done */
exit:
mbedtls_cipher_free( &ctx );
}
void test_enc_fail_wrapper( void ** params )
{
test_enc_fail( *( (int *) params[0] ), *( (int *) params[1] ), *( (int *) params[2] ), *( (int *) params[3] ), *( (int *) params[4] ) );
}
void test_dec_empty_buf( int cipher,
int expected_update_ret,
int expected_finish_ret )
{
unsigned char key[32];
unsigned char iv[16];
mbedtls_cipher_context_t ctx_dec;
const mbedtls_cipher_info_t *cipher_info;
unsigned char encbuf[64];
unsigned char decbuf[64];
size_t outlen = 0;
memset( key, 0, 32 );
memset( iv , 0, 16 );
mbedtls_cipher_init( &ctx_dec );
memset( encbuf, 0, 64 );
memset( decbuf, 0, 64 );
/* Initialise context */
cipher_info = mbedtls_cipher_info_from_type( cipher );
TEST_ASSERT( NULL != cipher_info);
TEST_ASSERT( sizeof(key) * 8 >= cipher_info->key_bitlen );
TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_dec, cipher_info ) );
TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_dec,
key, cipher_info->key_bitlen,
MBEDTLS_DECRYPT ) );
TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_dec, iv, 16 ) );
TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_dec ) );
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_dec, NULL, 0 ) );
#endif
/* decode 0-byte string */
TEST_ASSERT( expected_update_ret ==
mbedtls_cipher_update( &ctx_dec, encbuf, 0, decbuf, &outlen ) );
TEST_ASSERT( 0 == outlen );
if ( expected_finish_ret == 0 &&
( cipher_info->mode == MBEDTLS_MODE_CBC ||
cipher_info->mode == MBEDTLS_MODE_ECB ) )
{
/* Non-CBC and non-ECB ciphers are OK with decrypting empty buffers and
* return success, not MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED, when
* decrypting an empty buffer.
* On the other hand, CBC and ECB ciphers need a full block of input.
*/
expected_finish_ret = MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED;
}
TEST_ASSERT( expected_finish_ret == mbedtls_cipher_finish(
&ctx_dec, decbuf + outlen, &outlen ) );
TEST_ASSERT( 0 == outlen );
exit:
mbedtls_cipher_free( &ctx_dec );
}
void test_dec_empty_buf_wrapper( void ** params )
{
test_dec_empty_buf( *( (int *) params[0] ), *( (int *) params[1] ), *( (int *) params[2] ) );
}
void test_enc_dec_buf_multipart( int cipher_id, int key_len, int first_length_val,
int second_length_val, int pad_mode,
int first_encrypt_output_len, int second_encrypt_output_len,
int first_decrypt_output_len, int second_decrypt_output_len )
{
size_t first_length = first_length_val;
size_t second_length = second_length_val;
size_t length = first_length + second_length;
size_t block_size;
unsigned char key[32];
unsigned char iv[16];
mbedtls_cipher_context_t ctx_dec;
mbedtls_cipher_context_t ctx_enc;
const mbedtls_cipher_info_t *cipher_info;
unsigned char inbuf[64];
unsigned char encbuf[64];
unsigned char decbuf[64];
size_t outlen = 0;
size_t totaloutlen = 0;
memset( key, 0, 32 );
memset( iv , 0, 16 );
mbedtls_cipher_init( &ctx_dec );
mbedtls_cipher_init( &ctx_enc );
memset( inbuf, 5, 64 );
memset( encbuf, 0, 64 );
memset( decbuf, 0, 64 );
/* Initialise enc and dec contexts */
cipher_info = mbedtls_cipher_info_from_type( cipher_id );
TEST_ASSERT( NULL != cipher_info);
TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_dec, cipher_info ) );
TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_enc, cipher_info ) );
TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_dec, key, key_len, MBEDTLS_DECRYPT ) );
TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_enc, key, key_len, MBEDTLS_ENCRYPT ) );
#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
if( -1 != pad_mode )
{
TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx_dec, pad_mode ) );
TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx_enc, pad_mode ) );
}
#else
(void) pad_mode;
#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_dec, iv, 16 ) );
TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_enc, iv, 16 ) );
TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_dec ) );
TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_enc ) );
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_dec, NULL, 0 ) );
TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_enc, NULL, 0 ) );
#endif
block_size = mbedtls_cipher_get_block_size( &ctx_enc );
TEST_ASSERT( block_size != 0 );
/* encode length number of bytes from inbuf */
TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_enc, inbuf, first_length, encbuf, &outlen ) );
TEST_ASSERT( (size_t)first_encrypt_output_len == outlen );
totaloutlen = outlen;
TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_enc, inbuf + first_length, second_length, encbuf + totaloutlen, &outlen ) );
TEST_ASSERT( (size_t)second_encrypt_output_len == outlen );
totaloutlen += outlen;
TEST_ASSERT( totaloutlen == length ||
( totaloutlen % block_size == 0 &&
totaloutlen < length &&
totaloutlen + block_size > length ) );
TEST_ASSERT( 0 == mbedtls_cipher_finish( &ctx_enc, encbuf + totaloutlen, &outlen ) );
totaloutlen += outlen;
TEST_ASSERT( totaloutlen == length ||
( totaloutlen % block_size == 0 &&
totaloutlen > length &&
totaloutlen <= length + block_size ) );
/* decode the previously encoded string */
second_length = totaloutlen - first_length;
TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_dec, encbuf, first_length, decbuf, &outlen ) );
TEST_ASSERT( (size_t)first_decrypt_output_len == outlen );
totaloutlen = outlen;
TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_dec, encbuf + first_length, second_length, decbuf + totaloutlen, &outlen ) );
TEST_ASSERT( (size_t)second_decrypt_output_len == outlen );
totaloutlen += outlen;
TEST_ASSERT( totaloutlen == length ||
( totaloutlen % block_size == 0 &&
totaloutlen < length &&
totaloutlen + block_size >= length ) );
TEST_ASSERT( 0 == mbedtls_cipher_finish( &ctx_dec, decbuf + totaloutlen, &outlen ) );
totaloutlen += outlen;
TEST_ASSERT( totaloutlen == length );
TEST_ASSERT( 0 == timingsafe_bcmp(inbuf, decbuf, length) );
exit:
mbedtls_cipher_free( &ctx_dec );
mbedtls_cipher_free( &ctx_enc );
}
void test_enc_dec_buf_multipart_wrapper( void ** params )
{
test_enc_dec_buf_multipart( *( (int *) params[0] ), *( (int *) params[1] ), *( (int *) params[2] ), *( (int *) params[3] ), *( (int *) params[4] ), *( (int *) params[5] ), *( (int *) params[6] ), *( (int *) params[7] ), *( (int *) params[8] ) );
}
void test_decrypt_test_vec( int cipher_id, int pad_mode, data_t * key,
data_t * iv, data_t * cipher,
data_t * clear, data_t * ad, data_t * tag,
int finish_result, int tag_result )
{
unsigned char output[265];
mbedtls_cipher_context_t ctx;
size_t outlen, total_len;
mbedtls_cipher_init( &ctx );
memset( output, 0x00, sizeof( output ) );
#if !defined(MBEDTLS_GCM_C) && !defined(MBEDTLS_CHACHAPOLY_C)
((void) ad);
((void) tag);
#endif
/* Prepare context */
TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx,
mbedtls_cipher_info_from_type( cipher_id ) ) );
TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key->x, 8 * key->len, MBEDTLS_DECRYPT ) );
#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
if( pad_mode != -1 )
TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx, pad_mode ) );
#else
(void) pad_mode;
#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx, iv->x, iv->len ) );
TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx ) );
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx, ad->x, ad->len ) );
#endif
/* decode buffer and check tag->x */
total_len = 0;
TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx, cipher->x, cipher->len, output, &outlen ) );
total_len += outlen;
TEST_ASSERT( finish_result == mbedtls_cipher_finish( &ctx, output + outlen,
&outlen ) );
total_len += outlen;
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
TEST_ASSERT( tag_result == mbedtls_cipher_check_tag( &ctx, tag->x, tag->len ) );
#endif
/* check plaintext only if everything went fine */
if( 0 == finish_result && 0 == tag_result )
{
TEST_ASSERT( total_len == clear->len );
TEST_ASSERT( 0 == timingsafe_bcmp( output, clear->x, clear->len ) );
}
exit:
mbedtls_cipher_free( &ctx );
}
void test_decrypt_test_vec_wrapper( void ** params )
{
data_t data2 = {(uint8_t *) params[2], *( (uint32_t *) params[3] )};
data_t data4 = {(uint8_t *) params[4], *( (uint32_t *) params[5] )};
data_t data6 = {(uint8_t *) params[6], *( (uint32_t *) params[7] )};
data_t data8 = {(uint8_t *) params[8], *( (uint32_t *) params[9] )};
data_t data10 = {(uint8_t *) params[10], *( (uint32_t *) params[11] )};
data_t data12 = {(uint8_t *) params[12], *( (uint32_t *) params[13] )};
test_decrypt_test_vec( *( (int *) params[0] ), *( (int *) params[1] ), &data2, &data4, &data6, &data8, &data10, &data12, *( (int *) params[14] ), *( (int *) params[15] ) );
}
#if defined(MBEDTLS_CIPHER_AUTH_CRYPT)
void test_auth_crypt_tv( int cipher_id, data_t * key, data_t * iv,
data_t * ad, data_t * cipher, data_t * tag,
char * result, data_t * clear, int use_psa )
{
/*
* Take an AEAD ciphertext + tag and perform a pair
* of AEAD decryption and AEAD encryption. Check that
* this results in the expected plaintext, and that
* decryption and encryption are inverse to one another.
*
* Do that twice:
* - once with legacy functions auth_decrypt/auth_encrypt
* - once with new functions auth_decrypt_ext/auth_encrypt_ext
* This allows testing both without duplicating test cases.
*/
int ret;
int using_nist_kw, using_nist_kw_padding;
mbedtls_cipher_context_t ctx;
size_t outlen;
unsigned char *cipher_plus_tag = NULL;
size_t cipher_plus_tag_len;
unsigned char *decrypt_buf = NULL;
size_t decrypt_buf_len = 0;
unsigned char *encrypt_buf = NULL;
size_t encrypt_buf_len = 0;
#if !defined(MBEDTLS_DEPRECATED_WARNING) && \
!defined(MBEDTLS_DEPRECATED_REMOVED)
unsigned char *tmp_tag = NULL;
unsigned char *tmp_cipher = NULL;
unsigned char *tag_buf = NULL;
#endif /* !MBEDTLS_DEPRECATED_WARNING && !MBEDTLS_DEPRECATED_REMOVED */
/* Null pointers are documented as valid for inputs of length 0.
* The test framework passes non-null pointers, so set them to NULL.
* key, cipher and tag can't be empty. */
if( iv->len == 0 )
iv->x = NULL;
if( ad->len == 0 )
ad->x = NULL;
if( clear->len == 0 )
clear->x = NULL;
mbedtls_cipher_init( &ctx );
/* Initialize PSA Crypto */
#if defined(MBEDTLS_USE_PSA_CRYPTO)
if( use_psa == 1 )
PSA_ASSERT( psa_crypto_init( ) );
#else
(void) use_psa;
#endif
/*
* Are we using NIST_KW? with padding?
*/
using_nist_kw_padding = cipher_id == MBEDTLS_CIPHER_AES_128_KWP ||
cipher_id == MBEDTLS_CIPHER_AES_192_KWP ||
cipher_id == MBEDTLS_CIPHER_AES_256_KWP;
using_nist_kw = cipher_id == MBEDTLS_CIPHER_AES_128_KW ||
cipher_id == MBEDTLS_CIPHER_AES_192_KW ||
cipher_id == MBEDTLS_CIPHER_AES_256_KW ||
using_nist_kw_padding;
/****************************************************************
* *
* Part 1: non-deprecated API *
* *
****************************************************************/
/*
* Prepare context for decryption
*/
if( ! cipher_reset_key( &ctx, cipher_id, use_psa, tag->len, key,
MBEDTLS_DECRYPT ) )
goto exit;
/*
* prepare buffer for decryption
* (we need the tag appended to the ciphertext)
*/
cipher_plus_tag_len = cipher->len + tag->len;
ASSERT_ALLOC( cipher_plus_tag, cipher_plus_tag_len );
memcpy( cipher_plus_tag, cipher->x, cipher->len );
memcpy( cipher_plus_tag + cipher->len, tag->x, tag->len );
/*
* Compute length of output buffer according to the documentation
*/
if( using_nist_kw )
decrypt_buf_len = cipher_plus_tag_len - 8;
else
decrypt_buf_len = cipher_plus_tag_len - tag->len;
/*
* Try decrypting to a buffer that's 1B too small
*/
if( decrypt_buf_len != 0 )
{
ASSERT_ALLOC( decrypt_buf, decrypt_buf_len - 1 );
outlen = 0;
ret = mbedtls_cipher_auth_decrypt_ext( &ctx, iv->x, iv->len,
ad->x, ad->len, cipher_plus_tag, cipher_plus_tag_len,
decrypt_buf, decrypt_buf_len - 1, &outlen, tag->len );
TEST_ASSERT( ret == MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
mbedtls_free( decrypt_buf );
decrypt_buf = NULL;
}
/*
* Authenticate and decrypt, and check result
*/
ASSERT_ALLOC( decrypt_buf, decrypt_buf_len );
outlen = 0;
ret = mbedtls_cipher_auth_decrypt_ext( &ctx, iv->x, iv->len,
ad->x, ad->len, cipher_plus_tag, cipher_plus_tag_len,
decrypt_buf, decrypt_buf_len, &outlen, tag->len );
if( strcmp( result, "FAIL" ) == 0 )
{
TEST_ASSERT( ret == MBEDTLS_ERR_CIPHER_AUTH_FAILED );
TEST_ASSERT( buffer_is_all_zero( decrypt_buf, decrypt_buf_len ) );
}
else
{
TEST_ASSERT( ret == 0 );
ASSERT_COMPARE( decrypt_buf, outlen, clear->x, clear->len );
}
/* Free this, but keep cipher_plus_tag for deprecated function with PSA */
mbedtls_free( decrypt_buf );
decrypt_buf = NULL;
/*
* Encrypt back if test data was authentic
*/
if( strcmp( result, "FAIL" ) != 0 )
{
/* prepare context for encryption */
if( ! cipher_reset_key( &ctx, cipher_id, use_psa, tag->len, key,
MBEDTLS_ENCRYPT ) )
goto exit;
/*
* Compute size of output buffer according to documentation
*/
if( using_nist_kw )
{
encrypt_buf_len = clear->len + 8;
if( using_nist_kw_padding && encrypt_buf_len % 8 != 0 )
encrypt_buf_len += 8 - encrypt_buf_len % 8;
}
else
{
encrypt_buf_len = clear->len + tag->len;
}
/*
* Try encrypting with an output buffer that's 1B too small
*/
ASSERT_ALLOC( encrypt_buf, encrypt_buf_len - 1 );
outlen = 0;
ret = mbedtls_cipher_auth_encrypt_ext( &ctx, iv->x, iv->len,
ad->x, ad->len, clear->x, clear->len,
encrypt_buf, encrypt_buf_len - 1, &outlen, tag->len );
TEST_ASSERT( ret != 0 );
mbedtls_free( encrypt_buf );
encrypt_buf = NULL;
/*
* Encrypt and check the result
*/
ASSERT_ALLOC( encrypt_buf, encrypt_buf_len );
outlen = 0;
ret = mbedtls_cipher_auth_encrypt_ext( &ctx, iv->x, iv->len,
ad->x, ad->len, clear->x, clear->len,
encrypt_buf, encrypt_buf_len, &outlen, tag->len );
TEST_ASSERT( ret == 0 );
TEST_ASSERT( outlen == cipher->len + tag->len );
TEST_ASSERT( timingsafe_bcmp( encrypt_buf, cipher->x, cipher->len ) == 0 );
TEST_ASSERT( timingsafe_bcmp( encrypt_buf + cipher->len,
tag->x, tag->len ) == 0 );
mbedtls_free( encrypt_buf );
encrypt_buf = NULL;
}
/****************************************************************
* *
* Part 2: deprecated API *
* *
****************************************************************/
#if !defined(MBEDTLS_DEPRECATED_WARNING) && \
!defined(MBEDTLS_DEPRECATED_REMOVED)
/*
* Prepare context for decryption
*/
if( ! cipher_reset_key( &ctx, cipher_id, use_psa, tag->len, key,
MBEDTLS_DECRYPT ) )
goto exit;
/*
* Prepare pointers for decryption
*/
#if defined(MBEDTLS_USE_PSA_CRYPTO)
if( use_psa == 1 )
{
/* PSA requires that the tag immediately follows the ciphertext.
* Fortunately, we already have that from testing the new API. */
tmp_cipher = cipher_plus_tag;
tmp_tag = tmp_cipher + cipher->len;
}
else
#endif /* MBEDTLS_USE_PSA_CRYPTO */
{
tmp_cipher = cipher->x;
tmp_tag = tag->x;
}
/*
* Authenticate and decrypt, and check result
*/
ASSERT_ALLOC( decrypt_buf, cipher->len );
outlen = 0;
ret = mbedtls_cipher_auth_decrypt( &ctx, iv->x, iv->len, ad->x, ad->len,
tmp_cipher, cipher->len, decrypt_buf, &outlen,
tmp_tag, tag->len );
if( using_nist_kw )
{
/* NIST_KW with legacy API */
TEST_ASSERT( ret == MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
}
else if( strcmp( result, "FAIL" ) == 0 )
{
/* unauthentic message */
TEST_ASSERT( ret == MBEDTLS_ERR_CIPHER_AUTH_FAILED );
TEST_ASSERT( buffer_is_all_zero( decrypt_buf, cipher->len ) );
}
else
{
/* authentic message: is the plaintext correct? */
TEST_ASSERT( ret == 0 );
ASSERT_COMPARE( decrypt_buf, outlen, clear->x, clear->len );
}
mbedtls_free( decrypt_buf );
decrypt_buf = NULL;
mbedtls_free( cipher_plus_tag );
cipher_plus_tag = NULL;
/*
* Encrypt back if test data was authentic
*/
if( strcmp( result, "FAIL" ) != 0 )
{
/* prepare context for encryption */
if( ! cipher_reset_key( &ctx, cipher_id, use_psa, tag->len, key,
MBEDTLS_ENCRYPT ) )
goto exit;
/* prepare buffers for encryption */
#if defined(MBEDTLS_USE_PSA_CRYPTO)
if( use_psa )
{
ASSERT_ALLOC( cipher_plus_tag, cipher->len + tag->len );
tmp_cipher = cipher_plus_tag;
tmp_tag = cipher_plus_tag + cipher->len;
}
else
#endif /* MBEDTLS_USE_PSA_CRYPTO */
{
ASSERT_ALLOC( encrypt_buf, cipher->len );
ASSERT_ALLOC( tag_buf, tag->len );
tmp_cipher = encrypt_buf;
tmp_tag = tag_buf;
}
/*
* Encrypt and check the result
*/
outlen = 0;
ret = mbedtls_cipher_auth_encrypt( &ctx, iv->x, iv->len, ad->x, ad->len,
clear->x, clear->len, tmp_cipher, &outlen,
tmp_tag, tag->len );
if( using_nist_kw )
{
TEST_ASSERT( ret == MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
}
else
{
TEST_ASSERT( ret == 0 );
TEST_ASSERT( outlen == cipher->len );
if( cipher->len != 0 )
TEST_ASSERT( timingsafe_bcmp( tmp_cipher, cipher->x, cipher->len ) == 0 );
TEST_ASSERT( timingsafe_bcmp( tmp_tag, tag->x, tag->len ) == 0 );
}
}
#endif /* !MBEDTLS_DEPRECATED_WARNING && !MBEDTLS_DEPRECATED_REMOVED */
exit:
mbedtls_cipher_free( &ctx );
mbedtls_free( decrypt_buf );
mbedtls_free( encrypt_buf );
mbedtls_free( cipher_plus_tag );
#if !defined(MBEDTLS_DEPRECATED_WARNING) && \
!defined(MBEDTLS_DEPRECATED_REMOVED)
mbedtls_free( tag_buf );
#endif /* !MBEDTLS_DEPRECATED_WARNING && !MBEDTLS_DEPRECATED_REMOVED */
#if defined(MBEDTLS_USE_PSA_CRYPTO)
if( use_psa == 1 )
PSA_DONE( );
#endif /* MBEDTLS_USE_PSA_CRYPTO */
}
void test_auth_crypt_tv_wrapper( void ** params )
{
data_t data1 = {(uint8_t *) params[1], *( (uint32_t *) params[2] )};
data_t data3 = {(uint8_t *) params[3], *( (uint32_t *) params[4] )};
data_t data5 = {(uint8_t *) params[5], *( (uint32_t *) params[6] )};
data_t data7 = {(uint8_t *) params[7], *( (uint32_t *) params[8] )};
data_t data9 = {(uint8_t *) params[9], *( (uint32_t *) params[10] )};
data_t data12 = {(uint8_t *) params[12], *( (uint32_t *) params[13] )};
test_auth_crypt_tv( *( (int *) params[0] ), &data1, &data3, &data5, &data7, &data9, (char *) params[11], &data12, *( (int *) params[14] ) );
}
#endif /* MBEDTLS_CIPHER_AUTH_CRYPT */
void test_test_vec_ecb( int cipher_id, int operation, data_t * key,
data_t * input, data_t * result, int finish_result
)
{
mbedtls_cipher_context_t ctx;
unsigned char output[32];
size_t outlen;
mbedtls_cipher_init( &ctx );
memset( output, 0x00, sizeof( output ) );
/* Prepare context */
TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx,
mbedtls_cipher_info_from_type( cipher_id ) ) );
TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key->x, 8 * key->len, operation ) );
TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx, input->x,
mbedtls_cipher_get_block_size( &ctx ),
output, &outlen ) );
TEST_ASSERT( outlen == mbedtls_cipher_get_block_size( &ctx ) );
TEST_ASSERT( finish_result == mbedtls_cipher_finish( &ctx, output + outlen,
&outlen ) );
TEST_ASSERT( 0 == outlen );
/* check plaintext only if everything went fine */
if( 0 == finish_result )
TEST_ASSERT( 0 == timingsafe_bcmp( output, result->x,
mbedtls_cipher_get_block_size( &ctx ) ) );
exit:
mbedtls_cipher_free( &ctx );
}
void test_test_vec_ecb_wrapper( void ** params )
{
data_t data2 = {(uint8_t *) params[2], *( (uint32_t *) params[3] )};
data_t data4 = {(uint8_t *) params[4], *( (uint32_t *) params[5] )};
data_t data6 = {(uint8_t *) params[6], *( (uint32_t *) params[7] )};
test_test_vec_ecb( *( (int *) params[0] ), *( (int *) params[1] ), &data2, &data4, &data6, *( (int *) params[8] ) );
}
#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
void test_test_vec_crypt( int cipher_id, int operation, data_t *key,
data_t *iv, data_t *input, data_t *result,
int finish_result, int use_psa )
{
mbedtls_cipher_context_t ctx;
unsigned char output[32];
size_t outlen;
mbedtls_cipher_init( &ctx );
memset( output, 0x00, sizeof( output ) );
/* Prepare context */
#if !defined(MBEDTLS_USE_PSA_CRYPTO)
(void) use_psa;
#else
if( use_psa == 1 )
{
PSA_ASSERT( psa_crypto_init( ) );
TEST_ASSERT( 0 == mbedtls_cipher_setup_psa( &ctx,
mbedtls_cipher_info_from_type( cipher_id ), 0 ) );
}
else
#endif /* MBEDTLS_USE_PSA_CRYPTO */
TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx,
mbedtls_cipher_info_from_type( cipher_id ) ) );
TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key->x, 8 * key->len, operation ) );
if( MBEDTLS_MODE_CBC == ctx.cipher_info->mode )
TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx, MBEDTLS_PADDING_NONE ) );
TEST_ASSERT( finish_result == mbedtls_cipher_crypt( &ctx, iv->len ? iv->x : NULL,
iv->len, input->x, input->len,
output, &outlen ) );
TEST_ASSERT( result->len == outlen );
/* check plaintext only if everything went fine */
if( 0 == finish_result )
TEST_ASSERT( 0 == timingsafe_bcmp( output, result->x, outlen ) );
exit:
mbedtls_cipher_free( &ctx );
#if defined(MBEDTLS_USE_PSA_CRYPTO)
PSA_DONE( );
#endif /* MBEDTLS_USE_PSA_CRYPTO */
}
void test_test_vec_crypt_wrapper( void ** params )
{
data_t data2 = {(uint8_t *) params[2], *( (uint32_t *) params[3] )};
data_t data4 = {(uint8_t *) params[4], *( (uint32_t *) params[5] )};
data_t data6 = {(uint8_t *) params[6], *( (uint32_t *) params[7] )};
data_t data8 = {(uint8_t *) params[8], *( (uint32_t *) params[9] )};
test_test_vec_crypt( *( (int *) params[0] ), *( (int *) params[1] ), &data2, &data4, &data6, &data8, *( (int *) params[10] ), *( (int *) params[11] ) );
}
#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
void test_set_padding( int cipher_id, int pad_mode, int ret )
{
const mbedtls_cipher_info_t *cipher_info;
mbedtls_cipher_context_t ctx;
mbedtls_cipher_init( &ctx );
cipher_info = mbedtls_cipher_info_from_type( cipher_id );
TEST_ASSERT( NULL != cipher_info );
TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx, cipher_info ) );
TEST_ASSERT( ret == mbedtls_cipher_set_padding_mode( &ctx, pad_mode ) );
exit:
mbedtls_cipher_free( &ctx );
}
void test_set_padding_wrapper( void ** params )
{
test_set_padding( *( (int *) params[0] ), *( (int *) params[1] ), *( (int *) params[2] ) );
}
#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
#if defined(MBEDTLS_CIPHER_MODE_CBC)
void test_check_padding( int pad_mode, data_t * input, int ret, int dlen_check
)
{
mbedtls_cipher_info_t cipher_info;
mbedtls_cipher_context_t ctx;
size_t dlen;
/* build a fake context just for getting access to get_padding */
mbedtls_cipher_init( &ctx );
cipher_info.mode = MBEDTLS_MODE_CBC;
ctx.cipher_info = &cipher_info;
TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx, pad_mode ) );
TEST_ASSERT( ret == ctx.get_padding( input->x, input->len, &dlen ) );
if( 0 == ret )
TEST_ASSERT( dlen == (size_t) dlen_check );
exit:
;
}
void test_check_padding_wrapper( void ** params )
{
data_t data1 = {(uint8_t *) params[1], *( (uint32_t *) params[2] )};
test_check_padding( *( (int *) params[0] ), &data1, *( (int *) params[3] ), *( (int *) params[4] ) );
}
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#endif /* MBEDTLS_CIPHER_C */
/*----------------------------------------------------------------------------*/
/* Test dispatch code */
/**
* \brief Evaluates an expression/macro into its literal integer value.
* For optimizing space for embedded targets each expression/macro
* is identified by a unique identifier instead of string literals.
* Identifiers and evaluation code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param exp_id Expression identifier.
* \param out_value Pointer to int to hold the integer.
*
* \return 0 if exp_id is found. 1 otherwise.
*/
int get_expression( int32_t exp_id, int32_t * out_value )
{
int ret = KEY_VALUE_MAPPING_FOUND;
(void) exp_id;
(void) out_value;
switch( exp_id )
{
#if defined(MBEDTLS_CIPHER_C)
case 0:
{
*out_value = MBEDTLS_CIPHER_CHACHA20;
}
break;
case 1:
{
*out_value = -1;
}
break;
#endif
default:
{
ret = KEY_VALUE_MAPPING_NOT_FOUND;
}
break;
}
return( ret );
}
/**
* \brief Checks if the dependency i.e. the compile flag is set.
* For optimizing space for embedded targets each dependency
* is identified by a unique identifier instead of string literals.
* Identifiers and check code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param dep_id Dependency identifier.
*
* \return DEPENDENCY_SUPPORTED if set else DEPENDENCY_NOT_SUPPORTED
*/
int dep_check( int dep_id )
{
int ret = DEPENDENCY_NOT_SUPPORTED;
(void) dep_id;
switch( dep_id )
{
#if defined(MBEDTLS_CIPHER_C)
case 0:
{
#if defined(MBEDTLS_CHACHA20_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
#endif
default:
break;
}
return( ret );
}
/**
* \brief Function pointer type for test function wrappers.
*
* A test function wrapper decodes the parameters and passes them to the
* underlying test function. Both the wrapper and the underlying function
* return void. Test wrappers assume that they are passed a suitable
* parameter array and do not perform any error detection.
*
* \param param_array The array of parameters. Each element is a `void *`
* which the wrapper casts to the correct type and
* dereferences. Each wrapper function hard-codes the
* number and types of the parameters.
*/
typedef void (*TestWrapper_t)( void **param_array );
/**
* \brief Table of test function wrappers. Used by dispatch_test().
* This table is populated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
*/
TestWrapper_t test_funcs[] =
{
/* Function Id: 0 */
#if defined(MBEDTLS_CIPHER_C)
test_mbedtls_cipher_list_wrapper,
#else
NULL,
#endif
/* Function Id: 1 */
#if defined(MBEDTLS_CIPHER_C)
test_cipher_invalid_param_unconditional_wrapper,
#else
NULL,
#endif
/* Function Id: 2 */
#if defined(MBEDTLS_CIPHER_C) && defined(MBEDTLS_CHECK_PARAMS) && !defined(MBEDTLS_PARAM_FAILED_ALT)
test_cipher_invalid_param_conditional_wrapper,
#else
NULL,
#endif
/* Function Id: 3 */
#if defined(MBEDTLS_CIPHER_C) && defined(MBEDTLS_AES_C)
test_cipher_special_behaviours_wrapper,
#else
NULL,
#endif
/* Function Id: 4 */
#if defined(MBEDTLS_CIPHER_C)
test_enc_dec_buf_wrapper,
#else
NULL,
#endif
/* Function Id: 5 */
#if defined(MBEDTLS_CIPHER_C)
test_enc_fail_wrapper,
#else
NULL,
#endif
/* Function Id: 6 */
#if defined(MBEDTLS_CIPHER_C)
test_dec_empty_buf_wrapper,
#else
NULL,
#endif
/* Function Id: 7 */
#if defined(MBEDTLS_CIPHER_C)
test_enc_dec_buf_multipart_wrapper,
#else
NULL,
#endif
/* Function Id: 8 */
#if defined(MBEDTLS_CIPHER_C)
test_decrypt_test_vec_wrapper,
#else
NULL,
#endif
/* Function Id: 9 */
#if defined(MBEDTLS_CIPHER_C) && defined(MBEDTLS_CIPHER_AUTH_CRYPT)
test_auth_crypt_tv_wrapper,
#else
NULL,
#endif
/* Function Id: 10 */
#if defined(MBEDTLS_CIPHER_C)
test_test_vec_ecb_wrapper,
#else
NULL,
#endif
/* Function Id: 11 */
#if defined(MBEDTLS_CIPHER_C) && defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
test_test_vec_crypt_wrapper,
#else
NULL,
#endif
/* Function Id: 12 */
#if defined(MBEDTLS_CIPHER_C) && defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
test_set_padding_wrapper,
#else
NULL,
#endif
/* Function Id: 13 */
#if defined(MBEDTLS_CIPHER_C) && defined(MBEDTLS_CIPHER_MODE_CBC)
test_check_padding_wrapper,
#else
NULL,
#endif
};
/**
* \brief Execute the test function.
*
* This is a wrapper function around the test function execution
* to allow the setjmp() call used to catch any calls to the
* parameter failure callback, to be used. Calls to setjmp()
* can invalidate the state of any local auto variables.
*
* \param fp Function pointer to the test function.
* \param params Parameters to pass to the #TestWrapper_t wrapper function.
*
*/
void execute_function_ptr(TestWrapper_t fp, void **params)
{
#if defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG)
mbedtls_test_enable_insecure_external_rng( );
#endif
#if defined(MBEDTLS_CHECK_PARAMS)
mbedtls_test_param_failed_location_record_t location_record;
if ( setjmp( mbedtls_test_param_failed_get_state_buf( ) ) == 0 )
{
fp( params );
}
else
{
/* Unexpected parameter validation error */
mbedtls_test_param_failed_get_location_record( &location_record );
mbedtls_test_fail( location_record.failure_condition,
location_record.line,
location_record.file );
}
mbedtls_test_param_failed_reset_state( );
#else
fp( params );
#endif
#if defined(MBEDTLS_TEST_MUTEX_USAGE)
mbedtls_test_mutex_usage_check( );
#endif /* MBEDTLS_TEST_MUTEX_USAGE */
}
/**
* \brief Dispatches test functions based on function index.
*
* \param func_idx Test function index.
* \param params The array of parameters to pass to the test function.
* It will be decoded by the #TestWrapper_t wrapper function.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int dispatch_test( size_t func_idx, void ** params )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof( test_funcs ) / sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp )
execute_function_ptr(fp, params);
else
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
/**
* \brief Checks if test function is supported in this build-time
* configuration.
*
* \param func_idx Test function index.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int check_test( size_t func_idx )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof(test_funcs)/sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp == NULL )
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
int main( int argc, const char *argv[] )
{
int ret;
mbedtls_test_platform_setup();
ret = execute_tests( argc, argv, "/zip/third_party/mbedtls/test/test_suite_cipher.chacha20.datax" );
mbedtls_test_platform_teardown();
return( ret );
}
| 71,702 | 2,029 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_ccm.datax | CCM self test
0
CCM - Invalid parameters
8
CCM - Valid parameters
9
CCM init #1 AES-128: OK
depends_on:0
1:exp:0:int:128:int:0
CCM init #2 CAMELLIA-256: OK
depends_on:1
1:exp:1:int:256:int:0
CCM init #3 AES-224: bad key size
depends_on:0
1:exp:0:int:224:exp:2
CCM init #4 BLOWFISH-128: bad block size
depends_on:2
1:exp:3:int:128:exp:2
CCM lengths #1 all OK
2:int:5:int:10:int:5:int:8:int:0
CCM lengths #2 nonce too short
2:int:5:int:6:int:5:int:8:exp:2
CCM lengths #3 nonce too long
2:int:5:int:14:int:5:int:8:exp:2
CCM lengths #4 tag too short
2:int:5:int:10:int:5:int:2:exp:2
CCM lengths #5 tag too long
2:int:5:int:10:int:5:int:18:exp:2
CCM lengths #6 tag length not even
2:int:5:int:10:int:5:int:7:exp:2
CCM lengths #7 AD too long (2^16 - 2^8)
depends_on:3
2:int:5:int:10:int:65280:int:8:exp:2
CCM lengths #8 msg too long for this IV length (2^16, q = 2)
2:int:65536:int:13:int:5:int:8:exp:2
CCM lengths #9 tag length 0
2:int:5:int:10:int:5:int:0:exp:2
CCM lengths #10 Large AD
2:int:5:int:10:int:32768:int:8:int:0
CCM* fixed tag lengths #1 all OK
3:int:5:int:10:int:5:int:8:int:0
CCM* fixed tag lengths #2 all OK - tag length 0
3:int:5:int:10:int:5:int:0:int:0
CCM* encrypt and tag #1
depends_on:0
6:exp:0:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"":hex:"ACDE480000000001":hex:"00000005":int:2:hex:"08D0842143010000000048DEAC020500000055CF000051525354":hex:"223BC1EC841AB553":int:0
CCM* encrypt and tag #2
depends_on:0
6:exp:0:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"61626364":hex:"ACDE480000000001":hex:"00000005":int:4:hex:"69DC842143020000000048DEAC010000000048DEAC0405000000":hex:"D43E022B":int:0
CCM* encrypt and tag #3
depends_on:0
6:exp:0:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"CE":hex:"ACDE480000000001":hex:"00000005":int:6:hex:"2BDC842143020000000048DEACFFFF010000000048DEAC060500000001":hex:"D84FDE529061F9C6F1":int:0
CCM* auth decrypt tag #1
depends_on:0
7:exp:0:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"223BC1EC841AB553":hex:"ACDE480000000001":hex:"00000005":int:2:hex:"08D0842143010000000048DEAC020500000055CF000051525354":hex:"":int:0
CCM* auth decrypt tag #2
depends_on:0
7:exp:0:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"D43E022B":hex:"ACDE480000000001":hex:"00000005":int:4:hex:"69DC842143020000000048DEAC010000000048DEAC0405000000":hex:"61626364":int:0
CCM* auth decrypt tag #3
depends_on:0
7:exp:0:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"D84FDE529061F9C6F1":hex:"ACDE480000000001":hex:"00000005":int:6:hex:"2BDC842143020000000048DEACFFFF010000000048DEAC060500000001":hex:"CE":int:0
CCM encrypt and tag RFC 3610 #1
depends_on:0
4:exp:0:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"08090A0B0C0D0E0F101112131415161718191A1B1C1D1E":hex:"00000003020100A0A1A2A3A4A5":hex:"0001020304050607":hex:"588C979A61C663D2F066D0C2C0F989806D5F6B61DAC38417E8D12CFDF926E0"
CCM encrypt and tag RFC 3610 #2
depends_on:0
4:exp:0:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"08090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F":hex:"00000004030201A0A1A2A3A4A5":hex:"0001020304050607":hex:"72C91A36E135F8CF291CA894085C87E3CC15C439C9E43A3BA091D56E10400916"
CCM encrypt and tag RFC 3610 #3
depends_on:0
4:exp:0:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"08090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F20":hex:"00000005040302A0A1A2A3A4A5":hex:"0001020304050607":hex:"51B1E5F44A197D1DA46B0F8E2D282AE871E838BB64DA8596574ADAA76FBD9FB0C5"
CCM encrypt and tag RFC 3610 #4
depends_on:0
4:exp:0:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"0C0D0E0F101112131415161718191A1B1C1D1E":hex:"00000006050403A0A1A2A3A4A5":hex:"000102030405060708090A0B":hex:"A28C6865939A9A79FAAA5C4C2A9D4A91CDAC8C96C861B9C9E61EF1"
CCM encrypt and tag RFC 3610 #5
depends_on:0
4:exp:0:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"0C0D0E0F101112131415161718191A1B1C1D1E1F":hex:"00000007060504A0A1A2A3A4A5":hex:"000102030405060708090A0B":hex:"DCF1FB7B5D9E23FB9D4E131253658AD86EBDCA3E51E83F077D9C2D93"
CCM encrypt and tag RFC 3610 #6
depends_on:0
4:exp:0:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"0C0D0E0F101112131415161718191A1B1C1D1E1F20":hex:"00000008070605A0A1A2A3A4A5":hex:"000102030405060708090A0B":hex:"6FC1B011F006568B5171A42D953D469B2570A4BD87405A0443AC91CB94"
CCM encrypt and tag RFC 3610 #7
depends_on:0
4:exp:0:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"08090A0B0C0D0E0F101112131415161718191A1B1C1D1E":hex:"00000009080706A0A1A2A3A4A5":hex:"0001020304050607":hex:"0135D1B2C95F41D5D1D4FEC185D166B8094E999DFED96C048C56602C97ACBB7490"
CCM encrypt and tag RFC 3610 #8
depends_on:0
4:exp:0:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"08090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F":hex:"0000000A090807A0A1A2A3A4A5":hex:"0001020304050607":hex:"7B75399AC0831DD2F0BBD75879A2FD8F6CAE6B6CD9B7DB24C17B4433F434963F34B4"
CCM encrypt and tag RFC 3610 #9
depends_on:0
4:exp:0:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"08090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F20":hex:"0000000B0A0908A0A1A2A3A4A5":hex:"0001020304050607":hex:"82531A60CC24945A4B8279181AB5C84DF21CE7F9B73F42E197EA9C07E56B5EB17E5F4E"
CCM encrypt and tag RFC 3610 #10
depends_on:0
4:exp:0:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"0C0D0E0F101112131415161718191A1B1C1D1E":hex:"0000000C0B0A09A0A1A2A3A4A5":hex:"000102030405060708090A0B":hex:"07342594157785152B074098330ABB141B947B566AA9406B4D999988DD"
CCM encrypt and tag RFC 3610 #11
depends_on:0
4:exp:0:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"0C0D0E0F101112131415161718191A1B1C1D1E1F":hex:"0000000D0C0B0AA0A1A2A3A4A5":hex:"000102030405060708090A0B":hex:"676BB20380B0E301E8AB79590A396DA78B834934F53AA2E9107A8B6C022C"
CCM encrypt and tag RFC 3610 #12
depends_on:0
4:exp:0:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"0C0D0E0F101112131415161718191A1B1C1D1E1F20":hex:"0000000E0D0C0BA0A1A2A3A4A5":hex:"000102030405060708090A0B":hex:"C0FFA0D6F05BDB67F24D43A4338D2AA4BED7B20E43CD1AA31662E7AD65D6DB"
CCM encrypt and tag RFC 3610 #13
depends_on:0
4:exp:0:hex:"D7828D13B2B0BDC325A76236DF93CC6B":hex:"08E8CF97D820EA258460E96AD9CF5289054D895CEAC47C":hex:"00412B4EA9CDBE3C9696766CFA":hex:"0BE1A88BACE018B1":hex:"4CB97F86A2A4689A877947AB8091EF5386A6FFBDD080F8E78CF7CB0CDDD7B3"
CCM encrypt and tag RFC 3610 #14
depends_on:0
4:exp:0:hex:"D7828D13B2B0BDC325A76236DF93CC6B":hex:"9020EA6F91BDD85AFA0039BA4BAFF9BFB79C7028949CD0EC":hex:"0033568EF7B2633C9696766CFA":hex:"63018F76DC8A1BCB":hex:"4CCB1E7CA981BEFAA0726C55D378061298C85C92814ABC33C52EE81D7D77C08A"
CCM encrypt and tag RFC 3610 #15
depends_on:0
4:exp:0:hex:"D7828D13B2B0BDC325A76236DF93CC6B":hex:"B916E0EACC1C00D7DCEC68EC0B3BBB1A02DE8A2D1AA346132E":hex:"00103FE41336713C9696766CFA":hex:"AA6CFA36CAE86B40":hex:"B1D23A2220DDC0AC900D9AA03C61FCF4A559A4417767089708A776796EDB723506"
CCM encrypt and tag RFC 3610 #16
depends_on:0
4:exp:0:hex:"D7828D13B2B0BDC325A76236DF93CC6B":hex:"12DAAC5630EFA5396F770CE1A66B21F7B2101C":hex:"00764C63B8058E3C9696766CFA":hex:"D0D0735C531E1BECF049C244":hex:"14D253C3967B70609B7CBB7C499160283245269A6F49975BCADEAF"
CCM encrypt and tag RFC 3610 #17
depends_on:0
4:exp:0:hex:"D7828D13B2B0BDC325A76236DF93CC6B":hex:"E88B6A46C78D63E52EB8C546EFB5DE6F75E9CC0D":hex:"00F8B678094E3B3C9696766CFA":hex:"77B60F011C03E1525899BCAE":hex:"5545FF1A085EE2EFBF52B2E04BEE1E2336C73E3F762C0C7744FE7E3C"
CCM encrypt and tag RFC 3610 #18
depends_on:0
4:exp:0:hex:"D7828D13B2B0BDC325A76236DF93CC6B":hex:"6435ACBAFB11A82E2F071D7CA4A5EBD93A803BA87F":hex:"00D560912D3F703C9696766CFA":hex:"CD9044D2B71FDB8120EA60C0":hex:"009769ECABDF48625594C59251E6035722675E04C847099E5AE0704551"
CCM encrypt and tag RFC 3610 #19
depends_on:0
4:exp:0:hex:"D7828D13B2B0BDC325A76236DF93CC6B":hex:"8A19B950BCF71A018E5E6701C91787659809D67DBEDD18":hex:"0042FFF8F1951C3C9696766CFA":hex:"D85BC7E69F944FB8":hex:"BC218DAA947427B6DB386A99AC1AEF23ADE0B52939CB6A637CF9BEC2408897C6BA"
CCM encrypt and tag RFC 3610 #20
depends_on:0
4:exp:0:hex:"D7828D13B2B0BDC325A76236DF93CC6B":hex:"1761433C37C5A35FC1F39F406302EB907C6163BE38C98437":hex:"00920F40E56CDC3C9696766CFA":hex:"74A0EBC9069F5B37":hex:"5810E6FD25874022E80361A478E3E9CF484AB04F447EFFF6F0A477CC2FC9BF548944"
CCM encrypt and tag RFC 3610 #21
depends_on:0
4:exp:0:hex:"D7828D13B2B0BDC325A76236DF93CC6B":hex:"A434A8E58500C6E41530538862D686EA9E81301B5AE4226BFA":hex:"0027CA0C7120BC3C9696766CFA":hex:"44A3AA3AAE6475CA":hex:"F2BEED7BC5098E83FEB5B31608F8E29C38819A89C8E776F1544D4151A4ED3A8B87B9CE"
CCM encrypt and tag RFC 3610 #22
depends_on:0
4:exp:0:hex:"D7828D13B2B0BDC325A76236DF93CC6B":hex:"B96B49E21D621741632875DB7F6C9243D2D7C2":hex:"005B8CCBCD9AF83C9696766CFA":hex:"EC46BB63B02520C33C49FD70":hex:"31D750A09DA3ED7FDDD49A2032AABF17EC8EBF7D22C8088C666BE5C197"
CCM encrypt and tag RFC 3610 #23
depends_on:0
4:exp:0:hex:"D7828D13B2B0BDC325A76236DF93CC6B":hex:"E2FCFBB880442C731BF95167C8FFD7895E337076":hex:"003EBE94044B9A3C9696766CFA":hex:"47A65AC78B3D594227E85E71":hex:"E882F1DBD38CE3EDA7C23F04DD65071EB41342ACDF7E00DCCEC7AE52987D"
CCM encrypt and tag RFC 3610 #24
depends_on:0
4:exp:0:hex:"D7828D13B2B0BDC325A76236DF93CC6B":hex:"ABF21C0B02FEB88F856DF4A37381BCE3CC128517D4":hex:"008D493B30AE8B3C9696766CFA":hex:"6E37A6EF546D955D34AB6059":hex:"F32905B88A641B04B9C9FFB58CC390900F3DA12AB16DCE9E82EFA16DA62059"
CCM encrypt and tag NIST VTT AES-128 #1 (P=24, N=13, A=32, T=4)
depends_on:0
4:exp:0:hex:"43b1a6bc8d0d22d6d1ca95c18593cca5":hex:"a2b381c7d1545c408fe29817a21dc435a154c87256346b05":hex:"9882578e750b9682c6ca7f8f86":hex:"2084f3861c9ad0ccee7c63a7e05aece5db8b34bd8724cc06b4ca99a7f9c4914f":hex:"cc69ed76985e0ed4c8365a72775e5a19bfccc71aeb116c85a8c74677"
CCM encrypt and tag NIST VTT AES-128 #2 (P=24, N=13, A=32, T=6)
depends_on:0
4:exp:0:hex:"44e89189b815b4649c4e9b38c4275a5a":hex:"8db6ae1eb959963931d1c5224f29ef50019d2b0db7f5f76f":hex:"374c83e94384061ac01963f88d":hex:"cd149d17dba7ec50000b8c5390d114697fafb61025301f4e3eaa9f4535718a08":hex:"df952dce0f843374d33da94c969eff07b7bc2418ca9ee01e32bc2ffa8600"
CCM encrypt and tag NIST VTT AES-128 #3 (P=24, N=13, A=32, T=8)
depends_on:0
4:exp:0:hex:"368f35a1f80eaaacd6bb136609389727":hex:"1cccd55825316a94c5979e049310d1d717cdfb7624289dac":hex:"842a8445847502ea77363a16b6":hex:"34396dfcfa6f742aea7040976bd596497a7a6fa4fb85ee8e4ca394d02095b7bf":hex:"1a58094f0e8c6035a5584bfa8d1009c5f78fd2ca487ff222f6d1d897d6051618"
CCM encrypt and tag NIST VTT AES-128 #4 (P=24, N=13, A=32, T=10)
depends_on:0
4:exp:0:hex:"996a09a652fa6c82eae8be7886d7e75e":hex:"84cdd7380f47524b86168ed95386faa402831f22045183d0":hex:"a8b3eb68f205a46d8f632c3367":hex:"c71620d0477c8137b77ec5c72ced4df3a1e987fd9af6b5b10853f0526d876cd5":hex:"a7fbf9dd1b099ed3acf6bcbd0b6f7cae57bee99f9d084f826d86e69c07f053d1a607"
CCM encrypt and tag NIST VTT AES-128 #5 (P=24, N=13, A=32, T=12)
depends_on:0
4:exp:0:hex:"3ee186594f110fb788a8bf8aa8be5d4a":hex:"d71864877f2578db092daba2d6a1f9f4698a9c356c7830a1":hex:"44f705d52acf27b7f17196aa9b":hex:"2c16724296ff85e079627be3053ea95adf35722c21886baba343bd6c79b5cb57":hex:"b4dd74e7a0cc51aea45dfb401a41d5822c96901a83247ea0d6965f5aa6e31302a9cc2b36"
CCM encrypt and tag NIST VTT AES-128 #6 (P=24, N=13, A=32, T=14)
depends_on:0
4:exp:0:hex:"7b2d52a5186d912cf6b83ace7740ceda":hex:"ea384b081f60bb450808e0c20dc2914ae14a320612c3e1e8":hex:"f47be3a2b019d1beededf5b80c":hex:"76cf3522aff97a44b4edd0eef3b81e3ab3cd1ccc93a767a133afd508315f05ed":hex:"79070f33114a980dfd48215051e224dfd01471ac293242afddb36e37da1ee8a88a77d7f12cc6"
CCM encrypt and tag NIST VTT AES-128 #7 (P=24, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"4189351b5caea375a0299e81c621bf43":hex:"4535d12b4377928a7c0a61c9f825a48671ea05910748c8ef":hex:"48c0906930561e0ab0ef4cd972":hex:"40a27c1d1e23ea3dbe8056b2774861a4a201cce49f19997d19206d8c8a343951":hex:"26c56961c035a7e452cce61bc6ee220d77b3f94d18fd10b6d80e8bf80f4a46cab06d4313f0db9be9"
CCM encrypt and tag NIST VTT AES-192 #1 (P=24, N=13, A=32, T=4)
depends_on:0
4:exp:0:hex:"11fd45743d946e6d37341fec49947e8c70482494a8f07fcc":hex:"ee7e6075ba52846de5d6254959a18affc4faf59c8ef63489":hex:"c6aeebcb146cfafaae66f78aab":hex:"7dc8c52144a7cb65b3e5a846e8fd7eae37bf6996c299b56e49144ebf43a1770f":hex:"137d9da59baf5cbfd46620c5f298fc766de10ac68e774edf1f2c5bad"
CCM encrypt and tag NIST VTT AES-192 #2 (P=24, N=13, A=32, T=6)
depends_on:0
4:exp:0:hex:"146a163bbf10746e7c1201546ba46de769be23f9d7cc2c80":hex:"473b6600559aefb67f7976f0a5cc744fb456efd86f615648":hex:"f5827e51707d8d64bb522985bb":hex:"599b12ebd3347a5ad098772c44c49eed954ec27c3ba6206d899ddaabca23a762":hex:"26d2be30e171439d54a0fec291c6024d1de09d61b44f53258ba1360406f9"
CCM encrypt and tag NIST VTT AES-192 #3 (P=24, N=13, A=32, T=8)
depends_on:0
4:exp:0:hex:"bdf277af2226f03ec1a0ba7a8532ade6aea9b3d519fe2d38":hex:"0ff89eff92a530b66684cd75a39481e7e069a7d05e89b692":hex:"cc3c596be884e7caed503315c0":hex:"4d6546167b3ed55f01c62bd384e02e1039c0d67ef7abe33291fecb136272f73b":hex:"6ef66a52c866bd5df20ec5096de92167ad83cab0e095ad0c778a299f1224f10c"
CCM encrypt and tag NIST VTT AES-192 #4 (P=24, N=13, A=32, T=10)
depends_on:0
4:exp:0:hex:"62f8eba1c2c5f66215493a6fa6ae007aae5be92f7880336a":hex:"f5522e3405d9b77cbf3257db2b9675e618e8744a0ee03f0f":hex:"15769753f503aa324f4b0e8ee0":hex:"1bc05440ee3e34d0f25e90ca1ecbb555d0fb92b311621d171be6f2b719923d23":hex:"b9103942dbbb93e15086751c9bb0a3d33112b55f95b7d4f32ff0bb90a8879812683f"
CCM encrypt and tag NIST VTT AES-192 #5 (P=24, N=13, A=32, T=12)
depends_on:0
4:exp:0:hex:"5a5667197f46b8027980d0a3166c0a419713d4df0629a860":hex:"d0e4024d6e33daafc011fe463545ed20f172872f6f33cefa":hex:"6236b01079d180fce156fbaab4":hex:"29bdf65b29394d363d5243d4249bad087520f8d733a763daa1356be458d487e5":hex:"479f3d408bfa00d1cd1c8bf11a167ce7ae4bcdb011f04e38733013b8ebe5e92b1917640c"
CCM encrypt and tag NIST VTT AES-192 #6 (P=24, N=13, A=32, T=14)
depends_on:0
4:exp:0:hex:"d2d4482ea8e98c1cf309671895a16610152ce283434bca38":hex:"78168e5cc3cddf4b90d5bc11613465030903e0196f1fe443":hex:"6ee177d48f59bd37045ec03731":hex:"9ef2d0d556d05cf9d1ee9dab9b322a389c75cd4e9dee2c0d08eea961efce8690":hex:"e2324a6d5643dfc8aea8c08cbbc245494a3dcbcb800c797c3abcdb0563978785bf7fd71c6c1f"
CCM encrypt and tag NIST VTT AES-192 #7 (P=24, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"a7177fd129674c6c91c1c89f4408139afe187026b8114893":hex:"2cea0f7304860a4f40a28c8b890db60f3891b9982478495e":hex:"31bb28f0e1e63c36ca3959dd18":hex:"2529a834668187213f5342a1f3deea0dc2765478c7d71c9c21b9eb1351a5f6cb":hex:"5bb7aa6ab9c02a5712d62343fbe61f774e598d6b87545612380ea23dcffc9574f672bca92e306411"
CCM encrypt and tag NIST VTT AES-256 #1 (P=24, N=13, A=32, T=4)
depends_on:0
4:exp:0:hex:"9074b1ae4ca3342fe5bf6f14bcf2f27904f0b15179d95a654f61e699692e6f71":hex:"239029f150bccbd67edbb67f8ae456b4ea066a4beee065f9":hex:"2e1e0132468500d4bd47862563":hex:"3c5f5404370abdcb1edde99de60d0682c600b034e063b7d3237723da70ab7552":hex:"9c8d5dd227fd9f81237601830afee4f0115636c8e5d5fd743cb9afed"
CCM encrypt and tag NIST VTT AES-256 #2 (P=24, N=13, A=32, T=6)
depends_on:0
4:exp:0:hex:"8596a69890b0e47d43aeeca54b52029331da06fae63aa3249faaca94e2605feb":hex:"f0b065da6ecb9ddcab855152d3b4155037adfa758ba96070":hex:"20442e1c3f3c88919c39978b78":hex:"4e0d3aa502bd03fe1761b167c4e0df1d228301d3ebaa4a0281becd813266e255":hex:"d6a0f377f7c1b14dcdba729cae5271b027e71cc7850173ec265867a29eb3"
CCM encrypt and tag NIST VTT AES-256 #3 (P=24, N=13, A=32, T=8)
depends_on:0
4:exp:0:hex:"bae73483de27b581a7c13f178a6d7bda168c1b4a1cb9180512a13e3ab914eb61":hex:"28ef408d57930086011b167ac04b866e5b58fe6690a0b9c3":hex:"daf54faef6e4fc7867624b76f2":hex:"7022eaa52c9da821da72d2edd98f6b91dfe474999b75b34699aeb38465f70c1c":hex:"356367c6cee4453658418d9517f7c6faddcd7c65aef460138cf050f48c505151"
CCM encrypt and tag NIST VTT AES-256 #4 (P=24, N=13, A=32, T=10)
depends_on:0
4:exp:0:hex:"d5b321b0ac2fedce0933d57d12195c7b9941f4caa95529125ed21c41fac43374":hex:"6aa6ea668df60b0db85592d0a819c9df9e1099916272aafb":hex:"b35fb2262edfa14938a0fba03e":hex:"ba762bbda601d711e2dfc9dbe3003d39df1043ca845612b8e9dc9ff5c5d06ec4":hex:"97027de5effd82c58f8dbfb909d7696fbe2d54916262912001a4d765bc1c95c90a95"
CCM encrypt and tag NIST VTT AES-256 #5 (P=24, N=13, A=32, T=12)
depends_on:0
4:exp:0:hex:"7f4af6765cad1d511db07e33aaafd57646ec279db629048aa6770af24849aa0d":hex:"7ebef26bf4ecf6f0ebb2eb860edbf900f27b75b4a6340fdb":hex:"dde2a362ce81b2b6913abc3095":hex:"404f5df97ece7431987bc098cce994fc3c063b519ffa47b0365226a0015ef695":hex:"353022db9c568bd7183a13c40b1ba30fcc768c54264aa2cd2927a053c9244d3217a7ad05"
CCM encrypt and tag NIST VTT AES-256 #6 (P=24, N=13, A=32, T=14)
depends_on:0
4:exp:0:hex:"5c8b59d3e7986c277d5ad51e4a2233251076809ebf59463f47cd10b4aa951f8c":hex:"138ee53b1914d3322c2dd0a4e02faab2236555131d5eea08":hex:"21ff892b743d661189e205c7f3":hex:"f1e0af185180d2eb63e50e37ba692647cac2c6a149d70c81dbd34685ed78feaa":hex:"5b2f3026f30fdd50accc40ddd093b7997f23d7c6d3c8bc425f82c828413643b8794494cb5236"
CCM encrypt and tag NIST VTT AES-256 #7 (P=24, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"60823b64e0b2da3a7eb772bd5941c534e6ff94ea96b564e2b38f82c78bb54522":hex:"a8be794613835c4366e75817d228438f011a2ec8a86f9797":hex:"48526f1bffc97dd65e42906983":hex:"fab62b3e5deda7a9c1128663cc81c44b74ab1bfe70bc1c9dec7c7fd08173b80a":hex:"cc3efe04d84a4ec5cb6a6c28dc2c2d386a359d9550dbdec963ddd56464aed6d0613159d1aa181dcb"
CCM encrypt and tag NIST VPT AES-128 #1 (P=0, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"2ebf60f0969013a54a3dedb19d20f6c8":hex:"":hex:"1de8c5e21f9db33123ff870add":hex:"e1de6c6119d7db471136285d10b47a450221b16978569190ef6a22b055295603":hex:"0ead29ef205fbb86d11abe5ed704b880"
CCM encrypt and tag NIST VPT AES-128 #2 (P=1, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"6ae7a8e907b8720f4b0d5507c1d0dc41":hex:"0e":hex:"7f18ad442e536a0159e7aa8c0f":hex:"9c9b0f11e020c6512a63dfa1a5ec8df8bd8e2ad83cf87b80b38635621c5dc0d7":hex:"4c201784bdab19e255787fecd02000c49d"
CCM encrypt and tag NIST VPT AES-128 #3 (P=2, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"3d746ae6cac5cefd01f021c0bbf4bc3c":hex:"4360":hex:"597b3614ff9cd567afd1aad4e5":hex:"90446190e1ff5e48e8a09d692b217de3ad0ab4a670e7f1b437f9c07a902cad60":hex:"e38fdb77c1f8bbac2903a2ec7bc0f9c5654d"
CCM encrypt and tag NIST VPT AES-128 #4 (P=3, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"3e4fa1c6f8b00f1296956735ee86e310":hex:"3a6734":hex:"c6a170936568651020edfe15df":hex:"00d57896da2435a4271afb9c98f61a650e63a4955357c47d073c5165dd4ea318":hex:"384be657bfc5f385b179be7333eb3f57df546b"
CCM encrypt and tag NIST VPT AES-128 #5 (P=4, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"7ccbb8557f6e08f436d0957d4bbe7fdf":hex:"4cabeb02":hex:"bb8e2ef2ed9484f9021cda7073":hex:"fba1d18a74a3bb38671ab2842ffaa434cd572a0b45320e4145930b3008d8d350":hex:"32501f4235c4dd96e83d5ab4c3c31c523453c317"
CCM encrypt and tag NIST VPT AES-128 #6 (P=5, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"3725c7905bfaca415908c617b78f8dee":hex:"f5499a7082":hex:"c98ec4473e051a4d4ac56fd082":hex:"11bc87f1c2d2076ba47c5cb530dd6c2a224f7a0f7f554e23d7d29077c7787680":hex:"e378b776242066751af249d521c6eaebdff40b2642"
CCM encrypt and tag NIST VPT AES-128 #7 (P=6, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"80bead98a05d1bb173cd4fca463b8fa3":hex:"e479990bf082":hex:"8a14a6d255aa4032ebff37a3d7":hex:"bb4e706e73d21df66f64173859d47e247527cd9832e20dccff8548ed5f554108":hex:"89c9246238878427f36b1f6c633e4542f32b50ca8edb"
CCM encrypt and tag NIST VPT AES-128 #8 (P=7, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"dc8ec91184ba18eae31ac2d3b252673f":hex:"2a5775986551c8":hex:"0da4c988f521f5648259f2bec2":hex:"6d5573c9279897d7d1602d8a95c04bb5ca3fad2dbe89a024b3651eb227e73bb5":hex:"4f259f2a718faea852a7c4358dfa9f5467357638acac90"
CCM encrypt and tag NIST VPT AES-128 #9 (P=8, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"19f97ef5318b8005fc7133fa31dd1236":hex:"6d972a673fbe1ca1":hex:"01ce9814c6329dbee1d02b1321":hex:"85853f120981f33cf1d50fde6b8bc865fe988a9f12579acdb336f9f992b08b89":hex:"2f12a7e7acecae5d2563309efc19368cdee8266538ca89d3"
CCM encrypt and tag NIST VPT AES-128 #10 (P=9, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"c17944bfaeeb808eed66ae7242ab545f":hex:"7caae2640e734539d3":hex:"910b3db64df3728ca98219e01b":hex:"edf64f98b3ab593cbcf68ab37a8c9472e49cb849d4a744deae925a5a43faf262":hex:"0dae8b3ccf0b439f6ff8ee4a233dfb7753f6bfe321b3e26959"
CCM encrypt and tag NIST VPT AES-128 #11 (P=10, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"0fb9df6f638847f5de371f003dd938f4":hex:"e10cc36bc1c5d3c646ab":hex:"c9ddf61c052f3502ad6b229819":hex:"4f9938d5bc3dcbe47f6b256d5e99723d0891e50c6175aba41b011e4686113c49":hex:"7f797367de50be6dc04e4cf0d8c24189affd35060cb7ca3dd136"
CCM encrypt and tag NIST VPT AES-128 #12 (P=11, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"006ff7d3153caf906ec7929f5aef9276":hex:"31be1b241cae79c54c2446":hex:"57db1541a185bd9cdc34d62025":hex:"7d9681cac38e778fba11f4464f69ed9ebfea31b7ffcaf2925b3381c65d975974":hex:"9dd8a4244fbdb30b624578a625c43233476bbb959acd9edebe2883"
CCM encrypt and tag NIST VPT AES-128 #13 (P=12, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"026331e98aba9e8c23a9e8a91d0b0c97":hex:"a82200ef3a08c390dec5cbf9":hex:"bccfe69bba168b81cbdf7d018a":hex:"26e011143a686a7224ddb8c5b1e5d31713fa22c386785e2c34f498ae56d07ed5":hex:"adf4fc6f9be113066c09248fcb56a9c1a1c3bb16fbb9fbaedacdb12b"
CCM encrypt and tag NIST VPT AES-128 #14 (P=13, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"d32088d50df9aba14d9022c870a0cb85":hex:"4b10788c1a03bca656f04f1f98":hex:"e16c69861efc206e85aab1255e":hex:"0eff7d7bcceb873c3203a8df74f4e91b04bd607ec11202f96cfeb99f5bcdb7aa":hex:"89f15b1cb665a8851da03b874ca6f73242f2f227350c0277e4e72cdaa6"
CCM encrypt and tag NIST VPT AES-128 #15 (P=14, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"7301c907b9d2aaac355c5416ff25c59b":hex:"484300aa3a506afcd313b49ead8d":hex:"7304b65b6dab466273862c88b9":hex:"2c5d114eff62c527cc2e03c33c595a80fe609bfc0fe13ce3380efe05d85cceac":hex:"928ca58b0d373dc50c52afac787ce8eeb5d5b493661259a9d91ea31a5f7e"
CCM encrypt and tag NIST VPT AES-128 #16 (P=15, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"38be46d271bf868c198052391f8a2147":hex:"61bd1385be92097e866550a55278f0":hex:"6758f67db9bfea5f0e0972e08b":hex:"c6de3be97f11d0e2ab85c9353b783f25b37366a78a2012cecf5b7a87138b3c86":hex:"7c9fa8d99b38f825315ece6a2613f55e902f296dcce870263ae50cda4fadae"
CCM encrypt and tag NIST VPT AES-128 #17 (P=16, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"70010ed90e6186ecad41f0d3c7c42ff8":hex:"be322f58efa7f8c68a635e0b9cce77f2":hex:"a5f4f4986e98472965f5abcc4b":hex:"3fec0e5cc24d67139437cbc8112414fc8daccd1a94b49a4c76e2d39303547317":hex:"8e4425ae573974f0f0693a188b525812eef08e3fb15f4227e0d989a4d587a8cf"
CCM encrypt and tag NIST VPT AES-128 #18 (P=17, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"79eae5baddc5887bdf3031fd1d65085b":hex:"001343e6191f5f1738e7d19d4eec2b9592":hex:"9da59614535d1fad35f2ece00f":hex:"46603500af9e4e7a2f9545411a58b21a6efd21f2b5f315d02d964c09270145b3":hex:"2162e27bfbf1d00f2404754a254665fd9270f0edb415993588b2535e2e0e4fd086"
CCM encrypt and tag NIST VPT AES-128 #19 (P=18, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"c14eda0f958465246fe6ab541e5dfd75":hex:"617868ae91f705c6b583b5fd7e1e4086a1bb":hex:"32b63ca7e269223f80a56baaaa":hex:"733f8e7670de3446016916510dfe722ce671570121d91331a64feb3d03f210e6":hex:"b2dc1e548b3d3f225a34082f4391980a0788b4cc36852fd64a423fb8e872252b248e"
CCM encrypt and tag NIST VPT AES-128 #20 (P=19, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"c5e7147f56ba4530b8799ababeb82772":hex:"2f3bf0b566440912a1e47a0c07f1cfd39cb440":hex:"bdd38e173fb20b981659c597d6":hex:"3a069a2bfda44abbb0a82a97e5e9047258c803da2c66190d77149e0f010b3af9":hex:"bd6265dcba9e14c59e515e395dc60bd053345fa6d7568c738e3a7fdf142d8f2d1562c0"
CCM encrypt and tag NIST VPT AES-128 #21 (P=20, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"78c46e3249ca28e1ef0531d80fd37c12":hex:"4802422c9b3b4459ba26e7863ad87b0c172cfe4b":hex:"5de41a86ce3f3fb1b685b3ca4d":hex:"e98a77f2a941b36232589486b05f4278275588665a06d98aec98915cc5607e06":hex:"daea2234ea433533bf0716abe1aa3844b6d3c51e9d5ca3d8ec5065630d2de0717cdeb7d5"
CCM encrypt and tag NIST VPT AES-128 #22 (P=21, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"8883002bf13b3a94b2467225970df938":hex:"d516bbff452e7706c91c7ace3e9baa76d65ff7050f":hex:"818a702d5c8ee973b34e9acda1":hex:"545aeac737c0ca2a3d5e1fd966840c3a0d71e0301abbe99c7af18d24cc7e9633":hex:"b85242fdc06344f2bd9a97b408902ebcd22aece3d42f2da4dd4d817c9fa2d44bc02163a0a9"
CCM encrypt and tag NIST VPT AES-128 #23 (P=22, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"5cea00ee44cfb9cfbb598d3812e380ef":hex:"33bfd0713f30fcac8f7f95920ac6d9b803ddd5480dd8":hex:"948788a9c8188cb988430a7ebd":hex:"50422c5e6a0fb8231b3bb6e2f89607019be6ad92a4dae8e0fe3f9e486476004b":hex:"b168747dea3ae0fbede4402af9a3dc3185d6d162f859d828101682de32923788c70262b84814"
CCM encrypt and tag NIST VPT AES-128 #24 (P=23, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"cb83f77751e72711401cbbf4f61aa0ed":hex:"eede01b08f9a303cdf14c99d7a45732972c6eff2a1db06":hex:"c0b461b2e15b8b116ef9281704":hex:"2bd112231f903fa0dff085db48a2e2a96ec0199249b005d5ab4c2eab753f9ad0":hex:"feb114b7bd3b43497b62454a675a632c3546d2802462c6af57647efda119c59862cd5dd3904efc"
CCM encrypt and tag NIST VPT AES-128 #25 (P=24, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"43c1142877d9f450e12d7b6db47a85ba":hex:"b506a6ba900c1147c806775324b36eb376aa01d4c3eef6f5":hex:"76becd9d27ca8a026215f32712":hex:"6a59aacadd416e465264c15e1a1e9bfa084687492710f9bda832e2571e468224":hex:"14b14fe5b317411392861638ec383ae40ba95fefe34255dc2ec067887114bc370281de6f00836ce4"
CCM encrypt and tag NIST VPT AES-192 #1 (P=0, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"086e2967cde99e90faaea8a94e168bf0e066c503a849a9f3":hex:"":hex:"929542cd690f1babcf1696cb03":hex:"58f70bab24e0a6137e5cd3eb18656f2b5ccddc3f538a0000c65190e4a3668e71":hex:"3bf9d93af6ffac9ac84cd3202d4e0cc8"
CCM encrypt and tag NIST VPT AES-192 #2 (P=1, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"992d38768b11a236945bd4b327c3728fac24c091238b6553":hex:"1c":hex:"b248a90b84b0122a5ad8e12760":hex:"27cabc40da0e1eda0ea5f8abbb7c179e30776250a7b30d711b0e106c5ee9d84a":hex:"1a96f58c3f38c44d1a345f3e2da6679f20"
CCM encrypt and tag NIST VPT AES-192 #3 (P=2, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"5012db40ff6ae23c1e1ce43768c5936c4400b0e79ae77f30":hex:"0c6c":hex:"b67e500b35d60ad7264240027c":hex:"40affd355416200191ba64edec8d7d27ead235a7b2e01a12662273deb36379b8":hex:"c996ef3d6ef9f981557506ecc8797bbaaaa7"
CCM encrypt and tag NIST VPT AES-192 #4 (P=3, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"fa15cc7f0de294d7341b1fd79326c8be78e67822343c1992":hex:"bcb898":hex:"e5257aed2bda0495aa44591db4":hex:"31a0338c3839931fa1dd5131cb796c4c6cfde9fb336d8a80ac35dec463be7a94":hex:"68f08298d9a2147776dca9c1a42382bce323b2"
CCM encrypt and tag NIST VPT AES-192 #5 (P=4, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"b5330a8447d74a7987fb718cfae246b5c7e057991064eeaf":hex:"b46b343e":hex:"2ef29d62b40d8643848797cde8":hex:"1225b036e6044df52314016760e92750de0936120395de750a2c54a7fa0cea82":hex:"c2c39d6f9344e2de064f269d065a2a6108605916"
CCM encrypt and tag NIST VPT AES-192 #6 (P=5, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"30419145ae966591b408c29e5fd14d9112542909be5363f7":hex:"8ceaeb89fd":hex:"27e6b2a482bbc6f13702005708":hex:"e04e81e860daf9696098c723085d8023c240ebe7a643131e35359ab04bd650fe":hex:"ec9d5ed36243ddf77b33d8cf2963ba76fd4e19f3c5"
CCM encrypt and tag NIST VPT AES-192 #7 (P=6, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"748ad503388a34041a7bdae6361d57894357c333bacf02ca":hex:"24d6880aed7e":hex:"518b79d194579b19f2d8845b70":hex:"691dd98f61fd213b0840ec5a6f06ef9a1420be0d59bde5e43546347a2a865a94":hex:"270120f9634ec15536e21d961c675070ec4cff9037bc"
CCM encrypt and tag NIST VPT AES-192 #8 (P=7, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"b930cca30a3fd230c237c8f3cc6792d0c4084dff5c18d775":hex:"2a755e362373ef":hex:"7574802fd82fe96c05431acd40":hex:"1cf83928b6a9e525fe578c5c0f40c322be71b3092239bff954dd6883738d6d71":hex:"f06238b0450fd1f4b6cab1383adb420c4724aa7bdfefb7"
CCM encrypt and tag NIST VPT AES-192 #9 (P=8, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"314c136999e41d137bd7ba17201a9fa406025868334e39b3":hex:"4d54d8b06b204445":hex:"65f7a0f4c0f5bba9d26f7e0ddb":hex:"5c7ce4819b30b975ae6ce58dcc1bfa29a8b6dda8f4b76c7e23516487745e829c":hex:"2baf90c490b11f9607482362ab3f157c42d0e9c6c5cffcf0"
CCM encrypt and tag NIST VPT AES-192 #10 (P=9, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"a19f6be062ec0aaf33046bd52734f3336c85d8368bef86ab":hex:"13511ae5ff6c6860a1":hex:"7f2d07f8169c5672b4df7f6cac":hex:"d68d5f763db6111c5d6324d694cb0236beab877daae8115ecb75d60530777b58":hex:"b3859b757802ebd048467fd8e139eb9ee8fcdca45ed87dc1c8"
CCM encrypt and tag NIST VPT AES-192 #11 (P=10, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"de1c8263345081d2dfa9afdf37675971135e178df554a4d8":hex:"f777aba1fa70f94e6de9":hex:"a301bb82f91a582db01355c388":hex:"9ad52c041390d0d4aaf65a4667c3239c95e7eae6178acc23fb4e70a852d483c6":hex:"9d8bff6d2dcde77104ac6aba025abc01416a7ca9f096ab2529cb"
CCM encrypt and tag NIST VPT AES-192 #12 (P=11, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"248d36bd15f58e47fcf1c948272355821f8492e6e69f3661":hex:"33709d9c7906e2f82dd9e2":hex:"9e8d492c304cf6ad59102bca0e":hex:"9ec08c7ed6b70823d819e9ab019e9929249f966fdb2069311a0ddc680ac468f5":hex:"9114d36b79b1918b2720f40cddce66df9b4802f737bea4bd8f5378"
CCM encrypt and tag NIST VPT AES-192 #13 (P=12, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"77a67fb504b961028633321111aac2c30eb6d71a8cf72056":hex:"10554c062d269ff6dcd98493":hex:"acadc0330194906f8c75ac287f":hex:"8c18486d52571f70f2ba6a747aaa3d4b3ebc2e481ee1b70907dddb94bdfa0ca6":hex:"7f8b0cad79b545e5addf0b04ff4b0f2b2a5067283210aba8630d0306"
CCM encrypt and tag NIST VPT AES-192 #14 (P=13, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"0d423519e4110c06063061323f8c7c95387776b6ee4e4b6e":hex:"4021ff104ff1dbd91e46db249f":hex:"39abe53826d9b8e300fe747533":hex:"cdd9bf1b4f865e922c678ec4947ea0cb02e78bd5c1538f33aeb818ad3f47e519":hex:"7953d3cd66d093785d123f65ba37f16761dd6aedbfc789ad96edf1490d"
CCM encrypt and tag NIST VPT AES-192 #15 (P=14, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"a60cf7ceb62bf3118532bc61daa25ce946991047f951b536":hex:"d64f9426febce6a84c954dd5ded5":hex:"7499494faa44a7576f9ed5580d":hex:"baa482c64eefd09118549a8968f44cfea7a436913a428e30aa4ab44802a4ba35":hex:"f7580f17266d68237747bf57c7ed8242ac1a1979c5a9e7bc67d7698c7efa"
CCM encrypt and tag NIST VPT AES-192 #16 (P=15, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"82d4bc9aac298b09112073277205e1bf42176d1e6339b76c":hex:"25a53fd3e476dc0860eeeea25fcb0c":hex:"70325ef19e581b743095cd5eb1":hex:"6d14bb2635c5d0ae83687f1824279cf141173527e1b32d1baf8a27f7fe34a542":hex:"4a1cfd0023557a184b929965b0a445cb3993ca35acf354cb2b4254ff672e7f"
CCM encrypt and tag NIST VPT AES-192 #17 (P=16, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"6873f1c6c30975aff6f08470264321130a6e5984ade324e9":hex:"5051a0b0b6766cd6ea29a672769d40fe":hex:"7c4d2f7cec04361f187f0726d5":hex:"77743b5d83a00d2c8d5f7e10781531b496e09f3bc9295d7ae9799e64668ef8c5":hex:"0ce5ac8d6b256fb7580bf6acc76426af40bce58fd4cd6548df90a0337c842004"
CCM encrypt and tag NIST VPT AES-192 #18 (P=17, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"3cf8da27d5be1af024158985f725fd7a6242cbe0041f2c17":hex:"f6dd2c64bf597e63263ccae1c54e0805fe":hex:"07f77f114d7264a122a7e9db4f":hex:"30457e99616f0247f1339b101974ea231904d0ef7bd0d5ee9b57c6c16761a282":hex:"ce3031c3a70600e9340b2ddfe56aa72cffdc5e53e68c51ee55b276eb3f85d2cf63"
CCM encrypt and tag NIST VPT AES-192 #19 (P=18, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"b46a3a24c66eb846ca6413c001153dc6998970c12e7acd5a":hex:"56d18d3e2e496440d0a5c9e1bcb464faf5bc":hex:"b79c33c96a0a90030694163e2a":hex:"ea9405d6a46cac9783a7b48ac2e25cc9a3a519c4658b2a8770a37240d41587fb":hex:"01baba2e0d5b49d600d03a7ed84ee878926c0ca478f40a6fbde01f584d938a1c91bf"
CCM encrypt and tag NIST VPT AES-192 #20 (P=19, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"7b71045ccef735bd0c5bea3cf3b7e16e58d9c62061a204e0":hex:"890d05420d57e3b3d8dbef117fe60c3fa6a095":hex:"2b9ecfd179242c295fe6c6fa55":hex:"b89166f97deb9cc7fdeb63639eeafb145895b307749ec1a293b27115f3aa8232":hex:"f842ff6662684de8785af275fa2d82d587de0687ebe35e883cbd53b82f2a4624c03894"
CCM encrypt and tag NIST VPT AES-192 #21 (P=20, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"dc7c67715f2709e150cceff020aaacf88a1e7568191acbcf":hex:"f383bd3e6270876b74abbb5d35e7d4f11d83412c":hex:"da56ea046990c70fa216e5e6c4":hex:"f799818d91be7bab555a2e39f1f45810a94d07179f94fe1151d95ab963c47611":hex:"377b5df263c5c74f63603692cbb61ea37b6d686c743f71e15490ca41d245768988719ede"
CCM encrypt and tag NIST VPT AES-192 #22 (P=21, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"f41e369a1599627e76983e9a4fc2e963dab4960b09ebe390":hex:"81ad3f386bedcbf656ff535c63580d1f87e3c72326":hex:"68ef8285b90f28bcd3cb1bacea":hex:"dbe3e82e49624d968f5463ceb8af189fb3ad8b3b4122142b110d848a286dae71":hex:"9f6028153e06d14d30b862a99a35413413c04a49dc6f68a03a11cf00d58f062a7b36465d13"
CCM encrypt and tag NIST VPT AES-192 #23 (P=22, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"3289e59e3a7b29bf4a309afc253030bba4b9bdd64f0722f9":hex:"53911a67b65738f87fc7c20d6db8044bde1af95838d1":hex:"30259ce106e9bd7a8bacbaf212":hex:"2870bd9a26c510e9a256920899bbc77a4eb9b53f927045a943d5ed6b13638cf3":hex:"70cf37d4b6f7e707376b1574ce17c040b5143da47abb2fe9afafc2fccd98ccf63b0fdec30eac"
CCM encrypt and tag NIST VPT AES-192 #24 (P=23, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"40f1aff2e44d05f12126097a0f07ac0359ba1a609356a4e6":hex:"8d98c580fb366f330dbfda20f91d99a0878b47efd14c6d":hex:"0df3fc6396f851785fca9aa5ff":hex:"e9699b20b0574fce8b5cbc4ef792eb96e2c1cce36b1b1f06ea2a95fe300633cc":hex:"579cdf9da62a2df471e03450516adb4ce99ae0f70b1776a39c3b429a1f922fac0b59e29a122e43"
CCM encrypt and tag NIST VPT AES-192 #25 (P=24, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"91f9d636a071c3aad1743137e0644a73de9e47bd76acd919":hex:"4eaf9384cad976f65f98042d561d760b5a787330dc658f6c":hex:"1bf491ac320d660eb2dd45c6c3":hex:"3bdfd7f18d2b6d0804d779f0679aaa2d7d32978c2df8015ae4b758d337be81dd":hex:"635530cab14e3d0a135bb6eebb5829412676e6dd4995f99cb7e17f235bd660e7e17b2c65320e9fd4"
CCM encrypt and tag NIST VPT AES-256 #1 (P=0, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"c6c14c655e52c8a4c7e8d54e974d698e1f21ee3ba717a0adfa6136d02668c476":hex:"":hex:"291e91b19de518cd7806de44f6":hex:"b4f8326944a45d95f91887c2a6ac36b60eea5edef84c1c358146a666b6878335":hex:"ca482c674b599046cc7d7ee0d00eec1e"
CCM encrypt and tag NIST VPT AES-256 #2 (P=1, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"cc49d4a397887cb57bc92c8a8c26a7aac205c653ef4011c1f48390ad35f5df14":hex:"1a":hex:"6df8c5c28d1728975a0b766cd7":hex:"080f82469505118842e5fa70df5323de175a37609904ee5e76288f94ca84b3c5":hex:"a5f24e87a11a95374d4c190945bf08ef2f"
CCM encrypt and tag NIST VPT AES-256 #3 (P=2, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"36b0175379e7ae19c277fe656a2252a82796309be0f0d4e1c07fdde88aca4510":hex:"be80":hex:"021bd8b551947be4c18cf1a455":hex:"b5c6e8313b9c68e6bb84bffd65fa4108d243f580eab99bb80563ed1050c8266b":hex:"ecacc3152e43d9efea26e16c1d1793e2a8c4"
CCM encrypt and tag NIST VPT AES-256 #4 (P=3, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"ddb739acda6c56ec9aefc4f4cbc258587f443da4e76ddfa85dbe0813a8784944":hex:"db457c":hex:"0bddf342121b82f906368b0d7b":hex:"887486fff7922768186363ef17eb78e5cf2fab8f47a4eb327de8b16d63b02acb":hex:"54473c3f65d6be431e79700378049ac06f2599"
CCM encrypt and tag NIST VPT AES-256 #5 (P=4, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"62b82637e567ad27c3066d533ed76e314522ac5c53851a8c958ce6c64b82ffd0":hex:"87294078":hex:"5bc2896d8b81999546f88232ab":hex:"fffb40b0d18cb23018aac109bf62d849adca42629d8a9ad1299b83fe274f9a63":hex:"2bc22735ab21dfdcfe95bd83592fb6b4168d9a23"
CCM encrypt and tag NIST VPT AES-256 #6 (P=5, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"bc29a16e19cfbe32bf4948e8e4484159bc819b7eec504e4441a1a98ca210e576":hex:"3e8c6d1b12":hex:"4f18bcc8ee0bbb80de30a9e086":hex:"574931ae4b24bdf7e9217eca6ce2a07287999e529f6e106e3721c42dacf00f5d":hex:"45f3795fcf9c66e1a43103d9a18f5fba5fab83f994"
CCM encrypt and tag NIST VPT AES-256 #7 (P=6, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"5f4b4f97b6aa48adb3336c451aac377fde4adf47897fd9ccdf139f33be76b18c":hex:"1b62ad19dcac":hex:"7a76eac44486afdb112fc4aab9":hex:"a66c980f6621e03ff93b55d5a148615c4ad36d6cbdd0b22b173b4b1479fb8ff7":hex:"4ad1fcf57c12b14e0e659a6305b4aeffae82f8a66c94"
CCM encrypt and tag NIST VPT AES-256 #8 (P=7, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"f7aaeff3a1dc0cc5ecf220c67ad9f6dda060b4f1be3cc609cb4f18b2342a88a2":hex:"d48daa2919348d":hex:"d0d6871b9adc8623ac63faf00f":hex:"e97175c23c5b47da8ce67811c6d60a7499b3b7e1347ad860519285b67201fe38":hex:"eb32ab153a8e092fa325bafc176a07c31e6cc0a852d288"
CCM encrypt and tag NIST VPT AES-256 #9 (P=8, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"493e14623cd250058a7fc66a3fee0c24b6e363b966c2314aff53b276b6c2ea7b":hex:"e5653e512d8b0b70":hex:"fe2d8ae8da94a6df563f89ce00":hex:"579a637e37a0974cd2fc3b735d9ed088e8e488ffe210f043e0f9d2079a015ad6":hex:"75d31f8d47bee5c4e2ba537355ae8ab25cc9ed3511ff5053"
CCM encrypt and tag NIST VPT AES-256 #10 (P=9, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"b23255372455c69244a0210e6a9e13b155a5ec9d6d0900e54a8f4d9f7a255e3a":hex:"615d724ae94a5daf8d":hex:"274846196d78f0af2df5860231":hex:"69adcae8a1e9a3f2fe9e62591f7b4c5b19d3b50e769521f67e7ea8d7b58d9fc8":hex:"f019ae51063239287d896e7127f17d13f98013b420219eb877"
CCM encrypt and tag NIST VPT AES-256 #11 (P=10, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"dbf06366f766e2811ecd5d4384d6d08336adc37e0824d620cf0d9e7fd1e7afa9":hex:"2e3cf0af8c96c7b22719":hex:"b3503ed4e277ed9769b20c10c0":hex:"9ae5a04baa9d02c8854e609899c6240851cbc83f81f752bc04c71affa4eed385":hex:"e317df43ab46eb31be7e76f2730d771d56099a0c8d2703d7a24e"
CCM encrypt and tag NIST VPT AES-256 #12 (P=11, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"4dd555bd3a5253a90b68b5d4d46bd050340ee07ddad3a72048c657b5d76bb207":hex:"8015c0f07a7acd4b1cbdd2":hex:"bdb1b82ba864893c2ee8f7426c":hex:"9bcc5848e928ba0068f7a867e79e83a6f93593354a8bfcfc306aeeb9821c1da1":hex:"8e9f80c726980b3d42e43a6512a0481255b729a10f9edb5f07c60c"
CCM encrypt and tag NIST VPT AES-256 #13 (P=12, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"d3ad8cda9a0d91a205c4c05665728bb255d50a83403c9ab9243fcbbe95ae7906":hex:"a203aeb635e195bc33fd42fa":hex:"0b5f69697eb1af24e8e6fcb605":hex:"ea26ea68facdac3c75ba0cdf7b1ad703c9474af83b3fbfc58e548d776b2529b9":hex:"62666297a809c982b50722bd56bc555899345e0404b2938edf33168e"
CCM encrypt and tag NIST VPT AES-256 #14 (P=13, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"e300fc7a5b96806382c35af5b2c2e8e26382751b59010d4b1cfc90a4a9cb06df":hex:"8714eb9ecf8bdb13e919de40f9":hex:"55b59eb434dd1ba3723ee0dc72":hex:"9b1d85384cb6f47c0b13514a303d4e1d95af4c6442691f314a401135f07829ec":hex:"ba6063824d314aa3cbab14b8c54c6520dac0f073856d9b9010b7857736"
CCM encrypt and tag NIST VPT AES-256 #15 (P=14, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"3ae5be5904bae62609ac525e2d1cad90133447573d7b608975a6a2b16cb2efc0":hex:"959403e0771c21a416bd03f38983":hex:"61bf06b9fa5a450d094f3ddcb5":hex:"0245484bcd987787fe97fda6c8ffb6e7058d7b8f7064f27514afaac4048767fd":hex:"37a346bc4909965c5497838251826385a52c68914e9d1f63fd297ee6e7ed"
CCM encrypt and tag NIST VPT AES-256 #16 (P=15, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"fab62b3e5deda7a9c1128663cc81c44b74ab1bfe70bc1c9dec7c7fd08173b80a":hex:"54be71705e453177b53c92bbf2ab13":hex:"a5c1b146c82c34b2e6ebeceb58":hex:"5e60b02b26e2d5f752eb55ea5f50bb354a6f01b800cea5c815ff0030b8c7d475":hex:"788db949697b8cd9abbc74ed9aa40cd6852dc829469368491149d6bb140071"
CCM encrypt and tag NIST VPT AES-256 #17 (P=16, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"ee8ce187169779d13e443d6428e38b38b55dfb90f0228a8a4e62f8f535806e62":hex:"d15f98f2c6d670f55c78a06648332bc9":hex:"121642c4218b391c98e6269c8a":hex:"718d13e47522ac4cdf3f828063980b6d452fcdcd6e1a1904bf87f548a5fd5a05":hex:"cc17bf8794c843457d899391898ed22a6f9d28fcb64234e1cd793c4144f1da50"
CCM encrypt and tag NIST VPT AES-256 #18 (P=17, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"7da6ef35ad594a09cb74daf27e50a6b30d6b4160cf0de41ee32bbf2a208b911d":hex:"b0053d1f490809794250d856062d0aaa92":hex:"98a32d7fe606583e2906420297":hex:"217d130408a738e6a833931e69f8696960c817407301560bbe5fbd92361488b4":hex:"a6341ee3d60eb34a8a8bc2806d50dd57a3f628ee49a8c2005c7d07d354bf80994d"
CCM encrypt and tag NIST VPT AES-256 #19 (P=18, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"0786706f680c27b792d054faa63f499a8e6b5ddb90502946235bf74c022d772c":hex:"6a26677836d65bd0d35a027d278b2534e7df":hex:"f61ef1c8c10a863efeb4a1de86":hex:"67874c808600a27fcab34d6f69cc5c730831ad4589075dd82479823cb9b41dc3":hex:"d1c1f3c60603359c7d6a707f05ecb2296f8e52f2210b7a798ad5c778ee7cfd7fe6e0"
CCM encrypt and tag NIST VPT AES-256 #20 (P=19, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"bac55f9847d93325bf5071c220c0a3dfeb38f214292d47b4acb7b0a597fe056f":hex:"c1a994dc198f5676ea85801cd27cc8f47267ec":hex:"05b50c458adbba16c55fcc454d":hex:"89ad6ae1e550975eaa916a62615e6b6a66366a17a7e06380a95ea5cdcc1d3302":hex:"7c9b138177590edaafec4728c4663e77458ffbe3243faec177de4a2e4a293952073e43"
CCM encrypt and tag NIST VPT AES-256 #21 (P=20, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"8beedeb85d42c2a7fa6f7237b05acb197dd8e1672471ac878064fe5319eab876":hex:"7b125c3b9612a8b554913d0384f4795c90cd387c":hex:"8479bdfad28ebe781e9c01a3f6":hex:"7aebdfd955d6e8a19a701d387447a4bdd59a9382156ab0c0dcd37b89419d6eff":hex:"6cc611d816b18c6847b348e46a4119465104254a04e2dfeeeac9c3255f6227704848d5b2"
CCM encrypt and tag NIST VPT AES-256 #22 (P=21, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"c3a0c126cad581012151c25cf85a44472c23f83b6095b6004f4f32cd60ec2db2":hex:"73b09d18554471309141aa33b687f9248b50fe3154":hex:"94ab51ce75db8b046d6ab92830":hex:"2a243246bfe5b5ab05f51bf5f401af52d5bbaa2549cf57a18e197597fe15dd8c":hex:"b7e8264ca70fd2a4fb76f20a8ad5da3c37f5893fb12abeeaef1187f815ca481ed8ddd3dd37"
CCM encrypt and tag NIST VPT AES-256 #23 (P=22, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"9cdebaeee8690b68751070691f49593668a6de12d3a948b38ddbd3f75218b2d4":hex:"3cbb08f133270e4454bcaaa0f20f6d63c38b6572e766":hex:"af1a97d43151f5ea9c48ad36a3":hex:"f5353fb6bfc8f09d556158132d6cbb97d9045eacdc71f782bcef62d258b1950a":hex:"3966930a2ae8fdd8f40e7007f3fde0bd6eb48a46e6d26eef83da9f6384b1a2bda10790dadb3f"
CCM encrypt and tag NIST VPT AES-256 #24 (P=23, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"d34264a12c35cdd67ac105e2826b071e46f8131d1e325f8e0ae80a6447375135":hex:"79ac1a6a9eca5e07ce635bfd666ef72b16f3f2e140d56c":hex:"3891e308b9f44c5b5a8b59004a":hex:"0cda000ed754456a844c9ed61843deea9dadf5e723ea1448057712996d660f8c":hex:"1abcc9b1649deaa0bfa7dcd23508282d9c50ca7fee72486950608d7bcb39dcf03a2cab01587f61"
CCM encrypt and tag NIST VPT AES-256 #25 (P=24, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"4ad98dbef0fb2a188b6c49a859c920967214b998435a00b93d931b5acecaf976":hex:"9cea3b061e5c402d48497ea4948d75b8af7746d4e570c848":hex:"00d772b07788536b688ff2b84a":hex:"5f8b1400920891e8057639618183c9c847821c1aae79f2a90d75f114db21e975":hex:"f28ec535c2d834963c85814ec4173c0b8983dff8dc4a2d4e0f73bfb28ad42aa8f75f549a93594dd4"
CCM encrypt and tag NIST VNT AES-128 #1 (P=24, N=7, A=32, T=16)
depends_on:0
4:exp:0:hex:"c0425ed20cd28fda67a2bcc0ab342a49":hex:"4f065a23eeca6b18d118e1de4d7e5ca1a7c0e556d786d407":hex:"37667f334dce90":hex:"0b3e8d9785c74c8f41ea257d4d87495ffbbb335542b12e0d62bb177ec7a164d9":hex:"768fccdf4898bca099e33c3d40565497dec22dd6e33dcf4384d71be8565c21a455db45816da8158c"
CCM encrypt and tag NIST VNT AES-128 #2 (P=24, N=8, A=32, T=16)
depends_on:0
4:exp:0:hex:"0b6256bd328a4cda2510d527c0f73ed4":hex:"78a292662b8e05abc2d44fbefd0840795e7493028015d9f2":hex:"21fd9011d6d9484a":hex:"66ff35c4f86ad7755b149e14e299034763023e7384f4af8c35277d2c7e1a7de2":hex:"5a0be834c57b59d47a4590d8d19a1206d3c06e937a9b57f74034d9fdb43c3f48932aa72177b23bf6"
CCM encrypt and tag NIST VNT AES-128 #3 (P=24, N=9, A=32, T=16)
depends_on:0
4:exp:0:hex:"afdccc84f257cb768b7ad735edbd1990":hex:"56d0942490e546798f30d3c60ad4e3e110fc04f5b1c1fa83":hex:"b7776aa998f4d1189b":hex:"9f9ac464de508b98e789243fdb32db458538f8a291ed93ddf8aeaacfbfc371aa":hex:"96f124c74fd737819008ddef440320f4a3733d0062c83c893e259aecf12ba08f2a2e966a3341d6d4"
CCM encrypt and tag NIST VNT AES-128 #4 (P=24, N=10, A=32, T=16)
depends_on:0
4:exp:0:hex:"6ccb68d3838d4ddf660b9cd904cad40f":hex:"5ea35c082e2b190e9d98e6b2daad8672f587b4f2968072fc":hex:"c4fb7519a19f13d9d1fc":hex:"092e64fef08b5655a86cdb8de63ffaa7772e8730844e9016141af8bad2216246":hex:"cda5fe3d15d00150b99120c7f206b88a4c2c4a39ca9143425603ab284a73a38cc916f8b653c92ab4"
CCM encrypt and tag NIST VNT AES-128 #5 (P=24, N=11, A=32, T=16)
depends_on:0
4:exp:0:hex:"e6ab9e70a4fb51b01c2e262233e64c0d":hex:"ba15916733550d7aa82b2f6b117cd3f54c83ddc16cd0288a":hex:"74e689eb5af9441dd690a6":hex:"42f6518ee0fbe42f28e13b4bb2eb60517b37c9744394d9143393a879c3e107c7":hex:"dcc151443288f35d39ed8fae6f0ce1d1eb656f4f7fd65c0b16f322ce85d7c54e71ac560fd4da9651"
CCM encrypt and tag NIST VNT AES-128 #6 (P=24, N=12, A=32, T=16)
depends_on:0
4:exp:0:hex:"005e8f4d8e0cbf4e1ceeb5d87a275848":hex:"b6f345204526439daf84998f380dcfb4b4167c959c04ff65":hex:"0ec3ac452b547b9062aac8fa":hex:"2f1821aa57e5278ffd33c17d46615b77363149dbc98470413f6543a6b749f2ca":hex:"9575e16f35da3c88a19c26a7b762044f4d7bbbafeff05d754829e2a7752fa3a14890972884b511d8"
CCM encrypt and tag NIST VNT AES-128 #7 (P=24, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"ac87fef3b76e725d66d905625a387e82":hex:"959403e0771c21a416bd03f3898390e90d0a0899f69f9552":hex:"61bf06b9fa5a450d094f3ddcb5":hex:"0245484bcd987787fe97fda6c8ffb6e7058d7b8f7064f27514afaac4048767fd":hex:"cabf8aa613d5357aa3e70173d43f1f202b628a61d18e8b572eb66bb8213a515aa61e5f0945cd57f4"
CCM encrypt and tag NIST VNT AES-192 #1 (P=24, N=7, A=32, T=16)
depends_on:0
4:exp:0:hex:"ceb009aea4454451feadf0e6b36f45555dd04723baa448e8":hex:"c8d275f919e17d7fe69c2a1f58939dfe4d403791b5df1310":hex:"764043c49460b7":hex:"6e80dd7f1badf3a1c9ab25c75f10bde78c23fa0eb8f9aaa53adefbf4cbf78fe4":hex:"8a0f3d8229e48e7487fd95a28ad392c80b3681d4fbc7bbfd2dd6ef1c45d4ccb723dc074414db506d"
CCM encrypt and tag NIST VNT AES-192 #2 (P=24, N=8, A=32, T=16)
depends_on:0
4:exp:0:hex:"1dd56442fa09a42890b1b4274b950770ea8beea2e048193d":hex:"bd92d6744cde446fc8621625658fc4bc00dcb97f06195ad7":hex:"ad749d596d88a4b4":hex:"c67219909828adef64422286008e1e306867a1c0b3da95444507a68b45c953e4":hex:"076cffd0ca978fe2bad411ced45a090abafb22a99896f6a75a1969276aa2b0cdb37ccaf2845dbf6e"
CCM encrypt and tag NIST VNT AES-192 #3 (P=24, N=9, A=32, T=16)
depends_on:0
4:exp:0:hex:"8cc622645065c72d0d2aca75802cf1bbbd81096721627c08":hex:"597b3614ff9cd567afd1aad4e5f52cc3fa4ca32b9b213c55":hex:"cd84acbe9abb6a990a":hex:"447b6f36acdad2d1cfd6e9a92f4055ad90142e61f4a19927caea9dbe634d3208":hex:"2d7fb83e6621eed9073e0386d032c6941bef37b2cf36a4c6c5e36222d17c6fb0631c3f560a3ce4a4"
CCM encrypt and tag NIST VNT AES-192 #4 (P=24, N=10, A=32, T=16)
depends_on:0
4:exp:0:hex:"ab72eef2aba30205c986e2052d6e2c67881d24ae5fceaa8f":hex:"2a794b84fc9e4a7e6d70a82b5141fd132177a86b4e8fc13a":hex:"d7a46e726ed43f1580eb":hex:"baa86f14271b2be7dbb37ddc7c95ce4857e57aa94624d594d7bd6ceeaada8d5f":hex:"2d7f76464417613bb61d3657481346b74fc9d6abc6a3babd39365dce86859cd82395d11bfc8cf188"
CCM encrypt and tag NIST VNT AES-192 #5 (P=24, N=11, A=32, T=16)
depends_on:0
4:exp:0:hex:"af84c6f302c59aeee6d5728ed5da2e3c64a5a781c52c4d1b":hex:"6db41aeb5f7c24df8929dbc30483b3c7934b3bd1cdce5bb9":hex:"df990c42a268950677c433":hex:"a6ab5d78427f297a4b7e21f1091ff3a5b20caa3fe1cbcb09459d9df596a6c8e1":hex:"8c9328258bf71970d33e23a3ff81cc1c9cbe196a1294264bfd6a7255e4801963bb30a63de3fc5b82"
CCM encrypt and tag NIST VNT AES-192 #6 (P=24, N=12, A=32, T=16)
depends_on:0
4:exp:0:hex:"d49b255aed8be1c02eb6d8ae2bac6dcd7901f1f61df3bbf5":hex:"062eafb0cd09d26e65108c0f56fcc7a305f31c34e0f3a24c":hex:"1af29e721c98e81fb6286370":hex:"64f8a0eee5487a4958a489ed35f1327e2096542c1bdb2134fb942ca91804c274":hex:"721344e2fd05d2ee50713531052d75e4071103ab0436f65f0af2a663da51bac626c9f4128ba5ec0b"
CCM encrypt and tag NIST VNT AES-192 #7 (P=24, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"36ad1e3fb630d1b1fbccfd685f44edd8984427b78deae7a9":hex:"8b9db1c8f9b4892a5654c85467bcffa2e15e28392c938952":hex:"3af625df8be9d7685a842f260e":hex:"308443033ecd4a814475672b814b7c6d813d0ec2a0caeecbcaba18a2840cdb6c":hex:"6bc6890fee299c712fb8d9df9c141f24ee1572b8f15112c2f8c99ccf2d82788cf613a61d60dae458"
CCM encrypt and tag NIST VNT AES-256 #1 (P=24, N=7, A=32, T=16)
depends_on:0
4:exp:0:hex:"553521a765ab0c3fd203654e9916330e189bdf951feee9b44b10da208fee7acf":hex:"644eb34b9a126e437b5e015eea141ca1a88020f2d5d6cc2c":hex:"aaa23f101647d8":hex:"a355d4c611812e5f9258d7188b3df8851477094ffc2af2cf0c8670db903fbbe0":hex:"27ed90668174ebf8241a3c74b35e1246b6617e4123578f153bdb67062a13ef4e986f5bb3d0bb4307"
CCM encrypt and tag NIST VNT AES-256 #2 (P=24, N=8, A=32, T=16)
depends_on:0
4:exp:0:hex:"472bf7946bce1d3c6f168f4475e5bb3a67d5df2fa01e64bce8bb6e43a6c8b177":hex:"59eb45bbbeb054b0b97334d53580ce03f699ac2a7e490143":hex:"790134a8db83f2da":hex:"a7a86a4407b7ecebc89434baa65ef173e88bd2dad9899b717ca578867c2d916f":hex:"db4961070f528ccd1a5a0681ee4d0ce3515fb890bccedc2dbc00b1d8b2bc393a8d09e87af7811f55"
CCM encrypt and tag NIST VNT AES-256 #3 (P=24, N=9, A=32, T=16)
depends_on:0
4:exp:0:hex:"58ae7965a508e8dd2eda69b5d888a28a1cb3783bad55d59d5b0da87137b72e93":hex:"e61bad17640ecff926d0b0238271ee4c9f8e801dd7243e9e":hex:"caa3d928d2bf2b7f2c":hex:"304678b3ffd3200e33a8912bcb556b3cfec53ca17f70ecba00d359f9f51d3e3b":hex:"7bb1137c14cb4d324a4a8f1115c619ebf74927f0bed60a8d5a9140ff50dc4da375c7d2de80de097f"
CCM encrypt and tag NIST VNT AES-256 #4 (P=24, N=10, A=32, T=16)
depends_on:0
4:exp:0:hex:"aecc5e18088bf9fd7b17f089bdd5607b69903b04b726361f8a81e221b1c91891":hex:"d4291c99901345afe29f58912a414a7498f37b44362bdf3c":hex:"c527d309ab29ee91c5fc":hex:"8f9a73e7bc1c11e2919020ba3a404cbddf861e9e78477218e3be2cd4337b278d":hex:"392784a9e0b14bcd37639ec5409d6ead3e75f855e5a92c33ffc040ef3977e0035ce6ea6d157c18d3"
CCM encrypt and tag NIST VNT AES-256 #5 (P=24, N=11, A=32, T=16)
depends_on:0
4:exp:0:hex:"97bc7482a87ba005475dfa3448f59d4b3f9c4c969d08b39b1b21ef965c0f5125":hex:"b99bf4dc781795fc4d3a8467b06e1665d4e543657f23129f":hex:"0bcf78103ec52d6df28887":hex:"049c10f0cb37ae08eae2d0766563b7c5a8454f841c2061a4f71a0a2158ae6ce5":hex:"0d3891fa0caac1f7ebe41b480920ffd34d4155064c24f3b17a483163dd8f228d1f20cd4f86cf38fd"
CCM encrypt and tag NIST VNT AES-256 #6 (P=24, N=12, A=32, T=16)
depends_on:0
4:exp:0:hex:"d6ff67379a2ead2ca87aa4f29536258f9fb9fc2e91b0ed18e7b9f5df332dd1dc":hex:"98626ffc6c44f13c964e7fcb7d16e988990d6d063d012d33":hex:"2f1d0717a822e20c7cd28f0a":hex:"d50741d34c8564d92f396b97be782923ff3c855ea9757bde419f632c83997630":hex:"50e22db70ac2bab6d6af7059c90d00fbf0fb52eee5eb650e08aca7dec636170f481dcb9fefb85c05"
CCM encrypt and tag NIST VNT AES-256 #7 (P=24, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"4a75ff2f66dae2935403cce27e829ad8be98185c73f8bc61d3ce950a83007e11":hex:"205f2a664a8512e18321a91c13ec13b9e6b633228c57cc1e":hex:"46eb390b175e75da6193d7edb6":hex:"282f05f734f249c0535ee396282218b7c4913c39b59ad2a03ffaf5b0e9b0f780":hex:"58f1584f761983bef4d0060746b5d5ee610ecfda31101a7f5460e9b7856d60a5ad9803c0762f8176"
CCM encrypt and tag NIST VADT AES-128 #1 (P=24, N=13, A=0, T=16)
depends_on:0
4:exp:0:hex:"d24a3d3dde8c84830280cb87abad0bb3":hex:"7c86135ed9c2a515aaae0e9a208133897269220f30870006":hex:"f1100035bb24a8d26004e0e24b":hex:"":hex:"1faeb0ee2ca2cd52f0aa3966578344f24e69b742c4ab37ab1123301219c70599b7c373ad4b3ad67b"
CCM encrypt and tag NIST VADT AES-128 #2 (P=24, N=13, A=1, T=16)
depends_on:0
4:exp:0:hex:"08b0da255d2083808a1b4d367090bacc":hex:"1b156d7e2bf7c9a25ad91cff7b0b02161cb78ff9162286b0":hex:"777828b13679a9e2ca89568233":hex:"dd":hex:"e8b80af4960d5417c15726406e345c5c46831192b03432eed16b6282283e16602331bcca9d51ce76"
CCM encrypt and tag NIST VADT AES-128 #3 (P=24, N=13, A=2, T=16)
depends_on:0
4:exp:0:hex:"1538cc03b60880bf3e7d388e29f27739":hex:"e7b819a853ffe79baaa72097ff0d04f02640ae62bcfd3da5":hex:"9e734de325026b5d7128193973":hex:"c93c":hex:"1d8f42f9730424fa27240bd6277f4882604f440324b11b003ca01d874439b4e1f79a26d8c6dc433a"
CCM encrypt and tag NIST VADT AES-128 #4 (P=24, N=13, A=3, T=16)
depends_on:0
4:exp:0:hex:"f149e41d848f59276cfddd743bafa9a9":hex:"9759e6f21f5a588010f57e6d6eae178d8b20ab59cda66f42":hex:"14b756d66fc51134e203d1c6f9":hex:"f5827e":hex:"f634bf00f1f9f1f93f41049d7f3797b05e805f0b14850f4e78e2a23411147a6187da6818506232ee"
CCM encrypt and tag NIST VADT AES-128 #5 (P=24, N=13, A=4, T=16)
depends_on:0
4:exp:0:hex:"9a57a22c7f26feff8ca6cceff214e4c2":hex:"035c516776c706a7dd5f181fa6aa891b04dd423042ea0667":hex:"88f30fd2b04fb8ddbce8fc26e6":hex:"a95bdff6":hex:"b92f7ec2ebecebdbd2977b3874e61bf496a382153b2529fc9b6443a35f329b2068916fb6ab8227eb"
CCM encrypt and tag NIST VADT AES-128 #6 (P=24, N=13, A=5, T=16)
depends_on:0
4:exp:0:hex:"54caf96ef6d448734700aadab50faf7a":hex:"c69f7c5a50f3e72123371bbfd6bdf532b99ef78500508dfe":hex:"a3803e752ae849c910d8da36af":hex:"5f476348dd":hex:"20c43ad83610880249f1632dd418ec9a5ed333b50e996d1a4e5a32fbe7961b832b722bc07a18595b"
CCM encrypt and tag NIST VADT AES-128 #7 (P=24, N=13, A=6, T=16)
depends_on:0
4:exp:0:hex:"cc0c084d7de011e2f031616a302e7a31":hex:"15b369889699b6de1fa3ee73e5fe19814e46f129074c965b":hex:"f0b4522847f6f8336fe534a4e7":hex:"da853a27aee2":hex:"f39755d160a64611368a8eccf6fcbc45ef7f1f56240eb19a2e3ca4ec3c776ab58843f617d605fd72"
CCM encrypt and tag NIST VADT AES-128 #8 (P=24, N=13, A=7, T=16)
depends_on:0
4:exp:0:hex:"d7572ed0e37261efa02f8c83e695efdc":hex:"1edef80c57d17f969f8bde10ab38a1a8811a124de72c526e":hex:"f4f96d7b4384a3930b3d830f82":hex:"922340ec94861f":hex:"de14558cc686e1836f1f121ea1b941a9ebd4f0fb916dc870fd541b988a801cb5751c7faaf5b0c164"
CCM encrypt and tag NIST VADT AES-128 #9 (P=24, N=13, A=8, T=16)
depends_on:0
4:exp:0:hex:"98a42d7a0c5917deaf3b4de3f0cbe0a1":hex:"9aa9c8358117564371366beeec923051ef433252197aaad5":hex:"03d33ab0c2df7bfce88b5ee4c4":hex:"2d5438b728b950d9":hex:"9ff942baa60f440c17a78e9581216b9a947a67f04d54911feecfff971fdfaa856310b014aa59c978"
CCM encrypt and tag NIST VADT AES-128 #10 (P=24, N=13, A=9, T=16)
depends_on:0
4:exp:0:hex:"2a68e3fe746f593c1b97cb637079c3e5":hex:"13b4a874888db0e5d8fd814b5e7e04f7fdfbc1601ccc02bc":hex:"cd62d0f27b7f4864dc7c343acd":hex:"abe4f1d3812bfe3ccf":hex:"032835a3dbf688d09cf2a32a92b101959d33ff47500f92f4fd49840440f866d1a22b0854996111d8"
CCM encrypt and tag NIST VADT AES-128 #11 (P=24, N=13, A=10, T=16)
depends_on:0
4:exp:0:hex:"46b067cf9b1a28cf187002e90b14e130":hex:"cc0915194218d4536e467433cd6d79ff1d9eb9ff160ab684":hex:"bad8c03292bf01cfd8d34f860c":hex:"8d65880eddb9fd96d276":hex:"bd56edc015692c6ab9bec493a9893863598414a3d11a6a0f27ecdcb257d0d30491e5bf1aa8f90958"
CCM encrypt and tag NIST VADT AES-128 #12 (P=24, N=13, A=11, T=16)
depends_on:0
4:exp:0:hex:"e94dac9c90984790a7c0c867536615ff":hex:"4d64461c55eb16bf7b9120f22be349598f2f394da8460dc6":hex:"c19f06f91e645d4199365f18c0":hex:"537038b5357e358a930bd6":hex:"e9fc5004c2359724e1e4411ae6f834ef6bea046d549753c88790c1648f461a31c84e62ea8592a074"
CCM encrypt and tag NIST VADT AES-128 #13 (P=24, N=13, A=12, T=16)
depends_on:0
4:exp:0:hex:"f6bb5d59b0fa9de0828b115303bf94aa":hex:"011fc50329bfd63a85ebd4f7693363602f1a4147371270b7":hex:"05358f33e1fc6a53ab5a5c98ce":hex:"040b25771239cc2a39446e3c":hex:"4432d7eb42980734d34f19c50cf8abf71ac1b19ed75a727854e5d050a405f755047d09cb0f49546a"
CCM encrypt and tag NIST VADT AES-128 #14 (P=24, N=13, A=13, T=16)
depends_on:0
4:exp:0:hex:"d1da2e961e78063af8de41865b226873":hex:"8e5fa1a6662a8378cda15697e926841594f2f394fa5a34ab":hex:"03739f5474857006340cce554d":hex:"e3afd091d2b588465872a6300f":hex:"ca0d95e3ff186ad6b88d45fc4079e6b7b4a615e7e8dd5f4742d522cc9dc19c47a4fa0b1528069cf8"
CCM encrypt and tag NIST VADT AES-128 #15 (P=24, N=13, A=14, T=16)
depends_on:0
4:exp:0:hex:"1eee667267ef10b03624cf9c341e3f75":hex:"798e31cce0a83702a95171fb1162a17b9ce00ec3592ce262":hex:"0630a3eae27e505c61c56e6560":hex:"d24651ef0561282d3e20e834960c":hex:"f3c3e52f1a1ff528a8d3783ee4e75f114e3e6416334815d2d9236d5c5c9319092078411b72c51ba8"
CCM encrypt and tag NIST VADT AES-128 #16 (P=24, N=13, A=15, T=16)
depends_on:0
4:exp:0:hex:"dbbd26f5d9e970e4e384b2273961be5a":hex:"553714e17a208a2eceb847a4a2d95088388b1ac8d8ca43e0":hex:"0b1eabe504ef4822542e397fec":hex:"477937301c83ba02d50760b603e0ea":hex:"1c80213268bad5402c4dc9b5d836ab7499810d0d8a974716df9a0e986ab2890736423bb3772cec3e"
CCM encrypt and tag NIST VADT AES-128 #17 (P=24, N=13, A=16, T=16)
depends_on:0
4:exp:0:hex:"10a7720f2e18f739c26924925af6b670":hex:"e59782a9aea45f467b90e51a0fdf166baba05663def2d8b6":hex:"8c4e7813ab9bce9dafee01c628":hex:"a209941fab710fda38d11c68b13d930f":hex:"e357b1ccdaca6f3506dc45279c2e4c59f5307a5fd6a99cd72341ea8c0785569973f90ee9ee645acc"
CCM encrypt and tag NIST VADT AES-128 #18 (P=24, N=13, A=17, T=16)
depends_on:0
4:exp:0:hex:"6bffab1f4f4c1ff66b4a669b515b2f8d":hex:"d91b12e8655dd92b1332fc1d71c391c96a17111562d90ba3":hex:"ddb34d5e0140fb96d690e1a2b7":hex:"5cbba9ea778e01af00afb2a934f28c7211":hex:"d302e5b2d5d90433186b804cd7717e2db2f22cdc34fb2942ab30780a2c4f12af8f35350d65284c59"
CCM encrypt and tag NIST VADT AES-128 #19 (P=24, N=13, A=18, T=16)
depends_on:0
4:exp:0:hex:"ae6136df9ab43631ef143515dacedbe7":hex:"6a493c5ef3769ccc4101dbb2eb36e1e5bbc577a057ce0731":hex:"c5c445792208a50c8e93d64aa3":hex:"e04006b68c83a5dd4ceac3cde238e48895ae":hex:"c7584c0203c2535c5702c6ae93b7cbfb066f4a055c627a180d6d676d11fce907b5c93fa1ed7bff2b"
CCM encrypt and tag NIST VADT AES-128 #20 (P=24, N=13, A=19, T=16)
depends_on:0
4:exp:0:hex:"f1908328edf2996ebfc9655472ca5ad0":hex:"eede01b08f9a303cdf14c99d7a45732972c6eff2a1db06eb":hex:"4c693364546930b6c5250e2699":hex:"4a3634e5028df97fbe00eb016e8ea4f1918faa":hex:"90c850790b0b380f5aeb2488fdf43c9d5ef1759861e86f6e52570e769629dcc2e568737ba53a1195"
CCM encrypt and tag NIST VADT AES-128 #21 (P=24, N=13, A=20, T=16)
depends_on:0
4:exp:0:hex:"61cb8eb792e95d099a1455fb789d8d16":hex:"6ad541695a37c32d73ff6d5f870abd5b0f362a8968c4fce0":hex:"1f37b3e59137f2a60dc09d16ac":hex:"09db3efac9473f713da630ae92c2c8604c61c51e":hex:"e65fcc975865c1499b088b58ba163283085d8ca68dc3b235d89756e5d78753ef22c012ae34b39a20"
CCM encrypt and tag NIST VADT AES-128 #22 (P=24, N=13, A=21, T=16)
depends_on:0
4:exp:0:hex:"be1ed49e2cb0caf6b6a0940c58453b93":hex:"a9eec383f63892521e4616fcbadc5485942ffaf4669c43a7":hex:"b78ad129457681fa7346435b97":hex:"161d92c7df1ebb0924719e066e08b95eb4914a5eda":hex:"949be340720c4fdc4adc05cb777dd81a2549628d33fba07e62d2b338a7b34ebd9d85c244c952d681"
CCM encrypt and tag NIST VADT AES-128 #23 (P=24, N=13, A=22, T=16)
depends_on:0
4:exp:0:hex:"34ab6fd7f54a2e0276fcb7cf1e203aba":hex:"8d164f598ea141082b1069776fccd87baf6a2563cbdbc9d1":hex:"6091afb62c1a8eed4da5624dd7":hex:"1ab5cc3d7b01dc74e6cf838bb565fea3187d33d552a2":hex:"0d30ab07153b5153637969e6bd3539448c541e42b3d432fd7ef14622a9b621d1721b944c60f7fd67"
CCM encrypt and tag NIST VADT AES-128 #24 (P=24, N=13, A=23, T=16)
depends_on:0
4:exp:0:hex:"ea96f90fbae12a857f5c97e0cba57943":hex:"49db80f22bc267a70e5636dfbc8a21c83d9691fe4b9c3051":hex:"21cc46d9ced1539b0ad946e600":hex:"105258d2f25f62675aee975cfdb668aff833f05b61eb2a":hex:"d2fcc8b7809b5fc07e44083e437d8180157f1782a9ce9f65c7fa9ee2e7cdc1b755258f2212a8a8f4"
CCM encrypt and tag NIST VADT AES-128 #25 (P=24, N=13, A=24, T=16)
depends_on:0
4:exp:0:hex:"35b403a15212097085d6e2b77ec3d4f2":hex:"7dd7396db6613eb80909a3b8c0029b624912aabedda0659b":hex:"daa423bf9256c3fcc347a293aa":hex:"d3c0ed74e5f25e4c1e479e1a51182bb018698ec267269149":hex:"5b00cf8a66baa7fe22502ed6f4861af71fa64b550d643f95eee82c19ecba34280604b58d92dacd3f"
CCM encrypt and tag NIST VADT AES-128 #26 (P=24, N=13, A=25, T=16)
depends_on:0
4:exp:0:hex:"7a459aadb48f1a528edae71fcf698b84":hex:"0b3d947de8632dc8ff752f619ba7c84716fac7a23e101641":hex:"fa4616b715ea898772b0e89dd4":hex:"0c0b4a45df5c3919c1e1669c5af5d398d9545e44307d95c481":hex:"7db9f3f7dc26fc2adf58d4525d26d5601e977de5a7c33911a1138cff7b624f9908b5b4d7e90a824a"
CCM encrypt and tag NIST VADT AES-128 #27 (P=24, N=13, A=26, T=16)
depends_on:0
4:exp:0:hex:"ca748225057f735f712ecc64791367f0":hex:"e92cd0cb97afe4fb00c4f12e9b9abe1d08db98f49a27f461":hex:"1341a6998eb1f50d4b710a13ac":hex:"5fb96b045f494808c02014f06074bd45b8a8ad12b4cb448ec162":hex:"82b666694232e86e82295beae66ae67d56aceb5d6b1484ceb4a6843ec16078038c10afedc41f5362"
CCM encrypt and tag NIST VADT AES-128 #28 (P=24, N=13, A=27, T=16)
depends_on:0
4:exp:0:hex:"fdf2b2c7fcb3789b4e90abe607dca2af":hex:"d7aa4efa5d75195a400018bd38f7d8cd53fdffe88df1837f":hex:"a69ddc66e63a3415f21009d53a":hex:"c76846da496ed87b9c0f65c6266c9a822224acde9775efb186a4a5":hex:"150d9a8b78d9c04239d66207a1f95021bbb1b7c70d7c354825d05e5a2e76a90f6fe489fd74cab2a3"
CCM encrypt and tag NIST VADT AES-128 #29 (P=24, N=13, A=28, T=16)
depends_on:0
4:exp:0:hex:"7d870d7e52d3053c65eefad47764cfeb":hex:"109317556c21c969eda65a94176d7a11462c9ae18a865b6d":hex:"37d888f4aa452d7bf217f5a529":hex:"9610949f6d23d5b1f3989b2f4e524fab4f297a5bec8ddad4f16cb616":hex:"4e6b967b1571c6d7b9e118b112b7ac949a4a175650316a242dd579cb0d201d22c86bbc7fbe47bd0d"
CCM encrypt and tag NIST VADT AES-128 #30 (P=24, N=13, A=29, T=16)
depends_on:0
4:exp:0:hex:"8fcac40527c0e7ca8eaff265ca12c053":hex:"78d1e96af8cebdcc7e7e2a4ddcfa34f6cf9a24fb85672ad7":hex:"ae9f012fd9af60a400e20b1690":hex:"9ce65598cd1f86afc9aaaf172809570cc306333c25523f863c6d0e0154":hex:"9adb9a95a9379ad795d8d3ffd4e37a045160d6d727f974a6cb3b5151f327e65447e52c7525562c91"
CCM encrypt and tag NIST VADT AES-128 #31 (P=24, N=13, A=30, T=16)
depends_on:0
4:exp:0:hex:"ddf9f150cc3f1c15e8e773663c5b061c":hex:"79d8841ab83279724ce35e1a8abd4e158168dcf388ab4c3d":hex:"98c5036b7d54da9a1177105600":hex:"20c5ab290e6d97f53c74121951f39ba865b3acc465fa3f0fb8a591622277":hex:"d00d29396ffa9e691290d746527777bf96a851f306d4da0b1816df1e0e82bb7bc8105930ad6a2232"
CCM encrypt and tag NIST VADT AES-128 #32 (P=24, N=13, A=31, T=16)
depends_on:0
4:exp:0:hex:"b1dc81d116d94f5eced526b37c004b95":hex:"54390715b6e7c7bd51a234db059a51ba030cf22ee00b7277":hex:"97c8f69fb91b17299461fd8d63":hex:"f8b08aa83bed09ca342249b2cf9e2b45a89dcfb8711a120395e455921af481":hex:"cb629994c3418a662a8cde1b5f4d99aa7df66e24c53dc6df11297930fd44c63675b7cca70671ef4d"
CCM encrypt and tag NIST VADT AES-128 #33 (P=24, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"5a33980e71e7d67fd6cf171454dc96e5":hex:"a34dfa24847c365291ce1b54bcf8d9a75d861e5133cc3a74":hex:"33ae68ebb8010c6b3da6b9cb29":hex:"eca622a37570df619e10ebb18bebadb2f2b49c4d2b2ff715873bb672e30fc0ff":hex:"7a60fa7ee8859e283cce378fb6b95522ab8b70efcdb0265f7c4b4fa597666b86dd1353e400f28864"
CCM encrypt and tag NIST VADT AES-192 #1 (P=24, N=13, A=0, T=16)
depends_on:0
4:exp:0:hex:"26511fb51fcfa75cb4b44da75a6e5a0eb8d9c8f3b906f886":hex:"39f08a2af1d8da6212550639b91fb2573e39a8eb5d801de8":hex:"15b369889699b6de1fa3ee73e5":hex:"":hex:"6342b8700edec97a960eb16e7cb1eb4412fb4e263ddd2206b090155d34a76c8324e5550c3ef426ed"
CCM encrypt and tag NIST VADT AES-192 #2 (P=24, N=13, A=1, T=16)
depends_on:0
4:exp:0:hex:"9748798c0f3cc766795c8ce0e4c979c1930dfe7faefea84a":hex:"100fa71462277d76ca81f2cfdb3d39d3894b0ca28074a0f0":hex:"cdf4ba655acfe8e2134fa0542f":hex:"67":hex:"36e2415b4f888a6072f260d7e786d803be16f8b9cbee112d7ff74e3b05b7d7c13284573bd3e7e481"
CCM encrypt and tag NIST VADT AES-192 #3 (P=24, N=13, A=2, T=16)
depends_on:0
4:exp:0:hex:"393dcac5a28d77297946d7ab471ae03bd303ba3499e2ce26":hex:"262f4ac988812500cb437f52f0c182148e85a0bec67a2736":hex:"fe7329f343f6e726a90b11ae37":hex:"1c8b":hex:"e6d43f822ad168aa9c2e29c07f4592d7bbeb0203f418f3020ecdbc200be353112faf20e2be711908"
CCM encrypt and tag NIST VADT AES-192 #4 (P=24, N=13, A=3, T=16)
depends_on:0
4:exp:0:hex:"a74abc4347e4be0acb0a73bb8f7d25c35bae13b77f80233a":hex:"6372824bf416cd072a7ad0ae5f9f596c6127520c1b688ab4":hex:"6a850e94940da8781159ba97ef":hex:"a4490e":hex:"b14a07bdc119d87611342c4c6935c5786ff1f9ae2eb49e6191c88a3cb4fbafcb8a4a157d587d7e39"
CCM encrypt and tag NIST VADT AES-192 #5 (P=24, N=13, A=4, T=16)
depends_on:0
4:exp:0:hex:"df052e95aea3769a433ce4e4e800b8418649bbe8c6297eb0":hex:"e8c1a89228d8212f75c136bab7923a89f9fea18e781cb836":hex:"ba356d392c3f700f4f2706a4ca":hex:"8ffc0e3d":hex:"66b5d782323925e1bd0a8413a9a5a881356453d5df2cbeb199b2e1e803550dcdde55fd66ecb45edd"
CCM encrypt and tag NIST VADT AES-192 #6 (P=24, N=13, A=5, T=16)
depends_on:0
4:exp:0:hex:"16d345606a315ad2406abbcb43cd8cabe948107ba6d17a72":hex:"d3bef460223c81e4579c9d1d463ac5e0881685de1420a411":hex:"d4ef3e9e04f1b7f20ffc5a022e":hex:"a468f08d07":hex:"abb85db49a9b1c8724ecbc734cc8373bd20083cfa4007b1cfe4d3a3bb25f89f692884be230c6035c"
CCM encrypt and tag NIST VADT AES-192 #7 (P=24, N=13, A=6, T=16)
depends_on:0
4:exp:0:hex:"1c476cfd7dd300d961fd3f24a6fe0e80742b00851676ca63":hex:"6f3938932b5c1280311e892280d8a822a828a0be7fdb1bcd":hex:"e300fc7a5b96806382c35af5b2":hex:"28130f938c45":hex:"df48662fe134e75a85abc2cece2c3b6236c88a70fa792e9beadc9601adf9fbdf4e3e94b395b0a332"
CCM encrypt and tag NIST VADT AES-192 #8 (P=24, N=13, A=7, T=16)
depends_on:0
4:exp:0:hex:"79d1e38a70df1cf239be168833dcd0570bc8f37b3aa26c37":hex:"83c24f3a77b83b4ef45277ba90225f3ba1722312f52b1a07":hex:"8229d6d7e9e21fdc789bff5dcf":hex:"076887d2abe900":hex:"19d880f1d959a68f162de243d4a45747ace704613359b27218d1531a066de60a95d2924a6910e990"
CCM encrypt and tag NIST VADT AES-192 #9 (P=24, N=13, A=8, T=16)
depends_on:0
4:exp:0:hex:"72e6cebdaf88205c4e74428664bc0d7eb4687a272217b7ca":hex:"54bc7e3c227df4e83252a5848fea12dfdb2d14b9e67c1629":hex:"3820db475c7cb04a0f74d8e449":hex:"f427c47e10c45bb3":hex:"91e7baff2b42af63e26c87ce6991af22422c1f82906858b1721961de5c768f4d19bd3034f44f08d2"
CCM encrypt and tag NIST VADT AES-192 #10 (P=24, N=13, A=9, T=16)
depends_on:0
4:exp:0:hex:"39c03a0c8634047b1635348f284d3dc1e752ab40548eb337":hex:"0662e63c88e963d3e0cf2c4653515ae4474a2c78ab0394c0":hex:"9e2ea8eb7f56087ee506925648":hex:"28d157f09a71da80dd":hex:"01dcd4dd3b8c1369518136ce45e8bb9df565b0ad231a887b02ada34addf0aa2f4744ed2e07995491"
CCM encrypt and tag NIST VADT AES-192 #11 (P=24, N=13, A=10, T=16)
depends_on:0
4:exp:0:hex:"e2a92ffbb0b5eb68cb82687f12449fae5167d375131b0b10":hex:"048c9ba4597c3bb595bfd5048e5e9a1296f30e5c0118b177":hex:"441ad5e1382e083a95224f395d":hex:"2352648299b0413cb2ce":hex:"25247a258e4ac0a988d8def60cc174a9d4578cd5346fb5150c96e8ab8774baa421f39c64a386c418"
CCM encrypt and tag NIST VADT AES-192 #12 (P=24, N=13, A=11, T=16)
depends_on:0
4:exp:0:hex:"ef1ad3eb0bde7d4728389da2255d1f8a66ecb72e6f2f1ac4":hex:"9f580cc6c62a05ce125c6bec109a48ca527ee26a64b14b68":hex:"8e7d8a44244daa7df2b340993e":hex:"521583c25eb4a3b2e46120":hex:"ff0ff95bcb0bccd5e4aadd77ac6770f5013654eb3c6386fded2c87135861b43a99f258b6938f66e3"
CCM encrypt and tag NIST VADT AES-192 #13 (P=24, N=13, A=12, T=16)
depends_on:0
4:exp:0:hex:"44cba20b7204ed85327c9c71c6fea00b47ce7bdde9dea490":hex:"6333bde218b784ccd8370492f7c8c722f8ef143af66d71d7":hex:"f3329154d8908f4e4a5b079992":hex:"f1e0af185180d2eb63e50e37":hex:"b9401a4927b34dc15e9193db00212f85f0c319781ec90e3b4484d93cb422cb564acc63d3d18e169c"
CCM encrypt and tag NIST VADT AES-192 #14 (P=24, N=13, A=13, T=16)
depends_on:0
4:exp:0:hex:"b5f43f3ae38a6165f0f990abe9ee50cd9ad7e847a0a51731":hex:"3726c1aaf85ee8099a7ebd3268700e07d4b3f292c65bba34":hex:"13501aebda19a9bf1b5ffaa42a":hex:"ead4c45ff9db54f9902a6de181":hex:"fd80e88f07dad09eed5569a4f9bb65c42ef426dda40450119503d811701642143013f28ce384d912"
CCM encrypt and tag NIST VADT AES-192 #15 (P=24, N=13, A=14, T=16)
depends_on:0
4:exp:0:hex:"13f179aa2a23bc90a85660306394940e9bb226ce3885ec01":hex:"d3b36c6289ad6ae7c5d885fe83d62a76270689ce05fa3b48":hex:"aaa52c63ca1f74a203d08c2078":hex:"5cc924222692979a8e28ab1e0018":hex:"bc4fcef401c2e1d1c335734ff23ea52c3474d2e6f31648a7f58649400ac9e825b038d67f0c2a6f1c"
CCM encrypt and tag NIST VADT AES-192 #16 (P=24, N=13, A=15, T=16)
depends_on:0
4:exp:0:hex:"c1dfc48273d406a3a7b9176f80b2dc4e9a7f68134bab66d2":hex:"67d9728a88f1fac3af43ed6d634ba902896bd226858697d9":hex:"1ac53ba965cdaeeef7326a37e4":hex:"39ba54a410a58a5d11615a2163cc3b":hex:"360f0fc714994e3b59448b50cdd61d511b4f09e0e5fb5ac826a51fe5b9b598a17eb3da10f936813b"
CCM encrypt and tag NIST VADT AES-192 #17 (P=24, N=13, A=16, T=16)
depends_on:0
4:exp:0:hex:"d8a662ab8449bd037da0346a24565683a3bbbbd1800e3c1c":hex:"61fdd10938557080191d13dd6c3002dd445d9af988029199":hex:"166fb8d0e110124c09013e0568":hex:"1c1c082eeb5b8548283d50cc2ace1c35":hex:"23c05927502a4ee6e61e4e10552d49b020643eab476eeacc867601fe79a122a7817819655183283e"
CCM encrypt and tag NIST VADT AES-192 #18 (P=24, N=13, A=17, T=16)
depends_on:0
4:exp:0:hex:"116f4855121d6aa53e8b8b43a2e23d468c8568c744f49de5":hex:"1bd3b5db392402790be16e8d0a715453928f17f3384c13a7":hex:"924322a3ef0c64412f460a91b2":hex:"03c2d22a3bb08bbb96b2811ce4b1110a83":hex:"ad736402626df0f9393fe4491eb812725ad39d6facf20b5b2f9340b0d48a17ae1cc71d7515e61ee9"
CCM encrypt and tag NIST VADT AES-192 #19 (P=24, N=13, A=18, T=16)
depends_on:0
4:exp:0:hex:"e67f3ba11282d61fe36e38cab7b559c2fd9cbe8bf7eb5863":hex:"d7a954dae563b93385c02c82e0143b6c17ce3067d8b54120":hex:"a727ed373886dd872859b92ccd":hex:"68d199e8fced02b7aeba31aa94068a25d27a":hex:"c6cfaa1f54d041089bd81f89197e57a53b2880cefc3f9d877e30b2bcc3f1ea9ec2b8f28bf0af4ecf"
CCM encrypt and tag NIST VADT AES-192 #20 (P=24, N=13, A=19, T=16)
depends_on:0
4:exp:0:hex:"e0a29a2c7840cf9b41de49780b9ee92d646a4bfc5b9da74a":hex:"344dc8b6bd66a1fbbe330a95af5dd2a8783dc264d6a9267d":hex:"fc9fd876b1edded09f70b18824":hex:"36e15baafa0002efbb4bb26503b7e3b79f6c68":hex:"43b3b96aa5a54378f3bb573ffda3e154aa7f425fc3008175b60a77b9d38740356b544b1c0f259086"
CCM encrypt and tag NIST VADT AES-192 #21 (P=24, N=13, A=20, T=16)
depends_on:0
4:exp:0:hex:"26d0a3a8509d97f81379d21981fe1a02c579121ab7356ca0":hex:"37ab2a0b7b69942278e21032fc83eba6cdc34f5285a8b711":hex:"8015c0f07a7acd4b1cbdd21b54":hex:"093ed26ada5628cfb8cfc1391526b3bcc4af97d9":hex:"a3a60b422eb070b499cf6da0a404b13a05cedda549c6b93e6ca0e07e04674f21a46df2659a5905fb"
CCM encrypt and tag NIST VADT AES-192 #22 (P=24, N=13, A=21, T=16)
depends_on:0
4:exp:0:hex:"aac60835c309d837aacc635931af95702a4784c214283ebb":hex:"e8610756528f75607b83926597ef515f4b32a8386437e6d4":hex:"0e20602d4dc38baa1ebf94ded5":hex:"796e55fbe7bed46d025599c258964a99574c523f6a":hex:"e0a3d5f43e688ce104f4ae1a4fcd85500aa6b8fdbcd1b8d3003c0c3b7369e79339433e1754c0937f"
CCM encrypt and tag NIST VADT AES-192 #23 (P=24, N=13, A=22, T=16)
depends_on:0
4:exp:0:hex:"671544bf2988056f7f9ccd526861391a27233793a23f811f":hex:"576b069ae2713f53d2924c1fd68f786cb2eec68892f9e1be":hex:"0a259148a1d081e0df381ecd0c":hex:"61dafc237cb52f83ab773ba8a885462b6f77d4924611":hex:"ce06b3d09b02921f290544032a081a7766612940048867281bb089af0245792c16e6320cf5ffa19e"
CCM encrypt and tag NIST VADT AES-192 #24 (P=24, N=13, A=23, T=16)
depends_on:0
4:exp:0:hex:"90e2c63b6e5394b1aeec03f95a9d13a01a7d4e9d58610786":hex:"44dd098b1f869d670a8a841900c4bef023a1946a0c278354":hex:"dada5465eb9b7229807a39e557":hex:"f5629ca0eea589f6cf963d875a7d2efb656983f2dd2231":hex:"6b38ca85450e05e7b9362ed7e6e291a130ff233b5a561cdef7ec84dd992fdf98514f845dac8f656e"
CCM encrypt and tag NIST VADT AES-192 #25 (P=24, N=13, A=24, T=16)
depends_on:0
4:exp:0:hex:"13cdaaa4f5721c6d7e709cc048063cfb8b9d92e6425903e6":hex:"d7c837971b973f5f651102bf8d032e7dcd10e306739a0d6c":hex:"f97b532259babac5322e9d9a79":hex:"ad6622279832502839a82348486d42e9b38626e8f06317c4":hex:"4709600418f2839841e6d126359f6982bdb53acc7ff209635623d15b24184481eadc63bb8c878fc4"
CCM encrypt and tag NIST VADT AES-192 #26 (P=24, N=13, A=25, T=16)
depends_on:0
4:exp:0:hex:"90851933d4d3257137984cdb9cba2ca737322dac4dbd64bc":hex:"ba1785a149cb8b69a4e011c11a3ff06f6d7218f525ac81b5":hex:"be02df3a840322df8d448c600c":hex:"69a9dd9ac8be489c3a3f7f070bdaca10699171f66ab3da9351":hex:"89ab2efefa8406336d9e2245199fbc9454f0ef650b9ed0f446c7246bd3130803bf8d703ef5bdf15c"
CCM encrypt and tag NIST VADT AES-192 #27 (P=24, N=13, A=26, T=16)
depends_on:0
4:exp:0:hex:"5c5d02c93faa74a848e5046fc52f236049e28cd8096dcac6":hex:"b4da43ebfe9396b68f4689fba8837c68d0064841c6ddd4a7":hex:"54cbf2889437673b8875a0f567":hex:"09fc21ac4a1f43de29621cacf3ad84e055c6b220721af7ce33bb":hex:"d40725397229021a18f3481e3a85f70445557bb2a85e4ae8101a34c777e918e16186fda05a386572"
CCM encrypt and tag NIST VADT AES-192 #28 (P=24, N=13, A=27, T=16)
depends_on:0
4:exp:0:hex:"0234dae5bd7ae66c67ff0c1a3f1a191a0d7bceb451bc2b7d":hex:"0f960a89a7e806f8709047cb7a2e7c4211ad724692c88a05":hex:"16d345606a315ad2406abbcb43":hex:"c37fdf7449fd7e943595d75e977089c623be0a3926e63fdbbfdf4a":hex:"3907880d25f910eab12dd14e704d1b33ea7c453634d54da2a461f44dac1112ae3f9c65671a931d3e"
CCM encrypt and tag NIST VADT AES-192 #29 (P=24, N=13, A=28, T=16)
depends_on:0
4:exp:0:hex:"6351a67fd6daabd2fd49ee944dd41dd37301f958dd17fcc3":hex:"0c0663dd69ccbffbbd0c8c2e9473d0354451ae7a20fa3695":hex:"b8d517b033754058128d13d11a":hex:"511c6924fa96db716f6b053b7a48aebdc1504145a56cd02d6be2590d":hex:"19f2745df5007619c79c84d174e4521b942776478a0601d982c560fede4741e2fd3b54b3a48f3e38"
CCM encrypt and tag NIST VADT AES-192 #30 (P=24, N=13, A=29, T=16)
depends_on:0
4:exp:0:hex:"9a5a9560baed3b8e0e90b92655d4e5f33889e5d7253d9f6c":hex:"5bbe9c1fb2563e3e82999fe097b28da4dc6ff2e020f3b4f3":hex:"c0049382cdd8646756d4e6bff5":hex:"c95a86d52088a8b0107cc5b437a8938b2c9e74e46e2e03bb9bceecdbe3":hex:"6d5401db42b5c48b79203b6ad82806d7460ac4c82ad0809b811020480e834f6fe55900a162a4e61a"
CCM encrypt and tag NIST VADT AES-192 #31 (P=24, N=13, A=30, T=16)
depends_on:0
4:exp:0:hex:"3e61094c80df0053e86d43fccf4e1d3ee2cdb862d3237b0a":hex:"1fada8f4c7daea0d1c370184c169485b80a278708ed41451":hex:"63f00b2488809fdc49ca5f05d5":hex:"a08763ca936abdeece06467bef8c3c47c3a473636a039d4db540c867d3e3":hex:"680dd22f16a1290bde42c9792dfa997aed24d5bd2265b6e095aa6b99d3f894d3790c2aa2dae1ba2c"
CCM encrypt and tag NIST VADT AES-192 #32 (P=24, N=13, A=31, T=16)
depends_on:0
4:exp:0:hex:"b5664dd6ed435df006052f6ded74bb7ce9482ca9229886f7":hex:"0b6de49b530703affc94010c2b793ddc6de0c44d48037ff2":hex:"7a1649896f3e030c18f0205599":hex:"c5f1a26351e53e6509c8bbbed03c42c23ad81c65fccec7ffa1cb494c7f1fc4":hex:"56b02fea595cc24e798691ae905be3d466ca68ca744005dba260b5ea3b047020b73b5bafa17e5084"
CCM encrypt and tag NIST VADT AES-192 #33 (P=24, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"50925853a84a33ff392154e4e737efc18dcfc98f4d5235a9":hex:"718f061e8b972a3adcf465d66c5b28e8661f080127f6722f":hex:"809343e986f6ff47f54d4cac22":hex:"d70aef3532bdc5293a3ebb11589ac1f801c9f93ea0d656e1d04068facf9f768b":hex:"bad3b0e6772e9c4c9c631c095e259d99692292932efb72b8966e91a19617bb748f3495aa433585bb"
CCM encrypt and tag NIST VADT AES-256 #1 (P=24, N=13, A=0, T=16)
depends_on:0
4:exp:0:hex:"26511fb51fcfa75cb4b44da75a6e5a0eb8d9c8f3b906f886df3ba3e6da3a1389":hex:"30d56ff2a25b83fee791110fcaea48e41db7c7f098a81000":hex:"72a60f345a1978fb40f28a2fa4":hex:"":hex:"55f068c0bbba8b598013dd1841fd740fda2902322148ab5e935753e601b79db4ae730b6ae3500731"
CCM encrypt and tag NIST VADT AES-256 #2 (P=24, N=13, A=1, T=16)
depends_on:0
4:exp:0:hex:"a4490ed6ab51dbfccd6f3702a857575dad44da3a27eaf31178abc97da60d1e4b":hex:"1b5cc6b1651dec4bbbf5130343852e971c7ff1774100d9be":hex:"26ceaf6e3b28190a17c4f0c378":hex:"9e":hex:"789bce069a725a96c484e64a9e54dcb7a7c268c85df47815a462ff2dd8ba44a381e1f6edab12b5a9"
CCM encrypt and tag NIST VADT AES-256 #3 (P=24, N=13, A=2, T=16)
depends_on:0
4:exp:0:hex:"df594db94ef8eca56a417afe946085eaed444c7cc648d07d58132e6cb5bc2bc3":hex:"f4d7978fad36223623ccb5bb18a7373cba8a6e3b1c921259":hex:"c1ad812bf2bbb2cdaee4636ee7":hex:"c0c3":hex:"bea778540a90033b2c0d087e3cc447711ea25f7eea96855506ec97f23bd6ea97834f92f7263c3195"
CCM encrypt and tag NIST VADT AES-256 #4 (P=24, N=13, A=3, T=16)
depends_on:0
4:exp:0:hex:"d98193ab2a465e3fcd85651aaeca18b8e91489b73b7c7e93b518c4b5b81fc6ac":hex:"edba7d6312144e90ec9eaace7576045a46e553dcb8ee5a98":hex:"2247dc7e2674e9e0a63fe70613":hex:"4dc2f4":hex:"44b9ea727c847336fd739ad11f4b906b292edb810462f06ef59626ad5cdac2e4d4cb07b538a1fd8f"
CCM encrypt and tag NIST VADT AES-256 #5 (P=24, N=13, A=4, T=16)
depends_on:0
4:exp:0:hex:"45c8afd7373cb0f6b092af3a633d9fd97c4ca378e19d75f9b74d089429726c29":hex:"0b92adbb251dc29a67f0bb97f8e7160862b6c4e843d07fd9":hex:"fdb1fa230ae0b172ff98fc7496":hex:"270981af":hex:"274e2faea3271ea6fa0494c1951f115b5491a893056c3ee4c76fc350e585277e373e9119bf9595cb"
CCM encrypt and tag NIST VADT AES-256 #6 (P=24, N=13, A=5, T=16)
depends_on:0
4:exp:0:hex:"a2e6bf39efd1ceddc92b4333ed92d65efeea6c031ca345adb93a7770a8039bcd":hex:"d822f84b023f12ea9e3ce16b904278e4aaab5e11c2c23f3f":hex:"693cbb46bc8366086ec7cd7776":hex:"3ba11282d6":hex:"9f91fd2f6472e33b02b1eabb9d6655729d44c44dad6b3883fe0667bcc5806b225224b04ade8b21c1"
CCM encrypt and tag NIST VADT AES-256 #7 (P=24, N=13, A=6, T=16)
depends_on:0
4:exp:0:hex:"c5a850167a5bfdf56636ce9e56e2952855504e35cc4f5d24ee5e168853be82d8":hex:"e758796d7db73bccb1697c42df691ac57974b40ca9186a43":hex:"c45b165477e8bfa9ca3a1cd3ca":hex:"4759557e9bab":hex:"93ad58bd5f4f77ac4f92b0ae16c62489e4074c7f152e2ed8a88179e0d32f4928eff13b4ce2873338"
CCM encrypt and tag NIST VADT AES-256 #8 (P=24, N=13, A=7, T=16)
depends_on:0
4:exp:0:hex:"ae8f93c3efe38e2af07e256961dd33028faa0716e5320a7ab319a10d2f4c5548":hex:"bc9ca92a9c9919e39095d3e53fb148694620ae61227e0069":hex:"6333bde218b784ccd8370492f7":hex:"0b1fabdf2a4107":hex:"45811b0c8f754bf03950e520cd4afc81c2e3eb8a11f4fd386d5a6e4b1fbee15d35939c721004502e"
CCM encrypt and tag NIST VADT AES-256 #9 (P=24, N=13, A=8, T=16)
depends_on:0
4:exp:0:hex:"548c2d1eb7d91e003633d4d9ff199e4a8447180edd89ac7867d25a1db288b5ce":hex:"49fd5cbe4aff89dc3b8718f9ce545d612cbbebb289ecbf42":hex:"23b205bd6ff8ed0bab0c98999c":hex:"a6601111cd92c943":hex:"3cfc6211e359ae322802fc9566f377b0dfe17d1dfe0878ebf2a9047e37cc0be1fab0006af8db8dc4"
CCM encrypt and tag NIST VADT AES-256 #10 (P=24, N=13, A=9, T=16)
depends_on:0
4:exp:0:hex:"aab793e377a12484dbdd74c9b3a85c74c286e1cc498663fbd7c718b5633bb91a":hex:"7c0889854658d3408c5d8043aad2f4ae4a89449a36f8a3b8":hex:"10022cddb323e88b3c08f95a0f":hex:"82b8c736037ce2f2e8":hex:"1044250f58857c69f72b5d3454d43949e5c02b3822970b280de1a3f7fc5d06cc30f06075f5504ed7"
CCM encrypt and tag NIST VADT AES-256 #11 (P=24, N=13, A=10, T=16)
depends_on:0
4:exp:0:hex:"06ac39896073a44283611a66ccab067e2dd2faa8da82ff9a45bb29e54d2e6e77":hex:"3216dce3b8b1ce0e79e40fffcac728ab191aaaf319d971d3":hex:"6c7942c9819cf69b817bfcdb0a":hex:"215e2a6c24325340fdec":hex:"c5b3b50ed8a7b7b96b02ba9464b6a2ff80e90548605699a63d70e6dffb31a376a1eb7f94526dca48"
CCM encrypt and tag NIST VADT AES-256 #12 (P=24, N=13, A=11, T=16)
depends_on:0
4:exp:0:hex:"50412c6444bcf9829506ab019e98234af1541061557412740bc120b456052763":hex:"6cdbd63f6d591f59776f828533b28e2453a214d1d0dd8a39":hex:"85684f94c3702c5d870310166d":hex:"f706a3e09df95d3e21d2e0":hex:"8c8b4ae854a5d5c265b25e3b54bded9444cc454b3e0e6a24d6c05eaf406a5ebd578e19edd5227380"
CCM encrypt and tag NIST VADT AES-256 #13 (P=24, N=13, A=12, T=16)
depends_on:0
4:exp:0:hex:"8a56588fe5e125237b6cdc30f940b8d88b2863ec501a0cb00b1abade1b5ce0ed":hex:"c825952293e434ea866db558aaf486ef09a92bf366988f71":hex:"d80210b9f9776ea36dc0e0a787":hex:"e4296d1c8cf4ffc4b2635135":hex:"b8b3b15fdf6a4a0b5abc313afc769e4e8413bd887552583ede3ed995d1b70561c8e28a7b1a7e3dc8"
CCM encrypt and tag NIST VADT AES-256 #14 (P=24, N=13, A=13, T=16)
depends_on:0
4:exp:0:hex:"a4cc7e1c90f8684e6a5f95e6898ab4e3c194cb46e196d8228062b9f3fa744930":hex:"10d4cff95ef490923c9e0906880729d4d05412e7675cce76":hex:"cdc2712e51c7f333d6bad78eee":hex:"569c56b27268d3db54e728aac0":hex:"be3ce3e9dc72499839a98ae52abb17415e8547687e8a3c7b8aaaac20d4c9276f2851cbba2b04d185"
CCM encrypt and tag NIST VADT AES-256 #15 (P=24, N=13, A=14, T=16)
depends_on:0
4:exp:0:hex:"347e12eec56e95aafcc7d25bf10fc756b4e42bc2e43da7f97df24331f27f1f5c":hex:"ca88dddfc876a12f45f19562bc9ca250f43267ab251a7f34":hex:"b8d517b033754058128d13d11a":hex:"511c6924fa96db716f6b053b7a48":hex:"eeedcfa8f5b5b48c1d7e277526eecb7294213b9f5785167ae949b93003dfe63c95c1d49edfb4de3f"
CCM encrypt and tag NIST VADT AES-256 #16 (P=24, N=13, A=15, T=16)
depends_on:0
4:exp:0:hex:"520902aa27c16dee112812b2e685aa203aeb8b8633bd1bfc99728a482d96c1fe":hex:"533fee7d2c7740db55770e48cb1b541d990ea3f8f08ed1a6":hex:"ddf50502f414c1bf24888f1328":hex:"22b4f8f1aac02a9b2ef785d0ff6f93":hex:"fc867b319e0e4ab45ec518a1b5dcec4f29982173f3abfd4d8a8f8d14d2bdac84c3737cfbd75b7c0b"
CCM encrypt and tag NIST VADT AES-256 #17 (P=24, N=13, A=16, T=16)
depends_on:0
4:exp:0:hex:"57da1c2704219ed59abfdf04743a9a93c87a63d471818de0f1564b2db6421562":hex:"ddc3c1aa73fb6de92bb4db138e26f3c2e0543ab4f5924871":hex:"4b60a47b7e90f622fa0bf803e1":hex:"0ae8c012ff39753510df3ee80707e4e2":hex:"daa8256d4753fdf9cfef876295badaba89b45cc497f54d220ec2c6fb687753bca4580adc6aa2f296"
CCM encrypt and tag NIST VADT AES-256 #18 (P=24, N=13, A=17, T=16)
depends_on:0
4:exp:0:hex:"9267ebc99ccf648b146cba3c251187e24a9947d806ceb0ced6894211641a1e0d":hex:"967daf12f16f166b7b5038f83a1cf0b980f5abf4c7746f2a":hex:"9b7298950280e8762ecdc9bbe4":hex:"5824689453bc406bf891b85e4576e38fe8":hex:"7cfe2a7a54306eb8d8a63d3d1ae86794f9a2c22198b2cb4f10ca926f1a430c08c12e23db3d913e93"
CCM encrypt and tag NIST VADT AES-256 #19 (P=24, N=13, A=18, T=16)
depends_on:0
4:exp:0:hex:"7a855e1690ee638de01db43b37401dcd569c1ae03dc73dd0a917d0cadb5abc29":hex:"33ae68ebb8010c6b3da6b9cb29fe9f8bd09b59ec39f4ce4b":hex:"8f160a873a1166c8b32bccbba7":hex:"72674aca7eba2fc0eeafbd143c2c4d8aa6c8":hex:"b22afdf4f12c43ec23e01ac1215a3f5286059211207e957057e9a9203da74387a9468f8af5e27547"
CCM encrypt and tag NIST VADT AES-256 #20 (P=24, N=13, A=19, T=16)
depends_on:0
4:exp:0:hex:"0ebdc6ddb4c502725dd6ee8da95d56a0d1044b4694d6ba8475a4434f23a8474f":hex:"c7360282c85484a5a33ab1c68dd70873ab4e74ffd4a62cd5":hex:"fb717a8c82114477253acc14f6":hex:"41e9d65632f74f449a6842d5e6c4a86ef83791":hex:"2e961b3a2fa1609a4e6fd04bff6ac5e306ae2638706f997b42be2e2ba05c54b619850db5c9d684fe"
CCM encrypt and tag NIST VADT AES-256 #21 (P=24, N=13, A=20, T=16)
depends_on:0
4:exp:0:hex:"2ff64bbec197a63315c2f328dcb4837d0cdc21a5d6f89ff1d97cb51195330cd8":hex:"4a17522da707b4b2587a0ae367a2cd2831bb593a18ef442a":hex:"a235f8ee3de9896b71910ac02c":hex:"2b411bea57b51d10a4d2fb17ef0f204aa53cf112":hex:"1bf122798bd8ee8e73391d589bd046a294d1615794e69cb9e6f3ba30143acbc3a1c1c6ec74333107"
CCM encrypt and tag NIST VADT AES-256 #22 (P=24, N=13, A=21, T=16)
depends_on:0
4:exp:0:hex:"24e9f08a9a007f9976919e10dc432002e2e078a339677f00105c72ed35633a3f":hex:"d3416a81b4246eb0bf8119a72a886bbc0ac9449c69f71d2f":hex:"15977424eeec0ec7f647e6c798":hex:"2d838eb51a4bc69a001a18adf2084a680f02a3c5fc":hex:"e001a8fae390dc5d672cdd18f86a1f728158ec83a002050def9af5679edbcbb7db20ab6af30698db"
CCM encrypt and tag NIST VADT AES-256 #23 (P=24, N=13, A=22, T=16)
depends_on:0
4:exp:0:hex:"0ec1b22b8df05dc92135d2dfbefed8ea81458f5ea1b801e8a218faf6cbdf1a79":hex:"2f59d94d4ab8eeb84c2a6fefb7fb0a3ac059c1e1a65ae34a":hex:"97ebcb8575bb58260208d5c227":hex:"a2f6337f86dd00d1a58448851e95d8c9bace4a5c8710":hex:"7ca0b1dbe34b0391e524b868b0af08b3e096917664d6aa2cabc1f9d0132394149c9062b74b82f04b"
CCM encrypt and tag NIST VADT AES-256 #24 (P=24, N=13, A=23, T=16)
depends_on:0
4:exp:0:hex:"0875020959ed969cfb38636d1d5aabce9658b00171a7614ea9e5395331c7659c":hex:"065ef9eeafbe077c1c7049f43eb0d8999708e8609f214d5c":hex:"451101250ec6f26652249d59dc":hex:"7cc9c51b69f98a06391ab32742fb6365e15106c811fe8a":hex:"990065322a438e136860f7b019807e9feff52a642bf3d44a9163fa7a867f04cab6f52dc250070f31"
CCM encrypt and tag NIST VADT AES-256 #25 (P=24, N=13, A=24, T=16)
depends_on:0
4:exp:0:hex:"ef4c1d2314e671f666cc6667660f1438a293208c7cc29b412d81277f0a635c91":hex:"c99c3e79125b6fd95e737326a842424eb6c6ecea4c0475c4":hex:"50b23b052922366c25dd40e348":hex:"cd0522ebe1fed82465277d1c10ae9316a98b4469be63b180":hex:"76df4be4ec8373864399acda11294b220b9f7c3a7d2b3660b25764e40ac6a171e7e6bab4fdee4288"
CCM encrypt and tag NIST VADT AES-256 #26 (P=24, N=13, A=25, T=16)
depends_on:0
4:exp:0:hex:"8544808e8fbf8c3a5e1d4ca751d4b603af9fe119eabc6923205815e0e748b7e7":hex:"617d54fc6a23601c79e3984f93bfc2d151fde420863206b3":hex:"b44a58724596b4d8dea827c1a0":hex:"f5b2c88f5232c37273b1e66aa31cfa7201e33c21d60054d025":hex:"57b3414db48982c6567265e1e0173bf38fdfaffe4461fbebc1411af83237c0f9eb0bfe8ed914da66"
CCM encrypt and tag NIST VADT AES-256 #27 (P=24, N=13, A=26, T=16)
depends_on:0
4:exp:0:hex:"e19eaddd9f1574447e7e6525f7fd67e3b42807e44fbb60e75d8c3e98abc18361":hex:"b3b0de10b7c0996662f1b064e04e528b7d85ca1166985d33":hex:"a8c459ce0223358826fb1ec0f0":hex:"ef88f4393d6c1e7b7be55a12144209ee051bb779e440432721ef":hex:"d63e6082c95c6c5ff2bc0771321a4f883ef61cff7b99e0ea8a20a1abe7c842ebc08c8c81a2743c81"
CCM encrypt and tag NIST VADT AES-256 #28 (P=24, N=13, A=27, T=16)
depends_on:0
4:exp:0:hex:"9498f02e50487cfbda1ce6459e241233bd4c4cb10281dcb51915dbc7fb6545c0":hex:"0d16cc69caa9f19b88b05e151b3d26accd018ca4a5786a80":hex:"e3bd4bc3a60cddd26c20aa8636":hex:"70cfcb828d483216b46c3cd22e2f9ee879e9e3059b566179b6e16c":hex:"f1c4bedb8d6f91676881daa37656a7e6402f472735b04a0f1f8332f4236437737438e7aa1b5100c7"
CCM encrypt and tag NIST VADT AES-256 #29 (P=24, N=13, A=28, T=16)
depends_on:0
4:exp:0:hex:"3ac7d5bc4698c021e49a685cd71057e09821633957d1d59c3c30cbc3f2d1dbf8":hex:"89198d3acc39b950f0d411119c478c60b2422ffe7e26e00b":hex:"54c8ff5459702aac058bb3be04":hex:"ecbd7091732e49c0f4bda2e63235ea43bbf8c8730f955f9c049dd1ec":hex:"7717b8e4447afcea1eeebf3e39ffdab2f52828e7931ef27e475acd27900478f09fec1f479ab3a7c8"
CCM encrypt and tag NIST VADT AES-256 #30 (P=24, N=13, A=29, T=16)
depends_on:0
4:exp:0:hex:"948882c3667caa81c9b900996e3d591e6fcb3d08333eeb29911e9c6338710c17":hex:"8b9130b0c3c15366831bbb19f377e3209a8dbf7619cd09bd":hex:"43b0aca2f0a9030f90559fa6d3":hex:"a516ca8405e5c8854e667921b5c5e1968bdd052915b55ac9984b7eefb3":hex:"4646b2acdeb11174171da23999cd54e297daa32bbc13d30512e57c576b315f48c11877178389aaa0"
CCM encrypt and tag NIST VADT AES-256 #31 (P=24, N=13, A=30, T=16)
depends_on:0
4:exp:0:hex:"3bf52cc5ee86b9a0190f390a5c0366a560b557000dbe5115fd9ee11630a62769":hex:"094b538110495e938b08cf748a6bcf3e0c80ff9c66570237":hex:"f9fbd02f28ecc929d369182752":hex:"ebf0b3e3199a5c3773c761c725c7600add5f9d8321c9f8e5e5fd1c7a5d2f":hex:"4d8b53016fc8bc9677184c0fa15bbd3d671b9366d82ecb67f8562eadcdcbcdbad1299bea1523f5d2"
CCM encrypt and tag NIST VADT AES-256 #32 (P=24, N=13, A=31, T=16)
depends_on:0
4:exp:0:hex:"e45bb1730d0d539aab3805350ac986540de9f0f6c239ee70395c291397b70309":hex:"bc8b3bc48c7a88c9fafde258b6ccaa9d4f0d018703d63871":hex:"d5c7824af715bb7822b6b340fe":hex:"860f4a09ad8b3d345c2aa18ffb803f0bc3b734a4d047a1437701a5e3d95288":hex:"95f083ad6bbaee6ab540fe023858f8baf25e333fd3e89c00e678a392d228b210dc5c991905dacf3f"
CCM encrypt and tag NIST VADT AES-256 #33 (P=24, N=13, A=32, T=16)
depends_on:0
4:exp:0:hex:"2e6e34070caf1b8820ed39edfa83459abe1c15a1827f1c39f7ac316c4c27910f":hex:"771a7baa9cf83aa253349f6475d5e74dba4525307b022ba7":hex:"c49ccef869bb86d21932cb443b":hex:"d37e35d7cdccd9824a1ae4c787819735e4af798a3beb49d4705336d6496853ad":hex:"eebac2475004970071dfa2cfb855c4e78b1add8dcbccfc0bd6b14027324b657a56263df148665393"
CCM auth decrypt tag NIST DVPT AES-128 #1 (P=0, N=7, A=0, T=4)
depends_on:0
5:exp:0:hex:"4ae701103c63deca5b5a3939d7d05992":hex:"02209f55":hex:"5a8aa485c316e9":hex:"":int:4:int:0:hex:""
CCM auth decrypt tag NIST DVPT AES-128 #2 (P=0, N=7, A=0, T=4)
depends_on:0
5:exp:0:hex:"4ae701103c63deca5b5a3939d7d05992":hex:"9a04c241":hex:"3796cf51b87266":hex:"":int:4:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-128 #3 (P=0, N=7, A=0, T=16)
depends_on:0
5:exp:0:hex:"4bb3c4a4f893ad8c9bdc833c325d62b3":hex:"75d582db43ce9b13ab4b6f7f14341330":hex:"5a8aa485c316e9":hex:"":int:16:int:0:hex:""
CCM auth decrypt tag NIST DVPT AES-128 #4 (P=0, N=7, A=0, T=16)
depends_on:0
5:exp:0:hex:"4bb3c4a4f893ad8c9bdc833c325d62b3":hex:"3a65e03af37b81d05acc7ec1bc39deb0":hex:"3796cf51b87266":hex:"":int:16:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-128 #5 (P=0, N=13, A=0, T=4)
depends_on:0
5:exp:0:hex:"4bb3c4a4f893ad8c9bdc833c325d62b3":hex:"90156f3f":hex:"5a8aa485c316e9403aff859fbb":hex:"":int:4:int:0:hex:""
CCM auth decrypt tag NIST DVPT AES-128 #6 (P=0, N=13, A=0, T=4)
depends_on:0
5:exp:0:hex:"4bb3c4a4f893ad8c9bdc833c325d62b3":hex:"88909016":hex:"a16a2e741f1cd9717285b6d882":hex:"":int:4:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-128 #7 (P=0, N=13, A=0, T=16)
depends_on:0
5:exp:0:hex:"19ebfde2d5468ba0a3031bde629b11fd":hex:"fb04dc5a44c6bb000f2440f5154364b4":hex:"5a8aa485c316e9403aff859fbb":hex:"":int:16:int:0:hex:""
CCM auth decrypt tag NIST DVPT AES-128 #8 (P=0, N=13, A=0, T=16)
depends_on:0
5:exp:0:hex:"19ebfde2d5468ba0a3031bde629b11fd":hex:"5447075bf42a59b91f08064738b015ab":hex:"a16a2e741f1cd9717285b6d882":hex:"":int:16:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-128 #9 (P=24, N=7, A=0, T=4)
depends_on:0
5:exp:0:hex:"19ebfde2d5468ba0a3031bde629b11fd":hex:"a90e8ea44085ced791b2fdb7fd44b5cf0bd7d27718029bb703e1fa6b":hex:"5a8aa485c316e9":hex:"":int:4:int:0:hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22"
CCM auth decrypt tag NIST DVPT AES-128 #10 (P=24, N=7, A=0, T=4)
depends_on:0
5:exp:0:hex:"19ebfde2d5468ba0a3031bde629b11fd":hex:"50aafe0578c115c4a8e126ff7b3ccb64dce8ccaa8ceda69f23e5d81c":hex:"31f8fa25827d48":hex:"":int:4:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-128 #11 (P=24, N=7, A=0, T=16)
depends_on:0
5:exp:0:hex:"197afb02ffbd8f699dacae87094d5243":hex:"24ab9eeb0e5508cae80074f1070ee188a637171860881f1f2d9a3fbc210595b7b8b1b41523111a8e":hex:"5a8aa485c316e9":hex:"":int:16:int:0:hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22"
CCM auth decrypt tag NIST DVPT AES-128 #12 (P=24, N=7, A=0, T=16)
depends_on:0
5:exp:0:hex:"197afb02ffbd8f699dacae87094d5243":hex:"7ebfda6fa5da1dbffd82dc29b875798fbcef8ba0084fbd2463af747cc88a001fa94e060290f209c4":hex:"31f8fa25827d48":hex:"":int:16:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-128 #13 (P=24, N=13, A=0, T=4)
depends_on:0
5:exp:0:hex:"197afb02ffbd8f699dacae87094d5243":hex:"4a550134f94455979ec4bf89ad2bd80d25a77ae94e456134a3e138b9":hex:"5a8aa485c316e9403aff859fbb":hex:"":int:4:int:0:hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697"
CCM auth decrypt tag NIST DVPT AES-128 #14 (P=24, N=13, A=0, T=4)
depends_on:0
5:exp:0:hex:"197afb02ffbd8f699dacae87094d5243":hex:"118ec53dd1bfbe52d5b9fe5dfebecf2ee674ec983eada654091a5ae9":hex:"49004912fdd7269279b1f06a89":hex:"":int:4:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-128 #15 (P=24, N=13, A=0, T=16)
depends_on:0
5:exp:0:hex:"90929a4b0ac65b350ad1591611fe4829":hex:"4bfe4e35784f0a65b545477e5e2f4bae0e1e6fa717eaf2cb6a9a970b9beb2ac1bd4fd62168f8378a":hex:"5a8aa485c316e9403aff859fbb":hex:"":int:16:int:0:hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697"
CCM auth decrypt tag NIST DVPT AES-128 #16 (P=24, N=13, A=0, T=16)
depends_on:0
5:exp:0:hex:"90929a4b0ac65b350ad1591611fe4829":hex:"0c56a503aa2c12e87450d45a7b714db980fd348f327c0065a65666144994bad0c8195bcb4ade1337":hex:"49004912fdd7269279b1f06a89":hex:"":int:16:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-128 #17 (P=0, N=7, A=32, T=4)
depends_on:0
5:exp:0:hex:"90929a4b0ac65b350ad1591611fe4829":hex:"782e4318":hex:"5a8aa485c316e9":hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22ec22b1a268f88e2c":int:4:int:0:hex:""
CCM auth decrypt tag NIST DVPT AES-128 #18 (P=0, N=7, A=32, T=4)
depends_on:0
5:exp:0:hex:"90929a4b0ac65b350ad1591611fe4829":hex:"a04f270a":hex:"a265480ca88d5f":hex:"a2248a882ecbf850daf91933a389e78e81623d233dfd47bf8321361a38f138fe":int:4:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-128 #19 (P=0, N=7, A=32, T=16)
depends_on:0
5:exp:0:hex:"6a798d7c5e1a72b43e20ad5c7b08567b":hex:"41b476013f45e4a781f253a6f3b1e530":hex:"5a8aa485c316e9":hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22ec22b1a268f88e2c":int:16:int:0:hex:""
CCM auth decrypt tag NIST DVPT AES-128 #20 (P=0, N=7, A=32, T=16)
depends_on:0
5:exp:0:hex:"6a798d7c5e1a72b43e20ad5c7b08567b":hex:"f9f018fcd125822616083fffebc4c8e6":hex:"a265480ca88d5f":hex:"a2248a882ecbf850daf91933a389e78e81623d233dfd47bf8321361a38f138fe":int:16:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-128 #21 (P=0, N=13, A=32, T=4)
depends_on:0
5:exp:0:hex:"6a798d7c5e1a72b43e20ad5c7b08567b":hex:"9f69f24f":hex:"5a8aa485c316e9403aff859fbb":hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697a7ee6410184c7982":int:4:int:0:hex:""
CCM auth decrypt tag NIST DVPT AES-128 #22 (P=0, N=13, A=32, T=4)
depends_on:0
5:exp:0:hex:"6a798d7c5e1a72b43e20ad5c7b08567b":hex:"e17afaa4":hex:"8739b4bea1a099fe547499cbc6":hex:"f6107696edb332b2ea059d8860fee26be42e5e12e1a4f79a8d0eafce1b2278a7":int:4:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-128 #23 (P=0, N=13, A=32, T=16)
depends_on:0
5:exp:0:hex:"f9fdca4ac64fe7f014de0f43039c7571":hex:"1859ac36a40a6b28b34266253627797a":hex:"5a8aa485c316e9403aff859fbb":hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697a7ee6410184c7982":int:16:int:0:hex:""
CCM auth decrypt tag NIST DVPT AES-128 #24 (P=0, N=13, A=32, T=16)
depends_on:0
5:exp:0:hex:"f9fdca4ac64fe7f014de0f43039c7571":hex:"edf8b46eb69ac0044116019dec183072":hex:"8739b4bea1a099fe547499cbc6":hex:"f6107696edb332b2ea059d8860fee26be42e5e12e1a4f79a8d0eafce1b2278a7":int:16:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-128 #25 (P=24, N=7, A=32, T=4)
depends_on:0
5:exp:0:hex:"f9fdca4ac64fe7f014de0f43039c7571":hex:"6be31860ca271ef448de8f8d8b39346daf4b81d7e92d65b338f125fa":hex:"5a8aa485c316e9":hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22ec22b1a268f88e2c":int:4:int:0:hex:"a265480ca88d5f536db0dc6abc40faf0d05be7a966977768"
CCM auth decrypt tag NIST DVPT AES-128 #26 (P=24, N=7, A=32, T=4)
depends_on:0
5:exp:0:hex:"f9fdca4ac64fe7f014de0f43039c7571":hex:"4cc57a9927a6bc401441870d3193bf89ebd163f5c01501c728a66b69":hex:"fdd2d6f503c915":hex:"5b92394f21ddc3ad49d9b0881b829a5935cb3a4d23e292a62fb66b5e7ab7020e":int:4:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-128 #27 (P=24, N=7, A=32, T=16)
depends_on:0
5:exp:0:hex:"a7aa635ea51b0bb20a092bd5573e728c":hex:"b351ab96b2e45515254558d5212673ee6c776d42dbca3b512cf3a20b7fd7c49e6e79bef475c2906f":hex:"5a8aa485c316e9":hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22ec22b1a268f88e2c":int:16:int:0:hex:"a265480ca88d5f536db0dc6abc40faf0d05be7a966977768"
CCM auth decrypt tag NIST DVPT AES-128 #28 (P=24, N=7, A=32, T=16)
depends_on:0
5:exp:0:hex:"a7aa635ea51b0bb20a092bd5573e728c":hex:"df1a5285caa41b4bb47f6e5ceceba4e82721828d68427a3081d18ca149d6766bfaccec88f194eb5b":hex:"fdd2d6f503c915":hex:"5b92394f21ddc3ad49d9b0881b829a5935cb3a4d23e292a62fb66b5e7ab7020e":int:16:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-128 #29 (P=24, N=13, A=32, T=4)
depends_on:0
5:exp:0:hex:"a7aa635ea51b0bb20a092bd5573e728c":hex:"934f893824e880f743d196b22d1f340a52608155087bd28ac25e5329":hex:"5a8aa485c316e9403aff859fbb":hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697a7ee6410184c7982":int:4:int:0:hex:"8739b4bea1a099fe547499cbc6d1b13d849b8084c9b6acc5"
CCM auth decrypt tag NIST DVPT AES-128 #30 (P=24, N=13, A=32, T=4)
depends_on:0
5:exp:0:hex:"a7aa635ea51b0bb20a092bd5573e728c":hex:"f43ba9d834ad85dfab3f1c0c27c3441fe4e411a38a261a6559b3b3ee":hex:"0812757ad0cc4d17c4cfe7a642":hex:"ec6c44a7e94e51a3ca6dee229098391575ec7213c85267fbf7492fdbeee61b10":int:4:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-128 #31 (P=24, N=13, A=32, T=16)
depends_on:0
5:exp:0:hex:"26511fb51fcfa75cb4b44da75a6e5a0e":hex:"50038b5fdd364ee747b70d00bd36840ece4ea19998123375c0a458bfcafa3b2609afe0f825cbf503":hex:"5a8aa485c316e9403aff859fbb":hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697a7ee6410184c7982":int:16:int:0:hex:"8739b4bea1a099fe547499cbc6d1b13d849b8084c9b6acc5"
CCM auth decrypt tag NIST DVPT AES-128 #32 (P=24, N=13, A=32, T=16)
depends_on:0
5:exp:0:hex:"26511fb51fcfa75cb4b44da75a6e5a0e":hex:"78ed8ff6b5a1255d0fbd0a719a9c27b059ff5f83d0c4962c390042ba8bb5f6798dab01c5afad7306":hex:"0812757ad0cc4d17c4cfe7a642":hex:"ec6c44a7e94e51a3ca6dee229098391575ec7213c85267fbf7492fdbeee61b10":int:16:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-192 #1 (P=0, N=7, A=0, T=4)
depends_on:0
5:exp:0:hex:"c98ad7f38b2c7e970c9b965ec87a08208384718f78206c6c":hex:"9d4b7f3b":hex:"5a8aa485c316e9":hex:"":int:4:int:0:hex:""
CCM auth decrypt tag NIST DVPT AES-192 #2 (P=0, N=7, A=0, T=4)
depends_on:0
5:exp:0:hex:"c98ad7f38b2c7e970c9b965ec87a08208384718f78206c6c":hex:"80745de9":hex:"3796cf51b87266":hex:"":int:4:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-192 #3 (P=0, N=7, A=0, T=16)
depends_on:0
5:exp:0:hex:"4bb3c4a4f893ad8c9bdc833c325d62b3d3ad1bccf9282a65":hex:"17223038fa99d53681ca1beabe78d1b4":hex:"5a8aa485c316e9":hex:"":int:16:int:0:hex:""
CCM auth decrypt tag NIST DVPT AES-192 #4 (P=0, N=7, A=0, T=16)
depends_on:0
5:exp:0:hex:"4bb3c4a4f893ad8c9bdc833c325d62b3d3ad1bccf9282a65":hex:"d0e1eeef4d2a264536bb1c2c1bde7c35":hex:"3796cf51b87266":hex:"":int:16:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-192 #5 (P=0, N=13, A=0, T=4)
depends_on:0
5:exp:0:hex:"4bb3c4a4f893ad8c9bdc833c325d62b3d3ad1bccf9282a65":hex:"fe69ed84":hex:"5a8aa485c316e9403aff859fbb":hex:"":int:4:int:0:hex:""
CCM auth decrypt tag NIST DVPT AES-192 #6 (P=0, N=13, A=0, T=4)
depends_on:0
5:exp:0:hex:"4bb3c4a4f893ad8c9bdc833c325d62b3d3ad1bccf9282a65":hex:"db7ffc82":hex:"a16a2e741f1cd9717285b6d882":hex:"":int:4:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-192 #7 (P=0, N=13, A=0, T=16)
depends_on:0
5:exp:0:hex:"19ebfde2d5468ba0a3031bde629b11fd4094afcb205393fa":hex:"0c66a8e547ed4f8c2c9a9a1eb5d455b9":hex:"5a8aa485c316e9403aff859fbb":hex:"":int:16:int:0:hex:""
CCM auth decrypt tag NIST DVPT AES-192 #8 (P=0, N=13, A=0, T=16)
depends_on:0
5:exp:0:hex:"19ebfde2d5468ba0a3031bde629b11fd4094afcb205393fa":hex:"38757b3a61a4dc97ca3ab88bf1240695":hex:"a16a2e741f1cd9717285b6d882":hex:"":int:16:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-192 #9 (P=24, N=7, A=0, T=4)
depends_on:0
5:exp:0:hex:"19ebfde2d5468ba0a3031bde629b11fd4094afcb205393fa":hex:"411986d04d6463100bff03f7d0bde7ea2c3488784378138cddc93a54":hex:"5a8aa485c316e9":hex:"":int:4:int:0:hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22"
CCM auth decrypt tag NIST DVPT AES-192 #10 (P=24, N=7, A=0, T=4)
depends_on:0
5:exp:0:hex:"19ebfde2d5468ba0a3031bde629b11fd4094afcb205393fa":hex:"32b649ab56162e55d4148a1292d6a225a988eb1308298273b6889036":hex:"31f8fa25827d48":hex:"":int:4:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-192 #11 (P=24, N=7, A=0, T=16)
depends_on:0
5:exp:0:hex:"197afb02ffbd8f699dacae87094d524324576b99844f75e1":hex:"cba4b4aeb85f0492fd8d905c4a6d8233139833373ef188a8c5a5ebecf7ac8607fe412189e83d9d20":hex:"5a8aa485c316e9":hex:"":int:16:int:0:hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22"
CCM auth decrypt tag NIST DVPT AES-192 #12 (P=24, N=7, A=0, T=16)
depends_on:0
5:exp:0:hex:"197afb02ffbd8f699dacae87094d524324576b99844f75e1":hex:"ca62713728b5c9d652504b0ae8fd4fee5d297ee6a8d19cb6e699f15f14d34dcaf9ba8ed4b877c97d":hex:"31f8fa25827d48":hex:"":int:16:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-192 #13 (P=24, N=13, A=0, T=4)
depends_on:0
5:exp:0:hex:"197afb02ffbd8f699dacae87094d524324576b99844f75e1":hex:"042653c674ef2a90f7fb11d30848e530ae59478f1051633a34fad277":hex:"5a8aa485c316e9403aff859fbb":hex:"":int:4:int:0:hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697"
CCM auth decrypt tag NIST DVPT AES-192 #14 (P=24, N=13, A=0, T=4)
depends_on:0
5:exp:0:hex:"197afb02ffbd8f699dacae87094d524324576b99844f75e1":hex:"1902d9769a7ba3d3268e1257395c8c2e5f98eef295dcbfa5a35df775":hex:"49004912fdd7269279b1f06a89":hex:"":int:4:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-192 #15 (P=24, N=13, A=0, T=16)
depends_on:0
5:exp:0:hex:"90929a4b0ac65b350ad1591611fe48297e03956f6083e451":hex:"a5b7d8cca2069908d1ed88e6a9fe2c9bede3131dad54671ea7ade30a07d185692ab0ebdf4c78cf7a":hex:"5a8aa485c316e9403aff859fbb":hex:"":int:16:int:0:hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697"
CCM auth decrypt tag NIST DVPT AES-192 #16 (P=24, N=13, A=0, T=16)
depends_on:0
5:exp:0:hex:"90929a4b0ac65b350ad1591611fe48297e03956f6083e451":hex:"9a98617fb97a0dfe466be692272dcdaec1c5443a3b51312ef042c86363cc05afb98c66e16be8a445":hex:"49004912fdd7269279b1f06a89":hex:"":int:16:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-192 #17 (P=0, N=7, A=32, T=4)
depends_on:0
5:exp:0:hex:"90929a4b0ac65b350ad1591611fe48297e03956f6083e451":hex:"1d089a5f":hex:"5a8aa485c316e9":hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22ec22b1a268f88e2c":int:4:int:0:hex:""
CCM auth decrypt tag NIST DVPT AES-192 #18 (P=0, N=7, A=32, T=4)
depends_on:0
5:exp:0:hex:"90929a4b0ac65b350ad1591611fe48297e03956f6083e451":hex:"2f46022a":hex:"a265480ca88d5f":hex:"a2248a882ecbf850daf91933a389e78e81623d233dfd47bf8321361a38f138fe":int:4:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-192 #19 (P=0, N=7, A=32, T=16)
depends_on:0
5:exp:0:hex:"6a798d7c5e1a72b43e20ad5c7b08567b12ab744b61c070e2":hex:"5280a2137fee3deefcfe9b63a1199fb3":hex:"5a8aa485c316e9":hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22ec22b1a268f88e2c":int:16:int:0:hex:""
CCM auth decrypt tag NIST DVPT AES-192 #20 (P=0, N=7, A=32, T=16)
depends_on:0
5:exp:0:hex:"6a798d7c5e1a72b43e20ad5c7b08567b12ab744b61c070e2":hex:"d40a7318c5f2d82f838c0beeefe0d598":hex:"a265480ca88d5f":hex:"a2248a882ecbf850daf91933a389e78e81623d233dfd47bf8321361a38f138fe":int:16:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-192 #21 (P=0, N=13, A=32, T=4)
depends_on:0
5:exp:0:hex:"6a798d7c5e1a72b43e20ad5c7b08567b12ab744b61c070e2":hex:"5e0eaebd":hex:"5a8aa485c316e9403aff859fbb":hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697a7ee6410184c7982":int:4:int:0:hex:""
CCM auth decrypt tag NIST DVPT AES-192 #22 (P=0, N=13, A=32, T=4)
depends_on:0
5:exp:0:hex:"6a798d7c5e1a72b43e20ad5c7b08567b12ab744b61c070e2":hex:"71b7fc33":hex:"8739b4bea1a099fe547499cbc6":hex:"f6107696edb332b2ea059d8860fee26be42e5e12e1a4f79a8d0eafce1b2278a7":int:4:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-192 #23 (P=0, N=13, A=32, T=16)
depends_on:0
5:exp:0:hex:"f9fdca4ac64fe7f014de0f43039c757194d544ce5d15eed4":hex:"d07ccf9fdc3d33aa94cda3d230da707c":hex:"5a8aa485c316e9403aff859fbb":hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697a7ee6410184c7982":int:16:int:0:hex:""
CCM auth decrypt tag NIST DVPT AES-192 #24 (P=0, N=13, A=32, T=16)
depends_on:0
5:exp:0:hex:"f9fdca4ac64fe7f014de0f43039c757194d544ce5d15eed4":hex:"65fe32b649dc328c9f531584897e85b3":hex:"8739b4bea1a099fe547499cbc6":hex:"f6107696edb332b2ea059d8860fee26be42e5e12e1a4f79a8d0eafce1b2278a7":int:16:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-192 #25 (P=24, N=7, A=32, T=4)
depends_on:0
5:exp:0:hex:"f9fdca4ac64fe7f014de0f43039c757194d544ce5d15eed4":hex:"9f6ca4af9b159148c889a6584d1183ea26e2614874b0504575dea8d1":hex:"5a8aa485c316e9":hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22ec22b1a268f88e2c":int:4:int:0:hex:"a265480ca88d5f536db0dc6abc40faf0d05be7a966977768"
CCM auth decrypt tag NIST DVPT AES-192 #26 (P=24, N=7, A=32, T=4)
depends_on:0
5:exp:0:hex:"f9fdca4ac64fe7f014de0f43039c757194d544ce5d15eed4":hex:"84d8212e9cfc2121252baa3b065b1edcf50497b9594db1ebd7965825":hex:"fdd2d6f503c915":hex:"5b92394f21ddc3ad49d9b0881b829a5935cb3a4d23e292a62fb66b5e7ab7020e":int:4:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-192 #27 (P=24, N=7, A=32, T=16)
depends_on:0
5:exp:0:hex:"a7aa635ea51b0bb20a092bd5573e728ccd4b3e8cdd2ab33d":hex:"6aab64c4787599d8f213446beadb16e08dba60e97f56dbd14d1d980d6fe0fb44b421992662b97975":hex:"5a8aa485c316e9":hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22ec22b1a268f88e2c":int:16:int:0:hex:"a265480ca88d5f536db0dc6abc40faf0d05be7a966977768"
CCM auth decrypt tag NIST DVPT AES-192 #28 (P=24, N=7, A=32, T=16)
depends_on:0
5:exp:0:hex:"a7aa635ea51b0bb20a092bd5573e728ccd4b3e8cdd2ab33d":hex:"4980b2ee49b1aaf393175f5ab9bae95ec7904557dfa206603c51d36c826f01384100886198a7f6a3":hex:"fdd2d6f503c915":hex:"5b92394f21ddc3ad49d9b0881b829a5935cb3a4d23e292a62fb66b5e7ab7020e":int:16:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-192 #29 (P=24, N=13, A=32, T=4)
depends_on:0
5:exp:0:hex:"a7aa635ea51b0bb20a092bd5573e728ccd4b3e8cdd2ab33d":hex:"16e543d0e20615ff0df15acd9927ddfe40668a54bb854cccc25e9fce":hex:"5a8aa485c316e9403aff859fbb":hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697a7ee6410184c7982":int:4:int:0:hex:"8739b4bea1a099fe547499cbc6d1b13d849b8084c9b6acc5"
CCM auth decrypt tag NIST DVPT AES-192 #30 (P=24, N=13, A=32, T=4)
depends_on:0
5:exp:0:hex:"a7aa635ea51b0bb20a092bd5573e728ccd4b3e8cdd2ab33d":hex:"df35b109caf690656ae278bbd8f8bba687a2ce11b105dae98ecedb3e":hex:"0812757ad0cc4d17c4cfe7a642":hex:"ec6c44a7e94e51a3ca6dee229098391575ec7213c85267fbf7492fdbeee61b10":int:4:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-192 #31 (P=24, N=13, A=32, T=16)
depends_on:0
5:exp:0:hex:"26511fb51fcfa75cb4b44da75a6e5a0eb8d9c8f3b906f886":hex:"c5b0b2ef17498c5570eb335df4588032958ba3d69bf6f3178464a6f7fa2b76744e8e8d95691cecb8":hex:"5a8aa485c316e9403aff859fbb":hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697a7ee6410184c7982":int:16:int:0:hex:"8739b4bea1a099fe547499cbc6d1b13d849b8084c9b6acc5"
CCM auth decrypt tag NIST DVPT AES-192 #32 (P=24, N=13, A=32, T=16)
depends_on:0
5:exp:0:hex:"26511fb51fcfa75cb4b44da75a6e5a0eb8d9c8f3b906f886":hex:"d1f0518929f4ae2f0543de2a7dfe4bb0110bb3057e524a1c06bd6dc2e6bcc3436cffb969ae900388":hex:"0812757ad0cc4d17c4cfe7a642":hex:"ec6c44a7e94e51a3ca6dee229098391575ec7213c85267fbf7492fdbeee61b10":int:16:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-256 #1 (P=0, N=7, A=0, T=4)
depends_on:0
5:exp:0:hex:"eda32f751456e33195f1f499cf2dc7c97ea127b6d488f211ccc5126fbb24afa6":hex:"469c90bb":hex:"a544218dadd3c1":hex:"":int:4:int:0:hex:""
CCM auth decrypt tag NIST DVPT AES-256 #2 (P=0, N=7, A=0, T=4)
depends_on:0
5:exp:0:hex:"eda32f751456e33195f1f499cf2dc7c97ea127b6d488f211ccc5126fbb24afa6":hex:"46a908ed":hex:"d3d5424e20fbec":hex:"":int:4:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-256 #3 (P=0, N=7, A=0, T=16)
depends_on:0
5:exp:0:hex:"e1b8a927a95efe94656677b692662000278b441c79e879dd5c0ddc758bdc9ee8":hex:"8207eb14d33855a52acceed17dbcbf6e":hex:"a544218dadd3c1":hex:"":int:16:int:0:hex:""
CCM auth decrypt tag NIST DVPT AES-256 #4 (P=0, N=7, A=0, T=16)
depends_on:0
5:exp:0:hex:"e1b8a927a95efe94656677b692662000278b441c79e879dd5c0ddc758bdc9ee8":hex:"60f8e127cb4d30db6df0622158cd931d":hex:"d3d5424e20fbec":hex:"":int:16:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-256 #5 (P=0, N=13, A=0, T=4)
depends_on:0
5:exp:0:hex:"e1b8a927a95efe94656677b692662000278b441c79e879dd5c0ddc758bdc9ee8":hex:"8a19a133":hex:"a544218dadd3c10583db49cf39":hex:"":int:4:int:0:hex:""
CCM auth decrypt tag NIST DVPT AES-256 #6 (P=0, N=13, A=0, T=4)
depends_on:0
5:exp:0:hex:"e1b8a927a95efe94656677b692662000278b441c79e879dd5c0ddc758bdc9ee8":hex:"2e317f1b":hex:"3c0e2815d37d844f7ac240ba9d":hex:"":int:4:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-256 #7 (P=0, N=13, A=0, T=16)
depends_on:0
5:exp:0:hex:"af063639e66c284083c5cf72b70d8bc277f5978e80d9322d99f2fdc718cda569":hex:"97e1a8dd4259ccd2e431e057b0397fcf":hex:"a544218dadd3c10583db49cf39":hex:"":int:16:int:0:hex:""
CCM auth decrypt tag NIST DVPT AES-256 #8 (P=0, N=13, A=0, T=16)
depends_on:0
5:exp:0:hex:"af063639e66c284083c5cf72b70d8bc277f5978e80d9322d99f2fdc718cda569":hex:"5a9596c511ea6a8671adefc4f2157d8b":hex:"3c0e2815d37d844f7ac240ba9d":hex:"":int:16:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-256 #9 (P=24, N=7, A=0, T=4)
depends_on:0
5:exp:0:hex:"af063639e66c284083c5cf72b70d8bc277f5978e80d9322d99f2fdc718cda569":hex:"64a1341679972dc5869fcf69b19d5c5ea50aa0b5e985f5b722aa8d59":hex:"a544218dadd3c1":hex:"":int:4:int:0:hex:"d3d5424e20fbec43ae495353ed830271515ab104f8860c98"
CCM auth decrypt tag NIST DVPT AES-256 #10 (P=24, N=7, A=0, T=4)
depends_on:0
5:exp:0:hex:"af063639e66c284083c5cf72b70d8bc277f5978e80d9322d99f2fdc718cda569":hex:"c5b7f802bffc498c1626e3774f1d9f94045dfd8e1a10a20277d00a75":hex:"bfcda8b5a2d0d2":hex:"":int:4:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-256 #11 (P=24, N=7, A=0, T=16)
depends_on:0
5:exp:0:hex:"f7079dfa3b5c7b056347d7e437bcded683abd6e2c9e069d333284082cbb5d453":hex:"bc51c3925a960e7732533e4ef3a4f69ee6826de952bcb0fd374f3bb6db8377ebfc79674858c4f305":hex:"a544218dadd3c1":hex:"":int:16:int:0:hex:"d3d5424e20fbec43ae495353ed830271515ab104f8860c98"
CCM auth decrypt tag NIST DVPT AES-256 #12 (P=24, N=7, A=0, T=16)
depends_on:0
5:exp:0:hex:"f7079dfa3b5c7b056347d7e437bcded683abd6e2c9e069d333284082cbb5d453":hex:"afa1fa8e8a70e26b02161150556d604101fdf423f332c3363275f2a4907d51b734fe7238cebbd48f":hex:"bfcda8b5a2d0d2":hex:"":int:16:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-256 #13 (P=24, N=13, A=0, T=4)
depends_on:0
5:exp:0:hex:"f7079dfa3b5c7b056347d7e437bcded683abd6e2c9e069d333284082cbb5d453":hex:"63e00d30e4b08fd2a1cc8d70fab327b2368e77a93be4f4123d14fb3f":hex:"a544218dadd3c10583db49cf39":hex:"":int:4:int:0:hex:"3c0e2815d37d844f7ac240ba9d6e3a0b2a86f706e885959e"
CCM auth decrypt tag NIST DVPT AES-256 #14 (P=24, N=13, A=0, T=4)
depends_on:0
5:exp:0:hex:"f7079dfa3b5c7b056347d7e437bcded683abd6e2c9e069d333284082cbb5d453":hex:"bb5425b3869b76856ec58e39886fb6f6f2ac13fe44cb132d8d0c0099":hex:"894dcaa61008eb8fb052c60d41":hex:"":int:4:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-256 #15 (P=24, N=13, A=0, T=16)
depends_on:0
5:exp:0:hex:"1b0e8df63c57f05d9ac457575ea764524b8610ae5164e6215f426f5a7ae6ede4":hex:"f0050ad16392021a3f40207bed3521fb1e9f808f49830c423a578d179902f912f9ea1afbce1120b3":hex:"a544218dadd3c10583db49cf39":hex:"":int:16:int:0:hex:"3c0e2815d37d844f7ac240ba9d6e3a0b2a86f706e885959e"
CCM auth decrypt tag NIST DVPT AES-256 #16 (P=24, N=13, A=0, T=16)
depends_on:0
5:exp:0:hex:"1b0e8df63c57f05d9ac457575ea764524b8610ae5164e6215f426f5a7ae6ede4":hex:"c408190d0fbf5034f83b24a8ed9657331a7ce141de4fae769084607b83bd06e6442eac8dacf583cc":hex:"894dcaa61008eb8fb052c60d41":hex:"":int:16:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-256 #17 (P=0, N=7, A=32, T=4)
depends_on:0
5:exp:0:hex:"1b0e8df63c57f05d9ac457575ea764524b8610ae5164e6215f426f5a7ae6ede4":hex:"92d00fbe":hex:"a544218dadd3c1":hex:"d3d5424e20fbec43ae495353ed830271515ab104f8860c988d15b6d36c038eab":int:4:int:0:hex:""
CCM auth decrypt tag NIST DVPT AES-256 #18 (P=0, N=7, A=32, T=4)
depends_on:0
5:exp:0:hex:"1b0e8df63c57f05d9ac457575ea764524b8610ae5164e6215f426f5a7ae6ede4":hex:"9143e5c4":hex:"78c46e3249ca28":hex:"232e957c65ffa11988e830d4617d500f1c4a35c1221f396c41ab214f074ca2dc":int:4:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-256 #19 (P=0, N=7, A=32, T=16)
depends_on:0
5:exp:0:hex:"a4bc10b1a62c96d459fbaf3a5aa3face7313bb9e1253e696f96a7a8e36801088":hex:"93af11a08379eb37a16aa2837f09d69d":hex:"a544218dadd3c1":hex:"d3d5424e20fbec43ae495353ed830271515ab104f8860c988d15b6d36c038eab":int:16:int:0:hex:""
CCM auth decrypt tag NIST DVPT AES-256 #20 (P=0, N=7, A=32, T=16)
depends_on:0
5:exp:0:hex:"a4bc10b1a62c96d459fbaf3a5aa3face7313bb9e1253e696f96a7a8e36801088":hex:"d19b0c14ec686a7961ca7c386d125a65":hex:"78c46e3249ca28":hex:"232e957c65ffa11988e830d4617d500f1c4a35c1221f396c41ab214f074ca2dc":int:16:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-256 #21 (P=0, N=13, A=32, T=4)
depends_on:0
5:exp:0:hex:"a4bc10b1a62c96d459fbaf3a5aa3face7313bb9e1253e696f96a7a8e36801088":hex:"866d4227":hex:"a544218dadd3c10583db49cf39":hex:"3c0e2815d37d844f7ac240ba9d6e3a0b2a86f706e885959e09a1005e024f6907":int:4:int:0:hex:""
CCM auth decrypt tag NIST DVPT AES-256 #22 (P=0, N=13, A=32, T=4)
depends_on:0
5:exp:0:hex:"a4bc10b1a62c96d459fbaf3a5aa3face7313bb9e1253e696f96a7a8e36801088":hex:"94cb1127":hex:"e8de970f6ee8e80ede933581b5":hex:"89f8b068d34f56bc49d839d8e47b347e6dae737b903b278632447e6c0485d26a":int:4:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-256 #23 (P=0, N=13, A=32, T=16)
depends_on:0
5:exp:0:hex:"8c5cf3457ff22228c39c051c4e05ed4093657eb303f859a9d4b0f8be0127d88a":hex:"867b0d87cf6e0f718200a97b4f6d5ad5":hex:"a544218dadd3c10583db49cf39":hex:"3c0e2815d37d844f7ac240ba9d6e3a0b2a86f706e885959e09a1005e024f6907":int:16:int:0:hex:""
CCM auth decrypt tag NIST DVPT AES-256 #24 (P=0, N=13, A=32, T=16)
depends_on:0
5:exp:0:hex:"8c5cf3457ff22228c39c051c4e05ed4093657eb303f859a9d4b0f8be0127d88a":hex:"677a040d46ee3f2b7838273bdad14f16":hex:"e8de970f6ee8e80ede933581b5":hex:"89f8b068d34f56bc49d839d8e47b347e6dae737b903b278632447e6c0485d26a":int:16:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-256 #25 (P=24, N=7, A=32, T=4)
depends_on:0
5:exp:0:hex:"8c5cf3457ff22228c39c051c4e05ed4093657eb303f859a9d4b0f8be0127d88a":hex:"c2fe12658139f5d0dd22cadf2e901695b579302a72fc56083ebc7720":hex:"a544218dadd3c1":hex:"d3d5424e20fbec43ae495353ed830271515ab104f8860c988d15b6d36c038eab":int:4:int:0:hex:"78c46e3249ca28e1ef0531d80fd37c124d9aecb7be6668e3"
CCM auth decrypt tag NIST DVPT AES-256 #26 (P=24, N=7, A=32, T=4)
depends_on:0
5:exp:0:hex:"8c5cf3457ff22228c39c051c4e05ed4093657eb303f859a9d4b0f8be0127d88a":hex:"94748ba81229e53c38583a8564b23ebbafc6f6efdf4c2a81c44db2c9":hex:"6ba004fd176791":hex:"5a053b2a1bb87e85d56527bfcdcd3ecafb991bb10e4c862bb0751c700a29f54b":int:4:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-256 #27 (P=24, N=7, A=32, T=16)
depends_on:0
5:exp:0:hex:"705334e30f53dd2f92d190d2c1437c8772f940c55aa35e562214ed45bd458ffe":hex:"3341168eb8c48468c414347fb08f71d2086f7c2d1bd581ce1ac68bd42f5ec7fa7e068cc0ecd79c2a":hex:"a544218dadd3c1":hex:"d3d5424e20fbec43ae495353ed830271515ab104f8860c988d15b6d36c038eab":int:16:int:0:hex:"78c46e3249ca28e1ef0531d80fd37c124d9aecb7be6668e3"
CCM auth decrypt tag NIST DVPT AES-256 #28 (P=24, N=7, A=32, T=16)
depends_on:0
5:exp:0:hex:"705334e30f53dd2f92d190d2c1437c8772f940c55aa35e562214ed45bd458ffe":hex:"d543acda712b898cbb27b8f598b2e4438ce587a836e2785147c3338a2400809e739b63ba8227d2f9":hex:"6ba004fd176791":hex:"5a053b2a1bb87e85d56527bfcdcd3ecafb991bb10e4c862bb0751c700a29f54b":int:16:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-256 #29 (P=24, N=13, A=32, T=4)
depends_on:0
5:exp:0:hex:"705334e30f53dd2f92d190d2c1437c8772f940c55aa35e562214ed45bd458ffe":hex:"c0ea400b599561e7905b99262b4565d5c3dc49fad84d7c69ef891339":hex:"a544218dadd3c10583db49cf39":hex:"3c0e2815d37d844f7ac240ba9d6e3a0b2a86f706e885959e09a1005e024f6907":int:4:int:0:hex:"e8de970f6ee8e80ede933581b5bcf4d837e2b72baa8b00c3"
CCM auth decrypt tag NIST DVPT AES-256 #30 (P=24, N=13, A=32, T=4)
depends_on:0
5:exp:0:hex:"705334e30f53dd2f92d190d2c1437c8772f940c55aa35e562214ed45bd458ffe":hex:"60871e03ea0eb968536c99f926ea24ef43d41272ad9fb7f63d488623":hex:"8fa501c5dd9ac9b868144c9fa5":hex:"5bb40e3bb72b4509324a7edc852f72535f1f6283156e63f6959ffaf39dcde800":int:4:exp:4:hex:""
CCM auth decrypt tag NIST DVPT AES-256 #31 (P=24, N=13, A=32, T=16)
depends_on:0
5:exp:0:hex:"314a202f836f9f257e22d8c11757832ae5131d357a72df88f3eff0ffcee0da4e":hex:"8d34cdca37ce77be68f65baf3382e31efa693e63f914a781367f30f2eaad8c063ca50795acd90203":hex:"a544218dadd3c10583db49cf39":hex:"3c0e2815d37d844f7ac240ba9d6e3a0b2a86f706e885959e09a1005e024f6907":int:16:int:0:hex:"e8de970f6ee8e80ede933581b5bcf4d837e2b72baa8b00c3"
CCM auth decrypt tag NIST DVPT AES-256 #32 (P=24, N=13, A=32, T=16)
depends_on:0
5:exp:0:hex:"314a202f836f9f257e22d8c11757832ae5131d357a72df88f3eff0ffcee0da4e":hex:"516c0095cc3d85fd55e48da17c592e0c7014b9daafb82bdc4b41096dfdbe9cc1ab610f8f3e038d16":hex:"8fa501c5dd9ac9b868144c9fa5":hex:"5bb40e3bb72b4509324a7edc852f72535f1f6283156e63f6959ffaf39dcde800":int:16:exp:4:hex:""
CCM-Camellia encrypt and tag RFC 5528 #1
depends_on:1
4:exp:1:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"08090A0B0C0D0E0F101112131415161718191A1B1C1D1E":hex:"00000003020100A0A1A2A3A4A5":hex:"0001020304050607":hex:"BA737185E719310492F38A5F1251DA55FAFBC949848A0DFCAECE746B3DB9AD"
CCM-Camellia encrypt and tag RFC 5528 #2
depends_on:1
4:exp:1:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"08090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F":hex:"00000004030201A0A1A2A3A4A5":hex:"0001020304050607":hex:"5D2564BF8EAFE1D99526EC016D1BF0424CFBD2CD62848F3360B2295DF24283E8"
CCM-Camellia encrypt and tag RFC 5528 #3
depends_on:1
4:exp:1:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"08090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F20":hex:"00000005040302A0A1A2A3A4A5":hex:"0001020304050607":hex:"81F663D6C7787817F9203608B982AD15DC2BBD87D756F79204F551D6682F23AA46"
CCM-Camellia encrypt and tag RFC 5528 #4
depends_on:1
4:exp:1:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"0C0D0E0F101112131415161718191A1B1C1D1E":hex:"00000006050403A0A1A2A3A4A5":hex:"000102030405060708090A0B":hex:"CAEF1E827211B08F7BD90F08C77288C070A4A08B3A933A63E497A0"
CCM-Camellia encrypt and tag RFC 5528 #5
depends_on:1
4:exp:1:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"0C0D0E0F101112131415161718191A1B1C1D1E1F":hex:"00000007060504A0A1A2A3A4A5":hex:"000102030405060708090A0B":hex:"2AD3BAD94FC52E92BE438E827C1023B96A8A77258FA17BA7F331DB09"
CCM-Camellia encrypt and tag RFC 5528 #6
depends_on:1
4:exp:1:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"0C0D0E0F101112131415161718191A1B1C1D1E1F20":hex:"00000008070605A0A1A2A3A4A5":hex:"000102030405060708090A0B":hex:"FEA5480BA53FA8D3C34422AACE4DE67FFA3BB73BABAB36A1EE4FE0FE28"
CCM-Camellia encrypt and tag RFC 5528 #7
depends_on:1
4:exp:1:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"08090A0B0C0D0E0F101112131415161718191A1B1C1D1E":hex:"00000009080706A0A1A2A3A4A5":hex:"0001020304050607":hex:"54532026E54C119A8D36D9EC6E1ED97416C8708C4B5C2CACAFA3BCCF7A4EBF9573"
CCM-Camellia encrypt and tag RFC 5528 #8
depends_on:1
4:exp:1:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"08090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F":hex:"0000000A090807A0A1A2A3A4A5":hex:"0001020304050607":hex:"8AD19B001A87D148F4D92BEF34525CCCE3A63C6512A6F5757388E4913EF14701F441"
CCM-Camellia encrypt and tag RFC 5528 #9
depends_on:1
4:exp:1:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"08090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F20":hex:"0000000B0A0908A0A1A2A3A4A5":hex:"0001020304050607":hex:"5DB08D62407E6E31D60F9CA2C60474219AC0BE50C0D4A5778794D6E230CD25C9FEBF87"
CCM-Camellia encrypt and tag RFC 5528 #10
depends_on:1
4:exp:1:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"0C0D0E0F101112131415161718191A1B1C1D1E":hex:"0000000C0B0A09A0A1A2A3A4A5":hex:"000102030405060708090A0B":hex:"DB118CCEC1B8761C877CD8963A67D6F3BBBC5CD09299EB11F312F23237"
CCM-Camellia encrypt and tag RFC 5528 #11
depends_on:1
4:exp:1:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"0C0D0E0F101112131415161718191A1B1C1D1E1F":hex:"0000000D0C0B0AA0A1A2A3A4A5":hex:"000102030405060708090A0B":hex:"7CC83D8DC49103525B483DC5CA7EA9AB812B7056079DAFFADA16CCCF2C4E"
CCM-Camellia encrypt and tag RFC 5528 #12
depends_on:1
4:exp:1:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"0C0D0E0F101112131415161718191A1B1C1D1E1F20":hex:"0000000E0D0C0BA0A1A2A3A4A5":hex:"000102030405060708090A0B":hex:"2CD35B8820D23E7AA351B0E92FC79367238B2CC748CBB94C2947793D64AF75"
CCM-Camellia encrypt and tag RFC 5528 #13
depends_on:1
4:exp:1:hex:"D75C2778078CA93D971F96FDE720F4CD":hex:"C6B5F3E6CA2311AEF7472B203E735EA561ADB17D56C5A3":hex:"00A970110E1927B160B6A31C1C":hex:"6B7F464507FAE496":hex:"A435D727348DDD22907F7EB8F5FDBB4D939DA6524DB4F64558C02D25B127EE"
CCM-Camellia encrypt and tag RFC 5528 #14
depends_on:1
4:exp:1:hex:"D75C2778078CA93D971F96FDE720F4CD":hex:"01F6CE6764C574483BB02E6BBF1E0ABD26A22572B4D80EE7":hex:"0083CD8CE0CB42B160B6A31C1C":hex:"986605B43DF15DE7":hex:"8AE052508FBECA932E346F05E0DC0DFBCF939EAFFA3E587C867D6E1C48703806"
CCM-Camellia encrypt and tag RFC 5528 #15
depends_on:1
4:exp:1:hex:"D75C2778078CA93D971F96FDE720F4CD":hex:"CDF1D8406FC2E9014953897005FBFB8BA57276F92404608E08":hex:"005F54950B18F2B160B6A31C1C":hex:"48F2E7E1A7671A51":hex:"08B67EE21C8BF26E473E408599E9C0836D6AF0BB18DF55466CA80878A790476DE5"
CCM-Camellia encrypt and tag RFC 5528 #16
depends_on:1
4:exp:1:hex:"D75C2778078CA93D971F96FDE720F4CD":hex:"B005DCFA0B59181426A961685A993D8C43185B":hex:"00EC600863319AB160B6A31C1C":hex:"DE97DF3B8CBD6D8E5030DA4C":hex:"63B78B4967B19EDBB733CD1114F64EB226089368C354828D950CC5"
CCM-Camellia encrypt and tag RFC 5528 #17
depends_on:1
4:exp:1:hex:"D75C2778078CA93D971F96FDE720F4CD":hex:"2E20211298105F129D5ED95B93F72D30B2FACCD7":hex:"0060CFF1A31EA1B160B6A31C1C":hex:"A5EE93E457DF05466E782DCF":hex:"0BC6BBE2A8B909F4629EE6DC148DA44410E18AF43147383276F66A9F"
CCM-Camellia encrypt and tag RFC 5528 #18
depends_on:1
4:exp:1:hex:"D75C2778078CA93D971F96FDE720F4CD":hex:"2645941E75632D3491AF0FC0C9876C3BE4AA7468C9":hex:"000F85CD995C97B160B6A31C1C":hex:"24AA1BF9A5CD876182A25074":hex:"222AD632FA31D6AF970C345F7E77CA3BD0DC25B340A1A3D31F8D4B44B7"
CCM-Camellia encrypt and tag RFC 5528 #19
depends_on:1
4:exp:1:hex:"D75C2778078CA93D971F96FDE720F4CD":hex:"070135A6437C9DB120CD61D8F6C39C3EA125FD95A0D23D":hex:"00C29B2CAAC4CDB160B6A31C1C":hex:"691946B9CA07BE87":hex:"05B8E1B9C49CFD56CF130AA6251DC2ECC06CCC508FE697A0066D57C84BEC182768"
CCM-Camellia encrypt and tag RFC 5528 #20
depends_on:1
4:exp:1:hex:"D75C2778078CA93D971F96FDE720F4CD":hex:"C8C0880E6C636E20093DD6594217D2E18877DB264E71A5CC":hex:"002C6B7595EE62B160B6A31C1C":hex:"D0C54ECB84627DC4":hex:"54CEB968DEE23611575EC003DFAA1CD48849BDF5AE2EDB6B7FA775B150ED4383C5A9"
CCM-Camellia encrypt and tag RFC 5528 #21
depends_on:1
4:exp:1:hex:"D75C2778078CA93D971F96FDE720F4CD":hex:"F75DAA0710C4E64297794DC2B7D2A20757B1AA4E448002FFAB":hex:"00C53CD4C2AA24B160B6A31C1C":hex:"E285E0E4808CDA3D":hex:"B1404546BF667210CA28E309B39BD6CA7E9FC8285FE698D43CD20A02E0BDCAED2010D3"
CCM-Camellia encrypt and tag RFC 5528 #22
depends_on:1
4:exp:1:hex:"D75C2778078CA93D971F96FDE720F4CD":hex:"C238822FAC5F98FF929405B0AD127A4E41854E":hex:"00BEE9267FBADCB160B6A31C1C":hex:"6CAEF9941141570D7C813405":hex:"94C8959C11569A297831A721005857AB61B87A2DEA0936B6EB5F625F5D"
CCM-Camellia encrypt and tag RFC 5528 #23
depends_on:1
4:exp:1:hex:"D75C2778078CA93D971F96FDE720F4CD":hex:"4DBF3E774AD245E5D5891F9D1C32A0AE022C85D7":hex:"00DFA8B1245007B160B6A31C1C":hex:"36A52CF16B19A2037AB7011E":hex:"5869E3AAD2447C74E0FC05F9A4EA74577F4DE8CA8924764296AD04119CE7"
CCM-Camellia encrypt and tag RFC 5528 #24
depends_on:1
4:exp:1:hex:"D75C2778078CA93D971F96FDE720F4CD":hex:"9DC9EDAE2FF5DF8636E8C6DE0EED55F7867E33337D":hex:"003B8FD8D3A937B160B6A31C1C":hex:"A4D499F78419728C19178B0C":hex:"4B198156393B0F7796086AAFB454F8C3F034CCA966945F1FCEA7E11BEE6A2F"
| 120,663 | 1,527 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_cipher.blowfish.c | /* clang-format off */
/*
* Copyright The Mbed TLS Contributors
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "third_party/mbedtls/test/test.inc"
/*
* *** THIS FILE WAS MACHINE GENERATED ***
*
* This file has been machine generated using the script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* Test file : ./test_suite_cipher.blowfish.c
*
* The following files were used to create this file.
*
* Main code file : suites/main_test.function
* Platform code file : suites/host_test.function
* Helper file : suites/helpers.function
* Test suite file : suites/test_suite_cipher.function
* Test suite data : suites/test_suite_cipher.blowfish.data
*
*/
#define TEST_SUITE_ACTIVE
#if defined(MBEDTLS_CIPHER_C)
#include "third_party/mbedtls/cipher.h"
#if defined(MBEDTLS_AES_C)
#include "third_party/mbedtls/aes.h"
#endif
#if defined(MBEDTLS_GCM_C)
#include "third_party/mbedtls/gcm.h"
#endif
#if defined(MBEDTLS_CIPHER_MODE_AEAD) || defined(MBEDTLS_NIST_KW_C)
#define MBEDTLS_CIPHER_AUTH_CRYPT
#endif
#if defined(MBEDTLS_CIPHER_AUTH_CRYPT)
/* Helper for resetting key/direction
*
* The documentation doesn't explicitly say whether calling
* mbedtls_cipher_setkey() twice is allowed or not. This currently works with
* the default software implementation, but only by accident. It isn't
* guaranteed to work with new ciphers or with alternative implementations of
* individual ciphers, and it doesn't work with the PSA wrappers. So don't do
* it, and instead start with a fresh context.
*/
static int cipher_reset_key( mbedtls_cipher_context_t *ctx, int cipher_id,
int use_psa, size_t tag_len, const data_t *key, int direction )
{
mbedtls_cipher_free( ctx );
mbedtls_cipher_init( ctx );
#if !defined(MBEDTLS_USE_PSA_CRYPTO)
(void) use_psa;
(void) tag_len;
#else
if( use_psa == 1 )
{
TEST_ASSERT( 0 == mbedtls_cipher_setup_psa( ctx,
mbedtls_cipher_info_from_type( cipher_id ),
tag_len ) );
}
else
#endif /* MBEDTLS_USE_PSA_CRYPTO */
{
TEST_ASSERT( 0 == mbedtls_cipher_setup( ctx,
mbedtls_cipher_info_from_type( cipher_id ) ) );
}
TEST_ASSERT( 0 == mbedtls_cipher_setkey( ctx, key->x, 8 * key->len,
direction ) );
return( 1 );
exit:
return( 0 );
}
/*
* Check if a buffer is all-0 bytes:
* return 1 if it is,
* 0 if it isn't.
*/
int buffer_is_all_zero( const uint8_t *buf, size_t size )
{
for( size_t i = 0; i < size; i++ )
if( buf[i] != 0 )
return 0;
return 1;
}
#endif /* MBEDTLS_CIPHER_AUTH_CRYPT */
void test_mbedtls_cipher_list( )
{
const int *cipher_type;
for( cipher_type = mbedtls_cipher_list(); *cipher_type != 0; cipher_type++ )
TEST_ASSERT( mbedtls_cipher_info_from_type( *cipher_type ) != NULL );
exit:
;
}
void test_mbedtls_cipher_list_wrapper( void ** params )
{
(void)params;
test_mbedtls_cipher_list( );
}
void test_cipher_invalid_param_unconditional( )
{
mbedtls_cipher_context_t valid_ctx;
mbedtls_cipher_context_t invalid_ctx;
mbedtls_operation_t valid_operation = MBEDTLS_ENCRYPT;
mbedtls_cipher_padding_t valid_mode = MBEDTLS_PADDING_ZEROS;
unsigned char valid_buffer[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
int valid_size = sizeof(valid_buffer);
int valid_bitlen = valid_size * 8;
const mbedtls_cipher_info_t *valid_info = mbedtls_cipher_info_from_type(
*( mbedtls_cipher_list() ) );
size_t size_t_var;
(void)valid_mode; /* In some configurations this is unused */
mbedtls_cipher_init( &valid_ctx );
mbedtls_cipher_setup( &valid_ctx, valid_info );
mbedtls_cipher_init( &invalid_ctx );
/* mbedtls_cipher_setup() */
TEST_ASSERT( mbedtls_cipher_setup( &valid_ctx, NULL ) ==
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
/* mbedtls_cipher_get_block_size() */
TEST_ASSERT( mbedtls_cipher_get_block_size( &invalid_ctx ) == 0 );
/* mbedtls_cipher_get_cipher_mode() */
TEST_ASSERT( mbedtls_cipher_get_cipher_mode( &invalid_ctx ) ==
MBEDTLS_MODE_NONE );
/* mbedtls_cipher_get_iv_size() */
TEST_ASSERT( mbedtls_cipher_get_iv_size( &invalid_ctx ) == 0 );
/* mbedtls_cipher_get_type() */
TEST_ASSERT(
mbedtls_cipher_get_type( &invalid_ctx ) ==
MBEDTLS_CIPHER_NONE);
/* mbedtls_cipher_get_name() */
TEST_ASSERT( mbedtls_cipher_get_name( &invalid_ctx ) == 0 );
/* mbedtls_cipher_get_key_bitlen() */
TEST_ASSERT( mbedtls_cipher_get_key_bitlen( &invalid_ctx ) ==
MBEDTLS_KEY_LENGTH_NONE );
/* mbedtls_cipher_get_operation() */
TEST_ASSERT( mbedtls_cipher_get_operation( &invalid_ctx ) ==
MBEDTLS_OPERATION_NONE );
/* mbedtls_cipher_setkey() */
TEST_ASSERT(
mbedtls_cipher_setkey( &invalid_ctx,
valid_buffer,
valid_bitlen,
valid_operation ) ==
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
/* mbedtls_cipher_set_iv() */
TEST_ASSERT(
mbedtls_cipher_set_iv( &invalid_ctx,
valid_buffer,
valid_size ) ==
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
/* mbedtls_cipher_reset() */
TEST_ASSERT( mbedtls_cipher_reset( &invalid_ctx ) ==
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
/* mbedtls_cipher_update_ad() */
TEST_ASSERT(
mbedtls_cipher_update_ad( &invalid_ctx,
valid_buffer,
valid_size ) ==
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
#endif /* defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C) */
#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
/* mbedtls_cipher_set_padding_mode() */
TEST_ASSERT( mbedtls_cipher_set_padding_mode( &invalid_ctx, valid_mode ) ==
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
#endif
/* mbedtls_cipher_update() */
TEST_ASSERT(
mbedtls_cipher_update( &invalid_ctx,
valid_buffer,
valid_size,
valid_buffer,
&size_t_var ) ==
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
/* mbedtls_cipher_finish() */
TEST_ASSERT(
mbedtls_cipher_finish( &invalid_ctx,
valid_buffer,
&size_t_var ) ==
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
/* mbedtls_cipher_write_tag() */
TEST_ASSERT(
mbedtls_cipher_write_tag( &invalid_ctx,
valid_buffer,
valid_size ) ==
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
/* mbedtls_cipher_check_tag() */
TEST_ASSERT(
mbedtls_cipher_check_tag( &invalid_ctx,
valid_buffer,
valid_size ) ==
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
#endif /* defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C) */
exit:
mbedtls_cipher_free( &invalid_ctx );
mbedtls_cipher_free( &valid_ctx );
}
void test_cipher_invalid_param_unconditional_wrapper( void ** params )
{
(void)params;
test_cipher_invalid_param_unconditional( );
}
#if defined(MBEDTLS_CHECK_PARAMS)
#if !defined(MBEDTLS_PARAM_FAILED_ALT)
void test_cipher_invalid_param_conditional( )
{
mbedtls_cipher_context_t valid_ctx;
mbedtls_operation_t valid_operation = MBEDTLS_ENCRYPT;
mbedtls_operation_t invalid_operation = 100;
mbedtls_cipher_padding_t valid_mode = MBEDTLS_PADDING_ZEROS;
unsigned char valid_buffer[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
int valid_size = sizeof(valid_buffer);
int valid_bitlen = valid_size * 8;
const mbedtls_cipher_info_t *valid_info = mbedtls_cipher_info_from_type(
*( mbedtls_cipher_list() ) );
size_t size_t_var;
(void)valid_mode; /* In some configurations this is unused */
/* mbedtls_cipher_init() */
TEST_VALID_PARAM( mbedtls_cipher_init( &valid_ctx ) );
TEST_INVALID_PARAM( mbedtls_cipher_init( NULL ) );
/* mbedtls_cipher_setup() */
TEST_VALID_PARAM( mbedtls_cipher_setup( &valid_ctx, valid_info ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_setup( NULL, valid_info ) );
/* mbedtls_cipher_get_block_size() */
TEST_INVALID_PARAM_RET( 0, mbedtls_cipher_get_block_size( NULL ) );
/* mbedtls_cipher_get_cipher_mode() */
TEST_INVALID_PARAM_RET(
MBEDTLS_MODE_NONE,
mbedtls_cipher_get_cipher_mode( NULL ) );
/* mbedtls_cipher_get_iv_size() */
TEST_INVALID_PARAM_RET( 0, mbedtls_cipher_get_iv_size( NULL ) );
/* mbedtls_cipher_get_type() */
TEST_INVALID_PARAM_RET(
MBEDTLS_CIPHER_NONE,
mbedtls_cipher_get_type( NULL ) );
/* mbedtls_cipher_get_name() */
TEST_INVALID_PARAM_RET( 0, mbedtls_cipher_get_name( NULL ) );
/* mbedtls_cipher_get_key_bitlen() */
TEST_INVALID_PARAM_RET(
MBEDTLS_KEY_LENGTH_NONE,
mbedtls_cipher_get_key_bitlen( NULL ) );
/* mbedtls_cipher_get_operation() */
TEST_INVALID_PARAM_RET(
MBEDTLS_OPERATION_NONE,
mbedtls_cipher_get_operation( NULL ) );
/* mbedtls_cipher_setkey() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_setkey( NULL,
valid_buffer,
valid_bitlen,
valid_operation ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_setkey( &valid_ctx,
NULL,
valid_bitlen,
valid_operation ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_setkey( &valid_ctx,
valid_buffer,
valid_bitlen,
invalid_operation ) );
/* mbedtls_cipher_set_iv() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_set_iv( NULL,
valid_buffer,
valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_set_iv( &valid_ctx,
NULL,
valid_size ) );
/* mbedtls_cipher_reset() */
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_reset( NULL ) );
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
/* mbedtls_cipher_update_ad() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_update_ad( NULL,
valid_buffer,
valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_update_ad( &valid_ctx,
NULL,
valid_size ) );
#endif /* defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C) */
#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
/* mbedtls_cipher_set_padding_mode() */
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_set_padding_mode( NULL, valid_mode ) );
#endif
/* mbedtls_cipher_update() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_update( NULL,
valid_buffer,
valid_size,
valid_buffer,
&size_t_var ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_update( &valid_ctx,
NULL, valid_size,
valid_buffer,
&size_t_var ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_update( &valid_ctx,
valid_buffer, valid_size,
NULL,
&size_t_var ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_update( &valid_ctx,
valid_buffer, valid_size,
valid_buffer,
NULL ) );
/* mbedtls_cipher_finish() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_finish( NULL,
valid_buffer,
&size_t_var ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_finish( &valid_ctx,
NULL,
&size_t_var ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_finish( &valid_ctx,
valid_buffer,
NULL ) );
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
/* mbedtls_cipher_write_tag() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_write_tag( NULL,
valid_buffer,
valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_write_tag( &valid_ctx,
NULL,
valid_size ) );
/* mbedtls_cipher_check_tag() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_check_tag( NULL,
valid_buffer,
valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_check_tag( &valid_ctx,
NULL,
valid_size ) );
#endif /* defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C) */
/* mbedtls_cipher_crypt() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_crypt( NULL,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, &size_t_var ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_crypt( &valid_ctx,
NULL, valid_size,
valid_buffer, valid_size,
valid_buffer, &size_t_var ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_crypt( &valid_ctx,
valid_buffer, valid_size,
NULL, valid_size,
valid_buffer, &size_t_var ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_crypt( &valid_ctx,
valid_buffer, valid_size,
valid_buffer, valid_size,
NULL, &size_t_var ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_crypt( &valid_ctx,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, NULL ) );
#if defined(MBEDTLS_CIPHER_MODE_AEAD)
/* mbedtls_cipher_auth_encrypt() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_encrypt( NULL,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, &size_t_var,
valid_buffer, valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_encrypt( &valid_ctx,
NULL, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, &size_t_var,
valid_buffer, valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_encrypt( &valid_ctx,
valid_buffer, valid_size,
NULL, valid_size,
valid_buffer, valid_size,
valid_buffer, &size_t_var,
valid_buffer, valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_encrypt( &valid_ctx,
valid_buffer, valid_size,
valid_buffer, valid_size,
NULL, valid_size,
valid_buffer, &size_t_var,
valid_buffer, valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_encrypt( &valid_ctx,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
NULL, &size_t_var,
valid_buffer, valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_encrypt( &valid_ctx,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, NULL,
valid_buffer, valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_encrypt( &valid_ctx,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, &size_t_var,
NULL, valid_size ) );
/* mbedtls_cipher_auth_decrypt() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_decrypt( NULL,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, &size_t_var,
valid_buffer, valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_decrypt( &valid_ctx,
NULL, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, &size_t_var,
valid_buffer, valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_decrypt( &valid_ctx,
valid_buffer, valid_size,
NULL, valid_size,
valid_buffer, valid_size,
valid_buffer, &size_t_var,
valid_buffer, valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_decrypt( &valid_ctx,
valid_buffer, valid_size,
valid_buffer, valid_size,
NULL, valid_size,
valid_buffer, &size_t_var,
valid_buffer, valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_decrypt( &valid_ctx,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
NULL, &size_t_var,
valid_buffer, valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_decrypt( &valid_ctx,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, NULL,
valid_buffer, valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_decrypt( &valid_ctx,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, &size_t_var,
NULL, valid_size ) );
#endif /* defined(MBEDTLS_CIPHER_MODE_AEAD) */
#if defined(MBEDTLS_CIPHER_MODE_AEAD) || defined(MBEDTLS_NIST_KW_C)
/* mbedtls_cipher_auth_encrypt_ext */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_encrypt_ext( NULL,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size, &size_t_var,
valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_encrypt_ext( &valid_ctx,
NULL, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size, &size_t_var,
valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_encrypt_ext( &valid_ctx,
valid_buffer, valid_size,
NULL, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size, &size_t_var,
valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_encrypt_ext( &valid_ctx,
valid_buffer, valid_size,
valid_buffer, valid_size,
NULL, valid_size,
valid_buffer, valid_size, &size_t_var,
valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_encrypt_ext( &valid_ctx,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
NULL, valid_size, &size_t_var,
valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_encrypt_ext( &valid_ctx,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size, NULL,
valid_size ) );
/* mbedtls_cipher_auth_decrypt_ext */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_decrypt_ext( NULL,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size, &size_t_var,
valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_decrypt_ext( &valid_ctx,
NULL, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size, &size_t_var,
valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_decrypt_ext( &valid_ctx,
valid_buffer, valid_size,
NULL, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size, &size_t_var,
valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_decrypt_ext( &valid_ctx,
valid_buffer, valid_size,
valid_buffer, valid_size,
NULL, valid_size,
valid_buffer, valid_size, &size_t_var,
valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_decrypt_ext( &valid_ctx,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
NULL, valid_size, &size_t_var,
valid_size ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
mbedtls_cipher_auth_decrypt_ext( &valid_ctx,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size,
valid_buffer, valid_size, NULL,
valid_size ) );
#endif /* MBEDTLS_CIPHER_MODE_AEAD || MBEDTLS_NIST_KW_C */
/* mbedtls_cipher_free() */
TEST_VALID_PARAM( mbedtls_cipher_free( NULL ) );
exit:
TEST_VALID_PARAM( mbedtls_cipher_free( &valid_ctx ) );
}
void test_cipher_invalid_param_conditional_wrapper( void ** params )
{
(void)params;
test_cipher_invalid_param_conditional( );
}
#endif /* !MBEDTLS_PARAM_FAILED_ALT */
#endif /* MBEDTLS_CHECK_PARAMS */
#if defined(MBEDTLS_AES_C)
void test_cipher_special_behaviours( )
{
const mbedtls_cipher_info_t *cipher_info;
mbedtls_cipher_context_t ctx;
unsigned char input[32];
unsigned char output[32];
#if defined (MBEDTLS_CIPHER_MODE_CBC)
unsigned char iv[32];
#endif
size_t olen = 0;
mbedtls_cipher_init( &ctx );
memset( input, 0, sizeof( input ) );
memset( output, 0, sizeof( output ) );
#if defined(MBEDTLS_CIPHER_MODE_CBC)
memset( iv, 0, sizeof( iv ) );
/* Check and get info structures */
cipher_info = mbedtls_cipher_info_from_type( MBEDTLS_CIPHER_AES_128_CBC );
TEST_ASSERT( NULL != cipher_info );
TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx, cipher_info ) );
/* IV too big */
TEST_ASSERT( mbedtls_cipher_set_iv( &ctx, iv, MBEDTLS_MAX_IV_LENGTH + 1 )
== MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
/* IV too small */
TEST_ASSERT( mbedtls_cipher_set_iv( &ctx, iv, 0 )
== MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
mbedtls_cipher_free( &ctx );
mbedtls_cipher_init( &ctx );
#endif /* MBEDTLS_CIPHER_MODE_CBC */
cipher_info = mbedtls_cipher_info_from_type( MBEDTLS_CIPHER_AES_128_ECB );
TEST_ASSERT( NULL != cipher_info );
TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx, cipher_info ) );
/* Update ECB with partial block */
TEST_ASSERT( mbedtls_cipher_update( &ctx, input, 1, output, &olen )
== MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED );
exit:
mbedtls_cipher_free( &ctx );
}
void test_cipher_special_behaviours_wrapper( void ** params )
{
(void)params;
test_cipher_special_behaviours( );
}
#endif /* MBEDTLS_AES_C */
void test_enc_dec_buf( int cipher_id, char * cipher_string, int key_len,
int length_val, int pad_mode )
{
size_t length = length_val, outlen, total_len, i, block_size;
unsigned char key[64];
unsigned char iv[16];
unsigned char ad[13];
unsigned char tag[16];
unsigned char inbuf[64];
unsigned char encbuf[64];
unsigned char decbuf[64];
const mbedtls_cipher_info_t *cipher_info;
mbedtls_cipher_context_t ctx_dec;
mbedtls_cipher_context_t ctx_enc;
/*
* Prepare contexts
*/
mbedtls_cipher_init( &ctx_dec );
mbedtls_cipher_init( &ctx_enc );
memset( key, 0x2a, sizeof( key ) );
/* Check and get info structures */
cipher_info = mbedtls_cipher_info_from_type( cipher_id );
TEST_ASSERT( NULL != cipher_info );
TEST_ASSERT( mbedtls_cipher_info_from_string( cipher_string ) == cipher_info );
/* Initialise enc and dec contexts */
TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_dec, cipher_info ) );
TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_enc, cipher_info ) );
TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_dec, key, key_len, MBEDTLS_DECRYPT ) );
TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_enc, key, key_len, MBEDTLS_ENCRYPT ) );
#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
if( -1 != pad_mode )
{
TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx_dec, pad_mode ) );
TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx_enc, pad_mode ) );
}
#else
(void) pad_mode;
#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
/*
* Do a few encode/decode cycles
*/
for( i = 0; i < 3; i++ )
{
memset( iv , 0x00 + i, sizeof( iv ) );
memset( ad, 0x10 + i, sizeof( ad ) );
memset( inbuf, 0x20 + i, sizeof( inbuf ) );
memset( encbuf, 0, sizeof( encbuf ) );
memset( decbuf, 0, sizeof( decbuf ) );
memset( tag, 0, sizeof( tag ) );
TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_dec, iv, sizeof( iv ) ) );
TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_enc, iv, sizeof( iv ) ) );
TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_dec ) );
TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_enc ) );
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_dec, ad, sizeof( ad ) - i ) );
TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_enc, ad, sizeof( ad ) - i ) );
#endif
block_size = mbedtls_cipher_get_block_size( &ctx_enc );
TEST_ASSERT( block_size != 0 );
/* encode length number of bytes from inbuf */
TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_enc, inbuf, length, encbuf, &outlen ) );
total_len = outlen;
TEST_ASSERT( total_len == length ||
( total_len % block_size == 0 &&
total_len < length &&
total_len + block_size > length ) );
TEST_ASSERT( 0 == mbedtls_cipher_finish( &ctx_enc, encbuf + outlen, &outlen ) );
total_len += outlen;
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
TEST_ASSERT( 0 == mbedtls_cipher_write_tag( &ctx_enc, tag, sizeof( tag ) ) );
#endif
TEST_ASSERT( total_len == length ||
( total_len % block_size == 0 &&
total_len > length &&
total_len <= length + block_size ) );
/* decode the previously encoded string */
TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_dec, encbuf, total_len, decbuf, &outlen ) );
total_len = outlen;
TEST_ASSERT( total_len == length ||
( total_len % block_size == 0 &&
total_len < length &&
total_len + block_size >= length ) );
TEST_ASSERT( 0 == mbedtls_cipher_finish( &ctx_dec, decbuf + outlen, &outlen ) );
total_len += outlen;
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
TEST_ASSERT( 0 == mbedtls_cipher_check_tag( &ctx_dec, tag, sizeof( tag ) ) );
#endif
/* check result */
TEST_ASSERT( total_len == length );
TEST_ASSERT( 0 == timingsafe_bcmp(inbuf, decbuf, length) );
}
/*
* Done
*/
exit:
mbedtls_cipher_free( &ctx_dec );
mbedtls_cipher_free( &ctx_enc );
}
void test_enc_dec_buf_wrapper( void ** params )
{
test_enc_dec_buf( *( (int *) params[0] ), (char *) params[1], *( (int *) params[2] ), *( (int *) params[3] ), *( (int *) params[4] ) );
}
void test_enc_fail( int cipher_id, int pad_mode, int key_len, int length_val,
int ret )
{
size_t length = length_val;
unsigned char key[32];
unsigned char iv[16];
const mbedtls_cipher_info_t *cipher_info;
mbedtls_cipher_context_t ctx;
unsigned char inbuf[64];
unsigned char encbuf[64];
size_t outlen = 0;
memset( key, 0, 32 );
memset( iv , 0, 16 );
mbedtls_cipher_init( &ctx );
memset( inbuf, 5, 64 );
memset( encbuf, 0, 64 );
/* Check and get info structures */
cipher_info = mbedtls_cipher_info_from_type( cipher_id );
TEST_ASSERT( NULL != cipher_info );
/* Initialise context */
TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx, cipher_info ) );
TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key, key_len, MBEDTLS_ENCRYPT ) );
#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx, pad_mode ) );
#else
(void) pad_mode;
#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx, iv, 16 ) );
TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx ) );
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx, NULL, 0 ) );
#endif
/* encode length number of bytes from inbuf */
TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx, inbuf, length, encbuf, &outlen ) );
TEST_ASSERT( ret == mbedtls_cipher_finish( &ctx, encbuf + outlen, &outlen ) );
/* done */
exit:
mbedtls_cipher_free( &ctx );
}
void test_enc_fail_wrapper( void ** params )
{
test_enc_fail( *( (int *) params[0] ), *( (int *) params[1] ), *( (int *) params[2] ), *( (int *) params[3] ), *( (int *) params[4] ) );
}
void test_dec_empty_buf( int cipher,
int expected_update_ret,
int expected_finish_ret )
{
unsigned char key[32];
unsigned char iv[16];
mbedtls_cipher_context_t ctx_dec;
const mbedtls_cipher_info_t *cipher_info;
unsigned char encbuf[64];
unsigned char decbuf[64];
size_t outlen = 0;
memset( key, 0, 32 );
memset( iv , 0, 16 );
mbedtls_cipher_init( &ctx_dec );
memset( encbuf, 0, 64 );
memset( decbuf, 0, 64 );
/* Initialise context */
cipher_info = mbedtls_cipher_info_from_type( cipher );
TEST_ASSERT( NULL != cipher_info);
TEST_ASSERT( sizeof(key) * 8 >= cipher_info->key_bitlen );
TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_dec, cipher_info ) );
TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_dec,
key, cipher_info->key_bitlen,
MBEDTLS_DECRYPT ) );
TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_dec, iv, 16 ) );
TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_dec ) );
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_dec, NULL, 0 ) );
#endif
/* decode 0-byte string */
TEST_ASSERT( expected_update_ret ==
mbedtls_cipher_update( &ctx_dec, encbuf, 0, decbuf, &outlen ) );
TEST_ASSERT( 0 == outlen );
if ( expected_finish_ret == 0 &&
( cipher_info->mode == MBEDTLS_MODE_CBC ||
cipher_info->mode == MBEDTLS_MODE_ECB ) )
{
/* Non-CBC and non-ECB ciphers are OK with decrypting empty buffers and
* return success, not MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED, when
* decrypting an empty buffer.
* On the other hand, CBC and ECB ciphers need a full block of input.
*/
expected_finish_ret = MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED;
}
TEST_ASSERT( expected_finish_ret == mbedtls_cipher_finish(
&ctx_dec, decbuf + outlen, &outlen ) );
TEST_ASSERT( 0 == outlen );
exit:
mbedtls_cipher_free( &ctx_dec );
}
void test_dec_empty_buf_wrapper( void ** params )
{
test_dec_empty_buf( *( (int *) params[0] ), *( (int *) params[1] ), *( (int *) params[2] ) );
}
void test_enc_dec_buf_multipart( int cipher_id, int key_len, int first_length_val,
int second_length_val, int pad_mode,
int first_encrypt_output_len, int second_encrypt_output_len,
int first_decrypt_output_len, int second_decrypt_output_len )
{
size_t first_length = first_length_val;
size_t second_length = second_length_val;
size_t length = first_length + second_length;
size_t block_size;
unsigned char key[32];
unsigned char iv[16];
mbedtls_cipher_context_t ctx_dec;
mbedtls_cipher_context_t ctx_enc;
const mbedtls_cipher_info_t *cipher_info;
unsigned char inbuf[64];
unsigned char encbuf[64];
unsigned char decbuf[64];
size_t outlen = 0;
size_t totaloutlen = 0;
memset( key, 0, 32 );
memset( iv , 0, 16 );
mbedtls_cipher_init( &ctx_dec );
mbedtls_cipher_init( &ctx_enc );
memset( inbuf, 5, 64 );
memset( encbuf, 0, 64 );
memset( decbuf, 0, 64 );
/* Initialise enc and dec contexts */
cipher_info = mbedtls_cipher_info_from_type( cipher_id );
TEST_ASSERT( NULL != cipher_info);
TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_dec, cipher_info ) );
TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_enc, cipher_info ) );
TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_dec, key, key_len, MBEDTLS_DECRYPT ) );
TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_enc, key, key_len, MBEDTLS_ENCRYPT ) );
#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
if( -1 != pad_mode )
{
TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx_dec, pad_mode ) );
TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx_enc, pad_mode ) );
}
#else
(void) pad_mode;
#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_dec, iv, 16 ) );
TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_enc, iv, 16 ) );
TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_dec ) );
TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_enc ) );
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_dec, NULL, 0 ) );
TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_enc, NULL, 0 ) );
#endif
block_size = mbedtls_cipher_get_block_size( &ctx_enc );
TEST_ASSERT( block_size != 0 );
/* encode length number of bytes from inbuf */
TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_enc, inbuf, first_length, encbuf, &outlen ) );
TEST_ASSERT( (size_t)first_encrypt_output_len == outlen );
totaloutlen = outlen;
TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_enc, inbuf + first_length, second_length, encbuf + totaloutlen, &outlen ) );
TEST_ASSERT( (size_t)second_encrypt_output_len == outlen );
totaloutlen += outlen;
TEST_ASSERT( totaloutlen == length ||
( totaloutlen % block_size == 0 &&
totaloutlen < length &&
totaloutlen + block_size > length ) );
TEST_ASSERT( 0 == mbedtls_cipher_finish( &ctx_enc, encbuf + totaloutlen, &outlen ) );
totaloutlen += outlen;
TEST_ASSERT( totaloutlen == length ||
( totaloutlen % block_size == 0 &&
totaloutlen > length &&
totaloutlen <= length + block_size ) );
/* decode the previously encoded string */
second_length = totaloutlen - first_length;
TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_dec, encbuf, first_length, decbuf, &outlen ) );
TEST_ASSERT( (size_t)first_decrypt_output_len == outlen );
totaloutlen = outlen;
TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_dec, encbuf + first_length, second_length, decbuf + totaloutlen, &outlen ) );
TEST_ASSERT( (size_t)second_decrypt_output_len == outlen );
totaloutlen += outlen;
TEST_ASSERT( totaloutlen == length ||
( totaloutlen % block_size == 0 &&
totaloutlen < length &&
totaloutlen + block_size >= length ) );
TEST_ASSERT( 0 == mbedtls_cipher_finish( &ctx_dec, decbuf + totaloutlen, &outlen ) );
totaloutlen += outlen;
TEST_ASSERT( totaloutlen == length );
TEST_ASSERT( 0 == timingsafe_bcmp(inbuf, decbuf, length) );
exit:
mbedtls_cipher_free( &ctx_dec );
mbedtls_cipher_free( &ctx_enc );
}
void test_enc_dec_buf_multipart_wrapper( void ** params )
{
test_enc_dec_buf_multipart( *( (int *) params[0] ), *( (int *) params[1] ), *( (int *) params[2] ), *( (int *) params[3] ), *( (int *) params[4] ), *( (int *) params[5] ), *( (int *) params[6] ), *( (int *) params[7] ), *( (int *) params[8] ) );
}
void test_decrypt_test_vec( int cipher_id, int pad_mode, data_t * key,
data_t * iv, data_t * cipher,
data_t * clear, data_t * ad, data_t * tag,
int finish_result, int tag_result )
{
unsigned char output[265];
mbedtls_cipher_context_t ctx;
size_t outlen, total_len;
mbedtls_cipher_init( &ctx );
memset( output, 0x00, sizeof( output ) );
#if !defined(MBEDTLS_GCM_C) && !defined(MBEDTLS_CHACHAPOLY_C)
((void) ad);
((void) tag);
#endif
/* Prepare context */
TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx,
mbedtls_cipher_info_from_type( cipher_id ) ) );
TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key->x, 8 * key->len, MBEDTLS_DECRYPT ) );
#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
if( pad_mode != -1 )
TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx, pad_mode ) );
#else
(void) pad_mode;
#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx, iv->x, iv->len ) );
TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx ) );
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx, ad->x, ad->len ) );
#endif
/* decode buffer and check tag->x */
total_len = 0;
TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx, cipher->x, cipher->len, output, &outlen ) );
total_len += outlen;
TEST_ASSERT( finish_result == mbedtls_cipher_finish( &ctx, output + outlen,
&outlen ) );
total_len += outlen;
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
TEST_ASSERT( tag_result == mbedtls_cipher_check_tag( &ctx, tag->x, tag->len ) );
#endif
/* check plaintext only if everything went fine */
if( 0 == finish_result && 0 == tag_result )
{
TEST_ASSERT( total_len == clear->len );
TEST_ASSERT( 0 == timingsafe_bcmp( output, clear->x, clear->len ) );
}
exit:
mbedtls_cipher_free( &ctx );
}
void test_decrypt_test_vec_wrapper( void ** params )
{
data_t data2 = {(uint8_t *) params[2], *( (uint32_t *) params[3] )};
data_t data4 = {(uint8_t *) params[4], *( (uint32_t *) params[5] )};
data_t data6 = {(uint8_t *) params[6], *( (uint32_t *) params[7] )};
data_t data8 = {(uint8_t *) params[8], *( (uint32_t *) params[9] )};
data_t data10 = {(uint8_t *) params[10], *( (uint32_t *) params[11] )};
data_t data12 = {(uint8_t *) params[12], *( (uint32_t *) params[13] )};
test_decrypt_test_vec( *( (int *) params[0] ), *( (int *) params[1] ), &data2, &data4, &data6, &data8, &data10, &data12, *( (int *) params[14] ), *( (int *) params[15] ) );
}
#if defined(MBEDTLS_CIPHER_AUTH_CRYPT)
void test_auth_crypt_tv( int cipher_id, data_t * key, data_t * iv,
data_t * ad, data_t * cipher, data_t * tag,
char * result, data_t * clear, int use_psa )
{
/*
* Take an AEAD ciphertext + tag and perform a pair
* of AEAD decryption and AEAD encryption. Check that
* this results in the expected plaintext, and that
* decryption and encryption are inverse to one another.
*
* Do that twice:
* - once with legacy functions auth_decrypt/auth_encrypt
* - once with new functions auth_decrypt_ext/auth_encrypt_ext
* This allows testing both without duplicating test cases.
*/
int ret;
int using_nist_kw, using_nist_kw_padding;
mbedtls_cipher_context_t ctx;
size_t outlen;
unsigned char *cipher_plus_tag = NULL;
size_t cipher_plus_tag_len;
unsigned char *decrypt_buf = NULL;
size_t decrypt_buf_len = 0;
unsigned char *encrypt_buf = NULL;
size_t encrypt_buf_len = 0;
#if !defined(MBEDTLS_DEPRECATED_WARNING) && \
!defined(MBEDTLS_DEPRECATED_REMOVED)
unsigned char *tmp_tag = NULL;
unsigned char *tmp_cipher = NULL;
unsigned char *tag_buf = NULL;
#endif /* !MBEDTLS_DEPRECATED_WARNING && !MBEDTLS_DEPRECATED_REMOVED */
/* Null pointers are documented as valid for inputs of length 0.
* The test framework passes non-null pointers, so set them to NULL.
* key, cipher and tag can't be empty. */
if( iv->len == 0 )
iv->x = NULL;
if( ad->len == 0 )
ad->x = NULL;
if( clear->len == 0 )
clear->x = NULL;
mbedtls_cipher_init( &ctx );
/* Initialize PSA Crypto */
#if defined(MBEDTLS_USE_PSA_CRYPTO)
if( use_psa == 1 )
PSA_ASSERT( psa_crypto_init( ) );
#else
(void) use_psa;
#endif
/*
* Are we using NIST_KW? with padding?
*/
using_nist_kw_padding = cipher_id == MBEDTLS_CIPHER_AES_128_KWP ||
cipher_id == MBEDTLS_CIPHER_AES_192_KWP ||
cipher_id == MBEDTLS_CIPHER_AES_256_KWP;
using_nist_kw = cipher_id == MBEDTLS_CIPHER_AES_128_KW ||
cipher_id == MBEDTLS_CIPHER_AES_192_KW ||
cipher_id == MBEDTLS_CIPHER_AES_256_KW ||
using_nist_kw_padding;
/****************************************************************
* *
* Part 1: non-deprecated API *
* *
****************************************************************/
/*
* Prepare context for decryption
*/
if( ! cipher_reset_key( &ctx, cipher_id, use_psa, tag->len, key,
MBEDTLS_DECRYPT ) )
goto exit;
/*
* prepare buffer for decryption
* (we need the tag appended to the ciphertext)
*/
cipher_plus_tag_len = cipher->len + tag->len;
ASSERT_ALLOC( cipher_plus_tag, cipher_plus_tag_len );
memcpy( cipher_plus_tag, cipher->x, cipher->len );
memcpy( cipher_plus_tag + cipher->len, tag->x, tag->len );
/*
* Compute length of output buffer according to the documentation
*/
if( using_nist_kw )
decrypt_buf_len = cipher_plus_tag_len - 8;
else
decrypt_buf_len = cipher_plus_tag_len - tag->len;
/*
* Try decrypting to a buffer that's 1B too small
*/
if( decrypt_buf_len != 0 )
{
ASSERT_ALLOC( decrypt_buf, decrypt_buf_len - 1 );
outlen = 0;
ret = mbedtls_cipher_auth_decrypt_ext( &ctx, iv->x, iv->len,
ad->x, ad->len, cipher_plus_tag, cipher_plus_tag_len,
decrypt_buf, decrypt_buf_len - 1, &outlen, tag->len );
TEST_ASSERT( ret == MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
mbedtls_free( decrypt_buf );
decrypt_buf = NULL;
}
/*
* Authenticate and decrypt, and check result
*/
ASSERT_ALLOC( decrypt_buf, decrypt_buf_len );
outlen = 0;
ret = mbedtls_cipher_auth_decrypt_ext( &ctx, iv->x, iv->len,
ad->x, ad->len, cipher_plus_tag, cipher_plus_tag_len,
decrypt_buf, decrypt_buf_len, &outlen, tag->len );
if( strcmp( result, "FAIL" ) == 0 )
{
TEST_ASSERT( ret == MBEDTLS_ERR_CIPHER_AUTH_FAILED );
TEST_ASSERT( buffer_is_all_zero( decrypt_buf, decrypt_buf_len ) );
}
else
{
TEST_ASSERT( ret == 0 );
ASSERT_COMPARE( decrypt_buf, outlen, clear->x, clear->len );
}
/* Free this, but keep cipher_plus_tag for deprecated function with PSA */
mbedtls_free( decrypt_buf );
decrypt_buf = NULL;
/*
* Encrypt back if test data was authentic
*/
if( strcmp( result, "FAIL" ) != 0 )
{
/* prepare context for encryption */
if( ! cipher_reset_key( &ctx, cipher_id, use_psa, tag->len, key,
MBEDTLS_ENCRYPT ) )
goto exit;
/*
* Compute size of output buffer according to documentation
*/
if( using_nist_kw )
{
encrypt_buf_len = clear->len + 8;
if( using_nist_kw_padding && encrypt_buf_len % 8 != 0 )
encrypt_buf_len += 8 - encrypt_buf_len % 8;
}
else
{
encrypt_buf_len = clear->len + tag->len;
}
/*
* Try encrypting with an output buffer that's 1B too small
*/
ASSERT_ALLOC( encrypt_buf, encrypt_buf_len - 1 );
outlen = 0;
ret = mbedtls_cipher_auth_encrypt_ext( &ctx, iv->x, iv->len,
ad->x, ad->len, clear->x, clear->len,
encrypt_buf, encrypt_buf_len - 1, &outlen, tag->len );
TEST_ASSERT( ret != 0 );
mbedtls_free( encrypt_buf );
encrypt_buf = NULL;
/*
* Encrypt and check the result
*/
ASSERT_ALLOC( encrypt_buf, encrypt_buf_len );
outlen = 0;
ret = mbedtls_cipher_auth_encrypt_ext( &ctx, iv->x, iv->len,
ad->x, ad->len, clear->x, clear->len,
encrypt_buf, encrypt_buf_len, &outlen, tag->len );
TEST_ASSERT( ret == 0 );
TEST_ASSERT( outlen == cipher->len + tag->len );
TEST_ASSERT( timingsafe_bcmp( encrypt_buf, cipher->x, cipher->len ) == 0 );
TEST_ASSERT( timingsafe_bcmp( encrypt_buf + cipher->len,
tag->x, tag->len ) == 0 );
mbedtls_free( encrypt_buf );
encrypt_buf = NULL;
}
/****************************************************************
* *
* Part 2: deprecated API *
* *
****************************************************************/
#if !defined(MBEDTLS_DEPRECATED_WARNING) && \
!defined(MBEDTLS_DEPRECATED_REMOVED)
/*
* Prepare context for decryption
*/
if( ! cipher_reset_key( &ctx, cipher_id, use_psa, tag->len, key,
MBEDTLS_DECRYPT ) )
goto exit;
/*
* Prepare pointers for decryption
*/
#if defined(MBEDTLS_USE_PSA_CRYPTO)
if( use_psa == 1 )
{
/* PSA requires that the tag immediately follows the ciphertext.
* Fortunately, we already have that from testing the new API. */
tmp_cipher = cipher_plus_tag;
tmp_tag = tmp_cipher + cipher->len;
}
else
#endif /* MBEDTLS_USE_PSA_CRYPTO */
{
tmp_cipher = cipher->x;
tmp_tag = tag->x;
}
/*
* Authenticate and decrypt, and check result
*/
ASSERT_ALLOC( decrypt_buf, cipher->len );
outlen = 0;
ret = mbedtls_cipher_auth_decrypt( &ctx, iv->x, iv->len, ad->x, ad->len,
tmp_cipher, cipher->len, decrypt_buf, &outlen,
tmp_tag, tag->len );
if( using_nist_kw )
{
/* NIST_KW with legacy API */
TEST_ASSERT( ret == MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
}
else if( strcmp( result, "FAIL" ) == 0 )
{
/* unauthentic message */
TEST_ASSERT( ret == MBEDTLS_ERR_CIPHER_AUTH_FAILED );
TEST_ASSERT( buffer_is_all_zero( decrypt_buf, cipher->len ) );
}
else
{
/* authentic message: is the plaintext correct? */
TEST_ASSERT( ret == 0 );
ASSERT_COMPARE( decrypt_buf, outlen, clear->x, clear->len );
}
mbedtls_free( decrypt_buf );
decrypt_buf = NULL;
mbedtls_free( cipher_plus_tag );
cipher_plus_tag = NULL;
/*
* Encrypt back if test data was authentic
*/
if( strcmp( result, "FAIL" ) != 0 )
{
/* prepare context for encryption */
if( ! cipher_reset_key( &ctx, cipher_id, use_psa, tag->len, key,
MBEDTLS_ENCRYPT ) )
goto exit;
/* prepare buffers for encryption */
#if defined(MBEDTLS_USE_PSA_CRYPTO)
if( use_psa )
{
ASSERT_ALLOC( cipher_plus_tag, cipher->len + tag->len );
tmp_cipher = cipher_plus_tag;
tmp_tag = cipher_plus_tag + cipher->len;
}
else
#endif /* MBEDTLS_USE_PSA_CRYPTO */
{
ASSERT_ALLOC( encrypt_buf, cipher->len );
ASSERT_ALLOC( tag_buf, tag->len );
tmp_cipher = encrypt_buf;
tmp_tag = tag_buf;
}
/*
* Encrypt and check the result
*/
outlen = 0;
ret = mbedtls_cipher_auth_encrypt( &ctx, iv->x, iv->len, ad->x, ad->len,
clear->x, clear->len, tmp_cipher, &outlen,
tmp_tag, tag->len );
if( using_nist_kw )
{
TEST_ASSERT( ret == MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
}
else
{
TEST_ASSERT( ret == 0 );
TEST_ASSERT( outlen == cipher->len );
if( cipher->len != 0 )
TEST_ASSERT( timingsafe_bcmp( tmp_cipher, cipher->x, cipher->len ) == 0 );
TEST_ASSERT( timingsafe_bcmp( tmp_tag, tag->x, tag->len ) == 0 );
}
}
#endif /* !MBEDTLS_DEPRECATED_WARNING && !MBEDTLS_DEPRECATED_REMOVED */
exit:
mbedtls_cipher_free( &ctx );
mbedtls_free( decrypt_buf );
mbedtls_free( encrypt_buf );
mbedtls_free( cipher_plus_tag );
#if !defined(MBEDTLS_DEPRECATED_WARNING) && \
!defined(MBEDTLS_DEPRECATED_REMOVED)
mbedtls_free( tag_buf );
#endif /* !MBEDTLS_DEPRECATED_WARNING && !MBEDTLS_DEPRECATED_REMOVED */
#if defined(MBEDTLS_USE_PSA_CRYPTO)
if( use_psa == 1 )
PSA_DONE( );
#endif /* MBEDTLS_USE_PSA_CRYPTO */
}
void test_auth_crypt_tv_wrapper( void ** params )
{
data_t data1 = {(uint8_t *) params[1], *( (uint32_t *) params[2] )};
data_t data3 = {(uint8_t *) params[3], *( (uint32_t *) params[4] )};
data_t data5 = {(uint8_t *) params[5], *( (uint32_t *) params[6] )};
data_t data7 = {(uint8_t *) params[7], *( (uint32_t *) params[8] )};
data_t data9 = {(uint8_t *) params[9], *( (uint32_t *) params[10] )};
data_t data12 = {(uint8_t *) params[12], *( (uint32_t *) params[13] )};
test_auth_crypt_tv( *( (int *) params[0] ), &data1, &data3, &data5, &data7, &data9, (char *) params[11], &data12, *( (int *) params[14] ) );
}
#endif /* MBEDTLS_CIPHER_AUTH_CRYPT */
void test_test_vec_ecb( int cipher_id, int operation, data_t * key,
data_t * input, data_t * result, int finish_result
)
{
mbedtls_cipher_context_t ctx;
unsigned char output[32];
size_t outlen;
mbedtls_cipher_init( &ctx );
memset( output, 0x00, sizeof( output ) );
/* Prepare context */
TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx,
mbedtls_cipher_info_from_type( cipher_id ) ) );
TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key->x, 8 * key->len, operation ) );
TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx, input->x,
mbedtls_cipher_get_block_size( &ctx ),
output, &outlen ) );
TEST_ASSERT( outlen == mbedtls_cipher_get_block_size( &ctx ) );
TEST_ASSERT( finish_result == mbedtls_cipher_finish( &ctx, output + outlen,
&outlen ) );
TEST_ASSERT( 0 == outlen );
/* check plaintext only if everything went fine */
if( 0 == finish_result )
TEST_ASSERT( 0 == timingsafe_bcmp( output, result->x,
mbedtls_cipher_get_block_size( &ctx ) ) );
exit:
mbedtls_cipher_free( &ctx );
}
void test_test_vec_ecb_wrapper( void ** params )
{
data_t data2 = {(uint8_t *) params[2], *( (uint32_t *) params[3] )};
data_t data4 = {(uint8_t *) params[4], *( (uint32_t *) params[5] )};
data_t data6 = {(uint8_t *) params[6], *( (uint32_t *) params[7] )};
test_test_vec_ecb( *( (int *) params[0] ), *( (int *) params[1] ), &data2, &data4, &data6, *( (int *) params[8] ) );
}
#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
void test_test_vec_crypt( int cipher_id, int operation, data_t *key,
data_t *iv, data_t *input, data_t *result,
int finish_result, int use_psa )
{
mbedtls_cipher_context_t ctx;
unsigned char output[32];
size_t outlen;
mbedtls_cipher_init( &ctx );
memset( output, 0x00, sizeof( output ) );
/* Prepare context */
#if !defined(MBEDTLS_USE_PSA_CRYPTO)
(void) use_psa;
#else
if( use_psa == 1 )
{
PSA_ASSERT( psa_crypto_init( ) );
TEST_ASSERT( 0 == mbedtls_cipher_setup_psa( &ctx,
mbedtls_cipher_info_from_type( cipher_id ), 0 ) );
}
else
#endif /* MBEDTLS_USE_PSA_CRYPTO */
TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx,
mbedtls_cipher_info_from_type( cipher_id ) ) );
TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key->x, 8 * key->len, operation ) );
if( MBEDTLS_MODE_CBC == ctx.cipher_info->mode )
TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx, MBEDTLS_PADDING_NONE ) );
TEST_ASSERT( finish_result == mbedtls_cipher_crypt( &ctx, iv->len ? iv->x : NULL,
iv->len, input->x, input->len,
output, &outlen ) );
TEST_ASSERT( result->len == outlen );
/* check plaintext only if everything went fine */
if( 0 == finish_result )
TEST_ASSERT( 0 == timingsafe_bcmp( output, result->x, outlen ) );
exit:
mbedtls_cipher_free( &ctx );
#if defined(MBEDTLS_USE_PSA_CRYPTO)
PSA_DONE( );
#endif /* MBEDTLS_USE_PSA_CRYPTO */
}
void test_test_vec_crypt_wrapper( void ** params )
{
data_t data2 = {(uint8_t *) params[2], *( (uint32_t *) params[3] )};
data_t data4 = {(uint8_t *) params[4], *( (uint32_t *) params[5] )};
data_t data6 = {(uint8_t *) params[6], *( (uint32_t *) params[7] )};
data_t data8 = {(uint8_t *) params[8], *( (uint32_t *) params[9] )};
test_test_vec_crypt( *( (int *) params[0] ), *( (int *) params[1] ), &data2, &data4, &data6, &data8, *( (int *) params[10] ), *( (int *) params[11] ) );
}
#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
void test_set_padding( int cipher_id, int pad_mode, int ret )
{
const mbedtls_cipher_info_t *cipher_info;
mbedtls_cipher_context_t ctx;
mbedtls_cipher_init( &ctx );
cipher_info = mbedtls_cipher_info_from_type( cipher_id );
TEST_ASSERT( NULL != cipher_info );
TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx, cipher_info ) );
TEST_ASSERT( ret == mbedtls_cipher_set_padding_mode( &ctx, pad_mode ) );
exit:
mbedtls_cipher_free( &ctx );
}
void test_set_padding_wrapper( void ** params )
{
test_set_padding( *( (int *) params[0] ), *( (int *) params[1] ), *( (int *) params[2] ) );
}
#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
#if defined(MBEDTLS_CIPHER_MODE_CBC)
void test_check_padding( int pad_mode, data_t * input, int ret, int dlen_check
)
{
mbedtls_cipher_info_t cipher_info;
mbedtls_cipher_context_t ctx;
size_t dlen;
/* build a fake context just for getting access to get_padding */
mbedtls_cipher_init( &ctx );
cipher_info.mode = MBEDTLS_MODE_CBC;
ctx.cipher_info = &cipher_info;
TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx, pad_mode ) );
TEST_ASSERT( ret == ctx.get_padding( input->x, input->len, &dlen ) );
if( 0 == ret )
TEST_ASSERT( dlen == (size_t) dlen_check );
exit:
;
}
void test_check_padding_wrapper( void ** params )
{
data_t data1 = {(uint8_t *) params[1], *( (uint32_t *) params[2] )};
test_check_padding( *( (int *) params[0] ), &data1, *( (int *) params[3] ), *( (int *) params[4] ) );
}
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#endif /* MBEDTLS_CIPHER_C */
/*----------------------------------------------------------------------------*/
/* Test dispatch code */
/**
* \brief Evaluates an expression/macro into its literal integer value.
* For optimizing space for embedded targets each expression/macro
* is identified by a unique identifier instead of string literals.
* Identifiers and evaluation code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param exp_id Expression identifier.
* \param out_value Pointer to int to hold the integer.
*
* \return 0 if exp_id is found. 1 otherwise.
*/
int get_expression( int32_t exp_id, int32_t * out_value )
{
int ret = KEY_VALUE_MAPPING_FOUND;
(void) exp_id;
(void) out_value;
switch( exp_id )
{
#if defined(MBEDTLS_CIPHER_C)
case 0:
{
*out_value = MBEDTLS_CIPHER_BLOWFISH_CBC;
}
break;
case 1:
{
*out_value = -1;
}
break;
case 2:
{
*out_value = MBEDTLS_PADDING_ONE_AND_ZEROS;
}
break;
case 3:
{
*out_value = MBEDTLS_PADDING_ZEROS_AND_LEN;
}
break;
case 4:
{
*out_value = MBEDTLS_PADDING_ZEROS;
}
break;
case 5:
{
*out_value = MBEDTLS_PADDING_NONE;
}
break;
case 6:
{
*out_value = MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED;
}
break;
case 7:
{
*out_value = MBEDTLS_CIPHER_BLOWFISH_CFB64;
}
break;
case 8:
{
*out_value = MBEDTLS_CIPHER_BLOWFISH_CTR;
}
break;
case 9:
{
*out_value = MBEDTLS_CIPHER_BLOWFISH_ECB;
}
break;
case 10:
{
*out_value = MBEDTLS_ENCRYPT;
}
break;
case 11:
{
*out_value = MBEDTLS_DECRYPT;
}
break;
#endif
default:
{
ret = KEY_VALUE_MAPPING_NOT_FOUND;
}
break;
}
return( ret );
}
/**
* \brief Checks if the dependency i.e. the compile flag is set.
* For optimizing space for embedded targets each dependency
* is identified by a unique identifier instead of string literals.
* Identifiers and check code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param dep_id Dependency identifier.
*
* \return DEPENDENCY_SUPPORTED if set else DEPENDENCY_NOT_SUPPORTED
*/
int dep_check( int dep_id )
{
int ret = DEPENDENCY_NOT_SUPPORTED;
(void) dep_id;
switch( dep_id )
{
#if defined(MBEDTLS_CIPHER_C)
case 0:
{
#if defined(MBEDTLS_BLOWFISH_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 1:
{
#if defined(MBEDTLS_CIPHER_MODE_CBC)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 2:
{
#if defined(MBEDTLS_CIPHER_PADDING_PKCS7)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 3:
{
#if defined(MBEDTLS_CIPHER_MODE_CFB)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 4:
{
#if defined(MBEDTLS_CIPHER_MODE_CTR)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
#endif
default:
break;
}
return( ret );
}
/**
* \brief Function pointer type for test function wrappers.
*
* A test function wrapper decodes the parameters and passes them to the
* underlying test function. Both the wrapper and the underlying function
* return void. Test wrappers assume that they are passed a suitable
* parameter array and do not perform any error detection.
*
* \param param_array The array of parameters. Each element is a `void *`
* which the wrapper casts to the correct type and
* dereferences. Each wrapper function hard-codes the
* number and types of the parameters.
*/
typedef void (*TestWrapper_t)( void **param_array );
/**
* \brief Table of test function wrappers. Used by dispatch_test().
* This table is populated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
*/
TestWrapper_t test_funcs[] =
{
/* Function Id: 0 */
#if defined(MBEDTLS_CIPHER_C)
test_mbedtls_cipher_list_wrapper,
#else
NULL,
#endif
/* Function Id: 1 */
#if defined(MBEDTLS_CIPHER_C)
test_cipher_invalid_param_unconditional_wrapper,
#else
NULL,
#endif
/* Function Id: 2 */
#if defined(MBEDTLS_CIPHER_C) && defined(MBEDTLS_CHECK_PARAMS) && !defined(MBEDTLS_PARAM_FAILED_ALT)
test_cipher_invalid_param_conditional_wrapper,
#else
NULL,
#endif
/* Function Id: 3 */
#if defined(MBEDTLS_CIPHER_C) && defined(MBEDTLS_AES_C)
test_cipher_special_behaviours_wrapper,
#else
NULL,
#endif
/* Function Id: 4 */
#if defined(MBEDTLS_CIPHER_C)
test_enc_dec_buf_wrapper,
#else
NULL,
#endif
/* Function Id: 5 */
#if defined(MBEDTLS_CIPHER_C)
test_enc_fail_wrapper,
#else
NULL,
#endif
/* Function Id: 6 */
#if defined(MBEDTLS_CIPHER_C)
test_dec_empty_buf_wrapper,
#else
NULL,
#endif
/* Function Id: 7 */
#if defined(MBEDTLS_CIPHER_C)
test_enc_dec_buf_multipart_wrapper,
#else
NULL,
#endif
/* Function Id: 8 */
#if defined(MBEDTLS_CIPHER_C)
test_decrypt_test_vec_wrapper,
#else
NULL,
#endif
/* Function Id: 9 */
#if defined(MBEDTLS_CIPHER_C) && defined(MBEDTLS_CIPHER_AUTH_CRYPT)
test_auth_crypt_tv_wrapper,
#else
NULL,
#endif
/* Function Id: 10 */
#if defined(MBEDTLS_CIPHER_C)
test_test_vec_ecb_wrapper,
#else
NULL,
#endif
/* Function Id: 11 */
#if defined(MBEDTLS_CIPHER_C) && defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
test_test_vec_crypt_wrapper,
#else
NULL,
#endif
/* Function Id: 12 */
#if defined(MBEDTLS_CIPHER_C) && defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
test_set_padding_wrapper,
#else
NULL,
#endif
/* Function Id: 13 */
#if defined(MBEDTLS_CIPHER_C) && defined(MBEDTLS_CIPHER_MODE_CBC)
test_check_padding_wrapper,
#else
NULL,
#endif
};
/**
* \brief Execute the test function.
*
* This is a wrapper function around the test function execution
* to allow the setjmp() call used to catch any calls to the
* parameter failure callback, to be used. Calls to setjmp()
* can invalidate the state of any local auto variables.
*
* \param fp Function pointer to the test function.
* \param params Parameters to pass to the #TestWrapper_t wrapper function.
*
*/
void execute_function_ptr(TestWrapper_t fp, void **params)
{
#if defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG)
mbedtls_test_enable_insecure_external_rng( );
#endif
#if defined(MBEDTLS_CHECK_PARAMS)
mbedtls_test_param_failed_location_record_t location_record;
if ( setjmp( mbedtls_test_param_failed_get_state_buf( ) ) == 0 )
{
fp( params );
}
else
{
/* Unexpected parameter validation error */
mbedtls_test_param_failed_get_location_record( &location_record );
mbedtls_test_fail( location_record.failure_condition,
location_record.line,
location_record.file );
}
mbedtls_test_param_failed_reset_state( );
#else
fp( params );
#endif
#if defined(MBEDTLS_TEST_MUTEX_USAGE)
mbedtls_test_mutex_usage_check( );
#endif /* MBEDTLS_TEST_MUTEX_USAGE */
}
/**
* \brief Dispatches test functions based on function index.
*
* \param func_idx Test function index.
* \param params The array of parameters to pass to the test function.
* It will be decoded by the #TestWrapper_t wrapper function.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int dispatch_test( size_t func_idx, void ** params )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof( test_funcs ) / sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp )
execute_function_ptr(fp, params);
else
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
/**
* \brief Checks if test function is supported in this build-time
* configuration.
*
* \param func_idx Test function index.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int check_test( size_t func_idx )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof(test_funcs)/sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp == NULL )
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
int main( int argc, const char *argv[] )
{
int ret;
mbedtls_test_platform_setup();
ret = execute_tests( argc, argv, "/zip/third_party/mbedtls/test/test_suite_cipher.blowfish.datax" );
mbedtls_test_platform_teardown();
return( ret );
}
| 73,723 | 2,115 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_chachapoly.datax | ChaCha20-Poly1305 RFC 7539 Example and Test Vector (Encrypt)
0:hex:"808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f":hex:"070000004041424344454647":hex:"50515253c0c1c2c3c4c5c6c7":hex:"4c616469657320616e642047656e746c656d656e206f662074686520636c617373206f66202739393a204966204920636f756c64206f6666657220796f75206f6e6c79206f6e652074697020666f7220746865206675747572652c2073756e73637265656e20776f756c642062652069742e":hex:"d31a8d34648e60db7b86afbc53ef7ec2a4aded51296e08fea9e2b5a736ee62d63dbea45e8ca9671282fafb69da92728b1a71de0a9e060b2905d6a5b67ecd3b3692ddbd7f2d778b8c9803aee328091b58fab324e4fad675945585808b4831d7bc3ff4def08e4b7a9de576d26586cec64b6116":hex:"1ae10b594f09e26a7e902ecbd0600691"
ChaCha20-Poly1305 RFC 7539 Example and Test Vector (Decrypt)
1:hex:"808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f":hex:"070000004041424344454647":hex:"50515253c0c1c2c3c4c5c6c7":hex:"d31a8d34648e60db7b86afbc53ef7ec2a4aded51296e08fea9e2b5a736ee62d63dbea45e8ca9671282fafb69da92728b1a71de0a9e060b2905d6a5b67ecd3b3692ddbd7f2d778b8c9803aee328091b58fab324e4fad675945585808b4831d7bc3ff4def08e4b7a9de576d26586cec64b6116":hex:"4c616469657320616e642047656e746c656d656e206f662074686520636c617373206f66202739393a204966204920636f756c64206f6666657220796f75206f6e6c79206f6e652074697020666f7220746865206675747572652c2073756e73637265656e20776f756c642062652069742e":hex:"1ae10b594f09e26a7e902ecbd0600691":int:0
ChaCha20-Poly1305 RFC 7539 Example and Test Vector (Decrypt, not authentic)
1:hex:"808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f":hex:"070000004041424344454647":hex:"50515253c0c1c2c3c4c5c6c7":hex:"d31a8d34648e60db7b86afbc53ef7ec2a4aded51296e08fea9e2b5a736ee62d63dbea45e8ca9671282fafb69da92728b1a71de0a9e060b2905d6a5b67ecd3b3692ddbd7f2d778b8c9803aee328091b58fab324e4fad675945585808b4831d7bc3ff4def08e4b7a9de576d26586cec64b6116":hex:"4c616469657320616e642047656e746c656d656e206f662074686520636c617373206f66202739393a204966204920636f756c64206f6666657220796f75206f6e6c79206f6e652074697020666f7220746865206675747572652c2073756e73637265656e20776f756c642062652069742e":hex:"1ae10b594f09e26a7e902ecbd0600690":exp:0
ChaCha20-Poly1305 RFC 7539 Test Vector #1 (Encrypt)
0:hex:"1c9240a5eb55d38af333888604f6b5f0473917c1402b80099dca5cbc207075c0":hex:"000000000102030405060708":hex:"f33388860000000000004e91":hex:"496e7465726e65742d4472616674732061726520647261667420646f63756d656e74732076616c696420666f722061206d6178696d756d206f6620736978206d6f6e74687320616e64206d617920626520757064617465642c207265706c616365642c206f72206f62736f6c65746564206279206f7468657220646f63756d656e747320617420616e792074696d652e20497420697320696e617070726f70726961746520746f2075736520496e7465726e65742d447261667473206173207265666572656e6365206d6174657269616c206f7220746f2063697465207468656d206f74686572207468616e206173202fe2809c776f726b20696e2070726f67726573732e2fe2809d":hex:"64a0861575861af460f062c79be643bd5e805cfd345cf389f108670ac76c8cb24c6cfc18755d43eea09ee94e382d26b0bdb7b73c321b0100d4f03b7f355894cf332f830e710b97ce98c8a84abd0b948114ad176e008d33bd60f982b1ff37c8559797a06ef4f0ef61c186324e2b3506383606907b6a7c02b0f9f6157b53c867e4b9166c767b804d46a59b5216cde7a4e99040c5a40433225ee282a1b0a06c523eaf4534d7f83fa1155b0047718cbc546a0d072b04b3564eea1b422273f548271a0bb2316053fa76991955ebd63159434ecebb4e466dae5a1073a6727627097a1049e617d91d361094fa68f0ff77987130305beaba2eda04df997b714d6c6f2c29a6ad5cb4022b02709b":hex:"eead9d67890cbb22392336fea1851f38"
ChaCha20-Poly1305 RFC 7539 Test Vector #1 (Decrypt)
1:hex:"1c9240a5eb55d38af333888604f6b5f0473917c1402b80099dca5cbc207075c0":hex:"000000000102030405060708":hex:"f33388860000000000004e91":hex:"64a0861575861af460f062c79be643bd5e805cfd345cf389f108670ac76c8cb24c6cfc18755d43eea09ee94e382d26b0bdb7b73c321b0100d4f03b7f355894cf332f830e710b97ce98c8a84abd0b948114ad176e008d33bd60f982b1ff37c8559797a06ef4f0ef61c186324e2b3506383606907b6a7c02b0f9f6157b53c867e4b9166c767b804d46a59b5216cde7a4e99040c5a40433225ee282a1b0a06c523eaf4534d7f83fa1155b0047718cbc546a0d072b04b3564eea1b422273f548271a0bb2316053fa76991955ebd63159434ecebb4e466dae5a1073a6727627097a1049e617d91d361094fa68f0ff77987130305beaba2eda04df997b714d6c6f2c29a6ad5cb4022b02709b":hex:"496e7465726e65742d4472616674732061726520647261667420646f63756d656e74732076616c696420666f722061206d6178696d756d206f6620736978206d6f6e74687320616e64206d617920626520757064617465642c207265706c616365642c206f72206f62736f6c65746564206279206f7468657220646f63756d656e747320617420616e792074696d652e20497420697320696e617070726f70726961746520746f2075736520496e7465726e65742d447261667473206173207265666572656e6365206d6174657269616c206f7220746f2063697465207468656d206f74686572207468616e206173202fe2809c776f726b20696e2070726f67726573732e2fe2809d":hex:"eead9d67890cbb22392336fea1851f38":int:0
ChaCha20-Poly1305 RFC 7539 Test Vector #1 (Decrypt, not authentic)
1:hex:"1c9240a5eb55d38af333888604f6b5f0473917c1402b80099dca5cbc207075c0":hex:"000000000102030405060708":hex:"f33388860000000000004e91":hex:"64a0861575861af460f062c79be643bd5e805cfd345cf389f108670ac76c8cb24c6cfc18755d43eea09ee94e382d26b0bdb7b73c321b0100d4f03b7f355894cf332f830e710b97ce98c8a84abd0b948114ad176e008d33bd60f982b1ff37c8559797a06ef4f0ef61c186324e2b3506383606907b6a7c02b0f9f6157b53c867e4b9166c767b804d46a59b5216cde7a4e99040c5a40433225ee282a1b0a06c523eaf4534d7f83fa1155b0047718cbc546a0d072b04b3564eea1b422273f548271a0bb2316053fa76991955ebd63159434ecebb4e466dae5a1073a6727627097a1049e617d91d361094fa68f0ff77987130305beaba2eda04df997b714d6c6f2c29a6ad5cb4022b02709b":hex:"496e7465726e65742d4472616674732061726520647261667420646f63756d656e74732076616c696420666f722061206d6178696d756d206f6620736978206d6f6e74687320616e64206d617920626520757064617465642c207265706c616365642c206f72206f62736f6c65746564206279206f7468657220646f63756d656e747320617420616e792074696d652e20497420697320696e617070726f70726961746520746f2075736520496e7465726e65742d447261667473206173207265666572656e6365206d6174657269616c206f7220746f2063697465207468656d206f74686572207468616e206173202fe2809c776f726b20696e2070726f67726573732e2fe2809d":hex:"fead9d67890cbb22392336fea1851f38":exp:0
ChaCha20-Poly1305 State Flow
3
ChaCha20-Poly1305 Parameter Validation
2
ChaCha20-Poly1305 Selftest
depends_on:0
4
| 6,192 | 29 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_pkcs1_v15.c | /* clang-format off */
/*
* Copyright The Mbed TLS Contributors
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "third_party/mbedtls/test/test.inc"
/*
* *** THIS FILE WAS MACHINE GENERATED ***
*
* This file has been machine generated using the script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* Test file : ./test_suite_pkcs1_v15.c
*
* The following files were used to create this file.
*
* Main code file : suites/main_test.function
* Platform code file : suites/host_test.function
* Helper file : suites/helpers.function
* Test suite file : suites/test_suite_pkcs1_v15.function
* Test suite data : suites/test_suite_pkcs1_v15.data
*
*/
#define TEST_SUITE_ACTIVE
#if defined(MBEDTLS_PKCS1_V15)
#if defined(MBEDTLS_RSA_C)
#if defined(MBEDTLS_SHA1_C)
#include "third_party/mbedtls/rsa.h"
#include "third_party/mbedtls/md.h"
void test_pkcs1_rsaes_v15_encrypt( int mod, int radix_N, char * input_N,
int radix_E, char * input_E, int hash,
data_t * message_str, data_t * rnd_buf,
data_t * result_str, int result )
{
unsigned char output[128];
mbedtls_rsa_context ctx;
mbedtls_test_rnd_buf_info info;
mbedtls_mpi N, E;
info.buf = rnd_buf->x;
info.length = rnd_buf->len;
mbedtls_mpi_init( &N ); mbedtls_mpi_init( &E );
mbedtls_rsa_init( &ctx, MBEDTLS_RSA_PKCS_V15, hash );
memset( output, 0x00, sizeof( output ) );
TEST_ASSERT( mbedtls_mpi_read_string( &N, radix_N, input_N ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &E, radix_E, input_E ) == 0 );
TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, NULL, NULL, NULL, &E ) == 0 );
TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( ( mod + 7 ) / 8 ) );
TEST_ASSERT( mbedtls_rsa_check_pubkey( &ctx ) == 0 );
if( message_str->len == 0 )
message_str->x = NULL;
TEST_ASSERT( mbedtls_rsa_pkcs1_encrypt( &ctx,
&mbedtls_test_rnd_buffer_rand,
&info, MBEDTLS_RSA_PUBLIC,
message_str->len, message_str->x,
output ) == result );
if( result == 0 )
{
TEST_ASSERT( mbedtls_test_hexcmp( output, result_str->x,
ctx.len, result_str->len ) == 0 );
}
exit:
mbedtls_mpi_free( &N ); mbedtls_mpi_free( &E );
mbedtls_rsa_free( &ctx );
}
void test_pkcs1_rsaes_v15_encrypt_wrapper( void ** params )
{
data_t data6 = {(uint8_t *) params[6], *( (uint32_t *) params[7] )};
data_t data8 = {(uint8_t *) params[8], *( (uint32_t *) params[9] )};
data_t data10 = {(uint8_t *) params[10], *( (uint32_t *) params[11] )};
test_pkcs1_rsaes_v15_encrypt( *( (int *) params[0] ), *( (int *) params[1] ), (char *) params[2], *( (int *) params[3] ), (char *) params[4], *( (int *) params[5] ), &data6, &data8, &data10, *( (int *) params[12] ) );
}
void test_pkcs1_rsaes_v15_decrypt( int mod, int radix_P, char * input_P,
int radix_Q, char * input_Q, int radix_N,
char * input_N, int radix_E, char * input_E,
int hash, data_t * result_str,
char * seed, data_t * message_str,
int result )
{
unsigned char output[128];
mbedtls_rsa_context ctx;
size_t output_len;
mbedtls_test_rnd_pseudo_info rnd_info;
mbedtls_mpi N, P, Q, E;
((void) seed);
mbedtls_mpi_init( &N ); mbedtls_mpi_init( &P );
mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &E );
mbedtls_rsa_init( &ctx, MBEDTLS_RSA_PKCS_V15, hash );
memset( output, 0x00, sizeof( output ) );
memset( &rnd_info, 0, sizeof( mbedtls_test_rnd_pseudo_info ) );
TEST_ASSERT( mbedtls_mpi_read_string( &P, radix_P, input_P ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &Q, radix_Q, input_Q ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &N, radix_N, input_N ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &E, radix_E, input_E ) == 0 );
TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, &P, &Q, NULL, &E ) == 0 );
TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( ( mod + 7 ) / 8 ) );
TEST_ASSERT( mbedtls_rsa_complete( &ctx ) == 0 );
TEST_ASSERT( mbedtls_rsa_check_privkey( &ctx ) == 0 );
if( result_str->len == 0 )
{
TEST_ASSERT( mbedtls_rsa_pkcs1_decrypt( &ctx,
&mbedtls_test_rnd_pseudo_rand,
&rnd_info,
MBEDTLS_RSA_PRIVATE,
&output_len, message_str->x,
NULL, 0 ) == result );
}
else
{
TEST_ASSERT( mbedtls_rsa_pkcs1_decrypt( &ctx,
&mbedtls_test_rnd_pseudo_rand,
&rnd_info, MBEDTLS_RSA_PRIVATE,
&output_len, message_str->x,
output, 1000 ) == result );
if( result == 0 )
{
TEST_ASSERT( mbedtls_test_hexcmp( output, result_str->x,
output_len,
result_str->len) == 0 );
}
}
exit:
mbedtls_mpi_free( &N ); mbedtls_mpi_free( &P );
mbedtls_mpi_free( &Q ); mbedtls_mpi_free( &E );
mbedtls_rsa_free( &ctx );
}
void test_pkcs1_rsaes_v15_decrypt_wrapper( void ** params )
{
data_t data10 = {(uint8_t *) params[10], *( (uint32_t *) params[11] )};
data_t data13 = {(uint8_t *) params[13], *( (uint32_t *) params[14] )};
test_pkcs1_rsaes_v15_decrypt( *( (int *) params[0] ), *( (int *) params[1] ), (char *) params[2], *( (int *) params[3] ), (char *) params[4], *( (int *) params[5] ), (char *) params[6], *( (int *) params[7] ), (char *) params[8], *( (int *) params[9] ), &data10, (char *) params[12], &data13, *( (int *) params[15] ) );
}
void test_pkcs1_v15_decode( int mode,
data_t *input,
int expected_plaintext_length_arg,
int output_size_arg,
int expected_result )
{
size_t expected_plaintext_length = expected_plaintext_length_arg;
size_t output_size = output_size_arg;
mbedtls_test_rnd_pseudo_info rnd_info;
mbedtls_mpi Nmpi, Empi, Pmpi, Qmpi;
mbedtls_rsa_context ctx;
static unsigned char N[128] = {
0xc4, 0x79, 0x4c, 0x6d, 0xb2, 0xe9, 0xdf, 0xc5,
0xe5, 0xd7, 0x55, 0x4b, 0xfb, 0x6c, 0x2e, 0xec,
0x84, 0xd0, 0x88, 0x12, 0xaf, 0xbf, 0xb4, 0xf5,
0x47, 0x3c, 0x7e, 0x92, 0x4c, 0x58, 0xc8, 0x73,
0xfe, 0x8f, 0x2b, 0x8f, 0x8e, 0xc8, 0x5c, 0xf5,
0x05, 0xeb, 0xfb, 0x0d, 0x7b, 0x2a, 0x93, 0xde,
0x15, 0x0d, 0xc8, 0x13, 0xcf, 0xd2, 0x6f, 0x0d,
0x9d, 0xad, 0x30, 0xe5, 0x70, 0x20, 0x92, 0x9e,
0xb3, 0x6b, 0xba, 0x5c, 0x50, 0x0f, 0xc3, 0xb2,
0x7e, 0x64, 0x07, 0x94, 0x7e, 0xc9, 0x4e, 0xc1,
0x65, 0x04, 0xaf, 0xb3, 0x9f, 0xde, 0xa8, 0x46,
0xfa, 0x6c, 0xf3, 0x03, 0xaf, 0x1c, 0x1b, 0xec,
0x75, 0x44, 0x66, 0x77, 0xc9, 0xde, 0x51, 0x33,
0x64, 0x27, 0xb0, 0xd4, 0x8d, 0x31, 0x6a, 0x11,
0x27, 0x3c, 0x99, 0xd4, 0x22, 0xc0, 0x9d, 0x12,
0x01, 0xc7, 0x4a, 0x73, 0xac, 0xbf, 0xc2, 0xbb
};
static unsigned char E[1] = { 0x03 };
static unsigned char P[64] = {
0xe5, 0x53, 0x1f, 0x88, 0x51, 0xee, 0x59, 0xf8,
0xc1, 0xe4, 0xcc, 0x5b, 0xb3, 0x75, 0x8d, 0xc8,
0xe8, 0x95, 0x2f, 0xd0, 0xef, 0x37, 0xb4, 0xcd,
0xd3, 0x9e, 0x48, 0x8b, 0x81, 0x58, 0x60, 0xb9,
0x27, 0x1d, 0xb6, 0x28, 0x92, 0x64, 0xa3, 0xa5,
0x64, 0xbd, 0xcc, 0x53, 0x68, 0xdd, 0x3e, 0x55,
0xea, 0x9d, 0x5e, 0xcd, 0x1f, 0x96, 0x87, 0xf1,
0x29, 0x75, 0x92, 0x70, 0x8f, 0x28, 0xfb, 0x2b
};
static unsigned char Q[64] = {
0xdb, 0x53, 0xef, 0x74, 0x61, 0xb4, 0x20, 0x3b,
0x3b, 0x87, 0x76, 0x75, 0x81, 0x56, 0x11, 0x03,
0x59, 0x31, 0xe3, 0x38, 0x4b, 0x8c, 0x7a, 0x9c,
0x05, 0xd6, 0x7f, 0x1e, 0x5e, 0x60, 0xf0, 0x4e,
0x0b, 0xdc, 0x34, 0x54, 0x1c, 0x2e, 0x90, 0x83,
0x14, 0xef, 0xc0, 0x96, 0x5c, 0x30, 0x10, 0xcc,
0xc1, 0xba, 0xa0, 0x54, 0x3f, 0x96, 0x24, 0xca,
0xa3, 0xfb, 0x55, 0xbc, 0x71, 0x29, 0x4e, 0xb1
};
unsigned char original[128];
unsigned char intermediate[128];
static unsigned char default_content[128] = {
/* A randomly generated pattern. */
0x4c, 0x27, 0x54, 0xa0, 0xce, 0x0d, 0x09, 0x4a,
0x1c, 0x38, 0x8e, 0x2d, 0xa3, 0xc4, 0xe0, 0x19,
0x4c, 0x99, 0xb2, 0xbf, 0xe6, 0x65, 0x7e, 0x58,
0xd7, 0xb6, 0x8a, 0x05, 0x2f, 0xa5, 0xec, 0xa4,
0x35, 0xad, 0x10, 0x36, 0xff, 0x0d, 0x08, 0x50,
0x74, 0x47, 0xc9, 0x9c, 0x4a, 0xe7, 0xfd, 0xfa,
0x83, 0x5f, 0x14, 0x5a, 0x1e, 0xe7, 0x35, 0x08,
0xad, 0xf7, 0x0d, 0x86, 0xdf, 0xb8, 0xd4, 0xcf,
0x32, 0xb9, 0x5c, 0xbe, 0xa3, 0xd2, 0x89, 0x70,
0x7b, 0xc6, 0x48, 0x7e, 0x58, 0x4d, 0xf3, 0xef,
0x34, 0xb7, 0x57, 0x54, 0x79, 0xc5, 0x8e, 0x0a,
0xa3, 0xbf, 0x6d, 0x42, 0x83, 0x25, 0x13, 0xa2,
0x95, 0xc0, 0x0d, 0x32, 0xec, 0x77, 0x91, 0x2b,
0x68, 0xb6, 0x8c, 0x79, 0x15, 0xfb, 0x94, 0xde,
0xb9, 0x2b, 0x94, 0xb3, 0x28, 0x23, 0x86, 0x3d,
0x37, 0x00, 0xe6, 0xf1, 0x1f, 0x4e, 0xd4, 0x42
};
unsigned char final[128];
size_t output_length = 0x7EA0;
memset( &rnd_info, 0, sizeof( mbedtls_test_rnd_pseudo_info ) );
mbedtls_mpi_init( &Nmpi ); mbedtls_mpi_init( &Empi );
mbedtls_mpi_init( &Pmpi ); mbedtls_mpi_init( &Qmpi );
mbedtls_rsa_init( &ctx, MBEDTLS_RSA_PKCS_V15, 0 );
TEST_ASSERT( mbedtls_mpi_read_binary( &Nmpi, N, sizeof( N ) ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_binary( &Empi, E, sizeof( E ) ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_binary( &Pmpi, P, sizeof( P ) ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_binary( &Qmpi, Q, sizeof( Q ) ) == 0 );
TEST_ASSERT( mbedtls_rsa_import( &ctx, &Nmpi, &Pmpi, &Qmpi,
NULL, &Empi ) == 0 );
TEST_ASSERT( mbedtls_rsa_complete( &ctx ) == 0 );
TEST_ASSERT( input->len <= sizeof( N ) );
memcpy( original, input->x, input->len );
memset( original + input->len, 'd', sizeof( original ) - input->len );
if( mode == MBEDTLS_RSA_PRIVATE )
TEST_ASSERT( mbedtls_rsa_public( &ctx, original, intermediate ) == 0 );
else
TEST_ASSERT( mbedtls_rsa_private( &ctx, &mbedtls_test_rnd_pseudo_rand,
&rnd_info, original,
intermediate ) == 0 );
memcpy( final, default_content, sizeof( final ) );
TEST_ASSERT( mbedtls_rsa_pkcs1_decrypt( &ctx,
&mbedtls_test_rnd_pseudo_rand,
&rnd_info, mode, &output_length,
intermediate, final,
output_size ) == expected_result );
if( expected_result == 0 )
{
TEST_ASSERT( output_length == expected_plaintext_length );
TEST_ASSERT( timingsafe_bcmp( original + sizeof( N ) - output_length,
final, output_length ) == 0 );
}
else if( expected_result == MBEDTLS_ERR_RSA_INVALID_PADDING ||
expected_result == MBEDTLS_ERR_RSA_OUTPUT_TOO_LARGE )
{
size_t max_payload_length =
output_size > sizeof( N ) - 11 ? sizeof( N ) - 11 : output_size;
size_t i;
size_t count = 0;
#if !defined(MBEDTLS_RSA_ALT)
/* Check that the output in invalid cases is what the default
* implementation currently does. Alternative implementations
* may produce different output, so we only perform these precise
* checks when using the default implementation. */
TEST_ASSERT( output_length == max_payload_length );
for( i = 0; i < max_payload_length; i++ )
TEST_ASSERT( final[i] == 0 );
#endif
/* Even in alternative implementations, the outputs must have
* changed, otherwise it indicates at least a timing vulnerability
* because no write to the outputs is performed in the bad case. */
TEST_ASSERT( output_length != 0x7EA0 );
for( i = 0; i < max_payload_length; i++ )
count += ( final[i] == default_content[i] );
/* If more than 16 bytes are unchanged in final, that's evidence
* that final wasn't overwritten. */
TEST_ASSERT( count < 16 );
}
exit:
mbedtls_mpi_free( &Nmpi ); mbedtls_mpi_free( &Empi );
mbedtls_mpi_free( &Pmpi ); mbedtls_mpi_free( &Qmpi );
mbedtls_rsa_free( &ctx );
}
void test_pkcs1_v15_decode_wrapper( void ** params )
{
data_t data1 = {(uint8_t *) params[1], *( (uint32_t *) params[2] )};
test_pkcs1_v15_decode( *( (int *) params[0] ), &data1, *( (int *) params[3] ), *( (int *) params[4] ), *( (int *) params[5] ) );
}
void test_pkcs1_rsassa_v15_sign( int mod, int radix_P, char * input_P, int radix_Q,
char * input_Q, int radix_N, char * input_N,
int radix_E, char * input_E, int digest, int hash,
data_t * message_str, data_t * rnd_buf,
data_t * result_str, int result )
{
unsigned char hash_result[MBEDTLS_MD_MAX_SIZE];
unsigned char output[128];
mbedtls_rsa_context ctx;
mbedtls_mpi N, P, Q, E;
mbedtls_test_rnd_buf_info info;
info.buf = rnd_buf->x;
info.length = rnd_buf->len;
mbedtls_mpi_init( &N ); mbedtls_mpi_init( &P );
mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &E );
mbedtls_rsa_init( &ctx, MBEDTLS_RSA_PKCS_V15, hash );
memset( hash_result, 0x00, sizeof( hash_result ) );
memset( output, 0x00, sizeof( output ) );
TEST_ASSERT( mbedtls_mpi_read_string( &P, radix_P, input_P ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &Q, radix_Q, input_Q ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &N, radix_N, input_N ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &E, radix_E, input_E ) == 0 );
TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, &P, &Q, NULL, &E ) == 0 );
TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( ( mod + 7 ) / 8 ) );
TEST_ASSERT( mbedtls_rsa_complete( &ctx ) == 0 );
TEST_ASSERT( mbedtls_rsa_check_privkey( &ctx ) == 0 );
if( mbedtls_md_info_from_type( digest ) != NULL )
TEST_ASSERT( mbedtls_md( mbedtls_md_info_from_type( digest ), message_str->x, message_str->len, hash_result ) == 0 );
TEST_ASSERT( mbedtls_rsa_pkcs1_sign( &ctx, &mbedtls_test_rnd_buffer_rand,
&info, MBEDTLS_RSA_PRIVATE, digest,
0, hash_result, output ) == result );
if( result == 0 )
{
TEST_ASSERT( mbedtls_test_hexcmp( output, result_str->x,
ctx.len, result_str->len ) == 0 );
}
exit:
mbedtls_mpi_free( &N ); mbedtls_mpi_free( &P );
mbedtls_mpi_free( &Q ); mbedtls_mpi_free( &E );
mbedtls_rsa_free( &ctx );
}
void test_pkcs1_rsassa_v15_sign_wrapper( void ** params )
{
data_t data11 = {(uint8_t *) params[11], *( (uint32_t *) params[12] )};
data_t data13 = {(uint8_t *) params[13], *( (uint32_t *) params[14] )};
data_t data15 = {(uint8_t *) params[15], *( (uint32_t *) params[16] )};
test_pkcs1_rsassa_v15_sign( *( (int *) params[0] ), *( (int *) params[1] ), (char *) params[2], *( (int *) params[3] ), (char *) params[4], *( (int *) params[5] ), (char *) params[6], *( (int *) params[7] ), (char *) params[8], *( (int *) params[9] ), *( (int *) params[10] ), &data11, &data13, &data15, *( (int *) params[17] ) );
}
void test_pkcs1_rsassa_v15_verify( int mod, int radix_N, char * input_N,
int radix_E, char * input_E, int digest,
int hash, data_t * message_str, char * salt,
data_t * result_str, int result )
{
unsigned char hash_result[MBEDTLS_MD_MAX_SIZE];
mbedtls_rsa_context ctx;
mbedtls_mpi N, E;
((void) salt);
mbedtls_mpi_init( &N ); mbedtls_mpi_init( &E );
mbedtls_rsa_init( &ctx, MBEDTLS_RSA_PKCS_V15, hash );
memset( hash_result, 0x00, sizeof( hash_result ) );
TEST_ASSERT( mbedtls_mpi_read_string( &N, radix_N, input_N ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &E, radix_E, input_E ) == 0 );
TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, NULL, NULL, NULL, &E ) == 0 );
TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( ( mod + 7 ) / 8 ) );
TEST_ASSERT( mbedtls_rsa_check_pubkey( &ctx ) == 0 );
if( mbedtls_md_info_from_type( digest ) != NULL )
TEST_ASSERT( mbedtls_md( mbedtls_md_info_from_type( digest ), message_str->x, message_str->len, hash_result ) == 0 );
TEST_ASSERT( mbedtls_rsa_pkcs1_verify( &ctx, NULL, NULL, MBEDTLS_RSA_PUBLIC, digest, 0, hash_result, result_str->x ) == result );
exit:
mbedtls_mpi_free( &N ); mbedtls_mpi_free( &E );
mbedtls_rsa_free( &ctx );
}
void test_pkcs1_rsassa_v15_verify_wrapper( void ** params )
{
data_t data7 = {(uint8_t *) params[7], *( (uint32_t *) params[8] )};
data_t data10 = {(uint8_t *) params[10], *( (uint32_t *) params[11] )};
test_pkcs1_rsassa_v15_verify( *( (int *) params[0] ), *( (int *) params[1] ), (char *) params[2], *( (int *) params[3] ), (char *) params[4], *( (int *) params[5] ), *( (int *) params[6] ), &data7, (char *) params[9], &data10, *( (int *) params[12] ) );
}
#endif /* MBEDTLS_SHA1_C */
#endif /* MBEDTLS_RSA_C */
#endif /* MBEDTLS_PKCS1_V15 */
/*----------------------------------------------------------------------------*/
/* Test dispatch code */
/**
* \brief Evaluates an expression/macro into its literal integer value.
* For optimizing space for embedded targets each expression/macro
* is identified by a unique identifier instead of string literals.
* Identifiers and evaluation code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param exp_id Expression identifier.
* \param out_value Pointer to int to hold the integer.
*
* \return 0 if exp_id is found. 1 otherwise.
*/
int get_expression( int32_t exp_id, int32_t * out_value )
{
int ret = KEY_VALUE_MAPPING_FOUND;
(void) exp_id;
(void) out_value;
switch( exp_id )
{
#if defined(MBEDTLS_PKCS1_V15) && defined(MBEDTLS_RSA_C) && defined(MBEDTLS_SHA1_C)
case 0:
{
*out_value = MBEDTLS_MD_NONE;
}
break;
case 1:
{
*out_value = MBEDTLS_MD_SHA1;
}
break;
case 2:
{
*out_value = MBEDTLS_ERR_RSA_BAD_INPUT_DATA;
}
break;
case 3:
{
*out_value = MBEDTLS_ERR_RSA_INVALID_PADDING;
}
break;
case 4:
{
*out_value = MBEDTLS_RSA_PRIVATE;
}
break;
case 5:
{
*out_value = MBEDTLS_ERR_RSA_OUTPUT_TOO_LARGE;
}
break;
case 6:
{
*out_value = MBEDTLS_RSA_PUBLIC;
}
break;
#endif
default:
{
ret = KEY_VALUE_MAPPING_NOT_FOUND;
}
break;
}
return( ret );
}
/**
* \brief Checks if the dependency i.e. the compile flag is set.
* For optimizing space for embedded targets each dependency
* is identified by a unique identifier instead of string literals.
* Identifiers and check code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param dep_id Dependency identifier.
*
* \return DEPENDENCY_SUPPORTED if set else DEPENDENCY_NOT_SUPPORTED
*/
int dep_check( int dep_id )
{
int ret = DEPENDENCY_NOT_SUPPORTED;
(void) dep_id;
switch( dep_id )
{
#if defined(MBEDTLS_PKCS1_V15) && defined(MBEDTLS_RSA_C) && defined(MBEDTLS_SHA1_C)
#endif
default:
break;
}
return( ret );
}
/**
* \brief Function pointer type for test function wrappers.
*
* A test function wrapper decodes the parameters and passes them to the
* underlying test function. Both the wrapper and the underlying function
* return void. Test wrappers assume that they are passed a suitable
* parameter array and do not perform any error detection.
*
* \param param_array The array of parameters. Each element is a `void *`
* which the wrapper casts to the correct type and
* dereferences. Each wrapper function hard-codes the
* number and types of the parameters.
*/
typedef void (*TestWrapper_t)( void **param_array );
/**
* \brief Table of test function wrappers. Used by dispatch_test().
* This table is populated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
*/
TestWrapper_t test_funcs[] =
{
/* Function Id: 0 */
#if defined(MBEDTLS_PKCS1_V15) && defined(MBEDTLS_RSA_C) && defined(MBEDTLS_SHA1_C)
test_pkcs1_rsaes_v15_encrypt_wrapper,
#else
NULL,
#endif
/* Function Id: 1 */
#if defined(MBEDTLS_PKCS1_V15) && defined(MBEDTLS_RSA_C) && defined(MBEDTLS_SHA1_C)
test_pkcs1_rsaes_v15_decrypt_wrapper,
#else
NULL,
#endif
/* Function Id: 2 */
#if defined(MBEDTLS_PKCS1_V15) && defined(MBEDTLS_RSA_C) && defined(MBEDTLS_SHA1_C)
test_pkcs1_v15_decode_wrapper,
#else
NULL,
#endif
/* Function Id: 3 */
#if defined(MBEDTLS_PKCS1_V15) && defined(MBEDTLS_RSA_C) && defined(MBEDTLS_SHA1_C)
test_pkcs1_rsassa_v15_sign_wrapper,
#else
NULL,
#endif
/* Function Id: 4 */
#if defined(MBEDTLS_PKCS1_V15) && defined(MBEDTLS_RSA_C) && defined(MBEDTLS_SHA1_C)
test_pkcs1_rsassa_v15_verify_wrapper,
#else
NULL,
#endif
};
/**
* \brief Execute the test function.
*
* This is a wrapper function around the test function execution
* to allow the setjmp() call used to catch any calls to the
* parameter failure callback, to be used. Calls to setjmp()
* can invalidate the state of any local auto variables.
*
* \param fp Function pointer to the test function.
* \param params Parameters to pass to the #TestWrapper_t wrapper function.
*
*/
void execute_function_ptr(TestWrapper_t fp, void **params)
{
#if defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG)
mbedtls_test_enable_insecure_external_rng( );
#endif
#if defined(MBEDTLS_CHECK_PARAMS)
mbedtls_test_param_failed_location_record_t location_record;
if ( setjmp( mbedtls_test_param_failed_get_state_buf( ) ) == 0 )
{
fp( params );
}
else
{
/* Unexpected parameter validation error */
mbedtls_test_param_failed_get_location_record( &location_record );
mbedtls_test_fail( location_record.failure_condition,
location_record.line,
location_record.file );
}
mbedtls_test_param_failed_reset_state( );
#else
fp( params );
#endif
#if defined(MBEDTLS_TEST_MUTEX_USAGE)
mbedtls_test_mutex_usage_check( );
#endif /* MBEDTLS_TEST_MUTEX_USAGE */
}
/**
* \brief Dispatches test functions based on function index.
*
* \param func_idx Test function index.
* \param params The array of parameters to pass to the test function.
* It will be decoded by the #TestWrapper_t wrapper function.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int dispatch_test( size_t func_idx, void ** params )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof( test_funcs ) / sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp )
execute_function_ptr(fp, params);
else
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
/**
* \brief Checks if test function is supported in this build-time
* configuration.
*
* \param func_idx Test function index.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int check_test( size_t func_idx )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof(test_funcs)/sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp == NULL )
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
int main( int argc, const char *argv[] )
{
int ret;
mbedtls_test_platform_setup();
ret = execute_tests( argc, argv, "/zip/third_party/mbedtls/test/test_suite_pkcs1_v15.datax" );
mbedtls_test_platform_teardown();
return( ret );
}
| 26,444 | 697 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_asn1parse.datax | Empty length
0:hex:"04":exp:0:exp:1
Incomplete length
0:hex:"0481":exp:0:exp:1
Prefixes of OCTET STRING, length=0
0:hex:"0400":int:0:int:0
Prefixes of OCTET STRING, length=0 (0 length bytes)
0:hex:"0480":exp:2:exp:2
Prefixes of OCTET STRING, length=1
0:hex:"040141":int:0:int:0
Prefixes of OCTET STRING, length=2
0:hex:"04024142":int:0:int:0
Prefixes of BOOLEAN, length=0
0:hex:"0100":exp:2:exp:2
Prefixes of BOOLEAN, length=1
0:hex:"010100":int:0:int:0
Prefixes of BOOLEAN, length=2
0:hex:"01020000":exp:2:exp:2
Prefixes of INTEGER, length=1
0:hex:"020141":int:0:int:0
Prefixes of INTEGER, length=2
0:hex:"02024142":int:0:int:0
Prefixes of INTEGER, length=5
0:hex:"02054142434445":int:0:int:0
Prefixes of empty BIT STRING
0:hex:"0300":exp:0:exp:1
Prefixes of BIT STRING, unused_bits=0, payload_length=0
0:hex:"030100":int:0:exp:3
Prefixes of BIT STRING, unused_bits=0, payload_length=1
0:hex:"0302002a":int:0:exp:3
Prefixes of BIT STRING, unused_bits=1, payload_length=1
0:hex:"0302012a":int:0:exp:3
Prefixes of empty SEQUENCE
0:hex:"3000":int:0:int:0
Prefixes of SEQUENCE of BOOLEAN, INTEGER, INTEGER
0:hex:"300b01010102012a0203123456":int:0:int:0
Prefixes of SEQUENCE of (SEQUENCE of INTEGER, INTEGER), INTEGER
0:hex:"300b3006020141020142020161":int:0:int:0
length=0 (short form)
1:hex:"00":int:0
length=0 (1 length byte)
1:hex:"8100":int:0
length=0 (2 length bytes)
1:hex:"820000":int:0
length=1 (short form)
1:hex:"01":int:1
length=1 (1 length byte)
1:hex:"8101":int:1
length=1 (2 length bytes)
1:hex:"820001":int:1
length=1 (3 length bytes)
1:hex:"83000001":int:1
length=1 (4 length bytes)
1:hex:"8400000001":int:1
length=2 (short form)
1:hex:"02":int:2
length=2 (1 length byte)
1:hex:"8102":int:2
length=2 (2 length bytes)
1:hex:"820002":int:2
length=2 (3 length bytes)
1:hex:"83000002":int:2
length=2 (4 length bytes)
1:hex:"8400000002":int:2
length=127 (short form)
1:hex:"7f":int:127
length=128 (1 length byte)
1:hex:"8180":int:128
length=128 (2 length bytes)
1:hex:"820080":int:128
length=255 (1 length byte)
1:hex:"81ff":int:255
length=255 (2 length bytes)
1:hex:"8200ff":int:255
length=256 (2 length bytes)
1:hex:"820100":int:256
length=256 (3 length bytes)
1:hex:"83000100":int:256
length=258 (2 length bytes)
1:hex:"820102":int:258
length=258 (3 length bytes)
1:hex:"83000102":int:258
length=65535 (2 length bytes)
1:hex:"82ffff":int:65535
length=65535 (3 length bytes)
1:hex:"8300ffff":int:65535
length=65535 (4 length bytes)
1:hex:"840000ffff":int:65535
length=65536 (3 length bytes)
1:hex:"83010000":int:65536
length=65536 (4 length bytes)
1:hex:"8400010000":int:65536
length=16777215 (3 length bytes)
1:hex:"83ffffff":int:16777215
length=16777215 (4 length bytes)
1:hex:"8400ffffff":int:16777215
length=16777216 (4 length bytes)
1:hex:"8401000000":int:16777216
length=16909060 (4 length bytes)
1:hex:"8401020304":int:16909060
BOOLEAN FALSE
2:hex:"010100":int:0:int:0
BOOLEAN TRUE (1)
2:hex:"010101":int:1:int:0
BOOLEAN TRUE (2)
2:hex:"010101":int:1:int:0
BOOLEAN TRUE (128)
2:hex:"010180":int:1:int:0
BOOLEAN TRUE (255)
2:hex:"0101ff":int:1:int:0
Not BOOLEAN
2:hex:"020101":int:0:exp:4
Empty INTEGER
3:hex:"0200"
INTEGER 0
4:hex:"020100":char*:"0":int:0
INTEGER 0, extra leading 0
4:hex:"02020000":char*:"0":int:0
INTEGER 1
4:hex:"020101":char*:"1":int:0
INTEGER 1, extra leading 0
4:hex:"02020001":char*:"1":int:0
INTEGER 0x7f
4:hex:"02017f":char*:"7f":int:0
INTEGER 0x80
4:hex:"02020080":char*:"80":int:0
INTEGER 0x80, extra leading 0
4:hex:"0203000080":char*:"80":int:0
INTEGER 0xff
4:hex:"020200ff":char*:"ff":int:0
INTEGER 0x7fff
4:hex:"02027fff":char*:"7fff":int:0
INTEGER 0x12345678
4:hex:"020412345678":char*:"12345678":int:0
INTEGER 0x12345678, extra leading 0
4:hex:"02050012345678":char*:"12345678":int:0
INTEGER 0x7fffffff
4:hex:"02047fffffff":char*:"7fffffff":int:0
INTEGER 0x7fffffff, extra leading 0
4:hex:"0205007fffffff":char*:"7fffffff":int:0
INTEGER 0x80000000
4:hex:"02050080000000":char*:"80000000":int:0
INTEGER 0xffffffff
4:hex:"020500ffffffff":char*:"ffffffff":int:0
INTEGER 0x100000000
4:hex:"02050100000000":char*:"0100000000":int:0
INTEGER 0x123456789abcdef0
4:hex:"0208123456789abcdef0":char*:"123456789abcdef0":int:0
INTEGER 0xfedcab9876543210
4:hex:"020900fedcab9876543210":char*:"fedcab9876543210":int:0
INTEGER 0x1fedcab9876543210
4:hex:"020901fedcab9876543210":char*:"1fedcab9876543210":int:0
INTEGER with 127 value octets
4:hex:"027f0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcd":char*:"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcd":int:0
INTEGER with 127 value octets (long length encoding)
4:hex:"02817f0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcd":char*:"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcd":int:0
INTEGER with 128 value octets
4:hex:"0281800123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef":char*:"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef":int:0
INTEGER with 128 value octets (leading 0 in length)
4:hex:"028200800123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef":char*:"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef":int:0
INTEGER -1
4:hex:"0201ff":char*:"-1":int:0
INTEGER -1, extra leading ff
4:hex:"0202ffff":char*:"-1":int:0
INTEGER -0x7f
4:hex:"020181":char*:"-7f":int:0
INTEGER -0x80
4:hex:"020180":char*:"-80":int:0
INTEGER -0x81
4:hex:"0202ff7f":char*:"-81":int:0
INTEGER -0xff
4:hex:"0202ff01":char*:"-ff":int:0
INTEGER -0x100
4:hex:"0202ff00":char*:"-100":int:0
INTEGER -0x7fffffff
4:hex:"020480000001":char*:"-7fffffff":int:0
INTEGER -0x80000000
4:hex:"020480000000":char*:"-80000000":int:0
INTEGER -0x80000001
4:hex:"0205ff7fffffff":char*:"-80000001":int:0
INTEGER -0xffffffff
4:hex:"0205ff00000001":char*:"-ffffffff":int:0
INTEGER -0x100000000
4:hex:"0205ff00000000":char*:"-100000000":int:0
INTEGER -0x123456789abcdef0
4:hex:"0208edcba98765432110":char*:"-123456789abcdef0":int:0
INTEGER -0xfedcba9876543210
4:hex:"0209ff0123456789abcdf0":char*:"-fedcba9876543210":int:0
INTEGER -0x1fedcab9876543210
4:hex:"0209fe0123546789abcdf0":char*:"-1fedcab9876543210":int:0
Not INTEGER
4:hex:"010101":char*:"":exp:4
INTEGER too large for mpi
6
ENUMERATED 0
5:hex:"0A0100":char*:"0":int:0
ENUMERATED 0, extra leading 0
5:hex:"0A020000":char*:"0":int:0
ENUMERATED 1
5:hex:"0A0101":char*:"1":int:0
ENUMERATED 1, extra leading 0
5:hex:"0A020001":char*:"1":int:0
ENUMERATED 0x7f
5:hex:"0A017f":char*:"7f":int:0
ENUMERATED 0x80
5:hex:"0A020080":char*:"80":int:0
ENUMERATED 0x80, extra leading 0
5:hex:"0A03000080":char*:"80":int:0
ENUMERATED 0xff
5:hex:"0A0200ff":char*:"ff":int:0
ENUMERATED 0x7fff
5:hex:"0A027fff":char*:"7fff":int:0
ENUMERATED 0x12345678
5:hex:"0A0412345678":char*:"12345678":int:0
ENUMERATED 0x12345678, extra leading 0
5:hex:"0A050012345678":char*:"12345678":int:0
ENUMERATED 0x7fffffff
5:hex:"0A047fffffff":char*:"7fffffff":int:0
ENUMERATED 0x7fffffff, extra leading 0
5:hex:"0A05007fffffff":char*:"7fffffff":int:0
ENUMERATED 0x80000000
5:hex:"0A050080000000":char*:"80000000":int:0
ENUMERATED 0xffffffff
5:hex:"0A0500ffffffff":char*:"ffffffff":int:0
ENUMERATED 0x100000000
5:hex:"0A050100000000":char*:"0100000000":int:0
ENUMERATED -1
5:hex:"0A01ff":char*:"-1":int:0
ENUMERATED -1, extra leading ff
5:hex:"0A02ffff":char*:"-1":int:0
ENUMERATED -0x7f
5:hex:"0A0181":char*:"-7f":int:0
ENUMERATED -0x80
5:hex:"0A0180":char*:"-80":int:0
ENUMERATED -0x81
5:hex:"0A02ff7f":char*:"-81":int:0
ENUMERATED -0xff
5:hex:"0A02ff01":char*:"-ff":int:0
ENUMERATED -0x100
5:hex:"0A02ff00":char*:"-100":int:0
ENUMERATED -0x7fffffff
5:hex:"0A0480000001":char*:"-7fffffff":int:0
ENUMERATED -0x80000000
5:hex:"0A0480000000":char*:"-80000000":int:0
ENUMERATED -0x80000001
5:hex:"0A05ff7fffffff":char*:"-80000001":int:0
ENUMERATED -0xffffffff
5:hex:"0A05ff00000001":char*:"-ffffffff":int:0
ENUMERATED -0x100000000
5:hex:"0A05ff00000000":char*:"-100000000":int:0
BIT STRING: empty
7:hex:"0300":int:0:int:0:exp:0:exp:5
BIT STRING: octets=0, unused_bits=0
7:hex:"030100":int:0:int:0:int:0:int:0
BIT STRING: octets=0, unused_bits=7
7:hex:"030107":int:0:int:7:int:0:exp:5
BIT STRING: octets=0, unused_bits=8
7:hex:"030108":int:0:int:0:exp:2:exp:5
BIT STRING: octets=1, unused_bits=0
7:hex:"03020041":int:1:int:0:int:0:int:0
BIT STRING: octets=1, unused_bits=7
7:hex:"03020741":int:1:int:7:int:0:exp:5
BIT STRING: octets=1, unused_bits=8
7:hex:"03020841":int:1:int:8:exp:2:exp:5
BIT STRING: octets=2, unused_bits=0
7:hex:"0303004142":int:2:int:0:int:0:int:0
BIT STRING: octets=2, unused_bits=7
7:hex:"0303074142":int:2:int:7:int:0:exp:5
BIT STRING: octets=2, unused_bits=8
7:hex:"0303084142":int:2:int:8:exp:2:exp:5
BIT STRING with trailing garbage, unused_bits=0
7:hex:"030200417e":int:1:int:0:exp:3:int:0
BIT STRING with trailing garbage, unused_bits=7
7:hex:"030207417e":int:1:int:7:exp:3:exp:5
BIT STRING with trailing garbage, unused_bits=8
7:hex:"030208417e":int:1:int:8:exp:2:exp:5
Not BIT STRING
7:hex:"04020100":int:0:int:0:exp:4:exp:4
SEQUENCE OF 0 OCTET STRING
8:hex:"3000":int:0x04:char*:"":int:0
SEQUENCE OF 0 OCTET STRING plus trailing garbage
8:hex:"30007e":int:0x04:char*:"":exp:3
SEQUENCE of 1 OCTET STRING truncated after tag
8:hex:"300104":int:0x04:char*:"":exp:0
SEQUENCE of 1 OCTET STRING truncated in length #1
8:hex:"30020481":int:0x04:char*:"":exp:0
SEQUENCE of 1 OCTET STRING truncated in length #2
8:hex:"3003048201":int:0x04:char*:"":exp:0
SEQUENCE of 1 OCTET STRING truncated in content #1
8:hex:"30020401":int:0x04:char*:"":exp:0
SEQUENCE of 1 OCTET STRING truncated in content #2
8:hex:"3003040241":int:0x04:char*:"":exp:0
SEQUENCE of 1 OCTET STRING truncated in content #3
8:hex:"300404034142":int:0x04:char*:"":exp:0
SEQUENCE of 1 OCTET STRING (0)
8:hex:"30020400":int:0x04:char*:"4,0":int:0
SEQUENCE of 1 OCTET STRING (1)
8:hex:"3003040141":int:0x04:char*:"4,1":int:0
SEQUENCE of 1 OCTET STRING (126)
8:hex:"308180047e414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141":int:0x04:char*:"5,126":int:0
SEQUENCE of 2 OCTET STRINGs, second truncated after tag
8:hex:"30050402414104":int:0x04:char*:"":exp:0
SEQUENCE of 2 OCTET STRINGs, second truncated in length #1
8:hex:"3006040241410481":int:0x04:char*:"":exp:0
SEQUENCE of 2 OCTET STRINGs, second truncated in length #2
8:hex:"300704024141048201":int:0x04:char*:"":exp:0
SEQUENCE of 2 OCTET STRINGs, second truncated in content #1
8:hex:"3006040241410401":int:0x04:char*:"":exp:0
SEQUENCE of 2 OCTET STRINGs, second truncated in content #2
8:hex:"300704024141040241":int:0x04:char*:"":exp:0
SEQUENCE of 2 OCTET STRINGs, second truncated in content #3
8:hex:"30080402414104034142":int:0x04:char*:"":exp:0
SEQUENCE of 2 OCTET STRINGs (2, 0)
8:hex:"3006040241410400":int:0x04:char*:"4,2,8,0":int:0
SEQUENCE of 2 OCTET STRINGs (2, 1)
8:hex:"300704024141040142":int:0x04:char*:"4,2,8,1":int:0
SEQUENCE of 2 OCTET STRINGs (0, 2)
8:hex:"3006040004024141":int:0x04:char*:"4,0,6,2":int:0
SEQUENCE of 2 OCTET STRINGs (1, 2)
8:hex:"300704014104024242":int:0x04:char*:"4,1,7,2":int:0
Not a SEQUENCE (not CONSTRUCTED)
8:hex:"1000":int:0x04:char*:"":exp:4
Not a SEQUENCE (not SEQUENCE)
8:hex:"3100":int:0x04:char*:"":exp:4
Traverse empty SEQUENCE
9:hex:"3000":int:0:int:0:int:0:int:0:char*:"":int:0
Traverse empty SEQUENCE plus trailing garbage
9:hex:"30007e":int:0:int:0:int:0:int:0:char*:"":exp:3
Traverse SEQUENCE of INTEGER: 1 INTEGER
9:hex:"30050203123456":int:0xff:int:0x02:int:0:int:0:char*:"4,0x02,3":int:0
Traverse SEQUENCE of INTEGER: 2 INTEGERs
9:hex:"30080203123456020178":int:0xff:int:0x02:int:0:int:0:char*:"4,0x02,3,9,0x02,1":int:0
Traverse SEQUENCE of INTEGER: INTEGER, NULL
9:hex:"300702031234560500":int:0xff:int:0x02:int:0:int:0:char*:"4,0x02,3":exp:4
Traverse SEQUENCE of INTEGER: NULL, INTEGER
9:hex:"300705000203123456":int:0xff:int:0x02:int:0:int:0:char*:"":exp:4
Traverse SEQUENCE of ANY: NULL, INTEGER
9:hex:"300705000203123456":int:0:int:0:int:0:int:0:char*:"4,0x05,0,6,0x02,3":int:0
Traverse SEQUENCE of ANY, skip non-INTEGER: INTEGER, NULL
9:hex:"300702031234560500":int:0:int:0:int:0xff:int:0x02:char*:"4,0x02,3":int:0
Traverse SEQUENCE of ANY, skip non-INTEGER: NULL, INTEGER
9:hex:"300705000203123456":int:0:int:0:int:0xff:int:0x02:char*:"6,0x02,3":int:0
Traverse SEQUENCE of INTEGER, skip everything
9:hex:"30080203123456020178":int:0xff:int:0x02:int:0:int:1:char*:"":int:0
Traverse SEQUENCE of {NULL, OCTET STRING}, skip NULL: OS, NULL
9:hex:"300704031234560500":int:0xfe:int:0x04:int:0xff:int:0x04:char*:"4,0x04,3":int:0
Traverse SEQUENCE of {NULL, OCTET STRING}, skip NULL: NULL, OS
9:hex:"300705000403123456":int:0xfe:int:0x04:int:0xff:int:0x04:char*:"6,0x04,3":int:0
Traverse SEQUENCE of {NULL, OCTET STRING}, skip everything
9:hex:"300705000403123456":int:0xfe:int:0x04:int:0:int:1:char*:"":int:0
Traverse SEQUENCE of INTEGER, stop at 0: NULL
9:hex:"30020500":int:0xff:int:0x02:int:0:int:0:char*:"":exp:4
Traverse SEQUENCE of INTEGER, stop at 0: INTEGER
9:hex:"30050203123456":int:0xff:int:0x02:int:0:int:0:char*:"":exp:6
Traverse SEQUENCE of INTEGER, stop at 0: INTEGER, NULL
9:hex:"300702031234560500":int:0xff:int:0x02:int:0:int:0:char*:"":exp:6
Traverse SEQUENCE of INTEGER, stop at 1: INTEGER, NULL
9:hex:"300702031234560500":int:0xff:int:0x02:int:0:int:0:char*:"4,0x02,3":exp:4
Traverse SEQUENCE of INTEGER, stop at 1: INTEGER, INTEGER
9:hex:"30080203123456020178":int:0xff:int:0x02:int:0:int:0:char*:"4,0x02,3":exp:6
AlgorithmIdentifier, no params
10:hex:"300506034f4944":int:4:int:3:int:0:int:0:int:0:int:7:int:0
AlgorithmIdentifier, no params, trailing garbage
10:hex:"300506034f49447e":int:4:int:3:int:0:int:0:int:0:int:7:int:0
AlgorithmIdentifier, null params
10:hex:"300706034f49440500":int:4:int:3:int:0x05:int:9:int:0:int:9:int:0
AlgorithmIdentifier, null params, trailing garbage
10:hex:"300706034f494405007e":int:4:int:3:int:0x05:int:9:int:0:int:9:int:0
AlgorithmIdentifier, OCTET STRING params
10:hex:"300c06034f494404056162636465":int:4:int:3:int:0x04:int:9:int:5:int:14:int:0
AlgorithmIdentifier, truncated before OID
10:hex:"3000":int:4:int:3:int:0:int:0:int:0:int:2:exp:0
AlgorithmIdentifier, truncated in OID after tag
10:hex:"300106":int:0:int:0:int:0:int:0:int:0:int:3:exp:0
AlgorithmIdentifier, truncated in OID after length
10:hex:"30020603":int:4:int:3:int:0:int:0:int:0:int:4:exp:0
AlgorithmIdentifier, truncated inside OID content
10:hex:"300406034f49":int:4:int:3:int:0:int:0:int:0:int:6:exp:0
AlgorithmIdentifier, truncated in params after tag
10:hex:"300606034f494404":int:4:int:3:int:0x04:int:0:int:0:int:8:exp:0
AlgorithmIdentifier, truncated in params after length
10:hex:"300706034f49440405":int:4:int:3:int:0x04:int:9:int:0:int:9:exp:0
AlgorithmIdentifier, truncated inside params content
10:hex:"300806034f4944040561":int:4:int:3:int:0x04:int:9:int:5:int:10:exp:0
Not an AlgorithmIdentifier (not a SEQUENCE)
10:hex:"310506034f4944":int:0:int:0:int:0:int:0:int:0:int:0:exp:4
Not an AlgorithmIdentifier (empty SEQUENCE)
10:hex:"3000":int:0:int:0:int:0:int:0:int:0:int:0:exp:0
Not an AlgorithmIdentifier (not an OID)
10:hex:"3006050006034f4944":int:0:int:0:int:0:int:0:int:0:int:0:exp:4
Not an AlgorithmIdentifier (too many elements)
10:hex:"300f06034f494406034f494406034f4944":int:0:int:0:int:0:int:0:int:0:int:0:exp:3
Find named data: not found
11:hex:"414141":hex:"424242":hex:"434343":hex:"444444":hex:"7f7f7f":int:0:int:4
Find named data: empty haystack
11:hex:"414141":hex:"424242":hex:"434343":hex:"444444":hex:"7f7f7f":int:4:int:4
Find named data: first
11:hex:"414141":hex:"424242":hex:"434343":hex:"444444":hex:"414141":int:0:int:0
Find named data: last
11:hex:"414141":hex:"424242":hex:"434343":hex:"444444":hex:"444444":int:0:int:3
Find named data: skip suffix
11:hex:"41414141":hex:"414141":hex:"434343":hex:"444444":hex:"414141":int:0:int:1
Find named data: skip prefix
11:hex:"4141":hex:"414141":hex:"434343":hex:"444444":hex:"414141":int:0:int:1
Find named data: first match
11:hex:"414141":hex:"414141":hex:"434343":hex:"444444":hex:"414141":int:0:int:0
Free named data: null pointer
12
Free named data: all null
13:int:0:int:0:int:0
Free named data: with oid
13:int:1:int:0:int:0
Free named data: with val
13:int:0:int:1:int:0
Free named data: with next
13:int:0:int:0:int:1
Free named data list (empty)
14:int:0
Free named data list (1)
14:int:1
Free named data list (2)
14:int:2
| 18,192 | 634 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_pkcs1_v21.c | /* clang-format off */
/*
* Copyright The Mbed TLS Contributors
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "third_party/mbedtls/test/test.inc"
/*
* *** THIS FILE WAS MACHINE GENERATED ***
*
* This file has been machine generated using the script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* Test file : ./test_suite_pkcs1_v21.c
*
* The following files were used to create this file.
*
* Main code file : suites/main_test.function
* Platform code file : suites/host_test.function
* Helper file : suites/helpers.function
* Test suite file : suites/test_suite_pkcs1_v21.function
* Test suite data : suites/test_suite_pkcs1_v21.data
*
*/
#define TEST_SUITE_ACTIVE
#if defined(MBEDTLS_PKCS1_V21)
#if defined(MBEDTLS_RSA_C)
#if defined(MBEDTLS_SHA1_C)
#include "third_party/mbedtls/rsa.h"
#include "third_party/mbedtls/md.h"
void test_pkcs1_rsaes_oaep_encrypt( int mod, int radix_N, char * input_N,
int radix_E, char * input_E, int hash,
data_t * message_str, data_t * rnd_buf,
data_t * result_str, int result )
{
unsigned char output[256];
mbedtls_rsa_context ctx;
mbedtls_test_rnd_buf_info info;
mbedtls_mpi N, E;
info.buf = rnd_buf->x;
info.length = rnd_buf->len;
mbedtls_mpi_init( &N ); mbedtls_mpi_init( &E );
mbedtls_rsa_init( &ctx, MBEDTLS_RSA_PKCS_V21, hash );
memset( output, 0x00, sizeof( output ) );
TEST_ASSERT( mbedtls_mpi_read_string( &N, radix_N, input_N ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &E, radix_E, input_E ) == 0 );
TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, NULL, NULL, NULL, &E ) == 0 );
TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( ( mod + 7 ) / 8 ) );
TEST_ASSERT( mbedtls_rsa_check_pubkey( &ctx ) == 0 );
if( message_str->len == 0 )
message_str->x = NULL;
TEST_ASSERT( mbedtls_rsa_pkcs1_encrypt( &ctx,
&mbedtls_test_rnd_buffer_rand,
&info, MBEDTLS_RSA_PUBLIC,
message_str->len, message_str->x,
output ) == result );
if( result == 0 )
{
TEST_ASSERT( mbedtls_test_hexcmp( output, result_str->x,
ctx.len, result_str->len ) == 0 );
}
exit:
mbedtls_mpi_free( &N ); mbedtls_mpi_free( &E );
mbedtls_rsa_free( &ctx );
}
void test_pkcs1_rsaes_oaep_encrypt_wrapper( void ** params )
{
data_t data6 = {(uint8_t *) params[6], *( (uint32_t *) params[7] )};
data_t data8 = {(uint8_t *) params[8], *( (uint32_t *) params[9] )};
data_t data10 = {(uint8_t *) params[10], *( (uint32_t *) params[11] )};
test_pkcs1_rsaes_oaep_encrypt( *( (int *) params[0] ), *( (int *) params[1] ), (char *) params[2], *( (int *) params[3] ), (char *) params[4], *( (int *) params[5] ), &data6, &data8, &data10, *( (int *) params[12] ) );
}
void test_pkcs1_rsaes_oaep_decrypt( int mod, int radix_P, char * input_P,
int radix_Q, char * input_Q, int radix_N,
char * input_N, int radix_E, char * input_E,
int hash, data_t * result_str,
char * seed, data_t * message_str,
int result )
{
unsigned char output[64];
mbedtls_rsa_context ctx;
size_t output_len;
mbedtls_test_rnd_pseudo_info rnd_info;
mbedtls_mpi N, P, Q, E;
((void) seed);
mbedtls_mpi_init( &N ); mbedtls_mpi_init( &P );
mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &E );
mbedtls_rsa_init( &ctx, MBEDTLS_RSA_PKCS_V21, hash );
memset( output, 0x00, sizeof( output ) );
memset( &rnd_info, 0, sizeof( mbedtls_test_rnd_pseudo_info ) );
TEST_ASSERT( mbedtls_mpi_read_string( &P, radix_P, input_P ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &Q, radix_Q, input_Q ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &N, radix_N, input_N ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &E, radix_E, input_E ) == 0 );
TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, &P, &Q, NULL, &E ) == 0 );
TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( ( mod + 7 ) / 8 ) );
TEST_ASSERT( mbedtls_rsa_complete( &ctx ) == 0 );
TEST_ASSERT( mbedtls_rsa_check_privkey( &ctx ) == 0 );
if( result_str->len == 0 )
{
TEST_ASSERT( mbedtls_rsa_pkcs1_decrypt( &ctx,
&mbedtls_test_rnd_pseudo_rand,
&rnd_info,
MBEDTLS_RSA_PRIVATE,
&output_len, message_str->x,
NULL, 0 ) == result );
}
else
{
TEST_ASSERT( mbedtls_rsa_pkcs1_decrypt( &ctx,
&mbedtls_test_rnd_pseudo_rand,
&rnd_info,
MBEDTLS_RSA_PRIVATE,
&output_len, message_str->x,
output,
sizeof( output ) ) == result );
if( result == 0 )
{
TEST_ASSERT( mbedtls_test_hexcmp( output, result_str->x,
output_len,
result_str->len ) == 0 );
}
}
exit:
mbedtls_mpi_free( &N ); mbedtls_mpi_free( &P );
mbedtls_mpi_free( &Q ); mbedtls_mpi_free( &E );
mbedtls_rsa_free( &ctx );
}
void test_pkcs1_rsaes_oaep_decrypt_wrapper( void ** params )
{
data_t data10 = {(uint8_t *) params[10], *( (uint32_t *) params[11] )};
data_t data13 = {(uint8_t *) params[13], *( (uint32_t *) params[14] )};
test_pkcs1_rsaes_oaep_decrypt( *( (int *) params[0] ), *( (int *) params[1] ), (char *) params[2], *( (int *) params[3] ), (char *) params[4], *( (int *) params[5] ), (char *) params[6], *( (int *) params[7] ), (char *) params[8], *( (int *) params[9] ), &data10, (char *) params[12], &data13, *( (int *) params[15] ) );
}
void test_pkcs1_rsassa_pss_sign( int mod, int radix_P, char * input_P, int radix_Q,
char * input_Q, int radix_N, char * input_N,
int radix_E, char * input_E, int digest, int hash,
data_t * message_str, data_t * rnd_buf,
data_t * result_str, int result )
{
unsigned char hash_result[MBEDTLS_MD_MAX_SIZE];
unsigned char output[256];
mbedtls_rsa_context ctx;
mbedtls_test_rnd_buf_info info;
mbedtls_mpi N, P, Q, E;
info.buf = rnd_buf->x;
info.length = rnd_buf->len;
mbedtls_mpi_init( &N ); mbedtls_mpi_init( &P );
mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &E );
mbedtls_rsa_init( &ctx, MBEDTLS_RSA_PKCS_V21, hash );
memset( hash_result, 0x00, sizeof( hash_result ) );
memset( output, 0x00, sizeof( output ) );
TEST_ASSERT( mbedtls_mpi_read_string( &P, radix_P, input_P ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &Q, radix_Q, input_Q ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &N, radix_N, input_N ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &E, radix_E, input_E ) == 0 );
TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, &P, &Q, NULL, &E ) == 0 );
TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( ( mod + 7 ) / 8 ) );
TEST_ASSERT( mbedtls_rsa_complete( &ctx ) == 0 );
TEST_ASSERT( mbedtls_rsa_check_privkey( &ctx ) == 0 );
if( mbedtls_md_info_from_type( digest ) != NULL )
TEST_ASSERT( mbedtls_md( mbedtls_md_info_from_type( digest ), message_str->x, message_str->len, hash_result ) == 0 );
TEST_ASSERT( mbedtls_rsa_pkcs1_sign( &ctx, &mbedtls_test_rnd_buffer_rand,
&info, MBEDTLS_RSA_PRIVATE, digest, 0,
hash_result, output ) == result );
if( result == 0 )
{
TEST_ASSERT( mbedtls_test_hexcmp( output, result_str->x,
ctx.len, result_str->len ) == 0 );
}
exit:
mbedtls_mpi_free( &N ); mbedtls_mpi_free( &P );
mbedtls_mpi_free( &Q ); mbedtls_mpi_free( &E );
mbedtls_rsa_free( &ctx );
}
void test_pkcs1_rsassa_pss_sign_wrapper( void ** params )
{
data_t data11 = {(uint8_t *) params[11], *( (uint32_t *) params[12] )};
data_t data13 = {(uint8_t *) params[13], *( (uint32_t *) params[14] )};
data_t data15 = {(uint8_t *) params[15], *( (uint32_t *) params[16] )};
test_pkcs1_rsassa_pss_sign( *( (int *) params[0] ), *( (int *) params[1] ), (char *) params[2], *( (int *) params[3] ), (char *) params[4], *( (int *) params[5] ), (char *) params[6], *( (int *) params[7] ), (char *) params[8], *( (int *) params[9] ), *( (int *) params[10] ), &data11, &data13, &data15, *( (int *) params[17] ) );
}
void test_pkcs1_rsassa_pss_verify( int mod, int radix_N, char * input_N,
int radix_E, char * input_E, int digest,
int hash, data_t * message_str, char * salt,
data_t * result_str, int result )
{
unsigned char hash_result[MBEDTLS_MD_MAX_SIZE];
mbedtls_rsa_context ctx;
mbedtls_mpi N, E;
((void) salt);
mbedtls_mpi_init( &N ); mbedtls_mpi_init( &E );
mbedtls_rsa_init( &ctx, MBEDTLS_RSA_PKCS_V21, hash );
memset( hash_result, 0x00, sizeof( hash_result ) );
TEST_ASSERT( mbedtls_mpi_read_string( &N, radix_N, input_N ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &E, radix_E, input_E ) == 0 );
TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, NULL, NULL, NULL, &E ) == 0 );
TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( ( mod + 7 ) / 8 ) );
TEST_ASSERT( mbedtls_rsa_check_pubkey( &ctx ) == 0 );
if( mbedtls_md_info_from_type( digest ) != NULL )
TEST_ASSERT( mbedtls_md( mbedtls_md_info_from_type( digest ), message_str->x, message_str->len, hash_result ) == 0 );
TEST_ASSERT( mbedtls_rsa_pkcs1_verify( &ctx, NULL, NULL, MBEDTLS_RSA_PUBLIC, digest, 0, hash_result, result_str->x ) == result );
exit:
mbedtls_mpi_free( &N ); mbedtls_mpi_free( &E );
mbedtls_rsa_free( &ctx );
}
void test_pkcs1_rsassa_pss_verify_wrapper( void ** params )
{
data_t data7 = {(uint8_t *) params[7], *( (uint32_t *) params[8] )};
data_t data10 = {(uint8_t *) params[10], *( (uint32_t *) params[11] )};
test_pkcs1_rsassa_pss_verify( *( (int *) params[0] ), *( (int *) params[1] ), (char *) params[2], *( (int *) params[3] ), (char *) params[4], *( (int *) params[5] ), *( (int *) params[6] ), &data7, (char *) params[9], &data10, *( (int *) params[12] ) );
}
void test_pkcs1_rsassa_pss_verify_ext( int mod, int radix_N, char * input_N,
int radix_E, char * input_E,
int msg_digest_id, int ctx_hash,
int mgf_hash, int salt_len,
data_t * message_str,
data_t * result_str, int result_simple,
int result_full )
{
unsigned char hash_result[MBEDTLS_MD_MAX_SIZE];
mbedtls_rsa_context ctx;
size_t hash_len;
mbedtls_mpi N, E;
mbedtls_mpi_init( &N ); mbedtls_mpi_init( &E );
mbedtls_rsa_init( &ctx, MBEDTLS_RSA_PKCS_V21, ctx_hash );
memset( hash_result, 0x00, sizeof( hash_result ) );
TEST_ASSERT( mbedtls_mpi_read_string( &N, radix_N, input_N ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &E, radix_E, input_E ) == 0 );
TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, NULL, NULL, NULL, &E ) == 0 );
TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( ( mod + 7 ) / 8 ) );
TEST_ASSERT( mbedtls_rsa_check_pubkey( &ctx ) == 0 );
if( msg_digest_id != MBEDTLS_MD_NONE )
{
TEST_ASSERT( mbedtls_md( mbedtls_md_info_from_type( msg_digest_id ),
message_str->x, message_str->len, hash_result ) == 0 );
hash_len = 0;
}
else
{
memcpy( hash_result, message_str->x, message_str->len );
hash_len = message_str->len;
}
TEST_ASSERT( mbedtls_rsa_pkcs1_verify( &ctx, NULL, NULL, MBEDTLS_RSA_PUBLIC,
msg_digest_id, hash_len, hash_result,
result_str->x ) == result_simple );
TEST_ASSERT( mbedtls_rsa_rsassa_pss_verify_ext( &ctx, NULL, NULL, MBEDTLS_RSA_PUBLIC,
msg_digest_id, hash_len, hash_result,
mgf_hash, salt_len,
result_str->x ) == result_full );
exit:
mbedtls_mpi_free( &N ); mbedtls_mpi_free( &E );
mbedtls_rsa_free( &ctx );
}
void test_pkcs1_rsassa_pss_verify_ext_wrapper( void ** params )
{
data_t data9 = {(uint8_t *) params[9], *( (uint32_t *) params[10] )};
data_t data11 = {(uint8_t *) params[11], *( (uint32_t *) params[12] )};
test_pkcs1_rsassa_pss_verify_ext( *( (int *) params[0] ), *( (int *) params[1] ), (char *) params[2], *( (int *) params[3] ), (char *) params[4], *( (int *) params[5] ), *( (int *) params[6] ), *( (int *) params[7] ), *( (int *) params[8] ), &data9, &data11, *( (int *) params[13] ), *( (int *) params[14] ) );
}
#endif /* MBEDTLS_SHA1_C */
#endif /* MBEDTLS_RSA_C */
#endif /* MBEDTLS_PKCS1_V21 */
/*----------------------------------------------------------------------------*/
/* Test dispatch code */
/**
* \brief Evaluates an expression/macro into its literal integer value.
* For optimizing space for embedded targets each expression/macro
* is identified by a unique identifier instead of string literals.
* Identifiers and evaluation code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param exp_id Expression identifier.
* \param out_value Pointer to int to hold the integer.
*
* \return 0 if exp_id is found. 1 otherwise.
*/
int get_expression( int32_t exp_id, int32_t * out_value )
{
int ret = KEY_VALUE_MAPPING_FOUND;
(void) exp_id;
(void) out_value;
switch( exp_id )
{
#if defined(MBEDTLS_PKCS1_V21) && defined(MBEDTLS_RSA_C) && defined(MBEDTLS_SHA1_C)
case 0:
{
*out_value = MBEDTLS_MD_SHA1;
}
break;
case 1:
{
*out_value = MBEDTLS_ERR_RSA_BAD_INPUT_DATA;
}
break;
case 2:
{
*out_value = MBEDTLS_MD_SHA512;
}
break;
case 3:
{
*out_value = MBEDTLS_MD_NONE;
}
break;
case 4:
{
*out_value = MBEDTLS_MD_SHA256;
}
break;
case 5:
{
*out_value = MBEDTLS_ERR_RSA_INVALID_PADDING;
}
break;
case 6:
{
*out_value = MBEDTLS_ERR_RSA_VERIFY_FAILED;
}
break;
case 7:
{
*out_value = MBEDTLS_RSA_SALT_LEN_ANY;
}
break;
#endif
default:
{
ret = KEY_VALUE_MAPPING_NOT_FOUND;
}
break;
}
return( ret );
}
/**
* \brief Checks if the dependency i.e. the compile flag is set.
* For optimizing space for embedded targets each dependency
* is identified by a unique identifier instead of string literals.
* Identifiers and check code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param dep_id Dependency identifier.
*
* \return DEPENDENCY_SUPPORTED if set else DEPENDENCY_NOT_SUPPORTED
*/
int dep_check( int dep_id )
{
int ret = DEPENDENCY_NOT_SUPPORTED;
(void) dep_id;
switch( dep_id )
{
#if defined(MBEDTLS_PKCS1_V21) && defined(MBEDTLS_RSA_C) && defined(MBEDTLS_SHA1_C)
case 0:
{
#if defined(MBEDTLS_SHA1_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 1:
{
#if defined(MBEDTLS_SHA512_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 2:
{
#if defined(MBEDTLS_SHA256_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
#endif
default:
break;
}
return( ret );
}
/**
* \brief Function pointer type for test function wrappers.
*
* A test function wrapper decodes the parameters and passes them to the
* underlying test function. Both the wrapper and the underlying function
* return void. Test wrappers assume that they are passed a suitable
* parameter array and do not perform any error detection.
*
* \param param_array The array of parameters. Each element is a `void *`
* which the wrapper casts to the correct type and
* dereferences. Each wrapper function hard-codes the
* number and types of the parameters.
*/
typedef void (*TestWrapper_t)( void **param_array );
/**
* \brief Table of test function wrappers. Used by dispatch_test().
* This table is populated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
*/
TestWrapper_t test_funcs[] =
{
/* Function Id: 0 */
#if defined(MBEDTLS_PKCS1_V21) && defined(MBEDTLS_RSA_C) && defined(MBEDTLS_SHA1_C)
test_pkcs1_rsaes_oaep_encrypt_wrapper,
#else
NULL,
#endif
/* Function Id: 1 */
#if defined(MBEDTLS_PKCS1_V21) && defined(MBEDTLS_RSA_C) && defined(MBEDTLS_SHA1_C)
test_pkcs1_rsaes_oaep_decrypt_wrapper,
#else
NULL,
#endif
/* Function Id: 2 */
#if defined(MBEDTLS_PKCS1_V21) && defined(MBEDTLS_RSA_C) && defined(MBEDTLS_SHA1_C)
test_pkcs1_rsassa_pss_sign_wrapper,
#else
NULL,
#endif
/* Function Id: 3 */
#if defined(MBEDTLS_PKCS1_V21) && defined(MBEDTLS_RSA_C) && defined(MBEDTLS_SHA1_C)
test_pkcs1_rsassa_pss_verify_wrapper,
#else
NULL,
#endif
/* Function Id: 4 */
#if defined(MBEDTLS_PKCS1_V21) && defined(MBEDTLS_RSA_C) && defined(MBEDTLS_SHA1_C)
test_pkcs1_rsassa_pss_verify_ext_wrapper,
#else
NULL,
#endif
};
/**
* \brief Execute the test function.
*
* This is a wrapper function around the test function execution
* to allow the setjmp() call used to catch any calls to the
* parameter failure callback, to be used. Calls to setjmp()
* can invalidate the state of any local auto variables.
*
* \param fp Function pointer to the test function.
* \param params Parameters to pass to the #TestWrapper_t wrapper function.
*
*/
void execute_function_ptr(TestWrapper_t fp, void **params)
{
#if defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG)
mbedtls_test_enable_insecure_external_rng( );
#endif
#if defined(MBEDTLS_CHECK_PARAMS)
mbedtls_test_param_failed_location_record_t location_record;
if ( setjmp( mbedtls_test_param_failed_get_state_buf( ) ) == 0 )
{
fp( params );
}
else
{
/* Unexpected parameter validation error */
mbedtls_test_param_failed_get_location_record( &location_record );
mbedtls_test_fail( location_record.failure_condition,
location_record.line,
location_record.file );
}
mbedtls_test_param_failed_reset_state( );
#else
fp( params );
#endif
#if defined(MBEDTLS_TEST_MUTEX_USAGE)
mbedtls_test_mutex_usage_check( );
#endif /* MBEDTLS_TEST_MUTEX_USAGE */
}
/**
* \brief Dispatches test functions based on function index.
*
* \param func_idx Test function index.
* \param params The array of parameters to pass to the test function.
* It will be decoded by the #TestWrapper_t wrapper function.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int dispatch_test( size_t func_idx, void ** params )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof( test_funcs ) / sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp )
execute_function_ptr(fp, params);
else
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
/**
* \brief Checks if test function is supported in this build-time
* configuration.
*
* \param func_idx Test function index.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int check_test( size_t func_idx )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof(test_funcs)/sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp == NULL )
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
int main( int argc, const char *argv[] )
{
int ret;
mbedtls_test_platform_setup();
ret = execute_tests( argc, argv, "/zip/third_party/mbedtls/test/test_suite_pkcs1_v21.datax" );
mbedtls_test_platform_teardown();
return( ret );
}
| 22,776 | 640 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_x509write.c | /* clang-format off */
/*
* Copyright The Mbed TLS Contributors
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "third_party/mbedtls/test/test.inc"
/*
* *** THIS FILE WAS MACHINE GENERATED ***
*
* This file has been machine generated using the script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* Test file : ./test_suite_x509write.c
*
* The following files were used to create this file.
*
* Main code file : suites/main_test.function
* Platform code file : suites/host_test.function
* Helper file : suites/helpers.function
* Test suite file : suites/test_suite_x509write.function
* Test suite data : suites/test_suite_x509write.data
*
*/
#define TEST_SUITE_ACTIVE
#if defined(MBEDTLS_BIGNUM_C)
#if defined(MBEDTLS_FS_IO)
#if defined(MBEDTLS_PK_PARSE_C)
#include "third_party/mbedtls/bignum.h"
#include "third_party/mbedtls/x509_crt.h"
#include "third_party/mbedtls/x509_csr.h"
#include "third_party/mbedtls/pem.h"
#include "third_party/mbedtls/oid.h"
#include "third_party/mbedtls/rsa.h"
#if defined(MBEDTLS_RSA_C)
int mbedtls_rsa_decrypt_func( void *ctx, int mode, size_t *olen,
const unsigned char *input, unsigned char *output,
size_t output_max_len )
{
return( mbedtls_rsa_pkcs1_decrypt( (mbedtls_rsa_context *) ctx, NULL, NULL, mode, olen,
input, output, output_max_len ) );
}
int mbedtls_rsa_sign_func( void *ctx,
int (*f_rng)(void *, unsigned char *, size_t), void *p_rng,
int mode, mbedtls_md_type_t md_alg, unsigned int hashlen,
const unsigned char *hash, unsigned char *sig )
{
return( mbedtls_rsa_pkcs1_sign( (mbedtls_rsa_context *) ctx, f_rng, p_rng, mode,
md_alg, hashlen, hash, sig ) );
}
size_t mbedtls_rsa_key_len_func( void *ctx )
{
return( ((const mbedtls_rsa_context *) ctx)->len );
}
#endif /* MBEDTLS_RSA_C */
#if defined(MBEDTLS_USE_PSA_CRYPTO) && \
defined(MBEDTLS_PEM_WRITE_C) && defined(MBEDTLS_X509_CSR_WRITE_C)
static int x509_crt_verifycsr( const unsigned char *buf, size_t buflen )
{
unsigned char hash[MBEDTLS_MD_MAX_SIZE];
const mbedtls_md_info_t *md_info;
mbedtls_x509_csr csr;
int ret = 0;
mbedtls_x509_csr_init( &csr );
if( mbedtls_x509_csr_parse( &csr, buf, buflen ) != 0 )
{
ret = MBEDTLS_ERR_X509_BAD_INPUT_DATA;
goto cleanup;
}
md_info = mbedtls_md_info_from_type( csr.sig_md );
if( mbedtls_md( md_info, csr.cri.p, csr.cri.len, hash ) != 0 )
{
/* Note: this can't happen except after an internal error */
ret = MBEDTLS_ERR_X509_BAD_INPUT_DATA;
goto cleanup;
}
if( mbedtls_pk_verify_ext( csr.sig_pk, csr.sig_opts, &csr.pk,
csr.sig_md, hash, mbedtls_md_get_size( md_info ),
csr.sig.p, csr.sig.len ) != 0 )
{
ret = MBEDTLS_ERR_X509_CERT_VERIFY_FAILED;
goto cleanup;
}
cleanup:
mbedtls_x509_csr_free( &csr );
return( ret );
}
#endif /* MBEDTLS_USE_PSA_CRYPTO && MBEDTLS_PEM_WRITE_C && MBEDTLS_X509_CSR_WRITE_C */
#if defined(MBEDTLS_PEM_WRITE_C)
#if defined(MBEDTLS_X509_CSR_WRITE_C)
void test_x509_csr_check( char * key_file, char * cert_req_check_file, int md_type,
int key_usage, int set_key_usage, int cert_type,
int set_cert_type )
{
mbedtls_pk_context key;
mbedtls_x509write_csr req;
unsigned char buf[4096];
unsigned char check_buf[4000];
int ret;
size_t olen = 0, pem_len = 0, buf_index;
int der_len = -1;
FILE *f;
const char *subject_name = "C=NL,O=PolarSSL,CN=PolarSSL Server 1";
mbedtls_test_rnd_pseudo_info rnd_info;
memset( &rnd_info, 0x2a, sizeof( mbedtls_test_rnd_pseudo_info ) );
mbedtls_pk_init( &key );
TEST_ASSERT( mbedtls_pk_parse_keyfile( &key, key_file, NULL ) == 0 );
mbedtls_x509write_csr_init( &req );
mbedtls_x509write_csr_set_md_alg( &req, md_type );
mbedtls_x509write_csr_set_key( &req, &key );
TEST_ASSERT( mbedtls_x509write_csr_set_subject_name( &req, subject_name ) == 0 );
if( set_key_usage != 0 )
TEST_ASSERT( mbedtls_x509write_csr_set_key_usage( &req, key_usage ) == 0 );
if( set_cert_type != 0 )
TEST_ASSERT( mbedtls_x509write_csr_set_ns_cert_type( &req, cert_type ) == 0 );
ret = mbedtls_x509write_csr_pem( &req, buf, sizeof( buf ),
mbedtls_test_rnd_pseudo_rand, &rnd_info );
TEST_ASSERT( ret == 0 );
pem_len = strlen( (char *) buf );
for( buf_index = pem_len; buf_index < sizeof( buf ); ++buf_index )
{
TEST_ASSERT( buf[buf_index] == 0 );
}
f = fopen( cert_req_check_file, "r" );
TEST_ASSERT( f != NULL );
olen = fread( check_buf, 1, sizeof( check_buf ), f );
fclose( f );
TEST_ASSERT( olen >= pem_len - 1 );
TEST_ASSERT( memcmp( buf, check_buf, pem_len - 1 ) == 0 );
der_len = mbedtls_x509write_csr_der( &req, buf, sizeof( buf ),
mbedtls_test_rnd_pseudo_rand,
&rnd_info );
TEST_ASSERT( der_len >= 0 );
if( der_len == 0 )
goto exit;
ret = mbedtls_x509write_csr_der( &req, buf, (size_t)( der_len - 1 ),
mbedtls_test_rnd_pseudo_rand, &rnd_info );
TEST_ASSERT( ret == MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
exit:
mbedtls_x509write_csr_free( &req );
mbedtls_pk_free( &key );
}
void test_x509_csr_check_wrapper( void ** params )
{
test_x509_csr_check( (char *) params[0], (char *) params[1], *( (int *) params[2] ), *( (int *) params[3] ), *( (int *) params[4] ), *( (int *) params[5] ), *( (int *) params[6] ) );
}
#endif /* MBEDTLS_X509_CSR_WRITE_C */
#endif /* MBEDTLS_PEM_WRITE_C */
#if defined(MBEDTLS_PEM_WRITE_C)
#if defined(MBEDTLS_X509_CSR_WRITE_C)
#if defined(MBEDTLS_USE_PSA_CRYPTO)
void test_x509_csr_check_opaque( char *key_file, int md_type, int key_usage,
int cert_type )
{
mbedtls_pk_context key;
mbedtls_svc_key_id_t key_id = MBEDTLS_SVC_KEY_ID_INIT;
psa_algorithm_t md_alg_psa;
mbedtls_x509write_csr req;
unsigned char buf[4096];
int ret;
size_t pem_len = 0;
const char *subject_name = "C=NL,O=PolarSSL,CN=PolarSSL Server 1";
mbedtls_test_rnd_pseudo_info rnd_info;
PSA_INIT( );
memset( &rnd_info, 0x2a, sizeof( mbedtls_test_rnd_pseudo_info ) );
md_alg_psa = mbedtls_psa_translate_md( (mbedtls_md_type_t) md_type );
TEST_ASSERT( md_alg_psa != MBEDTLS_MD_NONE );
mbedtls_pk_init( &key );
TEST_ASSERT( mbedtls_pk_parse_keyfile( &key, key_file, NULL ) == 0 );
TEST_ASSERT( mbedtls_pk_wrap_as_opaque( &key, &key_id, md_alg_psa ) == 0 );
mbedtls_x509write_csr_init( &req );
mbedtls_x509write_csr_set_md_alg( &req, md_type );
mbedtls_x509write_csr_set_key( &req, &key );
TEST_ASSERT( mbedtls_x509write_csr_set_subject_name( &req, subject_name ) == 0 );
if( key_usage != 0 )
TEST_ASSERT( mbedtls_x509write_csr_set_key_usage( &req, key_usage ) == 0 );
if( cert_type != 0 )
TEST_ASSERT( mbedtls_x509write_csr_set_ns_cert_type( &req, cert_type ) == 0 );
ret = mbedtls_x509write_csr_pem( &req, buf, sizeof( buf ) - 1,
mbedtls_test_rnd_pseudo_rand, &rnd_info );
TEST_ASSERT( ret == 0 );
pem_len = strlen( (char *) buf );
buf[pem_len] = '\0';
TEST_ASSERT( x509_crt_verifycsr( buf, pem_len + 1 ) == 0 );
exit:
mbedtls_x509write_csr_free( &req );
mbedtls_pk_free( &key );
psa_destroy_key( key_id );
PSA_DONE( );
}
void test_x509_csr_check_opaque_wrapper( void ** params )
{
test_x509_csr_check_opaque( (char *) params[0], *( (int *) params[1] ), *( (int *) params[2] ), *( (int *) params[3] ) );
}
#endif /* MBEDTLS_USE_PSA_CRYPTO */
#endif /* MBEDTLS_X509_CSR_WRITE_C */
#endif /* MBEDTLS_PEM_WRITE_C */
#if defined(MBEDTLS_PEM_WRITE_C)
#if defined(MBEDTLS_X509_CRT_WRITE_C)
#if defined(MBEDTLS_SHA1_C)
void test_x509_crt_check( char *subject_key_file, char *subject_pwd,
char *subject_name, char *issuer_key_file,
char *issuer_pwd, char *issuer_name,
char *serial_str, char *not_before, char *not_after,
int md_type, int key_usage, int set_key_usage,
int cert_type, int set_cert_type, int auth_ident,
int ver, char *cert_check_file, int rsa_alt, int is_ca )
{
mbedtls_pk_context subject_key, issuer_key, issuer_key_alt;
mbedtls_pk_context *key = &issuer_key;
mbedtls_x509write_cert crt;
unsigned char buf[4096];
unsigned char check_buf[5000];
mbedtls_mpi serial;
int ret;
size_t olen = 0, pem_len = 0, buf_index = 0;
int der_len = -1;
FILE *f;
mbedtls_test_rnd_pseudo_info rnd_info;
memset( &rnd_info, 0x2a, sizeof( mbedtls_test_rnd_pseudo_info ) );
mbedtls_mpi_init( &serial );
mbedtls_pk_init( &subject_key );
mbedtls_pk_init( &issuer_key );
mbedtls_pk_init( &issuer_key_alt );
mbedtls_x509write_crt_init( &crt );
TEST_ASSERT( mbedtls_pk_parse_keyfile( &subject_key, subject_key_file,
subject_pwd ) == 0 );
TEST_ASSERT( mbedtls_pk_parse_keyfile( &issuer_key, issuer_key_file,
issuer_pwd ) == 0 );
#if defined(MBEDTLS_RSA_C)
/* For RSA PK contexts, create a copy as an alternative RSA context. */
if( rsa_alt == 1 && mbedtls_pk_get_type( &issuer_key ) == MBEDTLS_PK_RSA )
{
TEST_ASSERT( mbedtls_pk_setup_rsa_alt( &issuer_key_alt,
mbedtls_pk_rsa( issuer_key ),
mbedtls_rsa_decrypt_func,
mbedtls_rsa_sign_func,
mbedtls_rsa_key_len_func ) == 0 );
key = &issuer_key_alt;
}
#else
(void) rsa_alt;
#endif
TEST_ASSERT( mbedtls_mpi_read_string( &serial, 10, serial_str ) == 0 );
if( ver != -1 )
mbedtls_x509write_crt_set_version( &crt, ver );
TEST_ASSERT( mbedtls_x509write_crt_set_serial( &crt, &serial ) == 0 );
TEST_ASSERT( mbedtls_x509write_crt_set_validity( &crt, not_before,
not_after ) == 0 );
mbedtls_x509write_crt_set_md_alg( &crt, md_type );
TEST_ASSERT( mbedtls_x509write_crt_set_issuer_name( &crt, issuer_name ) == 0 );
TEST_ASSERT( mbedtls_x509write_crt_set_subject_name( &crt, subject_name ) == 0 );
mbedtls_x509write_crt_set_subject_key( &crt, &subject_key );
mbedtls_x509write_crt_set_issuer_key( &crt, key );
if( crt.version >= MBEDTLS_X509_CRT_VERSION_3 )
{
/* For the CA case, a path length of -1 means unlimited. */
TEST_ASSERT( mbedtls_x509write_crt_set_basic_constraints( &crt, is_ca,
(is_ca ? -1 : 0) ) == 0 );
TEST_ASSERT( mbedtls_x509write_crt_set_subject_key_identifier( &crt ) == 0 );
if( auth_ident )
TEST_ASSERT( mbedtls_x509write_crt_set_authority_key_identifier( &crt ) == 0 );
if( set_key_usage != 0 )
TEST_ASSERT( mbedtls_x509write_crt_set_key_usage( &crt, key_usage ) == 0 );
if( set_cert_type != 0 )
TEST_ASSERT( mbedtls_x509write_crt_set_ns_cert_type( &crt, cert_type ) == 0 );
}
ret = mbedtls_x509write_crt_pem( &crt, buf, sizeof( buf ),
mbedtls_test_rnd_pseudo_rand, &rnd_info );
TEST_ASSERT( ret == 0 );
pem_len = strlen( (char *) buf );
// check that the rest of the buffer remains clear
for( buf_index = pem_len; buf_index < sizeof( buf ); ++buf_index )
{
TEST_ASSERT( buf[buf_index] == 0 );
}
f = fopen( cert_check_file, "r" );
TEST_ASSERT( f != NULL );
olen = fread( check_buf, 1, sizeof( check_buf ), f );
fclose( f );
TEST_ASSERT( olen < sizeof( check_buf ) );
TEST_ASSERT( olen >= pem_len - 1 );
TEST_ASSERT( memcmp( buf, check_buf, pem_len - 1 ) == 0 );
der_len = mbedtls_x509write_crt_der( &crt, buf, sizeof( buf ),
mbedtls_test_rnd_pseudo_rand,
&rnd_info );
TEST_ASSERT( der_len >= 0 );
if( der_len == 0 )
goto exit;
ret = mbedtls_x509write_crt_der( &crt, buf, (size_t)( der_len - 1 ),
mbedtls_test_rnd_pseudo_rand, &rnd_info );
TEST_ASSERT( ret == MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
exit:
mbedtls_x509write_crt_free( &crt );
mbedtls_pk_free( &issuer_key_alt );
mbedtls_pk_free( &subject_key );
mbedtls_pk_free( &issuer_key );
mbedtls_mpi_free( &serial );
}
void test_x509_crt_check_wrapper( void ** params )
{
test_x509_crt_check( (char *) params[0], (char *) params[1], (char *) params[2], (char *) params[3], (char *) params[4], (char *) params[5], (char *) params[6], (char *) params[7], (char *) params[8], *( (int *) params[9] ), *( (int *) params[10] ), *( (int *) params[11] ), *( (int *) params[12] ), *( (int *) params[13] ), *( (int *) params[14] ), *( (int *) params[15] ), (char *) params[16], *( (int *) params[17] ), *( (int *) params[18] ) );
}
#endif /* MBEDTLS_SHA1_C */
#endif /* MBEDTLS_X509_CRT_WRITE_C */
#endif /* MBEDTLS_PEM_WRITE_C */
#if defined(MBEDTLS_X509_CREATE_C)
#if defined(MBEDTLS_X509_USE_C)
void test_mbedtls_x509_string_to_names( char * name, char * parsed_name, int result
)
{
int ret;
size_t len = 0;
mbedtls_asn1_named_data *names = NULL;
mbedtls_x509_name parsed, *parsed_cur, *parsed_prv;
unsigned char buf[1024], out[1024], *c;
memset( &parsed, 0, sizeof( parsed ) );
memset( out, 0, sizeof( out ) );
memset( buf, 0, sizeof( buf ) );
c = buf + sizeof( buf );
ret = mbedtls_x509_string_to_names( &names, name );
TEST_ASSERT( ret == result );
if( ret != 0 )
goto exit;
ret = mbedtls_x509_write_names( &c, buf, names );
TEST_ASSERT( ret > 0 );
TEST_ASSERT( mbedtls_asn1_get_tag( &c, buf + sizeof( buf ), &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) == 0 );
TEST_ASSERT( mbedtls_x509_get_name( &c, buf + sizeof( buf ), &parsed ) == 0 );
ret = mbedtls_x509_dn_gets( (char *) out, sizeof( out ), &parsed );
TEST_ASSERT( ret > 0 );
TEST_ASSERT( strcmp( (char *) out, parsed_name ) == 0 );
exit:
mbedtls_asn1_free_named_data_list( &names );
parsed_cur = parsed.next;
while( parsed_cur != 0 )
{
parsed_prv = parsed_cur;
parsed_cur = parsed_cur->next;
mbedtls_free( parsed_prv );
}
}
void test_mbedtls_x509_string_to_names_wrapper( void ** params )
{
test_mbedtls_x509_string_to_names( (char *) params[0], (char *) params[1], *( (int *) params[2] ) );
}
#endif /* MBEDTLS_X509_USE_C */
#endif /* MBEDTLS_X509_CREATE_C */
#endif /* MBEDTLS_PK_PARSE_C */
#endif /* MBEDTLS_FS_IO */
#endif /* MBEDTLS_BIGNUM_C */
/*----------------------------------------------------------------------------*/
/* Test dispatch code */
/**
* \brief Evaluates an expression/macro into its literal integer value.
* For optimizing space for embedded targets each expression/macro
* is identified by a unique identifier instead of string literals.
* Identifiers and evaluation code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param exp_id Expression identifier.
* \param out_value Pointer to int to hold the integer.
*
* \return 0 if exp_id is found. 1 otherwise.
*/
int get_expression( int32_t exp_id, int32_t * out_value )
{
int ret = KEY_VALUE_MAPPING_FOUND;
(void) exp_id;
(void) out_value;
switch( exp_id )
{
#if defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_FS_IO) && defined(MBEDTLS_PK_PARSE_C)
case 0:
{
*out_value = MBEDTLS_MD_SHA1;
}
break;
case 1:
{
*out_value = MBEDTLS_MD_SHA224;
}
break;
case 2:
{
*out_value = MBEDTLS_MD_SHA256;
}
break;
case 3:
{
*out_value = MBEDTLS_MD_SHA384;
}
break;
case 4:
{
*out_value = MBEDTLS_MD_SHA512;
}
break;
case 5:
{
*out_value = MBEDTLS_MD_MD4;
}
break;
case 6:
{
*out_value = MBEDTLS_MD_MD5;
}
break;
case 7:
{
*out_value = MBEDTLS_X509_KU_DIGITAL_SIGNATURE | MBEDTLS_X509_KU_NON_REPUDIATION | MBEDTLS_X509_KU_KEY_ENCIPHERMENT;
}
break;
case 8:
{
*out_value = MBEDTLS_X509_NS_CERT_TYPE_SSL_SERVER;
}
break;
case 9:
{
*out_value = MBEDTLS_X509_KU_DIGITAL_SIGNATURE | MBEDTLS_X509_KU_NON_REPUDIATION;
}
break;
case 10:
{
*out_value = -1;
}
break;
case 11:
{
*out_value = MBEDTLS_X509_CRT_VERSION_1;
}
break;
case 12:
{
*out_value = MBEDTLS_ERR_X509_UNKNOWN_OID;
}
break;
case 13:
{
*out_value = MBEDTLS_ERR_X509_INVALID_NAME;
}
break;
#endif
default:
{
ret = KEY_VALUE_MAPPING_NOT_FOUND;
}
break;
}
return( ret );
}
/**
* \brief Checks if the dependency i.e. the compile flag is set.
* For optimizing space for embedded targets each dependency
* is identified by a unique identifier instead of string literals.
* Identifiers and check code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param dep_id Dependency identifier.
*
* \return DEPENDENCY_SUPPORTED if set else DEPENDENCY_NOT_SUPPORTED
*/
int dep_check( int dep_id )
{
int ret = DEPENDENCY_NOT_SUPPORTED;
(void) dep_id;
switch( dep_id )
{
#if defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_FS_IO) && defined(MBEDTLS_PK_PARSE_C)
case 0:
{
#if defined(MBEDTLS_SHA1_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 1:
{
#if defined(MBEDTLS_RSA_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 2:
{
#if defined(MBEDTLS_PKCS1_V15)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 3:
{
#if defined(MBEDTLS_SHA256_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 4:
{
#if defined(MBEDTLS_SHA512_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 5:
{
#if !defined(MBEDTLS_SHA512_NO_SHA384)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 6:
{
#if defined(MBEDTLS_MD4_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 7:
{
#if defined(MBEDTLS_MD5_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 8:
{
#if defined(MBEDTLS_ECDSA_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 9:
{
#if defined(MBEDTLS_ECDSA_DETERMINISTIC)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 10:
{
#if defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 11:
{
#if defined(MBEDTLS_DES_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 12:
{
#if defined(MBEDTLS_CIPHER_MODE_CBC)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
#endif
default:
break;
}
return( ret );
}
/**
* \brief Function pointer type for test function wrappers.
*
* A test function wrapper decodes the parameters and passes them to the
* underlying test function. Both the wrapper and the underlying function
* return void. Test wrappers assume that they are passed a suitable
* parameter array and do not perform any error detection.
*
* \param param_array The array of parameters. Each element is a `void *`
* which the wrapper casts to the correct type and
* dereferences. Each wrapper function hard-codes the
* number and types of the parameters.
*/
typedef void (*TestWrapper_t)( void **param_array );
/**
* \brief Table of test function wrappers. Used by dispatch_test().
* This table is populated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
*/
TestWrapper_t test_funcs[] =
{
/* Function Id: 0 */
#if defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_FS_IO) && defined(MBEDTLS_PK_PARSE_C) && defined(MBEDTLS_PEM_WRITE_C) && defined(MBEDTLS_X509_CSR_WRITE_C)
test_x509_csr_check_wrapper,
#else
NULL,
#endif
/* Function Id: 1 */
#if defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_FS_IO) && defined(MBEDTLS_PK_PARSE_C) && defined(MBEDTLS_PEM_WRITE_C) && defined(MBEDTLS_X509_CSR_WRITE_C) && defined(MBEDTLS_USE_PSA_CRYPTO)
test_x509_csr_check_opaque_wrapper,
#else
NULL,
#endif
/* Function Id: 2 */
#if defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_FS_IO) && defined(MBEDTLS_PK_PARSE_C) && defined(MBEDTLS_PEM_WRITE_C) && defined(MBEDTLS_X509_CRT_WRITE_C) && defined(MBEDTLS_SHA1_C)
test_x509_crt_check_wrapper,
#else
NULL,
#endif
/* Function Id: 3 */
#if defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_FS_IO) && defined(MBEDTLS_PK_PARSE_C) && defined(MBEDTLS_X509_CREATE_C) && defined(MBEDTLS_X509_USE_C)
test_mbedtls_x509_string_to_names_wrapper,
#else
NULL,
#endif
};
/**
* \brief Execute the test function.
*
* This is a wrapper function around the test function execution
* to allow the setjmp() call used to catch any calls to the
* parameter failure callback, to be used. Calls to setjmp()
* can invalidate the state of any local auto variables.
*
* \param fp Function pointer to the test function.
* \param params Parameters to pass to the #TestWrapper_t wrapper function.
*
*/
void execute_function_ptr(TestWrapper_t fp, void **params)
{
#if defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG)
mbedtls_test_enable_insecure_external_rng( );
#endif
#if defined(MBEDTLS_CHECK_PARAMS)
mbedtls_test_param_failed_location_record_t location_record;
if ( setjmp( mbedtls_test_param_failed_get_state_buf( ) ) == 0 )
{
fp( params );
}
else
{
/* Unexpected parameter validation error */
mbedtls_test_param_failed_get_location_record( &location_record );
mbedtls_test_fail( location_record.failure_condition,
location_record.line,
location_record.file );
}
mbedtls_test_param_failed_reset_state( );
#else
fp( params );
#endif
#if defined(MBEDTLS_TEST_MUTEX_USAGE)
mbedtls_test_mutex_usage_check( );
#endif /* MBEDTLS_TEST_MUTEX_USAGE */
}
/**
* \brief Dispatches test functions based on function index.
*
* \param func_idx Test function index.
* \param params The array of parameters to pass to the test function.
* It will be decoded by the #TestWrapper_t wrapper function.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int dispatch_test( size_t func_idx, void ** params )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof( test_funcs ) / sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp )
execute_function_ptr(fp, params);
else
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
/**
* \brief Checks if test function is supported in this build-time
* configuration.
*
* \param func_idx Test function index.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int check_test( size_t func_idx )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof(test_funcs)/sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp == NULL )
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
int main( int argc, const char *argv[] )
{
int ret;
mbedtls_test_platform_setup();
ret = execute_tests( argc, argv, "/zip/third_party/mbedtls/test/test_suite_x509write.datax" );
mbedtls_test_platform_teardown();
return( ret );
}
| 27,341 | 863 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_rsa.c | /* clang-format off */
/*
* Copyright The Mbed TLS Contributors
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "third_party/mbedtls/test/test.inc"
/*
* *** THIS FILE WAS MACHINE GENERATED ***
*
* This file has been machine generated using the script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* Test file : ./test_suite_rsa.c
*
* The following files were used to create this file.
*
* Main code file : suites/main_test.function
* Platform code file : suites/host_test.function
* Helper file : suites/helpers.function
* Test suite file : suites/test_suite_rsa.function
* Test suite data : suites/test_suite_rsa.data
*
*/
#define TEST_SUITE_ACTIVE
#if defined(MBEDTLS_RSA_C)
#if defined(MBEDTLS_BIGNUM_C)
#if defined(MBEDTLS_GENPRIME)
#include "third_party/mbedtls/rsa.h"
#include "third_party/mbedtls/rsa_internal.h"
#include "third_party/mbedtls/md5.h"
#include "third_party/mbedtls/sha1.h"
#include "third_party/mbedtls/sha256.h"
#include "third_party/mbedtls/sha512.h"
#include "third_party/mbedtls/entropy.h"
#include "third_party/mbedtls/ctr_drbg.h"
#if defined(MBEDTLS_CHECK_PARAMS)
#if !defined(MBEDTLS_PARAM_FAILED_ALT)
void test_rsa_invalid_param( )
{
mbedtls_rsa_context ctx;
const int valid_padding = MBEDTLS_RSA_PKCS_V21;
const int invalid_padding = 42;
const int valid_mode = MBEDTLS_RSA_PRIVATE;
const int invalid_mode = 42;
unsigned char buf[42] = { 0 };
size_t olen;
TEST_INVALID_PARAM( mbedtls_rsa_init( NULL, valid_padding, 0 ) );
TEST_INVALID_PARAM( mbedtls_rsa_init( &ctx, invalid_padding, 0 ) );
TEST_VALID_PARAM( mbedtls_rsa_free( NULL ) );
/* No more variants because only the first argument must be non-NULL. */
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_import( NULL, NULL, NULL,
NULL, NULL, NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_import_raw( NULL,
NULL, 0,
NULL, 0,
NULL, 0,
NULL, 0,
NULL, 0 ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_complete( NULL ) );
/* No more variants because only the first argument must be non-NULL. */
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_export( NULL, NULL, NULL,
NULL, NULL, NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_export_raw( NULL,
NULL, 0,
NULL, 0,
NULL, 0,
NULL, 0,
NULL, 0 ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_export_crt( NULL, NULL, NULL, NULL ) );
TEST_INVALID_PARAM( mbedtls_rsa_set_padding( NULL,
valid_padding, 0 ) );
TEST_INVALID_PARAM( mbedtls_rsa_set_padding( &ctx,
invalid_padding, 0 ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_gen_key( NULL,
mbedtls_test_rnd_std_rand,
NULL, 0, 0 ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_gen_key( &ctx, NULL,
NULL, 0, 0 ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_check_pubkey( NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_check_privkey( NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_check_pub_priv( NULL, &ctx ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_check_pub_priv( &ctx, NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_public( NULL, buf, buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_public( &ctx, NULL, buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_public( &ctx, buf, NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_private( NULL, NULL, NULL,
buf, buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_private( &ctx, NULL, NULL,
NULL, buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_private( &ctx, NULL, NULL,
buf, NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_pkcs1_encrypt( NULL, NULL, NULL,
valid_mode,
sizeof( buf ), buf,
buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_pkcs1_encrypt( &ctx, NULL, NULL,
invalid_mode,
sizeof( buf ), buf,
buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_pkcs1_encrypt( &ctx, NULL, NULL,
valid_mode,
sizeof( buf ), NULL,
buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_pkcs1_encrypt( &ctx, NULL, NULL,
valid_mode,
sizeof( buf ), buf,
NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsaes_pkcs1_v15_encrypt( NULL, NULL,
NULL,
valid_mode,
sizeof( buf ), buf,
buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsaes_pkcs1_v15_encrypt( &ctx, NULL,
NULL,
invalid_mode,
sizeof( buf ), buf,
buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsaes_pkcs1_v15_encrypt( &ctx, NULL,
NULL,
valid_mode,
sizeof( buf ), NULL,
buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsaes_pkcs1_v15_encrypt( &ctx, NULL,
NULL,
valid_mode,
sizeof( buf ), buf,
NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsaes_oaep_encrypt( NULL, NULL, NULL,
valid_mode,
buf, sizeof( buf ),
sizeof( buf ), buf,
buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsaes_oaep_encrypt( &ctx, NULL, NULL,
invalid_mode,
buf, sizeof( buf ),
sizeof( buf ), buf,
buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsaes_oaep_encrypt( &ctx, NULL, NULL,
valid_mode,
NULL, sizeof( buf ),
sizeof( buf ), buf,
buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsaes_oaep_encrypt( &ctx, NULL, NULL,
valid_mode,
buf, sizeof( buf ),
sizeof( buf ), NULL,
buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsaes_oaep_encrypt( &ctx, NULL, NULL,
valid_mode,
buf, sizeof( buf ),
sizeof( buf ), buf,
NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_pkcs1_decrypt( NULL, NULL, NULL,
valid_mode, &olen,
buf, buf, 42 ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_pkcs1_decrypt( &ctx, NULL, NULL,
invalid_mode, &olen,
buf, buf, 42 ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_pkcs1_decrypt( &ctx, NULL, NULL,
valid_mode, NULL,
buf, buf, 42 ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_pkcs1_decrypt( &ctx, NULL, NULL,
valid_mode, &olen,
NULL, buf, 42 ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_pkcs1_decrypt( &ctx, NULL, NULL,
valid_mode, &olen,
buf, NULL, 42 ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsaes_pkcs1_v15_decrypt( NULL, NULL,
NULL,
valid_mode, &olen,
buf, buf, 42 ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsaes_pkcs1_v15_decrypt( &ctx, NULL,
NULL,
invalid_mode, &olen,
buf, buf, 42 ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsaes_pkcs1_v15_decrypt( &ctx, NULL,
NULL,
valid_mode, NULL,
buf, buf, 42 ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsaes_pkcs1_v15_decrypt( &ctx, NULL,
NULL,
valid_mode, &olen,
NULL, buf, 42 ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsaes_pkcs1_v15_decrypt( &ctx, NULL,
NULL,
valid_mode, &olen,
buf, NULL, 42 ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsaes_oaep_decrypt( NULL, NULL, NULL,
valid_mode,
buf, sizeof( buf ),
&olen,
buf, buf, 42 ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsaes_oaep_decrypt( &ctx, NULL, NULL,
invalid_mode,
buf, sizeof( buf ),
&olen,
buf, buf, 42 ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsaes_oaep_decrypt( &ctx, NULL, NULL,
valid_mode,
NULL, sizeof( buf ),
NULL,
buf, buf, 42 ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsaes_oaep_decrypt( &ctx, NULL, NULL,
valid_mode,
buf, sizeof( buf ),
&olen,
NULL, buf, 42 ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsaes_oaep_decrypt( &ctx, NULL, NULL,
valid_mode,
buf, sizeof( buf ),
&olen,
buf, NULL, 42 ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_pkcs1_sign( NULL, NULL, NULL,
valid_mode,
0, sizeof( buf ), buf,
buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_pkcs1_sign( &ctx, NULL, NULL,
invalid_mode,
0, sizeof( buf ), buf,
buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_pkcs1_sign( &ctx, NULL, NULL,
valid_mode,
0, sizeof( buf ), NULL,
buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_pkcs1_sign( &ctx, NULL, NULL,
valid_mode,
0, sizeof( buf ), buf,
NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_pkcs1_sign( &ctx, NULL, NULL,
valid_mode,
MBEDTLS_MD_SHA1,
0, NULL,
buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsassa_pkcs1_v15_sign( NULL, NULL, NULL,
valid_mode,
0, sizeof( buf ), buf,
buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsassa_pkcs1_v15_sign( &ctx, NULL, NULL,
invalid_mode,
0, sizeof( buf ), buf,
buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsassa_pkcs1_v15_sign( &ctx, NULL, NULL,
valid_mode,
0, sizeof( buf ), NULL,
buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsassa_pkcs1_v15_sign( &ctx, NULL, NULL,
valid_mode,
0, sizeof( buf ), buf,
NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsassa_pkcs1_v15_sign( &ctx, NULL, NULL,
valid_mode,
MBEDTLS_MD_SHA1,
0, NULL,
buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsassa_pss_sign( NULL, NULL, NULL,
valid_mode,
0, sizeof( buf ), buf,
buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsassa_pss_sign( &ctx, NULL, NULL,
invalid_mode,
0, sizeof( buf ), buf,
buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsassa_pss_sign( &ctx, NULL, NULL,
valid_mode,
0, sizeof( buf ), NULL,
buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsassa_pss_sign( &ctx, NULL, NULL,
valid_mode,
0, sizeof( buf ), buf,
NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsassa_pss_sign( &ctx, NULL, NULL,
valid_mode,
MBEDTLS_MD_SHA1,
0, NULL,
buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_pkcs1_verify( NULL, NULL, NULL,
valid_mode,
0, sizeof( buf ), buf,
buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_pkcs1_verify( &ctx, NULL, NULL,
invalid_mode,
0, sizeof( buf ), buf,
buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_pkcs1_verify( &ctx, NULL, NULL,
valid_mode,
0, sizeof( buf ), NULL,
buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_pkcs1_verify( &ctx, NULL, NULL,
valid_mode,
0, sizeof( buf ), buf,
NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_pkcs1_verify( &ctx, NULL, NULL,
valid_mode,
MBEDTLS_MD_SHA1, 0, NULL,
buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsassa_pkcs1_v15_verify( NULL, NULL,
NULL,
valid_mode,
0, sizeof( buf ), buf,
buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsassa_pkcs1_v15_verify( &ctx, NULL,
NULL,
invalid_mode,
0, sizeof( buf ), buf,
buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsassa_pkcs1_v15_verify( &ctx, NULL,
NULL,
valid_mode,
0, sizeof( buf ),
NULL, buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsassa_pkcs1_v15_verify( &ctx, NULL,
NULL,
valid_mode,
0, sizeof( buf ), buf,
NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsassa_pkcs1_v15_verify( &ctx, NULL,
NULL,
valid_mode,
MBEDTLS_MD_SHA1,
0, NULL,
buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsassa_pss_verify( NULL, NULL, NULL,
valid_mode,
0, sizeof( buf ),
buf, buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsassa_pss_verify( &ctx, NULL, NULL,
invalid_mode,
0, sizeof( buf ),
buf, buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsassa_pss_verify( &ctx, NULL, NULL,
valid_mode,
0, sizeof( buf ),
NULL, buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsassa_pss_verify( &ctx, NULL, NULL,
valid_mode,
0, sizeof( buf ),
buf, NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsassa_pss_verify( &ctx, NULL, NULL,
valid_mode,
MBEDTLS_MD_SHA1,
0, NULL,
buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsassa_pss_verify_ext( NULL, NULL, NULL,
valid_mode,
0, sizeof( buf ),
buf,
0, 0,
buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsassa_pss_verify_ext( &ctx, NULL, NULL,
invalid_mode,
0, sizeof( buf ),
buf,
0, 0,
buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsassa_pss_verify_ext( &ctx, NULL, NULL,
valid_mode,
0, sizeof( buf ),
NULL, 0, 0,
buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsassa_pss_verify_ext( &ctx, NULL, NULL,
valid_mode,
0, sizeof( buf ),
buf, 0, 0,
NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_rsassa_pss_verify_ext( &ctx, NULL, NULL,
valid_mode,
MBEDTLS_MD_SHA1,
0, NULL,
0, 0,
buf ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_copy( NULL, &ctx ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
mbedtls_rsa_copy( &ctx, NULL ) );
exit:
return;
}
void test_rsa_invalid_param_wrapper( void ** params )
{
(void)params;
test_rsa_invalid_param( );
}
#endif /* !MBEDTLS_PARAM_FAILED_ALT */
#endif /* MBEDTLS_CHECK_PARAMS */
void test_rsa_init_free( int reinit )
{
mbedtls_rsa_context ctx;
/* Double free is not explicitly documented to work, but we rely on it
* even inside the library so that you can call mbedtls_rsa_free()
* unconditionally on an error path without checking whether it has
* already been called in the success path. */
mbedtls_rsa_init( &ctx, 0, 0 );
mbedtls_rsa_free( &ctx );
if( reinit )
mbedtls_rsa_init( &ctx, 0, 0 );
mbedtls_rsa_free( &ctx );
/* This test case always succeeds, functionally speaking. A plausible
* bug might trigger an invalid pointer dereference or a memory leak. */
goto exit;
exit:
;
}
void test_rsa_init_free_wrapper( void ** params )
{
test_rsa_init_free( *( (int *) params[0] ) );
}
void test_mbedtls_rsa_pkcs1_sign( data_t * message_str, int padding_mode,
int digest, int mod, int radix_P, char * input_P,
int radix_Q, char * input_Q, int radix_N,
char * input_N, int radix_E, char * input_E,
data_t * result_str, int result )
{
unsigned char hash_result[MBEDTLS_MD_MAX_SIZE];
unsigned char output[256];
mbedtls_rsa_context ctx;
mbedtls_mpi N, P, Q, E;
mbedtls_test_rnd_pseudo_info rnd_info;
mbedtls_mpi_init( &N ); mbedtls_mpi_init( &P );
mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &E );
mbedtls_rsa_init( &ctx, padding_mode, 0 );
memset( hash_result, 0x00, sizeof( hash_result ) );
memset( output, 0x00, sizeof( output ) );
memset( &rnd_info, 0, sizeof( mbedtls_test_rnd_pseudo_info ) );
TEST_ASSERT( mbedtls_mpi_read_string( &P, radix_P, input_P ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &Q, radix_Q, input_Q ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &N, radix_N, input_N ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &E, radix_E, input_E ) == 0 );
TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, &P, &Q, NULL, &E ) == 0 );
TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( mod / 8 ) );
TEST_ASSERT( mbedtls_rsa_complete( &ctx ) == 0 );
TEST_ASSERT( mbedtls_rsa_check_privkey( &ctx ) == 0 );
if( mbedtls_md_info_from_type( digest ) != NULL )
TEST_ASSERT( mbedtls_md( mbedtls_md_info_from_type( digest ), message_str->x, message_str->len, hash_result ) == 0 );
TEST_ASSERT( mbedtls_rsa_pkcs1_sign( &ctx, &mbedtls_test_rnd_pseudo_rand,
&rnd_info, MBEDTLS_RSA_PRIVATE, digest,
0, hash_result, output ) == result );
if( result == 0 )
{
TEST_ASSERT( mbedtls_test_hexcmp( output, result_str->x,
ctx.len, result_str->len ) == 0 );
}
exit:
mbedtls_mpi_free( &N ); mbedtls_mpi_free( &P );
mbedtls_mpi_free( &Q ); mbedtls_mpi_free( &E );
mbedtls_rsa_free( &ctx );
}
void test_mbedtls_rsa_pkcs1_sign_wrapper( void ** params )
{
data_t data0 = {(uint8_t *) params[0], *( (uint32_t *) params[1] )};
data_t data13 = {(uint8_t *) params[13], *( (uint32_t *) params[14] )};
test_mbedtls_rsa_pkcs1_sign( &data0, *( (int *) params[2] ), *( (int *) params[3] ), *( (int *) params[4] ), *( (int *) params[5] ), (char *) params[6], *( (int *) params[7] ), (char *) params[8], *( (int *) params[9] ), (char *) params[10], *( (int *) params[11] ), (char *) params[12], &data13, *( (int *) params[15] ) );
}
void test_mbedtls_rsa_pkcs1_verify( data_t * message_str, int padding_mode,
int digest, int mod, int radix_N,
char * input_N, int radix_E, char * input_E,
data_t * result_str, int result )
{
unsigned char hash_result[MBEDTLS_MD_MAX_SIZE];
mbedtls_rsa_context ctx;
mbedtls_mpi N, E;
mbedtls_mpi_init( &N ); mbedtls_mpi_init( &E );
mbedtls_rsa_init( &ctx, padding_mode, 0 );
memset( hash_result, 0x00, sizeof( hash_result ) );
TEST_ASSERT( mbedtls_mpi_read_string( &N, radix_N, input_N ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &E, radix_E, input_E ) == 0 );
TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, NULL, NULL, NULL, &E ) == 0 );
TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( mod / 8 ) );
TEST_ASSERT( mbedtls_rsa_check_pubkey( &ctx ) == 0 );
if( mbedtls_md_info_from_type( digest ) != NULL )
TEST_ASSERT( mbedtls_md( mbedtls_md_info_from_type( digest ), message_str->x, message_str->len, hash_result ) == 0 );
TEST_ASSERT( mbedtls_rsa_pkcs1_verify( &ctx, NULL, NULL, MBEDTLS_RSA_PUBLIC, digest, 0, hash_result, result_str->x ) == result );
exit:
mbedtls_mpi_free( &N ); mbedtls_mpi_free( &E );
mbedtls_rsa_free( &ctx );
}
void test_mbedtls_rsa_pkcs1_verify_wrapper( void ** params )
{
data_t data0 = {(uint8_t *) params[0], *( (uint32_t *) params[1] )};
data_t data9 = {(uint8_t *) params[9], *( (uint32_t *) params[10] )};
test_mbedtls_rsa_pkcs1_verify( &data0, *( (int *) params[2] ), *( (int *) params[3] ), *( (int *) params[4] ), *( (int *) params[5] ), (char *) params[6], *( (int *) params[7] ), (char *) params[8], &data9, *( (int *) params[11] ) );
}
void test_rsa_pkcs1_sign_raw( data_t * hash_result,
int padding_mode, int mod, int radix_P,
char * input_P, int radix_Q, char * input_Q,
int radix_N, char * input_N, int radix_E,
char * input_E, data_t * result_str )
{
unsigned char output[256];
mbedtls_rsa_context ctx;
mbedtls_mpi N, P, Q, E;
mbedtls_test_rnd_pseudo_info rnd_info;
mbedtls_rsa_init( &ctx, padding_mode, 0 );
mbedtls_mpi_init( &N ); mbedtls_mpi_init( &P );
mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &E );
memset( output, 0x00, sizeof( output ) );
memset( &rnd_info, 0, sizeof( mbedtls_test_rnd_pseudo_info ) );
TEST_ASSERT( mbedtls_mpi_read_string( &P, radix_P, input_P ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &Q, radix_Q, input_Q ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &N, radix_N, input_N ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &E, radix_E, input_E ) == 0 );
TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, &P, &Q, NULL, &E ) == 0 );
TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( mod / 8 ) );
TEST_ASSERT( mbedtls_rsa_complete( &ctx ) == 0 );
TEST_ASSERT( mbedtls_rsa_check_privkey( &ctx ) == 0 );
TEST_ASSERT( mbedtls_rsa_pkcs1_sign( &ctx, &mbedtls_test_rnd_pseudo_rand,
&rnd_info, MBEDTLS_RSA_PRIVATE,
MBEDTLS_MD_NONE, hash_result->len,
hash_result->x, output ) == 0 );
TEST_ASSERT( mbedtls_test_hexcmp( output, result_str->x,
ctx.len, result_str->len ) == 0 );
#if defined(MBEDTLS_PKCS1_V15)
/* For PKCS#1 v1.5, there is an alternative way to generate signatures */
if( padding_mode == MBEDTLS_RSA_PKCS_V15 )
{
int res;
memset( output, 0x00, sizeof( output) );
res = mbedtls_rsa_rsaes_pkcs1_v15_encrypt( &ctx,
&mbedtls_test_rnd_pseudo_rand, &rnd_info,
MBEDTLS_RSA_PRIVATE, hash_result->len,
hash_result->x, output );
#if !defined(MBEDTLS_RSA_ALT)
TEST_ASSERT( res == 0 );
#else
TEST_ASSERT( ( res == 0 ) ||
( res == MBEDTLS_ERR_RSA_UNSUPPORTED_OPERATION ) );
#endif
if( res == 0 )
{
TEST_ASSERT( mbedtls_test_hexcmp( output, result_str->x,
ctx.len,
result_str->len ) == 0 );
}
}
#endif /* MBEDTLS_PKCS1_V15 */
exit:
mbedtls_mpi_free( &N ); mbedtls_mpi_free( &P );
mbedtls_mpi_free( &Q ); mbedtls_mpi_free( &E );
mbedtls_rsa_free( &ctx );
}
void test_rsa_pkcs1_sign_raw_wrapper( void ** params )
{
data_t data0 = {(uint8_t *) params[0], *( (uint32_t *) params[1] )};
data_t data12 = {(uint8_t *) params[12], *( (uint32_t *) params[13] )};
test_rsa_pkcs1_sign_raw( &data0, *( (int *) params[2] ), *( (int *) params[3] ), *( (int *) params[4] ), (char *) params[5], *( (int *) params[6] ), (char *) params[7], *( (int *) params[8] ), (char *) params[9], *( (int *) params[10] ), (char *) params[11], &data12 );
}
void test_rsa_pkcs1_verify_raw( data_t * hash_result,
int padding_mode, int mod, int radix_N,
char * input_N, int radix_E, char * input_E,
data_t * result_str, int correct )
{
unsigned char output[256];
mbedtls_rsa_context ctx;
mbedtls_mpi N, E;
mbedtls_mpi_init( &N ); mbedtls_mpi_init( &E );
mbedtls_rsa_init( &ctx, padding_mode, 0 );
memset( output, 0x00, sizeof( output ) );
TEST_ASSERT( mbedtls_mpi_read_string( &N, radix_N, input_N ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &E, radix_E, input_E ) == 0 );
TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, NULL, NULL, NULL, &E ) == 0 );
TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( mod / 8 ) );
TEST_ASSERT( mbedtls_rsa_check_pubkey( &ctx ) == 0 );
TEST_ASSERT( mbedtls_rsa_pkcs1_verify( &ctx, NULL, NULL, MBEDTLS_RSA_PUBLIC, MBEDTLS_MD_NONE, hash_result->len, hash_result->x, result_str->x ) == correct );
#if defined(MBEDTLS_PKCS1_V15)
/* For PKCS#1 v1.5, there is an alternative way to verify signatures */
if( padding_mode == MBEDTLS_RSA_PKCS_V15 )
{
int res;
int ok;
size_t olen;
res = mbedtls_rsa_rsaes_pkcs1_v15_decrypt( &ctx,
NULL, NULL, MBEDTLS_RSA_PUBLIC,
&olen, result_str->x, output, sizeof( output ) );
#if !defined(MBEDTLS_RSA_ALT)
TEST_ASSERT( res == 0 );
#else
TEST_ASSERT( ( res == 0 ) ||
( res == MBEDTLS_ERR_RSA_UNSUPPORTED_OPERATION ) );
#endif
if( res == 0 )
{
ok = olen == hash_result->len && memcmp( output, hash_result->x, olen ) == 0;
if( correct == 0 )
TEST_ASSERT( ok == 1 );
else
TEST_ASSERT( ok == 0 );
}
}
#endif /* MBEDTLS_PKCS1_V15 */
exit:
mbedtls_mpi_free( &N ); mbedtls_mpi_free( &E );
mbedtls_rsa_free( &ctx );
}
void test_rsa_pkcs1_verify_raw_wrapper( void ** params )
{
data_t data0 = {(uint8_t *) params[0], *( (uint32_t *) params[1] )};
data_t data8 = {(uint8_t *) params[8], *( (uint32_t *) params[9] )};
test_rsa_pkcs1_verify_raw( &data0, *( (int *) params[2] ), *( (int *) params[3] ), *( (int *) params[4] ), (char *) params[5], *( (int *) params[6] ), (char *) params[7], &data8, *( (int *) params[10] ) );
}
void test_mbedtls_rsa_pkcs1_encrypt( data_t * message_str, int padding_mode,
int mod, int radix_N, char * input_N,
int radix_E, char * input_E,
data_t * result_str, int result )
{
unsigned char output[256];
mbedtls_rsa_context ctx;
mbedtls_test_rnd_pseudo_info rnd_info;
mbedtls_mpi N, E;
mbedtls_mpi_init( &N ); mbedtls_mpi_init( &E );
memset( &rnd_info, 0, sizeof( mbedtls_test_rnd_pseudo_info ) );
mbedtls_rsa_init( &ctx, padding_mode, 0 );
memset( output, 0x00, sizeof( output ) );
TEST_ASSERT( mbedtls_mpi_read_string( &N, radix_N, input_N ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &E, radix_E, input_E ) == 0 );
TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, NULL, NULL, NULL, &E ) == 0 );
TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( mod / 8 ) );
TEST_ASSERT( mbedtls_rsa_check_pubkey( &ctx ) == 0 );
TEST_ASSERT( mbedtls_rsa_pkcs1_encrypt( &ctx,
&mbedtls_test_rnd_pseudo_rand,
&rnd_info, MBEDTLS_RSA_PUBLIC,
message_str->len, message_str->x,
output ) == result );
if( result == 0 )
{
TEST_ASSERT( mbedtls_test_hexcmp( output, result_str->x,
ctx.len, result_str->len ) == 0 );
}
exit:
mbedtls_mpi_free( &N ); mbedtls_mpi_free( &E );
mbedtls_rsa_free( &ctx );
}
void test_mbedtls_rsa_pkcs1_encrypt_wrapper( void ** params )
{
data_t data0 = {(uint8_t *) params[0], *( (uint32_t *) params[1] )};
data_t data8 = {(uint8_t *) params[8], *( (uint32_t *) params[9] )};
test_mbedtls_rsa_pkcs1_encrypt( &data0, *( (int *) params[2] ), *( (int *) params[3] ), *( (int *) params[4] ), (char *) params[5], *( (int *) params[6] ), (char *) params[7], &data8, *( (int *) params[10] ) );
}
void test_rsa_pkcs1_encrypt_bad_rng( data_t * message_str, int padding_mode,
int mod, int radix_N, char * input_N,
int radix_E, char * input_E,
data_t * result_str, int result )
{
unsigned char output[256];
mbedtls_rsa_context ctx;
mbedtls_mpi N, E;
mbedtls_mpi_init( &N ); mbedtls_mpi_init( &E );
mbedtls_rsa_init( &ctx, padding_mode, 0 );
memset( output, 0x00, sizeof( output ) );
TEST_ASSERT( mbedtls_mpi_read_string( &N, radix_N, input_N ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &E, radix_E, input_E ) == 0 );
TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, NULL, NULL, NULL, &E ) == 0 );
TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( mod / 8 ) );
TEST_ASSERT( mbedtls_rsa_check_pubkey( &ctx ) == 0 );
TEST_ASSERT( mbedtls_rsa_pkcs1_encrypt( &ctx, &mbedtls_test_rnd_zero_rand,
NULL, MBEDTLS_RSA_PUBLIC,
message_str->len, message_str->x,
output ) == result );
if( result == 0 )
{
TEST_ASSERT( mbedtls_test_hexcmp( output, result_str->x,
ctx.len, result_str->len ) == 0 );
}
exit:
mbedtls_mpi_free( &N ); mbedtls_mpi_free( &E );
mbedtls_rsa_free( &ctx );
}
void test_rsa_pkcs1_encrypt_bad_rng_wrapper( void ** params )
{
data_t data0 = {(uint8_t *) params[0], *( (uint32_t *) params[1] )};
data_t data8 = {(uint8_t *) params[8], *( (uint32_t *) params[9] )};
test_rsa_pkcs1_encrypt_bad_rng( &data0, *( (int *) params[2] ), *( (int *) params[3] ), *( (int *) params[4] ), (char *) params[5], *( (int *) params[6] ), (char *) params[7], &data8, *( (int *) params[10] ) );
}
void test_mbedtls_rsa_pkcs1_decrypt( data_t * message_str, int padding_mode,
int mod, int radix_P, char * input_P,
int radix_Q, char * input_Q, int radix_N,
char * input_N, int radix_E, char * input_E,
int max_output, data_t * result_str,
int result )
{
unsigned char output[32];
mbedtls_rsa_context ctx;
size_t output_len;
mbedtls_test_rnd_pseudo_info rnd_info;
mbedtls_mpi N, P, Q, E;
mbedtls_mpi_init( &N ); mbedtls_mpi_init( &P );
mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &E );
mbedtls_rsa_init( &ctx, padding_mode, 0 );
memset( output, 0x00, sizeof( output ) );
memset( &rnd_info, 0, sizeof( mbedtls_test_rnd_pseudo_info ) );
TEST_ASSERT( mbedtls_mpi_read_string( &P, radix_P, input_P ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &Q, radix_Q, input_Q ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &N, radix_N, input_N ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &E, radix_E, input_E ) == 0 );
TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, &P, &Q, NULL, &E ) == 0 );
TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( mod / 8 ) );
TEST_ASSERT( mbedtls_rsa_complete( &ctx ) == 0 );
TEST_ASSERT( mbedtls_rsa_check_privkey( &ctx ) == 0 );
output_len = 0;
TEST_ASSERT( mbedtls_rsa_pkcs1_decrypt( &ctx, mbedtls_test_rnd_pseudo_rand,
&rnd_info, MBEDTLS_RSA_PRIVATE,
&output_len, message_str->x, output,
max_output ) == result );
if( result == 0 )
{
TEST_ASSERT( mbedtls_test_hexcmp( output, result_str->x,
output_len,
result_str->len ) == 0 );
}
exit:
mbedtls_mpi_free( &N ); mbedtls_mpi_free( &P );
mbedtls_mpi_free( &Q ); mbedtls_mpi_free( &E );
mbedtls_rsa_free( &ctx );
}
void test_mbedtls_rsa_pkcs1_decrypt_wrapper( void ** params )
{
data_t data0 = {(uint8_t *) params[0], *( (uint32_t *) params[1] )};
data_t data13 = {(uint8_t *) params[13], *( (uint32_t *) params[14] )};
test_mbedtls_rsa_pkcs1_decrypt( &data0, *( (int *) params[2] ), *( (int *) params[3] ), *( (int *) params[4] ), (char *) params[5], *( (int *) params[6] ), (char *) params[7], *( (int *) params[8] ), (char *) params[9], *( (int *) params[10] ), (char *) params[11], *( (int *) params[12] ), &data13, *( (int *) params[15] ) );
}
void test_mbedtls_rsa_public( data_t * message_str, int mod, int radix_N,
char * input_N, int radix_E, char * input_E,
data_t * result_str, int result )
{
unsigned char output[256];
mbedtls_rsa_context ctx, ctx2; /* Also test mbedtls_rsa_copy() while at it */
mbedtls_mpi N, E;
mbedtls_mpi_init( &N ); mbedtls_mpi_init( &E );
mbedtls_rsa_init( &ctx, MBEDTLS_RSA_PKCS_V15, 0 );
mbedtls_rsa_init( &ctx2, MBEDTLS_RSA_PKCS_V15, 0 );
memset( output, 0x00, sizeof( output ) );
TEST_ASSERT( mbedtls_mpi_read_string( &N, radix_N, input_N ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &E, radix_E, input_E ) == 0 );
TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, NULL, NULL, NULL, &E ) == 0 );
TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( mod / 8 ) );
TEST_ASSERT( mbedtls_rsa_check_pubkey( &ctx ) == 0 );
TEST_ASSERT( mbedtls_rsa_public( &ctx, message_str->x, output ) == result );
if( result == 0 )
{
TEST_ASSERT( mbedtls_test_hexcmp( output, result_str->x,
ctx.len, result_str->len ) == 0 );
}
/* And now with the copy */
TEST_ASSERT( mbedtls_rsa_copy( &ctx2, &ctx ) == 0 );
/* clear the original to be sure */
mbedtls_rsa_free( &ctx );
TEST_ASSERT( mbedtls_rsa_check_pubkey( &ctx2 ) == 0 );
memset( output, 0x00, sizeof( output ) );
TEST_ASSERT( mbedtls_rsa_public( &ctx2, message_str->x, output ) == result );
if( result == 0 )
{
TEST_ASSERT( mbedtls_test_hexcmp( output, result_str->x,
ctx.len, result_str->len ) == 0 );
}
exit:
mbedtls_mpi_free( &N ); mbedtls_mpi_free( &E );
mbedtls_rsa_free( &ctx );
mbedtls_rsa_free( &ctx2 );
}
void test_mbedtls_rsa_public_wrapper( void ** params )
{
data_t data0 = {(uint8_t *) params[0], *( (uint32_t *) params[1] )};
data_t data7 = {(uint8_t *) params[7], *( (uint32_t *) params[8] )};
test_mbedtls_rsa_public( &data0, *( (int *) params[2] ), *( (int *) params[3] ), (char *) params[4], *( (int *) params[5] ), (char *) params[6], &data7, *( (int *) params[9] ) );
}
void test_mbedtls_rsa_private( data_t * message_str, int mod, int radix_P,
char * input_P, int radix_Q, char * input_Q,
int radix_N, char * input_N, int radix_E,
char * input_E, data_t * result_str,
int result )
{
unsigned char output[256];
mbedtls_rsa_context ctx, ctx2; /* Also test mbedtls_rsa_copy() while at it */
mbedtls_mpi N, P, Q, E;
mbedtls_test_rnd_pseudo_info rnd_info;
int i;
mbedtls_mpi_init( &N ); mbedtls_mpi_init( &P );
mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &E );
mbedtls_rsa_init( &ctx, MBEDTLS_RSA_PKCS_V15, 0 );
mbedtls_rsa_init( &ctx2, MBEDTLS_RSA_PKCS_V15, 0 );
memset( &rnd_info, 0, sizeof( mbedtls_test_rnd_pseudo_info ) );
TEST_ASSERT( mbedtls_mpi_read_string( &P, radix_P, input_P ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &Q, radix_Q, input_Q ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &N, radix_N, input_N ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &E, radix_E, input_E ) == 0 );
TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, &P, &Q, NULL, &E ) == 0 );
TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( mod / 8 ) );
TEST_ASSERT( mbedtls_rsa_complete( &ctx ) == 0 );
TEST_ASSERT( mbedtls_rsa_check_privkey( &ctx ) == 0 );
/* repeat three times to test updating of blinding values */
for( i = 0; i < 3; i++ )
{
memset( output, 0x00, sizeof( output ) );
TEST_ASSERT( mbedtls_rsa_private( &ctx, mbedtls_test_rnd_pseudo_rand,
&rnd_info, message_str->x,
output ) == result );
if( result == 0 )
{
TEST_ASSERT( mbedtls_test_hexcmp( output, result_str->x,
ctx.len,
result_str->len ) == 0 );
}
}
/* And now one more time with the copy */
TEST_ASSERT( mbedtls_rsa_copy( &ctx2, &ctx ) == 0 );
/* clear the original to be sure */
mbedtls_rsa_free( &ctx );
TEST_ASSERT( mbedtls_rsa_check_privkey( &ctx2 ) == 0 );
memset( output, 0x00, sizeof( output ) );
TEST_ASSERT( mbedtls_rsa_private( &ctx2, mbedtls_test_rnd_pseudo_rand,
&rnd_info, message_str->x,
output ) == result );
if( result == 0 )
{
TEST_ASSERT( mbedtls_test_hexcmp( output, result_str->x,
ctx2.len,
result_str->len ) == 0 );
}
exit:
mbedtls_mpi_free( &N ); mbedtls_mpi_free( &P );
mbedtls_mpi_free( &Q ); mbedtls_mpi_free( &E );
mbedtls_rsa_free( &ctx ); mbedtls_rsa_free( &ctx2 );
}
void test_mbedtls_rsa_private_wrapper( void ** params )
{
data_t data0 = {(uint8_t *) params[0], *( (uint32_t *) params[1] )};
data_t data11 = {(uint8_t *) params[11], *( (uint32_t *) params[12] )};
test_mbedtls_rsa_private( &data0, *( (int *) params[2] ), *( (int *) params[3] ), (char *) params[4], *( (int *) params[5] ), (char *) params[6], *( (int *) params[7] ), (char *) params[8], *( (int *) params[9] ), (char *) params[10], &data11, *( (int *) params[13] ) );
}
void test_rsa_check_privkey_null( )
{
mbedtls_rsa_context ctx;
memset( &ctx, 0x00, sizeof( mbedtls_rsa_context ) );
TEST_ASSERT( mbedtls_rsa_check_privkey( &ctx ) == MBEDTLS_ERR_RSA_KEY_CHECK_FAILED );
exit:
;
}
void test_rsa_check_privkey_null_wrapper( void ** params )
{
(void)params;
test_rsa_check_privkey_null( );
}
void test_mbedtls_rsa_check_pubkey( int radix_N, char * input_N, int radix_E,
char * input_E, int result )
{
mbedtls_rsa_context ctx;
mbedtls_mpi N, E;
mbedtls_mpi_init( &N ); mbedtls_mpi_init( &E );
mbedtls_rsa_init( &ctx, MBEDTLS_RSA_PKCS_V15, 0 );
if( strlen( input_N ) )
{
TEST_ASSERT( mbedtls_mpi_read_string( &N, radix_N, input_N ) == 0 );
}
if( strlen( input_E ) )
{
TEST_ASSERT( mbedtls_mpi_read_string( &E, radix_E, input_E ) == 0 );
}
TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, NULL, NULL, NULL, &E ) == 0 );
TEST_ASSERT( mbedtls_rsa_check_pubkey( &ctx ) == result );
exit:
mbedtls_mpi_free( &N ); mbedtls_mpi_free( &E );
mbedtls_rsa_free( &ctx );
}
void test_mbedtls_rsa_check_pubkey_wrapper( void ** params )
{
test_mbedtls_rsa_check_pubkey( *( (int *) params[0] ), (char *) params[1], *( (int *) params[2] ), (char *) params[3], *( (int *) params[4] ) );
}
void test_mbedtls_rsa_check_privkey( int mod, int radix_P, char * input_P,
int radix_Q, char * input_Q, int radix_N,
char * input_N, int radix_E, char * input_E,
int radix_D, char * input_D, int radix_DP,
char * input_DP, int radix_DQ,
char * input_DQ, int radix_QP,
char * input_QP, int result )
{
mbedtls_rsa_context ctx;
mbedtls_rsa_init( &ctx, MBEDTLS_RSA_PKCS_V15, 0 );
ctx.len = mod / 8;
if( strlen( input_P ) )
{
TEST_ASSERT( mbedtls_mpi_read_string( &ctx.P, radix_P, input_P ) == 0 );
}
if( strlen( input_Q ) )
{
TEST_ASSERT( mbedtls_mpi_read_string( &ctx.Q, radix_Q, input_Q ) == 0 );
}
if( strlen( input_N ) )
{
TEST_ASSERT( mbedtls_mpi_read_string( &ctx.N, radix_N, input_N ) == 0 );
}
if( strlen( input_E ) )
{
TEST_ASSERT( mbedtls_mpi_read_string( &ctx.E, radix_E, input_E ) == 0 );
}
if( strlen( input_D ) )
{
TEST_ASSERT( mbedtls_mpi_read_string( &ctx.D, radix_D, input_D ) == 0 );
}
#if !defined(MBEDTLS_RSA_NO_CRT)
if( strlen( input_DP ) )
{
TEST_ASSERT( mbedtls_mpi_read_string( &ctx.DP, radix_DP, input_DP ) == 0 );
}
if( strlen( input_DQ ) )
{
TEST_ASSERT( mbedtls_mpi_read_string( &ctx.DQ, radix_DQ, input_DQ ) == 0 );
}
if( strlen( input_QP ) )
{
TEST_ASSERT( mbedtls_mpi_read_string( &ctx.QP, radix_QP, input_QP ) == 0 );
}
#else
((void) radix_DP); ((void) input_DP);
((void) radix_DQ); ((void) input_DQ);
((void) radix_QP); ((void) input_QP);
#endif
TEST_ASSERT( mbedtls_rsa_check_privkey( &ctx ) == result );
exit:
mbedtls_rsa_free( &ctx );
}
void test_mbedtls_rsa_check_privkey_wrapper( void ** params )
{
test_mbedtls_rsa_check_privkey( *( (int *) params[0] ), *( (int *) params[1] ), (char *) params[2], *( (int *) params[3] ), (char *) params[4], *( (int *) params[5] ), (char *) params[6], *( (int *) params[7] ), (char *) params[8], *( (int *) params[9] ), (char *) params[10], *( (int *) params[11] ), (char *) params[12], *( (int *) params[13] ), (char *) params[14], *( (int *) params[15] ), (char *) params[16], *( (int *) params[17] ) );
}
void test_rsa_check_pubpriv( int mod, int radix_Npub, char * input_Npub,
int radix_Epub, char * input_Epub, int radix_P,
char * input_P, int radix_Q, char * input_Q,
int radix_N, char * input_N, int radix_E,
char * input_E, int radix_D, char * input_D,
int radix_DP, char * input_DP, int radix_DQ,
char * input_DQ, int radix_QP, char * input_QP,
int result )
{
mbedtls_rsa_context pub, prv;
mbedtls_rsa_init( &pub, MBEDTLS_RSA_PKCS_V15, 0 );
mbedtls_rsa_init( &prv, MBEDTLS_RSA_PKCS_V15, 0 );
pub.len = mod / 8;
prv.len = mod / 8;
if( strlen( input_Npub ) )
{
TEST_ASSERT( mbedtls_mpi_read_string( &pub.N, radix_Npub, input_Npub ) == 0 );
}
if( strlen( input_Epub ) )
{
TEST_ASSERT( mbedtls_mpi_read_string( &pub.E, radix_Epub, input_Epub ) == 0 );
}
if( strlen( input_P ) )
{
TEST_ASSERT( mbedtls_mpi_read_string( &prv.P, radix_P, input_P ) == 0 );
}
if( strlen( input_Q ) )
{
TEST_ASSERT( mbedtls_mpi_read_string( &prv.Q, radix_Q, input_Q ) == 0 );
}
if( strlen( input_N ) )
{
TEST_ASSERT( mbedtls_mpi_read_string( &prv.N, radix_N, input_N ) == 0 );
}
if( strlen( input_E ) )
{
TEST_ASSERT( mbedtls_mpi_read_string( &prv.E, radix_E, input_E ) == 0 );
}
if( strlen( input_D ) )
{
TEST_ASSERT( mbedtls_mpi_read_string( &prv.D, radix_D, input_D ) == 0 );
}
#if !defined(MBEDTLS_RSA_NO_CRT)
if( strlen( input_DP ) )
{
TEST_ASSERT( mbedtls_mpi_read_string( &prv.DP, radix_DP, input_DP ) == 0 );
}
if( strlen( input_DQ ) )
{
TEST_ASSERT( mbedtls_mpi_read_string( &prv.DQ, radix_DQ, input_DQ ) == 0 );
}
if( strlen( input_QP ) )
{
TEST_ASSERT( mbedtls_mpi_read_string( &prv.QP, radix_QP, input_QP ) == 0 );
}
#else
((void) radix_DP); ((void) input_DP);
((void) radix_DQ); ((void) input_DQ);
((void) radix_QP); ((void) input_QP);
#endif
TEST_ASSERT( mbedtls_rsa_check_pub_priv( &pub, &prv ) == result );
exit:
mbedtls_rsa_free( &pub );
mbedtls_rsa_free( &prv );
}
void test_rsa_check_pubpriv_wrapper( void ** params )
{
test_rsa_check_pubpriv( *( (int *) params[0] ), *( (int *) params[1] ), (char *) params[2], *( (int *) params[3] ), (char *) params[4], *( (int *) params[5] ), (char *) params[6], *( (int *) params[7] ), (char *) params[8], *( (int *) params[9] ), (char *) params[10], *( (int *) params[11] ), (char *) params[12], *( (int *) params[13] ), (char *) params[14], *( (int *) params[15] ), (char *) params[16], *( (int *) params[17] ), (char *) params[18], *( (int *) params[19] ), (char *) params[20], *( (int *) params[21] ) );
}
#if defined(MBEDTLS_CTR_DRBG_C)
#if defined(MBEDTLS_ENTROPY_C)
#if defined(ENTROPY_HAVE_STRONG)
void test_mbedtls_rsa_gen_key( int nrbits, int exponent, int result)
{
mbedtls_rsa_context ctx;
mbedtls_entropy_context entropy;
mbedtls_ctr_drbg_context ctr_drbg;
const char *pers = "test_suite_rsa";
mbedtls_ctr_drbg_init( &ctr_drbg );
mbedtls_entropy_init( &entropy );
mbedtls_rsa_init ( &ctx, 0, 0 );
TEST_ASSERT( mbedtls_ctr_drbg_seed( &ctr_drbg, mbedtls_entropy_func,
&entropy, (const unsigned char *) pers,
strlen( pers ) ) == 0 );
TEST_ASSERT( mbedtls_rsa_gen_key( &ctx, mbedtls_ctr_drbg_random, &ctr_drbg, nrbits, exponent ) == result );
if( result == 0 )
{
TEST_ASSERT( mbedtls_rsa_check_privkey( &ctx ) == 0 );
TEST_ASSERT( mbedtls_mpi_cmp_mpi( &ctx.P, &ctx.Q ) > 0 );
}
exit:
mbedtls_rsa_free( &ctx );
mbedtls_ctr_drbg_free( &ctr_drbg );
mbedtls_entropy_free( &entropy );
}
void test_mbedtls_rsa_gen_key_wrapper( void ** params )
{
test_mbedtls_rsa_gen_key( *( (int *) params[0] ), *( (int *) params[1] ), *( (int *) params[2] ) );
}
#endif /* ENTROPY_HAVE_STRONG */
#endif /* MBEDTLS_ENTROPY_C */
#endif /* MBEDTLS_CTR_DRBG_C */
#if defined(MBEDTLS_CTR_DRBG_C)
#if defined(MBEDTLS_ENTROPY_C)
void test_mbedtls_rsa_deduce_primes( int radix_N, char *input_N,
int radix_D, char *input_D,
int radix_E, char *input_E,
int radix_P, char *output_P,
int radix_Q, char *output_Q,
int corrupt, int result )
{
mbedtls_mpi N, P, Pp, Q, Qp, D, E;
mbedtls_mpi_init( &N );
mbedtls_mpi_init( &P ); mbedtls_mpi_init( &Q );
mbedtls_mpi_init( &Pp ); mbedtls_mpi_init( &Qp );
mbedtls_mpi_init( &D ); mbedtls_mpi_init( &E );
TEST_ASSERT( mbedtls_mpi_read_string( &N, radix_N, input_N ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &D, radix_D, input_D ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &E, radix_E, input_E ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &Qp, radix_P, output_P ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &Pp, radix_Q, output_Q ) == 0 );
if( corrupt )
TEST_ASSERT( mbedtls_mpi_add_int( &D, &D, 2 ) == 0 );
/* Try to deduce P, Q from N, D, E only. */
TEST_ASSERT( mbedtls_rsa_deduce_primes( &N, &D, &E, &P, &Q ) == result );
if( !corrupt )
{
/* Check if (P,Q) = (Pp, Qp) or (P,Q) = (Qp, Pp) */
TEST_ASSERT( ( mbedtls_mpi_cmp_mpi( &P, &Pp ) == 0 && mbedtls_mpi_cmp_mpi( &Q, &Qp ) == 0 ) ||
( mbedtls_mpi_cmp_mpi( &P, &Qp ) == 0 && mbedtls_mpi_cmp_mpi( &Q, &Pp ) == 0 ) );
}
exit:
mbedtls_mpi_free( &N );
mbedtls_mpi_free( &P ); mbedtls_mpi_free( &Q );
mbedtls_mpi_free( &Pp ); mbedtls_mpi_free( &Qp );
mbedtls_mpi_free( &D ); mbedtls_mpi_free( &E );
}
void test_mbedtls_rsa_deduce_primes_wrapper( void ** params )
{
test_mbedtls_rsa_deduce_primes( *( (int *) params[0] ), (char *) params[1], *( (int *) params[2] ), (char *) params[3], *( (int *) params[4] ), (char *) params[5], *( (int *) params[6] ), (char *) params[7], *( (int *) params[8] ), (char *) params[9], *( (int *) params[10] ), *( (int *) params[11] ) );
}
#endif /* MBEDTLS_ENTROPY_C */
#endif /* MBEDTLS_CTR_DRBG_C */
void test_mbedtls_rsa_deduce_private_exponent( int radix_P, char *input_P,
int radix_Q, char *input_Q,
int radix_E, char *input_E,
int radix_D, char *output_D,
int corrupt, int result )
{
mbedtls_mpi P, Q, D, Dp, E, R, Rp;
mbedtls_mpi_init( &P ); mbedtls_mpi_init( &Q );
mbedtls_mpi_init( &D ); mbedtls_mpi_init( &Dp );
mbedtls_mpi_init( &E );
mbedtls_mpi_init( &R ); mbedtls_mpi_init( &Rp );
TEST_ASSERT( mbedtls_mpi_read_string( &P, radix_P, input_P ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &Q, radix_Q, input_Q ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &E, radix_E, input_E ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &Dp, radix_D, output_D ) == 0 );
if( corrupt )
{
/* Make E even */
TEST_ASSERT( mbedtls_mpi_set_bit( &E, 0, 0 ) == 0 );
}
/* Try to deduce D from N, P, Q, E. */
TEST_ASSERT( mbedtls_rsa_deduce_private_exponent( &P, &Q,
&E, &D ) == result );
if( !corrupt )
{
/*
* Check that D and Dp agree modulo LCM(P-1, Q-1).
*/
/* Replace P,Q by P-1, Q-1 */
TEST_ASSERT( mbedtls_mpi_sub_int( &P, &P, 1 ) == 0 );
TEST_ASSERT( mbedtls_mpi_sub_int( &Q, &Q, 1 ) == 0 );
/* Check D == Dp modulo P-1 */
TEST_ASSERT( mbedtls_mpi_mod_mpi( &R, &D, &P ) == 0 );
TEST_ASSERT( mbedtls_mpi_mod_mpi( &Rp, &Dp, &P ) == 0 );
TEST_ASSERT( mbedtls_mpi_cmp_mpi( &R, &Rp ) == 0 );
/* Check D == Dp modulo Q-1 */
TEST_ASSERT( mbedtls_mpi_mod_mpi( &R, &D, &Q ) == 0 );
TEST_ASSERT( mbedtls_mpi_mod_mpi( &Rp, &Dp, &Q ) == 0 );
TEST_ASSERT( mbedtls_mpi_cmp_mpi( &R, &Rp ) == 0 );
}
exit:
mbedtls_mpi_free( &P ); mbedtls_mpi_free( &Q );
mbedtls_mpi_free( &D ); mbedtls_mpi_free( &Dp );
mbedtls_mpi_free( &E );
mbedtls_mpi_free( &R ); mbedtls_mpi_free( &Rp );
}
void test_mbedtls_rsa_deduce_private_exponent_wrapper( void ** params )
{
test_mbedtls_rsa_deduce_private_exponent( *( (int *) params[0] ), (char *) params[1], *( (int *) params[2] ), (char *) params[3], *( (int *) params[4] ), (char *) params[5], *( (int *) params[6] ), (char *) params[7], *( (int *) params[8] ), *( (int *) params[9] ) );
}
#if defined(MBEDTLS_CTR_DRBG_C)
#if defined(MBEDTLS_ENTROPY_C)
#if defined(ENTROPY_HAVE_STRONG)
void test_mbedtls_rsa_import( int radix_N, char *input_N,
int radix_P, char *input_P,
int radix_Q, char *input_Q,
int radix_D, char *input_D,
int radix_E, char *input_E,
int successive,
int is_priv,
int res_check,
int res_complete )
{
mbedtls_mpi N, P, Q, D, E;
mbedtls_rsa_context ctx;
/* Buffers used for encryption-decryption test */
unsigned char *buf_orig = NULL;
unsigned char *buf_enc = NULL;
unsigned char *buf_dec = NULL;
mbedtls_entropy_context entropy;
mbedtls_ctr_drbg_context ctr_drbg;
const char *pers = "test_suite_rsa";
const int have_N = ( strlen( input_N ) > 0 );
const int have_P = ( strlen( input_P ) > 0 );
const int have_Q = ( strlen( input_Q ) > 0 );
const int have_D = ( strlen( input_D ) > 0 );
const int have_E = ( strlen( input_E ) > 0 );
mbedtls_ctr_drbg_init( &ctr_drbg );
mbedtls_entropy_init( &entropy );
mbedtls_rsa_init( &ctx, 0, 0 );
mbedtls_mpi_init( &N );
mbedtls_mpi_init( &P ); mbedtls_mpi_init( &Q );
mbedtls_mpi_init( &D ); mbedtls_mpi_init( &E );
TEST_ASSERT( mbedtls_ctr_drbg_seed( &ctr_drbg, mbedtls_entropy_func, &entropy,
(const unsigned char *) pers, strlen( pers ) ) == 0 );
if( have_N )
TEST_ASSERT( mbedtls_mpi_read_string( &N, radix_N, input_N ) == 0 );
if( have_P )
TEST_ASSERT( mbedtls_mpi_read_string( &P, radix_P, input_P ) == 0 );
if( have_Q )
TEST_ASSERT( mbedtls_mpi_read_string( &Q, radix_Q, input_Q ) == 0 );
if( have_D )
TEST_ASSERT( mbedtls_mpi_read_string( &D, radix_D, input_D ) == 0 );
if( have_E )
TEST_ASSERT( mbedtls_mpi_read_string( &E, radix_E, input_E ) == 0 );
if( !successive )
{
TEST_ASSERT( mbedtls_rsa_import( &ctx,
have_N ? &N : NULL,
have_P ? &P : NULL,
have_Q ? &Q : NULL,
have_D ? &D : NULL,
have_E ? &E : NULL ) == 0 );
}
else
{
/* Import N, P, Q, D, E separately.
* This should make no functional difference. */
TEST_ASSERT( mbedtls_rsa_import( &ctx,
have_N ? &N : NULL,
NULL, NULL, NULL, NULL ) == 0 );
TEST_ASSERT( mbedtls_rsa_import( &ctx,
NULL,
have_P ? &P : NULL,
NULL, NULL, NULL ) == 0 );
TEST_ASSERT( mbedtls_rsa_import( &ctx,
NULL, NULL,
have_Q ? &Q : NULL,
NULL, NULL ) == 0 );
TEST_ASSERT( mbedtls_rsa_import( &ctx,
NULL, NULL, NULL,
have_D ? &D : NULL,
NULL ) == 0 );
TEST_ASSERT( mbedtls_rsa_import( &ctx,
NULL, NULL, NULL, NULL,
have_E ? &E : NULL ) == 0 );
}
TEST_ASSERT( mbedtls_rsa_complete( &ctx ) == res_complete );
/* On expected success, perform some public and private
* key operations to check if the key is working properly. */
if( res_complete == 0 )
{
if( is_priv )
TEST_ASSERT( mbedtls_rsa_check_privkey( &ctx ) == res_check );
else
TEST_ASSERT( mbedtls_rsa_check_pubkey( &ctx ) == res_check );
if( res_check != 0 )
goto exit;
buf_orig = mbedtls_calloc( 1, mbedtls_rsa_get_len( &ctx ) );
buf_enc = mbedtls_calloc( 1, mbedtls_rsa_get_len( &ctx ) );
buf_dec = mbedtls_calloc( 1, mbedtls_rsa_get_len( &ctx ) );
if( buf_orig == NULL || buf_enc == NULL || buf_dec == NULL )
goto exit;
TEST_ASSERT( mbedtls_ctr_drbg_random( &ctr_drbg,
buf_orig, mbedtls_rsa_get_len( &ctx ) ) == 0 );
/* Make sure the number we're generating is smaller than the modulus */
buf_orig[0] = 0x00;
TEST_ASSERT( mbedtls_rsa_public( &ctx, buf_orig, buf_enc ) == 0 );
if( is_priv )
{
TEST_ASSERT( mbedtls_rsa_private( &ctx, mbedtls_ctr_drbg_random,
&ctr_drbg, buf_enc,
buf_dec ) == 0 );
TEST_ASSERT( memcmp( buf_orig, buf_dec,
mbedtls_rsa_get_len( &ctx ) ) == 0 );
}
}
exit:
mbedtls_free( buf_orig );
mbedtls_free( buf_enc );
mbedtls_free( buf_dec );
mbedtls_rsa_free( &ctx );
mbedtls_ctr_drbg_free( &ctr_drbg );
mbedtls_entropy_free( &entropy );
mbedtls_mpi_free( &N );
mbedtls_mpi_free( &P ); mbedtls_mpi_free( &Q );
mbedtls_mpi_free( &D ); mbedtls_mpi_free( &E );
}
void test_mbedtls_rsa_import_wrapper( void ** params )
{
test_mbedtls_rsa_import( *( (int *) params[0] ), (char *) params[1], *( (int *) params[2] ), (char *) params[3], *( (int *) params[4] ), (char *) params[5], *( (int *) params[6] ), (char *) params[7], *( (int *) params[8] ), (char *) params[9], *( (int *) params[10] ), *( (int *) params[11] ), *( (int *) params[12] ), *( (int *) params[13] ) );
}
#endif /* ENTROPY_HAVE_STRONG */
#endif /* MBEDTLS_ENTROPY_C */
#endif /* MBEDTLS_CTR_DRBG_C */
void test_mbedtls_rsa_export( int radix_N, char *input_N,
int radix_P, char *input_P,
int radix_Q, char *input_Q,
int radix_D, char *input_D,
int radix_E, char *input_E,
int is_priv,
int successive )
{
/* Original MPI's with which we set up the RSA context */
mbedtls_mpi N, P, Q, D, E;
/* Exported MPI's */
mbedtls_mpi Ne, Pe, Qe, De, Ee;
const int have_N = ( strlen( input_N ) > 0 );
const int have_P = ( strlen( input_P ) > 0 );
const int have_Q = ( strlen( input_Q ) > 0 );
const int have_D = ( strlen( input_D ) > 0 );
const int have_E = ( strlen( input_E ) > 0 );
mbedtls_rsa_context ctx;
mbedtls_rsa_init( &ctx, 0, 0 );
mbedtls_mpi_init( &N );
mbedtls_mpi_init( &P ); mbedtls_mpi_init( &Q );
mbedtls_mpi_init( &D ); mbedtls_mpi_init( &E );
mbedtls_mpi_init( &Ne );
mbedtls_mpi_init( &Pe ); mbedtls_mpi_init( &Qe );
mbedtls_mpi_init( &De ); mbedtls_mpi_init( &Ee );
/* Setup RSA context */
if( have_N )
TEST_ASSERT( mbedtls_mpi_read_string( &N, radix_N, input_N ) == 0 );
if( have_P )
TEST_ASSERT( mbedtls_mpi_read_string( &P, radix_P, input_P ) == 0 );
if( have_Q )
TEST_ASSERT( mbedtls_mpi_read_string( &Q, radix_Q, input_Q ) == 0 );
if( have_D )
TEST_ASSERT( mbedtls_mpi_read_string( &D, radix_D, input_D ) == 0 );
if( have_E )
TEST_ASSERT( mbedtls_mpi_read_string( &E, radix_E, input_E ) == 0 );
TEST_ASSERT( mbedtls_rsa_import( &ctx,
strlen( input_N ) ? &N : NULL,
strlen( input_P ) ? &P : NULL,
strlen( input_Q ) ? &Q : NULL,
strlen( input_D ) ? &D : NULL,
strlen( input_E ) ? &E : NULL ) == 0 );
TEST_ASSERT( mbedtls_rsa_complete( &ctx ) == 0 );
/*
* Export parameters and compare to original ones.
*/
/* N and E must always be present. */
if( !successive )
{
TEST_ASSERT( mbedtls_rsa_export( &ctx, &Ne, NULL, NULL, NULL, &Ee ) == 0 );
}
else
{
TEST_ASSERT( mbedtls_rsa_export( &ctx, &Ne, NULL, NULL, NULL, NULL ) == 0 );
TEST_ASSERT( mbedtls_rsa_export( &ctx, NULL, NULL, NULL, NULL, &Ee ) == 0 );
}
TEST_ASSERT( mbedtls_mpi_cmp_mpi( &N, &Ne ) == 0 );
TEST_ASSERT( mbedtls_mpi_cmp_mpi( &E, &Ee ) == 0 );
/* If we were providing enough information to setup a complete private context,
* we expect to be able to export all core parameters. */
if( is_priv )
{
if( !successive )
{
TEST_ASSERT( mbedtls_rsa_export( &ctx, NULL, &Pe, &Qe,
&De, NULL ) == 0 );
}
else
{
TEST_ASSERT( mbedtls_rsa_export( &ctx, NULL, &Pe, NULL,
NULL, NULL ) == 0 );
TEST_ASSERT( mbedtls_rsa_export( &ctx, NULL, NULL, &Qe,
NULL, NULL ) == 0 );
TEST_ASSERT( mbedtls_rsa_export( &ctx, NULL, NULL, NULL,
&De, NULL ) == 0 );
}
if( have_P )
TEST_ASSERT( mbedtls_mpi_cmp_mpi( &P, &Pe ) == 0 );
if( have_Q )
TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Q, &Qe ) == 0 );
if( have_D )
TEST_ASSERT( mbedtls_mpi_cmp_mpi( &D, &De ) == 0 );
/* While at it, perform a sanity check */
TEST_ASSERT( mbedtls_rsa_validate_params( &Ne, &Pe, &Qe, &De, &Ee,
NULL, NULL ) == 0 );
}
exit:
mbedtls_rsa_free( &ctx );
mbedtls_mpi_free( &N );
mbedtls_mpi_free( &P ); mbedtls_mpi_free( &Q );
mbedtls_mpi_free( &D ); mbedtls_mpi_free( &E );
mbedtls_mpi_free( &Ne );
mbedtls_mpi_free( &Pe ); mbedtls_mpi_free( &Qe );
mbedtls_mpi_free( &De ); mbedtls_mpi_free( &Ee );
}
void test_mbedtls_rsa_export_wrapper( void ** params )
{
test_mbedtls_rsa_export( *( (int *) params[0] ), (char *) params[1], *( (int *) params[2] ), (char *) params[3], *( (int *) params[4] ), (char *) params[5], *( (int *) params[6] ), (char *) params[7], *( (int *) params[8] ), (char *) params[9], *( (int *) params[10] ), *( (int *) params[11] ) );
}
#if defined(MBEDTLS_ENTROPY_C)
#if defined(ENTROPY_HAVE_STRONG)
#if defined(MBEDTLS_ENTROPY_C)
#if defined(MBEDTLS_CTR_DRBG_C)
void test_mbedtls_rsa_validate_params( int radix_N, char *input_N,
int radix_P, char *input_P,
int radix_Q, char *input_Q,
int radix_D, char *input_D,
int radix_E, char *input_E,
int prng, int result )
{
/* Original MPI's with which we set up the RSA context */
mbedtls_mpi N, P, Q, D, E;
const int have_N = ( strlen( input_N ) > 0 );
const int have_P = ( strlen( input_P ) > 0 );
const int have_Q = ( strlen( input_Q ) > 0 );
const int have_D = ( strlen( input_D ) > 0 );
const int have_E = ( strlen( input_E ) > 0 );
mbedtls_entropy_context entropy;
mbedtls_ctr_drbg_context ctr_drbg;
const char *pers = "test_suite_rsa";
mbedtls_mpi_init( &N );
mbedtls_mpi_init( &P ); mbedtls_mpi_init( &Q );
mbedtls_mpi_init( &D ); mbedtls_mpi_init( &E );
mbedtls_ctr_drbg_init( &ctr_drbg );
mbedtls_entropy_init( &entropy );
TEST_ASSERT( mbedtls_ctr_drbg_seed( &ctr_drbg, mbedtls_entropy_func,
&entropy, (const unsigned char *) pers,
strlen( pers ) ) == 0 );
if( have_N )
TEST_ASSERT( mbedtls_mpi_read_string( &N, radix_N, input_N ) == 0 );
if( have_P )
TEST_ASSERT( mbedtls_mpi_read_string( &P, radix_P, input_P ) == 0 );
if( have_Q )
TEST_ASSERT( mbedtls_mpi_read_string( &Q, radix_Q, input_Q ) == 0 );
if( have_D )
TEST_ASSERT( mbedtls_mpi_read_string( &D, radix_D, input_D ) == 0 );
if( have_E )
TEST_ASSERT( mbedtls_mpi_read_string( &E, radix_E, input_E ) == 0 );
TEST_ASSERT( mbedtls_rsa_validate_params( have_N ? &N : NULL,
have_P ? &P : NULL,
have_Q ? &Q : NULL,
have_D ? &D : NULL,
have_E ? &E : NULL,
prng ? mbedtls_ctr_drbg_random : NULL,
prng ? &ctr_drbg : NULL ) == result );
exit:
mbedtls_ctr_drbg_free( &ctr_drbg );
mbedtls_entropy_free( &entropy );
mbedtls_mpi_free( &N );
mbedtls_mpi_free( &P ); mbedtls_mpi_free( &Q );
mbedtls_mpi_free( &D ); mbedtls_mpi_free( &E );
}
void test_mbedtls_rsa_validate_params_wrapper( void ** params )
{
test_mbedtls_rsa_validate_params( *( (int *) params[0] ), (char *) params[1], *( (int *) params[2] ), (char *) params[3], *( (int *) params[4] ), (char *) params[5], *( (int *) params[6] ), (char *) params[7], *( (int *) params[8] ), (char *) params[9], *( (int *) params[10] ), *( (int *) params[11] ) );
}
#endif /* MBEDTLS_CTR_DRBG_C */
#endif /* MBEDTLS_ENTROPY_C */
#endif /* ENTROPY_HAVE_STRONG */
#endif /* MBEDTLS_ENTROPY_C */
#if defined(MBEDTLS_CTR_DRBG_C)
#if defined(MBEDTLS_ENTROPY_C)
void test_mbedtls_rsa_export_raw( data_t *input_N, data_t *input_P,
data_t *input_Q, data_t *input_D,
data_t *input_E, int is_priv,
int successive )
{
/* Exported buffers */
unsigned char bufNe[256];
unsigned char bufPe[128];
unsigned char bufQe[128];
unsigned char bufDe[256];
unsigned char bufEe[1];
mbedtls_rsa_context ctx;
mbedtls_rsa_init( &ctx, 0, 0 );
/* Setup RSA context */
TEST_ASSERT( mbedtls_rsa_import_raw( &ctx,
input_N->len ? input_N->x : NULL, input_N->len,
input_P->len ? input_P->x : NULL, input_P->len,
input_Q->len ? input_Q->x : NULL, input_Q->len,
input_D->len ? input_D->x : NULL, input_D->len,
input_E->len ? input_E->x : NULL, input_E->len ) == 0 );
TEST_ASSERT( mbedtls_rsa_complete( &ctx ) == 0 );
/*
* Export parameters and compare to original ones.
*/
/* N and E must always be present. */
if( !successive )
{
TEST_ASSERT( mbedtls_rsa_export_raw( &ctx, bufNe, input_N->len,
NULL, 0, NULL, 0, NULL, 0,
bufEe, input_E->len ) == 0 );
}
else
{
TEST_ASSERT( mbedtls_rsa_export_raw( &ctx, bufNe, input_N->len,
NULL, 0, NULL, 0, NULL, 0,
NULL, 0 ) == 0 );
TEST_ASSERT( mbedtls_rsa_export_raw( &ctx, NULL, 0,
NULL, 0, NULL, 0, NULL, 0,
bufEe, input_E->len ) == 0 );
}
TEST_ASSERT( memcmp( input_N->x, bufNe, input_N->len ) == 0 );
TEST_ASSERT( memcmp( input_E->x, bufEe, input_E->len ) == 0 );
/* If we were providing enough information to setup a complete private context,
* we expect to be able to export all core parameters. */
if( is_priv )
{
if( !successive )
{
TEST_ASSERT( mbedtls_rsa_export_raw( &ctx, NULL, 0,
bufPe, input_P->len ? input_P->len : sizeof( bufPe ),
bufQe, input_Q->len ? input_Q->len : sizeof( bufQe ),
bufDe, input_D->len ? input_D->len : sizeof( bufDe ),
NULL, 0 ) == 0 );
}
else
{
TEST_ASSERT( mbedtls_rsa_export_raw( &ctx, NULL, 0,
bufPe, input_P->len ? input_P->len : sizeof( bufPe ),
NULL, 0, NULL, 0,
NULL, 0 ) == 0 );
TEST_ASSERT( mbedtls_rsa_export_raw( &ctx, NULL, 0, NULL, 0,
bufQe, input_Q->len ? input_Q->len : sizeof( bufQe ),
NULL, 0, NULL, 0 ) == 0 );
TEST_ASSERT( mbedtls_rsa_export_raw( &ctx, NULL, 0, NULL, 0, NULL, 0,
bufDe, input_D->len ? input_D->len : sizeof( bufDe ),
NULL, 0 ) == 0 );
}
if( input_P->len )
TEST_ASSERT( memcmp( input_P->x, bufPe, input_P->len ) == 0 );
if( input_Q->len )
TEST_ASSERT( memcmp( input_Q->x, bufQe, input_Q->len ) == 0 );
if( input_D->len )
TEST_ASSERT( memcmp( input_D->x, bufDe, input_D->len ) == 0 );
}
exit:
mbedtls_rsa_free( &ctx );
}
void test_mbedtls_rsa_export_raw_wrapper( void ** params )
{
data_t data0 = {(uint8_t *) params[0], *( (uint32_t *) params[1] )};
data_t data2 = {(uint8_t *) params[2], *( (uint32_t *) params[3] )};
data_t data4 = {(uint8_t *) params[4], *( (uint32_t *) params[5] )};
data_t data6 = {(uint8_t *) params[6], *( (uint32_t *) params[7] )};
data_t data8 = {(uint8_t *) params[8], *( (uint32_t *) params[9] )};
test_mbedtls_rsa_export_raw( &data0, &data2, &data4, &data6, &data8, *( (int *) params[10] ), *( (int *) params[11] ) );
}
#endif /* MBEDTLS_ENTROPY_C */
#endif /* MBEDTLS_CTR_DRBG_C */
#if defined(MBEDTLS_CTR_DRBG_C)
#if defined(MBEDTLS_ENTROPY_C)
#if defined(ENTROPY_HAVE_STRONG)
void test_mbedtls_rsa_import_raw( data_t *input_N,
data_t *input_P, data_t *input_Q,
data_t *input_D, data_t *input_E,
int successive,
int is_priv,
int res_check,
int res_complete )
{
/* Buffers used for encryption-decryption test */
unsigned char *buf_orig = NULL;
unsigned char *buf_enc = NULL;
unsigned char *buf_dec = NULL;
mbedtls_rsa_context ctx;
mbedtls_entropy_context entropy;
mbedtls_ctr_drbg_context ctr_drbg;
const char *pers = "test_suite_rsa";
mbedtls_ctr_drbg_init( &ctr_drbg );
mbedtls_entropy_init( &entropy );
mbedtls_rsa_init( &ctx, 0, 0 );
TEST_ASSERT( mbedtls_ctr_drbg_seed( &ctr_drbg, mbedtls_entropy_func,
&entropy, (const unsigned char *) pers,
strlen( pers ) ) == 0 );
if( !successive )
{
TEST_ASSERT( mbedtls_rsa_import_raw( &ctx,
( input_N->len > 0 ) ? input_N->x : NULL, input_N->len,
( input_P->len > 0 ) ? input_P->x : NULL, input_P->len,
( input_Q->len > 0 ) ? input_Q->x : NULL, input_Q->len,
( input_D->len > 0 ) ? input_D->x : NULL, input_D->len,
( input_E->len > 0 ) ? input_E->x : NULL, input_E->len ) == 0 );
}
else
{
/* Import N, P, Q, D, E separately.
* This should make no functional difference. */
TEST_ASSERT( mbedtls_rsa_import_raw( &ctx,
( input_N->len > 0 ) ? input_N->x : NULL, input_N->len,
NULL, 0, NULL, 0, NULL, 0, NULL, 0 ) == 0 );
TEST_ASSERT( mbedtls_rsa_import_raw( &ctx,
NULL, 0,
( input_P->len > 0 ) ? input_P->x : NULL, input_P->len,
NULL, 0, NULL, 0, NULL, 0 ) == 0 );
TEST_ASSERT( mbedtls_rsa_import_raw( &ctx,
NULL, 0, NULL, 0,
( input_Q->len > 0 ) ? input_Q->x : NULL, input_Q->len,
NULL, 0, NULL, 0 ) == 0 );
TEST_ASSERT( mbedtls_rsa_import_raw( &ctx,
NULL, 0, NULL, 0, NULL, 0,
( input_D->len > 0 ) ? input_D->x : NULL, input_D->len,
NULL, 0 ) == 0 );
TEST_ASSERT( mbedtls_rsa_import_raw( &ctx,
NULL, 0, NULL, 0, NULL, 0, NULL, 0,
( input_E->len > 0 ) ? input_E->x : NULL, input_E->len ) == 0 );
}
TEST_ASSERT( mbedtls_rsa_complete( &ctx ) == res_complete );
/* On expected success, perform some public and private
* key operations to check if the key is working properly. */
if( res_complete == 0 )
{
if( is_priv )
TEST_ASSERT( mbedtls_rsa_check_privkey( &ctx ) == res_check );
else
TEST_ASSERT( mbedtls_rsa_check_pubkey( &ctx ) == res_check );
if( res_check != 0 )
goto exit;
buf_orig = mbedtls_calloc( 1, mbedtls_rsa_get_len( &ctx ) );
buf_enc = mbedtls_calloc( 1, mbedtls_rsa_get_len( &ctx ) );
buf_dec = mbedtls_calloc( 1, mbedtls_rsa_get_len( &ctx ) );
if( buf_orig == NULL || buf_enc == NULL || buf_dec == NULL )
goto exit;
TEST_ASSERT( mbedtls_ctr_drbg_random( &ctr_drbg,
buf_orig, mbedtls_rsa_get_len( &ctx ) ) == 0 );
/* Make sure the number we're generating is smaller than the modulus */
buf_orig[0] = 0x00;
TEST_ASSERT( mbedtls_rsa_public( &ctx, buf_orig, buf_enc ) == 0 );
if( is_priv )
{
TEST_ASSERT( mbedtls_rsa_private( &ctx, mbedtls_ctr_drbg_random,
&ctr_drbg, buf_enc,
buf_dec ) == 0 );
TEST_ASSERT( memcmp( buf_orig, buf_dec,
mbedtls_rsa_get_len( &ctx ) ) == 0 );
}
}
exit:
mbedtls_free( buf_orig );
mbedtls_free( buf_enc );
mbedtls_free( buf_dec );
mbedtls_rsa_free( &ctx );
mbedtls_ctr_drbg_free( &ctr_drbg );
mbedtls_entropy_free( &entropy );
}
void test_mbedtls_rsa_import_raw_wrapper( void ** params )
{
data_t data0 = {(uint8_t *) params[0], *( (uint32_t *) params[1] )};
data_t data2 = {(uint8_t *) params[2], *( (uint32_t *) params[3] )};
data_t data4 = {(uint8_t *) params[4], *( (uint32_t *) params[5] )};
data_t data6 = {(uint8_t *) params[6], *( (uint32_t *) params[7] )};
data_t data8 = {(uint8_t *) params[8], *( (uint32_t *) params[9] )};
test_mbedtls_rsa_import_raw( &data0, &data2, &data4, &data6, &data8, *( (int *) params[10] ), *( (int *) params[11] ), *( (int *) params[12] ), *( (int *) params[13] ) );
}
#endif /* ENTROPY_HAVE_STRONG */
#endif /* MBEDTLS_ENTROPY_C */
#endif /* MBEDTLS_CTR_DRBG_C */
#if defined(MBEDTLS_SELF_TEST)
void test_rsa_selftest( )
{
TEST_ASSERT( mbedtls_rsa_self_test( 1 ) == 0 );
exit:
;
}
void test_rsa_selftest_wrapper( void ** params )
{
(void)params;
test_rsa_selftest( );
}
#endif /* MBEDTLS_SELF_TEST */
#endif /* MBEDTLS_GENPRIME */
#endif /* MBEDTLS_BIGNUM_C */
#endif /* MBEDTLS_RSA_C */
/*----------------------------------------------------------------------------*/
/* Test dispatch code */
/**
* \brief Evaluates an expression/macro into its literal integer value.
* For optimizing space for embedded targets each expression/macro
* is identified by a unique identifier instead of string literals.
* Identifiers and evaluation code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param exp_id Expression identifier.
* \param out_value Pointer to int to hold the integer.
*
* \return 0 if exp_id is found. 1 otherwise.
*/
int get_expression( int32_t exp_id, int32_t * out_value )
{
int ret = KEY_VALUE_MAPPING_FOUND;
(void) exp_id;
(void) out_value;
switch( exp_id )
{
#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_GENPRIME)
case 0:
{
*out_value = MBEDTLS_RSA_PKCS_V15;
}
break;
case 1:
{
*out_value = MBEDTLS_MD_SHA1;
}
break;
case 2:
{
*out_value = MBEDTLS_ERR_RSA_VERIFY_FAILED;
}
break;
case 3:
{
*out_value = MBEDTLS_MD_SHA224;
}
break;
case 4:
{
*out_value = MBEDTLS_MD_SHA256;
}
break;
case 5:
{
*out_value = MBEDTLS_MD_SHA384;
}
break;
case 6:
{
*out_value = MBEDTLS_MD_SHA512;
}
break;
case 7:
{
*out_value = MBEDTLS_MD_MD2;
}
break;
case 8:
{
*out_value = MBEDTLS_MD_MD4;
}
break;
case 9:
{
*out_value = MBEDTLS_MD_MD5;
}
break;
case 10:
{
*out_value = MBEDTLS_ERR_RSA_BAD_INPUT_DATA;
}
break;
case 11:
{
*out_value = MBEDTLS_MD_RIPEMD160;
}
break;
case 12:
{
*out_value = MBEDTLS_ERR_RSA_PRIVATE_FAILED + MBEDTLS_ERR_MPI_BAD_INPUT_DATA;
}
break;
case 13:
{
*out_value = MBEDTLS_ERR_RSA_OUTPUT_TOO_LARGE;
}
break;
case 14:
{
*out_value = MBEDTLS_ERR_RSA_KEY_CHECK_FAILED;
}
break;
case 15:
{
*out_value = MBEDTLS_ERR_RSA_PUBLIC_FAILED + MBEDTLS_ERR_MPI_BAD_INPUT_DATA;
}
break;
case 16:
{
*out_value = MBEDTLS_ERR_MPI_NOT_ACCEPTABLE;
}
break;
case 17:
{
*out_value = MBEDTLS_ERR_MPI_BAD_INPUT_DATA;
}
break;
case 18:
{
*out_value = MBEDTLS_ERR_RSA_RNG_FAILED;
}
break;
#endif
default:
{
ret = KEY_VALUE_MAPPING_NOT_FOUND;
}
break;
}
return( ret );
}
/**
* \brief Checks if the dependency i.e. the compile flag is set.
* For optimizing space for embedded targets each dependency
* is identified by a unique identifier instead of string literals.
* Identifiers and check code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param dep_id Dependency identifier.
*
* \return DEPENDENCY_SUPPORTED if set else DEPENDENCY_NOT_SUPPORTED
*/
int dep_check( int dep_id )
{
int ret = DEPENDENCY_NOT_SUPPORTED;
(void) dep_id;
switch( dep_id )
{
#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_GENPRIME)
case 0:
{
#if defined(MBEDTLS_SHA1_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 1:
{
#if defined(MBEDTLS_PKCS1_V15)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 2:
{
#if defined(MBEDTLS_SHA256_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 3:
{
#if defined(MBEDTLS_SHA512_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 4:
{
#if !defined(MBEDTLS_SHA512_NO_SHA384)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 5:
{
#if defined(MBEDTLS_MD2_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 6:
{
#if defined(MBEDTLS_MD4_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 7:
{
#if defined(MBEDTLS_MD5_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 8:
{
#if defined(MBEDTLS_RIPEMD160_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 9:
{
#if !defined(MBEDTLS_RSA_NO_CRT)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 10:
{
#if (MBEDTLS_MPI_MAX_SIZE>=1024)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 11:
{
#if defined(MBEDTLS_SELF_TEST)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
#endif
default:
break;
}
return( ret );
}
/**
* \brief Function pointer type for test function wrappers.
*
* A test function wrapper decodes the parameters and passes them to the
* underlying test function. Both the wrapper and the underlying function
* return void. Test wrappers assume that they are passed a suitable
* parameter array and do not perform any error detection.
*
* \param param_array The array of parameters. Each element is a `void *`
* which the wrapper casts to the correct type and
* dereferences. Each wrapper function hard-codes the
* number and types of the parameters.
*/
typedef void (*TestWrapper_t)( void **param_array );
/**
* \brief Table of test function wrappers. Used by dispatch_test().
* This table is populated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
*/
TestWrapper_t test_funcs[] =
{
/* Function Id: 0 */
#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_GENPRIME) && defined(MBEDTLS_CHECK_PARAMS) && !defined(MBEDTLS_PARAM_FAILED_ALT)
test_rsa_invalid_param_wrapper,
#else
NULL,
#endif
/* Function Id: 1 */
#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_GENPRIME)
test_rsa_init_free_wrapper,
#else
NULL,
#endif
/* Function Id: 2 */
#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_GENPRIME)
test_mbedtls_rsa_pkcs1_sign_wrapper,
#else
NULL,
#endif
/* Function Id: 3 */
#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_GENPRIME)
test_mbedtls_rsa_pkcs1_verify_wrapper,
#else
NULL,
#endif
/* Function Id: 4 */
#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_GENPRIME)
test_rsa_pkcs1_sign_raw_wrapper,
#else
NULL,
#endif
/* Function Id: 5 */
#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_GENPRIME)
test_rsa_pkcs1_verify_raw_wrapper,
#else
NULL,
#endif
/* Function Id: 6 */
#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_GENPRIME)
test_mbedtls_rsa_pkcs1_encrypt_wrapper,
#else
NULL,
#endif
/* Function Id: 7 */
#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_GENPRIME)
test_rsa_pkcs1_encrypt_bad_rng_wrapper,
#else
NULL,
#endif
/* Function Id: 8 */
#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_GENPRIME)
test_mbedtls_rsa_pkcs1_decrypt_wrapper,
#else
NULL,
#endif
/* Function Id: 9 */
#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_GENPRIME)
test_mbedtls_rsa_public_wrapper,
#else
NULL,
#endif
/* Function Id: 10 */
#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_GENPRIME)
test_mbedtls_rsa_private_wrapper,
#else
NULL,
#endif
/* Function Id: 11 */
#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_GENPRIME)
test_rsa_check_privkey_null_wrapper,
#else
NULL,
#endif
/* Function Id: 12 */
#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_GENPRIME)
test_mbedtls_rsa_check_pubkey_wrapper,
#else
NULL,
#endif
/* Function Id: 13 */
#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_GENPRIME)
test_mbedtls_rsa_check_privkey_wrapper,
#else
NULL,
#endif
/* Function Id: 14 */
#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_GENPRIME)
test_rsa_check_pubpriv_wrapper,
#else
NULL,
#endif
/* Function Id: 15 */
#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_GENPRIME) && defined(MBEDTLS_CTR_DRBG_C) && defined(MBEDTLS_ENTROPY_C) && defined(ENTROPY_HAVE_STRONG)
test_mbedtls_rsa_gen_key_wrapper,
#else
NULL,
#endif
/* Function Id: 16 */
#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_GENPRIME) && defined(MBEDTLS_CTR_DRBG_C) && defined(MBEDTLS_ENTROPY_C)
test_mbedtls_rsa_deduce_primes_wrapper,
#else
NULL,
#endif
/* Function Id: 17 */
#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_GENPRIME)
test_mbedtls_rsa_deduce_private_exponent_wrapper,
#else
NULL,
#endif
/* Function Id: 18 */
#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_GENPRIME) && defined(MBEDTLS_CTR_DRBG_C) && defined(MBEDTLS_ENTROPY_C) && defined(ENTROPY_HAVE_STRONG)
test_mbedtls_rsa_import_wrapper,
#else
NULL,
#endif
/* Function Id: 19 */
#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_GENPRIME)
test_mbedtls_rsa_export_wrapper,
#else
NULL,
#endif
/* Function Id: 20 */
#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_GENPRIME) && defined(MBEDTLS_ENTROPY_C) && defined(ENTROPY_HAVE_STRONG) && defined(MBEDTLS_ENTROPY_C) && defined(MBEDTLS_CTR_DRBG_C)
test_mbedtls_rsa_validate_params_wrapper,
#else
NULL,
#endif
/* Function Id: 21 */
#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_GENPRIME) && defined(MBEDTLS_CTR_DRBG_C) && defined(MBEDTLS_ENTROPY_C)
test_mbedtls_rsa_export_raw_wrapper,
#else
NULL,
#endif
/* Function Id: 22 */
#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_GENPRIME) && defined(MBEDTLS_CTR_DRBG_C) && defined(MBEDTLS_ENTROPY_C) && defined(ENTROPY_HAVE_STRONG)
test_mbedtls_rsa_import_raw_wrapper,
#else
NULL,
#endif
/* Function Id: 23 */
#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_GENPRIME) && defined(MBEDTLS_SELF_TEST)
test_rsa_selftest_wrapper,
#else
NULL,
#endif
};
/**
* \brief Execute the test function.
*
* This is a wrapper function around the test function execution
* to allow the setjmp() call used to catch any calls to the
* parameter failure callback, to be used. Calls to setjmp()
* can invalidate the state of any local auto variables.
*
* \param fp Function pointer to the test function.
* \param params Parameters to pass to the #TestWrapper_t wrapper function.
*
*/
void execute_function_ptr(TestWrapper_t fp, void **params)
{
#if defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG)
mbedtls_test_enable_insecure_external_rng( );
#endif
#if defined(MBEDTLS_CHECK_PARAMS)
mbedtls_test_param_failed_location_record_t location_record;
if ( setjmp( mbedtls_test_param_failed_get_state_buf( ) ) == 0 )
{
fp( params );
}
else
{
/* Unexpected parameter validation error */
mbedtls_test_param_failed_get_location_record( &location_record );
mbedtls_test_fail( location_record.failure_condition,
location_record.line,
location_record.file );
}
mbedtls_test_param_failed_reset_state( );
#else
fp( params );
#endif
#if defined(MBEDTLS_TEST_MUTEX_USAGE)
mbedtls_test_mutex_usage_check( );
#endif /* MBEDTLS_TEST_MUTEX_USAGE */
}
/**
* \brief Dispatches test functions based on function index.
*
* \param func_idx Test function index.
* \param params The array of parameters to pass to the test function.
* It will be decoded by the #TestWrapper_t wrapper function.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int dispatch_test( size_t func_idx, void ** params )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof( test_funcs ) / sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp )
execute_function_ptr(fp, params);
else
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
/**
* \brief Checks if test function is supported in this build-time
* configuration.
*
* \param func_idx Test function index.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int check_test( size_t func_idx )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof(test_funcs)/sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp == NULL )
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
int main( int argc, const char *argv[] )
{
int ret;
mbedtls_test_platform_setup();
ret = execute_tests( argc, argv, "/zip/third_party/mbedtls/test/test_suite_rsa.datax" );
mbedtls_test_platform_teardown();
return( ret );
}
| 104,925 | 2,608 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_aes.ofb.datax | OFB-AES128.Encrypt - Single block
depends_on:0
12:int:16:hex:"2b7e151628aed2a6abf7158809cf4f3c":hex:"000102030405060708090a0b0c0d0e0f":hex:"6bc1bee22e409f96e93d7e117393172a":hex:"3b3fd92eb72dad20333449f8e83cfb4a"
OFB-AES128.Encrypt - Partial blocks - 7 bytes
depends_on:0
12:int:5:hex:"2b7e151628aed2a6abf7158809cf4f3c":hex:"000102030405060708090a0b0c0d0e0f":hex:"6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710":hex:"3b3fd92eb72dad20333449f8e83cfb4a7789508d16918f03f53c52dac54ed8259740051e9c5fecf64344f7a82260edcc304c6528f659c77866a510d9c1d6ae5e"
OFB-AES128.Encrypt - Test NIST SP800-38A - F.4.1
depends_on:0
12:int:16:hex:"2b7e151628aed2a6abf7158809cf4f3c":hex:"000102030405060708090a0b0c0d0e0f":hex:"6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710":hex:"3b3fd92eb72dad20333449f8e83cfb4a7789508d16918f03f53c52dac54ed8259740051e9c5fecf64344f7a82260edcc304c6528f659c77866a510d9c1d6ae5e"
OFB-AES128.Decrypt - Test NIST SP800-38A - F.4.2
depends_on:0
12:int:16:hex:"2b7e151628aed2a6abf7158809cf4f3c":hex:"000102030405060708090a0b0c0d0e0f":hex:"3b3fd92eb72dad20333449f8e83cfb4a7789508d16918f03f53c52dac54ed8259740051e9c5fecf64344f7a82260edcc304c6528f659c77866a510d9c1d6ae5e":hex:"6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710"
OFB-AES192.Encrypt - Test NIST SP800-38A - F.4.3
depends_on:0
12:int:16:hex:"8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b":hex:"000102030405060708090a0b0c0d0e0f":hex:"6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710":hex:"cdc80d6fddf18cab34c25909c99a4174fcc28b8d4c63837c09e81700c11004018d9a9aeac0f6596f559c6d4daf59a5f26d9f200857ca6c3e9cac524bd9acc92a"
OFB-AES192.Decrypt - Test NIST SP800-38A - F.4.4
depends_on:0
12:int:16:hex:"8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b":hex:"000102030405060708090a0b0c0d0e0f":hex:"cdc80d6fddf18cab34c25909c99a4174fcc28b8d4c63837c09e81700c11004018d9a9aeac0f6596f559c6d4daf59a5f26d9f200857ca6c3e9cac524bd9acc92a":hex:"6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710"
OFB-AES256.Encrypt - Test NIST SP800-38A - F.4.5
depends_on:0
12:int:16:hex:"603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4":hex:"000102030405060708090a0b0c0d0e0f":hex:"6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710":hex:"dc7e84bfda79164b7ecd8486985d38604febdc6740d20b3ac88f6ad82a4fb08d71ab47a086e86eedf39d1c5bba97c4080126141d67f37be8538f5a8be740e484"
OFB-AES256.Decrypt - Test NIST SP800-38A - F.4.6
depends_on:0
12:int:16:hex:"603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4":hex:"000102030405060708090a0b0c0d0e0f":hex:"dc7e84bfda79164b7ecd8486985d38604febdc6740d20b3ac88f6ad82a4fb08d71ab47a086e86eedf39d1c5bba97c4080126141d67f37be8538f5a8be740e484":hex:"6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710"
| 3,253 | 33 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_gcm.aes128_en.datax | AES-GCM NIST Validation (AES-128,128,0,0,128) #0 [#1]
depends_on:0
1:exp:0:hex:"1014f74310d1718d1cc8f65f033aaf83":hex:"":hex:"6bb54c9fd83c12f5ba76cc83f7650d2c":hex:"":hex:"":int:128:hex:"0b6b57db309eff920c8133b8691e0cac":int:0
AES-GCM NIST Validation (AES-128,128,0,0,128) #1 [#1]
depends_on:0
1:exp:0:hex:"d874a25f2269e352ccdd83cc2d4e45b7":hex:"":hex:"9717abb9ed114f2760a067279c3821e3":hex:"":hex:"":int:128:hex:"0e09e53e5fe8d818c5397c51173eda97":int:0
AES-GCM NIST Validation (AES-128,128,0,0,128) #2 [#1]
depends_on:0
1:exp:0:hex:"7dab77e23b901c926454f29677eb62d4":hex:"":hex:"8aaec11c4a0f053d7f40badd31a63e27":hex:"":hex:"":int:128:hex:"cec2e3230d8b762acee527e184e4c0db":int:0
AES-GCM NIST Validation (AES-128,128,0,0,120) #0 [#1]
depends_on:0
1:exp:0:hex:"2397f163a0cb50b0e8c85f909b96adc1":hex:"":hex:"97a631f5f6fc928ffce32ee2c92f5e50":hex:"":hex:"":int:120:hex:"3b74cca7bcdc07c8f8d4818de714f2":int:0
AES-GCM NIST Validation (AES-128,128,0,0,120) #1 [#1]
depends_on:0
1:exp:0:hex:"a7adc0d3aacef42397bbca79dd65dbdf":hex:"":hex:"c6d3114c1429e37314683081d484c87c":hex:"":hex:"":int:120:hex:"d88141d27fe1748919845cfa5934bc":int:0
AES-GCM NIST Validation (AES-128,128,0,0,120) #2 [#1]
depends_on:0
1:exp:0:hex:"10171805d7f7a6d87b64bda57474d7fc":hex:"":hex:"fad65b50c1007c4b0c83c7a6720cacb8":hex:"":hex:"":int:120:hex:"c3d3f240d3f3da317eae42a238bcc1":int:0
AES-GCM NIST Validation (AES-128,128,0,0,112) #0 [#1]
depends_on:0
1:exp:0:hex:"8aaa0c85d214c6c9e9e260e62f695827":hex:"":hex:"84e25c916f38dd6fdb732c0d6d8f86bb":hex:"":hex:"":int:112:hex:"a774815a2a8432ca891ef4003125":int:0
AES-GCM NIST Validation (AES-128,128,0,0,112) #1 [#1]
depends_on:0
1:exp:0:hex:"def8b6a58b8e582e57700bab4f2a4109":hex:"":hex:"3615439e9fb777439eb814256c894fb2":hex:"":hex:"":int:112:hex:"537be9c88d3a46845e6cf5f91e11":int:0
AES-GCM NIST Validation (AES-128,128,0,0,112) #2 [#1]
depends_on:0
1:exp:0:hex:"5894231d743f79638687c070b60beee1":hex:"":hex:"e34cd13b897d1c9b8011a0e63950c099":hex:"":hex:"":int:112:hex:"d582c4bc083a8cf1af4d5c2c9b11":int:0
AES-GCM NIST Validation (AES-128,128,0,0,104) #0 [#1]
depends_on:0
1:exp:0:hex:"6b25f9cbdc3bcd27fd245a1c411594bc":hex:"":hex:"a6526f8c803b69dd5f59feca1cff78e2":hex:"":hex:"":int:104:hex:"c7e19e08a09a9c1fa698202890":int:0
AES-GCM NIST Validation (AES-128,128,0,0,104) #1 [#1]
depends_on:0
1:exp:0:hex:"b3235422897b6459798a97ddd709db3d":hex:"":hex:"96679e9362f919217d5e64068969d958":hex:"":hex:"":int:104:hex:"44ed41bda0eb0958d407b7b787":int:0
AES-GCM NIST Validation (AES-128,128,0,0,104) #2 [#1]
depends_on:0
1:exp:0:hex:"f65bc795434efba3c5399ed3c99ff045":hex:"":hex:"2e727c19a89cba6f9c04d990245fceed":hex:"":hex:"":int:104:hex:"64830ed7f772e898800fc9ae2a":int:0
AES-GCM NIST Validation (AES-128,128,0,0,96) #0 [#1]
depends_on:0
1:exp:0:hex:"c6c66d50f2f76c4e911b3b17fcdcba1d":hex:"":hex:"77b42158a4ef5dc33039d33631bb0161":hex:"":hex:"":int:96:hex:"1bce3ba33f73e750ab284d78":int:0
AES-GCM NIST Validation (AES-128,128,0,0,96) #1 [#1]
depends_on:0
1:exp:0:hex:"13558db9b7441c585d381ffc16b32517":hex:"":hex:"addf5dbe0975c5ad321e14dd4bdc2ad2":hex:"":hex:"":int:96:hex:"f413c3bf125ce5317cd1c6bd":int:0
AES-GCM NIST Validation (AES-128,128,0,0,96) #2 [#1]
depends_on:0
1:exp:0:hex:"74638628b1361c2954ce0ac5456a1155":hex:"":hex:"c5861507c879e6864d7cb1f77cc55cc6":hex:"":hex:"":int:96:hex:"8a514fdc7835711e4f458199":int:0
AES-GCM NIST Validation (AES-128,128,0,0,64) #0 [#1]
depends_on:0
1:exp:0:hex:"7815d22c5c081df9ac2114aaa2c0cbf9":hex:"":hex:"822f83cd9f249dfc204b5957f0b0deab":hex:"":hex:"":int:64:hex:"aa1f69f5d3bb79e5":int:0
AES-GCM NIST Validation (AES-128,128,0,0,64) #1 [#1]
depends_on:0
1:exp:0:hex:"1a847a47823cb9c298e4107c6aaff95c":hex:"":hex:"39348f80c6bc489f9315be7a6fcbb96f":hex:"":hex:"":int:64:hex:"c3b3f31e56cf4895":int:0
AES-GCM NIST Validation (AES-128,128,0,0,64) #2 [#1]
depends_on:0
1:exp:0:hex:"16e67ea248ea6db08af1d810cb10574e":hex:"":hex:"50386e2075eb15ca3f3e6db6bff01969":hex:"":hex:"":int:64:hex:"3d4f3b8526a376ae":int:0
AES-GCM NIST Validation (AES-128,128,0,0,32) #0 [#1]
depends_on:0
1:exp:0:hex:"26a8301636ba93e7f56309143f184241":hex:"":hex:"c7e32b1d312971bdc344aefaf45461bc":hex:"":hex:"":int:32:hex:"25f1b41c":int:0
AES-GCM NIST Validation (AES-128,128,0,0,32) #1 [#1]
depends_on:0
1:exp:0:hex:"130a07c467067148da2790f90d73ff32":hex:"":hex:"800b81c9d2ff3a8e15690ffb4117e211":hex:"":hex:"":int:32:hex:"abcc8d71":int:0
AES-GCM NIST Validation (AES-128,128,0,0,32) #2 [#1]
depends_on:0
1:exp:0:hex:"ccfaae59c3196b8c403716424ea601f5":hex:"":hex:"f9b059de0efa4e3f364763d63d098410":hex:"":hex:"":int:32:hex:"8933444f":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,128) #0 [#1]
depends_on:0
1:exp:0:hex:"b5beefbdd23360f2dd1e6e3c1ddbfebf":hex:"":hex:"81a8494f85be635d71e5663789162494":hex:"f9ebf242b616a42e2057ede3b56b4c27349fed148817a710654de75d1cfc5f6304709b46ef1e2ccb42f877c50f484f8a8c6b0a25cff61d9537c3fd0c69bbc6ef21cbec8986cbc9b6e87963b8d9db91b7134afe69d3d9dec3a76b6c645f9c5528968f27396cc9e989d589369c90bbfefb249e3fa416451bc3d6592cc5feefbd76":hex:"":int:128:hex:"159a642185e0756d46f1db57af975fa3":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,128) #1 [#1]
depends_on:0
1:exp:0:hex:"c465aa8fe5d534c912e654f5aaed5857":hex:"":hex:"5c155f7194b0d0a17b9a0c234d609443":hex:"a3f8d705b233b574399f72350b256cb4893e130688913ce3def8e44687688c0352ff987aea35dc53bc95cdb9cdcc6e6eb280265d9a1af38d526392ab63c9b043c1b1b43e18321e84eb7e08884f2463c32b55eb5859fb10918595a724a61cfdf935e4f96d0721612720d46a946487b525779f6ce0abf04fc5608351119b7427d2":hex:"":int:128:hex:"9595a6d879cd7a949fa08e95d2b76c69":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,128) #2 [#1]
depends_on:0
1:exp:0:hex:"744b9e1692d8974d7dec349ebd7fe1e8":hex:"":hex:"62ad4b09fd554e0d6b3937839e693e5b":hex:"6f9978f7078f0030c45caf49128ff72943a208a2398d08d132239f3ab5c184708e4222ec9ccde69dc86d1700c2fe0af939454bbb3962327158557860b6fa492ab8201df262a6209705c7e3129419bce8b827320893c1579ca05b32c81b3963b849428f71fe7528e710557a272117199163a35ebfbaba78f7676f7e566b16311a":hex:"":int:128:hex:"634f6fe9625be8b1af9f46bcc0fa3162":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,120) #0 [#1]
depends_on:0
1:exp:0:hex:"097c059535037c6b358dbb5a68b5f2b1":hex:"":hex:"00caedfa078c27e3d9551e3fb8d98d77":hex:"6c4bde11129a959fcd6a482cb19f5f1c582c042b314f7997b0450242f9e669dc1cbb0a3b7a185bf8b035267e6f03206268008e2b97864d44d6a9c6b1b4b067d623c4b4e9c608042ea9120aed3bee80886352683891496d8980e40b8480c98c2fe08f945aa1ef6007c65220319dd8678184ab54e81083b746ec6441e87a568e0c":hex:"":int:120:hex:"5075ef45c6326726264703f72badde":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,120) #1 [#1]
depends_on:0
1:exp:0:hex:"d25db5eca46c16490294423ca0c35660":hex:"":hex:"6f37f15d6c7ea816278ab977c29fa45e":hex:"bd76fd431cea72a288e5d7289c651c93b5f429a54f85249021d6b595eb9ce26e18914a381a6b0299acc3725431b352670f206b731be718a598ec123dce0a2c5ac0aa4641b092e704da9f967b909ca55c2722298365a50dcb5b5ec03a1d0cbb67b8de1e8b06e724af91137e0d98e7dc1e8253887da453cdcbd2eca03deacaabb8":hex:"":int:120:hex:"00510851e9682213d4124d5517ebaf":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,120) #2 [#1]
depends_on:0
1:exp:0:hex:"b3c6258a726aff94a7bcc41646c68157":hex:"":hex:"7f5b3315afe5167a7e9061ab8b005588":hex:"0ef3384862c7e00c2912e7fde91345dc3134b5448e6838f41135ba9199c03a7f208887e467563b39a6c1316540c1401e8ff148386c50fcf15724a65d3210b17832d63cdce76bd2b458348332b0b542122a57e381475a59440f280db6e1f4b8d0babfd47e3db11a9ef89cba5f334f0e8e72be30afb2b1ef2df8eb7f8d3da033c4":hex:"":int:120:hex:"180489039ccf4a86c5f6349fc2235b":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,112) #0 [#1]
depends_on:0
1:exp:0:hex:"73cd0a1e2b6e12fbaa7cbace77d5119c":hex:"":hex:"d897681764bcc3b62c26b4aaf407cefa":hex:"8c773e14a906c7deae362d1bf3d7e54c6be4c74c691b7f2d248693b2619219fba6eb5bc45f77af1cf7c05d3dd463158f884fe82290d145135889fd851b86ee282aa20bbdf6af78c7f9db6128b8b99e7f9b270fd222efa18f7aca6932a1024efb72113e812b3f9d2d4ccc7c85f5898ddacccbf1b441cd74097740dd922b57bade":hex:"":int:112:hex:"d8811a8990191f1e5bd15be84995":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,112) #1 [#1]
depends_on:0
1:exp:0:hex:"c1dfddafe076d0ceebb0f37bb25bc0b1":hex:"":hex:"29c56db10cea802c19fb6230227ab2bf":hex:"287b73cdc62ce058cdceff8e9af7afc321716f69da9eef60c2de93630ba7d0ed0a9d303cd15521a2647159b8478593f3dd3f5b7c52081e5154e55ccbff371d7e5dfc2d05e14d666a01ec2cc6028aacadfd78dfc73bf639fc4dfa0a0c46415902bbda2443620fa5e0ce4fccf1b8591e3a548f95755102a8438300753ea5f61b9f":hex:"":int:112:hex:"309fedad1f3b81e51d69e4162e6f":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,112) #2 [#1]
depends_on:0
1:exp:0:hex:"2c4087ccd28ceda147d2fcfc18579b1e":hex:"":hex:"9cbdd67c79ab46bcbcfa96fa2c3d7e87":hex:"35088d18dff0a9d3929ce087668aae1d364b37a97102f3f43e11950e6ec8296d0c99b00cd1c5dff53d3a38475e7da7b9ee4ce0c6388a95d3f8b036414e4b79cd02b5468cbb277f930e7c92432a609db1effe65f60f1174b58f713e199491f9e0c29ba1f2e43306775d18c1136274af61488a2f932e95eceadfe3fe4b854fe899":hex:"":int:112:hex:"b7e83207eb313b3ceb2360bc8d4f":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,104) #0 [#1]
depends_on:0
1:exp:0:hex:"bb66584c8b18f44c11f3bd7180b9b11d":hex:"":hex:"39c82aee03ce0862ff99f8812cdbdcf0":hex:"45ec858e0a5c6d81144ba893e0002818a70e9a19002a5471993077241b3fcfb4fd984f2450803293882d1c7ecb654e611578fe7d258f9a2ca3b5f0c0f0d0ec4828bdeb9299914ff2ac4cc997cf54fa908afdb3eae9f91d67c4637e1f9eb1eae2b3f482ddd5467668bc368b96bbbfc33b9ae2658e4ca43fcf4b66ba2a079d65f1":hex:"":int:104:hex:"24332fd35a83b1dfb75969819b":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,104) #1 [#1]
depends_on:0
1:exp:0:hex:"7b2a230c8978d4e38fa5096ddc19d6f5":hex:"":hex:"cd25e744a78af858e825e1fd070324ee":hex:"628baac336862573cee158cd3935c34df3055dadc9c1695e9ea18724f6457f0d1833aab30b85a99e0793e56000de5d6d5cb2327a4cc8bec40cd198459e7b93617713e63bbd15381a066bc44a69c9ad3dfb1984f8b33a9429eda3068d3ac5fbbaaee2b952a486e58d674ffca641d9ec1d102600af11641fd5fff725204e6c34a8":hex:"":int:104:hex:"68d49d495ff092ca8e5a2c16cb":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,104) #2 [#1]
depends_on:0
1:exp:0:hex:"73aa576e1dfad2c993afcc088bd8d62b":hex:"":hex:"712e665a0a83e8ecad97e92afeb35706":hex:"314e5fee776e9d5d2a1fb64ceb78e2c9a560a34724e30da860b5588fe63d50838cb480ff8ac61d7958b470b1bfd4c84799af6cb74c4a331b198204a251e731f7d785b966da595b745d01769623492c18b9dd8bd3c75249effd2032658c715906a71dbbed847027ea75d647f9803296a41906e0915250854597a163035a8d3f45":hex:"":int:104:hex:"a41f5c9c7de2694c75856460d4":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,96) #0 [#1]
depends_on:0
1:exp:0:hex:"83f7631c4d4c466c9246cbc48e2dde6f":hex:"":hex:"f5d6c8c252cb687a931c38f58f74943c":hex:"1f35e94a35d0f424bf690a15038126a41502593612efe6333cf94ea0565ca6acdefae8d74dae62df95e9261c6596c3397220e044c5b08cf39cccb27315d9b795da321204910274a93436bc0573fdba04ae6bb14c6ca955cf8b9e193a12e05796d7f4b397507614dabc457f1cd3ce19e439b6e62703f2189372938b29b7a542b9":hex:"":int:96:hex:"bb85dbd858ab7b752da7e53c":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,96) #1 [#1]
depends_on:0
1:exp:0:hex:"784e023b2d4c978151d05ee71533c56c":hex:"":hex:"f16d041b9f0f454db9985c8558ef8a61":hex:"91f6e108c294640c7bc65d102d3d25a7bfbbe114acec9b495636689afd65fff794837946602ef04de7d4304a81809e0f7ddc45c476c29fd5286fcf4dd1ba76ed3ce88abdb51cd21e7aaeecb13238ac031da87ab96b2a13157278bf669d0efae28852ec3585d520d54502881322f7977d03954e17e7c0c0d8f762e34f59ca141e":hex:"":int:96:hex:"59699c639d67be6a6d7c9789":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,96) #2 [#1]
depends_on:0
1:exp:0:hex:"d3a2ec66e4a72cb3540e87f4e67c7e58":hex:"":hex:"07a9cf9f44b07e3067d60e276322e9fb":hex:"d7e722b82e8607a64fbfeefc7887009298f06a637fe937277e3a76e8addaeeb460ba0743912c07b500b4b51e9fec2b7eddf691d155baf689f75968160c19a8330e254220142ae843bf0687aabeb74ab607227b0a7539ec3cfea72a5c35f236623af78beffaee6e7b1adc2895732ffedb3f8520710f04eb9c2ce9b2cae215ed5c":hex:"":int:96:hex:"f29aec72368bfcfa9ae815fd":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,64) #0 [#1]
depends_on:0
1:exp:0:hex:"83f382a90146544ef4871bde891aed22":hex:"":hex:"c6f664f5ccfd1aaefb60f7fa3b642302":hex:"656a2f221a1339d8f5c26393a08fa31859f626eec9a68afb6ee30e5b6859d1cbb5ed7dea6cbc4a5d537d70227d0608185df71a0252fa313be4d804567c162b743814f8b8306155931fdecf13822a524868b99a27fd2ff8f98c16edccd64520e2dce1ad645fd5255c7c436d9b876f592ef468397b00857ba948edf21215d63d99":hex:"":int:64:hex:"09df79dd8b476f69":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,64) #1 [#1]
depends_on:0
1:exp:0:hex:"64334f10a62c26fef79d9024d4ba7c5f":hex:"":hex:"7b85251554d4f0ff89980cf3568c5caa":hex:"dab2892262a1832a473cd3481acbd3d1820f14361c275514ec693b40f2170ea5ff82c4f7e95a7c783ea52c43a0a399c37b31319a122fd1a722e6631efa33f8bfb6dc193986580f0344d28842a3a4a5ca6880552557f3915a65501f6ee0c1b68a4c9040f0fac381cbccb6a6e9bca23b99f2ef1abbca71c69aa27af2db176bf37d":hex:"":int:64:hex:"3e8406900a4c28bc":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,64) #2 [#1]
depends_on:0
1:exp:0:hex:"1c98ca4971c3a6333c18b88addf13368":hex:"":hex:"7f617f08e826a3c61882c3e00c203d4b":hex:"ab1531fce0f279d21091c3334bd20afa55c7155bfc275330ed45f91cfc953771cbde2582f4be279918ac8b9ae07cb3b2efd14292e094891d4841be329678ad58d714fc8ce4bffe51f539f4240c14ba883b95cdc32cf4a9fd6ba4ffeafa0d6718989c46483c96cfca3fe91000f9f923d7f96725e966de068b5da65546fe38f70e":hex:"":int:64:hex:"58cc756d3bf9b6f9":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,32) #0 [#1]
depends_on:0
1:exp:0:hex:"247d3abeb807bde959e68b40a3750045":hex:"":hex:"3f5390cd7921fcb42c59f0db05a8a62f":hex:"81abf375da7157a1a56068d0918037fecb7296d9b1771c54ae6030abda4b9d76feff818de81747980b2c1b005e36b3be36afbf1092edef6fd875d2903d73612addf206a6ae65886421059c70990a6ee33197f92bed649901fed62fdd20c30d81baf6090f50d9f59290528e58a0b7412ace0a293369f2b4c8d72c2fb0e1c432f5":hex:"":int:32:hex:"37bb4857":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,32) #1 [#1]
depends_on:0
1:exp:0:hex:"622be8cd3c757de00fbb7ab4563ce14f":hex:"":hex:"16c53a843b1549716d7c06b141861862":hex:"a15d101580d549f2401bf0f36be0f83724875205c9109d2d69d2609cbf67504b918f0859303192b4075f952454f3e7152f898f997b36afc0356712fc08db3343054b20e88ad1274e019bf8fcc3c921d3bc8f9c1d1d24adc61f6033a83ef46a84762304f1903553748b13b1647c96eb8702ebb41ccea4d9cfebcb177c453277f2":hex:"":int:32:hex:"35778596":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,32) #2 [#1]
depends_on:0
1:exp:0:hex:"8a660aa0191f9816261387d5aeb262f6":hex:"":hex:"c720cb31e841480da5ba656e9b93f066":hex:"d979affe395bd048db26d26908a1c2a435905299086cc55bb65ef782f5aed99c41743c3ae252ea087f5453bdc605abd784b337b60960946358da2218b076826659a1fafa59124a00a3424fce0d00c38eea85cfb3d1e01bcb09d9870d5b3fe728f394e0e512f5aa849d0550d45a7cc384f1e4c6b2e138efbc8f586b5b5ed09212":hex:"":int:32:hex:"cf7944b1":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,128) #0 [#1]
depends_on:0
1:exp:0:hex:"ce0f8cfe9d64c4f4c045d11b97c2d918":hex:"dfff250d380f363880963b42d6913c1ba11e8edf7c4ab8b76d79ccbaac628f548ee542f48728a9a2620a0d69339c8291e8d398440d740e310908cdee7c273cc91275ce7271ba12f69237998b07b789b3993aaac8dc4ec1914432a30f5172f79ea0539bd1f70b36d437e5170bc63039a5280816c05e1e41760b58e35696cebd55":hex:"ad4c3627a494fc628316dc03faf81db8":hex:"":hex:"0de73d9702d9357c9e8619b7944e40732ac2f4dd3f1b42d8d7f36acb1f1497990d0ec3d626082cdb1384ec72a4c1d98955ba2a3aae6d81b24e9ce533eb5ede7210ae4a06d43f750138b8914d754d43bce416fee799cc4dd03949acedc34def7d6bde6ba41a4cf03d209689a3ad181f1b6dcf76ca25c87eb1c7459cc9f95ddc57":int:128:hex:"5f6a3620e59fe8977286f502d0da7517":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,128) #1 [#1]
depends_on:0
1:exp:0:hex:"81371acd5553fdadc6af96fdeee4c64d":hex:"940806fd5ddcab9937b4ba875e46bb4b7e9688d616d17fd24646f1ef1457819f55887f53bd70039bb83b4d346aabe805288ab7a5756874bdc2b3d4894217d3a036da5e9e162fa2d9819ceb561ecf817efc9493b9a60796f6dc5e717ac99bc4ba298eee4f3cd56bbc07dde970d4f07bbfa1f5fe18c29a3927abe11369091df28f":hex:"3262501ed230bc4f5a190ab050e1bcee":hex:"":hex:"ffeb1907bdbfea877890a6e972a533ae661a903a257b3b912c7c768cc988e05afd71a9e6117d90d1e1b54f55de9b10cbce7a109452567483cc8d6a68b9e56da10802630591fdd8d55f9e172f0f58a7e0c56a73a1ae3c3062f0997b364eb0885d48e039b2ba1bd14dbb9c74a41cbd4b52564e470d1a8038d15207a7650bd3f1d6":int:128:hex:"227d422f8797b58aa6a189658b770da9":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,128) #2 [#1]
depends_on:0
1:exp:0:hex:"ef5295e9ae74729e222df6dab251158d":hex:"59372848432f86f5740500391d2e5d5fbe1f80ea876a0ecb9a5b298d9ea7cdc28620aeb2fda015345ae476f265351b2c6b6fcd66bc8aae4dc8a95c1350cda204da3d2d2fc5e6e142dc448296d5df0cc349d1eba2fa98d2f468662616274a147fbe07927440afa3967ac09a03a8de0b03f3036bde5e272e3c4c5ff169dd730238":hex:"194d08fcc3c08ab96fa724c381274d3f":hex:"":hex:"fdceeffdc8390bde6b910544db61db2f345eba0664f78f65d94b90e3e2a5251be374b3c5d881460cfff3549a01f84eb9d54087306a20f5156cd555e46bd2173386c90ea47983320fcbf24e09a05f2ec4b2577287d05e050b55b3002b753de49abef895ee97015810c06d09212b0c09e4910c64ac3981795a1e360197740360fd":int:128:hex:"e94603dbd8af99ab1e14c602a38a0328":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,120) #0 [#1]
depends_on:0
1:exp:0:hex:"26db035f2ddd9f5672c6f6af156838d7":hex:"92c315936847649756b0b1bb4a3453e6e6da866f8088d96da44412d9f47a22dda0cd817287ba42163be59a69f73963059139fb3ba44bc5ebfd95b6742546dfb4fe95608dca71911d1347be68179d99c9ebf7ee1d56b17195f8794f3a658d7cad2317ed1d4bc246cd4530e17147e9ecdf41091a411a98bb6047eee8b4f1e4a9ef":hex:"3686d49bb8c7bd15546d453fdf30e1f3":hex:"":hex:"1ac98e9ccfe63a2f12a011e514f446c4c0e22dd93613b1b9b8f56d148be8a24e3682dfc1cde2b69e72d200b516a99e7466dae8cc678c6117dc14b2364cd2b952aed59722056d7dae4cfdb7d9c4f716aef2aa91a4f161d01c98d92d974247bb972de0557e175177ce34361be40c30ab9ac46240016e5ad350c3b7232c5920e051":int:120:hex:"b744316880b0df3d4f90c3ffa44144":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,120) #1 [#1]
depends_on:0
1:exp:0:hex:"d5c63757197a132cbb33351fd2d81a46":hex:"e970b62ce5f06b15f8448aa2a095c2b3c8adf535e110e7f374411ed51fa19f9c4926045f796b7cd8a942b6a19811b7aae59fce37e50d6ca5a4a57bfb041a5b51c1ee82b54d03be22d9dc2bb9a2e708503b85e2479b0425a033ae825b4f232ca373e280e3cc97cf0d79397a81fb30d3b41cdaa3e788470cde86734e10a58b1e3a":hex:"a669a4d2f841f9a0b9ede1fb61fee911":hex:"":hex:"522ba7220d0d4bea7ab9ca74ad8fa96ba337f7aa749cd26186499081ba325df6d6b90a81bd1c7adda0cd1ca065894f14a074ec13eff117b2a00042038aea55850056a63adf04f58fcd7269085f5ad1ef17ce7b6c40804127f14747a2ad93ec31fada83663af025a3b90c20a4ae415b1c960094e5fd57db0d93a81edcce64f72d":int:120:hex:"7bfce3c8e513a89a5ee1480db9441f":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,120) #2 [#1]
depends_on:0
1:exp:0:hex:"f380d3bf0d55a1cd56b7e78359eb6c66":hex:"c0e977e91c1c50ee78d4a56c527b2d31a1a14f261aa77e52d910f8f230de4908b5cc6943e28b8c6e7ac61eebe270dcfde48d140ec13792371932e545b6ef4b52d1dfdf54c60ff892b74095a3f4a2b9000acd2cac04666a2305343b8c09f89dcc0c25bbe2a39b14624118df025962edec3dfc58d36fcac531b291ec45b5159e22":hex:"ba3300f3a01e07dde1708343f01304d4":hex:"":hex:"752f09b518616a91a802cf181532c7ec65b54c59c1bab3860f0ad19971a9e5bc8843524c5ffac827067b462ebb328e2eff4dd931728de882055129997204e78717becd66e1f6c9e8a273c4251896343604ac289eb1880207a8ea012626e18e69ad7573ef73071b8e2fb22c75c7fc7bf22382d55a5d709c15e4e8ff14e2bf81e4":int:120:hex:"fbf8818aee5c71ebfd19b0bcd96a7a":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,112) #0 [#1]
depends_on:0
1:exp:0:hex:"47c807cd1cf181040a4e3b1d94659db8":hex:"c4a52c1f1f0d32c21fb85fba21d1b358b332efa066c7893c566b2e859efdde99fc67bb6167cdb0485a8ed53dd1068d90bc990f360b044039791be6048ba0ee4ce1090c9fce602af59d69069f5bff8b6219aaaed5a9b1bfc8c5b7250c5a6cfe86586fa8064124d551da38d429a17696eb1a7a0341c363f010eafd26683eecdf82":hex:"9963a3fb156beacd6dd88c15e83929df":hex:"":hex:"e784ab006de8a52de1d04bc2c680d847c5decdd777cb2475ad4ab1dc529882d9e51cff5451b14ea5ff9a9bab5c5474e8a331d79564acdb2ac8159e0f46e9019bf80650c481fdaf1680cadcb8c5de9f924760b376ce5736cc4970cb8715b5999f577436283a4c21469306840af36d1e069616157d1b9ce75de3adb13d201cdf1b":int:112:hex:"51e8ce23f415a39be5991a7a925b":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,112) #1 [#1]
depends_on:0
1:exp:0:hex:"a0b033d14fe902aa0892b0e87f966c41":hex:"1cc751d890cd102486d81c618c23fa335067ac324ef11f7eddc937853db6e16d0f73727725a5a5bd580705416ecd97e368464ed0aea923ffb71c23c37f9cf9c8bd81cdbdc3d0ac34a875db3167ec1d519004d4fa4bba041af67af1ed3d4e09c32b3e8e10abd91f46836cec74b1f9c5b06c05f3b18caa78e7ff185db212b52ce0":hex:"ad4dee18e6c19433ad52021164f8afb7":hex:"":hex:"a30044582dacf57332b04402e993831df0a4c1364a83c9bce7353979fb444cd1b3fe747e2c933457ff21f39e943a38a85457bfe99dc09af886734d6e4218fc65138055ad8eb5d3044f4eed658e312b6165199e682ffa226558dc4b516f8d519f149bb5a40d2bb7d59ece9e5fd05358c89e635792ad20c73c174719f9b28c7358":int:112:hex:"6a18a4f880ce9e6796e1086ed05b":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,112) #2 [#1]
depends_on:0
1:exp:0:hex:"c4030ca84f132bfabaf660e036f56377":hex:"a8fe98e2b4880d12c99c9d5193b3537b3fbc5165cc1327395174d989be5741f867332271cdc52ddb295ddbeba33698073054c6d2416fafaeb0a76aad870a6fb6097a29fba99f858d49418572c8e4dc0d074ca8af7727c773c8617495b1195d6b2687a2e37fad116dd721b60bcb5471d548c6dafe3ecdcf0c962e4659a61f4df3":hex:"975df9c932a46d54d677af8a6c9c9cc3":hex:"":hex:"86b20fecebc4cf88a6a382d693117cd2a3c9eab747bf5df5f1d35e341d204d8fea6694b92552e347da676bc8d3353984e96472a509f5208ce100a2a9232478417947f85f10993c9d6939c8138bd6151aef8e2038536e8ba1ba84442e27586c1b642f9505455c738e9fd2c1b2527d1ecd3a2f6ed6e3869000ef68417ec99ff7a2":int:112:hex:"3516909124c0c1f9c30453c90052":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,104) #0 [#1]
depends_on:0
1:exp:0:hex:"6e210de363f170a7ccb1b9cec8d34737":hex:"89853fa002985a45651f2a7db2b45b7e7a7d33ce6c438ec4533c7fa257e1a384130369a68184a807fd0d92a70d91d7ddc56e5c5172c872257230d7aeb9293d785b1b8835dcde753798caff4abcd8bbc5378cd505dcf904aa69902e4f38699be972099adffc8778bd844a9a03e6b58a721a73324d956f20f2ffd00d3491f72f42":hex:"39fe20b051ba21319a745349d908c4bf":hex:"":hex:"ac9d74f8f405fd482287a4a7fa359caca095c0f1b46744f19c3c11e13b0c605b9857c8cc5a1754b95bcc658416f463bf8764f373205941885948259916eaabd964f2d6c2d784f928dc5eefe331f6c04b4862d4c8e966530de6bf533a10818de852de3af7f521b167cb4eb7141ba8ae8a17be1eb714fd26a474bbbbe870a659dc":int:104:hex:"7a2dfc88ad34d889f5e344ee0e":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,104) #1 [#1]
depends_on:0
1:exp:0:hex:"6bbfeda23ea644fb37666b05dc47f590":hex:"a85ec4c2c160deda7e3de0ae449eea6ed1d24e2c8f3d5151f2ac0fd869f5a763981733b68f46c5197d76c26cce7ddc8afc6cdf4536d771cf3e9cef0098e270c5e1ff72cb0ad7f84abf44b726e0eae052d0c1553afc67c7289a43851a4d04c2856cc46b4039380436465a3b19deb56e41b859aecaf22b90578a23288d5f7d9b0e":hex:"9d154f3cc2c5b0bdd77e86e351220960":hex:"":hex:"dbe575ea04b58429e68c733d99d7fb3a57e5604d6fc3baf17e0c6f981d78c070144702861316f892023515f20b697a8f3a40d821162dc9255d4775e7578285acf2cca67e902c060f80eaae29b9c011b6c110371409d914782e1e4115dc59439a2823507330852f10436b121538f22a3b619075610f1da87b6035138d78c75a79":int:104:hex:"8698763c121bf3c2262ba87a40":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,104) #2 [#1]
depends_on:0
1:exp:0:hex:"ce1407f666f2aa142ed4ef50eb2a4f64":hex:"585fc1e86809247826f87424741f6ce2ce7c7228fb960803be643acd28332b2036715e2b639fe3f8de7e43e88bd8e65a6e2259391360aaf534ae7566cbd2b3961c874d08636fca117d4123b3063931d7a161d00220014339ae9f447f31b8a2d7d5466fb1ff2508397b5fa71f9b4cd278c541442a052ae4367889deaed4095127":hex:"1225a2662d6652e3d4e9c5556bc54af4":hex:"":hex:"8bc13cc1cb52fbd15390cb5663ce3111c3fb943f8ed3c4f07b7aeb723649fccb90895999ec5dbdb69712d8e34ae3f325fefa49ecc7c074de8bb2ea01fa0554d7adbf49498f2f6e78aa0cd24620bab0f11bf9b2c73ad0eff780eb6c03ee9c4538952af754c566aba7c717d1ee6ac2f5ffe21dab9afd649cd65313ee686596fef0":int:104:hex:"9a1f1137f9ed217815551657bf":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,96) #0 [#1]
depends_on:0
1:exp:0:hex:"5ecea1da76d6df90fd0d4077ef631b17":hex:"d87e9a0c6a9796d60ed78924f7a8c408d5b9fab03fc76790e74029f13358fcae0035bd971a400845f508c2c2cdc3949be498193afcca6d75f8d21521ac673bd41a936a133fb5ed61098f3cb89df5234c5ca5ad3dbbe488243d282412844df0d816c430de3280ab0680a2a5629dce53f94e8eb60b790f438a70fafb8a3ed78a1b":hex:"7d7ae2ed1cfc972f60122dec79ff06fc":hex:"":hex:"1eb19da71857854420c0b171f1f0714972fe7090db125d509aff6d92e5192353187f0906e3e8187f73709d1a60e074af01e83d1306d582a82edbdbebc797a733d72e2d4208675ef98ea4eaaddae2292e336fcd3fa85cdc577f4b8d3f324f0c5cf3919701208d6978f83466a02ae6cc368f57e18b9ee16e04cf6024b0c7fbad33":int:96:hex:"f74b3635ec3d755dc6defbd2":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,96) #1 [#1]
depends_on:0
1:exp:0:hex:"6d6de51c30692d7863482cbbaa5ccbc3":hex:"9f242c230ae44ad91cb0f4fe259684883968f3ca4f57a3e0cc4b03ab063a4eacdf63f9e7900a98073e345d1b497b985887e1ffb5fe7d88cefa57dd41076f2da55ce7ab0899bdc5799b23773f8f7a4dfbf1861cf4de377281fae9763dd4ea8dc7c0d632b874c86ac8e4c90339ec3f14cc51bf9241660ab828605cc602984a0f10":hex:"c6c0fa3da95255af5f15706274fa54ee":hex:"":hex:"55e75daa3df3b13a33f784d5adacb2ff6861cacb297d5eaa61693985b6a0f82e9e0b3a28d10648191c6e62d6260d8a8bb471e6b37aca00dafdb2fb17454660f90c2849a9ad1733d7bc227d962b3cd86ab32d5b031eb2e717e4551cb23d448e06bac7b2a4cadb0886fde472d45de39eca2df474ba79eb58504318207325c81813":int:96:hex:"8eb9086a53c41c6a67bad490":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,96) #2 [#1]
depends_on:0
1:exp:0:hex:"76b7f2307e9cf9221c8f3ff7105327f9":hex:"bc076bfd1ff7a9fb043a371e5af7112bb0c9c442be44ca648567937bcc091c127f02ab70b81ce51b2f7a38954dca3d94b3716c6114f0ba349d6f87f5efd84506ed289dfe8a1277a5d1821c56f9f297cb647cdf36d308e6ad41c55d68a5baaa520d11d18f5ddea061c4b1b1ec162b2d5bcf7c7716235dd31eda3dc3094cb15b26":hex:"3cdaf7932a953999a6ce5c3cbd0df7e8":hex:"":hex:"88c70d3cf5817f9fa669aadf731c0eb03c3d8e552f2dc763001ac94837353ab75b0c6553bb8ba2f83ef0556f73dae78f76bc22de9a9167d7be8e31da6e68b0f0bdf5566059901726b6f2890ac8745ed14f8898a937e7d3e4454246185124f65cebd278f8c11fb0de22da7248f33ef6bb82cb1c08259970714de39ea4114f85af":int:96:hex:"6006fe48f74f30bc467c7c50":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,64) #0 [#1]
depends_on:0
1:exp:0:hex:"bac83044f9d8fefcd24766644317c533":hex:"a72daba9de96bc03b5cd7449c2e97c858385475127b9614e37c197225d5789535b69f9123993c89a4815c1b4393bfe23754ddc6c01fc44cd2009b5f886988dc70a8cebb12664fa4a692db89acb91de6a9eda48542b04459149f59537e703e3e89f6d683ebb797fce3874c819d08676d926bf2da2f83a22449b89e204b5ece58a":hex:"1307cd0e6f9ba5570e9781fca9a4f577":hex:"":hex:"479cdb5f65b9baff52a96c75790e3b7e239125f94525068cd1d73a1b8475080f33451ec83789d7189f5ad6a9130e7aa4df10d71ecabb5ccd980d84d0fbfb342506edcf7298ccb310c0e297dd443ded77cf1d96fc49055534439f1af583217a5de36e4df036a3b640d0212658399b629193080d38aff0d4e8aecd6c8d8f48b44f":int:64:hex:"ca192f8153aa5fb7":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,64) #1 [#1]
depends_on:0
1:exp:0:hex:"627776b20ce9bb070a88f1a13d484550":hex:"1da4a24fb12538a724f62b277410d50e918bd6224d4a61df6fb7734300643198debea71686e018bcd8455c2041265d11f7f5dcec08c31fc94784404423bcf1dc8e615227d2b0840be123a1efb8201aaa15254a14a2d76a6ddf536701cb3379d3c6b1b0d689e5896186c88d4a2c53a70bb422ecc8e0a5c3b9f3d89ce40676e4f9":hex:"57f3f9388ea1e2c1c73f60b7d711f6ea":hex:"":hex:"f8a06eea528dad12b11ead51763aa68ca062f9f6c1c1f740fb910974f7ad9d2ac87c16fb74d07c3bd3b45f2e26af417e00416bdfee7ed0b69274ead70a52201c1fc05937438855f5564ec3e824daa0c59da1aa6f6cb8a44ab5f73d661b219766b80656cd3ff1e2d6909c6ce91fb14931af8580e859e9d7642678c1c35d9435d4":int:64:hex:"05b432826dd9b044":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,64) #2 [#1]
depends_on:0
1:exp:0:hex:"8954e2c0a7ea80fe3c8e75246f75bdbd":hex:"d77e11a837eff95c77dd56e9cd97f0ffcee0adcca4a2203d23ce74c804a75cef1bdd69b16228472a2395118dfce636b8916372d6a24106f9a168055c6d4b44264674ce3905b3b30f5108ebf939f3fa8f55c12e001b457b73669acd23c1dcabea05aaba34e2d0f66a4d1c9162764228ebc4d3974fdb38b1a61a207788c5deb878":hex:"2b5f9420b3c583403d92d76a2dd681c3":hex:"":hex:"35b8a04d6557426def9915eb798312a7572e040a65990ce15a8a6e5acd6b419c3fa26828b6efd2f1f50f91f672fed0feaa09a6ca6b4844fac5d3db571db8bbce250086b8c89aa6fa07bdca8dd0e1fe76e0f5a821145bafa11f3a9b0b003ad09de73ad71849ac58f7fd50851aa0fbbed17d222a0a5607f9f75dd3b0d3fa45a135":int:64:hex:"96511adc097838e6":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,32) #0 [#1]
depends_on:0
1:exp:0:hex:"7d0f9109dd846c47527a429b98d53301":hex:"506efc29c0f02910cc9f5b2e677bb811e366b9e4910c00b36e48e5d5b42718f3b6d1a08a2de9c6d4ce44fce00fb7e10cf89396a88bdb38dcb0dba69449195e19b72ff989666b366f03166dd47cf4c7bf72dba3048fa34329ba86bbbf32934a0992d72c463fffee94653379d23b8bb4dff03fd86cfc971a2f7cdb90589bbbcb28":hex:"f58a5bb77f4488ee60dd85ca66fad59a":hex:"":hex:"2e2760c649f17c1b4ba92b1fc9b78d149a9fc831f0d0fe4125cbfc70d52047f32a7f25c716533d199af77ed05e259cc31d551187dbc2e7d9e853d5f65ab8a48840f22391072cbe29e8529cd11740f27d11513c68ad41f4acc6fb363428930fe3d7c0e698387594156e6cc789d432817c788480f3b31326fa5f034e51d2af8c44":int:32:hex:"6ced7aac":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,32) #1 [#1]
depends_on:0
1:exp:0:hex:"034c805b5e83b59ad9d6a65ade3940a9":hex:"efbec09f8189404f3dbe569d3bab9b8bfabde419fc80abb3b21a07a5fe42326d23d022406981abd558e94f4debf38f2c34c3c315cb1ae1d5f2d48eae1335b50af9dd05b60aee724edb7d4e12703d5ec8873c55e3a3d6d8d5e4daddd5240fa3ec2d1f32442ce32cde66dfac77ed213207dc4838ca9782beb9a98d6dc52838831b":hex:"b0c19448b9f2a818fd21ba6489c34fb0":hex:"":hex:"a45ba5836011fc65882ba8b1d6bf7b08b17f26b9cd971eece86fbb6aac5cdfd42790a7c7390099b10dee98cb8e4bd8b3ccb3ca5d0b9d02f759431de640ad7f5dffb919a8aaa74695f94df8eff4c7cb242d643c55d6f9c8323006f3be595aa8cdbfb0d9260ad2473b244ca65a5df53d2edd69f47df608e22a68b05623150b5665":int:32:hex:"43e20e94":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,32) #2 [#1]
depends_on:0
1:exp:0:hex:"f3bad89e79691ae72f53964b928a09f3":hex:"01913e4ef10226d80c5026ba9243fa41edaf5f5c232d17c034db4c0c8369f48d89a1d58b3b2dda496506c30457365bdd76710173a97022d647276a4a8ac73f0e9e211cfd7d64849409ef61cce618675eaffe88b3f14496e5eb013c0f8a122dbf16f2c675edf7f813abe9c56101e570e208e651fd956e710dc09f13ebd22b81ab":hex:"aabf77116a75046e7ecc51a468aa21fe":hex:"":hex:"f7453670604ff6287ebdaa35705cf7553410452fdb1129a7fcae92565a4217b0d2927da21f3d1b2bd5ae9b7d4dcc1698fb97fc8b6622ddc04299fdebaba7f7090917776b86b2af4031fe04fa1b62987fa9ec78fbbc2badc3a31449be3a858ac7f277d331b77c0e9b12240bd98488a131dbd275b6a0ce9830ff7301d51921ba85":int:32:hex:"15852690":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,128) #0 [#1]
depends_on:0
1:exp:0:hex:"839664bb6c352e64714254e4d590fb28":hex:"752c7e877663d10f90e5c96cce2686f4aa846a12272a0aba399e860f2838827c7c718365e704084fbe1e68adb27ad18e993c800da2e05bcaf44b651944bde766e7b3ac22f068b525dd0b80b490b3498d7b7199f60faf69fee338087f7a752fb52147034de8922a3ed73b512d9c741f7bac1206e9b0871a970271f50688038ab7":hex:"5482db71d85039076a541aaba287e7f7":hex:"4d75a10ff29414c74d945da046ed45dc02783da28c1ee58b59cbc6f953dd09788b6d513f7366be523e6c2d877c36795942690ce9543050f7ab6f6f647d262360994f7f892e9f59941a8d440619fda8aa20350be14c13d7924c0451c1489da9a0cafd759c3798776245170ad88dbceb3cacde6ba122b656601ccb726e99d54115":hex:"c7ee1c32f8bc0181b53ce57f116e863481db6f21666ba3fa19bd99ce83eee2d573388a0459dfede92e701982a9cc93d697f313062dbea9866526f1d720a128ab97452a35f458637116f7d9294ffc76079539061dfeff9642a049db53d89f2480a6d74a05ff25d46d7048cc16d43f7888b5aff9957b5dc828973afccff63bd42a":int:128:hex:"63c8aa731a60076725cd5f9973eeadb5":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,128) #1 [#1]
depends_on:0
1:exp:0:hex:"5f2af1b14ca9598c341785189ac6e085":hex:"790bc975865f44e3a1534e978e90b064530321a2280a9172dc7f3451773b01d4a56c1857ad0474350b945e4f34cd677c22ca89445a564b47a8526d31d18160c35d2be1e89428c3593b53877cea0d88d85b2a7ed0552e39a0e96e35ae0384a5d7868243045dcbfc245a3eb3ff99f4dd86c0a314f68d1971e773caf9c168b0aa0b":hex:"bbf23307ad2718398b2791c16f69cc45":hex:"26b160695de2ba40afca6bd93f1c2895f92ca9108847a8ab71ad35cac9f9c9f537ef196c5d41b10e3777c9a02ad3c73cd299a85f60e5d02794c3be2643c3e63f105b94d32cb4e3eb131d3f487fa5d1de1a4ad80cad742704ed5c19a7cf4e55531fa0f4e40a4e3808fb4875b4b5feaf576c46a03013625f04331806149e0f6057":hex:"52c373a15e1bf86edfb4242049f186029b458e156da500ce7a8fc7a5fd8a526191ac33e6b4b79b36fda160570e2b67d0402a09b03f46c9b17317a04a4b9fbe2ddcfc128bd0e01b0be3fe23e51b69c28bcf8725b8e4208aefb1cf34fe91a2bb6d5bef7b936bec624a8f38c9cd4ac51a0187635138d55da1fb1791adfbf8459d3f":int:128:hex:"db3bbdf556c9c1be9b750a208fe55c37":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,128) #2 [#1]
depends_on:0
1:exp:0:hex:"02980dff205bfa5b18037486618e1fbd":hex:"f037ae281e45c50c9fa875f0ec9eb43251d3ae1b6acde27cb5edda7a4e384f50301a68bb6f4caf426adb31457c5eeaa789edc84fd902cb82e00dccbebe272d90cf690ca82ee748885f02daf377970e985d55994fa668fc5e3e06763e6829059fe0c3eb67033b3f5223cd4bb654484c57370d2b856d7117e32ead3d179064315b":hex:"27354e68a004b255a380d8480dc9b19e":hex:"37eed8620136842938ee3c3c08311d1298d3fd3f0456c056e0851a75d844fe6c61aeb2191c024ffce38686c09ab456f0ec26bd76f935d747002af9b47648502713301d5632c2e0d599b95d5543ac1206170ee6c7b365729c4d04ea042f04363857f9b8ea34e54df89e98fef0df3e67eaf241ed7ebbc7d02931934c14bb7a71ad":hex:"f8090d0a96fc99acb8f82bbbe58343fe227d3f43fceece5492036b51ac2fa6db4bf8c98bf28b40132b1ab46517d488b147e12ceb5e6b269bb476a648d8a1133d5e97d4f4fbdfa3866a04948851cfb664f3432de223f3333248a1affa671096708ce6e2c9b4f8e79d44c504ff3cd74e8dffd4ddff490bcba3abffbade0a4e209d":int:128:hex:"b5762b41241cbee4557f4be6d14d55d4":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,120) #0 [#1]
depends_on:0
1:exp:0:hex:"1fc9bcc5aee350f1ef160346b642cc20":hex:"e0fb08cf7dc901bf698385a38e1a81acd4118f083e52aa52e1ded16ab1e840cc49fa1ead3292ce21096cc75c89dc3701102b0982fd3a6bfa55a7799e579aa7336edf365574a904bad924ec080b093a604994db4dcd8323d7d39c3c35750b0741b170481539d22551871d6a0e2ea17e4bebe8ce19ec3bc3bf4f6edae9cd7ab123":hex:"910a81a5211ce0f542f1183c08ba96a7":hex:"2dcf7492c4539d6abc3d259ba5970033ebc2e7ddfa1af8be11f81b459d7477f310be2171290bec2f2ae2cc51266f46e98c878dd2444afefdbdb73a417518f5fd4c116547bf442fa9a8cb2300c5ff563117b2641dcd65018081e62a7ce5c4d822563824e5eafea90cbceee788ed44e6c4f23fe8926603a15adfdb556f11a0be9a":hex:"514d27f8413d7ed59d96c14e7e74b9f3d4518486876c469b369f8c5734145f4aa52506c8f832d4811e5f981caadedcf09875033c5b28a00f35605d773c7f9e1af7f0c795e3df1fa9b5a524f1f753836c1e2dc9edf1602d37ac120f3d8a5c093a5285dbe93957643a65f22995a2782bb455d23318f01bd18ae0d0813b01d233e5":int:120:hex:"feb7a25a68b5f68000cf6245056a1f":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,120) #1 [#1]
depends_on:0
1:exp:0:hex:"9cf329dc10bcebb484424c77eb785aa2":hex:"92728a696b07704fb1deb648c5036a1c8602b4006fb2fd2d401c4b6692e252c7f66918078542cc0b1a97486964276d6e6c77bbb88a9fff0285aef70783d9f2be3b7b22f8a8c02771492150122fe022722bf64263f5d2406884108d8d608273bc02a9127fe4dbcb321ac44a7d2090cff7017d59d73ecf927b8b05968675a63ca0":hex:"a430b979168f5df5ba21962d1bd6dd15":hex:"4d94b7650297c66b43210c84e6e7b09385117ed8fb91adf643b2339f39a5d8dd0b0d75a793e2a669e42c5ddb0873714e01cb65da9eb73fd976a49ae9a4762bcbc06be5052f750d110a407764280b510da5fd0fdce969f86ea6bf52ad4fd9e2d81ec5cb84af0a1d406504a34c51c751daebb4421fe1994bf6db642e64bd471d9a":hex:"c13dbfc60b34d75f8a84db1f6aa946dbfc19479d63900450389756cd1ada8f6d2d0776607f7053db6bfa6752c4b8456f0ace314ff3fd4890d6093a4a5d47dd8fbf902e3e3000f5e02ba93a00985f29ad651cb697cc061d8f3cc74e6d8d0743a1988947c9dc2305e2b7c5a78b29400d736acc238131700af38e72d8c98ba007eb":int:120:hex:"82f1dd58425eb9821fcf67a6b35206":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,120) #2 [#1]
depends_on:0
1:exp:0:hex:"cf43ff6a1ef35c37862ae3b87171a173":hex:"a1e670b3fd62039cf29edb61b26555bcd0f9184be4593bf6b20ceab263bdc76cdef34992fe0ce4d43bd93bd979b78bb252c120fbaafe4947fc0ec05cce4358a5089a841c7476b0ebfca6476e690cb9ee0b73c6700aa82aa8f4050f2c98500052a2d3274b30b0be67549d756efd163c4369b6df0236d608bfbecd784467db2488":hex:"6c56540b3a9595f3c43f5595ace926bc":hex:"5c0bc6e44362299642f3756acf09878bb05549eb6cd6c4942d39fe586ceac228d2aa9c92f8393e5017e73ee41002e60aa8b993c48a7638ce2ae0ae0eaa536bd749b07a8672fc620a5110af61232b6a3d527b36c86637cc1fa92c84008465fd861920884d8a784e194ec52fcbb767a68ca6fabb64ab0a0d680963140d5cfd9421":hex:"8ad36522e4ad47d4a54c5eae0a8b9ff4911aa5b9b13b88b00488a7b678f63cf85945b8d4998d1007e27529b56f50b9e3b373bb6fd861a990514743b9707d535b40d1bdbc3f58a63b8ca30dd7934ee98ec3325d80afaa37e38b4e82d8851166589027d91347727b314e02ed08a7846e29fcd0c764834d12429d9f568b312081f3":int:120:hex:"f5bf21d5eadeebdef3104d39362b85":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,112) #0 [#1]
depends_on:0
1:exp:0:hex:"a0ec7b0052541d9e9c091fb7fc481409":hex:"5431d93278c35cfcd7ffa9ce2de5c6b922edffd5055a9eaa5b54cae088db007cf2d28efaf9edd1569341889073e87c0a88462d77016744be62132fd14a243ed6e30e12cd2f7d08a8daeec161691f3b27d4996df8745d74402ee208e4055615a8cb069d495cf5146226490ac615d7b17ab39fb4fdd098e4e7ee294d34c1312826":hex:"00e440846db73a490573deaf3728c94f":hex:"a3cfcb832e935eb5bc3812583b3a1b2e82920c07fda3668a35d939d8f11379bb606d39e6416b2ef336fffb15aec3f47a71e191f4ff6c56ff15913562619765b26ae094713d60bab6ab82bfc36edaaf8c7ce2cf5906554dcc5933acdb9cb42c1d24718efdc4a09256020b024b224cfe602772bd688c6c8f1041a46f7ec7d51208":hex:"3b6de52f6e582d317f904ee768895bd4d0790912efcf27b58651d0eb7eb0b2f07222c6ffe9f7e127d98ccb132025b098a67dc0ec0083235e9f83af1ae1297df4319547cbcb745cebed36abc1f32a059a05ede6c00e0da097521ead901ad6a73be20018bda4c323faa135169e21581e5106ac20853642e9d6b17f1dd925c87281":int:112:hex:"4365847fe0b7b7fbed325953df34":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,112) #1 [#1]
depends_on:0
1:exp:0:hex:"f9ba053776afb01d15915e7f82a04f21":hex:"fb59858421ffbf43d09415a77320cc9250df861e4414817e7b78cab918fa890ea0400d4237f7ebf522d97318ea79f9979a73970296827a1a9690a039e6c605a0a3efc0077156e1b15f14d88685833e09f6cd6f783d0f50579de7a30907b9d8efc4c650ec57dbf7b425ffaf9a900ec91087d470409da4d67cae7328c15a5db1fb":hex:"df26b109244f5a808f3ea7137f2f49fa":hex:"b21c8101ac96c41bad2925b9b6c863f54888f36e4995820ebd51f53e323e46f528d91f4318183be0282312ccde8da075fc2e82041cb41a79e9933012a4cb6e9f89717444bc734da3b7e40e903e58dd0f38bcb115684227ec533c09a93c89c2c2584bbac83a4648f82b4c9207f43b61e5ec470602076ed4731756c87d4e0e24af":hex:"2c306fc60bff58308f2b9f08d52369e87119d7f6de2279fcdea0c46c901c8dc5b4f83578b17a00786014a17d3e380e1af4b9f32fa58b9ac763bdf86ff0c6084afe413a5dcb7617f94d76e59e370eae4829e69bcb70f10545b04ed5fd137e1159f3961b2c01089ebbe2f16a91c782d4f383fbd4d61b66138319b63d79ce9fdec3":int:112:hex:"d6db5aa539a6e2e70885508d637d":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,112) #2 [#1]
depends_on:0
1:exp:0:hex:"fbbc406a669b94374c7970f2ac10c91c":hex:"a9f334d1ae7d2960f39da4f1df85830d27c0f13fa0bd23d607ace4cf58b359584120e7c90d3062b1b23b1a9e85a740c9063ff80423b5846257e4426c174e8cd77a3dbcfe12970ebddaaa00a8ffb554b2a80decc81f9917f5a1369e8bf7288ed868457993f480d8aff0b92b3db2fda233e32fabec1a4514715364d4f70f98d62c":hex:"46152f5a68c03dbe2f28e69f5b52e2fc":hex:"1052f8b2d3e11da53ba9efe02ce985098d171dff9b98cbc2f6755fd88214ddb8660225a63a1c8bcaf43ff3930e239824ae8e122068b89d7fe73c658ce030cb51dae9836aafb68fad77b1cb5bff8d7d9c920ec449181e10ea643cc73abb9620dbdfa32e06c29cfbd8c7cb8b1103763616ae6f9b19c4a6e1eed88c3971c4778c2b":hex:"7b16424c508da3fed14bb53462d1805f0f9d09f803d4e166fdadbac76f9fc566665554317431642f6e527123ea6c1c0ddcf45005213b0f2747321fa112d7b893cdcf4c1a59e8bd1c48b7d77881c6d79de3d850bce449969305797196d187196d0d81dc3423295f552d3c27d6d70e42c9a1a744a039181e733450c9985c94ae94":int:112:hex:"b51dca8e00988af0987860a663ad":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,104) #0 [#1]
depends_on:0
1:exp:0:hex:"fe96eab10ff48c7942025422583d0377":hex:"194c8bbbfae4a671386b8cd38f390f46f9df6b8661b470c310921a1c858a938045834bb10380037fbf5f5e00688554537be0fcafe8270b9b59068fa056ab1268fc166c2d729243a06650a171c929c7845c85330c04568d62977eedf3b1ba9dca13bdb8f9522817c8cb99e635e37465ec1c9f6f148d51437aa9f994a62e1bd013":hex:"97ce3f848276783599c6875de324361e":hex:"127628b6dcbce6fc8a8ef60798eb67b2088415635119697d20bb878c24d9c6f9c29e148521cb5e0feff892c7855d4f1c0bfb32ad33420976714dce87a0bbc18e4378bd1ef35197d0ca73051148f1199010f63caf122df5f71ad8d9c71df3eb2fbe3b2529d0ba657570358d3776f687bdb9c96d5e0e9e00c4b42d5d7a268d6a08":hex:"12495120056ca3cac70d583603a476821bac6c57c9733b81cfb83538dc9e850f8bdf46065069591c23ebcbc6d1e2523375fb7efc80c09507fa25477ed07cee54fc4eb90168b3ef988f651fc40652474a644b1b311decf899660aef2347bb081af48950f06ebf799911e37120de94c55c20e5f0a77119be06e2b6e557f872fa0f":int:104:hex:"6bac793bdc2190a195122c9854":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,104) #1 [#1]
depends_on:0
1:exp:0:hex:"f2956384a65f9627dccf5126141c7bca":hex:"89dfd185bc33adbea0c69b55d37087de3fa7fd69a9fa76aa1568ac363c5f212ae92d202b9338ef397266dd8bd1ef36cab6d1368feafec69a4e3e11e1bf1beba35d96e040d91e9d3a838966bae62a15b18d621f33efd9ec511de4bd287c722cd39b4ba43e7a6f8c8ab672d69eac6b21a8d3544ab1d64f9de31956b93b1104431e":hex:"2f61f76bcf074a3d02f51816c0411052":hex:"bde1508823be7984d5921db4cab1ed3017c0d73cb9bff9874f39a6f5bc449719c1c43d8fb4e76f6813b0985d4b124517f9e4e2d3c552b2f75876563c93a44c18fb6523ee732ea5b6d13417db45120653df3820a32ebdb42d544768461b1d0b55b46b09f688e47240880930fca7097ddfae35f854891e21891dbad13f661a2534":hex:"023a9c3ab3ed0181ec8926e4bfbc0fa63e38ec8980eabd2ed75e29b681b3ec04cc8b27fad3a7ce6dc1efd680479a78f02de7ba92f45dc03de02852a2e67b35bb1dd154568df7acf59081dfc05aca02c0aa9f3f7b4fd4dbdb671b1b973a48af0c325a23467ba5cb59183540f6edf4c00376be39a3a672feb9e795d1bda96f0017":int:104:hex:"613eeca3decbe09e977e0beeda":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,104) #2 [#1]
depends_on:0
1:exp:0:hex:"2e9bb30ea25f50b3e7711fac05f9d44a":hex:"17a52f4faa608dc9853d4511feb3dd9d2fb92d7a3deb3f8a7a6df3fa2a909b7db30babef12d9da71aadfad16bfd2bcb5706ef2addc58eeb8d8d13f31326f7ab1d0aabfe5525014f05cd8fb80e1ecb0654e62078440157df66f618f078cdf2b322b0f8878bcd924609c33e42059aa69fe0ddca659aea42ab907b483aa55aacc63":hex:"9668e8b1ce9623ad52468431dfbed632":hex:"f776c6e892e373ec86ccf706704d47cd89fa45c2abdeb0f9f6f32cde88c22f001150cc66f0fd83e9b75b97bceb98913cf143cd8a68bf06e1125031e3e7f09dfefbcaef4f04d7bf28aca1992a7e4228fd4017a5b32fc48101c8f5a609eaee9489d02200e8a13efeda60b57df53ccf2fe26309a1c1e1d40db6eb8431dbfe8d43ea":hex:"407171db1dfb7ff20d5c97407375574220534ef75ba18dc616400e5e967e72db23783a6eb9506b611d0c67a83f5c423380ceae66d5dcdffc31e31239357b91794018e9c4c36c286f7b17ee911136d9cacf564baf5f9b9831779375e63aaade8734a91bd4000e53e5e412b3f92f8b68e0b7ad3bf6f274744e2c5a635894bf918e":int:104:hex:"2741ebc33a4d4c156c21385a23":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,96) #0 [#1]
depends_on:0
1:exp:0:hex:"aa705ee70297e9212f70585d92f42aa4":hex:"5e4b47d986d55f49708cb3e4d27072a7e850936b27b24723856acec7b2e03caccd98c2a002a2dd1d3f4dad8827a5910b42986cb00be7bff47eb401be5f324cd2cd3ea2fa41f4ef61f9771a4c0184d85d6023f37f3f54bb9d7cd621fe36ce11a82678a0754a33049106be597c53f287692ac5a42e59f09a2a117fad6c034a91b9":hex:"89822c9db69229d1e4880afd19965908":hex:"fdd655584a92e29a14a368f28a73f9dc608e5c2ffd308d4aeff7326bbef5ea58f84620c9ad43c0b598c271527ae60dae6db4ffd3f590e503ae7057d8c48e9b1bd8f8a8832629bbfc1391b954a4fcee77d40096eb5dcec5e0439375ed455378d716ee8f8b04ccde3291e580068dd7dbef4ba3685b51940471f24859f8e93b659b":hex:"0f34bb4e2a4016ba41eb23e7688edd455f2d46a5097236d9a124ae0bd47349876319976aa4c3aa41680a63cea85f433e3a1b4376f79d004710d486a3fb5afbb7db2c41aca400e04f75ba91660bb68354029defeaae1853447f8fa0d470b25371da73c9e8ee841ba95fc273f88c2e4604ff29a131a7d73e60a00340e886df5359":int:96:hex:"a247e88acbd4e354d7c8a80d":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,96) #1 [#1]
depends_on:0
1:exp:0:hex:"ddeec78a0c23e8c5c32d3d4f9830f927":hex:"134fd6be1a934053a539398aeaf5d3aceda3ef722a6b3568af6958a4b1207f7e9b9e835cfd46a7f3d4faed829ad23554fc7c0d1a9b32bad9477d9dd397a259cfb0bea30268aba7b8cf4a35dbf99a6b2ca968649847f717749bc5f41374e1574ad6c357f7b60b0cffcb822bd3924208d0472a973ae97550b921338792ca88fde6":hex:"ae428ebb974ccfbbdbcf6203105724f1":hex:"e3d5ce768c688e881e72f036341b2d91947e02b7327eb53240c85b0b93a40eb0f3346817e2c9e126209b31b57633c4384f7af46846d9bbe6fd0d6babc57b84d0f5be2a8a7b146b38914a4cea70273d5461126cfd7527ab397510176e790300a06066655907d499bded79f5bb39f6fdb03f85a415c2cc2ad1f25078f0da7df215":hex:"865d6148c9820b67c08c17c9214de612ada6e24ed67933d13c3b3ec43637fa305673d8d52d15a195b27a6b2563682a9f98912908668e3335192b1daabf26e1e73d7d34764af006b0c14a0ffad3b6a0def59964b11eb52e829ad790069997931d09be88b8d60aef90e39dfcb0df4fd54b71597b8ac64670e703e7cb83efa3f2cb":int:96:hex:"64b2458a6eaa6f12937a8643":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,96) #2 [#1]
depends_on:0
1:exp:0:hex:"829008339e983918b8d142091f84ee28":hex:"6f30604d8c2fae216b1ed3d67485631eaada68fe89a7020d6e29f42b937e7640fc1f23c00ba48bf239740f6468289ed211ba81e809cda55fe067bdfa198bf0461daf86d4a7969de9a629513809b358630ce7eb50a783b8c98ec1bd5e56cb47032ee8fc64a939dfc4a870ea9419b16178109f1966ab964da34debcf00cc49f57e":hex:"dc62cf12b6d0439578b457e516d8205e":hex:"e700cd917923b16c968712b2fdbf08be1b5c3b5d9e42cc45465549898daa07c44b4cd321ba16a38aeb6720e217a58428e3a4cc125920cb3fc92f039b66716543bab71b64ebedbb1e5e3e8fbbecff3385ab0ab16b7f6554b7fbb3b4c92307c654361f984d5a6cb69b8708684d90bb1fdfabc0cb59f42c2b3707b3755a8c7abf34":hex:"adf60c4affb2ac76cce20cf9f302b909bfda1bedc60be21b53f65d0b81bff08f7e90ecaaf12ee1f9d921926b75e244b7e8357c1cfc26013a6d1c874ed2e5cd0cce012bbfff0dff85b372d92c18dce887c1651b6467f173a67ac8cea194a6c41e77842675f60cacfbc9c81597a08959d19af632d3c191bf69505620e4290bb040":int:96:hex:"6209c09dd1b7ea85d02eb9fb":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,64) #0 [#1]
depends_on:0
1:exp:0:hex:"4aec55c7e4bb36c32cb543b57cfba3fc":hex:"4cf1443a5448fd09e09e91b7cc5f8e00f53f0b75a6b17db5ab9a721167de5f7bc5de1fb711accdafb7f3f1bf6b98393e5f09e9091e26d1340122edc91f7e60f62caa218f1927c8f0032be0752520aa650f6f1ddf40412c96d49dcc2287ee17834504f1dda3f4a723e2fce064f0b8dae0789ec455922a14488623e3ac10b6e312":hex:"6669c3022e0820634a95efa2b5578e93":hex:"f6ae9b1aaba18acb741c9fc64cfba3841f5127b1cda5cbcd48af5987428daa5782d2676bc3e2ef23936ec29a80d6b5310282b39b77181dc680799ac9c8125fc48afd185cba2ca8900bd9a0039787b4f3a6846f3edf5f7b921dec2608fd3df67600ae0aba9378da0015bd57d66d2999bf751806d1b89214332bac50f721ca9474":hex:"720c32b0d454f086af36a32cc7274e2f2fe08db9cf1cefecc14b42b3e5c573aefa7e9e1ee0042eee21104dc3e4d19b012099280c5a53e40a0bf662d8295dde743143a28be7305729767a37cbdf08fb3c87667939a8ffe44c96ad272e30b75aafada2963bb9636f189c37d976ed1c458295fe85ed19662c463d7c8155e9f04115":int:64:hex:"4b3343b627095f60":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,64) #1 [#1]
depends_on:0
1:exp:0:hex:"8629e8064b3ba2b95bc20dd075f8e931":hex:"85896de4b6454acf8568ccf95ab68a632330ce71ca8b4e7bfe26ad8d7e2e6b63f2032e2cd365999ffd24ece0df16904d749d06e829a291f3d07fccee27d9c6f3ff3a139d9e33f0660803de8fe79dc6ad291fad47c93543522a1c38e40697426a9855255e3e0abcb84d474ead15341c6b235ccd755e58fe6e87898d216d65abac":hex:"dc4bcefe284cfc606f39b057b7df411b":hex:"abfd0cb6fee8588aa68606b7e487bb9c0d2bd11205611a6f30a78d9ccf28e827cef4e966fa245e4b7b39533a4bd00176ce3c97858b0c8abdff4c548c835bf1962a6115c4ce7c05b1ce5aa29b412e816abc925b8cb998eb4b69c43a7dda1b3cf0d728072d42cb5a489db521698c5daffc3013537bbf622ef76a2e96089b7d4b96":hex:"b295ca0d7707892fb08537f42d28a844f5877177f136b4620f69b05c83f43bf2e61323e80076c88660f5385060228bdb91d866686e691cc7e96fdaff41f2ca5f5b5d93ecec7bba82515a6e0bd604c99ef93d3ea013d899464558bc822bd765eb1ca2b8b8a7d961a6a316bf135c22d2ee552e62d8bbc5b60ca31bb53cde82fb5f":int:64:hex:"d26cba11f68a5e1a":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,64) #2 [#1]
depends_on:0
1:exp:0:hex:"4d901e59a491c86bf538f7b38247bb21":hex:"4c370a9f316d25702195409d8e73bbfa40aa15c2b0ea55db9257a9ae4e8dccad14589718741a78e5a74c26a801857e388c9f141ef7df08bc01384b2b2338c38abce51d547056f4bbaf7484f9edc96df122e71f132b7bcb6484228c3ae2f741a2c8b9b208b6f49b07081334b93c501938808cdbd2e40cf95ae4f27a29e1121480":hex:"39e2788c9697e82cae0e222a9e413d8f":hex:"48d7d20e424df3c3efced29e860771647ae01312a96e68d33f982c540e74160a7fbdb623d4b19abb1871d74c6dadc56038954b154389b752bebc40cf4ee1505ec8d844e1a04dcae430befdb081cc84252e0840f5f5146ffe5b9594f856afc2edb33b3c6f9041c9631c5e3d812959c5504938635f72c6fe29a25bbf66a4ecd211":hex:"262718671dd0e2c9a40b9d7297c7f6a26cd5fe4f301999a32059812719896d3a2f5350f6ec20d999fc80b8d7af5a421545b325de9180f14505f0c72250658a5014768fed63ab553de0fb01ab1368356043f6d1a6c9950c80e3d9d4637bbeea44c9d58a4148bb10974d507c62b67cc4e37eaebd7eb8e67077856cc5d1702f8e2d":int:64:hex:"bd814b4584941681":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,32) #0 [#1]
depends_on:0
1:exp:0:hex:"2f54229167862034ef6c5ff4a1246697":hex:"af2c89d3600329779abfbcf5be8bb83c357d4d2435fc8f4c413b956b898d22a8a889db9e2ff5e7229d7495576989695a0b52d796f9a23e9570b7caec6b46059749c29a293d31a6224baaf73711bc0e4a587abe9d0379adec6de04ce444676dfd8672e6660cfc79d7ee2e7625ce57dd4681bad66aa29bea2baf936122c3db17e7":hex:"8168ef8ef278c832fc0ec846bc9f62e9":hex:"abb9ed24137915265bddbd4b63f1d02efa2a99c8c373f19077c7e1c389feae36a7af42c661b0adc5dc8e4b5520d334e8e0e112d42c2977fa23485c0a85aef83f1e52d6749bd29cbebe14aea6ee1c1098aa96c6360b0192894bb2001c7c0fed7f00bb84953c23bfdda00818d1568fb94c1bd971982d6c01c12a35ef7af34f947f":hex:"cd6dede25433fd3da6137001219b57aa54bdf6039a5a8d66138171b006194fe3e13d484e5cf57a1acdaa8e76f001df7bf41cbed2c5561a37a32113fa116d0918167c29dd9e7d46f7c18d9db33d7f1bc33ac21d159ddec57a2e158f0c0993c16dbf50582371100a8d7c55cd47c03473c5770ad562240f754c99d95ec593dca284":int:32:hex:"4ab63349":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,32) #1 [#1]
depends_on:0
1:exp:0:hex:"b7b52fe74c5c3266edf731578d28a72e":hex:"01a4b7da57c0f7d9aea51283004b23f899669dccd6dbaec9cd6e747c7adb52432c7c29d1411ec1df4e5e33311ad84218075dabe17f73c95511ce7950f08b618feff56bd452b33455a1a03caa8371dc7fb9aebedb3cb652d94e06bd00a98bb06d30b506d41cb516c759f6d7f793472e6d6dc9ae50cf3dc8b1ad3d0517c4f555a3":hex:"a005750e9f8c68ae238668f0a8f015ba":hex:"805cf3635f9d84c7608c242ee23a4837dd3f260de9afd6166b08164a0256200be9b52e5259a4a54186ec067ddfad90f5c4f92afd1c7e4f2d8443312ba3c4818b664439a02644e55467045071aa2cc7939a940e89cc52c8a53623bc6473bf843a4e0f00149b2ce1543a6540aa0d9c2c5b68ba2bd5791078deed1de3b5f48257c5":hex:"d6124da0896d99fc7f2c3688fbca164f8fecd75b6260162c4dc2d2773ce75cf41a8c7a57998e0a7e49cc71e5ad6a04c7415f8d4fd11f1035d3a02ed744345d74ebc9c4f202f65bfa88d55c747fe777225e218f2149da22b53e6584823dbda42cc2dda56fc72b753f3923c443eb5c656515dd824d8c08cc78152226ed8c1808db":int:32:hex:"60d86287":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,32) #2 [#1]
depends_on:0
1:exp:0:hex:"7a3501d9fbb86ab80f5faeaf8876b7c1":hex:"4f0dfbd2aeab70c80814a1f261a1fe442eacff5d267fd0c0f93757919810f6610113f1b442270afcc47f2fa01ab01797683ec9267691a0dec45033c57f5cbdfcafdf154fc99e6140176eea92503b3f6fee5dfa5aad05f802e08a08f10e49a8b32a50c028f2bc7aa451be3747d10b96b3a1105c67c5167eccdc18b4a9b0612d03":hex:"6d59be1833e75ce7f54ddc91ad6f5187":hex:"3e556b1b33c42f1ad6cca67dabc6ff79d6cb667527335858e26cb4f6a3d8503ec415968ba97d2d79a3f80c1a10d75174eb5294cce8b89224eba7dfb258fb17cb5c5db7a914ace06e94cd2f2cafe3febc8adc4c2264afa2db2c6356e4c3e8667393a77a0afc36be678d5c0a4b63ae82d9922bbbc60559f331ece9947b67469469":hex:"615ea4535f1e579d7aa45c011018f272c2e234c3ea9e2d102cfaa4a437c41e64bdef7a211ea4d858bdb656215e600911435ef9c8da68e8239e4782ced7e7add063f33f5bc62b85d9ae44ed1b139580118c5fc054ead08257b0a97632e8c503c6219294af423f0deb36758e05857ebb05c6835972488306ebfedd2ca4ce3b2c48":int:32:hex:"74c6bf0e":int:0
AES-GCM NIST Validation (AES-128,128,0,0,128) #0 [#2]
depends_on:0
1:exp:0:hex:"195ddad2b0da195ea54a9dad0f86c161":hex:"":hex:"265ab1995fac4fca7c2b26c84e4a2dbc":hex:"":hex:"":int:128:hex:"930f719034b76c232619ef2792fe6e65":int:0
AES-GCM NIST Validation (AES-128,128,0,0,128) #1 [#2]
depends_on:0
1:exp:0:hex:"12be48e90c849063637b1c2ab0f2b467":hex:"":hex:"0020c3dff2f6f3acaaae982ce38f63c3":hex:"":hex:"":int:128:hex:"c8891f32b8015024ca42536d633b1863":int:0
AES-GCM NIST Validation (AES-128,128,0,0,128) #2 [#2]
depends_on:0
1:exp:0:hex:"8e792fc91675d5efd4d80d5a06378d24":hex:"":hex:"15ad63b969f8e313eac3c717ff9a994d":hex:"":hex:"":int:128:hex:"de9a04b030954b0141dd78ffc67323d6":int:0
AES-GCM NIST Validation (AES-128,128,0,0,120) #0 [#2]
depends_on:0
1:exp:0:hex:"a668cfd45b6ef8b766a4bb187d0824d1":hex:"":hex:"a111e94a6426ad9b4362132052eadf4a":hex:"":hex:"":int:120:hex:"3a3331e6a41cada2cca8e856135549":int:0
AES-GCM NIST Validation (AES-128,128,0,0,120) #1 [#2]
depends_on:0
1:exp:0:hex:"f36e07f2689832b914e0b817010c528c":hex:"":hex:"654104f9d16348231e6ba6fd30c1f02c":hex:"":hex:"":int:120:hex:"be897583bae073f42138d64e622c35":int:0
AES-GCM NIST Validation (AES-128,128,0,0,120) #2 [#2]
depends_on:0
1:exp:0:hex:"25d839a709d98ef9c0c9e78ece961eba":hex:"":hex:"b64537609040790ff648d51406710b9a":hex:"":hex:"":int:120:hex:"4d5854c69cc973be8de41d5584407c":int:0
AES-GCM NIST Validation (AES-128,128,0,0,112) #0 [#2]
depends_on:0
1:exp:0:hex:"957dd619f9f19445c374ceda9e9ac082":hex:"":hex:"34887be03b4d4ca8ea2261b600ab0b0e":hex:"":hex:"":int:112:hex:"60e2d50adff707d8b279bdedb277":int:0
AES-GCM NIST Validation (AES-128,128,0,0,112) #1 [#2]
depends_on:0
1:exp:0:hex:"a5c9a2dcaf576e67828e806082d8e780":hex:"":hex:"f93732aac9448c4a427e634089d7edcc":hex:"":hex:"":int:112:hex:"f67ed1c98bd2c5f3a738e75f15ac":int:0
AES-GCM NIST Validation (AES-128,128,0,0,112) #2 [#2]
depends_on:0
1:exp:0:hex:"0a30a816e8d4d85d40c8e4d7c93b777e":hex:"":hex:"bf1f332aa19682d05cf95f2b03d26af9":hex:"":hex:"":int:112:hex:"acfb2f7884bc496f3089e50dbf42":int:0
AES-GCM NIST Validation (AES-128,128,0,0,104) #0 [#2]
depends_on:0
1:exp:0:hex:"b45a16bba5fba362704149dc56ba8a13":hex:"":hex:"64cca850412091bf4e120ccd612df353":hex:"":hex:"":int:104:hex:"7b1adc23af9be185e5ae0b0f0e":int:0
AES-GCM NIST Validation (AES-128,128,0,0,104) #1 [#2]
depends_on:0
1:exp:0:hex:"0cbcbc1c72aa90e3ea7e2fe328d79723":hex:"":hex:"2fc5fd964b45082546636ae1e208a937":hex:"":hex:"":int:104:hex:"fe091a768c731e54e2237bfdc4":int:0
AES-GCM NIST Validation (AES-128,128,0,0,104) #2 [#2]
depends_on:0
1:exp:0:hex:"94297a1ad3f0c333cd9b087b1efd43c0":hex:"":hex:"52ec9dc82131d7b1c69c01fed6aada10":hex:"":hex:"":int:104:hex:"5c927dda855b76ab8fc077203b":int:0
AES-GCM NIST Validation (AES-128,128,0,0,96) #0 [#2]
depends_on:0
1:exp:0:hex:"1e8cf32008bdf867f0ff76e7d7ec21bd":hex:"":hex:"3854b7412de72fefcc4b0c2155f6910e":hex:"":hex:"":int:96:hex:"cc8e7eccc056b06cffc307e0":int:0
AES-GCM NIST Validation (AES-128,128,0,0,96) #1 [#2]
depends_on:0
1:exp:0:hex:"2ce1a9bd93fdde2adfd8c2c16a395b95":hex:"":hex:"64072313ed36eef8209f079fa622d7f0":hex:"":hex:"":int:96:hex:"cd9e8ffc1423270015bf8e8b":int:0
AES-GCM NIST Validation (AES-128,128,0,0,96) #2 [#2]
depends_on:0
1:exp:0:hex:"b15354ad3d874fe472719ebccd45f123":hex:"":hex:"1b2013153290edef60a6a438bd7517de":hex:"":hex:"":int:96:hex:"f65a841ed510becf52b1eae7":int:0
AES-GCM NIST Validation (AES-128,128,0,0,64) #0 [#2]
depends_on:0
1:exp:0:hex:"14ef129784776647eb3fb8897915ab9e":hex:"":hex:"f7bbe9f699156549935f2b92c1dda163":hex:"":hex:"":int:64:hex:"dd10fa64fd51231d":int:0
AES-GCM NIST Validation (AES-128,128,0,0,64) #1 [#2]
depends_on:0
1:exp:0:hex:"5d4470053c46a577bba7000075e9bf2c":hex:"":hex:"854b768fdd7492c21618ca716bc8790d":hex:"":hex:"":int:64:hex:"1f3c73722006023a":int:0
AES-GCM NIST Validation (AES-128,128,0,0,64) #2 [#2]
depends_on:0
1:exp:0:hex:"ea87d675a0d406c57f78a2531bfc0c9a":hex:"":hex:"0907503fcb06ee384526f7206180a080":hex:"":hex:"":int:64:hex:"65d5466392b63bf6":int:0
AES-GCM NIST Validation (AES-128,128,0,0,32) #0 [#2]
depends_on:0
1:exp:0:hex:"d3e8e27568e6e17ff807cc207e5d4eea":hex:"":hex:"18e51cdfb4a3a5ebc7b0d7b17727aa95":hex:"":hex:"":int:32:hex:"a7e3f637":int:0
AES-GCM NIST Validation (AES-128,128,0,0,32) #1 [#2]
depends_on:0
1:exp:0:hex:"596a602164b1a0bb50ef91bce3a98796":hex:"":hex:"2025e72bd6a511980a8ddce34565d16a":hex:"":hex:"":int:32:hex:"f84f92de":int:0
AES-GCM NIST Validation (AES-128,128,0,0,32) #2 [#2]
depends_on:0
1:exp:0:hex:"d0194b6ee68f0ed8adc4b22ed15dbf14":hex:"":hex:"32ea8970a8cb70d6ffb3972a146c6984":hex:"":hex:"":int:32:hex:"eef4b97a":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,128) #0 [#2]
depends_on:0
1:exp:0:hex:"869ce65e5e5e12c620076365f149784f":hex:"":hex:"317bf07e83c2e9717880b7d080957fe1":hex:"ee185d738260de67f1792a7d548ea73267fbbb6543bc081fac43e00e6cca92d7d646f27054894664ffdcbe635e34cfa800912b59fdaa624b36c44c9ff4f193d3be2f97a7820a6d4ceabe967091ef672098baf82dd3b671cac4fd4f4b14e4ee388fbdaafb4dab2385df4fca23a78d31f11bca15eedd7cac778484258778106a07":hex:"":int:128:hex:"add6c89153c4c0eead03df44487742a0":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,128) #1 [#2]
depends_on:0
1:exp:0:hex:"0a05baee927bf23dd2f4b57b90fb6434":hex:"":hex:"8147e99dc9e462efea9c1d7f30bdf45c":hex:"6424ca7fbf24c6c3b0b5eb9d769b26a9792c96a8585dc596208ae6cfc0b265bd8d26af31027f278bb92a9e3b365beae8d964ec7a4096513f84fa73f8739fa7e11d54d678bed19546d2b71b3d0166b25b47ad7cfa69d74057d889258a796a65f2bf8d3bb151f4e721d398e74594a186e6182c16fe4c8813dfec67215b3c4a94c0":hex:"":int:128:hex:"05fac5520a99ad7fb407c48995a2c331":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,128) #2 [#2]
depends_on:0
1:exp:0:hex:"e28c435211743a7872e4a0bd7602336a":hex:"":hex:"2ddbee94fcbfacea080ded468f67180c":hex:"63190ef542656cc2b69a9b0daf8dbd2d38cd75f17b92d6d891c17b0337ad4fe4539d9154722fa430782a1d79620e974661918166e39c453c5a98759a13d2766138c7750e6cbdc7b6d7cbe44f3f4de7bb562d9bce6e6e2e815444842b89ba8b73454218c483e574ca886a84e8c9aa6f56dd1541a7e35a4a5b8f6a05ad5bb013e9":hex:"":int:128:hex:"2ce6d74cda466354a736636bf18acfc0":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,120) #0 [#2]
depends_on:0
1:exp:0:hex:"2b2bec16c7d326a35a8e4c0b8c2e3674":hex:"":hex:"4573eb54491ed91bfa2185b762115bc8":hex:"7a4a6b3114dabc50b201472c5cb13a79430f78eedb2ba8492c01ce10a74d08565b9bf9874bb8fb72f694a23babdd08684cb68d7e09e65813728aaa5c41f9c2b10d921f8271e200e0c519c7c46f572bc9fe3f27e13d1e6d7bda4bd66c1c4b0fec8c68a1b0ed7b0659009dc894ad55e0712ddd0837315734f2bc3b757241af35ba":hex:"":int:120:hex:"5f5d4695795b8580b0bc414a81b002":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,120) #1 [#2]
depends_on:0
1:exp:0:hex:"886fb12554b075dd9663efd076acbe56":hex:"":hex:"7e7a73542868fc27a01865c3aa635ad5":hex:"cb25c2f029c7a877a0aa565c7f7347b317ad534821edeeea838996dfc42b13787e5bb237525ac926ca8a6c5078210f4a27863e8114c728d09653fa93ae990e99f0c856bc8097c2cd33cdca1a407897e2f495d2e75356aabd891702f25ff20e6b6c8a785d74b78a734e311fd236f9e970202674004ee4151879d59340b20aa23b":hex:"":int:120:hex:"8255116ee1e3cf936633017c4dec3a":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,120) #2 [#2]
depends_on:0
1:exp:0:hex:"920fdf4b39c63947d57a07eabbf3f2f5":hex:"":hex:"77431ebaad53e42ca7eead0d45e5bd18":hex:"11f82f9ef7c2161ba73cf7da82c5397da5e8278da180a976f43222402e983b057171f793641a8343d6366d6cc9260dfe8becb8396b5bcfa0f46908bd809bdab61126cbb8d63f601965fb9e4b3afd66c594dfd394d4cf06f79f361771a85dcead6f45dc7df10fa434736eb109a76fe6cda32c5773d4db6449494f2a3f6c884bfe":hex:"":int:120:hex:"1291cbea1a9f8b166c7306ff9eb281":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,112) #0 [#2]
depends_on:0
1:exp:0:hex:"114060534f526895f30dfb4007356ea7":hex:"":hex:"5ed7fb59618ec3d081e60d8259a3f184":hex:"a56566a98d9d4fdcebc932adc405e0b8190d537f931983168283d0431e7589333d42f2a3d6e41f268e7b566cf48694cdcfe01fbb9198804ad39e7d387039575c5de787610a23ec265505a448c3a64ddac1b0d8c567eefe5c3c2dc1bb15af45b4bd8fc2e1506ddeb2e39e04f72fd24a64cbbbc929800e0687b53eb89b3049f271":hex:"":int:112:hex:"62f770b3985388ac37e14e8d4696":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,112) #1 [#2]
depends_on:0
1:exp:0:hex:"697ca4e9de580b525d7149e8b69e8093":hex:"":hex:"e844153734eaebd86983aa3bf50068df":hex:"cedcd5ffeb7988837c38a0be4234ab1b03f14367a1a3854b6dc9f33eb9a87c411326e5cb7d12dc730cb6f363da2ba68affdfb651fe497942e0dd59668f56c23dae80b7bbf905d36b501ff037fcdffa472efa4bcc1c975b67e5d7f348db73e0ce648b44ecc5b5bbbdf3101bf32ea99e3c8e8991c94fa609c93d4b375a4389023b":hex:"":int:112:hex:"95becb04cd39c868c9dbd1d4e59b":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,112) #2 [#2]
depends_on:0
1:exp:0:hex:"2fa92cc97ef469efeb2c25838193435a":hex:"":hex:"07e6492f2377c04a85045d24940fbe8f":hex:"0f021fb787c6de2be054bdb2741aef82ce35d951de2986c86c3dac77ee0804dfbd010d33a5dcc109769d4b8ff1471eb98fe917c7b0b374e80539f2f4432f92aa55d8398a71510c2acf85c54975fb09ff5638b936283efa3c1d3b054865f97685d6bfa0dfcffde3a20525b5324573b69dde230ea87c685e4f6b5c3c4c55828a86":hex:"":int:112:hex:"397b2b0dad7f1926bfc25a3ba0ca":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,104) #0 [#2]
depends_on:0
1:exp:0:hex:"a61f8a5777ec3da0c3e257d421286696":hex:"":hex:"14894cc4ff71e249f0053bbc1680331f":hex:"9df46dde257054160854248e70625183bf957ecec36fa4f5a79a1650e04b500f7f2fab4bb873f0e813f0d6b17610bde0de95427a8e2d1293dcdde053f5b1a5a81af25d553289e89e77e4ad7d0a1190151724730149050bd021ec61a08ce2271390161c752df8b5f61c33ee39366de4c1db41d085ab9dd88e170e8c41c571e2cf":hex:"":int:104:hex:"e062ab7984221ed226be353731":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,104) #1 [#2]
depends_on:0
1:exp:0:hex:"aa2d04f4f5258c6363b1210c91aff7d1":hex:"":hex:"6b24c03273dcfd508cead2df0c65ef2d":hex:"81a1b326f8f22bfecdf1f386bf8fe678a427e3886801b823a37860b9a832356724b1d352d6250cf8e8f89d0bf2314fd11464c3b4871478f0bc290ee1096c8f6cb5484176d70762289b44309d6a88e4750185abf30901bcf8d952da9abaaf9807c0c0ee8be2b247dbbfd182b83f9bfa67ca3bf448c3f5a3de3c31b058c3f944a9":hex:"":int:104:hex:"80dee09fed5183d6405beeb268":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,104) #2 [#2]
depends_on:0
1:exp:0:hex:"cf221e6cade9f6cf509afa6979cc1fb9":hex:"":hex:"d35433be41a259dfaf58aac1d82af462":hex:"b31c477490e5624c4aac8e590725bfa8b3efca618e2369e9b980d6a463a014d55aa8317a9e70ce6de7c574cd15242cf4eb3eb078cd2f49fd82d1a56c6c4241342e62a2e9d94f0aaa024055cb441d650f0a6ecabfe9ef563d6bd87d4cb1bed348aee42487c13b73e52fb70f0ca6ed81924fd519806e04babfd08df1a00191caa1":hex:"":int:104:hex:"f1776b1ee7a3c49f99f34f582d":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,96) #0 [#2]
depends_on:0
1:exp:0:hex:"c98eb634c7caf52d3f3d9f344e141988":hex:"":hex:"a0e58176826910a69c2d68ae1c6a05c0":hex:"6e559278bc469cc670c4d9105c3c2f8fa308e11b4a60f75664a9bfaff4f0176175ddd3c6c17ff91a208dbbc7c49efff099fa873f60849ffaa3a3003419cadaa06b92a678b80bf6c952bbbe596dd0a2eed35507c55c48a9e6131bcbda0621cff87e02be5d082944f2c8e27211527717272839601b0e26cb5aa2301afd05ae1b35":hex:"":int:96:hex:"3d8617b2db536ba7d367013c":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,96) #1 [#2]
depends_on:0
1:exp:0:hex:"c5018f4a8e2a850979b006d0498dd0fe":hex:"":hex:"75e4bebdd170159cff59f895ebdeb118":hex:"25ed2831fef205690381c73e925ef7ba20d5f2e3a4b5d7beabd749fafa08a6941acb1385aed977ea824322d378649f646a812e6c87ded6ae437c68ffdd4fae937a8498ae825d7523746730af84d56380be8f575c60e7f836a862343916e98cc2aa5a27cd63cd92df63b8bb47c81fa6a53740a125bb9cbb247c916363e60f5f65":hex:"":int:96:hex:"0aa5aced93e0237bea9a0015":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,96) #2 [#2]
depends_on:0
1:exp:0:hex:"cefd40aeac28fbea6e3343a125fe1c9a":hex:"":hex:"324b9722166edc3831bd19c1db5bfbf2":hex:"72b7a4289bf7f5a752665839adde8f79644424839db059ce40de326414c09691d5c7071e43722104a94e430e263bc974b98f167c50b97490bcd4286b502f607ddcec5387695463154bd9598ce8ffb6104d1f7010bc196ea2dcbfbf452d6257b1da00271fe1e6fb56c43656d5570b965e0369502443536cc46d4c05b1e863ed8f":hex:"":int:96:hex:"0c6b28de22e02fe6a4595d5f":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,64) #0 [#2]
depends_on:0
1:exp:0:hex:"58cb7cb58518ff3fecea4b44ad9fdef1":hex:"":hex:"fe619efb1c9502c03cb8a70792f9e046":hex:"1a7c444a84267f52c36f3c09f8c4a88b6ffe3309b8edaad93a08d3961af28b7c2baba5165f0a9efe13fa6a0ac595da156741dc7f728c11edbd8ab02f03e45716be504778a75374ee882af488bfbc6cdd58fd81d3ac5f369f85ba42c6fd7f9df4b25fdd2fd32607ea800047e06058388c4f71a5eb4d825e8578106041c84c25a1":hex:"":int:64:hex:"8243f32002d33cdd":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,64) #1 [#2]
depends_on:0
1:exp:0:hex:"15cc4cb979a343f4adfb821d6f6e9c66":hex:"":hex:"68464e7eb64360c7c0a8540ac3473513":hex:"d69f4a9595a48a50ec33ac1848df3d994eff838b28ea7c8b2c42876dadd60a3f9769bd4f61d8007c9dd4fde55edcec8f5ac3bf23b1a958fa714dd88cd5261edb69b7b086ef0f442179943f0871a6253aae99d31fdca448bc3efef353b5cc55cfc576e4a7fb73a5ab6b5af58dbd381bf7f9d69a5c2bfc902901fd485967b23bd9":hex:"":int:64:hex:"c0f4302d8276c3d3":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,64) #2 [#2]
depends_on:0
1:exp:0:hex:"6398de910ff8f3acdc2217811a1da2a1":hex:"":hex:"fc69b21ec18195901ffa62260fa20454":hex:"021f225240cc9a68c4886824d373f3a70fa32b3a926c78164642450287d269d39dbd49c8c71ce7b914f83e8b53bc61c6773f98318557b45f0cc2ef2539939df7a1e6765117f75631dc5640291d20e6402d22cd2e231f9c2c67cb24ab5d8a69933c49b89c9fb2ea57136a6bf1bffe8e04d8d6c813040215f051c654d93224edfc":hex:"":int:64:hex:"314d1a332d3c590b":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,32) #0 [#2]
depends_on:0
1:exp:0:hex:"382d86868ccd08d417d94f3b73729e09":hex:"":hex:"069069c377958235171437b34e0fce76":hex:"049af372e34ef7a92d0d49cf2dd03052dabacf2982eae6a817e6146ad799971be239ef5810ec3f6cc6990e9641a7b696392ad3faee38bb50746c1e93913c02dbbcbc6bf54f0d062f176779b7c0dd5d7ec7752601c9812fa80508a78bbd26922bed4f64b1ff2a8340ce1c01e317e3526cd8218ac24af87b07f8792849f6479b8e":hex:"":int:32:hex:"ffa59fa2":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,32) #1 [#2]
depends_on:0
1:exp:0:hex:"21052b2fc7bc7a662aa9dc4b6a04f25d":hex:"":hex:"d7e5432def6a24d486a608e5c5c919a8":hex:"1970ed40003bccabf7f3c57bbe5ba27e4254c1511413ed421cef3a6ffb9f0192987de83ae965478c3e9979637f8b3fa5d10d69b916f03fdc92ace7736f171660156d880114aefdcc164adb6f8c03940d9b43ce8881441b41cafee3351a56fcb632aa4b09ea81adea26fb0d8c6e1ae380df922a429ae1f5b82b38d9bda4323c51":hex:"":int:32:hex:"ff342f4b":int:0
AES-GCM NIST Validation (AES-128,128,0,1024,32) #2 [#2]
depends_on:0
1:exp:0:hex:"b6c53aa91a115db64653016375bd747e":hex:"":hex:"8163a4fd9c2c7010bc85c86177b194ab":hex:"93cddd318b999262c7cde2838cb5c4d78f3eb1e78d305e5f808fa5613526d724e84a0188ff42a2c34bdf3b5fff70e82b3c30346e179fb3faf378bc4e207e335a44da53a5ae33770104b95397fb5acb746e6418d0dfc7368b035af53b470fc66bd0c210b68ce1b276820b621e919f044e5cff5ced7e07dbb8825bca6b4ddd8ee2":hex:"":int:32:hex:"50b8acce":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,128) #0 [#2]
depends_on:0
1:exp:0:hex:"2251815f5bdfe1111c7f9ca246662f93":hex:"2247e781763edb1349db2cda53e5853b726c697b34497761373c3b6a1c44939207e570e14ea94bd5f9bf9b79de9cafedeabc9241e9147453648071f2240e10488c6e3d7077750a6f7ede235d44c5a96392778ec51f8aeb1a17fabe9b6c95fbc479fff954a676813ad3d2f71c76b9d096a0527f2e1b151aa8972147582c0fd2bf":hex:"58973280c2a7122ddfcb25eb33e7270c":hex:"":hex:"b202eb243338849600e2feba7f25a05fe98323bd7cb721ac49d5a8136422564391462439fd92caad95fc8cdcaa9a797e1df3ef6ba7af6c761ceaf8922436dd5c8b1b257f801c40914c1331deb274c58eed102fd5fa63161c697e63dc9dfe60bd83cea885d241983a7e5f0d6a8fd02762084d52bf88ec35f156934e53dffc0395":int:128:hex:"c3701ce3284d08145ad8c6d48e4ced8c":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,128) #1 [#2]
depends_on:0
1:exp:0:hex:"3199b70e7115c74e3aa3745c18fce8d1":hex:"4fa0b090652d5a8dcd9b5f2ceaaa2dc87a40b30e2d59bdff09e1f204d1b90371de70935c385cf5b4d7e0c4e88661f418705370b901b97bf199b366e669bc727882d4aedf8171a8c39431f11af830358cd0d9e110da1a0cc6ef70efb255efdac1dc61e722a2d8b7fb4cd752c6350d558ae1ccd1c89f8ba44ab697df96681ee301":hex:"808a019f7fb761e9701c0c4f1a1690e4":hex:"":hex:"8d5ed4146fb491db9456e92f753aa4f688a9bc276e6aebb782a0cdf7fe578d74ca3946fa7b7893eff6345e64251cb1b146442acb64041324e2847481fd4388b17f83206948e67c1e66b894d5d40ecac0bbe4db0c6f58b65a1f19f29429a9e76f78ef5dba0c94d88dfc06e6222a506f004d24cdb3fe26d6eb6e08e4fdf6289651":int:128:hex:"908806d668451d849ba0268523eb0e4a":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,128) #2 [#2]
depends_on:0
1:exp:0:hex:"63805cef84ca7fcf281b226c3ae37230":hex:"543fd64d1454ef6c007ee96b3ff5d2e4b7f5d15c23e7548dfd1dfad4da7774b8795e817fab3be7fbf8e4d0d351a743ea793d9d01385a552f78ede054be079aebd1511013de2096456e9fc1b83457fa1240cd39c17440d4b55c4e390119a759055ac851a02ea481eb83e294922d35f687a56d801eed638d289350e141116ffba8":hex:"1aa9e75d7854509a85d995ee482b8eca":hex:"":hex:"98db9e8e3ff23f09e585e5326f525e4f8350a1f233a0aebd60d5951583eaf5220f1690ee3607ba98cf8cc99a90efb7197835957f2bda918a32e528f55d548e3c83d65910b956634224cd5415ff0332c165d1241f7a93976649ebed2cc7e62addb76231bb738ee8a291b62365965392aeb72acc5f0fbd2f88f5613fcf44a1b074":int:128:hex:"9b1baa0b318e1f6e953a9f90b21cd914":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,120) #0 [#2]
depends_on:0
1:exp:0:hex:"2ec9245e8f567e1cc8795bbf72f2999b":hex:"f266d0060d290339def5f6d8dbf7d120a4c645aa90470e168b4f35342a00b8c7b7230003657d377d8568d252765df142e97a9dbfb9711d9ccf396f3d51bd91673f129d58efd80ab83a0678303e29a0dbeb1fa9fdb7fbde586a17ace65e894374ec8da1ccd3e21851ab998534de46cb43b38e241edc04b5c571dfc0aa0074d4fa":hex:"413628d9ff3e4067d840b0abc2cda0eb":hex:"":hex:"145d83092a269c8afea604e9192b8bb550b9bea85f842fcc4997c2b00c6f3ca46100e814e82389f27a69a12d29340c5827e607657a00fc72c4de30079e23760769e800ee4ce46957f82d61935d07d1c70dca836c19969dfd0fe0ea740a52e2d09b1c9aa137b5e8527756fb2c2298f8400949ba24a8351c1093626723a68a79f5":int:120:hex:"ad174d1edc713c187a5859a390fff8":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,120) #1 [#2]
depends_on:0
1:exp:0:hex:"b08df4acd253f9dd4abc52c4be488015":hex:"82f665910d853fd2b775bf66a1707935443574c90483fc33ba02d6479fafd99c5f816bc58a1393a44fb32711fbeb0d6936efeb3580f147c3019e9f2e2ef48b202bdd369c277791bce524f3b22ceb74c664143c4b1da819b229a5b480aa954be110ca006615d9cff5a158342a47cb6d04fbb817ae4ddff6d4f86b74205799c9c0":hex:"e1c27d35520ea527f9a2cd9b0f717841":hex:"":hex:"f5b0fcd812061be999901595b3547e70f7144cc9e0b0098262be4c440e8637af782f536f571534a658ad1fb44360d9c454d1000d6957f261401e09c0f19f5146ee5433e378423f9c94a90af2185d38cbe2940a459d8409d987d04a1f3e686c2b91d4fae1f3e3bdc5a30569838201b7d30c7320d7cbd787bfd6cd40e7e2d071a1":int:120:hex:"fa31e58fa32d1208dd8a67fed44033":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,120) #2 [#2]
depends_on:0
1:exp:0:hex:"9c08d6efb167beb035f71554f64c12cd":hex:"704f59d5202108b949170532ac1e78edb0e06fa323c1c69202d7d22dea4d7342199cebe949e980a21ff0fac282b868cc31ff4f6674c393c0f2cae2374664314afaf7791974b6bd6af26ade7fc266a6cd2de4f3c1f479f895ff597998cc8b929c1f05db13d9b9a4d98c9bc606eee32915bbdaeec6576e1fa6e8b22e0bb1098074":hex:"608d56f6dea2fdf175eae189d42a85fb":hex:"":hex:"2c7d2618808adcf8edf5a54119471b930e07488d5fac3dcb53f4ade43674d162881bee1f27dea6d158b254d4b432e17f211515bf595a9874d89f8cf748ddaf2324078029c6463312ad32eb0aa5ebefc31c7fbfd04b37ba6b766375952c211d160b943e9d3c5e144b581157bff9071d31cfc082b55c4a0fced386ef2fc75e1a7b":int:120:hex:"7a1ae03e2838294e286dca4fbbd9f1":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,112) #0 [#2]
depends_on:0
1:exp:0:hex:"192dbfdf86e48bf18710e706dc90e356":hex:"1d7c45c8ef6f9f073c7f186e4c876c2b8fbf22feeecdc111a19071f276e838ab0572c9a68e9ad464fa88ba8d8a162e9f5ee1c4983395a890990357673467988c057eb8a0342c41867baab41456edc3932531d1c4aa0b42ce2b388d2be579dfe332f40a9b864c5e33e2b3cfd73b68d65c4db9ec46d3ba1587a56cb7887dcb3c5e":hex:"1a511f85e0e138f4241882c20689f881":hex:"":hex:"3e50e821fbf83433155de7b4eb3c9a2c148b08d9d3998a3486f517fb5d0a1338faabbf95e85fa9186385bcb9e26aaa5e473d3cc7af869872e4fb36ad16c5468d994e9c71a09dd2868977f3f9064664f6ffcbac1bd313a7803c304273d69ad20369bad36adeb38480563bc6db9aa0d11a0e03d09731171c1229a756037b2c285c":int:112:hex:"9393edf0934796eb97a8c513bbfc":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,112) #1 [#2]
depends_on:0
1:exp:0:hex:"daf9455bad8bee905c6cd464677b803f":hex:"af04226cc6eb84f8167a68c2cfde33a1521dcbe781e7b97a3fae732bcd8c0616a588200328902faa5a65a27e769a720d7ea23333cc1c66c4d4e4c53facca5d6af06aea7fb49b12b04cd6ae38fe28d71cd66f769d640beeb07f508a0e3f856902cbfde6919077de378cf0486cf177f897cd0a56b69db3a31b448ebbf8fdf63736":hex:"6cfe8490e892f5ddba8bbd1cd522ba0b":hex:"":hex:"e5622ca7360272a33e30f7fbeaa00956e8af0d871c433c070c8854d818eab9717293e845106770ec07da372c75266239a225ad74465e255520218c6736e51070477d70976aa7d449c32a5c85bbd6931c76e9e4355f9697bad2ea3bcc0be005da15c62db219b074b71fe4a5512157143df2c1f70bb17c6d3740d8d20eef88535f":int:112:hex:"25fe6c9b2303b40ed31d1beea39a":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,112) #2 [#2]
depends_on:0
1:exp:0:hex:"82d166dddcbf4f7f66aa5ac6b12516bc":hex:"7883f4f96c0ef7f6d9fd7c2eaad25995943078559eb24a3e6650126ddaa32301b04f737dc27b648d6115ce08feac862cb888073b22aa648c752934bb7f9c566209a97499236f782758d6f6f9a012a2fb6885ca91858f9779cc93950baa731f1874629351e6186935475a20593f66cddefff89be0fc0f9b57695b147d9acd8157":hex:"540c2a07689bf314bc8ede71df3f4358":hex:"":hex:"44806e76a40bbbc2de860cd36e93d64c9f4c11994f754db6a279d6eaecfdf19966512de5223d8332a407381114d50fadb03e33e347a5f4d87c3fbf35f2d5967ba295003a2c6c12fba8394aa5b7a31365791c630734a6b2ef84eed0738cb4bc229e93c4e8529aaeadecff7ab93887b9fad5f05a88a5ba9fb449053ce4c6375d1f":int:112:hex:"756d65c1b8a04485c3944e2a3cbc":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,104) #0 [#2]
depends_on:0
1:exp:0:hex:"81c1fca371968513a68ac09a7459042d":hex:"182cb89c94171b685016bad76c445cc4561aff8e3170dd251f62efbd44910ddf8eba8a67dd1a237f2f7336f436edcfbdf9928e94c3488189110d672488c6c4e0dc4a1fb6e67dee9a1bfc3f49d2f934f305f139e98f0ba9c1ab56b5ce9ddce4ab54b6970bf6499e5e825abbb23f9e320ee05aaf0d712c09b0134839c5609e178a":hex:"7c962a92b8daa294b4962cc3020dcd0b":hex:"":hex:"f91e36c79db6789a3acec9e82ec777efc1958e7e5634d30a60239eb7cae1b48f40557965e8a6f6993db3f4ae443ba167753c89f52f610ab69159ff60233310c1bb2baccb936433270f8839758bc85c53604e771e3ab0df6d6bb02e860d0eb27f425c7d30fb7566aff982d289228da5ce5a45842e10ffbe9016c9e926d7f69863":int:104:hex:"0114c2de8f733fc18f203150a0":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,104) #1 [#2]
depends_on:0
1:exp:0:hex:"09ce73e733e880c6d7be92be3144db40":hex:"a283e20adb6efedc5530f4efd71840d5fe61c902a7511cdaa939f5030880f3675959ee96e39abe082a66eba2a5a93214b22c249d7167b7a0fda360d02df855d508c7ebae7016137e54290904909b2d41a59942abec76612b17ea76ffd1ee715aa2b05b1314c0ab28631f3934d0e9efe2aef0c711e75a5c62701b3358a414958d":hex:"f72a2fc910fdeeefe8743f57290e80af":hex:"":hex:"fe9a7f59abc3720706c33fa40e106663d26c0f8da0d25deb90ada8130b6f95aaec07f4a7db342b678d102b2c81464e4ca9458732783cdc3a9d504232f44e2878b0aaeec0f88efa5d7e5fb146911dcdb4569de7f114e1854ad7a95894561bd0fc4d9a5b58b5164872833283ed88fdb4900b2a596db4e8379eed4e3a5c08d5fadf":int:104:hex:"9de97bfec1325936bd171c996a":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,104) #2 [#2]
depends_on:0
1:exp:0:hex:"e61d415db78d9f2695344350e0a8291e":hex:"730c3fa9e07eea73a734b17fcbc5a969dc2c04f448f44c7f6276e32ae3504e9b15fb664908f530e83a74e25a4525f74d315ab85d7b85005401370dc50fdb86e97baf3e7acb403e476193527a1a5d642ffad6cf2555d16d28cf4c4127189056389368b76aea806906b0a38b808cb02378eea48edc005cf2c21e6547502e31d2cb":hex:"e09dee93466a3f35605b647d16b48452":hex:"":hex:"ae87e754c1af1175b474b0718e3560240f55194d946d101e7c0bc7af18d90a50fa41d68516e45dc2a4dba48d457ebff18a657a873e15620ed7cf6ed3a26195b9d354ea279b24ec7802e4e95d3f3765188a64d7b8d4b7c215e7d67385efc6288724a33a1a7994f21e0dc2970076af7cf31e9ad1098537543052a2b0f62e4e8a87":int:104:hex:"5de3c5716735d7d1b859debb6e":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,96) #0 [#2]
depends_on:0
1:exp:0:hex:"19bf00b228ddb6e8f1fa4ba85f866475":hex:"10742aeda590024bac2696af8402580d2ec6ba3f51cc6f79b6cfbb3057634ced6033fa43dbaec9af8ce7e9706ca699ede88d89caed89ea023d14761bec49da724538b4f9672163a5bb5dbf92f5278fc0014eafce402cb408a1eaad6bc17ec0e835d6b80f4701f946661757b9b2d54d1b137841519dd38d72835893ea6d52a27f":hex:"760c5b929ac3d33bee4dae0088a894f9":hex:"":hex:"b03d27bc7f4c9d48d555a38091347f371d0522ad4c347b4a23194c234c7877cd3621ce5a7c2fc26b38c7e6f1c2bf228ccec491f5bc352556c08e4e19ddc4e4b2c036f45a42aa425a5ff9a2e9c9e5580b538ee56fa804a86d9b1b59b6fb0d00216a96936755462979dc14990935919026fb51cdfef05b8dad03320a8112b7ada5":int:96:hex:"2f1cc79408c85a9867214061":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,96) #1 [#2]
depends_on:0
1:exp:0:hex:"65bd9e7d9009dd6110dca657ccfe603e":hex:"c1b539324a001901c2461b9747f605a2f4043b9b0f54d1357049fd1819de06df6e29880d62ef7d91f9cdd1108f3cce323f6c32cec16f7bd434e539fd00ada476ef41efe7c6907ad1cb726717ab56d6e2d32042ee2df3f90d15e1515f0a15a5f06703e06e14229d18328116148b3cc39683918e42927f62aec49ee9bcc19be38d":hex:"3fddf7e943326e431be540c49bb917c6":hex:"":hex:"2813d6eef070cbdee9d5d71caa8a88c631f0b71c41813c6219a765e4fb3e6eff9afe8f8f4394fbd5646fe80bab78806eddf7549d6ca3d0d16d47ef63db93cb5620e3814efd86be151b338ee6e2c681bd37be4039b2ea4a190feccd7d65cbd56ebda81f4b66ce12cc3e2cece731c37d4237a9dd0a2c1a7697bae42176a673d62a":int:96:hex:"96200bd3e64d5eea746693ba":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,96) #2 [#2]
depends_on:0
1:exp:0:hex:"b9b8ac9215289aa003cecd53a90e0407":hex:"8a6fbd067144b6d50ea73a2a7abba3ee9677bbf00312c70d808fd124541ab936229d59842c8846569a063fecb8bd1945882abd987a936991d5cdbec087937f91c4f5513feffa1984a6b8d04a7b69eb4e93e90b6825778cd2ce9a0ce54d4a468c93884619f851d2294be0bbbeef5fc0c05d2384126289283d5ddaaccd89711d73":hex:"27d367f3f0c60acf921f8d8b228a0b2f":hex:"":hex:"42d98ecfb4f707ec233c7f990b0cad8f39546b861b11d8cb9d939b29ff5ab315229d946ff55927dbde82c03aa73fd7857b2ad38fa55a827dda54d2726bcee66347ce42c9cfd13ba1507d209ff2388c0ea2474e17e31d8056593b722d3c2a302a716a288592b0a36547c7fd47f7595fee9d30f5bc09a9555d7f3169e26a924db1":int:96:hex:"d66974c95917ae1bf79b6685":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,64) #0 [#2]
depends_on:0
1:exp:0:hex:"ccbcc39512425bc32350587f0fc3e8fd":hex:"57d6ccda317b7ea150b18d9558b39fd78d9cb52509aa5c095c5b46da89b79918c85d469ffac7226caddd670ac8f5add47fc382df1f32b4de9cc1b2ca7c2acfbdcaa08429b97e77eedea55c8ddc7814fe4c3cc1e21f95d94301ab77b4df7572d0b8778cb2befc0f4c4a5e93429ad52d6c2a75481f38d92edb1dac563154bf90b2":hex:"0862ebfeb40ff24bfc65d3cc600f2897":hex:"":hex:"e6a77e90750cf0e4c276c50c3880b3f6fa357179cbd84e22f5b43cd10abcbe04b43f191ed3fabf83eaca886f4a7f48490fb1fd92ebdacb68c5158e9f81243f7cadc7a8ba39721df68dbf2406fcb5dab823202ceea7112e5d25952de1b922beda271e7677421fde25f8cde450c40667387e5abf8da42dfe891c52bdd9f5060dba":int:64:hex:"927d13cb90ee5f44":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,64) #1 [#2]
depends_on:0
1:exp:0:hex:"396b53a694b28b717c104111c4752074":hex:"bbc3b818f4ff10b6822ea41f63ca53c27578a8126f5163a5014c60e1bc8c1a9bba67a3808c8aeee09ba9e584a3584e9b86895a3f0db2e64e71bb18b843b12f4ebbfaa1dff3734196f70c5a6d970277ab5337e8b940ae7c957646f8e96c6b5d84e9e97b620a926e655850d09bc2d94678704aa45d1788e7c23ecf37e2904a0786":hex:"0981a151c6f6867d3830c1f9ef99c433":hex:"":hex:"72a5587076a1050b2b514f047ccdf7176c118db9236c0f72091513da39d7416734ac50e0a35b2905420214be8426a36e86863c9957693292bfc5bfc2e93d234a09e80f517edb7cf8e5d21d5ae6c2362b779a9b62b4c66202894d369d219ef0e4b52a342b71f248c18ffc345dc7eb0b47b3bc83ffdef921eb42b6d51abd889ef4":int:64:hex:"af99f8797495dd16":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,64) #2 [#2]
depends_on:0
1:exp:0:hex:"af090618cb454324a82a75a91944dd6f":hex:"3ebca6ff138c527b851b27b9e3917bb9a07282197868351dd599b74b332610bd634422911393171305caa4fe3f6e89ab6c033ca759e118c2d8684b903966999125c748e04312ecd2c1ac3135c3be2df9c8c67be4d8303ac7aa6c21ca7b7c20b1108f5622d8e6079f41e4be4abda99f782ad35a085b7db83482dc71b8e5d8e71c":hex:"3380a6f20875b7d561c4a137519cccd3":hex:"":hex:"6be8eebe7af78c062812513785e9803f302c771e8215e4c606fc5eddc3efd8b12c96e029b4287da55d8626583e58ce0e50c4ac5a39a1b0f309d5803386738397376c0ae155087f36fd86fdda4b5c8dd079011fa9a134ca8a76de570ef165b20d7d803544cd2f3a0ffede9b35ca1c982978bf95ac100af755553fdac38d988fe9":int:64:hex:"3e869dcac087aa6c":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,32) #0 [#2]
depends_on:0
1:exp:0:hex:"041cae51d9e631ef70115be58f8818ef":hex:"f6748f4a261d876e37fe44a419cfe965888aa5ee195ae12237322f6e7ac4bfaaf16e8e29be507e2978339a1855ab918485011fd52f834bf0876ba8d89dfc01927e0930d03c0ac7dc7ba1554a879a2051011bcb34a5e4c7cea4d4fb5ed53b41ec8d17bd52b2e1b9dd417a84ac5913ce3f9fb04daf4d14be65f49d0767b9431b47":hex:"c32f227659e0566faa09eb72d99f89c2":hex:"":hex:"f30fe6c8765c8c0af579c95bc2d182ccc346e587a57aa226eafb692675377a85e9ee08339a047b9cb674dabf5a25301d2c8c264bc06573e36e55ceaee39239e367b8f1a3d781a2020e548001f9f98850994c3aa79b13dfc93c1d7291befd91e044b2f5d2583d1a9f868fab4afecd46fec7d315b0cbf8a7331ef8f588d75f97e2":int:32:hex:"5629e1a4":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,32) #1 [#2]
depends_on:0
1:exp:0:hex:"f0577d9a7dbf7b4ada5b9758eec4c847":hex:"5b559738634825921b5cb620b5b9f637f8b7ce33998cce1ed1a23ff01f84e58255d852a02e59e4394752405ecc15248f7616a33e64936f726de6fc6d10c3fce9ac0b3fcffbd755f16bff8462b3be24f7cf342c8d0bf1ca79b1cb4ea88d690644998a8ac3cafc8c18c8cb737e38a681026d46966b89c7d6c7a4ce7a1e1faecdd5":hex:"b432473ae67205bc7a99f5ab2a2721e6":hex:"":hex:"ddfe664e28c5face3761deda1ab2dac6e36cfed538e3faf9d79c54e3c85b4baea9eedcef7f8f28c2feedec72ab2cc6aaae101b99512ef18e759b7828364e4daf9a572f8c6ad88eb82f7304989345aa4985e498dfebc58cbc45aa31c18c0dda5b1991fd998901c65807c8cff6058b1d5dfd583297da8451cef13f246547ad11df":int:32:hex:"ce55ac00":int:0
AES-GCM NIST Validation (AES-128,128,1024,0,32) #2 [#2]
depends_on:0
1:exp:0:hex:"6ca1d6ae9b5ddd6e3d68656c508df318":hex:"d160740aed955e30c1f946088b5bc5bbaf5c84f282c32f65d099509993628ba5a51b411c6ebf57d58e9176b490ab90fa8db8a3cdc67a5f8322d06d719d91f00ca07aa2a3977dd0838487f2e9d4dd285067a1f72bb8a6c9dfca107acf1f404995bb68ed9d7e12423efe570f144e0533fa34b8d0b7156112b85c94a8fa33d7a6d9":hex:"68a494c9002dadf4f0303dd0ebd600c0":hex:"":hex:"276e362cb73b405b10a98731333f6accf0d19cb96c21419d6d56b30dcf73f7208906b0e3eb103b721cdbb7eb1d4ff29ec3b7e9d433205bd9ec48c59d0075a1507ddf09275426c0ce9a58b973e06d6fceee7054ba92b1df771011ac73e39e451d9ac3375c595631090a2296d423e3ef806ac20770abf78ad04114f65661804fae":int:32:hex:"8ff9a26e":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,128) #0 [#2]
depends_on:0
1:exp:0:hex:"5a3e577743b4581519b84b7538fb32e7":hex:"172a0a14820448e5ffd017c18ee02219906f721c915c4f0ff13b7b7889812c0edb89f28be0c22deff76bc975d1ef8ef3fc40b10cce0d78933aa22e6adf2d4b7ee4ed6ef487eaddb666afd8671427f7525eb99af54a55d98159fc5d651266c65ccd915cbba60fb6e2c408ef177d682253c0b5410d77d08be1d8f175ca360becd0":hex:"1e155ada52e250cee145d69b4a307bc0":hex:"b9be2145b842d2f5c3d15ac032010400bffe31856441cb484d5c93e6710194b13e14077e132cfe03985d4b936bda9383c22c392968c748f7265213a8eac584aaa11eea35589e3536e39b3e4418248927fa9fcc027c5516e402445068ef793d349eb778b77fb0b37f51bfcc3c21df9999ca9985cc5bec6502445b068c2d061f41":hex:"b5bd224140d6b826062e55754299a43a87cbe861360334897e82b7a6023ab0041736479c9aaca7c73f27e239a63e7433e048a8d2c2d26f0b18476aca7ac20837affacdffb57c618ce5982ba61fe1792c8a3a856970c095b0c4695dce961a354135075e0a786192d5875d16793a3ad0e3572a81efa24099f5ed9c92df55c15dd1":int:128:hex:"74df58fd4a2a68657ce35a3ef11a9c0b":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,128) #1 [#2]
depends_on:0
1:exp:0:hex:"deb0ab6e8b0f392af6b89d253e923f1a":hex:"14a86c431bde5c0861e6bd2cb748a13b9bfb2a4a67a0bcf067960b3a9c7a75fc7ea321863c83693c70076462ec3179f4d82ed4a1155a4b5004842fb47482bd6a83804a05af2504f6f535eb9bdc95a9a2eb80c7dcd7dff54e3c00437e4da9c433c88f6d248e4754656acdf8ea7d68106b04ebb2f1cdb247fddb0bca1f8e9ed6a5":hex:"c1bc587c3440f1f5dea5b0a4b5ee8dfd":hex:"602cfb09e8bf250c3a2c248c4e91234629a4fe9a18c5f8b59df215e97dd873a7c1204bd0695796908daa28b77353e0e5b37877a7441d35633119c0aee9aa82c3c18a7f577d09293fafce1895dafea42f97222a33b001907b978f11471cc0adc46243e8f7fce94803d4d0595bc9fccb9b9396b52deb943280eac2c4eda54841bc":hex:"a72d27136d0b4efc0aa2126a246ae4946e2c62cf5055f7bde263e7516ace2b7e12179980f8dcff18dc4fcd662f38d3b9dc7f8a057827ebf27e5dab85264d9325e0eea3b12f8e9e39ad686263df75b0758cc8af0be89882bb159c95b8de392b3e295c039a520d2e56b50a6370afa57adc967f7e4ff670dab471a57fb6c81401eb":int:128:hex:"eb26cdf879e0cb1320d786a642c4dfc0":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,128) #2 [#2]
depends_on:0
1:exp:0:hex:"adf6006fb1cfea0f9641a4c35b864101":hex:"d21777e1fab632bffd82a58cb732794f112cd88bdda5a7a8d19c68ace343fd786e5e512013887105c21299f2d6ae23cae4f03047c68f019d98e76d2aa1b3a204f13f4cba13f5a8957b9aa3ebb44b8024b26cb6139a3bca3ada0520a68b8571ae89501b212a1f8ede5753d557ad2f38d9465dbb09b555300b13194bf7817321f7":hex:"a349d97fc677d8ba6f72e8cc7191ab78":hex:"5717bee8b31640f3999efda463d4b604c1cef62fc0dcc856efb4c50a8c6b902019c663279e1bf66fb52d82f8570b9a314647f4b1ed86eb89f4be8981225f94d4285f5ca9167434a1569b520b071ee4448d08cb8623b4cda6d1f7ad28e51a2df980b5a999025e9ba646707075a6cb2464c2a0d5fc804c98a79946fae0b4fa61fd":hex:"345af0d804490586c9ffbada0404176f4cb1331fc77705175619f27d107512d3e6068323b276743284feb938c5718a5b013305fb42282a89e270d24585236fa18265dc7e8ddd2b3efe93a2ea05ab359323c75211f2133aa97022c9a937a467af37c92a795c682a30f2ba1c4ab2dc45e63c56cd3b29b0efac2caa3150e6a72aa3":int:128:hex:"ae7d2827c4f1422b728a9fd31d8d1918":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,120) #0 [#2]
depends_on:0
1:exp:0:hex:"97c83d4628b65d94341984bbc266dc7a":hex:"e998cc0b7677fa2e504994e99cf7bbd84ba7e356d7da178f8ff40dddc046c70554ddec1d28aa23f9c4e6fcb9effeb8e28a883ad05bd0a6041b8a24d0fceff200a4e33996e279cbf029b11d58185adeb5e5e797a74d0d8b17adcf06dfbe3ee11d8e6bc3b6a8434de6e0ddfa0fd08c913f9fb911cefca72bc3f616b4ac9821f53c":hex:"671dcc5001c2146bf8a4e522ad702bd8":hex:"9eb12a42d2ca06a7da37fbc23d213f5e3f5e15580f01b0ea80eb4b6bd283e307dec965745ea3b3509d3269cf25808fc6a923e97d87d0c1a30b447a5a27a06d0c88a96cd90d990bf208f1abc4934f6a0ae34a694750a74ffb27f4bb66bc799d43570b01897b98b00e6a01b95b356b11d33e852b2010da5785a691246d0be2bcfb":hex:"5a6d8930e473e292e67425748e8618569b7a478f1e183ba4e4a64385ac4b75d3d42b1afc34cc6daff341f10c1ad8f03d77179f52a7239ab3261f5fcd5a0b4282d26fa4d08bf0c8a5c96782c073ad63ad233dfe3aa0290a03d73de14d445b9ce4ea0e3b10a4aef71c5919969b7086353c942c479a1c052a749afde2325ef46f7f":int:120:hex:"b81cb7bfd0aaf22b7233bcfe363b95":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,120) #1 [#2]
depends_on:0
1:exp:0:hex:"2dcd5c974c5d78cde0d3a677d0b1acdc":hex:"21b61035ca3c149d66608d77edd9770411e0ef73a97d4be9dcde95ed7997ba97117ae6c1979195a5d916ff7a1d43ddced5287004fb60a2c81c82b5f7c8a336a603c3eb7cb160bbf21b454f810681450d65deb64e7cd229333fc5e85dc29040d7da48511b6b2524f02eaeab422b5ca817796c47b9f2d7d498abc619b2ce2912bf":hex:"7455fea1bbbfe9479830d403e33c9d1c":hex:"d684d38f2b12111197ca512c54c8e29ef1c3b9b089a6923cdb327c763f0ac8c2ec0900c716e211e7cba1d7c13a60fe87f5d78e5d5215d92e57a0645d9b2eab4b11870b5f7bfa9f2c9e4b9fcf7596e7719b7d0c0e6cc16efe71d8bc92e16a83d4782f08e9b97dc85a18c435b51c940189a3c2608379a21a8c46633020b9b6cd10":hex:"eb039d8cf0bf217e3f2aa529ba872c385f2770ede6ca4ed32fd22cd3fcbfddfb92d681f00df6fbf170a5dad71c9988d556cd74bc99e18a68683e0ea7b6ef90b21ff42cef8c4627e4051bff0da00054390e10036f430dbe217e5bd939295d9c9f64c2614d42ba62efe78763cc427027edbd0b7f72eceaa8b4776ba633f2c3d500":int:120:hex:"18e7b50fcec11c98fe5438a40a4164":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,120) #2 [#2]
depends_on:0
1:exp:0:hex:"e5b132bb7aca3e01105848f9b37ff516":hex:"3b6d1a432b7fdb4022fc35d6b79ea03b6aa14d4ddf60a160e976909ca069242fb2e7d414d4e34ffdf9416823c4b3f4e018ac8ca689446647eda6a12029f886bcc9d18be150b451d78fa72b9c4dc13314077a5b04cffeb167005c7e8379940e6b998316bef9bf8b5a742e337663c0ed91d88d09d0c3ebec37aecaeb8277b13661":hex:"24c1ba77d37f99253576f4963779fd59":hex:"dedf78f05957bde906639bd35eacd8fba8582d288c9f14a25eb851a0a34c82fd91f2b78614ff46ca17fe7781d155cc30f3a62764b0614d57c89fddfdd46af4fa5fc540b9ee9076805d4d121aa0dad2449d228f1fc3c07d466c051c06db6846b9012e8d268c6e1e336121d272ca70d965389a5382fbfec0a439e979f16fab0283":hex:"9976d2f3e16485b6b3699a541b6df386562b5ea4f6f9ff41d265b16e2d7d3c5f131bb5874cdffa87e704ae3cc24f1dccb62bababdcdedf8bac277a7277ca53a4d38fd31f9fc83f86a105663f045b70dabd553137b6d6222abb334b7be7689a4afa28103619f11b8b61aa92a63136ad5639f11bae64b25f09f1e2db701938fa5e":int:120:hex:"29d1b8a68472f2da27aa84be714108":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,112) #0 [#2]
depends_on:0
1:exp:0:hex:"63628519a0f010620cbae37f8ad34570":hex:"6db2919208b09a8abe5e95dcfe0f957dce1ae0e5b29f06bf321dc815ceca094f38c5c812f591aedbc9fc28cc0317bd1d89d4a3ba14f7b3e5fb2e03778990a6006e0ec2ceb47c923f3b17473f99521491a4cb2f9bd435e3133dc90e129ded9d15d78e75bfb3492458ce0964d5614508ef2a38ea02ec8664ba901891a7cc86a62b":hex:"ce0ad75b94ab2d3918abf255c854ecf6":hex:"c29384bd7cd013fa02487867595d739d99886a3bbed7fd5acd689f3a74f240f14c8fffd0bdea1f83bfef7b58ce512849e3a986f37afa54ddc11719169a49bd7e7138a745053417ff80cab1a32ae9be476ccb61ae055b319fdee5dcab629bb237aeb7d998ce36dd9c6908451c3bca9d3582f7fd60e69f6298d43a3b958341b611":hex:"6205d37d720cbb628dbd5069f38ded8e566030eadb7fbdf2ed827d5f5a0117a21c75ade89782b3dc4e7307d9a7ae406ead0145aea1b6cce286103a55ce195999214b84bc25281bd7fe511868a69944d483e05ea6b39b11558ab46a33d227734eb3a386e30d58c3029ef0cb4046c0856078d57a6df194aa8c0e10f9b6ed8fb40b":int:112:hex:"423fd542498825cc54501cb42b2c":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,112) #1 [#2]
depends_on:0
1:exp:0:hex:"7c0e1c6bde79315f79f22ebc77107228":hex:"9cd56b16aa4e130c3dbf30e701e8784ff39f866031e778e9ab72b858c3e333e9589b4b6cd89d6546e52a478d92bd59d0e4756d6b5037ab1873d88242ef31be643745d26395385b71034f6f0c0c84816f0c6755965fc8a7718f891d618f226684bcc77f87fe168e178b330d4b4c0eb4791028017fe6c42e68b0e195654a5d65e5":hex:"9011dee57c3b8e112efa4d2b816cf189":hex:"57bfcccc6f00c0abbc5f30589dbb47597838fdd50dd622eeedee33824e63ba78753c05d2543687f60dde501757b6fb74c17fe34b3e9c455eb38cf078c8c77eff68d3e3b8c244cde70ddf61703664d34159a11785cc6626eb1cad70ab94405616fff52c0f781ee6b43ef2a449924a76b762035ff479cd6006c21a62a56a14650f":hex:"2c1ef998747163104e5a7d2a440a1a1cc2c20446a9d0cf5f138f85c1f5afd90fdc3fa4932845c150518f40bfd56569a5479126c49061ef350b4fae895170b4eb94dad7b456890a822e1bcb57f9bde5bea747d17be3d18ea201cd99bc46fee21132c6918ffb0117744f6ba3f25bc8a50f9719854314b934c3a3230f4757a49113":int:112:hex:"4ef9aebb721dabe2d09101037a63":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,112) #2 [#2]
depends_on:0
1:exp:0:hex:"93f3fa85dbdb2784fb078a34b1116eb1":hex:"e7a0fafda0b90cada671f5e2adfd2e2a5f14e4613ea76aad57e79e2cb532f655210614e2036d7ac005ed5e516814d8667ed71e0f29b9c7b470f4722327407cd6ce6dbd298cee37bff33c35e34cdfebbbf33934673469d6b98becd6d26868977e69e06deee99c118fd4da3530d367d20d15107c03efe0d7e7b38710231e0dcdf0":hex:"f5a7b0b26d1e86f4fc69f81c9eeff2cd":hex:"3d2a1dadccc597b5e7b6ce48760150dee01c8550b525c587abcce8c2c7fb6291683a58c2e42e7b7ba6a3c2a117ddb7e67ea058a78989d67946fd9551e30fcb52618dcb9fae079ca56b74572d7b6a7b6a5c60e906e9639eac5ee1a5a2db864721119da2c4c5110c2b8d487e792cf6929600f1587cb2d48efe6864019afc32af6e":hex:"60da3f4b3a263bc0178379646bce391bf552f60d2833261962375d2960c629dedac681d86f7915ea3cffdad0f37e409668f923d7c860525b994b325396531994a2fbb2d4e909d0b1dce322e078b4b8cd99820a39ffd7b468bd3e73b418b9a2cd5757b7d45f0363574c925bc22d66645abd95a6b29ea6366d8c2252d1c5710d45":int:112:hex:"833d2c55f5ee493060540d6b5349":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,104) #0 [#2]
depends_on:0
1:exp:0:hex:"163c05f69cdc4e518ff6445911d1ede0":hex:"84d8a1855423293de37ebfd9715a9b46b175bc6d44e94ac8a3e7d409e8a227a57a6b85144a8ee23564fadc28742b69e89c0d4aadf0a786f9a5d5f9198923643ffc0bfd0f96e43b08f1435d4afc0e49c0e2241d938780975bc7a31cdf38f30380753bdd66be72b4dff260a35dc10b9ba35059ba61b0beab16e35068721bd950e3":hex:"4b16188249096682b88aa5e4a13f62c1":hex:"a238d1111efb7811f6838c3cb6f3bf3e0ecee6d8efb26845391f8adb51e497e840ea40318bf8e3cf0681c3b69951c4f03d5a4b5edf7119a150eafe6dc16b68f3d2b91e1454637135148f4fec132bfd96ca088169a35961d4c663535b9852f12a00ec4c08082553a09ea046379ce747c717036154d063d876a2b95cd7bdb42daa":hex:"3bf751cf63bc1b433be6075303986ac1d0592dee400774d0bb7a9e72224417639e1e83e69f34226b873365f41fdac925628f32ed4b572b374310edfd892c5e0c3197e59efbc22ee11f0d4a66bd73a6f5b0de7c1cbb0612a63a262af51d418577a9bae0a8577e547382878f13047a92f51a867f8b7d283d2099c34c236918f718":int:104:hex:"0d778299c4dc0415ca789dd5b2":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,104) #1 [#2]
depends_on:0
1:exp:0:hex:"a2ff7cb9fe33b04a087d9ee6db58ec0e":hex:"ed7c22218009ceb5b322045fecc1fd748f27655397a09c2c29813eba9a5cbeebe88d4a35dfd741ef0ac1d11c4adbc6bfae824af88e3ce09f68d8ca7671de91ec9e2bd5f790d1cb1748e34b3560c9b10726ea4b85b127731d8a7fdfd0ddbed11aaf181799f71a68e542b43ed9889237d2fffe370f41064b810c2e14d1ab661517":hex:"6c58eb8f1f561b180f07ede0d3ae3358":hex:"00cb63fa0cf526c6db37e33cf092f3f421fd258d28446c9a7c687b941c7eb5e1c5be267db992d0d93ede0b09030f979d451ecbdbbbb386cf1d74b23d55b74f5f4d520c000c9a41922f54567ca7dfcd84c68883a23c7acc3db3cd8d340217ee7c5ea39b41cf2c0e58c270a19ee9e146d2dbfdaf8ba3e24fda7f2c5e4ba6563ef4":hex:"f0f119bddf5ddf147fe06da9d4510d97369d8e345519df2188b8d2dbaf8b7d3e01f3c26475141aae224e5ce1b131c8096f0e2a17c4c2df62f76f009cfc8aa20ddcd75a6a4281cfa2225485ca22aabcb60ff11265acb92a19ed66797fc2b418ae4b8c70fbecf0fd63f6c22ad62bfd6f40d8d0e2abeb620b7b4f5d8b3e041a53e6":int:104:hex:"7885ca22c4afd7dc6cb440ea35":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,104) #2 [#2]
depends_on:0
1:exp:0:hex:"2e739a485b6293b43535379e3b309fe8":hex:"699b9a5668042c48c63ffb323c0fab18446546417b2f33a69addce6178f9d5b7dfa891ff2004eb57a98ca012c2668e0614276d89b21b7bfa436b2aa1582daaa81a6a7722186e99dd16a5786fd0e8b09b194746232fd413984484524793a379112e297d733dce063408fe59367f5929c5086bc2191a8fdd60a346052c0d109d57":hex:"c4deca3eeea80352624c93523f35e0ae":hex:"704aa36a82d02c56f4992469bb7e8a3f7dda1326068bf6017e4a0c810352b476aea129c1ba1d4974bc0d0503dcf816b89c0dc8e6d066774ce97cea65b5fb5c7b5a7f93e5e2c7126dd3b241b958e47d8150b422bb91c4afc47d53cfc2d20176c2ea0c85b376dc46a86bbaa53c584aa561f6662d11de4e39e50f1a095b8555137b":hex:"30b8fa2e52577a7e5cdc12a7c619615b134ad4b41893ba9120651cd35c6f2d48ec6b8b9fa99366c4d60e643a8ccb2cbb3568f7647f4ad1a12d14deb8aac00dc4ef780133ee8df8f494675deb7f678fed54e70d6bf43476854eb0286a49cd322cc18daa238d4580ee665fbc759295a3e12567beff3e823811093cf0f02d00820b":int:104:hex:"ff89ee52fa4eaeb748c8676490":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,96) #0 [#2]
depends_on:0
1:exp:0:hex:"6bbb12361c95953a8d757bcbb92568eb":hex:"c3fccc5693abe53a13e5209f80611fad1e81e7ce19a4612666d954b4b6d2062bee764181716d5fe0fe1de485bb739d6e8625d5b6cedcaaf6e4e5ec350bc2168c24d7764e75b0cf079d7ad1b5fc24dbed14c5ae4714734f424b3611de0f70a0a8d752fb143e1b7e51ebc965a06021de3718af30b067dde270d804fb5b87ffb29f":hex:"48ca821e5e43fd58668380491d58cdfb":hex:"e97280fd78eb8bd695227fc79420971081de8f24bc95d9a1794ed2bebf5b68d8b43ae8288eb5ce72db0740334ff9bc9b4e660418d3cff8c344e50c7962c367c26247806d0b5c2ae0420a724203dcf4fdefd6513f8263d995afa4780a9c4e92c25496106fec370d0450d907225190ecccfae634f11f8f74f6422a652b2b9af9e5":hex:"61cfc5a6ab6847bf0127b35ce0712cbfa9cd28dfb3f0b4cac2624c52cf55f311e55e9abff2d4514c6feff801ea8739f874ded2efce4a440f2acd95eba6c75e09bcd91b898c98563a26b3df415658c4d04a6aaf547a90b03d1789bdf7ab8f09f6d9f222f567461380372a976240b7b180c3fa7b4507e53815af3f6b4a46973806":int:96:hex:"f86d5374d1ad269cc3f36756":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,96) #1 [#2]
depends_on:0
1:exp:0:hex:"1a0a9b2dd1ae31b3e47b6df979dd2fbf":hex:"353786f96620ae7dfa7aee163c7bb30384bb324b516cad13872f48e7251f6f4c5906748bf2a2f6167bc14453b2b2f513804308ba92d69639beac2f25274bd5477744281b7ef7d0661b3672cd45abd5bd30d98deac4ad0a565308c0224dff59e3190c86df6a5c52055f8e0f73fa024f99162219837c999a9c0a12c806f01227af":hex:"b39c8615fa062412fd9b6ac3a7e626f6":hex:"dea75b17cd13dd33b5016de549c44fa9c88baf424ac80c4835e868acb58082ffc4255c655878a1c627a44160d5e5054a0a04f65fdfb542cd342be2aa2e000117bf8cd67b02f3a3700755508f9af8379c226aded404117a5ca3fa70968495eab287064ee584b4ce596612f2c465d997518c6995518e3bb881967ab6b99d7f62d7":hex:"8430b8735f0b002e098d513eec7b3a8431a3fdac2b7faf256a7bcf08f3dcd6fa549f029240acae4dbd4ad54752ba358c14893aaa67a003261c252020d14b521906b23c37dd80af703c2964ce13773dd72fa56c389768c6efbd485953900b56f6bbaa837f1668f478677621a297d4b5a2c1a86f689d8644caec51435b0dd66c77":int:96:hex:"f000f2d398df18534428f382":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,96) #2 [#2]
depends_on:0
1:exp:0:hex:"4da736fba2b7202ea2ba60793da3344d":hex:"4f004852edd5dcde13507252ed8c2b20a093ac9081ce2a8133c48d2807e5f968c04a20dd52c070d6c43c704b8650da7f94e5450e0d34cfc2b2d2ba7cb5343e6b4281633c6c065dae27fab18ca71bea018eba94d20e78c5e3223c70f50cb77399c1a89436f1e7213673ae825d4fc5523645031696df10f9b5238c03f733b4dfcf":hex:"8572af442c9af9652a192d893c18b8c3":hex:"429915c3309fba2a42b8e89f42a9376a2f329805a4d6daae11e9a20c2f982671ef8a7539a9657777d03cbf755ef93be0d8e426ed00899a59e8b963fd44269d64692ed07b231cde93e85397cf125a75032ca3726ea1ff1b05d79f2040c1135012b90597186c1db2e16cd128d45a7b9d934ec01341d9030e9721c62f62003059b8":hex:"ff4e46c4236304b8d52ba2d6db269f95d2cd5fe4318ce930d407051469c7e36e44bbcc909c4966276f5a2ec70021982fecbeae34df235a3e9e0370afa5a269ca8847a84b8477f7ddd6055d0f800ff4d413f63db517c96d15dbe78655748edd820f2ee79df5eca31711870022f1f5394b84f05bfef97f99cbd6205f8e522b3d5e":int:96:hex:"624b0b5b6374c5153835b8e5":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,64) #0 [#2]
depends_on:0
1:exp:0:hex:"5bcc874114b9d78c3eb748a783d1448c":hex:"7d57418bcea007247f5e18c17a2e4601c3eb8c89f61ed365d5aebee7593cdd63871d964a25fc9d723f291d39e0c4f75012471faf8e06db60c4ad8a26cf434bd82a29a8b653fdda1b86a7e4800c1d70cb5d8b8a1d1af52894082bb282ffdde8f0128a4abb68aedcfcb59160f6b5aaf452812f4d00472d2862a8b22480e71231b3":hex:"5f4fde440faa9537d62e62994ab20fb5":hex:"b5dfe0d971f2920ba4c029d4c346a49788b499faacdb18b8f905f1457a8b9fa48709893516a7b48bc601710bfd73c12da094c29df5776d491c9978f8ab237f605785b0304488f1c20bf5a767ba6d5e1e2961957aa107bdba2358b81ef1e06576db985b3ef8194725b75d49de1de3a57f161dede508e37ad3356134fa0a1aa48e":hex:"6bc0dec98bece6c4e245fe978f6db113deca75e1b475bc31f1da0c7457a85ee7aac8be5f2121c0610b99a2c64519fc2514b643c379b4f53c5432b9729aea9fcecb88a2e2d0a6e74be04859a66f55fb2af1598bcb039108ef7fcfd99d94e79287ec1f62bd1bf5ff9dd51ab12fae4f6e21b95ca50032f9a65bd85f9a1aa0524950":int:64:hex:"354fb8bcd38f2a26":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,64) #1 [#2]
depends_on:0
1:exp:0:hex:"427c89146eb7d76578dc173bd9e15cda":hex:"1d39249130404d60ed40241cf3354458e06f1474b3723569d88235f03098053fc99010f39435620acc710a4e386b2ecbf9b327a8dcfbeddc084353fff029d24787ce81e74a5e1ac1ef096e0a2ae882a669ca168275806bb7f462e66c941fffc6ed44b9628450e03a5032676c1ee4aedfcb1767150d56c7d73a8a47f6d19854fa":hex:"0092e76cd8882e5f77f4c8514491705d":hex:"0ac4631358bb9375e07756692bde59d27012e921f054fdfea0ddb242c43421f4c7241cb210cb5c172d053de2763efd565f1138fbe7f9cd998d825ab800df900843474ebf857b3371c555b89670e86354fe430f715ebbd0ecad974fea34e3bbae43d3ca3ca178f3361f0a11fd75f60e9140f44364b02a073dcce8339fa28cb5ad":hex:"2b385e9df4ed41cdca53a4ac8cb3e0af75eddd518b6727380712950d96c34bc6a0a6ac02184c1987548932b116ec9ae7abf01157a50e422b3e6aa62deb0cb2d81bf7fe0c25041a355ccaaeb049abb0393acfe90d869e9edfdfb646971bbb1ba9e5983cd0e2739158fab31be26cfdf9286d347b58b00f75d9f48ece1353308a91":int:64:hex:"905cdf228a68bebb":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,64) #2 [#2]
depends_on:0
1:exp:0:hex:"2e09660909a9aa0a50958016c3e07895":hex:"d7b2ceb182d4a8ed57572c4237ba99bbdd589093db0f71732f9e67559d3054fa1af195aa4864fde413549d27468ffe7c5c23e242cab4ae4bb9e2657422dc3fc78fbdcde892ed202be1e47f095b09cfc53cfe86cb16e2e95444492ad5d0eef053178d6b0485731be7a5193563bf56f63cc0687fc01679254d74e9ed788645004c":hex:"c4f865be8b5062e488b1725749a87945":hex:"26f50acdefde4d585fc6de6c6234c9ead40684349a2bfd022df93d9774c9f5b8f50474032a417bdcc21a74da72c0297437a0cef8f527c9205797f77b4227c272e08ad0b120a2a31ef13e372cad2387ccc1bcefc88dd58899821d68f3be6a4b2cd08697d1897efcd6ed3a0d7849f6cbb50e46800627cfd26964e2cfe9f36624d9":hex:"321f6d79a6658c7c2b67fe3c932237593a6ec7e6fd8198abc6b0b6ba5d4dac9e0695f0c64dde1c94c0383839ee37f8bbfcc516f24871fd79a9b9135ceef841e4c8ddf6b57962c0e8ad7aaf210e97a43489097270756404fddde637de461b8644fef244142820e1af12b90f16748b0915a6b773dfbbdf6b16f1beaccb4cd5edba":int:64:hex:"b294db7ed69912dc":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,32) #0 [#2]
depends_on:0
1:exp:0:hex:"5e45d57981f65a6b170efa758cf4553d":hex:"bc8d4c418442743f2fdbaf95b8f87b7c15a3176085e34addf4cf0fb3c2df15587526691b07e6407ba16999b72382635a2aebb62d05c1547a7d074c857a23107c7577864e7f7bcdb5b6d1fb50136391f89c42d3f02754b0e4ed0fcb0c03576b986af5c12cf9bf5e0c585d6aaf49d0c6fb2ec30eae97b2b850a35474bfb9a2c069":hex:"b43403b627fe9e0135192d1a048c6faa":hex:"7a27ea26c7607e4e7e627f3161bdf15f21f3d62dc33df14951971712f960d3b2082d75395c5008e5ea00d282d350f86dac8c61f5c0f90e7797a5b61ee96f7e332ec5de51cb1377e47c641f326d1e58817c8c95feb5b2923758e33b279191d0a9ffd09b7619b0318a70775e36abf5f7ab59422ff68914e7b478c448a7b141c4bf":hex:"90d8a6218da063c38e0f06d548a3d5685fd3e0fbaf609c77bdd573bb9c63f30590eaf8b181a2feb81c8b3f5f34a94dc94b905036a6c69b97263302b8674d9e09325065588e97c0b5b33116981f1f362a7c5bb1e996c126c31fbd63791772f4d594632f408fdf011b3f2cc750b060452c181e8e09697c8662c00c8d4f29d875a7":int:32:hex:"611abef7":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,32) #1 [#2]
depends_on:0
1:exp:0:hex:"00d4bf20509a61bc76430ffa5f013589":hex:"036a191a388cf3c57c9e6f0e2f5c8bc3d5c25ee8e2fedfadb7b7433155c7e79304f0905ab2a17e1f04f2f2dacd4a41521d6ce213961df9dc9101d41df4e44246488fbedb75a01256fbc7784769eb8f99d44d5eabf93cf667ebae2437ccedc79efa58c075183d46a5c20bf4c81e0f9754ad35af65f7c8aafe7daa3460c6892b1a":hex:"25b1026a009470a5ca8caeeb67200792":hex:"fd75acfd5aa25fb8bccb53672e5d6a8080081506cf03df2bab0746a353510996e0237d6354ee0210a41f20f88ec6569f2b200b28c6a31464a0533a6bc45afef3ae381425a3606de2866dba694124d96da9d0a2b061b787524ee6e5d3b1ef5c4bcf168810aa177660b7e1379ac8a480ce43d73dfcc696873cea2df419f372651e":hex:"cab80615b666c47fcabf0d9805842ab2805150abad4de0ae8b12306bed504d4a7f91f52379df65cb9587577e59dafcd4203d2ed2743d35472285e9522db0ce3dd027a01c79ac64caee29ef3752a077254b0dca269f6f206f6cc575e8fedb0ba525dcf6252fa6f7b688556933f1dee84b2ad36a266695ce8672229cedd82f20a1":int:32:hex:"3287478c":int:0
AES-GCM NIST Validation (AES-128,128,1024,1024,32) #2 [#2]
depends_on:0
1:exp:0:hex:"fe481476fce76efcfc78ed144b0756f1":hex:"246e1f2babab8da98b17cc928bd49504d7d87ea2cc174f9ffb7dbafe5969ff824a0bcb52f35441d22f3edcd10fab0ec04c0bde5abd3624ca25cbb4541b5d62a3deb52c00b75d68aaf0504d51f95b8dcbebdd8433f4966c584ac7f8c19407ca927a79fa4ead2688c4a7baafb4c31ef83c05e8848ec2b4f657aab84c109c91c277":hex:"1a2c18c6bf13b3b2785610c71ccd98ca":hex:"b0ab3cb5256575774b8242b89badfbe0dfdfd04f5dd75a8e5f218b28d3f6bc085a013defa5f5b15dfb46132db58ed7a9ddb812d28ee2f962796ad988561a381c02d1cf37dca5fd33e081d61cc7b3ab0b477947524a4ca4cb48c36f48b302c440be6f5777518a60585a8a16cea510dbfc5580b0daac49a2b1242ff55e91a8eae8":hex:"5587620bbb77f70afdf3cdb7ae390edd0473286d86d3f862ad70902d90ff1d315947c959f016257a8fe1f52cc22a54f21de8cb60b74808ac7b22ea7a15945371e18b77c9571aad631aa080c60c1e472019fa85625fc80ed32a51d05e397a8987c8fece197a566689d24d05361b6f3a75616c89db6123bf5902960b21a18bc03a":int:32:hex:"bd4265a8":int:0
AES-GCM Bad IV (AES-128,128,0,0,32) #0
depends_on:0
0:exp:0:exp:1:hex:"d0194b6ee68f0ed8adc4b22ed15dbf14":hex:"":hex:"":hex:"":int:32:exp:2
AES-GCM Selftest
depends_on:0
5
| 101,909 | 681 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_rsa.datax | RSA parameter validation
0
RSA init-free-free
1:int:0
RSA init-free-init-free
1:int:1
RSA PKCS1 Verify v1.5 CAVS #1
depends_on:0:1
3:hex:"d6248c3e96b1a7e5fea978870fcc4c9786b4e5156e16b7faef4557d667f730b8bc4c784ef00c624df5309513c3a5de8ca94c2152e0459618666d3148092562ebc256ffca45b27fd2d63c68bd5e0a0aefbe496e9e63838a361b1db6fc272464f191490bf9c029643c49d2d9cd08833b8a70b4b3431f56fb1eb55ccd39e77a9c92":exp:0:exp:1:int:1024:int:16:char*:"e28a13548525e5f36dccb24ecb7cc332cc689dfd64012604c9c7816d72a16c3f5fcdc0e86e7c03280b1c69b586ce0cd8aec722cc73a5d3b730310bf7dfebdc77ce5d94bbc369dc18a2f7b07bd505ab0f82224aef09fdc1e5063234255e0b3c40a52e9e8ae60898eb88a766bdd788fe9493d8fd86bcdd2884d5c06216c65469e5":int:16:char*:"3":hex:"3203b7647fb7e345aa457681e5131777f1adc371f2fba8534928c4e52ef6206a856425d6269352ecbf64db2f6ad82397768cafdd8cd272e512d617ad67992226da6bc291c31404c17fd4b7e2beb20eff284a44f4d7af47fd6629e2c95809fa7f2241a04f70ac70d3271bb13258af1ed5c5988c95df7fa26603515791075feccd":exp:2
RSA PKCS1 Verify v1.5 CAVS #2
depends_on:0:1
3:hex:"206ef4bf396c6087f8229ef196fd35f37ccb8de5efcdb238f20d556668f114257a11fbe038464a67830378e62ae9791453953dac1dbd7921837ba98e84e856eb80ed9487e656d0b20c28c8ba5e35db1abbed83ed1c7720a97701f709e3547a4bfcabca9c89c57ad15c3996577a0ae36d7c7b699035242f37954646c1cd5c08ac":exp:0:exp:1:int:1024:int:16:char*:"e28a13548525e5f36dccb24ecb7cc332cc689dfd64012604c9c7816d72a16c3f5fcdc0e86e7c03280b1c69b586ce0cd8aec722cc73a5d3b730310bf7dfebdc77ce5d94bbc369dc18a2f7b07bd505ab0f82224aef09fdc1e5063234255e0b3c40a52e9e8ae60898eb88a766bdd788fe9493d8fd86bcdd2884d5c06216c65469e5":int:16:char*:"3":hex:"5abc01f5de25b70867ff0c24e222c61f53c88daf42586fddcd56f3c4588f074be3c328056c063388688b6385a8167957c6e5355a510e005b8a851d69c96b36ec6036644078210e5d7d326f96365ee0648882921492bc7b753eb9c26cdbab37555f210df2ca6fec1b25b463d38b81c0dcea202022b04af5da58aa03d77be949b7":int:0
RSA PKCS1 Verify v1.5 CAVS #3
depends_on:0:1
3:hex:"206ef4bf396c6087f8229ef196fd35f37ccb8de5efcdb238f20d556668f114257a11fbe038464a67830378e62ae9791453953dac1dbd7921837ba98e84e856eb80ed9487e656d0b20c28c8ba5e35db1abbed83ed1c7720a97701f709e3547a4bfcabca9c89c57ad15c3996577a0ae36d7c7b699035242f37954646c1cd5c08ac":exp:0:exp:1:int:1024:int:16:char*:"e28a13548525e5f36dccb24ecb7cc332cc689dfd64012604c9c7816d72a16c3f5fcdc0e86e7c03280b1c69b586ce0cd8aec722cc73a5d3b730310bf7dfebdc77ce5d94bbc369dc18a2f7b07bd505ab0f82224aef09fdc1e5063234255e0b3c40a52e9e8ae60898eb88a766bdd788fe9493d8fd86bcdd2884d5c06216c65469e5":int:16:char*:"3":hex:"5abc01f5de25b70867ff0c24e222c61f53c88daf42586fddcd56f3c4588f074be3c328056c063388688b6385a8167957c6e5355a510e005b8a851d69c96b36ec6036644078210e5d7d326f96365ee0648882921492bc7b753eb9c26cdbab37555f210df2ca6fec1b25b463d38b81c0dcea202022b04af5da58aa03d77be949b7":int:0
RSA PKCS1 Verify v1.5 CAVS #4
depends_on:2:1
3:hex:"867ac26e11a13b7ac34a42a1e177648692861226effb55bb597fbde10f299bf7fffd6fc8ddb2a46a73b97b67387a461b23e1d65dc119366286979add615b926b9272832fc0c058b946fc752dcffceca12233f4c63f7897cbaa08aa7e07cf02b5e7e3e5ece252bf2fe61d163bce84c0e0368454a98e9fdebf6edbd70b290d549b":exp:0:exp:3:int:1024:int:16:char*:"e28a13548525e5f36dccb24ecb7cc332cc689dfd64012604c9c7816d72a16c3f5fcdc0e86e7c03280b1c69b586ce0cd8aec722cc73a5d3b730310bf7dfebdc77ce5d94bbc369dc18a2f7b07bd505ab0f82224aef09fdc1e5063234255e0b3c40a52e9e8ae60898eb88a766bdd788fe9493d8fd86bcdd2884d5c06216c65469e5":int:16:char*:"3":hex:"3bb7b1c5f3391de4549e2e96fd33afa4d647dd90e321d9d576f3808e32213e948b697ef4fd2dd12923de6ec3ffd625078a57f86af38dc07052bb50547c616ed51fa1352b3ab66788408168d21263ef2d3388d567d2ce8cf674f45491ab2b0319d47be1266bda39e343b2a38ea2d6aaaee6c4465aee1d7bb33e93a1c40a8e3ae4":int:0
RSA PKCS1 Verify v1.5 CAVS #5
depends_on:2:1
3:hex:"cd810e97dc21095ea7a0238027a7bafd343e01444785ea9184a44a79f80438c41fc0b57aa95693407da38fe5ff0ec1398e03361e51a3dbe134b99cca2df0cef1c444ca54d2b7db2789455b6bb41918c24001fd82fc20ee089de3f34f053699c1c5f7954ce0aaabb9d26fce39d032894152229d98cf64ecafc7089530073c61d9":exp:0:exp:4:int:1024:int:16:char*:"e28a13548525e5f36dccb24ecb7cc332cc689dfd64012604c9c7816d72a16c3f5fcdc0e86e7c03280b1c69b586ce0cd8aec722cc73a5d3b730310bf7dfebdc77ce5d94bbc369dc18a2f7b07bd505ab0f82224aef09fdc1e5063234255e0b3c40a52e9e8ae60898eb88a766bdd788fe9493d8fd86bcdd2884d5c06216c65469e5":int:16:char*:"3":hex:"7b5fba70ec5b521638f182bcab39cec30b76e7bc017bdbd1059658a9a1db0969ab482dce32f3e9865952f0a0de0978272c951e3c015328ea3758f47029a379ab4200550fba58f11d51264878406fc717d5f7b72b3582946f16a7e5314a220881fc820f7d29949710273421533d8ac0a449dc6d0fd1a21c22444edd1c0d5b44d3":int:0
RSA PKCS1 Verify v1.5 CAVS #6
depends_on:3:4:1
3:hex:"44637d3b8de525fd589237bc81229c8966d3af24540850c24036330db8007e6d19a19486018b2b02074da590aaba9d2c8848c0a2d1b6de4dfaf24025b6393df9228008f83f13cc76a67cfbed77a6e3429342824a0b6a9b8dd884094acc6a54bbc8c8829930c52fe39ce5e0dcd02d9553ef899d26eb6cae0940b63584e2daeb3b":exp:0:exp:5:int:1024:int:16:char*:"e28a13548525e5f36dccb24ecb7cc332cc689dfd64012604c9c7816d72a16c3f5fcdc0e86e7c03280b1c69b586ce0cd8aec722cc73a5d3b730310bf7dfebdc77ce5d94bbc369dc18a2f7b07bd505ab0f82224aef09fdc1e5063234255e0b3c40a52e9e8ae60898eb88a766bdd788fe9493d8fd86bcdd2884d5c06216c65469e5":int:16:char*:"3":hex:"38fc4f6f0430bb3ea9f470a4c0f5cebdabac4dbeb3b9c99d4168e7b00f5eb294ec0ece1908eded1f3e14f1e69d10f9feb425bda0c998af945ef864298a60a675f0bb5c540a7be3f534d5faddff974eea8bffe182a44e2ee1f4f653e71967a11869ee1a850edb03cb44a340378cb7a1bc9616d3649b78002b390a05a7e54edec6":int:0
RSA PKCS1 Verify v1.5 CAVS #7
depends_on:3:4:1
3:hex:"d03f12276f6ba7545b8fce719471bd253791878809694e8754f3b389f26c9253a758ed28b4c62535a8d5702d7a778731d5759ff2b3b39b192db680e791632918b6093c0e8ca25c2bf756a07fde4144a37f769fe4054455a45cb8cefe4462e7a9a45ce71f2189b4fef01b47aee8585d44dc9d6fa627a3e5f08801871731f234cd":exp:0:exp:5:int:1024:int:16:char*:"e28a13548525e5f36dccb24ecb7cc332cc689dfd64012604c9c7816d72a16c3f5fcdc0e86e7c03280b1c69b586ce0cd8aec722cc73a5d3b730310bf7dfebdc77ce5d94bbc369dc18a2f7b07bd505ab0f82224aef09fdc1e5063234255e0b3c40a52e9e8ae60898eb88a766bdd788fe9493d8fd86bcdd2884d5c06216c65469e5":int:16:char*:"3":hex:"d93a878c1ce86571590b0e43794b3edb23552797c4b8c9e3da4fe1cc4ac0566acd3b10541fe9a7a79f5ea4892d3069ca6903efb5c40c47eb8a9c781eb4249281d40c3d96aae16da1bb4daaece6a26eca5f41c062b4124a64fc9d340cba5ab0d1f5affff6515a87f0933774fd4322d2fa497cd6f708a429ca56dcb1fd3db623d0":exp:2
RSA PKCS1 Verify v1.5 CAVS #8
depends_on:3:1
3:hex:"b2f2e6e09fd19b0a8c06447554d6a236c69e2b334017488881d8c02ab81d74cae0c64efd50a374998eeec162651975e637cb2ba594250c750a4943253f1db0613e4ce1d50f8e3e968a2a83bd6cb97455ab2ccc77071076b3e211ffb251bd4c1a738b88b2021c61c727c074ce933c054acbcbf4f0c362ec09af38de191686aebe":exp:0:exp:6:int:1024:int:16:char*:"e28a13548525e5f36dccb24ecb7cc332cc689dfd64012604c9c7816d72a16c3f5fcdc0e86e7c03280b1c69b586ce0cd8aec722cc73a5d3b730310bf7dfebdc77ce5d94bbc369dc18a2f7b07bd505ab0f82224aef09fdc1e5063234255e0b3c40a52e9e8ae60898eb88a766bdd788fe9493d8fd86bcdd2884d5c06216c65469e5":int:16:char*:"3":hex:"a853e67f928281d11506c9d39e5ea9b2d742782c663c37d0a7c9e9fe15379cde1e75d94adbfb1ca08691f320af4ff2b0a29a4d2ea10a20cb95d85f3dabac3d56cca9039c851d0181408c00b385fc82cafa4cfa7380d0c2c024fb83fec59d5ee591d63806dcb18b21ea440c3d3f12c1e7795eb15b7ce4c4b288d646cf1d34bdf1":int:0
RSA PKCS1 Verify v1.5 CAVS #9
depends_on:0:1
3:hex:"647586ba587b09aa555d1b8da4cdf5c6e777e08859379ca45789019f2041e708d97c4408d4d6943b11dd7ebe05c6b48a9b5f1b0079452cc484579acfa66a34c0cf3f0e7339b2dbd5f1339ef7937a8261547705a846885c43d8ef139a9c83f5604ea52b231176a821fb48c45ed45226f31ba7e8a94a69f6c65c39b7278bf3f08f":exp:0:exp:1:int:1024:int:16:char*:"e28a13548525e5f36dccb24ecb7cc332cc689dfd64012604c9c7816d72a16c3f5fcdc0e86e7c03280b1c69b586ce0cd8aec722cc73a5d3b730310bf7dfebdc77ce5d94bbc369dc18a2f7b07bd505ab0f82224aef09fdc1e5063234255e0b3c40a52e9e8ae60898eb88a766bdd788fe9493d8fd86bcdd2884d5c06216c65469e5":int:16:char*:"10001":hex:"e27a90b644c3a11f234132d6727ada397774cd7fdf5eb0160a665ffccedabb8ae9e357966939a71c973e75e5ff771fb01a6483fcaf82f16dee65e6826121e2ae9c69d2c92387b33a641f397676776cde501e7314a9a4e76c0f4538edeea163e8de7bd21c93c298df748c6f5c26b7d03bfa3671f2a7488fe311309e8218a71171":int:0
RSA PKCS1 Verify v1.5 CAVS #10
depends_on:0:1
3:hex:"55013a489e09b6553262aab59fb041b49437b86d52876f8e5d5e405b77ca0ff6ce8ea2dd75c7b3b411cf4445d56233c5b0ff0e58c49128d81b4fedd295e172d225c451e13defb34b87b7aea6d6f0d20f5c55feb71d2a789fa31f3d9ff47896adc16bec5ce0c9dda3fde190e08ca2451c01ff3091449887695f96dac97ad6a30e":exp:0:exp:1:int:1024:int:16:char*:"e28a13548525e5f36dccb24ecb7cc332cc689dfd64012604c9c7816d72a16c3f5fcdc0e86e7c03280b1c69b586ce0cd8aec722cc73a5d3b730310bf7dfebdc77ce5d94bbc369dc18a2f7b07bd505ab0f82224aef09fdc1e5063234255e0b3c40a52e9e8ae60898eb88a766bdd788fe9493d8fd86bcdd2884d5c06216c65469e5":int:16:char*:"10001":hex:"dd82b7be791c454fbbf6f1de47cbe585a687e4e8bbae0b6e2a77f8ca4efd06d71498f9a74b931bd59c377e71daf708a624c51303f377006c676487bad57f7067b09b7bb94a6189119ab8cf7321c321b2dc7df565bfbec833a28b86625fb5fd6a035d4ed79ff0f9aee9fa78935eec65069439ee449d7f5249cdae6fdd6d8c2a63":exp:2
RSA PKCS1 Verify v1.5 CAVS #11
depends_on:2:1
3:hex:"f4a990b8d434a5914340c0ca3ca4e4a70856c55e13e938c1f854e91cdef54c6107d6d682a62e6c1ff12b1c6178ee0b26b5d8ae5ee4043db4151465727f313e9e174d7c6961abe9cb86a21367a89e41b47267ac5ef3a6eceaaca5b19ae756b3904b97ec35aeb404dc2a2d0da373ba709a678d2728e7d72daae68d335cbf6c957d":exp:0:exp:3:int:1024:int:16:char*:"e28a13548525e5f36dccb24ecb7cc332cc689dfd64012604c9c7816d72a16c3f5fcdc0e86e7c03280b1c69b586ce0cd8aec722cc73a5d3b730310bf7dfebdc77ce5d94bbc369dc18a2f7b07bd505ab0f82224aef09fdc1e5063234255e0b3c40a52e9e8ae60898eb88a766bdd788fe9493d8fd86bcdd2884d5c06216c65469e5":int:16:char*:"10001":hex:"d8ef7bdc0f111b1249d5ad6515b6fe37f2ff327f493832f1385c10e975c07b0266497716fcb84f5039cd60f5a050614fde27f354a6c45e8a7d74f9821e2f301500ac1953feafeb9d98cf88d2c928413f337813135c66abfc3dc7a4d80655d925bf96f21872ca2b3a2684b976ca768fe37feae20a69eeec3cc8f1de0db34b3462":int:0
RSA PKCS1 Verify v1.5 CAVS #12
depends_on:2:1
3:hex:"c81f04c79982971fa176d64e8f7f8812f86a94c49e84672ff10996a2d6dfc444a884c7a87c4606a1aab22558894ee59b798b457827f5ee0b0cadcd94371902cc4ddaf97acefed641997717bcb3cc74cd440f0a31e20fb95812cecb740c36d6d1bf07e3641514cfa678aff2a39562ff4d60e02b17583a92bf0c56d66bde9e09f8":exp:0:exp:4:int:1024:int:16:char*:"e28a13548525e5f36dccb24ecb7cc332cc689dfd64012604c9c7816d72a16c3f5fcdc0e86e7c03280b1c69b586ce0cd8aec722cc73a5d3b730310bf7dfebdc77ce5d94bbc369dc18a2f7b07bd505ab0f82224aef09fdc1e5063234255e0b3c40a52e9e8ae60898eb88a766bdd788fe9493d8fd86bcdd2884d5c06216c65469e5":int:16:char*:"10001":hex:"52111f4798da3c11b3c74394358348ab0fc797bde99080f238d33a69b04b08ac2bd767b33872473943e23af27ca32fd568a43a8c7d6cc55b4fbb380212fdfcb60487e20694d4287e233efdf7b04737c0037a592d03077801828b051998c42b9f9e2420063331d5b2349918a64d8b65b21a2011ee7318fcef48aced95b8ddf501":int:0
RSA PKCS1 Verify v1.5 CAVS #13
depends_on:3:4:1
3:hex:"a97824871770b79da979a111f6decfb1dd11bd946cfa800b008f0ad5aea5aa92e205d27a46c31d4fe6cb909091bd21f082fb75074000ee46c2f3e530d77b34c7c5d6f8453025950d3e0afae1f9752655f5bbea8432e9f1014357ff11b08076179a101e4f9d3f25bffb5e656bf6afe6c97d7aa4740b5d9224cde4dede035a7768":exp:0:exp:5:int:1024:int:16:char*:"e28a13548525e5f36dccb24ecb7cc332cc689dfd64012604c9c7816d72a16c3f5fcdc0e86e7c03280b1c69b586ce0cd8aec722cc73a5d3b730310bf7dfebdc77ce5d94bbc369dc18a2f7b07bd505ab0f82224aef09fdc1e5063234255e0b3c40a52e9e8ae60898eb88a766bdd788fe9493d8fd86bcdd2884d5c06216c65469e5":int:16:char*:"10001":hex:"d5dcd27c74e040ea86f106b63d3275fa7b7e98d2dd701f38ec15fc7301b72df127f6d3bd5571253a0b9e0e719d7d522893896941a1aeccc697912282b5308d829b91905b5dd7b7e1b8fe27e2bd4003b09dfe7fe295f8a43c076c0cb52f2aac067e87de7ffe3a275d21a870c3dfc9b1d06d7f018667de9eb187bdf53d282e5d8b":int:0
RSA PKCS1 Verify v1.5 CAVS #14
depends_on:3:1
3:hex:"4ce61930c79dc017c2dea0c5085d73a3b0e4a6f341e9a5061a6658af11e5edf95bdad915ac3619969e39bee15788a8de667f92f4efc84f35082d52d562aa74e12cc7f22d3425b58f5056d74afcf162cd44e65b9ee510ff91af094c3d2d42c3b088536d62a98f1c689edcf3ea3fc228d711c109d76ae83d82d6a34dcfbad563cf":exp:0:exp:6:int:1024:int:16:char*:"e28a13548525e5f36dccb24ecb7cc332cc689dfd64012604c9c7816d72a16c3f5fcdc0e86e7c03280b1c69b586ce0cd8aec722cc73a5d3b730310bf7dfebdc77ce5d94bbc369dc18a2f7b07bd505ab0f82224aef09fdc1e5063234255e0b3c40a52e9e8ae60898eb88a766bdd788fe9493d8fd86bcdd2884d5c06216c65469e5":int:16:char*:"10001":hex:"27280b92eab5cbf0d787ff6fa6b0151d6610adfd25116113f2f186f3f8d39736d91ae510ec2bd96f2de135aefda79178138696dcc6d302e4a79ddabbe16e39ab96075776afce863e84a2e6013cb457e4047e22d43f67bf64ae5e1d844a7c12ac696efbb3cda7c0e0aca71f8a7ada9a0547bfaefe1ba2e04058c672c803720dd9":int:0
RSA PKCS1 Verify v1.5 CAVS #15
depends_on:0:1
3:hex:"224ecd3b630581da948216366c741015a9723c5ea43de67e28454d0a846f54a6df167a25cc500cf21f729aaefed6a71a3bdba438e12e20ad0c48396afe38568b70a3187f26098d6ac649a7c7ea68ed52748e7125225102216236a28f67753b077cfd8d9198b86b0b331027cb59b24b85fd92896e8f2ff5a1d11872c2e6af6ae2":exp:0:exp:1:int:1536:int:16:char*:"a59d9b7269b102b7be684ec5e28db79992e6d3231e77c90b78960c2638b35ef6dbdac1ac59e7249d96d426e7f99397eabc6b8903fe1942da580322b98bafacd81bb911c29666f83886a2a2864f3552044300e60cedd5a8c321c43e280413dc41673c39a11b98a885486f8187a70f270185c4c12bc48a1968305269776c070ef69d4913589a887c4d0f5e7dd58bd806d0d49a14a1762c38665cef4646ff13a0cd29c3a60460703c3d051d5b28c660bffb5f8bd43d495ffa64175f72b8abe5fddd":int:16:char*:"3":hex:"1f7938b20a9cd8bb8ca26bad9e79ea92373174203f3ab212a06de34a9a3e14e102d19a8878c28a2fc8083a97c06b19c1ae62678289d5d071a904aed1d364655d9e2d16480a6fd18f4c8edf204844a34d573b1b988b82d495caefd9298c1635083e196a11f4a7df6a7e3cc4db7b9642e7682d22ec7038c3bad791e1365fe8836976092460e6df749dc032baf1e026684f55936beb9369845c53c3d217941c1f8d8f54a32333a4c049c3f2d527125778032f5d390040d1d4cce83dc353ce250152":int:0
RSA PKCS1 Verify v1.5 CAVS #16
depends_on:2:1
3:hex:"6ecc722d233dad1aca45e6bc3e1a0b99fb1f89c0ec63bc657e6aaacbf931f267106cff42b712819f341b1ede798964a0b1a5032c198b391111e88d0d7303c02e23fa0137e74e604579a285b2dbc0a23aebdda65c371eb403125bd366e822e72dceffe0d55dfa3155c16283020dc9abb0d150da1aef251484aa49e49e00974dac":exp:0:exp:3:int:1536:int:16:char*:"a59d9b7269b102b7be684ec5e28db79992e6d3231e77c90b78960c2638b35ef6dbdac1ac59e7249d96d426e7f99397eabc6b8903fe1942da580322b98bafacd81bb911c29666f83886a2a2864f3552044300e60cedd5a8c321c43e280413dc41673c39a11b98a885486f8187a70f270185c4c12bc48a1968305269776c070ef69d4913589a887c4d0f5e7dd58bd806d0d49a14a1762c38665cef4646ff13a0cd29c3a60460703c3d051d5b28c660bffb5f8bd43d495ffa64175f72b8abe5fddd":int:16:char*:"3":hex:"339dce3a1937669d9fb14c4f652378861fd5adc4da88eaf833b16020b55a24ddc83b7ae3395a9a49b426bb9a4170cb765b02652faa9594b457aeefdae4f802e93d8e65c687ddc723701465a5ef19249ed5d2617b5121c58557b34eb99a663bbcf4453a6e1db5d88723de449fcf58ca8ef514daf08cfdc71be155bb3d0724df0c0a6fd5aa7737433cc376640b9b8b4c7ddd09776bae0245729cddb56e36f28edad6aecaed0821ec8d843a96348e722bf0a84cf060a793a2179f054138f907d0c3":int:0
RSA PKCS1 Verify v1.5 CAVS #17
depends_on:2:1
3:hex:"72f0b1ae27e1f5e5bfa15ded204c2c54b47b2420750a3eb5471f9ff98b67c8b5f1a30d3f8d6448562e12ce4deb33a26cfeeae993d6be9e20679d8713c5216870f11276e5f22b0ead2821a7b4dee106fc1e19b13fc9fba5d6e73e4bd93b65a9881a43d5e97ebfb0b357d5d06b21ddbecdbb10626d7748bb9e6e07d49316bbf3c4":exp:0:exp:4:int:1536:int:16:char*:"a59d9b7269b102b7be684ec5e28db79992e6d3231e77c90b78960c2638b35ef6dbdac1ac59e7249d96d426e7f99397eabc6b8903fe1942da580322b98bafacd81bb911c29666f83886a2a2864f3552044300e60cedd5a8c321c43e280413dc41673c39a11b98a885486f8187a70f270185c4c12bc48a1968305269776c070ef69d4913589a887c4d0f5e7dd58bd806d0d49a14a1762c38665cef4646ff13a0cd29c3a60460703c3d051d5b28c660bffb5f8bd43d495ffa64175f72b8abe5fddd":int:16:char*:"3":hex:"8117a6897e14c183737661cf5741350a84ae00495cd9ee8fb033582e559f79701ab424706660515ee5821a69a6850647ec641676a625d1a3899932aaa52161fbc0c0a825db82fde0585b3c9b9c16de43e26da6a30fe5a601dae68bded1e29ec34557b5f6962efb10b9450d6f096655f68e8499cfa16a0adeb9075e7b91851fef84243132d08273d35d01ad89c17e1e6e4deaf1cb233050b275fa9d2cae57e9e1a0e23139267040aa39b6abd8f10fa1cec38ce2183573ddc11626fc262e1a0ced":int:0
RSA PKCS1 Verify v1.5 CAVS #18
depends_on:3:4:1
3:hex:"f80c94a2b53736978adf041886ad97ab2aeb9e91c08bd4eeef6b2f2b8dd75a99b4506657188bbd7597bd5759121630627c8bf9cc30d90dd488c7a81cabab5350a62fa30abf5523f305b98f2c2c1743ec980cf26ab8219bfd9505b981ab1abbfef733b384519d5259fc5c14577cb6b88fa7f6f332ff6a65b23faecc24342c78e9":exp:0:exp:5:int:1536:int:16:char*:"a59d9b7269b102b7be684ec5e28db79992e6d3231e77c90b78960c2638b35ef6dbdac1ac59e7249d96d426e7f99397eabc6b8903fe1942da580322b98bafacd81bb911c29666f83886a2a2864f3552044300e60cedd5a8c321c43e280413dc41673c39a11b98a885486f8187a70f270185c4c12bc48a1968305269776c070ef69d4913589a887c4d0f5e7dd58bd806d0d49a14a1762c38665cef4646ff13a0cd29c3a60460703c3d051d5b28c660bffb5f8bd43d495ffa64175f72b8abe5fddd":int:16:char*:"3":hex:"6b49553ed964ae196a41ea281f4d2a250ce7d1e7434e45cf6a82f7bed17554f39c3f0241e0364702fcb87475eb0c0839ffd2180890fa05b4bbf31bbfa4bf5119dea0c9f88e1e9617fcdadabc6fa1945136cc66e039b905d78ed365c5806d38aec88b3edfb86c05ff446dbfd51d7cd75cbf8d3b85154c783765386f51637532221f52429db5612dcc034968bb8feab7dc6f5ed1f2feb557f6dd49c980296117be2c4195ec7b6101ea767df9d16a56fc9709b49308a54dab63dbc4d609f959ce17":int:0
RSA PKCS1 Verify v1.5 CAVS #19
depends_on:3:1
3:hex:"4eb97094bb42aaa58b040bd06a8f324396b9eca9e39359b7039c4a010434ee131a53aebd9f7a55ae58ea7444fa1505a3ec524e054fd408513cddc1ee4c2f7fd95ec4a6f594be1ba39fa1aa933dc0a5dafff5ce44509577ebb3a3e8084c44010aa27321e5a3f646ade99175633b795c0f570b360eeebeefaef15788f80b5cbecd":exp:0:exp:6:int:1536:int:16:char*:"a59d9b7269b102b7be684ec5e28db79992e6d3231e77c90b78960c2638b35ef6dbdac1ac59e7249d96d426e7f99397eabc6b8903fe1942da580322b98bafacd81bb911c29666f83886a2a2864f3552044300e60cedd5a8c321c43e280413dc41673c39a11b98a885486f8187a70f270185c4c12bc48a1968305269776c070ef69d4913589a887c4d0f5e7dd58bd806d0d49a14a1762c38665cef4646ff13a0cd29c3a60460703c3d051d5b28c660bffb5f8bd43d495ffa64175f72b8abe5fddd":int:16:char*:"3":hex:"2b8b794a8621d492eec18a4efd239e0e077c89340a34b0fdbf467f2bf3112c7f33d00ee736f2988af8569c1a74891efbefa839e295fffdf4d908c1ede61a861a4d24b154a09d1b3f923fd2bb7906994cf82a97da285bf48e61f90cc3596f9350ab9b66a216ffca323195bb213f5a77fe8c697475595a1857dbee58128cbf1be7cb220229ce52766fefd88cc129ad5cbbdcd31fb4eede6c4fdd3193a9aaaa54362bcea4082981d9b7c40483814828f3297d95ad933c76f31c47e37a93ffaf0d4a":int:0
RSA PKCS1 Verify v1.5 CAVS #20
depends_on:0:1
3:hex:"a3edb0f52c6166d7b76e71634761f402337c3e9667549d00cd7877e6055396b35c54c4dffc4c987060178fc10b7e5e827a5c870057002ba6efd31fc4e63a429029be0d6b256b6b653775cb026322743f48e319d053c4aeac34077acb8e0c6c2ef375b2210f8788bd23d24eb0b614de41875b1c8ec56acf18825eaf826691be96":exp:0:exp:1:int:1536:int:16:char*:"a59d9b7269b102b7be684ec5e28db79992e6d3231e77c90b78960c2638b35ef6dbdac1ac59e7249d96d426e7f99397eabc6b8903fe1942da580322b98bafacd81bb911c29666f83886a2a2864f3552044300e60cedd5a8c321c43e280413dc41673c39a11b98a885486f8187a70f270185c4c12bc48a1968305269776c070ef69d4913589a887c4d0f5e7dd58bd806d0d49a14a1762c38665cef4646ff13a0cd29c3a60460703c3d051d5b28c660bffb5f8bd43d495ffa64175f72b8abe5fddd":int:16:char*:"10001":hex:"180630d2f4dc91ddb1159978e278cda7ac4b178e82477f9770c4d2e1c5017d2f222348658044c1be4cda24ce3c9ba3d423536a39bf60324c1b30eabdad700b0982e58072f7e18216e7e4c07e17674ec3eabcfbafce317d2f539f129902d80031ca201a8b325629a96ca4a70b51294c2fddd1d0aca1537d7d8b780e1e62d34be2f98104d876a4990396c8628e6498d9651f468bdf1139664eabe9166efbe909bf87d7305d5f60f1acc3599ed339fcf4e009fbad4059af1a50264cb0a4ec1d23f3":int:0
RSA PKCS1 Verify v1.5 CAVS #21
depends_on:0:1
3:hex:"ac58fd024208d7f045d81a56cd55aad40ab86b0d216ab55136c7027aca23ea13480a52c0dacce0d98139b25965aa4ff76a41dd92037195d24bc0750d52cb3467b48b7b3e71d852c5f82bd9ee85a8388ead5cd8bc38c3d4792e8daa9734a137d31963e245ad3217fad235f7dfd5584de0fe91c4526568588e08b60bdf1badd99f":exp:0:exp:1:int:1536:int:16:char*:"a59d9b7269b102b7be684ec5e28db79992e6d3231e77c90b78960c2638b35ef6dbdac1ac59e7249d96d426e7f99397eabc6b8903fe1942da580322b98bafacd81bb911c29666f83886a2a2864f3552044300e60cedd5a8c321c43e280413dc41673c39a11b98a885486f8187a70f270185c4c12bc48a1968305269776c070ef69d4913589a887c4d0f5e7dd58bd806d0d49a14a1762c38665cef4646ff13a0cd29c3a60460703c3d051d5b28c660bffb5f8bd43d495ffa64175f72b8abe5fddd":int:16:char*:"10001":hex:"a142b0d9456f8f4772675265a08613a66c416bd1ae712975c69d9ca5fb8c1be9c24359a04fd15460bf6136a8a11f13e3ce2de2171524f10cb715f0d71e3db15281ab99eadbe86cf8c5c518162c638ef27a4f7bfb4a1a3873f3c384a5b1c3b4966c837b9d8d192ac34e03943b7ae191355aa1ff3b9cd041bb2668f1f81cf0d015b3d3608cd9ac79398212c0f132f1bd45d47768b999fcf3c05fe2069593ceecedc851a7fc465abcfef0fabba9b9460153f6ba8723a5c6e766c83a446aef3ee327":exp:2
RSA PKCS1 Verify v1.5 CAVS #22
depends_on:2:1
3:hex:"027f767928a5821e2723d6f36c43e6b498b6f0b381852571794a096bd49f1c36a4d7bacec7ec402c24b970163169173bb930ec7fdc39bc9457dfc4ca051f5f28a64de1bbe007c22e8368ff9b117dbda17efd2fb73434bbbf5a4158df56813b8c904bb2e779de504dcd974a291568210d6f85810291606a1c0cd88d51ceadf98a":exp:0:exp:3:int:1536:int:16:char*:"a59d9b7269b102b7be684ec5e28db79992e6d3231e77c90b78960c2638b35ef6dbdac1ac59e7249d96d426e7f99397eabc6b8903fe1942da580322b98bafacd81bb911c29666f83886a2a2864f3552044300e60cedd5a8c321c43e280413dc41673c39a11b98a885486f8187a70f270185c4c12bc48a1968305269776c070ef69d4913589a887c4d0f5e7dd58bd806d0d49a14a1762c38665cef4646ff13a0cd29c3a60460703c3d051d5b28c660bffb5f8bd43d495ffa64175f72b8abe5fddd":int:16:char*:"10001":hex:"0676e64daaa18f4af46e9dfbe234db389b8a527b0fe1db97eb7f404e3155226cba70d318800f83160fa1aa19916e5c09f079331079f18cb8ab1a4b884cb28501824974f683ed2b9babae9f8c15bea30802805c6b2152119764811bbf5f3994d2e97fa2fe8c5ab15a23c14d7ae56be00eaa8bc26678481ff5ba59b0acfb0e43341bff9fc638e5625480a73dbc5d8d13bd2b9e64037c6b79df0c60869980c6a22ec46f80fb859cb4ee5d2032ac1fe538cfd85c70a7f33b4af50a93395917c2cfb6":exp:2
RSA PKCS1 Verify v1.5 CAVS #23
depends_on:2:1
3:hex:"06dcd9d4c056b6a45b9ed2ae5f6c1cfa43aae06fe01ee098264aa7a80e901abbcf9a505e55f9a352ef0c078d48249b8298e57ea21bf0e423c3bf69002acfa541ca05007c704bc79cee7a80e1107c7b28d2b2aa6dd093b28efe9642519952a4a95ee49235f9924a0ac0aee5b2a1bce47459d70cd6e75074614199dca44561407c":exp:0:exp:3:int:1536:int:16:char*:"a59d9b7269b102b7be684ec5e28db79992e6d3231e77c90b78960c2638b35ef6dbdac1ac59e7249d96d426e7f99397eabc6b8903fe1942da580322b98bafacd81bb911c29666f83886a2a2864f3552044300e60cedd5a8c321c43e280413dc41673c39a11b98a885486f8187a70f270185c4c12bc48a1968305269776c070ef69d4913589a887c4d0f5e7dd58bd806d0d49a14a1762c38665cef4646ff13a0cd29c3a60460703c3d051d5b28c660bffb5f8bd43d495ffa64175f72b8abe5fddd":int:16:char*:"10001":hex:"5e08f399258e6de075b67a0a6a822ceb21b1eb7a0342eca6a4295739f644547dee3456243cf32bd6ea6f357c88632508457130f3dae04f7806efaed43d1d501e16c961dfbd6c71a42b480e95c7027f8275063d05a9aac3eef0520867b9896ebe8ec358f7d121beb4e61ddfdc3dcd835dfe265f2ba68d300ef566ed1284f9f3d7b1af363ed47bfa2e5f0492925444df7e5fcb1e79e690c746117650b543a5e82c39553552f0f44e617b5cf773c533050f4129e893ac22af69b1eb9afb4b5ba5f5":int:0
RSA PKCS1 Verify v1.5 CAVS #24
depends_on:2:1
3:hex:"1240028c6d7ab3992ada0e5ca55ee4f3d62f8de575302d5861d73685423c2e6a6d6fb3be090fbc2a701821b6d8fd5e8233f794b6549cd0bb52b390ac31478307bffa91a9bd9c1bf93ffc846356fef008ebee4bb3ee148e0fb1893d188e4934d0d088a433d14a596c5f2e3e49648a22edc6bdbcc58dc1edbd440046b3a169ca2b":exp:0:exp:4:int:1536:int:16:char*:"a59d9b7269b102b7be684ec5e28db79992e6d3231e77c90b78960c2638b35ef6dbdac1ac59e7249d96d426e7f99397eabc6b8903fe1942da580322b98bafacd81bb911c29666f83886a2a2864f3552044300e60cedd5a8c321c43e280413dc41673c39a11b98a885486f8187a70f270185c4c12bc48a1968305269776c070ef69d4913589a887c4d0f5e7dd58bd806d0d49a14a1762c38665cef4646ff13a0cd29c3a60460703c3d051d5b28c660bffb5f8bd43d495ffa64175f72b8abe5fddd":int:16:char*:"10001":hex:"a003ae9cf0704d58763b214f20446ecc4099c566f25384e28d0dd6540c58705fc8d0bfe1ceaa06096ed1e230146edb82056e39e6727abec09f25e44079b6ce1ca2c6a540dec7aa34444d7d435f41e5fca9b0bba62759ae2780638e5160e031bb60409c2e85674ac7a776b444b37b9d7f4dbaa557e88b8562a584f2dbe90729b241aede95dfcc7e05b10deef06255cb89f0e7ccff23354818756a1f8bb9f00fd18f6cd22ca1b4bfc38027562bb37562c77c7883b5d735170d75521195fd3f2bd3":int:0
RSA PKCS1 Verify v1.5 CAVS #25
depends_on:3:4:1
3:hex:"67922a8b9cbc95cf7c555ff2d73cfc62ee04c3f0df9bfc8f64293a58bd3bebd2eb212d711f94e35c729d0873d6b244914d21bd0e59b23089b38740e43f480e8f407d090ac93b08a57403968b55e78cfe31eee6e4ecbacf834168fe89b6b8454fce6e675e80f82b33e850ae3f3d24fd320335e37981fd000576941b4f08d4ba99":exp:0:exp:5:int:1536:int:16:char*:"a59d9b7269b102b7be684ec5e28db79992e6d3231e77c90b78960c2638b35ef6dbdac1ac59e7249d96d426e7f99397eabc6b8903fe1942da580322b98bafacd81bb911c29666f83886a2a2864f3552044300e60cedd5a8c321c43e280413dc41673c39a11b98a885486f8187a70f270185c4c12bc48a1968305269776c070ef69d4913589a887c4d0f5e7dd58bd806d0d49a14a1762c38665cef4646ff13a0cd29c3a60460703c3d051d5b28c660bffb5f8bd43d495ffa64175f72b8abe5fddd":int:16:char*:"10001":hex:"2c6b301852cc55a993a933e2c080eb9dabfe19e9dc3571066caeabed1492d3501cd838de1c01784932df7a5ad5bbfb48c78f53a45f76e9812d046f23bd968495ef7e981e5add4acfc538fe33a5205de74bb37d3d9b6b87b2d174e85a73f216fd67d5738fc469dff7ea6b852e8dd08bc8df036597372d4d51185e6f47a45fbe1b9bdb06a4018783425ec95294de41f27235ad3b3263a890b8b62b17410a9bb08673393ff205a866ee2057e99c6517c6bbc84f8d87717b83d6f64de7ee215e1e8d":int:0
RSA PKCS1 Verify v1.5 CAVS #26
depends_on:3:1
3:hex:"1428b4a449698a994ef84c46a517c3aa6359c48e4264ef65f1f69d77ae26133e17edfc103de416fffb4f2bfe865b434544a418f6e2faca00a165d443f0663ff64080154614f7194057d8b5f1f33934cc9fc2314cf86d4fdad4892bf0d3058f7f37ebe98ef52bfb240b9ad369153afe081bbcf9d7ae43e8ba336b8ac57e8a6da0":exp:0:exp:6:int:1536:int:16:char*:"a59d9b7269b102b7be684ec5e28db79992e6d3231e77c90b78960c2638b35ef6dbdac1ac59e7249d96d426e7f99397eabc6b8903fe1942da580322b98bafacd81bb911c29666f83886a2a2864f3552044300e60cedd5a8c321c43e280413dc41673c39a11b98a885486f8187a70f270185c4c12bc48a1968305269776c070ef69d4913589a887c4d0f5e7dd58bd806d0d49a14a1762c38665cef4646ff13a0cd29c3a60460703c3d051d5b28c660bffb5f8bd43d495ffa64175f72b8abe5fddd":int:16:char*:"10001":hex:"8e10a1ae470e6e57a8d234185f78fdb600cc636c41565a9f3694a84ae102f6251984f54d11a7785fdcfdfaf80a821e05d57ef6b8edc03d9076755779322fd53eb98c805da77dc9316744e393c2fecd291a7e6043b1ca89fd8248f661e1d53110211b91edb41b31e848cde1115d8afd9963ebcc36aff5a27085949f0781bc69167c140ecfe71c44aacaf4123e557eaf2b528c6d0ea875b4ceefa942fe338af8df10562c438af04cd7521da912b3e3899cef0d75722161be6abed5e4e9009dbf40":int:0
RSA PKCS1 Verify v1.5 CAVS #27
depends_on:0:1
3:hex:"4871adc05f6b3ecf296680b0dd8d86715b0d5264c064008037dc410512520b5f193c8f4d21eb6c42e10d220c0275c9b3751f03a4096e2f0e3db9df8d52068c06a51589d23ca1361e9fe27691e95663301ec1407fbf73aee99cc92362eaf6994b95038396d815052a0aef6489bbb7bcb0fffdf13f0af9e7d9fd14f6ce00ab98f7":exp:0:exp:1:int:1536:int:16:char*:"a59d9b7269b102b7be684ec5e28db79992e6d3231e77c90b78960c2638b35ef6dbdac1ac59e7249d96d426e7f99397eabc6b8903fe1942da580322b98bafacd81bb911c29666f83886a2a2864f3552044300e60cedd5a8c321c43e280413dc41673c39a11b98a885486f8187a70f270185c4c12bc48a1968305269776c070ef69d4913589a887c4d0f5e7dd58bd806d0d49a14a1762c38665cef4646ff13a0cd29c3a60460703c3d051d5b28c660bffb5f8bd43d495ffa64175f72b8abe5fddd":int:16:char*:"11":hex:"180caf03781b391aacebe5b3f5e1d3b01c68a00df4ecfb6c4bf14217aed7cfca0adac099ec1d6e1f0b43b09b86788533fee6691d773807af0df6cc3bbdde3cf34bf5b848fa59c8bc10227cc3eba3452a85e0520fccdb2d8d32dd99672d302756a2d7f7f2693db3a48be17bd34d9d891f4ba44449c5bad1de91b788f524500a7703cccbaa77b9fe8791f5c8aa7b8f055336f28fcfc01733712e33cfb3d33fe71ddb9ced2a31931ec38007f5ad4a0d19acc428124b0e5ee6e0746fb33c1a4d90c8":int:0
RSA PKCS1 Verify v1.5 CAVS #28
depends_on:2:1
3:hex:"3bba64de38438a71b95ab9c94539d5870c1fb08d7a9937600c00e9d063438edc97e625d0cd4b1eb00c31c9d94c7a0fe6d03160d1b6cbec5acdad16ada6ef253fee603df9faca8f98a477cc5456f3dfbf6414dbf19f3832e227ce291780188881e82e96a2e84744f12a34a9808a2daedc6fd00b345c6772bec26a095719451e6a":exp:0:exp:3:int:1536:int:16:char*:"a59d9b7269b102b7be684ec5e28db79992e6d3231e77c90b78960c2638b35ef6dbdac1ac59e7249d96d426e7f99397eabc6b8903fe1942da580322b98bafacd81bb911c29666f83886a2a2864f3552044300e60cedd5a8c321c43e280413dc41673c39a11b98a885486f8187a70f270185c4c12bc48a1968305269776c070ef69d4913589a887c4d0f5e7dd58bd806d0d49a14a1762c38665cef4646ff13a0cd29c3a60460703c3d051d5b28c660bffb5f8bd43d495ffa64175f72b8abe5fddd":int:16:char*:"11":hex:"8c846e75e32ce5f9964bdd8f6dcf1d2996a646b233bcf1bd6394e13e856691b89bedd18290a0f9f7c90dca307271b3108e795340490513b25e6789e93722c65ec064b4c43457295a31d1f07dd605e133fd6eaafc58cda132df2939f5f693e0205af34550afaa137f3e482885e50dfb48333a15c0821e7a19642acdddc6fea3c7487c691246a2b083dac439889d5ae741b7e08c47937530b4b069f1a260cd07fe4a0ddd530ab11534fb805e9b562118ee0e97932966008aadfc83f3b8a10de8ee":int:0
RSA PKCS1 Verify v1.5 CAVS #29
depends_on:2:1
3:hex:"f7857ce04bf4292ea1755f9e587822372f4dcdf10bddfc0ff498a8af60ae94a0b482e873085c1cd52a5d181ce6b99a1f8520d74b947d65f3e7e358e8ddc4ac4ae465e39d408eee1f09865159733f83f553cd93cfde1c114fb3e32cf51cd418359016b3867df467b645d752808671a4609f3c49a67023c9ca617e6cffa544a10a":exp:0:exp:4:int:1536:int:16:char*:"a59d9b7269b102b7be684ec5e28db79992e6d3231e77c90b78960c2638b35ef6dbdac1ac59e7249d96d426e7f99397eabc6b8903fe1942da580322b98bafacd81bb911c29666f83886a2a2864f3552044300e60cedd5a8c321c43e280413dc41673c39a11b98a885486f8187a70f270185c4c12bc48a1968305269776c070ef69d4913589a887c4d0f5e7dd58bd806d0d49a14a1762c38665cef4646ff13a0cd29c3a60460703c3d051d5b28c660bffb5f8bd43d495ffa64175f72b8abe5fddd":int:16:char*:"11":hex:"9677300bbee003be3c445634f8ed5beb152b63f46f84cf5a8e721e0fafe8f3f7e99a6d50741f23f449d3026da3e8a7ac36be99ab44831803486ae552f7aa01f075287829b231d2d0840908e09081ae177ed888fe46a9d937a0871eb5d52ec541c8411c4cbf7efea6ca213b12cea513b0739eedca7c9473e10a7796936f4eaa0c5d3a9013ca5536781ac68eb2ca5779144de23da2e9875114aca885b3219dfc292d73940c5992ea3c4882889e7543430652860e441a01a45d9f4005a012421493":int:0
RSA PKCS1 Verify v1.5 CAVS #30
depends_on:2:1
3:hex:"ca312774f2756ac2019f213a01a63c9a0b4a49ccafecf25e97a4c632668e3c77e664f4d7635241f25205e50c37061b02c546db8346fa597c3da8cfd44a827c5a4ff4ecfcd1797b39a1b215d9bbb93fdb6eb35bafbda427a5068888a6e19f86224b0897490491207e35ce39085668b10b4fb851b7dd9465c03869790ef38a61b5":exp:0:exp:4:int:1536:int:16:char*:"a59d9b7269b102b7be684ec5e28db79992e6d3231e77c90b78960c2638b35ef6dbdac1ac59e7249d96d426e7f99397eabc6b8903fe1942da580322b98bafacd81bb911c29666f83886a2a2864f3552044300e60cedd5a8c321c43e280413dc41673c39a11b98a885486f8187a70f270185c4c12bc48a1968305269776c070ef69d4913589a887c4d0f5e7dd58bd806d0d49a14a1762c38665cef4646ff13a0cd29c3a60460703c3d051d5b28c660bffb5f8bd43d495ffa64175f72b8abe5fddd":int:16:char*:"3":hex:"a202c33eb831b9d8e818b6c3bcdb42818e1d9c22a06ddd73a17a21e49d18cda44df349a066477cae068e1a5d2b518b0885e889ef796ca9e6f42a69ac755b8a6405fbaef93fe0130d98de35d689addfee3eecd26658903f774bda481c3f40ee0e9569a3c3e2da7ad576c7de82159d933e36fa29cfef99367005e34ab5082d80f48276d37dabc88dbb023bd01585329d2ccf417f78ec508aaa29751007d31f1669296b981d44c8fa99130c5df7a071725b496859314aaf9baf0ebc780355914249":exp:2
RSA PKCS1 Verify v1.5 CAVS #31
depends_on:3:4:1
3:hex:"2abe079077290ceb6c80ac5c61062ce8da814b1fb99a1a9fb2860ed900e6541856ec64bf19c0d9d1cc2280b7cc50af3e3d2ad8e044945d44761ca60891dd72bd6aa26a33274ffcf7ae7d661b5e651135fcff21aaf06b4a2db18fe5827e0243884f2841760b9f1c65fbda870f7f0cfbd6ff484f0825e688614928f2d12d1e7080":exp:0:exp:5:int:1536:int:16:char*:"a59d9b7269b102b7be684ec5e28db79992e6d3231e77c90b78960c2638b35ef6dbdac1ac59e7249d96d426e7f99397eabc6b8903fe1942da580322b98bafacd81bb911c29666f83886a2a2864f3552044300e60cedd5a8c321c43e280413dc41673c39a11b98a885486f8187a70f270185c4c12bc48a1968305269776c070ef69d4913589a887c4d0f5e7dd58bd806d0d49a14a1762c38665cef4646ff13a0cd29c3a60460703c3d051d5b28c660bffb5f8bd43d495ffa64175f72b8abe5fddd":int:16:char*:"10001":hex:"402631f3cddfb02cc4d9cb58ef1ab6726bd787a50e12e98567c9702bfdf47af85904aec5a2f6c5df9a10f08f90f93728eb090ae2ac21ded9f38faecd8195f3eb3d4107521b1cee956e7a214245b038adae912fa35ec97cb3bdc41352e8aaff80173561284cb740f999a3cd6653a6c3d5a3f911a416f41e2155083982c99eb5998a0a74d77f1ae999d901ee24a7f2c424179a3f92b07dc0b3498c1884e60677bee0175e810b426c4ad008d2743cd19b00b33177bf8be3fed7f7406e1bce0c2ea3":exp:2
RSA PKCS1 Verify v1.5 CAVS #32
depends_on:3:4:1
3:hex:"da9505809dc92cfd8e01a1857dde52df6677c40d98f4577c1659ca7d3e9f01f9a809065f51b54fe2f9723fe2c9d1eea7397f2d5531d1c51c6ea100b028596bf9f24dd90be14eab58f07b4f24a35b073aeb29ecde4a6f320237d7adbdc43d94f87e08866b95bbcac83dc7db3553a42400441f088e2bf6259539a2da8b5a74065f":exp:0:exp:5:int:1536:int:16:char*:"a59d9b7269b102b7be684ec5e28db79992e6d3231e77c90b78960c2638b35ef6dbdac1ac59e7249d96d426e7f99397eabc6b8903fe1942da580322b98bafacd81bb911c29666f83886a2a2864f3552044300e60cedd5a8c321c43e280413dc41673c39a11b98a885486f8187a70f270185c4c12bc48a1968305269776c070ef69d4913589a887c4d0f5e7dd58bd806d0d49a14a1762c38665cef4646ff13a0cd29c3a60460703c3d051d5b28c660bffb5f8bd43d495ffa64175f72b8abe5fddd":int:16:char*:"11":hex:"57edd0560df9840a25c28ff6d254e432395a5cd2d92248b3b44d7eab0fc65b3c4e545a916a8e90ce89745119db9ec9799aa8890f5250fb589cfc12dac1b6e406a39bc3b3663892da5354ba453cbd5e4c89bdce82d0ffe97052a03a5c3308819c1139ebc780c13cf6dc1477faf734abcb1db3fafaed6f22885c9c0222ff5deacb8cc6d027f2e959c3075011b382e88c4b27b83b4f2e6fda022e331c3602d19f5ac7bccfe95ea1e93d736dbd918ae5b1f468cd0b5b536a2f918d5e27a0757e75b7":int:0
RSA PKCS1 Verify v1.5 CAVS #33
depends_on:3:1
3:hex:"d0cd038c65b3acca45822eaf91ea5176e82043268876dec0b62e2abd619023b7023abc67c6b823cfef5447b8772f985ff7910d6cc87e6c23688ac6de1fee40bbe2da1a92770de92adaa427ace02fee571a0a0176fceb0c8f3eb72dde839ab201395625f5c0db8641ce19d7711212dec61733262c6ce4476c025e67a3d5bc01f3":exp:0:exp:6:int:1536:int:16:char*:"a59d9b7269b102b7be684ec5e28db79992e6d3231e77c90b78960c2638b35ef6dbdac1ac59e7249d96d426e7f99397eabc6b8903fe1942da580322b98bafacd81bb911c29666f83886a2a2864f3552044300e60cedd5a8c321c43e280413dc41673c39a11b98a885486f8187a70f270185c4c12bc48a1968305269776c070ef69d4913589a887c4d0f5e7dd58bd806d0d49a14a1762c38665cef4646ff13a0cd29c3a60460703c3d051d5b28c660bffb5f8bd43d495ffa64175f72b8abe5fddd":int:16:char*:"11":hex:"2f30629c1117d013bb36e6099dee931dcaf0a1032b07ec23e2b262898a8945e569c9573d81e22bb0a5f8a28b0d7b8ff01367dd7f089c68ed1daa11cf53a96ee91b38e6b839b6e90bea34d14b78f5d2c7629b68c5b4f2ecfff66b483b2233cb14f95df533c867a2b610aebcdbb7ea3109aaf2f5762ab3edc2571deccc7da0c9a5b443ca2b924c0f18de7bbb736a08fed3916795018a436a3ae62c85d554a53a6d48623908e06e7d275f4251d3b3bd530bd11e155dcf2b5c2adf030cdf931ae749":exp:2
RSA PKCS1 Verify v1.5 CAVS #34
depends_on:3:1
3:hex:"59779fd2a39e56640c4fc1e67b60aeffcecd78aed7ad2bdfa464e93d04198d48466b8da7445f25bfa19db2844edd5c8f539cf772cc132b483169d390db28a43bc4ee0f038f6568ffc87447746cb72fefac2d6d90ee3143a915ac4688028805905a68eb8f8a96674b093c495eddd8704461eaa2b345efbb2ad6930acd8023f870":exp:0:exp:6:int:1536:int:16:char*:"a59d9b7269b102b7be684ec5e28db79992e6d3231e77c90b78960c2638b35ef6dbdac1ac59e7249d96d426e7f99397eabc6b8903fe1942da580322b98bafacd81bb911c29666f83886a2a2864f3552044300e60cedd5a8c321c43e280413dc41673c39a11b98a885486f8187a70f270185c4c12bc48a1968305269776c070ef69d4913589a887c4d0f5e7dd58bd806d0d49a14a1762c38665cef4646ff13a0cd29c3a60460703c3d051d5b28c660bffb5f8bd43d495ffa64175f72b8abe5fddd":int:16:char*:"11":hex:"0b4d96f411c727a262d6d0ade34195b78603551061917d060f89add47b09dfe8715f4f9147d327dc25e91fe457e5d1a2f22cd8fe6fe8e29d2060658307c87a40640650fef3d4b289a6c3febc5a100b29a8b56623afb29fd3c13ea372bf3c638c1db25f8bd8c74c821beec7b5affcace1d05d056a6c2d3035926c7a268df4751a54bc20a6b8cfd729a7cba309ae817daccbef9950a482cf23950a8ca1d3a13ddb7d8d0f87ad5587d4d9ebe19fe93457597a7bdd056c2fd4cea7d31e4a0e595a7b":int:0
RSA PKCS1 Verify v1.5 padding too short
depends_on:0:1
3:hex:"AABBCC03020100FFFFFFFFFF1122330A0B0CCCDDDDDDDDDD":exp:0:exp:1:int:1024:int:16:char*:"9292758453063D803DD603D5E777D7888ED1D5BF35786190FA2F23EBC0848AEADDA92CA6C3D80B32C4D109BE0F36D6AE7130B9CED7ACDF54CFC7555AC14EEBAB93A89813FBF3C4F8066D2D800F7C38A81AE31942917403FF4946B0A83D3D3E05EE57C6F5F5606FB5D4BC6CD34EE0801A5E94BB77B07507233A0BC7BAC8F90F79":int:16:char*:"10001":hex:"6edd56f397d9bc6d176bbe3d80946fc352ad6127b85b1d67d849c0a38cbde7222c5fafbb18dcef791178a8e15f5c8cd91869f8ca4b758c46ce3e229bf666d2e3e296544351bcb5db7e0004f6c0800f76a432071297e405759d4324d1cf1c412758be93a39f834e03dee59e28ac571ce2b0b3c8fe639979f516223b54027340a5":exp:2
RSA PKCS1 Verify v1.5 reduced length encoding
depends_on:2:1
3:hex:"7369676e617475726520746573740a":exp:0:exp:4:int:1024:int:16:char*:"A1D46FBA2318F8DCEF16C280948B1CF27966B9B47225ED2989F8D74B45BD36049C0AAB5AD0FF003553BA843C8E12782FC5873BB89A3DC84B883D25666CD22BF3ACD5B675969F8BEBFBCAC93FDD927C7442B178B10D1DFF9398E52316AAE0AF74E594650BDC3C670241D418684593CDA1A7B9DC4F20D2FDC6F66344074003E211":int:16:char*:"10001":hex:"5B56096ECADA4DAC299FD3D6091C1BE4D7C4210086E61ADA6FFC267A690034DAFB3734035880B9E71CEB0331C32C8DE1A254D777DFE3C848AC7764907602452EC16FD8EB3664E2E682DB3AA8979059BFADFE6192D9029844C8CAF310552717DD5B5B36A9910CFABE5C54AC16F3A3461DEE730060981BD9B47EE8D6644963B7CA":int:0
RSA PKCS1 Verify v1.5 non-reduced length encoding #1
depends_on:2:1
3:hex:"7369676e617475726520746573740a":exp:0:exp:4:int:1024:int:16:char*:"A1D46FBA2318F8DCEF16C280948B1CF27966B9B47225ED2989F8D74B45BD36049C0AAB5AD0FF003553BA843C8E12782FC5873BB89A3DC84B883D25666CD22BF3ACD5B675969F8BEBFBCAC93FDD927C7442B178B10D1DFF9398E52316AAE0AF74E594650BDC3C670241D418684593CDA1A7B9DC4F20D2FDC6F66344074003E211":int:16:char*:"10001":hex:"2FCF7FC1B60B3C083872B1BD9C666745921951A8A9E099FD629675F620B670713519C4A97B870591B97FE5C5DB2FC2A0A3FCB0016536D1205AA32BA8BFCF54ABD542C02F7FCEA3C3531D7A87C82ED5B151A9599F1BDB070A905F5B721DE3C22F8AC35034C607920CE0699D7F79E5913915F3A01856B5D30F9E68F0CD7856D40F":exp:2
RSA PKCS1 Verify v1.5 non-reduced length encoding #2
depends_on:2:1
3:hex:"7369676e617475726520746573740a":exp:0:exp:4:int:1024:int:16:char*:"A1D46FBA2318F8DCEF16C280948B1CF27966B9B47225ED2989F8D74B45BD36049C0AAB5AD0FF003553BA843C8E12782FC5873BB89A3DC84B883D25666CD22BF3ACD5B675969F8BEBFBCAC93FDD927C7442B178B10D1DFF9398E52316AAE0AF74E594650BDC3C670241D418684593CDA1A7B9DC4F20D2FDC6F66344074003E211":int:16:char*:"10001":hex:"3C27512A8FDC973D856C0F288BE27D00D54FC0B359C520DA73A05156D98CDD6A83E6657BFA81D7B9716EEDFD98C08CD82F399298782782AE341D9AABCBB6B5F9C6552DE1D8B93047E1135032653F4F65A8937352E903864E008429E049680E3AA80F5DE1C7408C403011CEF4A3ECA549C027C8954BFBCA21F2A41C3EB0278029":exp:2
RSA PKCS1 Verify v1.5 non-reduced length encoding #3
depends_on:2:1
3:hex:"7369676e617475726520746573740a":exp:0:exp:4:int:1024:int:16:char*:"A1D46FBA2318F8DCEF16C280948B1CF27966B9B47225ED2989F8D74B45BD36049C0AAB5AD0FF003553BA843C8E12782FC5873BB89A3DC84B883D25666CD22BF3ACD5B675969F8BEBFBCAC93FDD927C7442B178B10D1DFF9398E52316AAE0AF74E594650BDC3C670241D418684593CDA1A7B9DC4F20D2FDC6F66344074003E211":int:16:char*:"10001":hex:"24BEB8502F24E0D11D9C10CEE4435EA972CEC93C23936E815ED2DF41BECEDDE889AF85BBEAF1B8C6928913AC523EA1D6653832E9D4E74F55B76771EA84F5A607342C341A14AB258019F38DBAEE4B967C8C8D26D6AF2583D32988471BA38751B6A67BA3D1147619C266A9AAC34244740BB59CD9DB3AFF19438B04C619AB719123":exp:2
RSA PKCS1 Verify v1.5 non-reduced length encoding #4
depends_on:2:1
3:hex:"7369676e617475726520746573740a":exp:0:exp:4:int:1024:int:16:char*:"A1D46FBA2318F8DCEF16C280948B1CF27966B9B47225ED2989F8D74B45BD36049C0AAB5AD0FF003553BA843C8E12782FC5873BB89A3DC84B883D25666CD22BF3ACD5B675969F8BEBFBCAC93FDD927C7442B178B10D1DFF9398E52316AAE0AF74E594650BDC3C670241D418684593CDA1A7B9DC4F20D2FDC6F66344074003E211":int:16:char*:"10001":hex:"13172EF7362CF421103FE1893429FAE85F83636BA8AF545252599A39892E62CEC317DC47C1D6B19328B63CDFD02FA0B49CE7980504635251FF08C0A1308C64D6466DFBF1EF2BA49EFDD6C2C888A30870EC2DC0FA4D67FDE6631C85ED2CEF8EEBF5578C974CBA4A04034D9B579B420D6CA93E4BFC09E014542A0EFB902AF90C5E":exp:2
RSA PKCS1 Verify v1.5 non-reduced length encoding #5
depends_on:2:1
3:hex:"7369676e617475726520746573740a":exp:0:exp:4:int:1024:int:16:char*:"A1D46FBA2318F8DCEF16C280948B1CF27966B9B47225ED2989F8D74B45BD36049C0AAB5AD0FF003553BA843C8E12782FC5873BB89A3DC84B883D25666CD22BF3ACD5B675969F8BEBFBCAC93FDD927C7442B178B10D1DFF9398E52316AAE0AF74E594650BDC3C670241D418684593CDA1A7B9DC4F20D2FDC6F66344074003E211":int:16:char*:"10001":hex:"65DD518F63A2E289C035E9F2A9927BF5A6A74FF6FEFFF61AFCC52ED4A8A5B93534A3AD1709136306EE1379B47A4863BC6ED879E92CD6F99AA5B5F106102BDAE8DAFB15CF6EF00CB5FA63967706528DEE8876F3D04E8D75533009C73DA4C5744D20FFDB18EA78EE4D5D9D6F7BD3AFC2AD9A0EDDD56AA40AAEF789E6FB12AB6DE7":exp:2
RSA PKCS1 Sign #1 (SHA512, 1536 bits RSA)
depends_on:3:1
2:hex:"59779fd2a39e56640c4fc1e67b60aeffcecd78aed7ad2bdfa464e93d04198d48466b8da7445f25bfa19db2844edd5c8f539cf772cc132b483169d390db28a43bc4ee0f038f6568ffc87447746cb72fefac2d6d90ee3143a915ac4688028805905a68eb8f8a96674b093c495eddd8704461eaa2b345efbb2ad6930acd8023f870":exp:0:exp:6:int:1536:int:16:char*:"c8c67df894c882045ede26a9008ab09ea0672077d7bc71d412511cd93981ddde8f91b967da404056c39f105f7f239abdaff92923859920f6299e82b95bd5b8c959948f4a035cbd693ad83014294d349813d1ad57911a6355d0731fe3a034e9db":int:16:char*:"f15147d0e7c04a1e3f37adde802cdc610999bf7ab0088434aaeda0c0ab3910b14d2ce56cb66bffd97552195fae8b061077e03920814d8b9cfb5a3958b3a82c2a7fc97e55db5978b47a922156eb8a3e55c06a54a45d1670abdfb995489c4d0051":int:16:char*:"bd429bb7c3b00bbea19ba664c0f8172d1a73c3cfa05e2ed656d570c1590918bb7e372ed25e2cd71395ba0a9b1a30f3ee012ffb0546cab8e3581fe3e23f44ab57a8aee9717e71a936a580fa8572d450fb00339a6f6704b717df0c149a465bab768c61500cd93b61113ff3e4389167f7b2c8e3c0da2d4765286bee555b0bcb4998f59b14fad03180a17c8b4f69bcd1234f4ae85950137665ac2ba80b55cc9b1aafb454b83771aa755acd2a00e93ddb65e696dbed8bdca69fb5e0c5c2097b9cfe4b":int:16:char*:"3":hex:"93b6fa99485c116ca6efdd4202ea1cf49f4c6345fae692584413743ce5b65510e8e4690aee9a19ea1ff10d57f22aa3548d839f28a8525a34354e9e58e0f3947e056ce2554e21bf287e220b98db3b551258cd42b495e5d1a3bbc83c9d1a02f2a300ef6d866ea75108e44ebb3e16b47df2f6de28feb2be3874dbbf21599451082d86e9f2f462575a8185c69aa1f1fcb6a363c5d71aeba2103449eaf3845285291148d5f78d1646b8dc95cbcc4082f987d948b0e7d4e80b60595f8a7517584e1643":int:0
RSA PKCS1 Sign #1 Verify
depends_on:3:1
3:hex:"59779fd2a39e56640c4fc1e67b60aeffcecd78aed7ad2bdfa464e93d04198d48466b8da7445f25bfa19db2844edd5c8f539cf772cc132b483169d390db28a43bc4ee0f038f6568ffc87447746cb72fefac2d6d90ee3143a915ac4688028805905a68eb8f8a96674b093c495eddd8704461eaa2b345efbb2ad6930acd8023f870":exp:0:exp:6:int:1536:int:16:char*:"bd429bb7c3b00bbea19ba664c0f8172d1a73c3cfa05e2ed656d570c1590918bb7e372ed25e2cd71395ba0a9b1a30f3ee012ffb0546cab8e3581fe3e23f44ab57a8aee9717e71a936a580fa8572d450fb00339a6f6704b717df0c149a465bab768c61500cd93b61113ff3e4389167f7b2c8e3c0da2d4765286bee555b0bcb4998f59b14fad03180a17c8b4f69bcd1234f4ae85950137665ac2ba80b55cc9b1aafb454b83771aa755acd2a00e93ddb65e696dbed8bdca69fb5e0c5c2097b9cfe4b":int:16:char*:"3":hex:"93b6fa99485c116ca6efdd4202ea1cf49f4c6345fae692584413743ce5b65510e8e4690aee9a19ea1ff10d57f22aa3548d839f28a8525a34354e9e58e0f3947e056ce2554e21bf287e220b98db3b551258cd42b495e5d1a3bbc83c9d1a02f2a300ef6d866ea75108e44ebb3e16b47df2f6de28feb2be3874dbbf21599451082d86e9f2f462575a8185c69aa1f1fcb6a363c5d71aeba2103449eaf3845285291148d5f78d1646b8dc95cbcc4082f987d948b0e7d4e80b60595f8a7517584e1643":int:0
RSA PKCS1 Sign #2 (SHA256, 2048 bits RSA)
depends_on:2:1
2:hex:"59779fd2a39e56640c4fc1e67b60aeffcecd78aed7ad2bdfa464e93d04198d48466b8da7445f25bfa19db2844edd5c8f539cf772cc132b483169d390db28a43bc4ee0f038f6568ffc87447746cb72fefac2d6d90ee3143a915ac4688028805905a68eb8f8a96674b093c495eddd8704461eaa2b345efbb2ad6930acd8023f870":exp:0:exp:4:int:2048:int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":hex:"5aee2b9dbc02a6a2d87ff64a64165dc0b9ce70c79bab2d287939e2601c3223e0493988d5468731ae4edc7d5f5d449335c204fdb0e192c1915c9d694d3a61c3be14df79c4b34d6ac73707829024d263c94f9107fa93f3783de3965522336e18d1e01a142b5103451bb97839eaf2f44703a63050a36b78aef4072ea1a8daaaf1a2918fc03ee957a9c09efdc7287bcb4d6aec4723290294b249b3e3dc63157b560ad9c867323a73ebeb360cc9e482111643b0d86c4e33dcf170155590f0eba7d170789e84de336b7fe2f6cf485ddca94607a4ff379fc49d375c730249dd1a210e7dccd762d1c23c7532e769c6aa88e38e8654ff90f7b34df4c07ba90e89099ec1ed":int:0
RSA PKCS1 Sign #2 Verify
depends_on:2:1
3:hex:"59779fd2a39e56640c4fc1e67b60aeffcecd78aed7ad2bdfa464e93d04198d48466b8da7445f25bfa19db2844edd5c8f539cf772cc132b483169d390db28a43bc4ee0f038f6568ffc87447746cb72fefac2d6d90ee3143a915ac4688028805905a68eb8f8a96674b093c495eddd8704461eaa2b345efbb2ad6930acd8023f870":exp:0:exp:4:int:2048:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":hex:"5aee2b9dbc02a6a2d87ff64a64165dc0b9ce70c79bab2d287939e2601c3223e0493988d5468731ae4edc7d5f5d449335c204fdb0e192c1915c9d694d3a61c3be14df79c4b34d6ac73707829024d263c94f9107fa93f3783de3965522336e18d1e01a142b5103451bb97839eaf2f44703a63050a36b78aef4072ea1a8daaaf1a2918fc03ee957a9c09efdc7287bcb4d6aec4723290294b249b3e3dc63157b560ad9c867323a73ebeb360cc9e482111643b0d86c4e33dcf170155590f0eba7d170789e84de336b7fe2f6cf485ddca94607a4ff379fc49d375c730249dd1a210e7dccd762d1c23c7532e769c6aa88e38e8654ff90f7b34df4c07ba90e89099ec1ed":int:0
RSA PKCS1 Sign #2 Verify (Fail)
depends_on:2:1
3:hex:"59779fd2a39e56640c4fc1e67b60aeffcecd78aed7ad2bdfa464e93d04198d48466b8da7445f25bfa19db2844edd5c8f539cf772cc132b483169d390db28a43bc4ee0f038f6568ffc87447746cb72fefac2d6d90ee3143a915ac4688028805905a68eb8f8a96674b093c495eddd8704461eaa2b345efbb2ad6930acd8023f870":exp:0:exp:4:int:2048:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":hex:"5aee2b9dbc02a6a2d87ff64a64165dc0b9ce70c79bab2d287939e2601c3223e0493988d5468731ae4edc7d5f5d449335c204fdb0e192c1915c9d694d3a61c3be14df79c4b34d6ac73707829024d263c94f9107fa93f3783de3965522336e18d1e01a142b5103451bb97839eaf2f44703a63050a36b78aef4072ea1a8daaaf1a2918fc03ee957a9c09efdc6287bcb4d6aec4723290294b249b3e3dc63157b560ad9c867323a73ebeb360cc9e482111643b0d86c4e33dcf170155590f0eba7d170789e84de336b7fe2f6cf485ddca94607a4ff379fc49d375c730249dd1a210e7dccd763d1c23c7532e769c6aa88e38e8654ff90f7b34df4c07ba90e89099ec1ed":exp:2
RSA PKCS1 Sign #3 (SHA224, 2048 bits RSA)
depends_on:2:1
2:hex:"59779fd2a39e56640c4fc1e67b60aeffcecd78aed7ad2bdfa464e93d04198d48466b8da7445f25bfa19db2844edd5c8f539cf772cc132b483169d390db28a43bc4ee0f038f6568ffc87447746cb72fefac2d6d90ee3143a915ac4688028805905a68eb8f8a96674b093c495eddd8704461eaa2b345efbb2ad6930acd8023f870":exp:0:exp:3:int:2048:int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":hex:"9d768b8b31421f9d9ced890aafaf8b3468656419049ed268f6e1992066f45dc3e4cd349e8c5ed5a06e4ef5badaba064ba94907dfedf3d708becaf44ae9b27c3866d329311ba93e8ddc7fc284fba05d1bb84fb1e060a5b76b7fa515cfcd2c8144474623672703cac1e15ff4fdf8ef19d365c51ba86e60f4cbbcd07f956060625751bfbecc47945646459cadaddd900603a8149a93b31a6d432e1da1a67eb765f5b2f0bd1adb9af12d731c7b02931b42dbbfd8c7cecde76b817e96f664147a2c5091c6ce4dc562c5f57159d6f9dc9ba2daa212db56677839621bd4805dde62955fb2d0cc2c448109d10ecc6206ea81f0a02e1646471358f3ec146cd3c75f2d390b":int:0
RSA PKCS1 Sign #3 Verify
depends_on:2:1
3:hex:"59779fd2a39e56640c4fc1e67b60aeffcecd78aed7ad2bdfa464e93d04198d48466b8da7445f25bfa19db2844edd5c8f539cf772cc132b483169d390db28a43bc4ee0f038f6568ffc87447746cb72fefac2d6d90ee3143a915ac4688028805905a68eb8f8a96674b093c495eddd8704461eaa2b345efbb2ad6930acd8023f870":exp:0:exp:3:int:2048:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":hex:"9d768b8b31421f9d9ced890aafaf8b3468656419049ed268f6e1992066f45dc3e4cd349e8c5ed5a06e4ef5badaba064ba94907dfedf3d708becaf44ae9b27c3866d329311ba93e8ddc7fc284fba05d1bb84fb1e060a5b76b7fa515cfcd2c8144474623672703cac1e15ff4fdf8ef19d365c51ba86e60f4cbbcd07f956060625751bfbecc47945646459cadaddd900603a8149a93b31a6d432e1da1a67eb765f5b2f0bd1adb9af12d731c7b02931b42dbbfd8c7cecde76b817e96f664147a2c5091c6ce4dc562c5f57159d6f9dc9ba2daa212db56677839621bd4805dde62955fb2d0cc2c448109d10ecc6206ea81f0a02e1646471358f3ec146cd3c75f2d390b":int:0
RSA PKCS1 Sign #4 (SHA384, 2048 bits RSA)
depends_on:3:4:1
2:hex:"59779fd2a39e56640c4fc1e67b60aeffcecd78aed7ad2bdfa464e93d04198d48466b8da7445f25bfa19db2844edd5c8f539cf772cc132b483169d390db28a43bc4ee0f038f6568ffc87447746cb72fefac2d6d90ee3143a915ac4688028805905a68eb8f8a96674b093c495eddd8704461eaa2b345efbb2ad6930acd8023f870":exp:0:exp:5:int:2048:int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":hex:"40dcc96822e5612eb33f1dca247a35109ba3845c7a3d556a60e656624bf1c103d94686ca7379e9e329ccd1b19b52bfd48b608df9f59a96a82d3feb0101096dbcb80e46da543b4c982ac6bb1717f24f9fe3f76b7154492b47525be1ddcaf4631d33481531be8f3e685837b40bdf4a02827d79f6a32374147174680f51c8e0d8eed9d5c445a563a7bce9ef4236e7cfdc12b2223ef457c3e8ccc6dd65cc23e977a1f03f5ef584feb9af00efc71a701f9d413b0290af17692cb821a1e863d5778e174b1130659f30583f434f09cb1212471a41dd65c102de64a194b6ae3e43cd75928049db78042c58e980aff3ea2774e42845bcf217410a118cf5deeaa64224dbc8":int:0
RSA PKCS1 Sign #4 Verify
depends_on:3:4:1
3:hex:"59779fd2a39e56640c4fc1e67b60aeffcecd78aed7ad2bdfa464e93d04198d48466b8da7445f25bfa19db2844edd5c8f539cf772cc132b483169d390db28a43bc4ee0f038f6568ffc87447746cb72fefac2d6d90ee3143a915ac4688028805905a68eb8f8a96674b093c495eddd8704461eaa2b345efbb2ad6930acd8023f870":exp:0:exp:5:int:2048:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":hex:"40dcc96822e5612eb33f1dca247a35109ba3845c7a3d556a60e656624bf1c103d94686ca7379e9e329ccd1b19b52bfd48b608df9f59a96a82d3feb0101096dbcb80e46da543b4c982ac6bb1717f24f9fe3f76b7154492b47525be1ddcaf4631d33481531be8f3e685837b40bdf4a02827d79f6a32374147174680f51c8e0d8eed9d5c445a563a7bce9ef4236e7cfdc12b2223ef457c3e8ccc6dd65cc23e977a1f03f5ef584feb9af00efc71a701f9d413b0290af17692cb821a1e863d5778e174b1130659f30583f434f09cb1212471a41dd65c102de64a194b6ae3e43cd75928049db78042c58e980aff3ea2774e42845bcf217410a118cf5deeaa64224dbc8":int:0
RSA PKCS1 Sign #5 (MD2, 2048 bits RSA)
depends_on:5:1
2:hex:"59779fd2a39e56640c4fc1e67b60aeffcecd78aed7ad2bdfa464e93d04198d48466b8da7445f25bfa19db2844edd5c8f539cf772cc132b483169d390db28a43bc4ee0f038f6568ffc87447746cb72fefac2d6d90ee3143a915ac4688028805905a68eb8f8a96674b093c495eddd8704461eaa2b345efbb2ad6930acd8023f870":exp:0:exp:7:int:2048:int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":hex:"6cbb0e4019d64dd5cd2d48fa43446e5cba1a7edbb79d91b199be75c7d3e7ae0820c44d3a120cd2910f73cbb315e15963a60ea7da3452015d9d6beb5ac998fddbd1fa3e5908abc9151f3ffb70365aaee6fb0cd440d3f5591868fc136fae38ac7bcdb3bde3c6a0362dd8b814f7edadd4a51b2edf2227a40d1e34c29f608add7746731425858eb93661c633b7a90942fca3cd594ab4ec170052d44105643518020782e76235def34d014135bad8daed590200482325c3416c3d66417e80d9f9c6322a54683638247b577445ecd0be2765ce96c4ee45213204026dfba24d5ee89e1ea75538ba39f7149a5ac0fc12d7c53cbc12481d4a8e2d410ec633d800ad4b4304":int:0
RSA PKCS1 Sign #5 Verify
depends_on:5:1
3:hex:"59779fd2a39e56640c4fc1e67b60aeffcecd78aed7ad2bdfa464e93d04198d48466b8da7445f25bfa19db2844edd5c8f539cf772cc132b483169d390db28a43bc4ee0f038f6568ffc87447746cb72fefac2d6d90ee3143a915ac4688028805905a68eb8f8a96674b093c495eddd8704461eaa2b345efbb2ad6930acd8023f870":exp:0:exp:7:int:2048:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":hex:"6cbb0e4019d64dd5cd2d48fa43446e5cba1a7edbb79d91b199be75c7d3e7ae0820c44d3a120cd2910f73cbb315e15963a60ea7da3452015d9d6beb5ac998fddbd1fa3e5908abc9151f3ffb70365aaee6fb0cd440d3f5591868fc136fae38ac7bcdb3bde3c6a0362dd8b814f7edadd4a51b2edf2227a40d1e34c29f608add7746731425858eb93661c633b7a90942fca3cd594ab4ec170052d44105643518020782e76235def34d014135bad8daed590200482325c3416c3d66417e80d9f9c6322a54683638247b577445ecd0be2765ce96c4ee45213204026dfba24d5ee89e1ea75538ba39f7149a5ac0fc12d7c53cbc12481d4a8e2d410ec633d800ad4b4304":int:0
RSA PKCS1 Sign #6 (MD4, 2048 bits RSA)
depends_on:6:1
2:hex:"59779fd2a39e56640c4fc1e67b60aeffcecd78aed7ad2bdfa464e93d04198d48466b8da7445f25bfa19db2844edd5c8f539cf772cc132b483169d390db28a43bc4ee0f038f6568ffc87447746cb72fefac2d6d90ee3143a915ac4688028805905a68eb8f8a96674b093c495eddd8704461eaa2b345efbb2ad6930acd8023f870":exp:0:exp:8:int:2048:int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":hex:"b0e60dc4dfaf0f636a3a4414eae2d7bce7c3ce505a46e38f3f654d8769b31b7891ba18f89672fce204bbac6e3764355e65447c087994731cd44f086710e79e8c3ebc6e2cb61edc5d3e05848ab733d95efe2d0252a691e810c17fa57fd2dd296374c9ba17fea704685677f45d668a386c8ca433fbbb56d3bbfb43a489ed9518b1c9ab13ce497a1cec91467453bfe533145a31a095c2de541255141768ccc6fdff3fc790b5050f1122c93c3044a9346947e1b23e8125bf7edbf38c64a4286dfc1b829e983db3117959a2559a8ef97687ab673e231be213d88edc632637b58cdb2d69c51fbf6bf894cff319216718b1e696f75cd4366f53dc2e28b2a00017984207":int:0
RSA PKCS1 Sign #6 Verify
depends_on:6:1
3:hex:"59779fd2a39e56640c4fc1e67b60aeffcecd78aed7ad2bdfa464e93d04198d48466b8da7445f25bfa19db2844edd5c8f539cf772cc132b483169d390db28a43bc4ee0f038f6568ffc87447746cb72fefac2d6d90ee3143a915ac4688028805905a68eb8f8a96674b093c495eddd8704461eaa2b345efbb2ad6930acd8023f870":exp:0:exp:8:int:2048:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":hex:"b0e60dc4dfaf0f636a3a4414eae2d7bce7c3ce505a46e38f3f654d8769b31b7891ba18f89672fce204bbac6e3764355e65447c087994731cd44f086710e79e8c3ebc6e2cb61edc5d3e05848ab733d95efe2d0252a691e810c17fa57fd2dd296374c9ba17fea704685677f45d668a386c8ca433fbbb56d3bbfb43a489ed9518b1c9ab13ce497a1cec91467453bfe533145a31a095c2de541255141768ccc6fdff3fc790b5050f1122c93c3044a9346947e1b23e8125bf7edbf38c64a4286dfc1b829e983db3117959a2559a8ef97687ab673e231be213d88edc632637b58cdb2d69c51fbf6bf894cff319216718b1e696f75cd4366f53dc2e28b2a00017984207":int:0
RSA PKCS1 Sign #7 (MD5, 2048 bits RSA)
depends_on:7:1
2:hex:"59779fd2a39e56640c4fc1e67b60aeffcecd78aed7ad2bdfa464e93d04198d48466b8da7445f25bfa19db2844edd5c8f539cf772cc132b483169d390db28a43bc4ee0f038f6568ffc87447746cb72fefac2d6d90ee3143a915ac4688028805905a68eb8f8a96674b093c495eddd8704461eaa2b345efbb2ad6930acd8023f870":exp:0:exp:9:int:2048:int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":hex:"3bcf673c3b27f6e2ece4bb97c7a37161e6c6ee7419ef366efc3cfee0f15f415ff6d9d4390937386c6fec1771acba73f24ec6b0469ea8b88083f0b4e1b6069d7bf286e67cf94182a548663137e82a6e09c35de2c27779da0503f1f5bedfebadf2a875f17763a0564df4a6d945a5a3e46bc90fb692af3a55106aafc6b577587456ff8d49cfd5c299d7a2b776dbe4c1ae777b0f64aa3bab27689af32d6cc76157c7dc6900a3469e18a7d9b6bfe4951d1105a08864575e4f4ec05b3e053f9b7a2d5653ae085e50a63380d6bdd6f58ab378d7e0a2be708c559849891317089ab04c82d8bc589ea088b90b11dea5cf85856ff7e609cc1adb1d403beead4c126ff29021":int:0
RSA PKCS1 Sign #7 Verify
depends_on:7:1
3:hex:"59779fd2a39e56640c4fc1e67b60aeffcecd78aed7ad2bdfa464e93d04198d48466b8da7445f25bfa19db2844edd5c8f539cf772cc132b483169d390db28a43bc4ee0f038f6568ffc87447746cb72fefac2d6d90ee3143a915ac4688028805905a68eb8f8a96674b093c495eddd8704461eaa2b345efbb2ad6930acd8023f870":exp:0:exp:9:int:2048:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":hex:"3bcf673c3b27f6e2ece4bb97c7a37161e6c6ee7419ef366efc3cfee0f15f415ff6d9d4390937386c6fec1771acba73f24ec6b0469ea8b88083f0b4e1b6069d7bf286e67cf94182a548663137e82a6e09c35de2c27779da0503f1f5bedfebadf2a875f17763a0564df4a6d945a5a3e46bc90fb692af3a55106aafc6b577587456ff8d49cfd5c299d7a2b776dbe4c1ae777b0f64aa3bab27689af32d6cc76157c7dc6900a3469e18a7d9b6bfe4951d1105a08864575e4f4ec05b3e053f9b7a2d5653ae085e50a63380d6bdd6f58ab378d7e0a2be708c559849891317089ab04c82d8bc589ea088b90b11dea5cf85856ff7e609cc1adb1d403beead4c126ff29021":int:0
RSA PKCS1 Sign #8 (RAW, 2048 bits RSA)
depends_on:1
4:hex:"1234567890deadbeef":exp:0:int:2048:int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":hex:"605baf947c0de49e4f6a0dfb94a43ae318d5df8ed20ba4ba5a37a73fb009c5c9e5cce8b70a25b1c7580f389f0d7092485cdfa02208b70d33482edf07a7eafebdc54862ca0e0396a5a7d09991b9753eb1ffb6091971bb5789c6b121abbcd0a3cbaa39969fa7c28146fce96c6d03272e3793e5be8f5abfa9afcbebb986d7b3050604a2af4d3a40fa6c003781a539a60259d1e84f13322da9e538a49c369b83e7286bf7d30b64bbb773506705da5d5d5483a563a1ffacc902fb75c9a751b1e83cdc7a6db0470056883f48b5a5446b43b1d180ea12ba11a6a8d93b3b32a30156b6084b7fb142998a2a0d28014b84098ece7d9d5e4d55cc342ca26f5a0167a679dec8"
RSA PKCS1 Sign #8 Verify
depends_on:1
5:hex:"1234567890deadbeef":exp:0:int:2048:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":hex:"605baf947c0de49e4f6a0dfb94a43ae318d5df8ed20ba4ba5a37a73fb009c5c9e5cce8b70a25b1c7580f389f0d7092485cdfa02208b70d33482edf07a7eafebdc54862ca0e0396a5a7d09991b9753eb1ffb6091971bb5789c6b121abbcd0a3cbaa39969fa7c28146fce96c6d03272e3793e5be8f5abfa9afcbebb986d7b3050604a2af4d3a40fa6c003781a539a60259d1e84f13322da9e538a49c369b83e7286bf7d30b64bbb773506705da5d5d5483a563a1ffacc902fb75c9a751b1e83cdc7a6db0470056883f48b5a5446b43b1d180ea12ba11a6a8d93b3b32a30156b6084b7fb142998a2a0d28014b84098ece7d9d5e4d55cc342ca26f5a0167a679dec8":int:0
RSA PKCS1 Sign #8 Verify (Wrong raw hash)
depends_on:1
5:hex:"1234567890deadcafe":exp:0:int:2048:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":hex:"605baf947c0de49e4f6a0dfb94a43ae318d5df8ed20ba4ba5a37a73fb009c5c9e5cce8b70a25b1c7580f389f0d7092485cdfa02208b70d33482edf07a7eafebdc54862ca0e0396a5a7d09991b9753eb1ffb6091971bb5789c6b121abbcd0a3cbaa39969fa7c28146fce96c6d03272e3793e5be8f5abfa9afcbebb986d7b3050604a2af4d3a40fa6c003781a539a60259d1e84f13322da9e538a49c369b83e7286bf7d30b64bbb773506705da5d5d5483a563a1ffacc902fb75c9a751b1e83cdc7a6db0470056883f48b5a5446b43b1d180ea12ba11a6a8d93b3b32a30156b6084b7fb142998a2a0d28014b84098ece7d9d5e4d55cc342ca26f5a0167a679dec8":exp:2
RSA PKCS1 Sign #9 (Invalid Digest type)
depends_on:1
2:hex:"59779fd2a39e56640c4fc1e67b60aeffcecd78aed7ad2bdfa464e93d04198d48466b8da7445f25bfa19db2844edd5c8f539cf772cc132b483169d390db28a43bc4ee0f038f6568ffc87447746cb72fefac2d6d90ee3143a915ac4688028805905a68eb8f8a96674b093c495eddd8704461eaa2b345efbb2ad6930acd8023f870":exp:0:int:255:int:2048:int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":hex:"3bcf673c3b27f6e2ece4bb97c7a37161e6c6ee7419ef366efc3cfee0f15f415ff6d9d4390937386c6fec1771acba73f24ec6b0469ea8b88083f0b4e1b6069d7bf286e67cf94182a548663137e82a6e09c35de2c27779da0503f1f5bedfebadf2a875f17763a0564df4a6d945a5a3e46bc90fb692af3a55106aafc6b577587456ff8d49cfd5c299d7a2b776dbe4c1ae777b0f64aa3bab27689af32d6cc76157c7dc6900a3469e18a7d9b6bfe4951d1105a08864575e4f4ec05b3e053f9b7a2d5653ae085e50a63380d6bdd6f58ab378d7e0a2be708c559849891317089ab04c82d8bc589ea088b90b11dea5cf85856ff7e609cc1adb1d403beead4c126ff29021":exp:10
RSA PKCS1 Sign #9 Verify (Invalid Digest type)
depends_on:1
3:hex:"59779fd2a39e56640c4fc1e67b60aeffcecd78aed7ad2bdfa464e93d04198d48466b8da7445f25bfa19db2844edd5c8f539cf772cc132b483169d390db28a43bc4ee0f038f6568ffc87447746cb72fefac2d6d90ee3143a915ac4688028805905a68eb8f8a96674b093c495eddd8704461eaa2b345efbb2ad6930acd8023f870":exp:0:int:255:int:2048:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":hex:"3bcf673c3b27f6e2ece4bb97c7a37161e6c6ee7419ef366efc3cfee0f15f415ff6d9d4390937386c6fec1771acba73f24ec6b0469ea8b88083f0b4e1b6069d7bf286e67cf94182a548663137e82a6e09c35de2c27779da0503f1f5bedfebadf2a875f17763a0564df4a6d945a5a3e46bc90fb692af3a55106aafc6b577587456ff8d49cfd5c299d7a2b776dbe4c1ae777b0f64aa3bab27689af32d6cc76157c7dc6900a3469e18a7d9b6bfe4951d1105a08864575e4f4ec05b3e053f9b7a2d5653ae085e50a63380d6bdd6f58ab378d7e0a2be708c559849891317089ab04c82d8bc589ea088b90b11dea5cf85856ff7e609cc1adb1d403beead4c126ff29021":exp:10
RSA PKCS1 Sign #10 (RIPEMD160, 2048 bits RSA)
depends_on:8:1
2:hex:"616263":exp:0:exp:11:int:2048:int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":hex:"aa2d9f88334d61bed74317ba549b1463600a9219801240cca5c11b9cdda29373172a28151313fb2cf73bb68af167e4ec645b6f065028802afbcfbc10e6c2c824e3c4d50c7181193b93734832170f0c5d3dd9ba5808f0e2a5c16b3d0df90defefef8e8fde5906962d42a2f0d62d7f81977f367f436f10c8b1183ccf6676953f7219445938f725d0cb62efbabf092de531642863b381e2694f2bf544ff6a4fefa7b37cdbf6292dbedcacf6e57d6f206ce5df0fd2771f9f64818f59a0ab7a5f003b368dc3eb51ab9409a0ec4e43f45281ee9a560664de88965ab207e256303d9dcb8233ed6ad0a5ad7f81e2f8c7a196dc81e2c8b6dde8a77fb6cfd1e5477ece9df8":int:0
RSA PKCS1 Verify #10 (RIPEMD160, 2048 bits RSA)
depends_on:8:1
3:hex:"616263":exp:0:exp:11:int:2048:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":hex:"aa2d9f88334d61bed74317ba549b1463600a9219801240cca5c11b9cdda29373172a28151313fb2cf73bb68af167e4ec645b6f065028802afbcfbc10e6c2c824e3c4d50c7181193b93734832170f0c5d3dd9ba5808f0e2a5c16b3d0df90defefef8e8fde5906962d42a2f0d62d7f81977f367f436f10c8b1183ccf6676953f7219445938f725d0cb62efbabf092de531642863b381e2694f2bf544ff6a4fefa7b37cdbf6292dbedcacf6e57d6f206ce5df0fd2771f9f64818f59a0ab7a5f003b368dc3eb51ab9409a0ec4e43f45281ee9a560664de88965ab207e256303d9dcb8233ed6ad0a5ad7f81e2f8c7a196dc81e2c8b6dde8a77fb6cfd1e5477ece9df8":int:0
RSA PKCS1 Encrypt #1
depends_on:1
6:hex:"4E636AF98E40F3ADCFCCB698F4E80B9F":exp:0:int:2048:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":hex:"b0c0b193ba4a5b4502bfacd1a9c2697da5510f3e3ab7274cf404418afd2c62c89b98d83bbc21c8c1bf1afe6d8bf40425e053e9c03e03a3be0edbe1eda073fade1cc286cc0305a493d98fe795634c3cad7feb513edb742d66d910c87d07f6b0055c3488bb262b5fd1ce8747af64801fb39d2d3a3e57086ffe55ab8d0a2ca86975629a0f85767a4990c532a7c2dab1647997ebb234d0b28a0008bfebfc905e7ba5b30b60566a5e0190417465efdbf549934b8f0c5c9f36b7c5b6373a47ae553ced0608a161b1b70dfa509375cf7a3598223a6d7b7a1d1a06ac74d345a9bb7c0e44c8388858a4f1d8115f2bd769ffa69020385fa286302c80e950f9e2751308666c":int:0
RSA PKCS1 Decrypt #1 (Verify)
depends_on:1
8:hex:"a42eda41e56235e666e7faaa77100197f657288a1bf183e4820f0c37ce2c456b960278d6003e0bbcd4be4a969f8e8fd9231e1f492414f00ed09844994c86ec32db7cde3bec7f0c3dbf6ae55baeb2712fa609f5fc3207a824eb3dace31849cd6a6084318523912bccb84cf42e3c6d6d1685131d69bb545acec827d2b0dfdd5568b7dcc4f5a11d6916583fefa689d367f8c9e1d95dcd2240895a9470b0c1730f97cd6e8546860bd254801769f54be96e16362ddcbf34d56035028890199e0f48db38642cb66a4181e028a6443a404fea284ce02b4614b683367d40874e505611d23142d49f06feea831d52d347b13610b413c4efc43a6de9f0b08d2a951dc503b6":exp:0:int:2048:int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":int:32:hex:"4E636AF98E40F3ADCFCCB698F4E80B9F":int:0
RSA PKCS1 Encrypt #2 (Data too large)
depends_on:1
6:hex:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":exp:0:int:2048:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":hex:"a42eda41e56235e666e7faaa77100197f657288a1bf183e4820f0c37ce2c456b960278d6003e0bbcd4be4a969f8e8fd9231e1f492414f00ed09844994c86ec32db7cde3bec7f0c3dbf6ae55baeb2712fa609f5fc3207a824eb3dace31849cd6a6084318523912bccb84cf42e3c6d6d1685131d69bb545acec827d2b0dfdd5568b7dcc4f5a11d6916583fefa689d367f8c9e1d95dcd2240895a9470b0c1730f97cd6e8546860bd254801769f54be96e16362ddcbf34d56035028890199e0f48db38642cb66a4181e028a6443a404fea284ce02b4614b683367d40874e505611d23142d49f06feea831d52d347b13610b413c4efc43a6de9f0b08d2a951dc503b6":exp:10
RSA PKCS1 Decrypt #2 (Data too small)
depends_on:1
8:hex:"deadbeafcafedeadbeeffedcba9876":exp:0:int:2048:int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":int:32:hex:"4E636AF98E40F3ADCFCCB698F4E80B9F":exp:12
RSA PKCS1 Decrypt #4 (Output buffer too small)
depends_on:1
8:hex:"a42eda41e56235e666e7faaa77100197f657288a1bf183e4820f0c37ce2c456b960278d6003e0bbcd4be4a969f8e8fd9231e1f492414f00ed09844994c86ec32db7cde3bec7f0c3dbf6ae55baeb2712fa609f5fc3207a824eb3dace31849cd6a6084318523912bccb84cf42e3c6d6d1685131d69bb545acec827d2b0dfdd5568b7dcc4f5a11d6916583fefa689d367f8c9e1d95dcd2240895a9470b0c1730f97cd6e8546860bd254801769f54be96e16362ddcbf34d56035028890199e0f48db38642cb66a4181e028a6443a404fea284ce02b4614b683367d40874e505611d23142d49f06feea831d52d347b13610b413c4efc43a6de9f0b08d2a951dc503b6":exp:0:int:2048:int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":int:15:hex:"4E636AF98E40F3ADCFCCB698F4E80B9F":exp:13
RSA Check empty private key
11
RSA Check Private key #1 (Correct)
13:int:2048:int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":int:16:char*:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":int:16:char*:"9A66CF76572A71A17475794FA1C8C70D987E581E990D772BB27C77C53FF1ECBB31260E9EDAFAEBC79991807E48918EAB8C3A5F03A600F30C69511546AE788EDF53168E2D035D300EDCD5E4BF3AA2A6D603EA0A7BD11E1C1089657306DF8A64E7F1BC6B266B825C1A6C5F0FC85775F4CF7ACD63367E42EAFE46511D58AD6DFE0F":int:16:char*:"844DBDD20925D9164F9A1E2F707076C261CCA8337D0241392B38AE3C12342F3AC14F8FD6DF4A1C36839662BD0D227344CD55A32AE5DBD2309A9A2B8A2C82BE6DDDDCE81D1B694775D9047AA765CA0C6E1BB8E61C8B7BE27ED711E8EE2FEAD87F3491F76A6D2262C14189EACDFD4CEFE0BF9D0A5B49857E0ED22CBEB98DC8D45B":int:16:char*:"4951A7B174DF972C37BADCC38457B5EDD1F078BC613E75CE25E08814E12461C7A1C189A70EB8138294298D141244C7A9DE31AB4F6D38B40B04D6353CD30F77ADBF66BBDE41C7BE463C5E30AAA3F7BAD6CEE99506DEAAFA2F335C1B1C5C88B8ABB0D0387EE0D1B4E7027F7F085A025CEDB5CCE18B88C0462F1C3C910D47C0D4AB":int:0
RSA Check Private key #2 (No P)
13:int:2048:int:16:char*:"":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":int:16:char*:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":int:16:char*:"9A66CF76572A71A17475794FA1C8C70D987E581E990D772BB27C77C53FF1ECBB31260E9EDAFAEBC79991807E48918EAB8C3A5F03A600F30C69511546AE788EDF53168E2D035D300EDCD5E4BF3AA2A6D603EA0A7BD11E1C1089657306DF8A64E7F1BC6B266B825C1A6C5F0FC85775F4CF7ACD63367E42EAFE46511D58AD6DFE0F":int:16:char*:"844DBDD20925D9164F9A1E2F707076C261CCA8337D0241392B38AE3C12342F3AC14F8FD6DF4A1C36839662BD0D227344CD55A32AE5DBD2309A9A2B8A2C82BE6DDDDCE81D1B694775D9047AA765CA0C6E1BB8E61C8B7BE27ED711E8EE2FEAD87F3491F76A6D2262C14189EACDFD4CEFE0BF9D0A5B49857E0ED22CBEB98DC8D45B":int:16:char*:"4951A7B174DF972C37BADCC38457B5EDD1F078BC613E75CE25E08814E12461C7A1C189A70EB8138294298D141244C7A9DE31AB4F6D38B40B04D6353CD30F77ADBF66BBDE41C7BE463C5E30AAA3F7BAD6CEE99506DEAAFA2F335C1B1C5C88B8ABB0D0387EE0D1B4E7027F7F085A025CEDB5CCE18B88C0462F1C3C910D47C0D4AB":exp:14
RSA Check Private key #3 (No Q)
13:int:2048:int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"":int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":int:16:char*:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":int:16:char*:"9A66CF76572A71A17475794FA1C8C70D987E581E990D772BB27C77C53FF1ECBB31260E9EDAFAEBC79991807E48918EAB8C3A5F03A600F30C69511546AE788EDF53168E2D035D300EDCD5E4BF3AA2A6D603EA0A7BD11E1C1089657306DF8A64E7F1BC6B266B825C1A6C5F0FC85775F4CF7ACD63367E42EAFE46511D58AD6DFE0F":int:16:char*:"844DBDD20925D9164F9A1E2F707076C261CCA8337D0241392B38AE3C12342F3AC14F8FD6DF4A1C36839662BD0D227344CD55A32AE5DBD2309A9A2B8A2C82BE6DDDDCE81D1B694775D9047AA765CA0C6E1BB8E61C8B7BE27ED711E8EE2FEAD87F3491F76A6D2262C14189EACDFD4CEFE0BF9D0A5B49857E0ED22CBEB98DC8D45B":int:16:char*:"4951A7B174DF972C37BADCC38457B5EDD1F078BC613E75CE25E08814E12461C7A1C189A70EB8138294298D141244C7A9DE31AB4F6D38B40B04D6353CD30F77ADBF66BBDE41C7BE463C5E30AAA3F7BAD6CEE99506DEAAFA2F335C1B1C5C88B8ABB0D0387EE0D1B4E7027F7F085A025CEDB5CCE18B88C0462F1C3C910D47C0D4AB":exp:14
RSA Check Private key #4 (No N)
13:int:2048:int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"":int:16:char*:"3":int:16:char*:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":int:16:char*:"9A66CF76572A71A17475794FA1C8C70D987E581E990D772BB27C77C53FF1ECBB31260E9EDAFAEBC79991807E48918EAB8C3A5F03A600F30C69511546AE788EDF53168E2D035D300EDCD5E4BF3AA2A6D603EA0A7BD11E1C1089657306DF8A64E7F1BC6B266B825C1A6C5F0FC85775F4CF7ACD63367E42EAFE46511D58AD6DFE0F":int:16:char*:"844DBDD20925D9164F9A1E2F707076C261CCA8337D0241392B38AE3C12342F3AC14F8FD6DF4A1C36839662BD0D227344CD55A32AE5DBD2309A9A2B8A2C82BE6DDDDCE81D1B694775D9047AA765CA0C6E1BB8E61C8B7BE27ED711E8EE2FEAD87F3491F76A6D2262C14189EACDFD4CEFE0BF9D0A5B49857E0ED22CBEB98DC8D45B":int:16:char*:"4951A7B174DF972C37BADCC38457B5EDD1F078BC613E75CE25E08814E12461C7A1C189A70EB8138294298D141244C7A9DE31AB4F6D38B40B04D6353CD30F77ADBF66BBDE41C7BE463C5E30AAA3F7BAD6CEE99506DEAAFA2F335C1B1C5C88B8ABB0D0387EE0D1B4E7027F7F085A025CEDB5CCE18B88C0462F1C3C910D47C0D4AB":exp:14
RSA Check Private key #5 (No E)
13:int:2048:int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"":int:16:char*:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":int:16:char*:"9A66CF76572A71A17475794FA1C8C70D987E581E990D772BB27C77C53FF1ECBB31260E9EDAFAEBC79991807E48918EAB8C3A5F03A600F30C69511546AE788EDF53168E2D035D300EDCD5E4BF3AA2A6D603EA0A7BD11E1C1089657306DF8A64E7F1BC6B266B825C1A6C5F0FC85775F4CF7ACD63367E42EAFE46511D58AD6DFE0F":int:16:char*:"844DBDD20925D9164F9A1E2F707076C261CCA8337D0241392B38AE3C12342F3AC14F8FD6DF4A1C36839662BD0D227344CD55A32AE5DBD2309A9A2B8A2C82BE6DDDDCE81D1B694775D9047AA765CA0C6E1BB8E61C8B7BE27ED711E8EE2FEAD87F3491F76A6D2262C14189EACDFD4CEFE0BF9D0A5B49857E0ED22CBEB98DC8D45B":int:16:char*:"4951A7B174DF972C37BADCC38457B5EDD1F078BC613E75CE25E08814E12461C7A1C189A70EB8138294298D141244C7A9DE31AB4F6D38B40B04D6353CD30F77ADBF66BBDE41C7BE463C5E30AAA3F7BAD6CEE99506DEAAFA2F335C1B1C5C88B8ABB0D0387EE0D1B4E7027F7F085A025CEDB5CCE18B88C0462F1C3C910D47C0D4AB":exp:14
RSA Check Private key #6 (No D)
13:int:2048:int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":int:16:char*:"":int:16:char*:"9A66CF76572A71A17475794FA1C8C70D987E581E990D772BB27C77C53FF1ECBB31260E9EDAFAEBC79991807E48918EAB8C3A5F03A600F30C69511546AE788EDF53168E2D035D300EDCD5E4BF3AA2A6D603EA0A7BD11E1C1089657306DF8A64E7F1BC6B266B825C1A6C5F0FC85775F4CF7ACD63367E42EAFE46511D58AD6DFE0F":int:16:char*:"844DBDD20925D9164F9A1E2F707076C261CCA8337D0241392B38AE3C12342F3AC14F8FD6DF4A1C36839662BD0D227344CD55A32AE5DBD2309A9A2B8A2C82BE6DDDDCE81D1B694775D9047AA765CA0C6E1BB8E61C8B7BE27ED711E8EE2FEAD87F3491F76A6D2262C14189EACDFD4CEFE0BF9D0A5B49857E0ED22CBEB98DC8D45B":int:16:char*:"4951A7B174DF972C37BADCC38457B5EDD1F078BC613E75CE25E08814E12461C7A1C189A70EB8138294298D141244C7A9DE31AB4F6D38B40B04D6353CD30F77ADBF66BBDE41C7BE463C5E30AAA3F7BAD6CEE99506DEAAFA2F335C1B1C5C88B8ABB0D0387EE0D1B4E7027F7F085A025CEDB5CCE18B88C0462F1C3C910D47C0D4AB":exp:14
RSA Check Private key #7 (No DP)
depends_on:9
13:int:2048:int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":int:16:char*:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":int:16:char*:"":int:16:char*:"844DBDD20925D9164F9A1E2F707076C261CCA8337D0241392B38AE3C12342F3AC14F8FD6DF4A1C36839662BD0D227344CD55A32AE5DBD2309A9A2B8A2C82BE6DDDDCE81D1B694775D9047AA765CA0C6E1BB8E61C8B7BE27ED711E8EE2FEAD87F3491F76A6D2262C14189EACDFD4CEFE0BF9D0A5B49857E0ED22CBEB98DC8D45B":int:16:char*:"4951A7B174DF972C37BADCC38457B5EDD1F078BC613E75CE25E08814E12461C7A1C189A70EB8138294298D141244C7A9DE31AB4F6D38B40B04D6353CD30F77ADBF66BBDE41C7BE463C5E30AAA3F7BAD6CEE99506DEAAFA2F335C1B1C5C88B8ABB0D0387EE0D1B4E7027F7F085A025CEDB5CCE18B88C0462F1C3C910D47C0D4AB":exp:14
RSA Check Private key #8 (No DQ)
depends_on:9
13:int:2048:int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":int:16:char*:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":int:16:char*:"9A66CF76572A71A17475794FA1C8C70D987E581E990D772BB27C77C53FF1ECBB31260E9EDAFAEBC79991807E48918EAB8C3A5F03A600F30C69511546AE788EDF53168E2D035D300EDCD5E4BF3AA2A6D603EA0A7BD11E1C1089657306DF8A64E7F1BC6B266B825C1A6C5F0FC85775F4CF7ACD63367E42EAFE46511D58AD6DFE0F":int:16:char*:"":int:16:char*:"4951A7B174DF972C37BADCC38457B5EDD1F078BC613E75CE25E08814E12461C7A1C189A70EB8138294298D141244C7A9DE31AB4F6D38B40B04D6353CD30F77ADBF66BBDE41C7BE463C5E30AAA3F7BAD6CEE99506DEAAFA2F335C1B1C5C88B8ABB0D0387EE0D1B4E7027F7F085A025CEDB5CCE18B88C0462F1C3C910D47C0D4AB":exp:14
RSA Check Private key #9 (No QP)
depends_on:9
13:int:2048:int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":int:16:char*:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":int:16:char*:"9A66CF76572A71A17475794FA1C8C70D987E581E990D772BB27C77C53FF1ECBB31260E9EDAFAEBC79991807E48918EAB8C3A5F03A600F30C69511546AE788EDF53168E2D035D300EDCD5E4BF3AA2A6D603EA0A7BD11E1C1089657306DF8A64E7F1BC6B266B825C1A6C5F0FC85775F4CF7ACD63367E42EAFE46511D58AD6DFE0F":int:16:char*:"844DBDD20925D9164F9A1E2F707076C261CCA8337D0241392B38AE3C12342F3AC14F8FD6DF4A1C36839662BD0D227344CD55A32AE5DBD2309A9A2B8A2C82BE6DDDDCE81D1B694775D9047AA765CA0C6E1BB8E61C8B7BE27ED711E8EE2FEAD87F3491F76A6D2262C14189EACDFD4CEFE0BF9D0A5B49857E0ED22CBEB98DC8D45B":int:16:char*:"":exp:14
RSA Check Private key #10 (Incorrect)
13:int:2048:int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":int:16:char*:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCC":int:16:char*:"9A66CF76572A71A17475794FA1C8C70D987E581E990D772BB27C77C53FF1ECBB31260E9EDAFAEBC79991807E48918EAB8C3A5F03A600F30C69511546AE788EDF53168E2D035D300EDCD5E4BF3AA2A6D603EA0A7BD11E1C1089657306DF8A64E7F1BC6B266B825C1A6C5F0FC85775F4CF7ACD63367E42EAFE46511D58AD6DFE0F":int:16:char*:"844DBDD20925D9164F9A1E2F707076C261CCA8337D0241392B38AE3C12342F3AC14F8FD6DF4A1C36839662BD0D227344CD55A32AE5DBD2309A9A2B8A2C82BE6DDDDCE81D1B694775D9047AA765CA0C6E1BB8E61C8B7BE27ED711E8EE2FEAD87F3491F76A6D2262C14189EACDFD4CEFE0BF9D0A5B49857E0ED22CBEB98DC8D45B":int:16:char*:"4951A7B174DF972C37BADCC38457B5EDD1F078BC613E75CE25E08814E12461C7A1C189A70EB8138294298D141244C7A9DE31AB4F6D38B40B04D6353CD30F77ADBF66BBDE41C7BE463C5E30AAA3F7BAD6CEE99506DEAAFA2F335C1B1C5C88B8ABB0D0387EE0D1B4E7027F7F085A025CEDB5CCE18B88C0462F1C3C910D47C0D4AB":exp:14
RSA Check Public key #1 (Correct)
12:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":int:0
RSA Check Public key #2 (Even N)
12:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a20340":int:16:char*:"3":exp:14
RSA Check Public key #3 (Even E)
12:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a20340":int:16:char*:"65536":exp:14
RSA Check Public key #4 (N exactly 128 bits)
12:int:16:char*:"fedcba9876543210deadbeefcafe4321":int:16:char*:"3":int:0
RSA Check Public key #5 (N smaller than 128 bits)
12:int:16:char*:"7edcba9876543210deadbeefcafe4321":int:16:char*:"3":exp:14
RSA Check Public key #6 (N exactly 8192 bits)
depends_on:10
12:int:16:char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int:16:char*:"010001":int:0
RSA Check Public key #7 (N larger than 8192 bits)
12:int:16:char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int:16:char*:"010001":exp:14
RSA Check Public key #8 (E exactly 2 bits)
12:int:16:char*:"fedcba9876543210deadbeefcafe4321":int:16:char*:"3":int:0
RSA Check Public key #8 (E exactly 1 bits)
12:int:16:char*:"fedcba9876543210deadbeefcafe4321":int:16:char*:"1":exp:14
RSA Check Public key #8 (E exactly 64 bits)
12:int:16:char*:"fedcba9876543210deadbeefcafe4321":int:16:char*:"00fedcba9876543213":int:0
RSA Check Public key #8 (E larger than 64 bits)
12:int:16:char*:"fedcba9876543210deadbeefcafe4321":int:16:char*:"01fedcba9876543213":int:0
RSA Check Public key #9 (E has size N-2)
12:int:16:char*:"00b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034fb38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"00b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034fb38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034d":int:0
RSA Check Public key #10 (E has size N)
12:int:16:char*:"00b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034fb38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"00b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034fb38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":exp:14
RSA Check Public-Private key #1 (Correct)
14:int:2048:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":int:16:char*:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":int:16:char*:"9A66CF76572A71A17475794FA1C8C70D987E581E990D772BB27C77C53FF1ECBB31260E9EDAFAEBC79991807E48918EAB8C3A5F03A600F30C69511546AE788EDF53168E2D035D300EDCD5E4BF3AA2A6D603EA0A7BD11E1C1089657306DF8A64E7F1BC6B266B825C1A6C5F0FC85775F4CF7ACD63367E42EAFE46511D58AD6DFE0F":int:16:char*:"844DBDD20925D9164F9A1E2F707076C261CCA8337D0241392B38AE3C12342F3AC14F8FD6DF4A1C36839662BD0D227344CD55A32AE5DBD2309A9A2B8A2C82BE6DDDDCE81D1B694775D9047AA765CA0C6E1BB8E61C8B7BE27ED711E8EE2FEAD87F3491F76A6D2262C14189EACDFD4CEFE0BF9D0A5B49857E0ED22CBEB98DC8D45B":int:16:char*:"4951A7B174DF972C37BADCC38457B5EDD1F078BC613E75CE25E08814E12461C7A1C189A70EB8138294298D141244C7A9DE31AB4F6D38B40B04D6353CD30F77ADBF66BBDE41C7BE463C5E30AAA3F7BAD6CEE99506DEAAFA2F335C1B1C5C88B8ABB0D0387EE0D1B4E7027F7F085A025CEDB5CCE18B88C0462F1C3C910D47C0D4AB":int:0
RSA Check Public-Private key #2 (Public no N)
14:int:2048:int:16:char*:"":int:16:char*:"3":int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":int:16:char*:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":int:16:char*:"9A66CF76572A71A17475794FA1C8C70D987E581E990D772BB27C77C53FF1ECBB31260E9EDAFAEBC79991807E48918EAB8C3A5F03A600F30C69511546AE788EDF53168E2D035D300EDCD5E4BF3AA2A6D603EA0A7BD11E1C1089657306DF8A64E7F1BC6B266B825C1A6C5F0FC85775F4CF7ACD63367E42EAFE46511D58AD6DFE0F":int:16:char*:"844DBDD20925D9164F9A1E2F707076C261CCA8337D0241392B38AE3C12342F3AC14F8FD6DF4A1C36839662BD0D227344CD55A32AE5DBD2309A9A2B8A2C82BE6DDDDCE81D1B694775D9047AA765CA0C6E1BB8E61C8B7BE27ED711E8EE2FEAD87F3491F76A6D2262C14189EACDFD4CEFE0BF9D0A5B49857E0ED22CBEB98DC8D45B":int:16:char*:"4951A7B174DF972C37BADCC38457B5EDD1F078BC613E75CE25E08814E12461C7A1C189A70EB8138294298D141244C7A9DE31AB4F6D38B40B04D6353CD30F77ADBF66BBDE41C7BE463C5E30AAA3F7BAD6CEE99506DEAAFA2F335C1B1C5C88B8ABB0D0387EE0D1B4E7027F7F085A025CEDB5CCE18B88C0462F1C3C910D47C0D4AB":exp:14
RSA Check Public-Private key #3 (Private no N)
14:int:2048:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"":int:16:char*:"3":int:16:char*:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":int:16:char*:"9A66CF76572A71A17475794FA1C8C70D987E581E990D772BB27C77C53FF1ECBB31260E9EDAFAEBC79991807E48918EAB8C3A5F03A600F30C69511546AE788EDF53168E2D035D300EDCD5E4BF3AA2A6D603EA0A7BD11E1C1089657306DF8A64E7F1BC6B266B825C1A6C5F0FC85775F4CF7ACD63367E42EAFE46511D58AD6DFE0F":int:16:char*:"844DBDD20925D9164F9A1E2F707076C261CCA8337D0241392B38AE3C12342F3AC14F8FD6DF4A1C36839662BD0D227344CD55A32AE5DBD2309A9A2B8A2C82BE6DDDDCE81D1B694775D9047AA765CA0C6E1BB8E61C8B7BE27ED711E8EE2FEAD87F3491F76A6D2262C14189EACDFD4CEFE0BF9D0A5B49857E0ED22CBEB98DC8D45B":int:16:char*:"4951A7B174DF972C37BADCC38457B5EDD1F078BC613E75CE25E08814E12461C7A1C189A70EB8138294298D141244C7A9DE31AB4F6D38B40B04D6353CD30F77ADBF66BBDE41C7BE463C5E30AAA3F7BAD6CEE99506DEAAFA2F335C1B1C5C88B8ABB0D0387EE0D1B4E7027F7F085A025CEDB5CCE18B88C0462F1C3C910D47C0D4AB":exp:14
RSA Check Public-Private key #4 (N mismatch)
14:int:2048:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034e":int:16:char*:"3":int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":int:16:char*:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":int:16:char*:"9A66CF76572A71A17475794FA1C8C70D987E581E990D772BB27C77C53FF1ECBB31260E9EDAFAEBC79991807E48918EAB8C3A5F03A600F30C69511546AE788EDF53168E2D035D300EDCD5E4BF3AA2A6D603EA0A7BD11E1C1089657306DF8A64E7F1BC6B266B825C1A6C5F0FC85775F4CF7ACD63367E42EAFE46511D58AD6DFE0F":int:16:char*:"844DBDD20925D9164F9A1E2F707076C261CCA8337D0241392B38AE3C12342F3AC14F8FD6DF4A1C36839662BD0D227344CD55A32AE5DBD2309A9A2B8A2C82BE6DDDDCE81D1B694775D9047AA765CA0C6E1BB8E61C8B7BE27ED711E8EE2FEAD87F3491F76A6D2262C14189EACDFD4CEFE0BF9D0A5B49857E0ED22CBEB98DC8D45B":int:16:char*:"4951A7B174DF972C37BADCC38457B5EDD1F078BC613E75CE25E08814E12461C7A1C189A70EB8138294298D141244C7A9DE31AB4F6D38B40B04D6353CD30F77ADBF66BBDE41C7BE463C5E30AAA3F7BAD6CEE99506DEAAFA2F335C1B1C5C88B8ABB0D0387EE0D1B4E7027F7F085A025CEDB5CCE18B88C0462F1C3C910D47C0D4AB":exp:14
RSA Check Public-Private key #5 (E mismatch)
14:int:2048:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"17":int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":int:16:char*:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":int:16:char*:"9A66CF76572A71A17475794FA1C8C70D987E581E990D772BB27C77C53FF1ECBB31260E9EDAFAEBC79991807E48918EAB8C3A5F03A600F30C69511546AE788EDF53168E2D035D300EDCD5E4BF3AA2A6D603EA0A7BD11E1C1089657306DF8A64E7F1BC6B266B825C1A6C5F0FC85775F4CF7ACD63367E42EAFE46511D58AD6DFE0F":int:16:char*:"844DBDD20925D9164F9A1E2F707076C261CCA8337D0241392B38AE3C12342F3AC14F8FD6DF4A1C36839662BD0D227344CD55A32AE5DBD2309A9A2B8A2C82BE6DDDDCE81D1B694775D9047AA765CA0C6E1BB8E61C8B7BE27ED711E8EE2FEAD87F3491F76A6D2262C14189EACDFD4CEFE0BF9D0A5B49857E0ED22CBEB98DC8D45B":int:16:char*:"4951A7B174DF972C37BADCC38457B5EDD1F078BC613E75CE25E08814E12461C7A1C189A70EB8138294298D141244C7A9DE31AB4F6D38B40B04D6353CD30F77ADBF66BBDE41C7BE463C5E30AAA3F7BAD6CEE99506DEAAFA2F335C1B1C5C88B8ABB0D0387EE0D1B4E7027F7F085A025CEDB5CCE18B88C0462F1C3C910D47C0D4AB":exp:14
RSA Private (Correct)
10:hex:"59779fd2a39e56640c4fc1e67b60aeffcecd78aed7ad2bdfa464e93d04198d48466b8da7445f25bfa19db2844edd5c8f539cf772cc132b483169d390db28a43bc4ee0f038f6568ffc87447746cb72fefac2d6d90ee3143a915ac4688028805905a68eb8f8a96674b093c495eddd8704461eaa2b345efbb2ad6930acd8023f8700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000":int:2048:int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":hex:"48ce62658d82be10737bd5d3579aed15bc82617e6758ba862eeb12d049d7bacaf2f62fce8bf6e980763d1951f7f0eae3a493df9890d249314b39d00d6ef791de0daebf2c50f46e54aeb63a89113defe85de6dbe77642aae9f2eceb420f3a47a56355396e728917f17876bb829fabcaeef8bf7ef6de2ff9e84e6108ea2e52bbb62b7b288efa0a3835175b8b08fac56f7396eceb1c692d419ecb79d80aef5bc08a75d89de9f2b2d411d881c0e3ffad24c311a19029d210d3d3534f1b626f982ea322b4d1cfba476860ef20d4f672f38c371084b5301b429b747ea051a619e4430e0dac33c12f9ee41ca4d81a4f6da3e495aa8524574bdc60d290dd1f7a62e90a67":int:0
RSA Private (Data larger than N)
10:hex:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:2048:int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":hex:"605baf947c0de49e4f6a0dfb94a43ae318d5df8ed20ba4ba5a37a73fb009c5c9e5cce8b70a25b1c7580f389f0d7092485cdfa02208b70d33482edf07a7eafebdc54862ca0e0396a5a7d09991b9753eb1ffb6091971bb5789c6b121abbcd0a3cbaa39969fa7c28146fce96c6d03272e3793e5be8f5abfa9afcbebb986d7b3050604a2af4d3a40fa6c003781a539a60259d1e84f13322da9e538a49c369b83e7286bf7d30b64bbb773506705da5d5d5483a563a1ffacc902fb75c9a751b1e83cdc7a6db0470056883f48b5a5446b43b1d180ea12ba11a6a8d93b3b32a30156b6084b7fb142998a2a0d28014b84098ece7d9d5e4d55cc342ca26f5a0167a679dec8":exp:12
RSA Public (Correct)
9:hex:"59779fd2a39e56640c4fc1e67b60aeffcecd78aed7ad2bdfa464e93d04198d48466b8da7445f25bfa19db2844edd5c8f539cf772cc132b483169d390db28a43bc4ee0f038f6568ffc87447746cb72fefac2d6d90ee3143a915ac4688028805905a68eb8f8a96674b093c495eddd8704461eaa2b345efbb2ad6930acd8023f8700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000":int:2048:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":hex:"1f5e927c13ff231090b0f18c8c3526428ed0f4a7561457ee5afe4d22d5d9220c34ef5b9a34d0c07f7248a1f3d57f95d10f7936b3063e40660b3a7ca3e73608b013f85a6e778ac7c60d576e9d9c0c5a79ad84ceea74e4722eb3553bdb0c2d7783dac050520cb27ca73478b509873cb0dcbd1d51dd8fccb96c29ad314f36d67cc57835d92d94defa0399feb095fd41b9f0b2be10f6041079ed4290040449f8a79aba50b0a1f8cf83c9fb8772b0686ec1b29cb1814bb06f9c024857db54d395a8da9a2c6f9f53b94bec612a0cb306a3eaa9fc80992e85d9d232e37a50cabe48c9343f039601ff7d95d60025e582aec475d031888310e8ec3833b394a5cf0599101e":int:0
RSA Public (Data larger than N)
9:hex:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:2048:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":hex:"605baf947c0de49e4f6a0dfb94a43ae318d5df8ed20ba4ba5a37a73fb009c5c9e5cce8b70a25b1c7580f389f0d7092485cdfa02208b70d33482edf07a7eafebdc54862ca0e0396a5a7d09991b9753eb1ffb6091971bb5789c6b121abbcd0a3cbaa39969fa7c28146fce96c6d03272e3793e5be8f5abfa9afcbebb986d7b3050604a2af4d3a40fa6c003781a539a60259d1e84f13322da9e538a49c369b83e7286bf7d30b64bbb773506705da5d5d5483a563a1ffacc902fb75c9a751b1e83cdc7a6db0470056883f48b5a5446b43b1d180ea12ba11a6a8d93b3b32a30156b6084b7fb142998a2a0d28014b84098ece7d9d5e4d55cc342ca26f5a0167a679dec8":exp:15
RSA Generate Key - 128bit key
15:int:128:int:3:int:0
RSA Generate Key (Number of bits too small)
15:int:127:int:3:exp:10
RSA Generate Key (Exponent too small)
15:int:128:int:2:exp:10
RSA Generate Key - 1024 bit key
15:int:1024:int:3:int:0
RSA Generate Key - 2048 bit key
15:int:2048:int:3:int:0
RSA Generate Key - 1025 bit key
15:int:1025:int:3:exp:10
RSA Validate Params, toy example
20:int:10:char*:"15":int:10:char*:"3":int:10:char*:"5":int:10:char*:"3":int:10:char*:"3":int:0:int:0
RSA Validate Params, toy example, N missing
20:int:10:char*:"":int:10:char*:"3":int:10:char*:"5":int:10:char*:"3":int:10:char*:"3":int:0:int:0
RSA Validate Params, toy example, E missing
20:int:10:char*:"15":int:10:char*:"3":int:10:char*:"5":int:10:char*:"3":int:10:char*:"":int:0:int:0
RSA Validate Params, toy example, corrupted
20:int:10:char*:"16":int:10:char*:"3":int:10:char*:"5":int:10:char*:"3":int:10:char*:"3":int:0:exp:14
RSA Validate Params, toy example, non-primes, no PRNG
20:int:10:char*:"45":int:10:char*:"9":int:10:char*:"5":int:10:char*:"7":int:10:char*:"23":int:0:int:0
RSA Validate Params, toy example, non-primes, PRNG
20:int:10:char*:"45":int:10:char*:"9":int:10:char*:"5":int:10:char*:"7":int:10:char*:"23":int:1:exp:14
RSA Validate Params
20:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":int:16:char*:"3":int:0:int:0
RSA Validate Params, N missing
20:int:16:char*:"":int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":int:16:char*:"3":int:0:int:0
RSA Validate Params, bad N
20:int:16:char*:"b38bc65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":int:16:char*:"3":int:0:exp:14
RSA Validate Params, non-prime, no PRNG
20:int:16:char*:"":int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd18":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"":int:16:char*:"":int:0:int:0
RSA Validate Params, non-prime, PRNG
20:int:16:char*:"":int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd18":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"":int:16:char*:"":int:1:exp:14
RSA Deduce Private, toy example
17:int:10:char*:"7":int:10:char*:"11":int:10:char*:"7":int:10:char*:"13":int:0:int:0
RSA Deduce Private, toy example, corrupted
17:int:10:char*:"3":int:10:char*:"5":int:10:char*:"3":int:10:char*:"3":int:1:exp:16
RSA Deduce Private
17:int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"3":int:16:char*:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":int:0:int:0
RSA Deduce Private, corrupted
17:int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"3":int:16:char*:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":int:1:exp:16
RSA Deduce Primes, toy example
16:int:10:char*:"35":int:10:char*:"5":int:10:char*:"5":int:10:char*:"5":int:10:char*:"7":int:0:int:0
RSA Deduce Primes, toy example, corrupted
16:int:10:char*:"35":int:10:char*:"5":int:10:char*:"5":int:10:char*:"5":int:10:char*:"7":int:1:exp:17
RSA Deduce Moduli
16:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":int:16:char*:"3":int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:0:int:0
RSA Deduce Moduli, corrupted
16:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":int:16:char*:"3":int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:1:exp:17
RSA Import (N,P,Q,D,E)
18:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":int:16:char*:"3":int:0:int:1:int:0:int:0
RSA Import (N,P,Q,D,E), inconsistent
18:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC3672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":int:16:char*:"3":int:0:int:1:exp:14:int:0
RSA Import (N,P,Q,D,E), successive
18:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":int:16:char*:"3":int:1:int:1:int:0:int:0
RSA Import (N,P,Q,D,E), successive, inconsistent
18:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC3672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":int:16:char*:"3":int:1:int:1:exp:14:int:0
RSA Import (-,P,Q,D,E)
18:int:16:char*:"":int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":int:16:char*:"3":int:0:int:1:int:0:int:0
RSA Import (-,P,Q,D,E), successive
18:int:16:char*:"":int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":int:16:char*:"3":int:1:int:1:int:0:int:0
RSA Import (N,-,-,D,E)
18:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"":int:16:char*:"":int:16:char*:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":int:16:char*:"3":int:0:int:1:int:0:int:0
RSA Import (N,-,-,D,E), successive
18:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"":int:16:char*:"":int:16:char*:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":int:16:char*:"3":int:1:int:1:int:0:int:0
RSA Import (N,P,Q,-,E)
18:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"":int:16:char*:"3":int:0:int:1:int:0:int:0
RSA Import (N,P,Q,-,E), successive
18:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"":int:16:char*:"3":int:1:int:1:int:0:int:0
RSA Import (-,P,Q,-,E)
18:int:16:char*:"":int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"":int:16:char*:"3":int:0:int:1:int:0:int:0
RSA Import (-,P,Q,-,E), successive
18:int:16:char*:"":int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"":int:16:char*:"3":int:1:int:1:int:0:int:0
RSA Import (N,-,Q,-,E)
18:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"":int:16:char*:"3":int:0:int:1:int:0:exp:10
RSA Import (N,-,Q,-,E), successive
18:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"":int:16:char*:"3":int:1:int:1:int:0:exp:10
RSA Import (N,-,-,-,E), complete public key
18:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"":int:16:char*:"":int:16:char*:"":int:16:char*:"3":int:0:int:0:int:0:int:0
RSA Import (N,-,-,-,E), complete public key, successive
18:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"":int:16:char*:"":int:16:char*:"":int:16:char*:"3":int:1:int:0:int:0:int:0
RSA Import (N,-,-,-,E), complete public key, corrupted
18:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"":int:16:char*:"":int:16:char*:"":int:16:char*:"4":int:0:int:0:exp:14:int:0
RSA Import (N,-,-,-,E), complete public key, successive, corrupted
18:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"":int:16:char*:"":int:16:char*:"":int:16:char*:"4":int:1:int:0:exp:14:int:0
RSA Import Raw (N,P,Q,D,E), complete private key
22:hex:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":hex:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":hex:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":hex:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":hex:"03":int:0:int:1:int:0:int:0
RSA Import Raw (N,P,Q,D,E), successive
22:hex:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":hex:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":hex:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":hex:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":hex:"03":int:1:int:1:int:0:int:0
RSA Import Raw (-,P,Q,D,E)
22:hex:"":hex:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":hex:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":hex:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":hex:"03":int:0:int:1:int:0:int:0
RSA Import Raw (-,P,Q,D,E), successive
22:hex:"":hex:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":hex:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":hex:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":hex:"03":int:1:int:1:int:0:int:0
RSA Import Raw (N,-,-,D,E)
22:hex:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":hex:"":hex:"":hex:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":hex:"03":int:0:int:1:int:0:int:0
RSA Import Raw (N,-,-,D,E), successive
22:hex:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":hex:"":hex:"":hex:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":hex:"03":int:1:int:1:int:0:int:0
RSA Import Raw (N,P,Q,-,E)
22:hex:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":hex:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":hex:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":hex:"":hex:"03":int:0:int:1:int:0:int:0
RSA Import Raw (N,P,Q,-,E), successive
22:hex:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":hex:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":hex:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":hex:"":hex:"03":int:1:int:1:int:0:int:0
RSA Import Raw (-,P,Q,-,E)
22:hex:"":hex:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":hex:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":hex:"":hex:"03":int:0:int:1:int:0:int:0
RSA Import Raw (-,P,Q,-,E), successive
22:hex:"":hex:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":hex:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":hex:"":hex:"03":int:1:int:1:int:0:int:0
RSA Import Raw (N,-,Q,-,E)
22:hex:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":hex:"":hex:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":hex:"":hex:"03":int:0:int:1:int:0:exp:10
RSA Import Raw (N,-,Q,-,E), successive
22:hex:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":hex:"":hex:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":hex:"":hex:"03":int:1:int:1:int:0:exp:10
RSA Import Raw (N,-,-,-,E)
22:hex:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":hex:"":hex:"":hex:"":hex:"03":int:0:int:0:int:0:int:0
RSA Import Raw (N,-,-,-,E), successive
22:hex:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":hex:"":hex:"":hex:"":hex:"03":int:1:int:0:int:0:int:0
RSA Import Raw (-,-,-,-,-)
22:hex:"":hex:"":hex:"":hex:"":hex:"":int:0:int:0:int:0:exp:10
RSA Export (N,P,Q,D,E)
19:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":int:16:char*:"3":int:1:int:0
RSA Export (N,P,Q,D,E), successive
19:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":int:16:char*:"3":int:1:int:1
RSA Export (N,-,-,D,E)
19:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"":int:16:char*:"":int:16:char*:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":int:16:char*:"3":int:1:int:0
RSA Export (N,-,-,D,E), successive
19:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"":int:16:char*:"":int:16:char*:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":int:16:char*:"3":int:1:int:1
RSA Export (N,P,Q,-,E)
19:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"":int:16:char*:"3":int:1:int:0
RSA Export (N,P,Q,-,E), successive
19:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":int:16:char*:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":int:16:char*:"":int:16:char*:"3":int:1:int:1
RSA Export (N,-,-,-,E)
19:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"":int:16:char*:"":int:16:char*:"":int:16:char*:"3":int:0:int:0
RSA Export Raw (N,P,Q,D,E)
21:hex:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":hex:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":hex:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":hex:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":hex:"03":int:1:int:0
RSA Export Raw (N,P,Q,D,E), successive
21:hex:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":hex:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":hex:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":hex:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":hex:"03":int:1:int:1
RSA Export Raw (N,-,-,D,E)
21:hex:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":hex:"":hex:"":hex:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":hex:"03":int:1:int:0
RSA Export Raw (N,-,-,D,E), successive
21:hex:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":hex:"":hex:"":hex:"77B1D99300D6A54E864962DA09AE10CF19A7FB888456BC2672B72AEA52B204914493D16C184AD201EC3F762E1FBD8702BA796EF953D9EA2F26300D285264F11B0C8301D0207FEB1E2C984445C899B0ACEBAA74EF014DD1D4BDDB43202C08D2FF9692D8D788478DEC829EB52AFB5AE068FBDBAC499A27FACECC391E75C936D55F07BB45EE184DAB45808E15722502F279F89B38C1CB292557E5063597F52C75D61001EDC33F4739353E33E56AD273B067C1A2760208529EA421774A5FFFCB3423B1E0051E7702A55D80CBF2141569F18F87BFF538A1DA8EDBB2693A539F68E0D62D77743F89EACF3B1723BDB25CE2F333FA63CACF0E67DF1A431893BB9B352FCB":hex:"03":int:1:int:1
RSA Export Raw (N,P,Q,-,E)
21:hex:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":hex:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":hex:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":hex:"":hex:"03":int:1:int:0
RSA Export Raw (N,P,Q,-,E), successive
21:hex:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":hex:"e79a373182bfaa722eb035f772ad2a9464bd842de59432c18bbab3a7dfeae318c9b915ee487861ab665a40bd6cda560152578e8579016c929df99fea05b4d64efca1d543850bc8164b40d71ed7f3fa4105df0fb9b9ad2a18ce182c8a4f4f975bea9aa0b9a1438a27a28e97ac8330ef37383414d1bd64607d6979ac050424fd17":hex:"c6749cbb0db8c5a177672d4728a8b22392b2fc4d3b8361d5c0d5055a1b4e46d821f757c24eef2a51c561941b93b3ace7340074c058c9bb48e7e7414f42c41da4cccb5c2ba91deb30c586b7fb18af12a52995592ad139d3be429add6547e044becedaf31fa3b39421e24ee034fbf367d11f6b8f88ee483d163b431e1654ad3e89":hex:"":hex:"03":int:1:int:1
RSA Export Raw (N,-,-,-,E)
21:hex:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":hex:"":hex:"":hex:"":hex:"03":int:0:int:0
RSA PKCS1 Encrypt Bad RNG
depends_on:1
7:hex:"4E636AF98E40F3ADCFCCB698F4E80B9F":exp:0:int:2048:int:16:char*:"b38ac65c8141f7f5c96e14470e851936a67bf94cc6821a39ac12c05f7c0b06d9e6ddba2224703b02e25f31452f9c4a8417b62675fdc6df46b94813bc7b9769a892c482b830bfe0ad42e46668ace68903617faf6681f4babf1cc8e4b0420d3c7f61dc45434c6b54e2c3ee0fc07908509d79c9826e673bf8363255adb0add2401039a7bcd1b4ecf0fbe6ec8369d2da486eec59559dd1d54c9b24190965eafbdab203b35255765261cd0909acf93c3b8b8428cbb448de4715d1b813d0c94829c229543d391ce0adab5351f97a3810c1f73d7b1458b97daed4209c50e16d064d2d5bfda8c23893d755222793146d0a78c3d64f35549141486c3b0961a7b4c1a2034f":int:16:char*:"3":hex:"a42eda41e56235e666e7faaa77100197f657288a1bf183e4820f0c37ce2c456b960278d6003e0bbcd4be4a969f8e8fd9231e1f492414f00ed09844994c86ec32db7cde3bec7f0c3dbf6ae55baeb2712fa609f5fc3207a824eb3dace31849cd6a6084318523912bccb84cf42e3c6d6d1685131d69bb545acec827d2b0dfdd5568b7dcc4f5a11d6916583fefa689d367f8c9e1d95dcd2240895a9470b0c1730f97cd6e8546860bd254801769f54be96e16362ddcbf34d56035028890199e0f48db38642cb66a4181e028a6443a404fea284ce02b4614b683367d40874e505611d23142d49f06feea831d52d347b13610b413c4efc43a6de9f0b08d2a951dc503b6":exp:18
RSA Selftest
depends_on:11
23
| 202,923 | 609 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_net.c | /* clang-format off */
/*
* Copyright The Mbed TLS Contributors
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "third_party/mbedtls/test/test.inc"
/*
* *** THIS FILE WAS MACHINE GENERATED ***
*
* This file has been machine generated using the script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* Test file : ./test_suite_net.c
*
* The following files were used to create this file.
*
* Main code file : suites/main_test.function
* Platform code file : suites/host_test.function
* Helper file : suites/helpers.function
* Test suite file : suites/test_suite_net.function
* Test suite data : suites/test_suite_net.data
*
*/
#define TEST_SUITE_ACTIVE
#if defined(MBEDTLS_NET_C)
#if defined(unix) || defined(__unix__) || defined(__unix) || \
defined(__APPLE__) || defined(__QNXNTO__) || \
defined(__HAIKU__) || defined(__midipix__)
#define MBEDTLS_PLATFORM_IS_UNIXLIKE
#endif
#if defined(MBEDTLS_PLATFORM_IS_UNIXLIKE)
#endif
#if defined(MBEDTLS_PLATFORM_IS_UNIXLIKE)
/** Open a file on the given file descriptor.
*
* This is disruptive if there is already something open on that descriptor.
* Caller beware.
*
* \param ctx An initialized, but unopened socket context.
* On success, it refers to the opened file (\p wanted_fd).
* \param wanted_fd The desired file descriptor.
*
* \return \c 0 on succes, a negative error code on error.
*/
static int open_file_on_fd( mbedtls_net_context *ctx, int wanted_fd )
{
int got_fd = open( "/dev/null", O_RDONLY );
TEST_ASSERT( got_fd >= 0 );
if( got_fd != wanted_fd )
{
TEST_ASSERT( dup2( got_fd, wanted_fd ) >= 0 );
TEST_ASSERT( close( got_fd ) >= 0 );
}
ctx->fd = wanted_fd;
return( 0 );
exit:
return( -1 );
}
#endif /* MBEDTLS_PLATFORM_IS_UNIXLIKE */
void test_context_init_free( int reinit )
{
mbedtls_net_context ctx;
mbedtls_net_init( &ctx );
mbedtls_net_free( &ctx );
if( reinit )
mbedtls_net_init( &ctx );
mbedtls_net_free( &ctx );
/* This test case always succeeds, functionally speaking. A plausible
* bug might trigger an invalid pointer dereference or a memory leak. */
goto exit;
exit:
;
}
void test_context_init_free_wrapper( void ** params )
{
test_context_init_free( *( (int *) params[0] ) );
}
#if defined(MBEDTLS_PLATFORM_IS_UNIXLIKE)
void test_poll_beyond_fd_setsize( )
{
/* Test that mbedtls_net_poll does not misbehave when given a file
* descriptor greater or equal to FD_SETSIZE. This code is specific to
* platforms with a Unix-like select() function, which is where
* FD_SETSIZE is a concern. */
struct rlimit rlim_nofile;
int restore_rlim_nofile = 0;
int ret;
mbedtls_net_context ctx;
uint8_t buf[1];
mbedtls_net_init( &ctx );
/* On many systems, by default, the maximum permitted file descriptor
* number is less than FD_SETSIZE. If so, raise the limit if
* possible.
*
* If the limit can't be raised, a file descriptor opened by the
* net_sockets module will be less than FD_SETSIZE, so the test
* is not necessary and we mark it as skipped.
* A file descriptor could still be higher than FD_SETSIZE if it was
* opened before the limit was lowered (which is something an application
* might do); but we don't do such things in our test code, so the unit
* test will run if it can.
*/
TEST_ASSERT( getrlimit( RLIMIT_NOFILE, &rlim_nofile ) == 0 );
if( rlim_nofile.rlim_cur < FD_SETSIZE + 1 )
{
rlim_t old_rlim_cur = rlim_nofile.rlim_cur;
rlim_nofile.rlim_cur = FD_SETSIZE + 1;
TEST_ASSUME( setrlimit( RLIMIT_NOFILE, &rlim_nofile ) == 0 );
rlim_nofile.rlim_cur = old_rlim_cur;
restore_rlim_nofile = 1;
}
TEST_ASSERT( open_file_on_fd( &ctx, FD_SETSIZE ) == 0 );
/* In principle, mbedtls_net_poll() with valid arguments should succeed.
* However, we know that on Unix-like platforms (and others), this function
* is implemented on top of select() and fd_set, which do not support
* file descriptors greater or equal to FD_SETSIZE. So we expect to hit
* this platform limitation.
*
* If mbedtls_net_poll() does not proprely check that ctx.fd is in range,
* it may still happen to return the expected failure code, but if this
* is problematic on the particular platform where the code is running,
* a memory sanitizer such as UBSan should catch it.
*/
ret = mbedtls_net_poll( &ctx, MBEDTLS_NET_POLL_READ, 0 );
TEST_EQUAL( ret, MBEDTLS_ERR_NET_POLL_FAILED );
/* mbedtls_net_recv_timeout() uses select() and fd_set in the same way. */
ret = mbedtls_net_recv_timeout( &ctx, buf, sizeof( buf ), 0 );
TEST_EQUAL( ret, MBEDTLS_ERR_NET_POLL_FAILED );
exit:
mbedtls_net_free( &ctx );
if( restore_rlim_nofile )
setrlimit( RLIMIT_NOFILE, &rlim_nofile );
}
void test_poll_beyond_fd_setsize_wrapper( void ** params )
{
(void)params;
test_poll_beyond_fd_setsize( );
}
#endif /* MBEDTLS_PLATFORM_IS_UNIXLIKE */
#endif /* MBEDTLS_NET_C */
/*----------------------------------------------------------------------------*/
/* Test dispatch code */
/**
* \brief Evaluates an expression/macro into its literal integer value.
* For optimizing space for embedded targets each expression/macro
* is identified by a unique identifier instead of string literals.
* Identifiers and evaluation code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param exp_id Expression identifier.
* \param out_value Pointer to int to hold the integer.
*
* \return 0 if exp_id is found. 1 otherwise.
*/
int get_expression( int32_t exp_id, int32_t * out_value )
{
int ret = KEY_VALUE_MAPPING_FOUND;
(void) exp_id;
(void) out_value;
switch( exp_id )
{
#if defined(MBEDTLS_NET_C)
#endif
default:
{
ret = KEY_VALUE_MAPPING_NOT_FOUND;
}
break;
}
return( ret );
}
/**
* \brief Checks if the dependency i.e. the compile flag is set.
* For optimizing space for embedded targets each dependency
* is identified by a unique identifier instead of string literals.
* Identifiers and check code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param dep_id Dependency identifier.
*
* \return DEPENDENCY_SUPPORTED if set else DEPENDENCY_NOT_SUPPORTED
*/
int dep_check( int dep_id )
{
int ret = DEPENDENCY_NOT_SUPPORTED;
(void) dep_id;
switch( dep_id )
{
#if defined(MBEDTLS_NET_C)
#endif
default:
break;
}
return( ret );
}
/**
* \brief Function pointer type for test function wrappers.
*
* A test function wrapper decodes the parameters and passes them to the
* underlying test function. Both the wrapper and the underlying function
* return void. Test wrappers assume that they are passed a suitable
* parameter array and do not perform any error detection.
*
* \param param_array The array of parameters. Each element is a `void *`
* which the wrapper casts to the correct type and
* dereferences. Each wrapper function hard-codes the
* number and types of the parameters.
*/
typedef void (*TestWrapper_t)( void **param_array );
/**
* \brief Table of test function wrappers. Used by dispatch_test().
* This table is populated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
*/
TestWrapper_t test_funcs[] =
{
/* Function Id: 0 */
#if defined(MBEDTLS_NET_C)
test_context_init_free_wrapper,
#else
NULL,
#endif
/* Function Id: 1 */
#if defined(MBEDTLS_NET_C) && defined(MBEDTLS_PLATFORM_IS_UNIXLIKE)
test_poll_beyond_fd_setsize_wrapper,
#else
NULL,
#endif
};
/**
* \brief Execute the test function.
*
* This is a wrapper function around the test function execution
* to allow the setjmp() call used to catch any calls to the
* parameter failure callback, to be used. Calls to setjmp()
* can invalidate the state of any local auto variables.
*
* \param fp Function pointer to the test function.
* \param params Parameters to pass to the #TestWrapper_t wrapper function.
*
*/
void execute_function_ptr(TestWrapper_t fp, void **params)
{
#if defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG)
mbedtls_test_enable_insecure_external_rng( );
#endif
#if defined(MBEDTLS_CHECK_PARAMS)
mbedtls_test_param_failed_location_record_t location_record;
if ( setjmp( mbedtls_test_param_failed_get_state_buf( ) ) == 0 )
{
fp( params );
}
else
{
/* Unexpected parameter validation error */
mbedtls_test_param_failed_get_location_record( &location_record );
mbedtls_test_fail( location_record.failure_condition,
location_record.line,
location_record.file );
}
mbedtls_test_param_failed_reset_state( );
#else
fp( params );
#endif
#if defined(MBEDTLS_TEST_MUTEX_USAGE)
mbedtls_test_mutex_usage_check( );
#endif /* MBEDTLS_TEST_MUTEX_USAGE */
}
/**
* \brief Dispatches test functions based on function index.
*
* \param func_idx Test function index.
* \param params The array of parameters to pass to the test function.
* It will be decoded by the #TestWrapper_t wrapper function.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int dispatch_test( size_t func_idx, void ** params )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof( test_funcs ) / sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp )
execute_function_ptr(fp, params);
else
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
/**
* \brief Checks if test function is supported in this build-time
* configuration.
*
* \param func_idx Test function index.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int check_test( size_t func_idx )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof(test_funcs)/sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp == NULL )
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
int main( int argc, const char *argv[] )
{
int ret;
mbedtls_test_platform_setup();
ret = execute_tests( argc, argv, "/zip/third_party/mbedtls/test/test_suite_net.datax" );
mbedtls_test_platform_teardown();
return( ret );
}
| 12,063 | 403 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_poly1305.datax | Poly1305 RFC 7539 Example And Test Vector
0:hex:"85d6be7857556d337f4452fe42d506a80103808afb0db2fd4abff6af4149f51b":hex:"a8061dc1305136c6c22b8baf0c0127a9":hex:"43727970746f6772617068696320466f72756d2052657365617263682047726f7570"
Poly1305 RFC 7539 Test Vector #1
0:hex:"0000000000000000000000000000000000000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
Poly1305 RFC 7539 Test Vector #2
0:hex:"0000000000000000000000000000000036e5f6b5c5e06070f0efca96227a863e":hex:"36e5f6b5c5e06070f0efca96227a863e":hex:"416e79207375626d697373696f6e20746f20746865204945544620696e74656e6465642062792074686520436f6e7472696275746f7220666f72207075626c69636174696f6e20617320616c6c206f722070617274206f6620616e204945544620496e7465726e65742d4472616674206f722052464320616e6420616e792073746174656d656e74206d6164652077697468696e2074686520636f6e74657874206f6620616e204945544620616374697669747920697320636f6e7369646572656420616e20224945544620436f6e747269627574696f6e222e20537563682073746174656d656e747320696e636c756465206f72616c2073746174656d656e747320696e20494554462073657373696f6e732c2061732077656c6c206173207772697474656e20616e6420656c656374726f6e696320636f6d6d756e69636174696f6e73206d61646520617420616e792074696d65206f7220706c6163652c207768696368206172652061646472657373656420746f"
Poly1305 RFC 7539 Test Vector #3
0:hex:"36e5f6b5c5e06070f0efca96227a863e00000000000000000000000000000000":hex:"f3477e7cd95417af89a6b8794c310cf0":hex:"416e79207375626d697373696f6e20746f20746865204945544620696e74656e6465642062792074686520436f6e7472696275746f7220666f72207075626c69636174696f6e20617320616c6c206f722070617274206f6620616e204945544620496e7465726e65742d4472616674206f722052464320616e6420616e792073746174656d656e74206d6164652077697468696e2074686520636f6e74657874206f6620616e204945544620616374697669747920697320636f6e7369646572656420616e20224945544620436f6e747269627574696f6e222e20537563682073746174656d656e747320696e636c756465206f72616c2073746174656d656e747320696e20494554462073657373696f6e732c2061732077656c6c206173207772697474656e20616e6420656c656374726f6e696320636f6d6d756e69636174696f6e73206d61646520617420616e792074696d65206f7220706c6163652c207768696368206172652061646472657373656420746f"
Poly1305 RFC 7539 Test Vector #4
0:hex:"1c9240a5eb55d38af333888604f6b5f0473917c1402b80099dca5cbc207075c0":hex:"4541669a7eaaee61e708dc7cbcc5eb62":hex:"2754776173206272696c6c69672c20616e642074686520736c6974687920746f7665730a446964206779726520616e642067696d626c6520696e2074686520776162653a0a416c6c206d696d737920776572652074686520626f726f676f7665732c0a416e6420746865206d6f6d65207261746873206f757467726162652e"
Poly1305 RFC 7539 Test Vector #5
0:hex:"0200000000000000000000000000000000000000000000000000000000000000":hex:"03000000000000000000000000000000":hex:"ffffffffffffffffffffffffffffffff"
Poly1305 RFC 7539 Test Vector #6
0:hex:"02000000000000000000000000000000ffffffffffffffffffffffffffffffff":hex:"03000000000000000000000000000000":hex:"02000000000000000000000000000000"
Poly1305 RFC 7539 Test Vector #7
0:hex:"0100000000000000000000000000000000000000000000000000000000000000":hex:"05000000000000000000000000000000":hex:"fffffffffffffffffffffffffffffffff0ffffffffffffffffffffffffffffff11000000000000000000000000000000"
Poly1305 RFC 7539 Test Vector #8
0:hex:"0100000000000000000000000000000000000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"fffffffffffffffffffffffffffffffffbfefefefefefefefefefefefefefefe01010101010101010101010101010101"
Poly1305 RFC 7539 Test Vector #9
0:hex:"0200000000000000000000000000000000000000000000000000000000000000":hex:"faffffffffffffffffffffffffffffff":hex:"fdffffffffffffffffffffffffffffff"
Poly1305 RFC 7539 Test Vector #10
0:hex:"0100000000000000040000000000000000000000000000000000000000000000":hex:"14000000000000005500000000000000":hex:"e33594d7505e43b900000000000000003394d7505e4379cd01000000000000000000000000000000000000000000000001000000000000000000000000000000"
Poly1305 RFC 7539 Test Vector #11
0:hex:"0100000000000000040000000000000000000000000000000000000000000000":hex:"13000000000000000000000000000000":hex:"e33594d7505e43b900000000000000003394d7505e4379cd010000000000000000000000000000000000000000000000"
Poly1305 Parameter validation
1
Poly1305 Selftest
depends_on:0
2
| 4,376 | 44 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_ecp.datax | ECP valid params
0
ECP invalid params
1
ECP curve info #1
depends_on:0
2:exp:0:int:28:int:512:char*:"brainpoolP512r1"
ECP curve info #2
depends_on:1
2:exp:1:int:27:int:384:char*:"brainpoolP384r1"
ECP curve info #3
depends_on:2
2:exp:2:int:26:int:256:char*:"brainpoolP256r1"
ECP curve info #4
depends_on:3
2:exp:3:int:25:int:521:char*:"secp521r1"
ECP curve info #5
depends_on:4
2:exp:4:int:24:int:384:char*:"secp384r1"
ECP curve info #6
depends_on:5
2:exp:5:int:23:int:256:char*:"secp256r1"
ECP curve info #7
depends_on:6
2:exp:6:int:21:int:224:char*:"secp224r1"
ECP curve info #8
depends_on:7
2:exp:7:int:19:int:192:char*:"secp192r1"
ECP check pubkey Montgomery #1 (too big)
depends_on:8
3:exp:8:char*:"010000000000000000000000000000000000000000000000000000000000000000":char*:"0":char*:"1":exp:9
ECP check pubkey Montgomery #2 (biggest)
depends_on:8
3:exp:8:char*:"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF":char*:"0":char*:"1":int:0
ECP check pubkey Koblitz #1 (point not on curve)
depends_on:9
3:exp:10:char*:"E2000000000000BB3A13D43B323337383935321F0603551D":char*:"100101FF040830060101FF02010A30220603551D0E041B04636FC0C0":char*:"1":exp:9
ECP check pubkey Koblitz #2 (coordinate not affine)
depends_on:9
3:exp:10:char*:"E2000000000000BB3A13D43B323337383935321F0603551D":char*:"100101FF040830060101FF02010A30220603551D0E041B04636FC0C0":char*:"101":exp:9
ECP write binary #1 (zero, uncompressed, buffer just fits)
depends_on:7
11:exp:7:char*:"01":char*:"01":char*:"00":exp:11:hex:"00":int:1:int:0
ECP write binary #2 (zero, buffer too small)
depends_on:7
11:exp:7:char*:"01":char*:"01":char*:"00":exp:11:hex:"00":int:0:exp:12
ECP write binary #3 (non-zero, uncompressed, buffer just fits)
depends_on:7
11:exp:7:char*:"48d8082a3a1e3112bc03a8ef2f6d40d0a77a6f8e00cc9933":char*:"6ceed4d7cba482e288669ee1b6415626d6f34d28501e060c":char*:"01":exp:11:hex:"0448d8082a3a1e3112bc03a8ef2f6d40d0a77a6f8e00cc99336ceed4d7cba482e288669ee1b6415626d6f34d28501e060c":int:49:int:0
ECP write binary #4 (non-zero, uncompressed, buffer too small)
depends_on:7
11:exp:7:char*:"48d8082a3a1e3112bc03a8ef2f6d40d0a77a6f8e00cc9933":char*:"6ceed4d7cba482e288669ee1b6415626d6f34d28501e060c":char*:"01":exp:11:hex:"0448d8082a3a1e3112bc03a8ef2f6d40d0a77a6f8e00cc99336ceed4d7cba482e288669ee1b6415626d6f34d28501e060c":int:48:exp:12
ECP write binary #5 (zero, compressed, buffer just fits)
depends_on:7
11:exp:7:char*:"01":char*:"01":char*:"00":exp:13:hex:"00":int:1:int:0
ECP write binary #6 (zero, buffer too small)
depends_on:7
11:exp:7:char*:"01":char*:"01":char*:"00":exp:13:hex:"00":int:0:exp:12
ECP write binary #7 (even, compressed, buffer just fits)
depends_on:7
11:exp:7:char*:"48d8082a3a1e3112bc03a8ef2f6d40d0a77a6f8e00cc9933":char*:"6ceed4d7cba482e288669ee1b6415626d6f34d28501e060c":char*:"01":exp:13:hex:"0248d8082a3a1e3112bc03a8ef2f6d40d0a77a6f8e00cc9933":int:25:int:0
ECP write binary #8 (even, compressed, buffer too small)
depends_on:7
11:exp:7:char*:"48d8082a3a1e3112bc03a8ef2f6d40d0a77a6f8e00cc9933":char*:"6ceed4d7cba482e288669ee1b6415626d6f34d28501e060c":char*:"01":exp:13:hex:"0248d8082a3a1e3112bc03a8ef2f6d40d0a77a6f8e00cc9933":int:24:exp:12
ECP write binary #9 (odd, compressed, buffer just fits)
depends_on:7
11:exp:7:char*:"48d8082a3a1e3112bc03a8ef2f6d40d0a77a6f8e00cc9933":char*:"93112b28345b7d1d7799611e49bea9d8290cb2d7afe1f9f3":char*:"01":exp:13:hex:"0348d8082a3a1e3112bc03a8ef2f6d40d0a77a6f8e00cc9933":int:25:int:0
ECP write binary #10 (Montgomery, buffer just fits)
depends_on:8
11:exp:8:char*:"11223344556677889900aabbccddeeff11223344556677889900aabbccddeeff":char*:"0":char*:"1":exp:13:hex:"ffeeddccbbaa00998877665544332211ffeeddccbbaa00998877665544332211":int:32:int:0
ECP write binary #11 (Montgomery, buffer too small)
depends_on:8
11:exp:8:char*:"11223344556677889900aabbccddeeff11223344556677889900aabbccddeeff":char*:"0":char*:"1":exp:13:hex:"ffeeddccbbaa00998877665544332211ffeeddccbbaa00998877665544332211":int:31:exp:12
ECP read binary #1 (zero, invalid ilen)
depends_on:7
12:exp:7:hex:"0000":char*:"01":char*:"01":char*:"00":exp:14
ECP read binary #2 (zero, invalid first byte)
depends_on:7
12:exp:7:hex:"01":char*:"01":char*:"01":char*:"00":exp:15
ECP read binary #3 (zero, OK)
depends_on:7
12:exp:7:hex:"00":char*:"01":char*:"01":char*:"00":int:0
ECP read binary #4 (non-zero, invalid ilen)
depends_on:7
12:exp:7:hex:"04001122":char*:"01":char*:"01":char*:"00":exp:14
ECP read binary #5 (non-zero, invalid first byte)
depends_on:7
12:exp:7:hex:"0548d8082a3a1e3112bc03a8ef2f6d40d0a77a6f8e00cc99336ceed4d7cba482e288669ee1b6415626d6f34d28501e060c":char*:"48d8082a3a1e3112bc03a8ef2f6d40d0a77a6f8e00cc9933":char*:"6ceed4d7cba482e288669ee1b6415626d6f34d28501e060c":char*:"01":exp:15
ECP read binary #6 (non-zero, OK)
depends_on:7
12:exp:7:hex:"0448d8082a3a1e3112bc03a8ef2f6d40d0a77a6f8e00cc99336ceed4d7cba482e288669ee1b6415626d6f34d28501e060c":char*:"48d8082a3a1e3112bc03a8ef2f6d40d0a77a6f8e00cc9933":char*:"6ceed4d7cba482e288669ee1b6415626d6f34d28501e060c":char*:"01":int:0
ECP read binary #7 (Curve25519, OK)
depends_on:8
12:exp:8:hex:"8520f0098930a754748b7ddcb43ef75a0dbf3a0d26381af4eba4a98eaa9b4e6a":char*:"6a4e9baa8ea9a4ebf41a38260d3abf0d5af73eb4dc7d8b7454a7308909f02085":char*:"0":char*:"1":int:0
ECP read binary #8 (Curve25519, masked first bit)
depends_on:8
12:exp:8:hex:"8520f0098930a754748b7ddcb43ef75a0dbf3a0d26381af4eba4a98eaa9b4efa":char*:"7a4e9baa8ea9a4ebf41a38260d3abf0d5af73eb4dc7d8b7454a7308909f02085":char*:"0":char*:"1":int:0
ECP read binary #9 (Curve25519, too short)
depends_on:8
12:exp:8:hex:"20f0098930a754748b7ddcb43ef75a0dbf3a0d26381af4eba4a98eaa9b4e6a":char*:"6a4e9baa8ea9a4ebf41a38260d3abf0d5af73eb4dc7d8b7454a7308909f020":char*:"0":char*:"1":exp:14
ECP read binary #10 (Curve25519, non-canonical)
depends_on:8
12:exp:8:hex:"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f":char*:"7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff":char*:"0":char*:"1":int:0
ECP read binary #11 (Curve25519, masked non-canonical)
depends_on:8
12:exp:8:hex:"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff":char*:"7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff":char*:"0":char*:"1":int:0
ECP read binary #12 (Curve25519, too long)
depends_on:8
12:exp:8:hex:"8520f0098930a754748b7ddcb43ef75a0dbf3a0d26381af4eba4a98eaa9b4e6a00":char*:"6a4e9baa8ea9a4ebf41a38260d3abf0d5af73eb4dc7d8b7454a7308909f02085":char*:"0":char*:"1":exp:14
ECP tls read point #1 (zero, invalid length byte)
depends_on:7
13:exp:7:hex:"0200":char*:"01":char*:"01":char*:"00":exp:14
ECP tls read point #2 (zero, OK)
depends_on:7
13:exp:7:hex:"0100":char*:"01":char*:"01":char*:"00":int:0
ECP tls read point #3 (non-zero, invalid length byte)
depends_on:7
13:exp:7:hex:"300448d8082a3a1e3112bc03a8ef2f6d40d0a77a6f8e00cc99336ceed4d7cba482e288669ee1b6415626d6f34d28501e060c":char*:"48d8082a3a1e3112bc03a8ef2f6d40d0a77a6f8e00cc9933":char*:"6ceed4d7cba482e288669ee1b6415626d6f34d28501e060c":char*:"01":exp:14
ECP tls read point #4 (non-zero, OK)
depends_on:7
13:exp:7:hex:"310448d8082a3a1e3112bc03a8ef2f6d40d0a77a6f8e00cc99336ceed4d7cba482e288669ee1b6415626d6f34d28501e060c":char*:"48d8082a3a1e3112bc03a8ef2f6d40d0a77a6f8e00cc9933":char*:"6ceed4d7cba482e288669ee1b6415626d6f34d28501e060c":char*:"01":int:0
ECP tls write-read point #1
depends_on:7
14:exp:7
ECP tls write-read point #2
depends_on:3
14:exp:3
ECP tls read group #1 (record too short)
15:hex:"0313":exp:14:int:0:int:0
ECP tls read group #2 (bad curve_type)
15:hex:"010013":exp:14:int:0:int:0
ECP tls read group #3 (unknown curve)
15:hex:"030010":exp:15:int:0:int:0
ECP tls read group #4 (OK, buffer just fits)
depends_on:5
15:hex:"030017":int:0:int:256:int:3
ECP tls read group #5 (OK, buffer continues)
depends_on:4
15:hex:"0300180000":int:0:int:384:int:3
ECP tls write-read group #1
depends_on:7
16:exp:7
ECP tls write-read group #2
depends_on:3
16:exp:3
ECP check privkey #1 (short weierstrass, too small)
depends_on:7
17:exp:7:char*:"00":exp:9
ECP check privkey #2 (short weierstrass, smallest)
depends_on:7
17:exp:7:char*:"01":int:0
ECP check privkey #3 (short weierstrass, biggest)
depends_on:7
17:exp:7:char*:"FFFFFFFFFFFFFFFFFFFFFFFF99DEF836146BC9B1B4D22830":int:0
ECP check privkey #4 (short weierstrass, too big)
depends_on:7
17:exp:7:char*:"FFFFFFFFFFFFFFFFFFFFFFFF99DEF836146BC9B1B4D22831":exp:9
ECP check privkey #5 (montgomery, too big)
depends_on:8
17:exp:8:char*:"C000000000000000000000000000000000000000000000000000000000000000":exp:9
ECP check privkey #6 (montgomery, not big enough)
depends_on:8
17:exp:8:char*:"3FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0":exp:9
ECP check privkey #7 (montgomery, msb OK)
depends_on:8
17:exp:8:char*:"4000000000000000000000000000000000000000000000000000000000000000":int:0
ECP check privkey #8 (montgomery, bit 0 set)
depends_on:8
17:exp:8:char*:"4000000000000000000000000000000000000000000000000000000000000001":exp:9
ECP check privkey #9 (montgomery, bit 1 set)
depends_on:8
17:exp:8:char*:"4000000000000000000000000000000000000000000000000000000000000002":exp:9
ECP check privkey #10 (montgomery, bit 2 set)
depends_on:8
17:exp:8:char*:"4000000000000000000000000000000000000000000000000000000000000004":exp:9
ECP check privkey #11 (montgomery, OK)
depends_on:8
17:exp:8:char*:"7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF8":int:0
ECP check public-private #1 (OK)
depends_on:5
18:exp:5:char*:"37cc56d976091e5a723ec7592dff206eee7cf9069174d0ad14b5f76822596292":char*:"4ee500d82311ffea2fd2345d5d16bd8a88c26b770d55cd8a2a0efa01c8b4edff":exp:5:char*:"00f12a1320760270a83cbffd53f6031ef76a5d86c8a204f2c30ca9ebf51f0f0ea7":char*:"37cc56d976091e5a723ec7592dff206eee7cf9069174d0ad14b5f76822596292":char*:"4ee500d82311ffea2fd2345d5d16bd8a88c26b770d55cd8a2a0efa01c8b4edff":int:0
ECP check public-private #2 (group none)
18:exp:16:char*:"37cc56d976091e5a723ec7592dff206eee7cf9069174d0ad14b5f76822596292":char*:"4ee500d82311ffea2fd2345d5d16bd8a88c26b770d55cd8a2a0efa01c8b4edff":exp:16:char*:"00f12a1320760270a83cbffd53f6031ef76a5d86c8a204f2c30ca9ebf51f0f0ea7":char*:"37cc56d976091e5a723ec7592dff206eee7cf9069174d0ad14b5f76822596292":char*:"4ee500d82311ffea2fd2345d5d16bd8a88c26b770d55cd8a2a0efa01c8b4edff":exp:14
ECP check public-private #3 (group mismatch)
depends_on:5:4
18:exp:4:char*:"37cc56d976091e5a723ec7592dff206eee7cf9069174d0ad14b5f76822596292":char*:"4ee500d82311ffea2fd2345d5d16bd8a88c26b770d55cd8a2a0efa01c8b4edff":exp:5:char*:"00f12a1320760270a83cbffd53f6031ef76a5d86c8a204f2c30ca9ebf51f0f0ea7":char*:"37cc56d976091e5a723ec7592dff206eee7cf9069174d0ad14b5f76822596292":char*:"4ee500d82311ffea2fd2345d5d16bd8a88c26b770d55cd8a2a0efa01c8b4edff":exp:14
ECP check public-private #4 (Qx mismatch)
depends_on:5
18:exp:5:char*:"37cc56d976091e5a723ec7592dff206eee7cf9069174d0ad14b5f76822596293":char*:"4ee500d82311ffea2fd2345d5d16bd8a88c26b770d55cd8a2a0efa01c8b4edff":exp:5:char*:"00f12a1320760270a83cbffd53f6031ef76a5d86c8a204f2c30ca9ebf51f0f0ea7":char*:"37cc56d976091e5a723ec7592dff206eee7cf9069174d0ad14b5f76822596292":char*:"4ee500d82311ffea2fd2345d5d16bd8a88c26b770d55cd8a2a0efa01c8b4edff":exp:14
ECP check public-private #5 (Qy mismatch)
depends_on:5
18:exp:5:char*:"37cc56d976091e5a723ec7592dff206eee7cf9069174d0ad14b5f76822596292":char*:"4ee500d82311ffea2fd2345d5d16bd8a88c26b770d55cd8a2a0efa01c8b4edfe":exp:5:char*:"00f12a1320760270a83cbffd53f6031ef76a5d86c8a204f2c30ca9ebf51f0f0ea7":char*:"37cc56d976091e5a723ec7592dff206eee7cf9069174d0ad14b5f76822596292":char*:"4ee500d82311ffea2fd2345d5d16bd8a88c26b770d55cd8a2a0efa01c8b4edff":exp:14
ECP check public-private #6 (wrong Qx)
depends_on:5
18:exp:5:char*:"37cc56d976091e5a723ec7592dff206eee7cf9069174d0ad14b5f76822596293":char*:"4ee500d82311ffea2fd2345d5d16bd8a88c26b770d55cd8a2a0efa01c8b4edff":exp:5:char*:"00f12a1320760270a83cbffd53f6031ef76a5d86c8a204f2c30ca9ebf51f0f0ea7":char*:"37cc56d976091e5a723ec7592dff206eee7cf9069174d0ad14b5f76822596293":char*:"4ee500d82311ffea2fd2345d5d16bd8a88c26b770d55cd8a2a0efa01c8b4edff":exp:14
ECP check public-private #7 (wrong Qy)
depends_on:5
18:exp:5:char*:"37cc56d976091e5a723ec7592dff206eee7cf9069174d0ad14b5f76822596292":char*:"4ee500d82311ffea2fd2345d5d16bd8a88c26b770d55cd8a2a0efa01c8b4edfe":exp:5:char*:"00f12a1320760270a83cbffd53f6031ef76a5d86c8a204f2c30ca9ebf51f0f0ea7":char*:"37cc56d976091e5a723ec7592dff206eee7cf9069174d0ad14b5f76822596292":char*:"4ee500d82311ffea2fd2345d5d16bd8a88c26b770d55cd8a2a0efa01c8b4edfe":exp:14
ECP gen keypair [#1]
depends_on:7
19:exp:7
ECP gen keypair [#2]
depends_on:8
19:exp:8
ECP gen keypair wrapper
depends_on:7
20:exp:7
ECP read key #1 (short weierstrass, too small)
depends_on:7
21:exp:7:hex:"00":exp:9:int:0
ECP read key #2 (short weierstrass, smallest)
depends_on:7
21:exp:7:hex:"01":int:0:int:1
ECP read key #3 (short weierstrass, biggest)
depends_on:7
21:exp:7:hex:"FFFFFFFFFFFFFFFFFFFFFFFF99DEF836146BC9B1B4D22830":int:0:int:1
ECP read key #4 (short weierstrass, too big)
depends_on:7
21:exp:7:hex:"FFFFFFFFFFFFFFFFFFFFFFFF99DEF836146BC9B1B4D22831":exp:9:int:0
ECP read key #5 (Curve25519, most significant bit set)
depends_on:8
21:exp:8:hex:"00000000000000000000000000000000000000000000000000000000000000C0":int:0:int:0
ECP read key #6 (Curve25519, second most significant bit unset)
depends_on:8
21:exp:8:hex:"F0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF3F":int:0:int:0
ECP read key #7 (Curve25519, msb OK)
depends_on:8
21:exp:8:hex:"0000000000000000000000000000000000000000000000000000000000000040":int:0:int:1
ECP read key #8 (Curve25519, bit 0 set)
depends_on:8
21:exp:8:hex:"0100000000000000000000000000000000000000000000000000000000000040":int:0:int:0
ECP read key #9 (Curve25519, bit 1 set)
depends_on:8
21:exp:8:hex:"0200000000000000000000000000000000000000000000000000000000000040":int:0:int:0
ECP read key #10 (Curve25519, bit 2 set)
depends_on:8
21:exp:8:hex:"0400000000000000000000000000000000000000000000000000000000000040":int:0:int:0
ECP read key #11 (Curve25519, OK)
depends_on:8
21:exp:8:hex:"F8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7F":int:0:int:1
ECP read key #12 (Curve25519, too long)
depends_on:8
21:exp:8:hex:"00000000000000000000000000000000000000000000000000000000000000000C":exp:9:int:0
ECP read key #13 (Curve25519, not long enough)
depends_on:8
21:exp:8:hex:"F0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF3F":exp:9:int:0
ECP read key #14 (Curve448, not supported)
21:exp:17:hex:"FCFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF":exp:15:int:0
ECP read key #15 (Curve25519, not supported)
depends_on:10
21:exp:8:hex:"F8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7F":exp:15:int:0
ECP read key #15 (invalid curve)
21:exp:18:hex:"F8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7F":exp:15:int:0
ECP read key #16 (Curve25519 RFC, OK)
depends_on:8
21:exp:8:hex:"70076d0a7318a57d3c16c17251b26645df4c2f87ebc0992ab177fba51db92c6a":int:0:int:1
ECP mod p192 small (more than 192 bits, less limbs than 2 * 192 bits)
depends_on:7
10:exp:7:char*:"0100000000000103010000000000010201000000000001010100000000000100"
ECP mod p192 readable
depends_on:7
10:exp:7:char*:"010000000000010501000000000001040100000000000103010000000000010201000000000001010100000000000100"
ECP mod p192 readable with carry
depends_on:7
10:exp:7:char*:"FF00000000010500FF00000000010400FF00000000010300FF00000000010200FF00000000010100FF00000000010000"
ECP mod p192 random
depends_on:7
10:exp:7:char*:"36CF96B45D706A0954D89E52CE5F38517A2270E0175849B6F3740151D238CCABEF921437E475881D83BB69E4AA258EBD"
ECP mod p192 (from a past failure case)
depends_on:7
10:exp:7:char*:"1AC2D6F96A2A425E9DD1776DD8368D4BBC86BF4964E79FEA713583BF948BBEFF0939F96FB19EC48C585BDA6A2D35C750"
ECP mod p224 readable without carry
depends_on:6
10:exp:6:char*:"0000000D0000000C0000000B0000000A0000000900000008000000070000FF060000FF050000FF040000FF03000FF0020000FF010000FF00"
ECP mod p224 readable with negative carry
depends_on:6
10:exp:6:char*:"0000000D0000000C0000000B0000000A00000009000000080000000700000006000000050000000400000003000000020000000100000000"
ECP mod p224 readable with positive carry
depends_on:6
10:exp:6:char*:"0000000D0000000C0000000BFFFFFF0AFFFFFF09FFFFFF08FFFFFF070000FF060000FF050000FF040000FF03000FF0020000FF010000FF00"
ECP mod p224 readable with final negative carry
depends_on:6
10:exp:6:char*:"FF00000D0000000C0000000B0000000A00000009000000080000000700000006000000050000000400000003000000020000000100000000"
ECP mod p521 very small
depends_on:3
10:exp:3:char*:"01"
ECP mod p521 small (522 bits)
depends_on:3
10:exp:3:char*:"030000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
ECP mod p521 readable
depends_on:3
10:exp:3:char*:"03FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
ECP mod p521 readable with carry
depends_on:3
10:exp:3:char*:"03FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001"
ECP test vectors secp192r1 rfc 5114
depends_on:7
6:exp:7:char*:"323FA3169D8E9C6593F59476BC142000AB5BE0E249C43426":char*:"CD46489ECFD6C105E7B3D32566E2B122E249ABAADD870612":char*:"68887B4877DF51DD4DC3D6FD11F0A26F8FD3844317916E9A":char*:"631F95BB4A67632C9C476EEE9AB695AB240A0499307FCF62":char*:"519A121680E0045466BA21DF2EEE47F5973B500577EF13D5":char*:"FF613AB4D64CEE3A20875BDB10F953F6B30CA072C60AA57F":char*:"AD420182633F8526BFE954ACDA376F05E5FF4F837F54FEBE":char*:"4371545ED772A59741D0EDA32C671112B7FDDD51461FCF32"
ECP test vectors secp224r1 rfc 5114
depends_on:6
6:exp:6:char*:"B558EB6C288DA707BBB4F8FBAE2AB9E9CB62E3BC5C7573E22E26D37F":char*:"49DFEF309F81488C304CFF5AB3EE5A2154367DC7833150E0A51F3EEB":char*:"4F2B5EE45762C4F654C1A0C67F54CF88B016B51BCE3D7C228D57ADB4":char*:"AC3B1ADD3D9770E6F6A708EE9F3B8E0AB3B480E9F27F85C88B5E6D18":char*:"6B3AC96A8D0CDE6A5599BE8032EDF10C162D0A8AD219506DCD42A207":char*:"D491BE99C213A7D1CA3706DEBFE305F361AFCBB33E2609C8B1618AD5":char*:"52272F50F46F4EDC9151569092F46DF2D96ECC3B6DC1714A4EA949FA":char*:"5F30C6AA36DDC403C0ACB712BB88F1763C3046F6D919BD9C524322BF"
ECP test vectors secp256r1 rfc 5114
depends_on:5
6:exp:5:char*:"814264145F2F56F2E96A8E337A1284993FAF432A5ABCE59E867B7291D507A3AF":char*:"2AF502F3BE8952F2C9B5A8D4160D09E97165BE50BC42AE4A5E8D3B4BA83AEB15":char*:"EB0FAF4CA986C4D38681A0F9872D79D56795BD4BFF6E6DE3C0F5015ECE5EFD85":char*:"2CE1788EC197E096DB95A200CC0AB26A19CE6BCCAD562B8EEE1B593761CF7F41":char*:"B120DE4AA36492795346E8DE6C2C8646AE06AAEA279FA775B3AB0715F6CE51B0":char*:"9F1B7EECE20D7B5ED8EC685FA3F071D83727027092A8411385C34DDE5708B2B6":char*:"DD0F5396219D1EA393310412D19A08F1F5811E9DC8EC8EEA7F80D21C820C2788":char*:"0357DCCD4C804D0D8D33AA42B848834AA5605F9AB0D37239A115BBB647936F50"
ECP test vectors secp384r1 rfc 5114
depends_on:4
6:exp:4:char*:"D27335EA71664AF244DD14E9FD1260715DFD8A7965571C48D709EE7A7962A156D706A90CBCB5DF2986F05FEADB9376F1":char*:"793148F1787634D5DA4C6D9074417D05E057AB62F82054D10EE6B0403D6279547E6A8EA9D1FD77427D016FE27A8B8C66":char*:"C6C41294331D23E6F480F4FB4CD40504C947392E94F4C3F06B8F398BB29E42368F7A685923DE3B67BACED214A1A1D128":char*:"52D1791FDB4B70F89C0F00D456C2F7023B6125262C36A7DF1F80231121CCE3D39BE52E00C194A4132C4A6C768BCD94D2":char*:"5CD42AB9C41B5347F74B8D4EFB708B3D5B36DB65915359B44ABC17647B6B9999789D72A84865AE2F223F12B5A1ABC120":char*:"E171458FEAA939AAA3A8BFAC46B404BD8F6D5B348C0FA4D80CECA16356CA933240BDE8723415A8ECE035B0EDF36755DE":char*:"5EA1FC4AF7256D2055981B110575E0A8CAE53160137D904C59D926EB1B8456E427AA8A4540884C37DE159A58028ABC0E":char*:"0CC59E4B046414A81C8A3BDFDCA92526C48769DD8D3127CAA99B3632D1913942DE362EAFAA962379374D9F3F066841CA"
ECP test vectors secp521r1 rfc 5114
depends_on:3
6:exp:3:char*:"0113F82DA825735E3D97276683B2B74277BAD27335EA71664AF2430CC4F33459B9669EE78B3FFB9B8683015D344DCBFEF6FB9AF4C6C470BE254516CD3C1A1FB47362":char*:"01EBB34DD75721ABF8ADC9DBED17889CBB9765D90A7C60F2CEF007BB0F2B26E14881FD4442E689D61CB2DD046EE30E3FFD20F9A45BBDF6413D583A2DBF59924FD35C":char*:"00F6B632D194C0388E22D8437E558C552AE195ADFD153F92D74908351B2F8C4EDA94EDB0916D1B53C020B5EECAED1A5FC38A233E4830587BB2EE3489B3B42A5A86A4":char*:"00CEE3480D8645A17D249F2776D28BAE616952D1791FDB4B70F7C3378732AA1B22928448BCD1DC2496D435B01048066EBE4F72903C361B1A9DC1193DC2C9D0891B96":char*:"010EBFAFC6E85E08D24BFFFCC1A4511DB0E634BEEB1B6DEC8C5939AE44766201AF6200430BA97C8AC6A0E9F08B33CE7E9FEEB5BA4EE5E0D81510C24295B8A08D0235":char*:"00A4A6EC300DF9E257B0372B5E7ABFEF093436719A77887EBB0B18CF8099B9F4212B6E30A1419C18E029D36863CC9D448F4DBA4D2A0E60711BE572915FBD4FEF2695":char*:"00CDEA89621CFA46B132F9E4CFE2261CDE2D4368EB5656634C7CC98C7A00CDE54ED1866A0DD3E6126C9D2F845DAFF82CEB1DA08F5D87521BB0EBECA77911169C20CC":char*:"00F9A71641029B7FC1A808AD07CD4861E868614B865AFBECAB1F2BD4D8B55EBCB5E3A53143CEB2C511B1AE0AF5AC827F60F2FD872565AC5CA0A164038FE980A7E4BD"
ECP test vectors brainpoolP256r1 rfc 7027
depends_on:2
6:exp:2:char*:"81DB1EE100150FF2EA338D708271BE38300CB54241D79950F77B063039804F1D":char*:"44106E913F92BC02A1705D9953A8414DB95E1AAA49E81D9E85F929A8E3100BE5":char*:"8AB4846F11CACCB73CE49CBDD120F5A900A69FD32C272223F789EF10EB089BDC":char*:"55E40BC41E37E3E2AD25C3C6654511FFA8474A91A0032087593852D3E7D76BD3":char*:"8D2D688C6CF93E1160AD04CC4429117DC2C41825E1E9FCA0ADDD34E6F1B39F7B":char*:"990C57520812BE512641E47034832106BC7D3E8DD0E4C7F1136D7006547CEC6A":char*:"89AFC39D41D3B327814B80940B042590F96556EC91E6AE7939BCE31F3A18BF2B":char*:"49C27868F4ECA2179BFD7D59B1E3BF34C1DBDE61AE12931648F43E59632504DE"
ECP test vectors brainpoolP384r1 rfc 7027
depends_on:1
6:exp:1:char*:"1E20F5E048A5886F1F157C74E91BDE2B98C8B52D58E5003D57053FC4B0BD65D6F15EB5D1EE1610DF870795143627D042":char*:"68B665DD91C195800650CDD363C625F4E742E8134667B767B1B476793588F885AB698C852D4A6E77A252D6380FCAF068":char*:"55BC91A39C9EC01DEE36017B7D673A931236D2F1F5C83942D049E3FA20607493E0D038FF2FD30C2AB67D15C85F7FAA59":char*:"032640BC6003C59260F7250C3DB58CE647F98E1260ACCE4ACDA3DD869F74E01F8BA5E0324309DB6A9831497ABAC96670":char*:"4D44326F269A597A5B58BBA565DA5556ED7FD9A8A9EB76C25F46DB69D19DC8CE6AD18E404B15738B2086DF37E71D1EB4":char*:"62D692136DE56CBE93BF5FA3188EF58BC8A3A0EC6C1E151A21038A42E9185329B5B275903D192F8D4E1F32FE9CC78C48":char*:"0BD9D3A7EA0B3D519D09D8E48D0785FB744A6B355E6304BC51C229FBBCE239BBADF6403715C35D4FB2A5444F575D4F42":char*:"0DF213417EBE4D8E40A5F76F66C56470C489A3478D146DECF6DF0D94BAE9E598157290F8756066975F1DB34B2324B7BD"
ECP test vectors brainpoolP512r1 rfc 7027
depends_on:0
6:exp:0:char*:"16302FF0DBBB5A8D733DAB7141C1B45ACBC8715939677F6A56850A38BD87BD59B09E80279609FF333EB9D4C061231FB26F92EEB04982A5F1D1764CAD57665422":char*:"0A420517E406AAC0ACDCE90FCD71487718D3B953EFD7FBEC5F7F27E28C6149999397E91E029E06457DB2D3E640668B392C2A7E737A7F0BF04436D11640FD09FD":char*:"72E6882E8DB28AAD36237CD25D580DB23783961C8DC52DFA2EC138AD472A0FCEF3887CF62B623B2A87DE5C588301EA3E5FC269B373B60724F5E82A6AD147FDE7":char*:"230E18E1BCC88A362FA54E4EA3902009292F7F8033624FD471B5D8ACE49D12CFABBC19963DAB8E2F1EBA00BFFB29E4D72D13F2224562F405CB80503666B25429":char*:"9D45F66DE5D67E2E6DB6E93A59CE0BB48106097FF78A081DE781CDB31FCE8CCBAAEA8DD4320C4119F1E9CD437A2EAB3731FA9668AB268D871DEDA55A5473199F":char*:"2FDC313095BCDD5FB3A91636F07A959C8E86B5636A1E930E8396049CB481961D365CC11453A06C719835475B12CB52FC3C383BCE35E27EF194512B71876285FA":char*:"A7927098655F1F9976FA50A9D566865DC530331846381C87256BAF3226244B76D36403C024D7BBF0AA0803EAFF405D3D24F11A9B5C0BEF679FE1454B21C4CD1F":char*:"7DB71C3DEF63212841C463E881BDCF055523BD368240E6C3143BD8DEF8B3B3223B95E0F53082FF5E412F4222537A43DF1C6D25729DDB51620A832BE6A26680A2"
ECP test vectors Curve25519
depends_on:8
7:exp:8:char*:"5AC99F33632E5A768DE7E81BF854C27C46E3FBF2ABBACD29EC4AFF517369C660":char*:"057E23EA9F1CBE8A27168F6E696A791DE61DD3AF7ACD4EEACC6E7BA514FDA863":char*:"47DC3D214174820E1154B49BC6CDB2ABD45EE95817055D255AA35831B70D3260":char*:"6EB89DA91989AE37C7EAC7618D9E5C4951DBA1D73C285AE1CD26A855020EEF04":char*:"61450CD98E36016B58776A897A9F0AEF738B99F09468B8D6B8511184D53494AB"
ECP point multiplication Curve25519 (normalized) #1
depends_on:8
8:exp:8:hex:"5AC99F33632E5A768DE7E81BF854C27C46E3FBF2ABBACD29EC4AFF517369C660":hex:"09":hex:"00":hex:"01":hex:"057E23EA9F1CBE8A27168F6E696A791DE61DD3AF7ACD4EEACC6E7BA514FDA863":hex:"00":hex:"01":int:0
ECP point multiplication Curve25519 (not normalized) #2
depends_on:8
8:exp:8:hex:"5AC99F33632E5A768DE7E81BF854C27C46E3FBF2ABBACD29EC4AFF517369C660":hex:"1B":hex:"00":hex:"03":hex:"057E23EA9F1CBE8A27168F6E696A791DE61DD3AF7ACD4EEACC6E7BA514FDA863":hex:"00":hex:"01":exp:9
ECP point multiplication Curve25519 (element of order 2: origin) #3
depends_on:8
8:exp:8:hex:"5AC99F33632E5A768DE7E81BF854C27C46E3FBF2ABBACD29EC4AFF517369C660":hex:"00":hex:"00":hex:"01":hex:"00":hex:"01":hex:"00":exp:19
ECP point multiplication Curve25519 (element of order 4: 1) #4
depends_on:8
8:exp:8:hex:"5AC99F33632E5A768DE7E81BF854C27C46E3FBF2ABBACD29EC4AFF517369C660":hex:"01":hex:"00":hex:"01":hex:"00":hex:"01":hex:"00":exp:19
ECP point multiplication Curve25519 (element of order 8) #5
depends_on:8
8:exp:8:hex:"5AC99F33632E5A768DE7E81BF854C27C46E3FBF2ABBACD29EC4AFF517369C660":hex:"B8495F16056286FDB1329CEB8D09DA6AC49FF1FAE35616AEB8413B7C7AEBE0":hex:"00":hex:"01":hex:"00":hex:"01":hex:"00":exp:19
ECP point multiplication rng fail secp256r1
depends_on:5
9:exp:5:hex:"814264145F2F56F2E96A8E337A1284993FAF432A5ABCE59E867B7291D507A3AF"
ECP point multiplication rng fail Curve25519
depends_on:8
9:exp:8:hex:"5AC99F33632E5A768DE7E81BF854C27C46E3FBF2ABBACD29EC4AFF517369C660"
ECP test vectors Curve448 (RFC 7748 6.2, after decodeUCoordinate)
depends_on:11
7:exp:17:char*:"eb7298a5c0d8c29a1dab27f1a6826300917389449741a974f5bac9d98dc298d46555bce8bae89eeed400584bb046cf75579f51d125498f98":char*:"a01fc432e5807f17530d1288da125b0cd453d941726436c8bbd9c5222c3da7fa639ce03db8d23b274a0721a1aed5227de6e3b731ccf7089b":char*:"ad997351b6106f36b0d1091b929c4c37213e0d2b97e85ebb20c127691d0dad8f1d8175b0723745e639a3cb7044290b99e0e2a0c27a6a301c":char*:"0936f37bc6c1bd07ae3dec7ab5dc06a73ca13242fb343efc72b9d82730b445f3d4b0bd077162a46dcfec6f9b590bfcbcf520cdb029a8b73e":char*:"9d874a5137509a449ad5853040241c5236395435c36424fd560b0cb62b281d285275a740ce32a22dd1740f4aa9161cec95ccc61a18f4ff07"
ECP test vectors secp192k1
depends_on:12
6:exp:20:char*:"D1E13A359F6E0F0698791938E6D60246030AE4B0D8D4E9DE":char*:"281BCA982F187ED30AD5E088461EBE0A5FADBB682546DF79":char*:"3F68A8E9441FB93A4DD48CB70B504FCC9AA01902EF5BE0F3":char*:"BE97C5D2A1A94D081E3FACE53E65A27108B7467BDF58DE43":char*:"5EB35E922CD693F7947124F5920022C4891C04F6A8B8DCB2":char*:"60ECF73D0FC43E0C42E8E155FFE39F9F0B531F87B34B6C3C":char*:"372F5C5D0E18313C82AEF940EC3AFEE26087A46F1EBAE923":char*:"D5A9F9182EC09CEAEA5F57EA10225EC77FA44174511985FD"
ECP test vectors secp224k1
depends_on:9
6:exp:10:char*:"8EAD9B2819A3C2746B3EDC1E0D30F23271CDAC048C0615C961B1A9D3":char*:"DEE0A75EF26CF8F501DB80807A3A0908E5CF01852709C1D35B31428B":char*:"276D2B817918F7CD1DA5CCA081EC4B62CD255E0ACDC9F85FA8C52CAC":char*:"AB7E70AEDA68A174ECC1F3800561B2D4FABE97C5D2A1A94D081E3FAC":char*:"D2E94B00FD30201C40EDF73B137427916687AEA1935B277A5960DD1C":char*:"DE728A614B17D91EB3CB2C17DA195562B6281585986332B3E12DA0ED":char*:"B66B673D29038A3487A2D9C10CDCE67646F7C39C984EBE9E8795AD3C":char*:"928C6147AF5EE4B54FA6ECF77B70CA3FEE5F4182DB057878F129DF"
ECP test vectors secp256k1
depends_on:13
6:exp:21:char*:"923C6D4756CD940CD1E13A359F6E0F0698791938E6D60246030AE4B0D8D4E9DE":char*:"20A865B295E93C5B090F324B84D7AC7526AA1CFE86DD80E792CECCD16B657D55":char*:"38AC87141A4854A8DFD87333E107B61692323721FE2EAD6E52206FE471A4771B":char*:"4F5036A8ED5809AB7E70AEDA68A174ECC1F3800561B2D4FABE97C5D2A1A94D08":char*:"029F5D2CC5A2C7E538FBA321439B4EC8DD79B7FEB9C0A8A5114EEA39856E22E8":char*:"165171AFC3411A427F24FDDE1192A551C90983EB421BC982AB4CF4E21F18F04B":char*:"E4B5B537D3ACEA7624F2E9C185BFFD80BC7035E515F33E0D4CFAE747FD20038E":char*:"2BC685B7DCDBC694F5E036C4EAE9BFB489D7BF8940C4681F734B71D68501514C"
ECP selftest
22
ECP restartable mul secp256r1 max_ops=0 (disabled)
depends_on:5
4:exp:5:char*:"814264145F2F56F2E96A8E337A1284993FAF432A5ABCE59E867B7291D507A3AF":char*:"2AF502F3BE8952F2C9B5A8D4160D09E97165BE50BC42AE4A5E8D3B4BA83AEB15":char*:"EB0FAF4CA986C4D38681A0F9872D79D56795BD4BFF6E6DE3C0F5015ECE5EFD85":char*:"2CE1788EC197E096DB95A200CC0AB26A19CE6BCCAD562B8EEE1B593761CF7F41":char*:"DD0F5396219D1EA393310412D19A08F1F5811E9DC8EC8EEA7F80D21C820C2788":char*:"0357DCCD4C804D0D8D33AA42B848834AA5605F9AB0D37239A115BBB647936F50":int:0:int:0:int:0
ECP restartable mul secp256r1 max_ops=1
depends_on:5
4:exp:5:char*:"814264145F2F56F2E96A8E337A1284993FAF432A5ABCE59E867B7291D507A3AF":char*:"2AF502F3BE8952F2C9B5A8D4160D09E97165BE50BC42AE4A5E8D3B4BA83AEB15":char*:"EB0FAF4CA986C4D38681A0F9872D79D56795BD4BFF6E6DE3C0F5015ECE5EFD85":char*:"2CE1788EC197E096DB95A200CC0AB26A19CE6BCCAD562B8EEE1B593761CF7F41":char*:"DD0F5396219D1EA393310412D19A08F1F5811E9DC8EC8EEA7F80D21C820C2788":char*:"0357DCCD4C804D0D8D33AA42B848834AA5605F9AB0D37239A115BBB647936F50":int:1:int:1:int:5000
ECP restartable mul secp256r1 max_ops=10000
depends_on:5
4:exp:5:char*:"814264145F2F56F2E96A8E337A1284993FAF432A5ABCE59E867B7291D507A3AF":char*:"2AF502F3BE8952F2C9B5A8D4160D09E97165BE50BC42AE4A5E8D3B4BA83AEB15":char*:"EB0FAF4CA986C4D38681A0F9872D79D56795BD4BFF6E6DE3C0F5015ECE5EFD85":char*:"2CE1788EC197E096DB95A200CC0AB26A19CE6BCCAD562B8EEE1B593761CF7F41":char*:"DD0F5396219D1EA393310412D19A08F1F5811E9DC8EC8EEA7F80D21C820C2788":char*:"0357DCCD4C804D0D8D33AA42B848834AA5605F9AB0D37239A115BBB647936F50":int:10000:int:0:int:0
ECP restartable mul secp256r1 max_ops=250
depends_on:5
4:exp:5:char*:"814264145F2F56F2E96A8E337A1284993FAF432A5ABCE59E867B7291D507A3AF":char*:"2AF502F3BE8952F2C9B5A8D4160D09E97165BE50BC42AE4A5E8D3B4BA83AEB15":char*:"EB0FAF4CA986C4D38681A0F9872D79D56795BD4BFF6E6DE3C0F5015ECE5EFD85":char*:"2CE1788EC197E096DB95A200CC0AB26A19CE6BCCAD562B8EEE1B593761CF7F41":char*:"DD0F5396219D1EA393310412D19A08F1F5811E9DC8EC8EEA7F80D21C820C2788":char*:"0357DCCD4C804D0D8D33AA42B848834AA5605F9AB0D37239A115BBB647936F50":int:250:int:2:int:32
ECP restartable muladd secp256r1 max_ops=0 (disabled)
depends_on:5
5:exp:5:char*:"CB28E0999B9C7715FD0A80D8E47A77079716CBBF917DD72E97566EA1C066957C":char*:"2B57C0235FB7489768D058FF4911C20FDBE71E3699D91339AFBB903EE17255DC":char*:"C3875E57C85038A0D60370A87505200DC8317C8C534948BEA6559C7C18E6D4CE":char*:"3B4E49C4FDBFC006FF993C81A50EAE221149076D6EC09DDD9FB3B787F85B6483":char*:"2442A5CC0ECD015FA3CA31DC8E2BBC70BF42D60CBCA20085E0822CB04235E970":char*:"6FC98BD7E50211A4A27102FA3549DF79EBCB4BF246B80945CDDFE7D509BBFD7D":int:0:int:0:int:0
ECP restartable muladd secp256r1 max_ops=1
depends_on:5
5:exp:5:char*:"CB28E0999B9C7715FD0A80D8E47A77079716CBBF917DD72E97566EA1C066957C":char*:"2B57C0235FB7489768D058FF4911C20FDBE71E3699D91339AFBB903EE17255DC":char*:"C3875E57C85038A0D60370A87505200DC8317C8C534948BEA6559C7C18E6D4CE":char*:"3B4E49C4FDBFC006FF993C81A50EAE221149076D6EC09DDD9FB3B787F85B6483":char*:"2442A5CC0ECD015FA3CA31DC8E2BBC70BF42D60CBCA20085E0822CB04235E970":char*:"6FC98BD7E50211A4A27102FA3549DF79EBCB4BF246B80945CDDFE7D509BBFD7D":int:1:int:1:int:10000
ECP restartable muladd secp256r1 max_ops=10000
depends_on:5
5:exp:5:char*:"CB28E0999B9C7715FD0A80D8E47A77079716CBBF917DD72E97566EA1C066957C":char*:"2B57C0235FB7489768D058FF4911C20FDBE71E3699D91339AFBB903EE17255DC":char*:"C3875E57C85038A0D60370A87505200DC8317C8C534948BEA6559C7C18E6D4CE":char*:"3B4E49C4FDBFC006FF993C81A50EAE221149076D6EC09DDD9FB3B787F85B6483":char*:"2442A5CC0ECD015FA3CA31DC8E2BBC70BF42D60CBCA20085E0822CB04235E970":char*:"6FC98BD7E50211A4A27102FA3549DF79EBCB4BF246B80945CDDFE7D509BBFD7D":int:10000:int:0:int:0
ECP restartable muladd secp256r1 max_ops=250
depends_on:5
5:exp:5:char*:"CB28E0999B9C7715FD0A80D8E47A77079716CBBF917DD72E97566EA1C066957C":char*:"2B57C0235FB7489768D058FF4911C20FDBE71E3699D91339AFBB903EE17255DC":char*:"C3875E57C85038A0D60370A87505200DC8317C8C534948BEA6559C7C18E6D4CE":char*:"3B4E49C4FDBFC006FF993C81A50EAE221149076D6EC09DDD9FB3B787F85B6483":char*:"2442A5CC0ECD015FA3CA31DC8E2BBC70BF42D60CBCA20085E0822CB04235E970":char*:"6FC98BD7E50211A4A27102FA3549DF79EBCB4BF246B80945CDDFE7D509BBFD7D":int:250:int:4:int:64
| 32,590 | 512 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_hmac_drbg.pr.c | /* clang-format off */
/*
* Copyright The Mbed TLS Contributors
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "third_party/mbedtls/test/test.inc"
/*
* *** THIS FILE WAS MACHINE GENERATED ***
*
* This file has been machine generated using the script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* Test file : ./test_suite_hmac_drbg.pr.c
*
* The following files were used to create this file.
*
* Main code file : suites/main_test.function
* Platform code file : suites/host_test.function
* Helper file : suites/helpers.function
* Test suite file : suites/test_suite_hmac_drbg.function
* Test suite data : suites/test_suite_hmac_drbg.pr.data
*
*/
#define TEST_SUITE_ACTIVE
#if defined(MBEDTLS_HMAC_DRBG_C)
#include "third_party/mbedtls/hmac_drbg.h"
typedef struct
{
unsigned char *p;
size_t len;
} entropy_ctx;
static int mbedtls_test_entropy_func( void *data, unsigned char *buf, size_t len )
{
entropy_ctx *ctx = (entropy_ctx *) data;
if( len > ctx->len )
return( -1 );
memcpy( buf, ctx->p, len );
ctx->p += len;
ctx->len -= len;
return( 0 );
}
void test_hmac_drbg_entropy_usage( int md_alg )
{
unsigned char out[16];
unsigned char buf[1024];
const mbedtls_md_info_t *md_info;
mbedtls_hmac_drbg_context ctx;
entropy_ctx entropy;
size_t i, reps = 10;
size_t default_entropy_len;
size_t expected_consumed_entropy = 0;
mbedtls_hmac_drbg_init( &ctx );
memset( buf, 0, sizeof( buf ) );
memset( out, 0, sizeof( out ) );
entropy.len = sizeof( buf );
entropy.p = buf;
md_info = mbedtls_md_info_from_type( md_alg );
TEST_ASSERT( md_info != NULL );
if( mbedtls_md_get_size( md_info ) <= 20 )
default_entropy_len = 16;
else if( mbedtls_md_get_size( md_info ) <= 28 )
default_entropy_len = 24;
else
default_entropy_len = 32;
/* Set reseed interval before seed */
mbedtls_hmac_drbg_set_reseed_interval( &ctx, 2 * reps );
/* Init must use entropy */
TEST_ASSERT( mbedtls_hmac_drbg_seed( &ctx, md_info, mbedtls_test_entropy_func, &entropy,
NULL, 0 ) == 0 );
/* default_entropy_len of entropy, plus half as much for the nonce */
expected_consumed_entropy += default_entropy_len * 3 / 2;
TEST_EQUAL( sizeof( buf ) - entropy.len, expected_consumed_entropy );
/* By default, PR is off, and reseed interval was set to
* 2 * reps so the next few calls should not use entropy */
for( i = 0; i < reps; i++ )
{
TEST_ASSERT( mbedtls_hmac_drbg_random( &ctx, out, sizeof( out ) - 4 ) == 0 );
TEST_ASSERT( mbedtls_hmac_drbg_random_with_add( &ctx, out, sizeof( out ) - 4,
buf, 16 ) == 0 );
}
TEST_EQUAL( sizeof( buf ) - entropy.len, expected_consumed_entropy );
/* While at it, make sure we didn't write past the requested length */
TEST_ASSERT( out[sizeof( out ) - 4] == 0 );
TEST_ASSERT( out[sizeof( out ) - 3] == 0 );
TEST_ASSERT( out[sizeof( out ) - 2] == 0 );
TEST_ASSERT( out[sizeof( out ) - 1] == 0 );
/* There have been 2 * reps calls to random. The next call should reseed */
TEST_ASSERT( mbedtls_hmac_drbg_random( &ctx, out, sizeof( out ) ) == 0 );
expected_consumed_entropy += default_entropy_len;
TEST_EQUAL( sizeof( buf ) - entropy.len, expected_consumed_entropy );
/* Set reseed interval after seed */
mbedtls_hmac_drbg_set_reseed_interval( &ctx, 4 * reps + 1);
/* The new few calls should not reseed */
for( i = 0; i < (2 * reps); i++ )
{
TEST_ASSERT( mbedtls_hmac_drbg_random( &ctx, out, sizeof( out ) ) == 0 );
TEST_ASSERT( mbedtls_hmac_drbg_random_with_add( &ctx, out, sizeof( out ) ,
buf, 16 ) == 0 );
}
TEST_EQUAL( sizeof( buf ) - entropy.len, expected_consumed_entropy );
/* Now enable PR, so the next few calls should all reseed */
mbedtls_hmac_drbg_set_prediction_resistance( &ctx, MBEDTLS_HMAC_DRBG_PR_ON );
TEST_ASSERT( mbedtls_hmac_drbg_random( &ctx, out, sizeof( out ) ) == 0 );
expected_consumed_entropy += default_entropy_len;
TEST_EQUAL( sizeof( buf ) - entropy.len, expected_consumed_entropy );
/* Finally, check setting entropy_len */
mbedtls_hmac_drbg_set_entropy_len( &ctx, 42 );
TEST_ASSERT( mbedtls_hmac_drbg_random( &ctx, out, sizeof( out ) ) == 0 );
expected_consumed_entropy += 42;
TEST_EQUAL( sizeof( buf ) - entropy.len, expected_consumed_entropy );
mbedtls_hmac_drbg_set_entropy_len( &ctx, 13 );
TEST_ASSERT( mbedtls_hmac_drbg_random( &ctx, out, sizeof( out ) ) == 0 );
expected_consumed_entropy += 13;
TEST_EQUAL( sizeof( buf ) - entropy.len, expected_consumed_entropy );
exit:
mbedtls_hmac_drbg_free( &ctx );
}
void test_hmac_drbg_entropy_usage_wrapper( void ** params )
{
test_hmac_drbg_entropy_usage( *( (int *) params[0] ) );
}
#if defined(MBEDTLS_FS_IO)
void test_hmac_drbg_seed_file( int md_alg, char * path, int ret )
{
const mbedtls_md_info_t *md_info;
mbedtls_hmac_drbg_context ctx;
mbedtls_hmac_drbg_init( &ctx );
md_info = mbedtls_md_info_from_type( md_alg );
TEST_ASSERT( md_info != NULL );
TEST_ASSERT( mbedtls_hmac_drbg_seed( &ctx, md_info,
mbedtls_test_rnd_std_rand, NULL,
NULL, 0 ) == 0 );
TEST_ASSERT( mbedtls_hmac_drbg_write_seed_file( &ctx, path ) == ret );
TEST_ASSERT( mbedtls_hmac_drbg_update_seed_file( &ctx, path ) == ret );
exit:
mbedtls_hmac_drbg_free( &ctx );
}
void test_hmac_drbg_seed_file_wrapper( void ** params )
{
test_hmac_drbg_seed_file( *( (int *) params[0] ), (char *) params[1], *( (int *) params[2] ) );
}
#endif /* MBEDTLS_FS_IO */
void test_hmac_drbg_buf( int md_alg )
{
unsigned char out[16];
unsigned char buf[100];
const mbedtls_md_info_t *md_info;
mbedtls_hmac_drbg_context ctx;
size_t i;
mbedtls_hmac_drbg_init( &ctx );
memset( buf, 0, sizeof( buf ) );
memset( out, 0, sizeof( out ) );
md_info = mbedtls_md_info_from_type( md_alg );
TEST_ASSERT( md_info != NULL );
TEST_ASSERT( mbedtls_hmac_drbg_seed_buf( &ctx, md_info, buf, sizeof( buf ) ) == 0 );
/* Make sure it never tries to reseed (would segfault otherwise) */
mbedtls_hmac_drbg_set_reseed_interval( &ctx, 3 );
mbedtls_hmac_drbg_set_prediction_resistance( &ctx, MBEDTLS_HMAC_DRBG_PR_ON );
for( i = 0; i < 30; i++ )
TEST_ASSERT( mbedtls_hmac_drbg_random( &ctx, out, sizeof( out ) ) == 0 );
exit:
mbedtls_hmac_drbg_free( &ctx );
}
void test_hmac_drbg_buf_wrapper( void ** params )
{
test_hmac_drbg_buf( *( (int *) params[0] ) );
}
void test_hmac_drbg_no_reseed( int md_alg, data_t * entropy,
data_t * custom, data_t * add1,
data_t * add2, data_t * output )
{
unsigned char data[1024];
unsigned char my_output[512];
entropy_ctx p_entropy;
const mbedtls_md_info_t *md_info;
mbedtls_hmac_drbg_context ctx;
mbedtls_hmac_drbg_init( &ctx );
p_entropy.p = entropy->x;
p_entropy.len = entropy->len;
md_info = mbedtls_md_info_from_type( md_alg );
TEST_ASSERT( md_info != NULL );
/* Test the simplified buffer-based variant */
memcpy( data, entropy->x, p_entropy.len );
memcpy( data + p_entropy.len, custom->x, custom->len );
TEST_ASSERT( mbedtls_hmac_drbg_seed_buf( &ctx, md_info,
data, p_entropy.len + custom->len ) == 0 );
TEST_ASSERT( mbedtls_hmac_drbg_random_with_add( &ctx, my_output, output->len,
add1->x, add1->len ) == 0 );
TEST_ASSERT( mbedtls_hmac_drbg_random_with_add( &ctx, my_output, output->len,
add2->x, add2->len ) == 0 );
/* Reset context for second run */
mbedtls_hmac_drbg_free( &ctx );
TEST_ASSERT( timingsafe_bcmp( my_output, output->x, output->len ) == 0 );
/* And now the normal entropy-based variant */
TEST_ASSERT( mbedtls_hmac_drbg_seed( &ctx, md_info, mbedtls_test_entropy_func, &p_entropy,
custom->x, custom->len ) == 0 );
TEST_ASSERT( mbedtls_hmac_drbg_random_with_add( &ctx, my_output, output->len,
add1->x, add1->len ) == 0 );
TEST_ASSERT( mbedtls_hmac_drbg_random_with_add( &ctx, my_output, output->len,
add2->x, add2->len ) == 0 );
TEST_ASSERT( timingsafe_bcmp( my_output, output->x, output->len ) == 0 );
exit:
mbedtls_hmac_drbg_free( &ctx );
}
void test_hmac_drbg_no_reseed_wrapper( void ** params )
{
data_t data1 = {(uint8_t *) params[1], *( (uint32_t *) params[2] )};
data_t data3 = {(uint8_t *) params[3], *( (uint32_t *) params[4] )};
data_t data5 = {(uint8_t *) params[5], *( (uint32_t *) params[6] )};
data_t data7 = {(uint8_t *) params[7], *( (uint32_t *) params[8] )};
data_t data9 = {(uint8_t *) params[9], *( (uint32_t *) params[10] )};
test_hmac_drbg_no_reseed( *( (int *) params[0] ), &data1, &data3, &data5, &data7, &data9 );
}
void test_hmac_drbg_nopr( int md_alg, data_t * entropy, data_t * custom,
data_t * add1, data_t * add2, data_t * add3,
data_t * output )
{
unsigned char my_output[512];
entropy_ctx p_entropy;
const mbedtls_md_info_t *md_info;
mbedtls_hmac_drbg_context ctx;
mbedtls_hmac_drbg_init( &ctx );
p_entropy.p = entropy->x;
p_entropy.len = entropy->len;
md_info = mbedtls_md_info_from_type( md_alg );
TEST_ASSERT( md_info != NULL );
TEST_ASSERT( mbedtls_hmac_drbg_seed( &ctx, md_info, mbedtls_test_entropy_func, &p_entropy,
custom->x, custom->len ) == 0 );
TEST_ASSERT( mbedtls_hmac_drbg_reseed( &ctx, add1->x, add1->len ) == 0 );
TEST_ASSERT( mbedtls_hmac_drbg_random_with_add( &ctx, my_output, output->len,
add2->x, add2->len ) == 0 );
TEST_ASSERT( mbedtls_hmac_drbg_random_with_add( &ctx, my_output, output->len,
add3->x, add3->len ) == 0 );
TEST_ASSERT( timingsafe_bcmp( my_output, output->x, output->len ) == 0 );
exit:
mbedtls_hmac_drbg_free( &ctx );
}
void test_hmac_drbg_nopr_wrapper( void ** params )
{
data_t data1 = {(uint8_t *) params[1], *( (uint32_t *) params[2] )};
data_t data3 = {(uint8_t *) params[3], *( (uint32_t *) params[4] )};
data_t data5 = {(uint8_t *) params[5], *( (uint32_t *) params[6] )};
data_t data7 = {(uint8_t *) params[7], *( (uint32_t *) params[8] )};
data_t data9 = {(uint8_t *) params[9], *( (uint32_t *) params[10] )};
data_t data11 = {(uint8_t *) params[11], *( (uint32_t *) params[12] )};
test_hmac_drbg_nopr( *( (int *) params[0] ), &data1, &data3, &data5, &data7, &data9, &data11 );
}
void test_hmac_drbg_pr( int md_alg, data_t * entropy, data_t * custom,
data_t * add1, data_t * add2, data_t * output )
{
unsigned char my_output[512];
entropy_ctx p_entropy;
const mbedtls_md_info_t *md_info;
mbedtls_hmac_drbg_context ctx;
mbedtls_hmac_drbg_init( &ctx );
p_entropy.p = entropy->x;
p_entropy.len = entropy->len;
md_info = mbedtls_md_info_from_type( md_alg );
TEST_ASSERT( md_info != NULL );
TEST_ASSERT( mbedtls_hmac_drbg_seed( &ctx, md_info, mbedtls_test_entropy_func, &p_entropy,
custom->x, custom->len ) == 0 );
mbedtls_hmac_drbg_set_prediction_resistance( &ctx, MBEDTLS_HMAC_DRBG_PR_ON );
TEST_ASSERT( mbedtls_hmac_drbg_random_with_add( &ctx, my_output, output->len,
add1->x, add1->len ) == 0 );
TEST_ASSERT( mbedtls_hmac_drbg_random_with_add( &ctx, my_output, output->len,
add2->x, add2->len ) == 0 );
TEST_ASSERT( timingsafe_bcmp( my_output, output->x, output->len ) == 0 );
exit:
mbedtls_hmac_drbg_free( &ctx );
}
void test_hmac_drbg_pr_wrapper( void ** params )
{
data_t data1 = {(uint8_t *) params[1], *( (uint32_t *) params[2] )};
data_t data3 = {(uint8_t *) params[3], *( (uint32_t *) params[4] )};
data_t data5 = {(uint8_t *) params[5], *( (uint32_t *) params[6] )};
data_t data7 = {(uint8_t *) params[7], *( (uint32_t *) params[8] )};
data_t data9 = {(uint8_t *) params[9], *( (uint32_t *) params[10] )};
test_hmac_drbg_pr( *( (int *) params[0] ), &data1, &data3, &data5, &data7, &data9 );
}
#if defined(MBEDTLS_SELF_TEST)
void test_hmac_drbg_selftest( )
{
TEST_ASSERT( mbedtls_hmac_drbg_self_test( 1 ) == 0 );
exit:
;
}
void test_hmac_drbg_selftest_wrapper( void ** params )
{
(void)params;
test_hmac_drbg_selftest( );
}
#endif /* MBEDTLS_SELF_TEST */
#endif /* MBEDTLS_HMAC_DRBG_C */
/*----------------------------------------------------------------------------*/
/* Test dispatch code */
/**
* \brief Evaluates an expression/macro into its literal integer value.
* For optimizing space for embedded targets each expression/macro
* is identified by a unique identifier instead of string literals.
* Identifiers and evaluation code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param exp_id Expression identifier.
* \param out_value Pointer to int to hold the integer.
*
* \return 0 if exp_id is found. 1 otherwise.
*/
int get_expression( int32_t exp_id, int32_t * out_value )
{
int ret = KEY_VALUE_MAPPING_FOUND;
(void) exp_id;
(void) out_value;
switch( exp_id )
{
#if defined(MBEDTLS_HMAC_DRBG_C)
case 0:
{
*out_value = MBEDTLS_MD_SHA1;
}
break;
case 1:
{
*out_value = MBEDTLS_MD_SHA224;
}
break;
case 2:
{
*out_value = MBEDTLS_MD_SHA256;
}
break;
case 3:
{
*out_value = MBEDTLS_MD_SHA384;
}
break;
case 4:
{
*out_value = MBEDTLS_MD_SHA512;
}
break;
#endif
default:
{
ret = KEY_VALUE_MAPPING_NOT_FOUND;
}
break;
}
return( ret );
}
/**
* \brief Checks if the dependency i.e. the compile flag is set.
* For optimizing space for embedded targets each dependency
* is identified by a unique identifier instead of string literals.
* Identifiers and check code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param dep_id Dependency identifier.
*
* \return DEPENDENCY_SUPPORTED if set else DEPENDENCY_NOT_SUPPORTED
*/
int dep_check( int dep_id )
{
int ret = DEPENDENCY_NOT_SUPPORTED;
(void) dep_id;
switch( dep_id )
{
#if defined(MBEDTLS_HMAC_DRBG_C)
case 0:
{
#if defined(MBEDTLS_SHA1_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 1:
{
#if defined(MBEDTLS_SHA256_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 2:
{
#if defined(MBEDTLS_SHA512_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 3:
{
#if !defined(MBEDTLS_SHA512_NO_SHA384)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
#endif
default:
break;
}
return( ret );
}
/**
* \brief Function pointer type for test function wrappers.
*
* A test function wrapper decodes the parameters and passes them to the
* underlying test function. Both the wrapper and the underlying function
* return void. Test wrappers assume that they are passed a suitable
* parameter array and do not perform any error detection.
*
* \param param_array The array of parameters. Each element is a `void *`
* which the wrapper casts to the correct type and
* dereferences. Each wrapper function hard-codes the
* number and types of the parameters.
*/
typedef void (*TestWrapper_t)( void **param_array );
/**
* \brief Table of test function wrappers. Used by dispatch_test().
* This table is populated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
*/
TestWrapper_t test_funcs[] =
{
/* Function Id: 0 */
#if defined(MBEDTLS_HMAC_DRBG_C)
test_hmac_drbg_entropy_usage_wrapper,
#else
NULL,
#endif
/* Function Id: 1 */
#if defined(MBEDTLS_HMAC_DRBG_C) && defined(MBEDTLS_FS_IO)
test_hmac_drbg_seed_file_wrapper,
#else
NULL,
#endif
/* Function Id: 2 */
#if defined(MBEDTLS_HMAC_DRBG_C)
test_hmac_drbg_buf_wrapper,
#else
NULL,
#endif
/* Function Id: 3 */
#if defined(MBEDTLS_HMAC_DRBG_C)
test_hmac_drbg_no_reseed_wrapper,
#else
NULL,
#endif
/* Function Id: 4 */
#if defined(MBEDTLS_HMAC_DRBG_C)
test_hmac_drbg_nopr_wrapper,
#else
NULL,
#endif
/* Function Id: 5 */
#if defined(MBEDTLS_HMAC_DRBG_C)
test_hmac_drbg_pr_wrapper,
#else
NULL,
#endif
/* Function Id: 6 */
#if defined(MBEDTLS_HMAC_DRBG_C) && defined(MBEDTLS_SELF_TEST)
test_hmac_drbg_selftest_wrapper,
#else
NULL,
#endif
};
/**
* \brief Execute the test function.
*
* This is a wrapper function around the test function execution
* to allow the setjmp() call used to catch any calls to the
* parameter failure callback, to be used. Calls to setjmp()
* can invalidate the state of any local auto variables.
*
* \param fp Function pointer to the test function.
* \param params Parameters to pass to the #TestWrapper_t wrapper function.
*
*/
void execute_function_ptr(TestWrapper_t fp, void **params)
{
#if defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG)
mbedtls_test_enable_insecure_external_rng( );
#endif
#if defined(MBEDTLS_CHECK_PARAMS)
mbedtls_test_param_failed_location_record_t location_record;
if ( setjmp( mbedtls_test_param_failed_get_state_buf( ) ) == 0 )
{
fp( params );
}
else
{
/* Unexpected parameter validation error */
mbedtls_test_param_failed_get_location_record( &location_record );
mbedtls_test_fail( location_record.failure_condition,
location_record.line,
location_record.file );
}
mbedtls_test_param_failed_reset_state( );
#else
fp( params );
#endif
#if defined(MBEDTLS_TEST_MUTEX_USAGE)
mbedtls_test_mutex_usage_check( );
#endif /* MBEDTLS_TEST_MUTEX_USAGE */
}
/**
* \brief Dispatches test functions based on function index.
*
* \param func_idx Test function index.
* \param params The array of parameters to pass to the test function.
* It will be decoded by the #TestWrapper_t wrapper function.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int dispatch_test( size_t func_idx, void ** params )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof( test_funcs ) / sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp )
execute_function_ptr(fp, params);
else
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
/**
* \brief Checks if test function is supported in this build-time
* configuration.
*
* \param func_idx Test function index.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int check_test( size_t func_idx )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof(test_funcs)/sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp == NULL )
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
int main( int argc, const char *argv[] )
{
int ret;
mbedtls_test_platform_setup();
ret = execute_tests( argc, argv, "/zip/third_party/mbedtls/test/test_suite_hmac_drbg.pr.datax" );
mbedtls_test_platform_teardown();
return( ret );
}
| 21,879 | 696 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_version.c | /* clang-format off */
/*
* Copyright The Mbed TLS Contributors
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "third_party/mbedtls/test/test.inc"
/*
* *** THIS FILE WAS MACHINE GENERATED ***
*
* This file has been machine generated using the script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* Test file : ./test_suite_version.c
*
* The following files were used to create this file.
*
* Main code file : suites/main_test.function
* Platform code file : suites/host_test.function
* Helper file : suites/helpers.function
* Test suite file : suites/test_suite_version.function
* Test suite data : suites/test_suite_version.data
*
*/
#define TEST_SUITE_ACTIVE
#if defined(MBEDTLS_VERSION_C)
#include "third_party/mbedtls/version.h"
void test_check_compiletime_version( char * version_str )
{
char build_str[100];
char build_str_full[100];
unsigned int build_int;
memset( build_str, 0, 100 );
memset( build_str_full, 0, 100 );
mbedtls_snprintf( build_str, 100, "%d.%d.%d", MBEDTLS_VERSION_MAJOR,
MBEDTLS_VERSION_MINOR, MBEDTLS_VERSION_PATCH );
mbedtls_snprintf( build_str_full, 100, "mbed TLS %d.%d.%d", MBEDTLS_VERSION_MAJOR,
MBEDTLS_VERSION_MINOR, MBEDTLS_VERSION_PATCH );
build_int = MBEDTLS_VERSION_MAJOR << 24 |
MBEDTLS_VERSION_MINOR << 16 |
MBEDTLS_VERSION_PATCH << 8;
TEST_ASSERT( build_int == MBEDTLS_VERSION_NUMBER );
TEST_ASSERT( strcmp( build_str, MBEDTLS_VERSION_STRING ) == 0 );
TEST_ASSERT( strcmp( build_str_full, MBEDTLS_VERSION_STRING_FULL ) == 0 );
TEST_ASSERT( strcmp( version_str, MBEDTLS_VERSION_STRING ) == 0 );
exit:
;
}
void test_check_compiletime_version_wrapper( void ** params )
{
test_check_compiletime_version( (char *) params[0] );
}
void test_check_runtime_version( char * version_str )
{
char build_str[100];
char get_str[100];
char build_str_full[100];
char get_str_full[100];
unsigned int get_int;
memset( build_str, 0, 100 );
memset( get_str, 0, 100 );
memset( build_str_full, 0, 100 );
memset( get_str_full, 0, 100 );
get_int = mbedtls_version_get_number();
mbedtls_version_get_string( get_str );
mbedtls_version_get_string_full( get_str_full );
mbedtls_snprintf( build_str, 100, "%u.%u.%u",
(get_int >> 24) & 0xFF,
(get_int >> 16) & 0xFF,
(get_int >> 8) & 0xFF );
mbedtls_snprintf( build_str_full, 100, "mbed TLS %s", version_str );
TEST_ASSERT( strcmp( build_str, version_str ) == 0 );
TEST_ASSERT( strcmp( build_str_full, get_str_full ) == 0 );
TEST_ASSERT( strcmp( version_str, get_str ) == 0 );
exit:
;
}
void test_check_runtime_version_wrapper( void ** params )
{
test_check_runtime_version( (char *) params[0] );
}
#if defined(MBEDTLS_VERSION_FEATURES)
void test_check_feature( char *feature, int result )
{
int check = mbedtls_version_check_feature( feature );
TEST_ASSERT( check == result );
exit:
;
}
void test_check_feature_wrapper( void ** params )
{
test_check_feature( (char *) params[0], *( (int *) params[1] ) );
}
#endif /* MBEDTLS_VERSION_FEATURES */
#endif /* MBEDTLS_VERSION_C */
/*----------------------------------------------------------------------------*/
/* Test dispatch code */
/**
* \brief Evaluates an expression/macro into its literal integer value.
* For optimizing space for embedded targets each expression/macro
* is identified by a unique identifier instead of string literals.
* Identifiers and evaluation code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param exp_id Expression identifier.
* \param out_value Pointer to int to hold the integer.
*
* \return 0 if exp_id is found. 1 otherwise.
*/
int get_expression( int32_t exp_id, int32_t * out_value )
{
int ret = KEY_VALUE_MAPPING_FOUND;
(void) exp_id;
(void) out_value;
switch( exp_id )
{
#if defined(MBEDTLS_VERSION_C)
case 0:
{
*out_value = -1;
}
break;
#endif
default:
{
ret = KEY_VALUE_MAPPING_NOT_FOUND;
}
break;
}
return( ret );
}
/**
* \brief Checks if the dependency i.e. the compile flag is set.
* For optimizing space for embedded targets each dependency
* is identified by a unique identifier instead of string literals.
* Identifiers and check code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param dep_id Dependency identifier.
*
* \return DEPENDENCY_SUPPORTED if set else DEPENDENCY_NOT_SUPPORTED
*/
int dep_check( int dep_id )
{
int ret = DEPENDENCY_NOT_SUPPORTED;
(void) dep_id;
switch( dep_id )
{
#if defined(MBEDTLS_VERSION_C)
case 0:
{
#if defined(MBEDTLS_AES_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
#endif
default:
break;
}
return( ret );
}
/**
* \brief Function pointer type for test function wrappers.
*
* A test function wrapper decodes the parameters and passes them to the
* underlying test function. Both the wrapper and the underlying function
* return void. Test wrappers assume that they are passed a suitable
* parameter array and do not perform any error detection.
*
* \param param_array The array of parameters. Each element is a `void *`
* which the wrapper casts to the correct type and
* dereferences. Each wrapper function hard-codes the
* number and types of the parameters.
*/
typedef void (*TestWrapper_t)( void **param_array );
/**
* \brief Table of test function wrappers. Used by dispatch_test().
* This table is populated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
*/
TestWrapper_t test_funcs[] =
{
/* Function Id: 0 */
#if defined(MBEDTLS_VERSION_C)
test_check_compiletime_version_wrapper,
#else
NULL,
#endif
/* Function Id: 1 */
#if defined(MBEDTLS_VERSION_C)
test_check_runtime_version_wrapper,
#else
NULL,
#endif
/* Function Id: 2 */
#if defined(MBEDTLS_VERSION_C) && defined(MBEDTLS_VERSION_FEATURES)
test_check_feature_wrapper,
#else
NULL,
#endif
};
/**
* \brief Execute the test function.
*
* This is a wrapper function around the test function execution
* to allow the setjmp() call used to catch any calls to the
* parameter failure callback, to be used. Calls to setjmp()
* can invalidate the state of any local auto variables.
*
* \param fp Function pointer to the test function.
* \param params Parameters to pass to the #TestWrapper_t wrapper function.
*
*/
void execute_function_ptr(TestWrapper_t fp, void **params)
{
#if defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG)
mbedtls_test_enable_insecure_external_rng( );
#endif
#if defined(MBEDTLS_CHECK_PARAMS)
mbedtls_test_param_failed_location_record_t location_record;
if ( setjmp( mbedtls_test_param_failed_get_state_buf( ) ) == 0 )
{
fp( params );
}
else
{
/* Unexpected parameter validation error */
mbedtls_test_param_failed_get_location_record( &location_record );
mbedtls_test_fail( location_record.failure_condition,
location_record.line,
location_record.file );
}
mbedtls_test_param_failed_reset_state( );
#else
fp( params );
#endif
#if defined(MBEDTLS_TEST_MUTEX_USAGE)
mbedtls_test_mutex_usage_check( );
#endif /* MBEDTLS_TEST_MUTEX_USAGE */
}
/**
* \brief Dispatches test functions based on function index.
*
* \param func_idx Test function index.
* \param params The array of parameters to pass to the test function.
* It will be decoded by the #TestWrapper_t wrapper function.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int dispatch_test( size_t func_idx, void ** params )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof( test_funcs ) / sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp )
execute_function_ptr(fp, params);
else
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
/**
* \brief Checks if test function is supported in this build-time
* configuration.
*
* \param func_idx Test function index.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int check_test( size_t func_idx )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof(test_funcs)/sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp == NULL )
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
int main( int argc, const char *argv[] )
{
int ret;
mbedtls_test_platform_setup();
ret = execute_tests( argc, argv, "/zip/third_party/mbedtls/test/test_suite_version.datax" );
mbedtls_test_platform_teardown();
return( ret );
}
| 10,521 | 373 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_aes.cbc.c | /* clang-format off */
/*
* Copyright The Mbed TLS Contributors
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "libc/log/log.h"
#include "third_party/mbedtls/test/test.inc"
/*
* *** THIS FILE WAS MACHINE GENERATED ***
*
* This file has been machine generated using the script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* Test file : ./test_suite_aes.cbc.c
*
* The following files were used to create this file.
*
* Main code file : suites/main_test.function
* Platform code file : suites/host_test.function
* Helper file : suites/helpers.function
* Test suite file : suites/test_suite_aes.function
* Test suite data : suites/test_suite_aes.cbc.data
*
*/
/*----------------------------------------------------------------------------*/
/* Test Suite Code */
#define TEST_SUITE_ACTIVE
#if defined(MBEDTLS_AES_C)
#include "third_party/mbedtls/aes.h"
void test_aes_encrypt_ecb( data_t * key_str, data_t * src_str,
data_t * dst, int setkey_result )
{
unsigned char output[100];
mbedtls_aes_context ctx;
memset(output, 0x00, 100);
mbedtls_aes_init( &ctx );
TEST_ASSERT( mbedtls_aes_setkey_enc( &ctx, key_str->x, key_str->len * 8 ) == setkey_result );
if( setkey_result == 0 )
{
TEST_ASSERT( mbedtls_aes_crypt_ecb( &ctx, MBEDTLS_AES_ENCRYPT, src_str->x, output ) == 0 );
TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, 16, dst->len ) == 0 );
}
exit:
mbedtls_aes_free( &ctx );
}
void test_aes_encrypt_ecb_wrapper( void ** params )
{
data_t data0 = {(uint8_t *) params[0], *( (uint32_t *) params[1] )};
data_t data2 = {(uint8_t *) params[2], *( (uint32_t *) params[3] )};
data_t data4 = {(uint8_t *) params[4], *( (uint32_t *) params[5] )};
test_aes_encrypt_ecb( &data0, &data2, &data4, *( (int *) params[6] ) );
}
void test_aes_decrypt_ecb( data_t * key_str, data_t * src_str,
data_t * dst, int setkey_result )
{
unsigned char output[100];
mbedtls_aes_context ctx;
memset(output, 0x00, 100);
mbedtls_aes_init( &ctx );
TEST_ASSERT( mbedtls_aes_setkey_dec( &ctx, key_str->x, key_str->len * 8 ) == setkey_result );
if( setkey_result == 0 )
{
TEST_ASSERT( mbedtls_aes_crypt_ecb( &ctx, MBEDTLS_AES_DECRYPT, src_str->x, output ) == 0 );
TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, 16, dst->len ) == 0 );
}
exit:
mbedtls_aes_free( &ctx );
}
void test_aes_decrypt_ecb_wrapper( void ** params )
{
data_t data0 = {(uint8_t *) params[0], *( (uint32_t *) params[1] )};
data_t data2 = {(uint8_t *) params[2], *( (uint32_t *) params[3] )};
data_t data4 = {(uint8_t *) params[4], *( (uint32_t *) params[5] )};
test_aes_decrypt_ecb( &data0, &data2, &data4, *( (int *) params[6] ) );
}
#if defined(MBEDTLS_CIPHER_MODE_CBC)
void test_aes_encrypt_cbc( data_t * key_str, data_t * iv_str,
data_t * src_str, data_t * dst,
int cbc_result )
{
unsigned char output[100];
mbedtls_aes_context ctx;
memset(output, 0x00, 100);
mbedtls_aes_init( &ctx );
mbedtls_aes_setkey_enc( &ctx, key_str->x, key_str->len * 8 );
TEST_ASSERT( mbedtls_aes_crypt_cbc( &ctx, MBEDTLS_AES_ENCRYPT, src_str->len, iv_str->x, src_str->x, output ) == cbc_result );
if( cbc_result == 0 )
{
TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x,
src_str->len, dst->len ) == 0 );
}
exit:
mbedtls_aes_free( &ctx );
}
void test_aes_encrypt_cbc_wrapper( void ** params )
{
data_t data0 = {(uint8_t *) params[0], *( (uint32_t *) params[1] )};
data_t data2 = {(uint8_t *) params[2], *( (uint32_t *) params[3] )};
data_t data4 = {(uint8_t *) params[4], *( (uint32_t *) params[5] )};
data_t data6 = {(uint8_t *) params[6], *( (uint32_t *) params[7] )};
test_aes_encrypt_cbc( &data0, &data2, &data4, &data6, *( (int *) params[8] ) );
}
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#if defined(MBEDTLS_CIPHER_MODE_CBC)
void test_aes_decrypt_cbc( data_t * key_str, data_t * iv_str,
data_t * src_str, data_t * dst,
int cbc_result )
{
unsigned char output[100];
mbedtls_aes_context ctx;
memset(output, 0x00, 100);
mbedtls_aes_init( &ctx );
mbedtls_aes_setkey_dec( &ctx, key_str->x, key_str->len * 8 );
TEST_ASSERT( mbedtls_aes_crypt_cbc( &ctx, MBEDTLS_AES_DECRYPT, src_str->len, iv_str->x, src_str->x, output ) == cbc_result );
if( cbc_result == 0)
{
TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x,
src_str->len, dst->len ) == 0 );
}
exit:
mbedtls_aes_free( &ctx );
}
void test_aes_decrypt_cbc_wrapper( void ** params )
{
data_t data0 = {(uint8_t *) params[0], *( (uint32_t *) params[1] )};
data_t data2 = {(uint8_t *) params[2], *( (uint32_t *) params[3] )};
data_t data4 = {(uint8_t *) params[4], *( (uint32_t *) params[5] )};
data_t data6 = {(uint8_t *) params[6], *( (uint32_t *) params[7] )};
test_aes_decrypt_cbc( &data0, &data2, &data4, &data6, *( (int *) params[8] ) );
}
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#if defined(MBEDTLS_CIPHER_MODE_XTS)
void test_aes_encrypt_xts( char *hex_key_string, char *hex_data_unit_string,
char *hex_src_string, char *hex_dst_string )
{
enum { AES_BLOCK_SIZE = 16 };
unsigned char *data_unit = NULL;
unsigned char *key = NULL;
unsigned char *src = NULL;
unsigned char *dst = NULL;
unsigned char *output = NULL;
mbedtls_aes_xts_context ctx;
size_t key_len, src_len, dst_len, data_unit_len;
mbedtls_aes_xts_init( &ctx );
data_unit = mbedtls_test_unhexify_alloc( hex_data_unit_string,
&data_unit_len );
TEST_ASSERT( data_unit_len == AES_BLOCK_SIZE );
key = mbedtls_test_unhexify_alloc( hex_key_string, &key_len );
TEST_ASSERT( key_len % 2 == 0 );
src = mbedtls_test_unhexify_alloc( hex_src_string, &src_len );
dst = mbedtls_test_unhexify_alloc( hex_dst_string, &dst_len );
TEST_ASSERT( src_len == dst_len );
output = mbedtls_test_zero_alloc( dst_len );
TEST_ASSERT( mbedtls_aes_xts_setkey_enc( &ctx, key, key_len * 8 ) == 0 );
TEST_ASSERT( mbedtls_aes_crypt_xts( &ctx, MBEDTLS_AES_ENCRYPT, src_len,
data_unit, src, output ) == 0 );
TEST_ASSERT( memcmp( output, dst, dst_len ) == 0 );
exit:
mbedtls_aes_xts_free( &ctx );
mbedtls_free( data_unit );
mbedtls_free( key );
mbedtls_free( src );
mbedtls_free( dst );
mbedtls_free( output );
}
void test_aes_encrypt_xts_wrapper( void ** params )
{
test_aes_encrypt_xts( (char *) params[0], (char *) params[1], (char *) params[2], (char *) params[3] );
}
#endif /* MBEDTLS_CIPHER_MODE_XTS */
#if defined(MBEDTLS_CIPHER_MODE_XTS)
void test_aes_decrypt_xts( char *hex_key_string, char *hex_data_unit_string,
char *hex_dst_string, char *hex_src_string )
{
enum { AES_BLOCK_SIZE = 16 };
unsigned char *data_unit = NULL;
unsigned char *key = NULL;
unsigned char *src = NULL;
unsigned char *dst = NULL;
unsigned char *output = NULL;
mbedtls_aes_xts_context ctx;
size_t key_len, src_len, dst_len, data_unit_len;
mbedtls_aes_xts_init( &ctx );
data_unit = mbedtls_test_unhexify_alloc( hex_data_unit_string,
&data_unit_len );
TEST_ASSERT( data_unit_len == AES_BLOCK_SIZE );
key = mbedtls_test_unhexify_alloc( hex_key_string, &key_len );
TEST_ASSERT( key_len % 2 == 0 );
src = mbedtls_test_unhexify_alloc( hex_src_string, &src_len );
dst = mbedtls_test_unhexify_alloc( hex_dst_string, &dst_len );
TEST_ASSERT( src_len == dst_len );
output = mbedtls_test_zero_alloc( dst_len );
TEST_ASSERT( mbedtls_aes_xts_setkey_dec( &ctx, key, key_len * 8 ) == 0 );
TEST_ASSERT( mbedtls_aes_crypt_xts( &ctx, MBEDTLS_AES_DECRYPT, src_len,
data_unit, src, output ) == 0 );
TEST_ASSERT( memcmp( output, dst, dst_len ) == 0 );
exit:
mbedtls_aes_xts_free( &ctx );
mbedtls_free( data_unit );
mbedtls_free( key );
mbedtls_free( src );
mbedtls_free( dst );
mbedtls_free( output );
}
void test_aes_decrypt_xts_wrapper( void ** params )
{
test_aes_decrypt_xts( (char *) params[0], (char *) params[1], (char *) params[2], (char *) params[3] );
}
#endif /* MBEDTLS_CIPHER_MODE_XTS */
#if defined(MBEDTLS_CIPHER_MODE_XTS)
void test_aes_crypt_xts_size( int size, int retval )
{
mbedtls_aes_xts_context ctx;
const unsigned char src[16] = { 0 };
unsigned char output[16];
unsigned char data_unit[16];
size_t length = size;
mbedtls_aes_xts_init( &ctx );
memset( data_unit, 0x00, sizeof( data_unit ) );
/* Valid pointers are passed for builds with MBEDTLS_CHECK_PARAMS, as
* otherwise we wouldn't get to the size check we're interested in. */
TEST_ASSERT( mbedtls_aes_crypt_xts( &ctx, MBEDTLS_AES_ENCRYPT, length, data_unit, src, output ) == retval );
exit:
;
}
void test_aes_crypt_xts_size_wrapper( void ** params )
{
test_aes_crypt_xts_size( *( (int *) params[0] ), *( (int *) params[1] ) );
}
#endif /* MBEDTLS_CIPHER_MODE_XTS */
#if defined(MBEDTLS_CIPHER_MODE_XTS)
void test_aes_crypt_xts_keysize( int size, int retval )
{
mbedtls_aes_xts_context ctx;
const unsigned char key[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
size_t key_len = size;
mbedtls_aes_xts_init( &ctx );
TEST_ASSERT( mbedtls_aes_xts_setkey_enc( &ctx, key, key_len * 8 ) == retval );
TEST_ASSERT( mbedtls_aes_xts_setkey_dec( &ctx, key, key_len * 8 ) == retval );
exit:
mbedtls_aes_xts_free( &ctx );
}
void test_aes_crypt_xts_keysize_wrapper( void ** params )
{
test_aes_crypt_xts_keysize( *( (int *) params[0] ), *( (int *) params[1] ) );
}
#endif /* MBEDTLS_CIPHER_MODE_XTS */
#if defined(MBEDTLS_CIPHER_MODE_CFB)
void test_aes_encrypt_cfb128( data_t * key_str, data_t * iv_str,
data_t * src_str, data_t * dst )
{
unsigned char output[100];
mbedtls_aes_context ctx;
size_t iv_offset = 0;
memset(output, 0x00, 100);
mbedtls_aes_init( &ctx );
mbedtls_aes_setkey_enc( &ctx, key_str->x, key_str->len * 8 );
TEST_ASSERT( mbedtls_aes_crypt_cfb128( &ctx, MBEDTLS_AES_ENCRYPT, 16, &iv_offset, iv_str->x, src_str->x, output ) == 0 );
TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, 16, dst->len ) == 0 );
exit:
mbedtls_aes_free( &ctx );
}
void test_aes_encrypt_cfb128_wrapper( void ** params )
{
data_t data0 = {(uint8_t *) params[0], *( (uint32_t *) params[1] )};
data_t data2 = {(uint8_t *) params[2], *( (uint32_t *) params[3] )};
data_t data4 = {(uint8_t *) params[4], *( (uint32_t *) params[5] )};
data_t data6 = {(uint8_t *) params[6], *( (uint32_t *) params[7] )};
test_aes_encrypt_cfb128( &data0, &data2, &data4, &data6 );
}
#endif /* MBEDTLS_CIPHER_MODE_CFB */
#if defined(MBEDTLS_CIPHER_MODE_CFB)
void test_aes_decrypt_cfb128( data_t * key_str, data_t * iv_str,
data_t * src_str, data_t * dst )
{
unsigned char output[100];
mbedtls_aes_context ctx;
size_t iv_offset = 0;
memset(output, 0x00, 100);
mbedtls_aes_init( &ctx );
mbedtls_aes_setkey_enc( &ctx, key_str->x, key_str->len * 8 );
TEST_ASSERT( mbedtls_aes_crypt_cfb128( &ctx, MBEDTLS_AES_DECRYPT, 16, &iv_offset, iv_str->x, src_str->x, output ) == 0 );
TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, 16, dst->len ) == 0 );
exit:
mbedtls_aes_free( &ctx );
}
void test_aes_decrypt_cfb128_wrapper( void ** params )
{
data_t data0 = {(uint8_t *) params[0], *( (uint32_t *) params[1] )};
data_t data2 = {(uint8_t *) params[2], *( (uint32_t *) params[3] )};
data_t data4 = {(uint8_t *) params[4], *( (uint32_t *) params[5] )};
data_t data6 = {(uint8_t *) params[6], *( (uint32_t *) params[7] )};
test_aes_decrypt_cfb128( &data0, &data2, &data4, &data6 );
}
#endif /* MBEDTLS_CIPHER_MODE_CFB */
#if defined(MBEDTLS_CIPHER_MODE_CFB)
void test_aes_encrypt_cfb8( data_t * key_str, data_t * iv_str,
data_t * src_str, data_t * dst )
{
unsigned char output[100];
mbedtls_aes_context ctx;
memset(output, 0x00, 100);
mbedtls_aes_init( &ctx );
mbedtls_aes_setkey_enc( &ctx, key_str->x, key_str->len * 8 );
TEST_ASSERT( mbedtls_aes_crypt_cfb8( &ctx, MBEDTLS_AES_ENCRYPT, src_str->len, iv_str->x, src_str->x, output ) == 0 );
TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x,
src_str->len, dst->len ) == 0 );
exit:
mbedtls_aes_free( &ctx );
}
void test_aes_encrypt_cfb8_wrapper( void ** params )
{
data_t data0 = {(uint8_t *) params[0], *( (uint32_t *) params[1] )};
data_t data2 = {(uint8_t *) params[2], *( (uint32_t *) params[3] )};
data_t data4 = {(uint8_t *) params[4], *( (uint32_t *) params[5] )};
data_t data6 = {(uint8_t *) params[6], *( (uint32_t *) params[7] )};
test_aes_encrypt_cfb8( &data0, &data2, &data4, &data6 );
}
#endif /* MBEDTLS_CIPHER_MODE_CFB */
#if defined(MBEDTLS_CIPHER_MODE_CFB)
void test_aes_decrypt_cfb8( data_t * key_str, data_t * iv_str,
data_t * src_str, data_t * dst )
{
unsigned char output[100];
mbedtls_aes_context ctx;
memset(output, 0x00, 100);
mbedtls_aes_init( &ctx );
mbedtls_aes_setkey_enc( &ctx, key_str->x, key_str->len * 8 );
TEST_ASSERT( mbedtls_aes_crypt_cfb8( &ctx, MBEDTLS_AES_DECRYPT, src_str->len, iv_str->x, src_str->x, output ) == 0 );
TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x,
src_str->len, dst->len ) == 0 );
exit:
mbedtls_aes_free( &ctx );
}
void test_aes_decrypt_cfb8_wrapper( void ** params )
{
data_t data0 = {(uint8_t *) params[0], *( (uint32_t *) params[1] )};
data_t data2 = {(uint8_t *) params[2], *( (uint32_t *) params[3] )};
data_t data4 = {(uint8_t *) params[4], *( (uint32_t *) params[5] )};
data_t data6 = {(uint8_t *) params[6], *( (uint32_t *) params[7] )};
test_aes_decrypt_cfb8( &data0, &data2, &data4, &data6 );
}
#endif /* MBEDTLS_CIPHER_MODE_CFB */
#if defined(MBEDTLS_CIPHER_MODE_OFB)
void test_aes_encrypt_ofb( int fragment_size, data_t *key_str,
data_t *iv_str, data_t *src_str,
data_t *expected_output )
{
unsigned char output[32];
mbedtls_aes_context ctx;
size_t iv_offset = 0;
int in_buffer_len;
unsigned char* src_str_next;
memset( output, 0x00, sizeof( output ) );
mbedtls_aes_init( &ctx );
TEST_ASSERT( (size_t)fragment_size < sizeof( output ) );
TEST_ASSERT( mbedtls_aes_setkey_enc( &ctx, key_str->x,
key_str->len * 8 ) == 0 );
in_buffer_len = src_str->len;
src_str_next = src_str->x;
while( in_buffer_len > 0 )
{
TEST_ASSERT( mbedtls_aes_crypt_ofb( &ctx, fragment_size, &iv_offset,
iv_str->x, src_str_next, output ) == 0 );
TEST_ASSERT( memcmp( output, expected_output->x, fragment_size ) == 0 );
in_buffer_len -= fragment_size;
expected_output->x += fragment_size;
src_str_next += fragment_size;
if( in_buffer_len < fragment_size )
fragment_size = in_buffer_len;
}
exit:
mbedtls_aes_free( &ctx );
}
void test_aes_encrypt_ofb_wrapper( void ** params )
{
data_t data1 = {(uint8_t *) params[1], *( (uint32_t *) params[2] )};
data_t data3 = {(uint8_t *) params[3], *( (uint32_t *) params[4] )};
data_t data5 = {(uint8_t *) params[5], *( (uint32_t *) params[6] )};
data_t data7 = {(uint8_t *) params[7], *( (uint32_t *) params[8] )};
test_aes_encrypt_ofb( *( (int *) params[0] ), &data1, &data3, &data5, &data7 );
}
#endif /* MBEDTLS_CIPHER_MODE_OFB */
#if defined(MBEDTLS_CHECK_PARAMS)
#if !defined(MBEDTLS_PARAM_FAILED_ALT)
void test_aes_check_params( )
{
mbedtls_aes_context aes_ctx;
#if defined(MBEDTLS_CIPHER_MODE_XTS)
mbedtls_aes_xts_context xts_ctx;
#endif
const unsigned char key[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
const unsigned char in[16] = { 0 };
unsigned char out[16];
size_t size;
const int valid_mode = MBEDTLS_AES_ENCRYPT;
const int invalid_mode = 42;
TEST_INVALID_PARAM( mbedtls_aes_init( NULL ) );
#if defined(MBEDTLS_CIPHER_MODE_XTS)
TEST_INVALID_PARAM( mbedtls_aes_xts_init( NULL ) );
#endif
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_setkey_enc( NULL, key, 128 ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_setkey_enc( &aes_ctx, NULL, 128 ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_setkey_dec( NULL, key, 128 ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_setkey_dec( &aes_ctx, NULL, 128 ) );
#if defined(MBEDTLS_CIPHER_MODE_XTS)
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_xts_setkey_enc( NULL, key, 128 ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_xts_setkey_enc( &xts_ctx, NULL, 128 ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_xts_setkey_dec( NULL, key, 128 ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_xts_setkey_dec( &xts_ctx, NULL, 128 ) );
#endif
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_ecb( NULL,
valid_mode, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_ecb( &aes_ctx,
invalid_mode, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_ecb( &aes_ctx,
valid_mode, NULL, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_ecb( &aes_ctx,
valid_mode, in, NULL ) );
#if defined(MBEDTLS_CIPHER_MODE_CBC)
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_cbc( NULL,
valid_mode, 16,
out, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_cbc( &aes_ctx,
invalid_mode, 16,
out, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_cbc( &aes_ctx,
valid_mode, 16,
NULL, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_cbc( &aes_ctx,
valid_mode, 16,
out, NULL, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_cbc( &aes_ctx,
valid_mode, 16,
out, in, NULL ) );
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#if defined(MBEDTLS_CIPHER_MODE_XTS)
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_xts( NULL,
valid_mode, 16,
in, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_xts( &xts_ctx,
invalid_mode, 16,
in, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_xts( &xts_ctx,
valid_mode, 16,
NULL, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_xts( &xts_ctx,
valid_mode, 16,
in, NULL, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_xts( &xts_ctx,
valid_mode, 16,
in, in, NULL ) );
#endif /* MBEDTLS_CIPHER_MODE_XTS */
#if defined(MBEDTLS_CIPHER_MODE_CFB)
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_cfb128( NULL,
valid_mode, 16,
&size, out, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_cfb128( &aes_ctx,
invalid_mode, 16,
&size, out, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_cfb128( &aes_ctx,
valid_mode, 16,
NULL, out, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_cfb128( &aes_ctx,
valid_mode, 16,
&size, NULL, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_cfb128( &aes_ctx,
valid_mode, 16,
&size, out, NULL, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_cfb128( &aes_ctx,
valid_mode, 16,
&size, out, in, NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_cfb8( NULL,
valid_mode, 16,
out, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_cfb8( &aes_ctx,
invalid_mode, 16,
out, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_cfb8( &aes_ctx,
valid_mode, 16,
NULL, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_cfb8( &aes_ctx,
valid_mode, 16,
out, NULL, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_cfb8( &aes_ctx,
valid_mode, 16,
out, in, NULL ) );
#endif /* MBEDTLS_CIPHER_MODE_CFB */
#if defined(MBEDTLS_CIPHER_MODE_OFB)
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_ofb( NULL, 16,
&size, out, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_ofb( &aes_ctx, 16,
NULL, out, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_ofb( &aes_ctx, 16,
&size, NULL, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_ofb( &aes_ctx, 16,
&size, out, NULL, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_ofb( &aes_ctx, 16,
&size, out, in, NULL ) );
#endif /* MBEDTLS_CIPHER_MODE_OFB */
#if defined(MBEDTLS_CIPHER_MODE_CTR)
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_ctr( NULL, 16, &size, out,
out, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_ctr( &aes_ctx, 16, NULL, out,
out, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_ctr( &aes_ctx, 16, &size, NULL,
out, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_ctr( &aes_ctx, 16, &size, out,
NULL, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_ctr( &aes_ctx, 16, &size, out,
out, NULL, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_ctr( &aes_ctx, 16, &size, out,
out, in, NULL ) );
#endif /* MBEDTLS_CIPHER_MODE_CTR */
exit:
;
}
void test_aes_check_params_wrapper( void ** params )
{
(void)params;
test_aes_check_params( );
}
#endif /* !MBEDTLS_PARAM_FAILED_ALT */
#endif /* MBEDTLS_CHECK_PARAMS */
void test_aes_misc_params( )
{
#if defined(MBEDTLS_CIPHER_MODE_CBC) || \
defined(MBEDTLS_CIPHER_MODE_XTS) || \
defined(MBEDTLS_CIPHER_MODE_CFB) || \
defined(MBEDTLS_CIPHER_MODE_OFB)
mbedtls_aes_context aes_ctx;
const unsigned char in[16] = { 0 };
unsigned char out[16];
#endif
#if defined(MBEDTLS_CIPHER_MODE_XTS)
mbedtls_aes_xts_context xts_ctx;
#endif
#if defined(MBEDTLS_CIPHER_MODE_CFB) || \
defined(MBEDTLS_CIPHER_MODE_OFB)
size_t size;
#endif
/* These calls accept NULL */
TEST_VALID_PARAM( mbedtls_aes_free( NULL ) );
#if defined(MBEDTLS_CIPHER_MODE_XTS)
TEST_VALID_PARAM( mbedtls_aes_xts_free( NULL ) );
#endif
#if defined(MBEDTLS_CIPHER_MODE_CBC)
TEST_ASSERT( mbedtls_aes_crypt_cbc( &aes_ctx, MBEDTLS_AES_ENCRYPT,
15,
out, in, out )
== MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH );
TEST_ASSERT( mbedtls_aes_crypt_cbc( &aes_ctx, MBEDTLS_AES_ENCRYPT,
17,
out, in, out )
== MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH );
#endif
#if defined(MBEDTLS_CIPHER_MODE_XTS)
TEST_ASSERT( mbedtls_aes_crypt_xts( &xts_ctx, MBEDTLS_AES_ENCRYPT,
15,
in, in, out )
== MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH );
TEST_ASSERT( mbedtls_aes_crypt_xts( &xts_ctx, MBEDTLS_AES_ENCRYPT,
(1 << 24) + 1,
in, in, out )
== MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH );
#endif
#if defined(MBEDTLS_CIPHER_MODE_CFB)
size = 16;
TEST_ASSERT( mbedtls_aes_crypt_cfb128( &aes_ctx, MBEDTLS_AES_ENCRYPT, 16,
&size, out, in, out )
== MBEDTLS_ERR_AES_BAD_INPUT_DATA );
#endif
#if defined(MBEDTLS_CIPHER_MODE_OFB)
size = 16;
TEST_ASSERT( mbedtls_aes_crypt_ofb( &aes_ctx, 16, &size, out, in, out )
== MBEDTLS_ERR_AES_BAD_INPUT_DATA );
#endif
exit:
;
}
void test_aes_misc_params_wrapper( void ** params )
{
(void)params;
test_aes_misc_params( );
}
#if defined(MBEDTLS_SELF_TEST)
void test_aes_selftest( )
{
TEST_ASSERT( mbedtls_aes_self_test( 1 ) == 0 );
exit:
;
}
void test_aes_selftest_wrapper( void ** params )
{
(void)params;
test_aes_selftest( );
}
#endif /* MBEDTLS_SELF_TEST */
#endif /* MBEDTLS_AES_C */
/*----------------------------------------------------------------------------*/
/* Test dispatch code */
/**
* \brief Evaluates an expression/macro into its literal integer value.
* For optimizing space for embedded targets each expression/macro
* is identified by a unique identifier instead of string literals.
* Identifiers and evaluation code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param exp_id Expression identifier.
* \param out_value Pointer to int to hold the integer.
*
* \return 0 if exp_id is found. 1 otherwise.
*/
int get_expression( int32_t exp_id, int32_t * out_value )
{
int ret = KEY_VALUE_MAPPING_FOUND;
(void) exp_id;
(void) out_value;
switch( exp_id )
{
#if defined(MBEDTLS_AES_C)
#endif
default:
{
ret = KEY_VALUE_MAPPING_NOT_FOUND;
}
break;
}
return( ret );
}
/**
* \brief Checks if the dependency i.e. the compile flag is set.
* For optimizing space for embedded targets each dependency
* is identified by a unique identifier instead of string literals.
* Identifiers and check code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param dep_id Dependency identifier.
*
* \return DEPENDENCY_SUPPORTED if set else DEPENDENCY_NOT_SUPPORTED
*/
int dep_check( int dep_id )
{
int ret = DEPENDENCY_NOT_SUPPORTED;
(void) dep_id;
switch( dep_id )
{
#if defined(MBEDTLS_AES_C)
#endif
default:
break;
}
return( ret );
}
/**
* \brief Function pointer type for test function wrappers.
*
* A test function wrapper decodes the parameters and passes them to the
* underlying test function. Both the wrapper and the underlying function
* return void. Test wrappers assume that they are passed a suitable
* parameter array and do not perform any error detection.
*
* \param param_array The array of parameters. Each element is a `void *`
* which the wrapper casts to the correct type and
* dereferences. Each wrapper function hard-codes the
* number and types of the parameters.
*/
typedef void (*TestWrapper_t)( void **param_array );
/**
* \brief Table of test function wrappers. Used by dispatch_test().
* This table is populated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
*/
TestWrapper_t test_funcs[] =
{
/* Function Id: 0 */
#if defined(MBEDTLS_AES_C)
test_aes_encrypt_ecb_wrapper,
#else
NULL,
#endif
/* Function Id: 1 */
#if defined(MBEDTLS_AES_C)
test_aes_decrypt_ecb_wrapper,
#else
NULL,
#endif
/* Function Id: 2 */
#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_CIPHER_MODE_CBC)
test_aes_encrypt_cbc_wrapper,
#else
NULL,
#endif
/* Function Id: 3 */
#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_CIPHER_MODE_CBC)
test_aes_decrypt_cbc_wrapper,
#else
NULL,
#endif
/* Function Id: 4 */
#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_CIPHER_MODE_XTS)
test_aes_encrypt_xts_wrapper,
#else
NULL,
#endif
/* Function Id: 5 */
#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_CIPHER_MODE_XTS)
test_aes_decrypt_xts_wrapper,
#else
NULL,
#endif
/* Function Id: 6 */
#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_CIPHER_MODE_XTS)
test_aes_crypt_xts_size_wrapper,
#else
NULL,
#endif
/* Function Id: 7 */
#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_CIPHER_MODE_XTS)
test_aes_crypt_xts_keysize_wrapper,
#else
NULL,
#endif
/* Function Id: 8 */
#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_CIPHER_MODE_CFB)
test_aes_encrypt_cfb128_wrapper,
#else
NULL,
#endif
/* Function Id: 9 */
#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_CIPHER_MODE_CFB)
test_aes_decrypt_cfb128_wrapper,
#else
NULL,
#endif
/* Function Id: 10 */
#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_CIPHER_MODE_CFB)
test_aes_encrypt_cfb8_wrapper,
#else
NULL,
#endif
/* Function Id: 11 */
#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_CIPHER_MODE_CFB)
test_aes_decrypt_cfb8_wrapper,
#else
NULL,
#endif
/* Function Id: 12 */
#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_CIPHER_MODE_OFB)
test_aes_encrypt_ofb_wrapper,
#else
NULL,
#endif
/* Function Id: 13 */
#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_CHECK_PARAMS) && !defined(MBEDTLS_PARAM_FAILED_ALT)
test_aes_check_params_wrapper,
#else
NULL,
#endif
/* Function Id: 14 */
#if defined(MBEDTLS_AES_C)
test_aes_misc_params_wrapper,
#else
NULL,
#endif
/* Function Id: 15 */
#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_SELF_TEST)
test_aes_selftest_wrapper,
#else
NULL,
#endif
};
/**
* \brief Execute the test function.
*
* This is a wrapper function around the test function execution
* to allow the setjmp() call used to catch any calls to the
* parameter failure callback, to be used. Calls to setjmp()
* can invalidate the state of any local auto variables.
*
* \param fp Function pointer to the test function.
* \param params Parameters to pass to the #TestWrapper_t wrapper function.
*
*/
void execute_function_ptr(TestWrapper_t fp, void **params)
{
#if defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG)
mbedtls_test_enable_insecure_external_rng( );
#endif
#if defined(MBEDTLS_CHECK_PARAMS)
mbedtls_test_param_failed_location_record_t location_record;
if ( setjmp( mbedtls_test_param_failed_get_state_buf( ) ) == 0 )
{
fp( params );
}
else
{
/* Unexpected parameter validation error */
mbedtls_test_param_failed_get_location_record( &location_record );
mbedtls_test_fail( location_record.failure_condition,
location_record.line,
location_record.file );
}
mbedtls_test_param_failed_reset_state( );
#else
fp( params );
#endif
#if defined(MBEDTLS_TEST_MUTEX_USAGE)
mbedtls_test_mutex_usage_check( );
#endif /* MBEDTLS_TEST_MUTEX_USAGE */
}
/**
* \brief Dispatches test functions based on function index.
*
* \param func_idx Test function index.
* \param params The array of parameters to pass to the test function.
* It will be decoded by the #TestWrapper_t wrapper function.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int dispatch_test( size_t func_idx, void ** params )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof( test_funcs ) / sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp )
execute_function_ptr(fp, params);
else
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
/**
* \brief Checks if test function is supported in this build-time
* configuration.
*
* \param func_idx Test function index.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int check_test( size_t func_idx )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof(test_funcs)/sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp == NULL )
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
int main( int argc, const char *argv[] )
{
int ret;
mbedtls_test_platform_setup();
ret = execute_tests( argc, argv, "/zip/third_party/mbedtls/test/test_suite_aes.cbc.datax" );
mbedtls_test_platform_teardown();
return( ret );
}
| 38,271 | 1,110 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_entropy.c | /* clang-format off */
/*
* Copyright The Mbed TLS Contributors
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "third_party/mbedtls/test/test.inc"
/*
* *** THIS FILE WAS MACHINE GENERATED ***
*
* This file has been machine generated using the script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* Test file : ./test_suite_entropy.c
*
* The following files were used to create this file.
*
* Main code file : suites/main_test.function
* Platform code file : suites/host_test.function
* Helper file : suites/helpers.function
* Test suite file : suites/test_suite_entropy.function
* Test suite data : suites/test_suite_entropy.data
*
*/
#define TEST_SUITE_ACTIVE
#if defined(MBEDTLS_ENTROPY_C)
#include "third_party/mbedtls/entropy.h"
#include "third_party/mbedtls/entropy_poll.h"
#include "third_party/mbedtls/md.h"
typedef enum
{
DUMMY_CONSTANT_LENGTH, /* Output context->length bytes */
DUMMY_REQUESTED_LENGTH, /* Output whatever length was requested */
DUMMY_FAIL, /* Return an error code */
} entropy_dummy_instruction;
typedef struct
{
entropy_dummy_instruction instruction;
size_t length; /* Length to return for DUMMY_CONSTANT_LENGTH */
size_t calls; /* Incremented at each call */
} entropy_dummy_context;
/*
* Dummy entropy source
*
* If data is NULL, write exactly the requested length.
* Otherwise, write the length indicated by data or error if negative
*/
static int entropy_dummy_source( void *arg, unsigned char *output,
size_t len, size_t *olen )
{
entropy_dummy_context *context = arg;
++context->calls;
switch( context->instruction )
{
case DUMMY_CONSTANT_LENGTH:
*olen = context->length;
break;
case DUMMY_REQUESTED_LENGTH:
*olen = len;
break;
case DUMMY_FAIL:
return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
}
memset( output, 0x2a, *olen );
return( 0 );
}
/*
* Ability to clear entropy sources to allow testing with just predefined
* entropy sources. This function or tests depending on it might break if there
* are internal changes to how entropy sources are registered.
*
* To be called immediately after mbedtls_entropy_init().
*
* Just resetting the counter. New sources will overwrite existing ones.
* This might break memory checks in the future if sources need 'free-ing' then
* as well.
*/
static void entropy_clear_sources( mbedtls_entropy_context *ctx )
{
ctx->source_count = 0;
}
#if defined(MBEDTLS_ENTROPY_NV_SEED)
/*
* NV seed read/write functions that use a buffer instead of a file
*/
static unsigned char buffer_seed[MBEDTLS_ENTROPY_BLOCK_SIZE];
int buffer_nv_seed_read( unsigned char *buf, size_t buf_len )
{
if( buf_len != MBEDTLS_ENTROPY_BLOCK_SIZE )
return( -1 );
memcpy( buf, buffer_seed, MBEDTLS_ENTROPY_BLOCK_SIZE );
return( 0 );
}
int buffer_nv_seed_write( unsigned char *buf, size_t buf_len )
{
if( buf_len != MBEDTLS_ENTROPY_BLOCK_SIZE )
return( -1 );
memcpy( buffer_seed, buf, MBEDTLS_ENTROPY_BLOCK_SIZE );
return( 0 );
}
/*
* NV seed read/write helpers that fill the base seedfile
*/
static int write_nv_seed( unsigned char *buf, size_t buf_len )
{
FILE *f;
if( buf_len != MBEDTLS_ENTROPY_BLOCK_SIZE )
return( -1 );
if( ( f = fopen( MBEDTLS_PLATFORM_STD_NV_SEED_FILE, "w" ) ) == NULL )
return( -1 );
if( fwrite( buf, 1, MBEDTLS_ENTROPY_BLOCK_SIZE, f ) !=
MBEDTLS_ENTROPY_BLOCK_SIZE )
return( -1 );
fclose( f );
return( 0 );
}
int read_nv_seed( unsigned char *buf, size_t buf_len )
{
FILE *f;
if( buf_len != MBEDTLS_ENTROPY_BLOCK_SIZE )
return( -1 );
if( ( f = fopen( MBEDTLS_PLATFORM_STD_NV_SEED_FILE, "rb" ) ) == NULL )
return( -1 );
if( fread( buf, 1, MBEDTLS_ENTROPY_BLOCK_SIZE, f ) !=
MBEDTLS_ENTROPY_BLOCK_SIZE )
return( -1 );
fclose( f );
return( 0 );
}
#endif /* MBEDTLS_ENTROPY_NV_SEED */
void test_entropy_init_free( int reinit )
{
mbedtls_entropy_context ctx;
/* Double free is not explicitly documented to work, but it is convenient
* to call mbedtls_entropy_free() unconditionally on an error path without
* checking whether it has already been called in the success path. */
mbedtls_entropy_init( &ctx );
mbedtls_entropy_free( &ctx );
if( reinit )
mbedtls_entropy_init( &ctx );
mbedtls_entropy_free( &ctx );
/* This test case always succeeds, functionally speaking. A plausible
* bug might trigger an invalid pointer dereference or a memory leak. */
goto exit;
exit:
;
}
void test_entropy_init_free_wrapper( void ** params )
{
test_entropy_init_free( *( (int *) params[0] ) );
}
#if defined(MBEDTLS_ENTROPY_NV_SEED)
#if defined(MBEDTLS_FS_IO)
void test_entropy_seed_file( char * path, int ret )
{
mbedtls_entropy_context ctx;
mbedtls_entropy_init( &ctx );
TEST_ASSERT( mbedtls_entropy_write_seed_file( &ctx, path ) == ret );
TEST_ASSERT( mbedtls_entropy_update_seed_file( &ctx, path ) == ret );
exit:
mbedtls_entropy_free( &ctx );
}
void test_entropy_seed_file_wrapper( void ** params )
{
test_entropy_seed_file( (char *) params[0], *( (int *) params[1] ) );
}
#endif /* MBEDTLS_FS_IO */
#endif /* MBEDTLS_ENTROPY_NV_SEED */
void test_entropy_no_sources( )
{
mbedtls_entropy_context ctx;
unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE];
mbedtls_entropy_init( &ctx );
entropy_clear_sources( &ctx );
TEST_EQUAL( mbedtls_entropy_func( &ctx, buf, sizeof( buf ) ),
MBEDTLS_ERR_ENTROPY_NO_SOURCES_DEFINED );
exit:
mbedtls_entropy_free( &ctx );
}
void test_entropy_no_sources_wrapper( void ** params )
{
(void)params;
test_entropy_no_sources( );
}
void test_entropy_too_many_sources( )
{
mbedtls_entropy_context ctx;
size_t i;
entropy_dummy_context dummy = {DUMMY_REQUESTED_LENGTH, 0, 0};
mbedtls_entropy_init( &ctx );
/*
* It's hard to tell precisely when the error will occur,
* since we don't know how many sources were automatically added.
*/
for( i = 0; i < MBEDTLS_ENTROPY_MAX_SOURCES; i++ )
(void) mbedtls_entropy_add_source( &ctx, entropy_dummy_source, &dummy,
16, MBEDTLS_ENTROPY_SOURCE_WEAK );
TEST_ASSERT( mbedtls_entropy_add_source( &ctx, entropy_dummy_source, &dummy,
16, MBEDTLS_ENTROPY_SOURCE_WEAK )
== MBEDTLS_ERR_ENTROPY_MAX_SOURCES );
exit:
mbedtls_entropy_free( &ctx );
}
void test_entropy_too_many_sources_wrapper( void ** params )
{
(void)params;
test_entropy_too_many_sources( );
}
#if defined(ENTROPY_HAVE_STRONG)
void test_entropy_func_len( int len, int ret )
{
mbedtls_entropy_context ctx;
unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE + 10] = { 0 };
unsigned char acc[MBEDTLS_ENTROPY_BLOCK_SIZE + 10] = { 0 };
size_t i, j;
mbedtls_entropy_init( &ctx );
/*
* See comments in mbedtls_entropy_self_test()
*/
for( i = 0; i < 8; i++ )
{
TEST_ASSERT( mbedtls_entropy_func( &ctx, buf, len ) == ret );
for( j = 0; j < sizeof( buf ); j++ )
acc[j] |= buf[j];
}
if( ret == 0 )
for( j = 0; j < (size_t) len; j++ )
TEST_ASSERT( acc[j] != 0 );
for( j = len; j < sizeof( buf ); j++ )
TEST_ASSERT( acc[j] == 0 );
exit:
mbedtls_entropy_free( &ctx );
}
void test_entropy_func_len_wrapper( void ** params )
{
test_entropy_func_len( *( (int *) params[0] ), *( (int *) params[1] ) );
}
#endif /* ENTROPY_HAVE_STRONG */
void test_entropy_source_fail( char * path )
{
mbedtls_entropy_context ctx;
unsigned char buf[16];
entropy_dummy_context dummy = {DUMMY_FAIL, 0, 0};
mbedtls_entropy_init( &ctx );
TEST_ASSERT( mbedtls_entropy_add_source( &ctx, entropy_dummy_source,
&dummy, 16,
MBEDTLS_ENTROPY_SOURCE_WEAK )
== 0 );
TEST_ASSERT( mbedtls_entropy_func( &ctx, buf, sizeof( buf ) )
== MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
TEST_ASSERT( mbedtls_entropy_gather( &ctx )
== MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
#if defined(MBEDTLS_FS_IO) && defined(MBEDTLS_ENTROPY_NV_SEED)
TEST_ASSERT( mbedtls_entropy_write_seed_file( &ctx, path )
== MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
TEST_ASSERT( mbedtls_entropy_update_seed_file( &ctx, path )
== MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
#else
((void) path);
#endif
exit:
mbedtls_entropy_free( &ctx );
}
void test_entropy_source_fail_wrapper( void ** params )
{
test_entropy_source_fail( (char *) params[0] );
}
void test_entropy_threshold( int threshold, int chunk_size, int result )
{
mbedtls_entropy_context ctx;
entropy_dummy_context strong =
{DUMMY_CONSTANT_LENGTH, MBEDTLS_ENTROPY_BLOCK_SIZE, 0};
entropy_dummy_context weak = {DUMMY_CONSTANT_LENGTH, chunk_size, 0};
unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE] = { 0 };
int ret;
mbedtls_entropy_init( &ctx );
entropy_clear_sources( &ctx );
/* Set strong source that reaches its threshold immediately and
* a weak source whose threshold is a test parameter. */
TEST_ASSERT( mbedtls_entropy_add_source( &ctx, entropy_dummy_source,
&strong, 1,
MBEDTLS_ENTROPY_SOURCE_STRONG ) == 0 );
TEST_ASSERT( mbedtls_entropy_add_source( &ctx, entropy_dummy_source,
&weak, threshold,
MBEDTLS_ENTROPY_SOURCE_WEAK ) == 0 );
ret = mbedtls_entropy_func( &ctx, buf, sizeof( buf ) );
if( result >= 0 )
{
TEST_ASSERT( ret == 0 );
#if defined(MBEDTLS_ENTROPY_NV_SEED)
/* If the NV seed functionality is enabled, there are two entropy
* updates: before and after updating the NV seed. */
result *= 2;
#endif
TEST_ASSERT( weak.calls == (size_t) result );
}
else
{
TEST_ASSERT( ret == result );
}
exit:
mbedtls_entropy_free( &ctx );
}
void test_entropy_threshold_wrapper( void ** params )
{
test_entropy_threshold( *( (int *) params[0] ), *( (int *) params[1] ), *( (int *) params[2] ) );
}
void test_entropy_calls( int strength1, int strength2,
int threshold, int chunk_size,
int result )
{
/*
* if result >= 0: result = expected number of calls to source 1
* if result < 0: result = expected return code from mbedtls_entropy_func()
*/
mbedtls_entropy_context ctx;
entropy_dummy_context dummy1 = {DUMMY_CONSTANT_LENGTH, chunk_size, 0};
entropy_dummy_context dummy2 = {DUMMY_CONSTANT_LENGTH, chunk_size, 0};
unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE] = { 0 };
int ret;
mbedtls_entropy_init( &ctx );
entropy_clear_sources( &ctx );
TEST_ASSERT( mbedtls_entropy_add_source( &ctx, entropy_dummy_source,
&dummy1, threshold,
strength1 ) == 0 );
TEST_ASSERT( mbedtls_entropy_add_source( &ctx, entropy_dummy_source,
&dummy2, threshold,
strength2 ) == 0 );
ret = mbedtls_entropy_func( &ctx, buf, sizeof( buf ) );
if( result >= 0 )
{
TEST_ASSERT( ret == 0 );
#if defined(MBEDTLS_ENTROPY_NV_SEED)
/* If the NV seed functionality is enabled, there are two entropy
* updates: before and after updating the NV seed. */
result *= 2;
#endif
TEST_ASSERT( dummy1.calls == (size_t) result );
}
else
{
TEST_ASSERT( ret == result );
}
exit:
mbedtls_entropy_free( &ctx );
}
void test_entropy_calls_wrapper( void ** params )
{
test_entropy_calls( *( (int *) params[0] ), *( (int *) params[1] ), *( (int *) params[2] ), *( (int *) params[3] ), *( (int *) params[4] ) );
}
#if defined(MBEDTLS_ENTROPY_NV_SEED)
#if defined(MBEDTLS_FS_IO)
void test_nv_seed_file_create( )
{
unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE];
memset( buf, 0, MBEDTLS_ENTROPY_BLOCK_SIZE );
TEST_ASSERT( write_nv_seed( buf, MBEDTLS_ENTROPY_BLOCK_SIZE ) == 0 );
exit:
;
}
void test_nv_seed_file_create_wrapper( void ** params )
{
(void)params;
test_nv_seed_file_create( );
}
#endif /* MBEDTLS_FS_IO */
#endif /* MBEDTLS_ENTROPY_NV_SEED */
#if defined(MBEDTLS_ENTROPY_NV_SEED)
#if defined(MBEDTLS_FS_IO)
#if defined(MBEDTLS_PLATFORM_NV_SEED_ALT)
void test_entropy_nv_seed_std_io( )
{
unsigned char io_seed[MBEDTLS_ENTROPY_BLOCK_SIZE];
unsigned char check_seed[MBEDTLS_ENTROPY_BLOCK_SIZE];
memset( io_seed, 1, MBEDTLS_ENTROPY_BLOCK_SIZE );
memset( check_seed, 0, MBEDTLS_ENTROPY_BLOCK_SIZE );
mbedtls_platform_set_nv_seed( mbedtls_platform_std_nv_seed_read,
mbedtls_platform_std_nv_seed_write );
/* Check if platform NV read and write manipulate the same data */
TEST_ASSERT( write_nv_seed( io_seed, MBEDTLS_ENTROPY_BLOCK_SIZE ) == 0 );
TEST_ASSERT( mbedtls_nv_seed_read( check_seed, MBEDTLS_ENTROPY_BLOCK_SIZE ) ==
MBEDTLS_ENTROPY_BLOCK_SIZE );
TEST_ASSERT( memcmp( io_seed, check_seed, MBEDTLS_ENTROPY_BLOCK_SIZE ) == 0 );
memset( check_seed, 0, MBEDTLS_ENTROPY_BLOCK_SIZE );
/* Check if platform NV write and raw read manipulate the same data */
TEST_ASSERT( mbedtls_nv_seed_write( io_seed, MBEDTLS_ENTROPY_BLOCK_SIZE ) ==
MBEDTLS_ENTROPY_BLOCK_SIZE );
TEST_ASSERT( read_nv_seed( check_seed, MBEDTLS_ENTROPY_BLOCK_SIZE ) == 0 );
TEST_ASSERT( memcmp( io_seed, check_seed, MBEDTLS_ENTROPY_BLOCK_SIZE ) == 0 );
exit:
;
}
void test_entropy_nv_seed_std_io_wrapper( void ** params )
{
(void)params;
test_entropy_nv_seed_std_io( );
}
#endif /* MBEDTLS_PLATFORM_NV_SEED_ALT */
#endif /* MBEDTLS_FS_IO */
#endif /* MBEDTLS_ENTROPY_NV_SEED */
#if defined(MBEDTLS_MD_C)
#if defined(MBEDTLS_ENTROPY_NV_SEED)
#if defined(MBEDTLS_PLATFORM_NV_SEED_ALT)
void test_entropy_nv_seed( data_t * read_seed )
{
#if defined(MBEDTLS_ENTROPY_SHA512_ACCUMULATOR)
const mbedtls_md_info_t *md_info =
mbedtls_md_info_from_type( MBEDTLS_MD_SHA512 );
#elif defined(MBEDTLS_ENTROPY_SHA256_ACCUMULATOR)
const mbedtls_md_info_t *md_info =
mbedtls_md_info_from_type( MBEDTLS_MD_SHA256 );
#else
#error "Unsupported entropy accumulator"
#endif
mbedtls_md_context_t accumulator;
mbedtls_entropy_context ctx;
int (*original_mbedtls_nv_seed_read)( unsigned char *buf, size_t buf_len ) =
mbedtls_nv_seed_read;
int (*original_mbedtls_nv_seed_write)( unsigned char *buf, size_t buf_len ) =
mbedtls_nv_seed_write;
unsigned char header[2];
unsigned char entropy[MBEDTLS_ENTROPY_BLOCK_SIZE];
unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE];
unsigned char empty[MBEDTLS_ENTROPY_BLOCK_SIZE];
unsigned char check_seed[MBEDTLS_ENTROPY_BLOCK_SIZE];
unsigned char check_entropy[MBEDTLS_ENTROPY_BLOCK_SIZE];
memset( entropy, 0, MBEDTLS_ENTROPY_BLOCK_SIZE );
memset( buf, 0, MBEDTLS_ENTROPY_BLOCK_SIZE );
memset( empty, 0, MBEDTLS_ENTROPY_BLOCK_SIZE );
memset( check_seed, 2, MBEDTLS_ENTROPY_BLOCK_SIZE );
memset( check_entropy, 3, MBEDTLS_ENTROPY_BLOCK_SIZE );
// Make sure we read/write NV seed from our buffers
mbedtls_platform_set_nv_seed( buffer_nv_seed_read, buffer_nv_seed_write );
mbedtls_md_init( &accumulator );
mbedtls_entropy_init( &ctx );
entropy_clear_sources( &ctx );
TEST_ASSERT( mbedtls_entropy_add_source( &ctx, mbedtls_nv_seed_poll, NULL,
MBEDTLS_ENTROPY_BLOCK_SIZE,
MBEDTLS_ENTROPY_SOURCE_STRONG ) == 0 );
// Set the initial NV seed to read
TEST_ASSERT( read_seed->len >= MBEDTLS_ENTROPY_BLOCK_SIZE );
memcpy( buffer_seed, read_seed->x, MBEDTLS_ENTROPY_BLOCK_SIZE );
// Do an entropy run
TEST_ASSERT( mbedtls_entropy_func( &ctx, entropy, sizeof( entropy ) ) == 0 );
// Determine what should have happened with manual entropy internal logic
// Init accumulator
header[1] = MBEDTLS_ENTROPY_BLOCK_SIZE;
TEST_ASSERT( mbedtls_md_setup( &accumulator, md_info, 0 ) == 0 );
// First run for updating write_seed
header[0] = 0;
TEST_ASSERT( mbedtls_md_starts( &accumulator ) == 0 );
TEST_ASSERT( mbedtls_md_update( &accumulator, header, 2 ) == 0 );
TEST_ASSERT( mbedtls_md_update( &accumulator,
read_seed->x, MBEDTLS_ENTROPY_BLOCK_SIZE ) == 0 );
TEST_ASSERT( mbedtls_md_finish( &accumulator, buf ) == 0 );
TEST_ASSERT( mbedtls_md_starts( &accumulator ) == 0 );
TEST_ASSERT( mbedtls_md_update( &accumulator,
buf, MBEDTLS_ENTROPY_BLOCK_SIZE ) == 0 );
TEST_ASSERT( mbedtls_md( md_info, buf, MBEDTLS_ENTROPY_BLOCK_SIZE,
check_seed ) == 0 );
// Second run for actual entropy (triggers mbedtls_entropy_update_nv_seed)
header[0] = MBEDTLS_ENTROPY_SOURCE_MANUAL;
TEST_ASSERT( mbedtls_md_update( &accumulator, header, 2 ) == 0 );
TEST_ASSERT( mbedtls_md_update( &accumulator,
empty, MBEDTLS_ENTROPY_BLOCK_SIZE ) == 0 );
header[0] = 0;
TEST_ASSERT( mbedtls_md_update( &accumulator, header, 2 ) == 0 );
TEST_ASSERT( mbedtls_md_update( &accumulator,
check_seed, MBEDTLS_ENTROPY_BLOCK_SIZE ) == 0 );
TEST_ASSERT( mbedtls_md_finish( &accumulator, buf ) == 0 );
TEST_ASSERT( mbedtls_md( md_info, buf, MBEDTLS_ENTROPY_BLOCK_SIZE,
check_entropy ) == 0 );
// Check result of both NV file and entropy received with the manual calculations
TEST_ASSERT( memcmp( check_seed, buffer_seed, MBEDTLS_ENTROPY_BLOCK_SIZE ) == 0 );
TEST_ASSERT( memcmp( check_entropy, entropy, MBEDTLS_ENTROPY_BLOCK_SIZE ) == 0 );
exit:
mbedtls_md_free( &accumulator );
mbedtls_entropy_free( &ctx );
mbedtls_nv_seed_read = original_mbedtls_nv_seed_read;
mbedtls_nv_seed_write = original_mbedtls_nv_seed_write;
}
void test_entropy_nv_seed_wrapper( void ** params )
{
data_t data0 = {(uint8_t *) params[0], *( (uint32_t *) params[1] )};
test_entropy_nv_seed( &data0 );
}
#endif /* MBEDTLS_PLATFORM_NV_SEED_ALT */
#endif /* MBEDTLS_ENTROPY_NV_SEED */
#endif /* MBEDTLS_MD_C */
#if defined(ENTROPY_HAVE_STRONG)
#if defined(MBEDTLS_SELF_TEST)
void test_entropy_selftest( int result )
{
TEST_ASSERT( mbedtls_entropy_self_test( 1 ) == result );
exit:
;
}
void test_entropy_selftest_wrapper( void ** params )
{
test_entropy_selftest( *( (int *) params[0] ) );
}
#endif /* MBEDTLS_SELF_TEST */
#endif /* ENTROPY_HAVE_STRONG */
#endif /* MBEDTLS_ENTROPY_C */
/*----------------------------------------------------------------------------*/
/* Test dispatch code */
/**
* \brief Evaluates an expression/macro into its literal integer value.
* For optimizing space for embedded targets each expression/macro
* is identified by a unique identifier instead of string literals.
* Identifiers and evaluation code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param exp_id Expression identifier.
* \param out_value Pointer to int to hold the integer.
*
* \return 0 if exp_id is found. 1 otherwise.
*/
int get_expression( int32_t exp_id, int32_t * out_value )
{
int ret = KEY_VALUE_MAPPING_FOUND;
(void) exp_id;
(void) out_value;
switch( exp_id )
{
#if defined(MBEDTLS_ENTROPY_C)
case 0:
{
*out_value = MBEDTLS_ERR_ENTROPY_FILE_IO_ERROR;
}
break;
case 1:
{
*out_value = MBEDTLS_ERR_ENTROPY_SOURCE_FAILED;
}
break;
case 2:
{
*out_value = MBEDTLS_ENTROPY_SOURCE_WEAK;
}
break;
case 3:
{
*out_value = MBEDTLS_ENTROPY_BLOCK_SIZE;
}
break;
case 4:
{
*out_value = MBEDTLS_ERR_ENTROPY_NO_STRONG_SOURCE;
}
break;
case 5:
{
*out_value = MBEDTLS_ENTROPY_SOURCE_STRONG;
}
break;
case 6:
{
*out_value = (MBEDTLS_ENTROPY_BLOCK_SIZE+1)/2;
}
break;
case 7:
{
*out_value = MBEDTLS_ENTROPY_BLOCK_SIZE+1;
}
break;
#endif
default:
{
ret = KEY_VALUE_MAPPING_NOT_FOUND;
}
break;
}
return( ret );
}
/**
* \brief Checks if the dependency i.e. the compile flag is set.
* For optimizing space for embedded targets each dependency
* is identified by a unique identifier instead of string literals.
* Identifiers and check code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param dep_id Dependency identifier.
*
* \return DEPENDENCY_SUPPORTED if set else DEPENDENCY_NOT_SUPPORTED
*/
int dep_check( int dep_id )
{
int ret = DEPENDENCY_NOT_SUPPORTED;
(void) dep_id;
switch( dep_id )
{
#if defined(MBEDTLS_ENTROPY_C)
case 0:
{
#if !defined(MBEDTLS_TEST_NULL_ENTROPY)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 1:
{
#if defined(MBEDTLS_TEST_NULL_ENTROPY)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
#endif
default:
break;
}
return( ret );
}
/**
* \brief Function pointer type for test function wrappers.
*
* A test function wrapper decodes the parameters and passes them to the
* underlying test function. Both the wrapper and the underlying function
* return void. Test wrappers assume that they are passed a suitable
* parameter array and do not perform any error detection.
*
* \param param_array The array of parameters. Each element is a `void *`
* which the wrapper casts to the correct type and
* dereferences. Each wrapper function hard-codes the
* number and types of the parameters.
*/
typedef void (*TestWrapper_t)( void **param_array );
/**
* \brief Table of test function wrappers. Used by dispatch_test().
* This table is populated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
*/
TestWrapper_t test_funcs[] =
{
/* Function Id: 0 */
#if defined(MBEDTLS_ENTROPY_C)
test_entropy_init_free_wrapper,
#else
NULL,
#endif
/* Function Id: 1 */
#if defined(MBEDTLS_ENTROPY_C) && defined(MBEDTLS_ENTROPY_NV_SEED) && defined(MBEDTLS_FS_IO)
test_entropy_seed_file_wrapper,
#else
NULL,
#endif
/* Function Id: 2 */
#if defined(MBEDTLS_ENTROPY_C)
test_entropy_no_sources_wrapper,
#else
NULL,
#endif
/* Function Id: 3 */
#if defined(MBEDTLS_ENTROPY_C)
test_entropy_too_many_sources_wrapper,
#else
NULL,
#endif
/* Function Id: 4 */
#if defined(MBEDTLS_ENTROPY_C) && defined(ENTROPY_HAVE_STRONG)
test_entropy_func_len_wrapper,
#else
NULL,
#endif
/* Function Id: 5 */
#if defined(MBEDTLS_ENTROPY_C)
test_entropy_source_fail_wrapper,
#else
NULL,
#endif
/* Function Id: 6 */
#if defined(MBEDTLS_ENTROPY_C)
test_entropy_threshold_wrapper,
#else
NULL,
#endif
/* Function Id: 7 */
#if defined(MBEDTLS_ENTROPY_C)
test_entropy_calls_wrapper,
#else
NULL,
#endif
/* Function Id: 8 */
#if defined(MBEDTLS_ENTROPY_C) && defined(MBEDTLS_ENTROPY_NV_SEED) && defined(MBEDTLS_FS_IO)
test_nv_seed_file_create_wrapper,
#else
NULL,
#endif
/* Function Id: 9 */
#if defined(MBEDTLS_ENTROPY_C) && defined(MBEDTLS_ENTROPY_NV_SEED) && defined(MBEDTLS_FS_IO) && defined(MBEDTLS_PLATFORM_NV_SEED_ALT)
test_entropy_nv_seed_std_io_wrapper,
#else
NULL,
#endif
/* Function Id: 10 */
#if defined(MBEDTLS_ENTROPY_C) && defined(MBEDTLS_MD_C) && defined(MBEDTLS_ENTROPY_NV_SEED) && defined(MBEDTLS_PLATFORM_NV_SEED_ALT)
test_entropy_nv_seed_wrapper,
#else
NULL,
#endif
/* Function Id: 11 */
#if defined(MBEDTLS_ENTROPY_C) && defined(ENTROPY_HAVE_STRONG) && defined(MBEDTLS_SELF_TEST)
test_entropy_selftest_wrapper,
#else
NULL,
#endif
};
/**
* \brief Execute the test function.
*
* This is a wrapper function around the test function execution
* to allow the setjmp() call used to catch any calls to the
* parameter failure callback, to be used. Calls to setjmp()
* can invalidate the state of any local auto variables.
*
* \param fp Function pointer to the test function.
* \param params Parameters to pass to the #TestWrapper_t wrapper function.
*
*/
void execute_function_ptr(TestWrapper_t fp, void **params)
{
#if defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG)
mbedtls_test_enable_insecure_external_rng( );
#endif
#if defined(MBEDTLS_CHECK_PARAMS)
mbedtls_test_param_failed_location_record_t location_record;
if ( setjmp( mbedtls_test_param_failed_get_state_buf( ) ) == 0 )
{
fp( params );
}
else
{
/* Unexpected parameter validation error */
mbedtls_test_param_failed_get_location_record( &location_record );
mbedtls_test_fail( location_record.failure_condition,
location_record.line,
location_record.file );
}
mbedtls_test_param_failed_reset_state( );
#else
fp( params );
#endif
#if defined(MBEDTLS_TEST_MUTEX_USAGE)
mbedtls_test_mutex_usage_check( );
#endif /* MBEDTLS_TEST_MUTEX_USAGE */
}
/**
* \brief Dispatches test functions based on function index.
*
* \param func_idx Test function index.
* \param params The array of parameters to pass to the test function.
* It will be decoded by the #TestWrapper_t wrapper function.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int dispatch_test( size_t func_idx, void ** params )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof( test_funcs ) / sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp )
execute_function_ptr(fp, params);
else
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
/**
* \brief Checks if test function is supported in this build-time
* configuration.
*
* \param func_idx Test function index.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int check_test( size_t func_idx )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof(test_funcs)/sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp == NULL )
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
int main( int argc, const char *argv[] )
{
int ret;
mbedtls_test_platform_setup();
ret = execute_tests( argc, argv, "/zip/third_party/mbedtls/test/test_suite_entropy.datax" );
mbedtls_test_platform_teardown();
return( ret );
}
| 28,999 | 976 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_memory_buffer_alloc.c | /* clang-format off */
/*
* Copyright The Mbed TLS Contributors
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "third_party/mbedtls/test/test.inc"
/*
* *** THIS FILE WAS MACHINE GENERATED ***
*
* This file has been machine generated using the script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* Test file : ./test_suite_memory_buffer_alloc.c
*
* The following files were used to create this file.
*
* Main code file : suites/main_test.function
* Platform code file : suites/host_test.function
* Helper file : suites/helpers.function
* Test suite file : suites/test_suite_memory_buffer_alloc.function
* Test suite data : suites/test_suite_memory_buffer_alloc.data
*
*/
#define TEST_SUITE_ACTIVE
#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
#include "third_party/mbedtls/memory_buffer_alloc.h"
#define TEST_SUITE_MEMORY_BUFFER_ALLOC
static int check_pointer( void *p )
{
if( p == NULL )
return( -1 );
if( (size_t) p % MBEDTLS_MEMORY_ALIGN_MULTIPLE != 0 )
return( -1 );
return( 0 );
}
#if defined(MBEDTLS_SELF_TEST)
void test_mbedtls_memory_buffer_alloc_self_test( )
{
TEST_ASSERT( mbedtls_memory_buffer_alloc_self_test( 1 ) == 0 );
exit:
;
}
void test_mbedtls_memory_buffer_alloc_self_test_wrapper( void ** params )
{
(void)params;
test_mbedtls_memory_buffer_alloc_self_test( );
}
#endif /* MBEDTLS_SELF_TEST */
void test_memory_buffer_alloc_free_alloc( int a_bytes, int b_bytes, int c_bytes,
int d_bytes, int free_a, int free_b,
int free_c, int free_d, int e_bytes,
int f_bytes )
{
unsigned char buf[1024];
unsigned char *ptr_a = NULL, *ptr_b = NULL, *ptr_c = NULL, *ptr_d = NULL,
*ptr_e = NULL, *ptr_f = NULL;
#if defined(MBEDTLS_MEMORY_DEBUG)
size_t reported_blocks;
size_t reported_bytes;
#endif
size_t allocated_bytes = 0;
mbedtls_memory_buffer_alloc_init( buf, sizeof( buf ) );
mbedtls_memory_buffer_set_verify( MBEDTLS_MEMORY_VERIFY_ALWAYS );
if( a_bytes > 0 )
{
ptr_a = mbedtls_calloc( a_bytes, sizeof(char) );
TEST_ASSERT( check_pointer( ptr_a ) == 0 );
allocated_bytes += a_bytes * sizeof(char);
}
if( b_bytes > 0 )
{
ptr_b = mbedtls_calloc( b_bytes, sizeof(char) );
TEST_ASSERT( check_pointer( ptr_b ) == 0 );
allocated_bytes += b_bytes * sizeof(char);
}
if( c_bytes > 0 )
{
ptr_c = mbedtls_calloc( c_bytes, sizeof(char) );
TEST_ASSERT( check_pointer( ptr_c ) == 0 );
allocated_bytes += c_bytes * sizeof(char);
}
if( d_bytes > 0 )
{
ptr_d = mbedtls_calloc( d_bytes, sizeof(char) );
TEST_ASSERT( check_pointer( ptr_d ) == 0 );
allocated_bytes += d_bytes * sizeof(char);
}
#if defined(MBEDTLS_MEMORY_DEBUG)
mbedtls_memory_buffer_alloc_cur_get( &reported_bytes, &reported_blocks );
TEST_ASSERT( reported_bytes == allocated_bytes );
#endif
if( free_a )
{
mbedtls_free( ptr_a );
ptr_a = NULL;
TEST_ASSERT( mbedtls_memory_buffer_alloc_verify() == 0 );
allocated_bytes -= a_bytes * sizeof(char);
}
if( free_b )
{
mbedtls_free( ptr_b );
ptr_b = NULL;
TEST_ASSERT( mbedtls_memory_buffer_alloc_verify() == 0 );
allocated_bytes -= b_bytes * sizeof(char);
}
if( free_c )
{
mbedtls_free( ptr_c );
ptr_c = NULL;
TEST_ASSERT( mbedtls_memory_buffer_alloc_verify() == 0 );
allocated_bytes -= c_bytes * sizeof(char);
}
if( free_d )
{
mbedtls_free( ptr_d );
ptr_d = NULL;
TEST_ASSERT( mbedtls_memory_buffer_alloc_verify() == 0 );
allocated_bytes -= d_bytes * sizeof(char);
}
#if defined(MBEDTLS_MEMORY_DEBUG)
mbedtls_memory_buffer_alloc_cur_get( &reported_bytes, &reported_blocks );
TEST_ASSERT( reported_bytes == allocated_bytes );
#endif
if( e_bytes > 0 )
{
ptr_e = mbedtls_calloc( e_bytes, sizeof(char) );
TEST_ASSERT( check_pointer( ptr_e ) == 0 );
}
if( f_bytes > 0 )
{
ptr_f = mbedtls_calloc( f_bytes, sizeof(char) );
TEST_ASSERT( check_pointer( ptr_f ) == 0 );
}
/* Once blocks are reallocated, the block allocated to the memory request
* may be bigger than the request itself, which is indicated by the reported
* bytes, and makes it hard to know what the reported size will be, so
* we don't check the size after blocks have been reallocated. */
if( ptr_a != NULL )
{
mbedtls_free( ptr_a );
ptr_a = NULL;
TEST_ASSERT( mbedtls_memory_buffer_alloc_verify() == 0 );
}
if( ptr_b != NULL )
{
mbedtls_free( ptr_b );
ptr_b = NULL;
TEST_ASSERT( mbedtls_memory_buffer_alloc_verify() == 0 );
}
if( ptr_c != NULL )
{
mbedtls_free( ptr_c );
ptr_c = NULL;
TEST_ASSERT( mbedtls_memory_buffer_alloc_verify() == 0 );
}
if( ptr_d != NULL )
{
mbedtls_free( ptr_d );
ptr_d = NULL;
TEST_ASSERT( mbedtls_memory_buffer_alloc_verify() == 0 );
}
if( ptr_e != NULL )
{
mbedtls_free( ptr_e );
ptr_e = NULL;
TEST_ASSERT( mbedtls_memory_buffer_alloc_verify() == 0 );
}
if( ptr_f != NULL )
{
mbedtls_free( ptr_f );
ptr_f = NULL;
}
#if defined(MBEDTLS_MEMORY_DEBUG)
mbedtls_memory_buffer_alloc_cur_get( &reported_bytes, &reported_blocks );
TEST_ASSERT( reported_bytes == 0 );
#endif
TEST_ASSERT( mbedtls_memory_buffer_alloc_verify() == 0 );
exit:
mbedtls_memory_buffer_alloc_free( );
}
void test_memory_buffer_alloc_free_alloc_wrapper( void ** params )
{
test_memory_buffer_alloc_free_alloc( *( (int *) params[0] ), *( (int *) params[1] ), *( (int *) params[2] ), *( (int *) params[3] ), *( (int *) params[4] ), *( (int *) params[5] ), *( (int *) params[6] ), *( (int *) params[7] ), *( (int *) params[8] ), *( (int *) params[9] ) );
}
void test_memory_buffer_alloc_oom_test( )
{
unsigned char buf[1024];
unsigned char *ptr_a = NULL, *ptr_b = NULL, *ptr_c = NULL;
#if defined(MBEDTLS_MEMORY_DEBUG)
size_t reported_blocks, reported_bytes;
#endif
(void)ptr_c;
mbedtls_memory_buffer_alloc_init( buf, sizeof( buf ) );
mbedtls_memory_buffer_set_verify( MBEDTLS_MEMORY_VERIFY_ALWAYS );
ptr_a = mbedtls_calloc( 432, sizeof(char) );
TEST_ASSERT( check_pointer( ptr_a ) == 0 );
ptr_b = mbedtls_calloc( 432, sizeof(char) );
TEST_ASSERT( check_pointer( ptr_b ) == 0 );
ptr_c = mbedtls_calloc( 431, sizeof(char) );
TEST_ASSERT( ptr_c == NULL );
#if defined(MBEDTLS_MEMORY_DEBUG)
mbedtls_memory_buffer_alloc_cur_get( &reported_bytes, &reported_blocks );
TEST_ASSERT( reported_bytes >= 864 && reported_bytes <= sizeof(buf) );
#endif
mbedtls_free( ptr_a );
ptr_a = NULL;
TEST_ASSERT( mbedtls_memory_buffer_alloc_verify() == 0 );
mbedtls_free( ptr_b );
ptr_b = NULL;
TEST_ASSERT( mbedtls_memory_buffer_alloc_verify() == 0 );
#if defined(MBEDTLS_MEMORY_DEBUG)
mbedtls_memory_buffer_alloc_cur_get( &reported_bytes, &reported_blocks );
TEST_ASSERT( reported_bytes == 0 );
#endif
TEST_ASSERT( mbedtls_memory_buffer_alloc_verify() == 0 );
exit:
mbedtls_memory_buffer_alloc_free( );
}
void test_memory_buffer_alloc_oom_test_wrapper( void ** params )
{
(void)params;
test_memory_buffer_alloc_oom_test( );
}
void test_memory_buffer_heap_too_small( )
{
unsigned char buf[1];
mbedtls_memory_buffer_alloc_init( buf, sizeof( buf ) );
/* With MBEDTLS_MEMORY_DEBUG enabled, this prints a message
* "FATAL: verification of first header failed".
*/
TEST_ASSERT( mbedtls_memory_buffer_alloc_verify() != 0 );
exit:
;
}
void test_memory_buffer_heap_too_small_wrapper( void ** params )
{
(void)params;
test_memory_buffer_heap_too_small( );
}
void test_memory_buffer_underalloc( )
{
unsigned char buf[100];
size_t i;
mbedtls_memory_buffer_alloc_init( buf, sizeof( buf ) );
for( i = 1; i < MBEDTLS_MEMORY_ALIGN_MULTIPLE; i++ )
{
TEST_ASSERT( mbedtls_calloc( 1,
(size_t)-( MBEDTLS_MEMORY_ALIGN_MULTIPLE - i ) ) == NULL );
TEST_ASSERT( mbedtls_memory_buffer_alloc_verify() == 0 );
}
exit:
mbedtls_memory_buffer_alloc_free();
}
void test_memory_buffer_underalloc_wrapper( void ** params )
{
(void)params;
test_memory_buffer_underalloc( );
}
#endif /* MBEDTLS_MEMORY_BUFFER_ALLOC_C */
/*----------------------------------------------------------------------------*/
/* Test dispatch code */
/**
* \brief Evaluates an expression/macro into its literal integer value.
* For optimizing space for embedded targets each expression/macro
* is identified by a unique identifier instead of string literals.
* Identifiers and evaluation code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param exp_id Expression identifier.
* \param out_value Pointer to int to hold the integer.
*
* \return 0 if exp_id is found. 1 otherwise.
*/
int get_expression( int32_t exp_id, int32_t * out_value )
{
int ret = KEY_VALUE_MAPPING_FOUND;
(void) exp_id;
(void) out_value;
switch( exp_id )
{
#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
#endif
default:
{
ret = KEY_VALUE_MAPPING_NOT_FOUND;
}
break;
}
return( ret );
}
/**
* \brief Checks if the dependency i.e. the compile flag is set.
* For optimizing space for embedded targets each dependency
* is identified by a unique identifier instead of string literals.
* Identifiers and check code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param dep_id Dependency identifier.
*
* \return DEPENDENCY_SUPPORTED if set else DEPENDENCY_NOT_SUPPORTED
*/
int dep_check( int dep_id )
{
int ret = DEPENDENCY_NOT_SUPPORTED;
(void) dep_id;
switch( dep_id )
{
#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
#endif
default:
break;
}
return( ret );
}
/**
* \brief Function pointer type for test function wrappers.
*
* A test function wrapper decodes the parameters and passes them to the
* underlying test function. Both the wrapper and the underlying function
* return void. Test wrappers assume that they are passed a suitable
* parameter array and do not perform any error detection.
*
* \param param_array The array of parameters. Each element is a `void *`
* which the wrapper casts to the correct type and
* dereferences. Each wrapper function hard-codes the
* number and types of the parameters.
*/
typedef void (*TestWrapper_t)( void **param_array );
/**
* \brief Table of test function wrappers. Used by dispatch_test().
* This table is populated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
*/
TestWrapper_t test_funcs[] =
{
/* Function Id: 0 */
#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C) && defined(MBEDTLS_SELF_TEST)
test_mbedtls_memory_buffer_alloc_self_test_wrapper,
#else
NULL,
#endif
/* Function Id: 1 */
#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
test_memory_buffer_alloc_free_alloc_wrapper,
#else
NULL,
#endif
/* Function Id: 2 */
#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
test_memory_buffer_alloc_oom_test_wrapper,
#else
NULL,
#endif
/* Function Id: 3 */
#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
test_memory_buffer_heap_too_small_wrapper,
#else
NULL,
#endif
/* Function Id: 4 */
#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
test_memory_buffer_underalloc_wrapper,
#else
NULL,
#endif
};
/**
* \brief Execute the test function.
*
* This is a wrapper function around the test function execution
* to allow the setjmp() call used to catch any calls to the
* parameter failure callback, to be used. Calls to setjmp()
* can invalidate the state of any local auto variables.
*
* \param fp Function pointer to the test function.
* \param params Parameters to pass to the #TestWrapper_t wrapper function.
*
*/
void execute_function_ptr(TestWrapper_t fp, void **params)
{
#if defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG)
mbedtls_test_enable_insecure_external_rng( );
#endif
#if defined(MBEDTLS_CHECK_PARAMS)
mbedtls_test_param_failed_location_record_t location_record;
if ( setjmp( mbedtls_test_param_failed_get_state_buf( ) ) == 0 )
{
fp( params );
}
else
{
/* Unexpected parameter validation error */
mbedtls_test_param_failed_get_location_record( &location_record );
mbedtls_test_fail( location_record.failure_condition,
location_record.line,
location_record.file );
}
mbedtls_test_param_failed_reset_state( );
#else
fp( params );
#endif
#if defined(MBEDTLS_TEST_MUTEX_USAGE)
mbedtls_test_mutex_usage_check( );
#endif /* MBEDTLS_TEST_MUTEX_USAGE */
}
/**
* \brief Dispatches test functions based on function index.
*
* \param func_idx Test function index.
* \param params The array of parameters to pass to the test function.
* It will be decoded by the #TestWrapper_t wrapper function.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int dispatch_test( size_t func_idx, void ** params )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof( test_funcs ) / sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp )
execute_function_ptr(fp, params);
else
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
/**
* \brief Checks if test function is supported in this build-time
* configuration.
*
* \param func_idx Test function index.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int check_test( size_t func_idx )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof(test_funcs)/sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp == NULL )
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
int main( int argc, const char *argv[] )
{
int ret;
mbedtls_test_platform_setup();
ret = execute_tests( argc, argv, "/zip/third_party/mbedtls/test/test_suite_memory_buffer_alloc.datax" );
mbedtls_test_platform_teardown();
return( ret );
}
| 16,071 | 584 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_error.datax | Single low error
depends_on:0
0:exp:0:char*:"AES - Invalid key length"
Single high error
depends_on:1
0:exp:1:char*:"RSA - Bad input parameters to function"
Low and high error
depends_on:0:1
0:exp:2:char*:"RSA - Bad input parameters to function \: AES - Invalid key length"
Non existing high error
0:exp:3:char*:"UNKNOWN ERROR CODE (8880)"
Non existing low error
0:exp:4:char*:"UNKNOWN ERROR CODE (007F)"
Non existing low and high error
0:exp:5:char*:"UNKNOWN ERROR CODE (8880) \: UNKNOWN ERROR CODE (007F)"
| 514 | 22 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_pkparse.c | /* clang-format off */
/*
* Copyright The Mbed TLS Contributors
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "third_party/mbedtls/test/test.inc"
/*
* *** THIS FILE WAS MACHINE GENERATED ***
*
* This file has been machine generated using the script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* Test file : ./test_suite_pkparse.c
*
* The following files were used to create this file.
*
* Main code file : suites/main_test.function
* Platform code file : suites/host_test.function
* Helper file : suites/helpers.function
* Test suite file : suites/test_suite_pkparse.function
* Test suite data : suites/test_suite_pkparse.data
*
*/
#define TEST_SUITE_ACTIVE
#if defined(MBEDTLS_PK_PARSE_C)
#if defined(MBEDTLS_BIGNUM_C)
#include "third_party/mbedtls/pk.h"
#include "third_party/mbedtls/pem.h"
#include "third_party/mbedtls/oid.h"
#if defined(MBEDTLS_RSA_C)
#if defined(MBEDTLS_FS_IO)
void test_pk_parse_keyfile_rsa( char * key_file, char * password, int result )
{
mbedtls_pk_context ctx;
int res;
char *pwd = password;
mbedtls_pk_init( &ctx );
if( strcmp( pwd, "NULL" ) == 0 )
pwd = NULL;
res = mbedtls_pk_parse_keyfile( &ctx, key_file, pwd );
TEST_ASSERT( res == result );
if( res == 0 )
{
mbedtls_rsa_context *rsa;
TEST_ASSERT( mbedtls_pk_can_do( &ctx, MBEDTLS_PK_RSA ) );
rsa = mbedtls_pk_rsa( ctx );
TEST_ASSERT( mbedtls_rsa_check_privkey( rsa ) == 0 );
}
exit:
mbedtls_pk_free( &ctx );
}
void test_pk_parse_keyfile_rsa_wrapper( void ** params )
{
test_pk_parse_keyfile_rsa( (char *) params[0], (char *) params[1], *( (int *) params[2] ) );
}
#endif /* MBEDTLS_FS_IO */
#endif /* MBEDTLS_RSA_C */
#if defined(MBEDTLS_RSA_C)
#if defined(MBEDTLS_FS_IO)
void test_pk_parse_public_keyfile_rsa( char * key_file, int result )
{
mbedtls_pk_context ctx;
int res;
mbedtls_pk_init( &ctx );
res = mbedtls_pk_parse_public_keyfile( &ctx, key_file );
TEST_ASSERT( res == result );
if( res == 0 )
{
mbedtls_rsa_context *rsa;
TEST_ASSERT( mbedtls_pk_can_do( &ctx, MBEDTLS_PK_RSA ) );
rsa = mbedtls_pk_rsa( ctx );
TEST_ASSERT( mbedtls_rsa_check_pubkey( rsa ) == 0 );
}
exit:
mbedtls_pk_free( &ctx );
}
void test_pk_parse_public_keyfile_rsa_wrapper( void ** params )
{
test_pk_parse_public_keyfile_rsa( (char *) params[0], *( (int *) params[1] ) );
}
#endif /* MBEDTLS_FS_IO */
#endif /* MBEDTLS_RSA_C */
#if defined(MBEDTLS_FS_IO)
#if defined(MBEDTLS_ECP_C)
void test_pk_parse_public_keyfile_ec( char * key_file, int result )
{
mbedtls_pk_context ctx;
int res;
mbedtls_pk_init( &ctx );
res = mbedtls_pk_parse_public_keyfile( &ctx, key_file );
TEST_ASSERT( res == result );
if( res == 0 )
{
mbedtls_ecp_keypair *eckey;
TEST_ASSERT( mbedtls_pk_can_do( &ctx, MBEDTLS_PK_ECKEY ) );
eckey = mbedtls_pk_ec( ctx );
TEST_ASSERT( mbedtls_ecp_check_pubkey( &eckey->grp, &eckey->Q ) == 0 );
}
exit:
mbedtls_pk_free( &ctx );
}
void test_pk_parse_public_keyfile_ec_wrapper( void ** params )
{
test_pk_parse_public_keyfile_ec( (char *) params[0], *( (int *) params[1] ) );
}
#endif /* MBEDTLS_ECP_C */
#endif /* MBEDTLS_FS_IO */
#if defined(MBEDTLS_FS_IO)
#if defined(MBEDTLS_ECP_C)
void test_pk_parse_keyfile_ec( char * key_file, char * password, int result )
{
mbedtls_pk_context ctx;
int res;
mbedtls_pk_init( &ctx );
res = mbedtls_pk_parse_keyfile( &ctx, key_file, password );
TEST_ASSERT( res == result );
if( res == 0 )
{
mbedtls_ecp_keypair *eckey;
TEST_ASSERT( mbedtls_pk_can_do( &ctx, MBEDTLS_PK_ECKEY ) );
eckey = mbedtls_pk_ec( ctx );
TEST_ASSERT( mbedtls_ecp_check_privkey( &eckey->grp, &eckey->d ) == 0 );
}
exit:
mbedtls_pk_free( &ctx );
}
void test_pk_parse_keyfile_ec_wrapper( void ** params )
{
test_pk_parse_keyfile_ec( (char *) params[0], (char *) params[1], *( (int *) params[2] ) );
}
#endif /* MBEDTLS_ECP_C */
#endif /* MBEDTLS_FS_IO */
void test_pk_parse_key( data_t * buf, int result )
{
mbedtls_pk_context pk;
mbedtls_pk_init( &pk );
TEST_ASSERT( mbedtls_pk_parse_key( &pk, buf->x, buf->len, NULL, 0 ) == result );
exit:
mbedtls_pk_free( &pk );
}
void test_pk_parse_key_wrapper( void ** params )
{
data_t data0 = {(uint8_t *) params[0], *( (uint32_t *) params[1] )};
test_pk_parse_key( &data0, *( (int *) params[2] ) );
}
#endif /* MBEDTLS_BIGNUM_C */
#endif /* MBEDTLS_PK_PARSE_C */
/*----------------------------------------------------------------------------*/
/* Test dispatch code */
/**
* \brief Evaluates an expression/macro into its literal integer value.
* For optimizing space for embedded targets each expression/macro
* is identified by a unique identifier instead of string literals.
* Identifiers and evaluation code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param exp_id Expression identifier.
* \param out_value Pointer to int to hold the integer.
*
* \return 0 if exp_id is found. 1 otherwise.
*/
int get_expression( int32_t exp_id, int32_t * out_value )
{
int ret = KEY_VALUE_MAPPING_FOUND;
(void) exp_id;
(void) out_value;
switch( exp_id )
{
#if defined(MBEDTLS_PK_PARSE_C) && defined(MBEDTLS_BIGNUM_C)
case 0:
{
*out_value = MBEDTLS_ERR_PK_PASSWORD_REQUIRED;
}
break;
case 1:
{
*out_value = MBEDTLS_ERR_PK_PASSWORD_MISMATCH;
}
break;
case 2:
{
*out_value = MBEDTLS_ERR_PK_KEY_INVALID_FORMAT;
}
break;
#endif
default:
{
ret = KEY_VALUE_MAPPING_NOT_FOUND;
}
break;
}
return( ret );
}
/**
* \brief Checks if the dependency i.e. the compile flag is set.
* For optimizing space for embedded targets each dependency
* is identified by a unique identifier instead of string literals.
* Identifiers and check code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param dep_id Dependency identifier.
*
* \return DEPENDENCY_SUPPORTED if set else DEPENDENCY_NOT_SUPPORTED
*/
int dep_check( int dep_id )
{
int ret = DEPENDENCY_NOT_SUPPORTED;
(void) dep_id;
switch( dep_id )
{
#if defined(MBEDTLS_PK_PARSE_C) && defined(MBEDTLS_BIGNUM_C)
case 0:
{
#if defined(MBEDTLS_MD5_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 1:
{
#if defined(MBEDTLS_PEM_PARSE_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 2:
{
#if defined(MBEDTLS_CIPHER_MODE_CBC)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 3:
{
#if defined(MBEDTLS_DES_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 4:
{
#if defined(MBEDTLS_AES_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 5:
{
#if defined(MBEDTLS_SHA1_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 6:
{
#if defined(MBEDTLS_PKCS12_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 7:
{
#if defined(MBEDTLS_CIPHER_PADDING_PKCS7)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 8:
{
#if defined(MBEDTLS_ARC4_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 9:
{
#if defined(MBEDTLS_PKCS5_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 10:
{
#if defined(MBEDTLS_SHA256_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 11:
{
#if defined(MBEDTLS_SHA512_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 12:
{
#if !defined(MBEDTLS_SHA512_NO_SHA384)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 13:
{
#if defined(MBEDTLS_ECP_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 14:
{
#if defined(MBEDTLS_ECP_DP_SECP192R1_ENABLED)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 15:
{
#if defined(MBEDTLS_ECP_DP_SECP224R1_ENABLED)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 16:
{
#if defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 17:
{
#if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 18:
{
#if defined(MBEDTLS_ECP_DP_SECP521R1_ENABLED)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 19:
{
#if defined(MBEDTLS_ECP_DP_BP256R1_ENABLED)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 20:
{
#if defined(MBEDTLS_ECP_DP_BP384R1_ENABLED)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 21:
{
#if defined(MBEDTLS_ECP_DP_BP512R1_ENABLED)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 22:
{
#if defined(MBEDTLS_ECP_DP_SECP256K1_ENABLED)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 23:
{
#if defined(MBEDTLS_PK_PARSE_EC_EXTENDED)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 24:
{
#if defined(MBEDTLS_RSA_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
#endif
default:
break;
}
return( ret );
}
/**
* \brief Function pointer type for test function wrappers.
*
* A test function wrapper decodes the parameters and passes them to the
* underlying test function. Both the wrapper and the underlying function
* return void. Test wrappers assume that they are passed a suitable
* parameter array and do not perform any error detection.
*
* \param param_array The array of parameters. Each element is a `void *`
* which the wrapper casts to the correct type and
* dereferences. Each wrapper function hard-codes the
* number and types of the parameters.
*/
typedef void (*TestWrapper_t)( void **param_array );
/**
* \brief Table of test function wrappers. Used by dispatch_test().
* This table is populated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
*/
TestWrapper_t test_funcs[] =
{
/* Function Id: 0 */
#if defined(MBEDTLS_PK_PARSE_C) && defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_RSA_C) && defined(MBEDTLS_FS_IO)
test_pk_parse_keyfile_rsa_wrapper,
#else
NULL,
#endif
/* Function Id: 1 */
#if defined(MBEDTLS_PK_PARSE_C) && defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_RSA_C) && defined(MBEDTLS_FS_IO)
test_pk_parse_public_keyfile_rsa_wrapper,
#else
NULL,
#endif
/* Function Id: 2 */
#if defined(MBEDTLS_PK_PARSE_C) && defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_FS_IO) && defined(MBEDTLS_ECP_C)
test_pk_parse_public_keyfile_ec_wrapper,
#else
NULL,
#endif
/* Function Id: 3 */
#if defined(MBEDTLS_PK_PARSE_C) && defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_FS_IO) && defined(MBEDTLS_ECP_C)
test_pk_parse_keyfile_ec_wrapper,
#else
NULL,
#endif
/* Function Id: 4 */
#if defined(MBEDTLS_PK_PARSE_C) && defined(MBEDTLS_BIGNUM_C)
test_pk_parse_key_wrapper,
#else
NULL,
#endif
};
/**
* \brief Execute the test function.
*
* This is a wrapper function around the test function execution
* to allow the setjmp() call used to catch any calls to the
* parameter failure callback, to be used. Calls to setjmp()
* can invalidate the state of any local auto variables.
*
* \param fp Function pointer to the test function.
* \param params Parameters to pass to the #TestWrapper_t wrapper function.
*
*/
void execute_function_ptr(TestWrapper_t fp, void **params)
{
#if defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG)
mbedtls_test_enable_insecure_external_rng( );
#endif
#if defined(MBEDTLS_CHECK_PARAMS)
mbedtls_test_param_failed_location_record_t location_record;
if ( setjmp( mbedtls_test_param_failed_get_state_buf( ) ) == 0 )
{
fp( params );
}
else
{
/* Unexpected parameter validation error */
mbedtls_test_param_failed_get_location_record( &location_record );
mbedtls_test_fail( location_record.failure_condition,
location_record.line,
location_record.file );
}
mbedtls_test_param_failed_reset_state( );
#else
fp( params );
#endif
#if defined(MBEDTLS_TEST_MUTEX_USAGE)
mbedtls_test_mutex_usage_check( );
#endif /* MBEDTLS_TEST_MUTEX_USAGE */
}
/**
* \brief Dispatches test functions based on function index.
*
* \param func_idx Test function index.
* \param params The array of parameters to pass to the test function.
* It will be decoded by the #TestWrapper_t wrapper function.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int dispatch_test( size_t func_idx, void ** params )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof( test_funcs ) / sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp )
execute_function_ptr(fp, params);
else
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
/**
* \brief Checks if test function is supported in this build-time
* configuration.
*
* \param func_idx Test function index.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int check_test( size_t func_idx )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof(test_funcs)/sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp == NULL )
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
int main( int argc, const char *argv[] )
{
int ret;
mbedtls_test_platform_setup();
ret = execute_tests( argc, argv, "/zip/third_party/mbedtls/test/test_suite_pkparse.datax" );
mbedtls_test_platform_teardown();
return( ret );
}
| 17,737 | 685 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_aes.xts.c | /* clang-format off */
/*
* Copyright The Mbed TLS Contributors
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "third_party/mbedtls/test/test.inc"
/*
* *** THIS FILE WAS MACHINE GENERATED ***
*
* This file has been machine generated using the script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* Test file : ./test_suite_aes.xts.c
*
* The following files were used to create this file.
*
* Main code file : suites/main_test.function
* Platform code file : suites/host_test.function
* Helper file : suites/helpers.function
* Test suite file : suites/test_suite_aes.function
* Test suite data : suites/test_suite_aes.xts.data
*
*/
#define TEST_SUITE_ACTIVE
#if defined(MBEDTLS_AES_C)
#include "third_party/mbedtls/aes.h"
void test_aes_encrypt_ecb( data_t * key_str, data_t * src_str,
data_t * dst, int setkey_result )
{
unsigned char output[100];
mbedtls_aes_context ctx;
memset(output, 0x00, 100);
mbedtls_aes_init( &ctx );
TEST_ASSERT( mbedtls_aes_setkey_enc( &ctx, key_str->x, key_str->len * 8 ) == setkey_result );
if( setkey_result == 0 )
{
TEST_ASSERT( mbedtls_aes_crypt_ecb( &ctx, MBEDTLS_AES_ENCRYPT, src_str->x, output ) == 0 );
TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, 16, dst->len ) == 0 );
}
exit:
mbedtls_aes_free( &ctx );
}
void test_aes_encrypt_ecb_wrapper( void ** params )
{
data_t data0 = {(uint8_t *) params[0], *( (uint32_t *) params[1] )};
data_t data2 = {(uint8_t *) params[2], *( (uint32_t *) params[3] )};
data_t data4 = {(uint8_t *) params[4], *( (uint32_t *) params[5] )};
test_aes_encrypt_ecb( &data0, &data2, &data4, *( (int *) params[6] ) );
}
void test_aes_decrypt_ecb( data_t * key_str, data_t * src_str,
data_t * dst, int setkey_result )
{
unsigned char output[100];
mbedtls_aes_context ctx;
memset(output, 0x00, 100);
mbedtls_aes_init( &ctx );
TEST_ASSERT( mbedtls_aes_setkey_dec( &ctx, key_str->x, key_str->len * 8 ) == setkey_result );
if( setkey_result == 0 )
{
TEST_ASSERT( mbedtls_aes_crypt_ecb( &ctx, MBEDTLS_AES_DECRYPT, src_str->x, output ) == 0 );
TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, 16, dst->len ) == 0 );
}
exit:
mbedtls_aes_free( &ctx );
}
void test_aes_decrypt_ecb_wrapper( void ** params )
{
data_t data0 = {(uint8_t *) params[0], *( (uint32_t *) params[1] )};
data_t data2 = {(uint8_t *) params[2], *( (uint32_t *) params[3] )};
data_t data4 = {(uint8_t *) params[4], *( (uint32_t *) params[5] )};
test_aes_decrypt_ecb( &data0, &data2, &data4, *( (int *) params[6] ) );
}
#if defined(MBEDTLS_CIPHER_MODE_CBC)
void test_aes_encrypt_cbc( data_t * key_str, data_t * iv_str,
data_t * src_str, data_t * dst,
int cbc_result )
{
unsigned char output[100];
mbedtls_aes_context ctx;
memset(output, 0x00, 100);
mbedtls_aes_init( &ctx );
mbedtls_aes_setkey_enc( &ctx, key_str->x, key_str->len * 8 );
TEST_ASSERT( mbedtls_aes_crypt_cbc( &ctx, MBEDTLS_AES_ENCRYPT, src_str->len, iv_str->x, src_str->x, output ) == cbc_result );
if( cbc_result == 0 )
{
TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x,
src_str->len, dst->len ) == 0 );
}
exit:
mbedtls_aes_free( &ctx );
}
void test_aes_encrypt_cbc_wrapper( void ** params )
{
data_t data0 = {(uint8_t *) params[0], *( (uint32_t *) params[1] )};
data_t data2 = {(uint8_t *) params[2], *( (uint32_t *) params[3] )};
data_t data4 = {(uint8_t *) params[4], *( (uint32_t *) params[5] )};
data_t data6 = {(uint8_t *) params[6], *( (uint32_t *) params[7] )};
test_aes_encrypt_cbc( &data0, &data2, &data4, &data6, *( (int *) params[8] ) );
}
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#if defined(MBEDTLS_CIPHER_MODE_CBC)
void test_aes_decrypt_cbc( data_t * key_str, data_t * iv_str,
data_t * src_str, data_t * dst,
int cbc_result )
{
unsigned char output[100];
mbedtls_aes_context ctx;
memset(output, 0x00, 100);
mbedtls_aes_init( &ctx );
mbedtls_aes_setkey_dec( &ctx, key_str->x, key_str->len * 8 );
TEST_ASSERT( mbedtls_aes_crypt_cbc( &ctx, MBEDTLS_AES_DECRYPT, src_str->len, iv_str->x, src_str->x, output ) == cbc_result );
if( cbc_result == 0)
{
TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x,
src_str->len, dst->len ) == 0 );
}
exit:
mbedtls_aes_free( &ctx );
}
void test_aes_decrypt_cbc_wrapper( void ** params )
{
data_t data0 = {(uint8_t *) params[0], *( (uint32_t *) params[1] )};
data_t data2 = {(uint8_t *) params[2], *( (uint32_t *) params[3] )};
data_t data4 = {(uint8_t *) params[4], *( (uint32_t *) params[5] )};
data_t data6 = {(uint8_t *) params[6], *( (uint32_t *) params[7] )};
test_aes_decrypt_cbc( &data0, &data2, &data4, &data6, *( (int *) params[8] ) );
}
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#if defined(MBEDTLS_CIPHER_MODE_XTS)
void test_aes_encrypt_xts( char *hex_key_string, char *hex_data_unit_string,
char *hex_src_string, char *hex_dst_string )
{
enum { AES_BLOCK_SIZE = 16 };
unsigned char *data_unit = NULL;
unsigned char *key = NULL;
unsigned char *src = NULL;
unsigned char *dst = NULL;
unsigned char *output = NULL;
mbedtls_aes_xts_context ctx;
size_t key_len, src_len, dst_len, data_unit_len;
mbedtls_aes_xts_init( &ctx );
data_unit = mbedtls_test_unhexify_alloc( hex_data_unit_string,
&data_unit_len );
TEST_ASSERT( data_unit_len == AES_BLOCK_SIZE );
key = mbedtls_test_unhexify_alloc( hex_key_string, &key_len );
TEST_ASSERT( key_len % 2 == 0 );
src = mbedtls_test_unhexify_alloc( hex_src_string, &src_len );
dst = mbedtls_test_unhexify_alloc( hex_dst_string, &dst_len );
TEST_ASSERT( src_len == dst_len );
output = mbedtls_test_zero_alloc( dst_len );
TEST_ASSERT( mbedtls_aes_xts_setkey_enc( &ctx, key, key_len * 8 ) == 0 );
TEST_ASSERT( mbedtls_aes_crypt_xts( &ctx, MBEDTLS_AES_ENCRYPT, src_len,
data_unit, src, output ) == 0 );
TEST_ASSERT( memcmp( output, dst, dst_len ) == 0 );
exit:
mbedtls_aes_xts_free( &ctx );
mbedtls_free( data_unit );
mbedtls_free( key );
mbedtls_free( src );
mbedtls_free( dst );
mbedtls_free( output );
}
void test_aes_encrypt_xts_wrapper( void ** params )
{
test_aes_encrypt_xts( (char *) params[0], (char *) params[1], (char *) params[2], (char *) params[3] );
}
#endif /* MBEDTLS_CIPHER_MODE_XTS */
#if defined(MBEDTLS_CIPHER_MODE_XTS)
void test_aes_decrypt_xts( char *hex_key_string, char *hex_data_unit_string,
char *hex_dst_string, char *hex_src_string )
{
enum { AES_BLOCK_SIZE = 16 };
unsigned char *data_unit = NULL;
unsigned char *key = NULL;
unsigned char *src = NULL;
unsigned char *dst = NULL;
unsigned char *output = NULL;
mbedtls_aes_xts_context ctx;
size_t key_len, src_len, dst_len, data_unit_len;
mbedtls_aes_xts_init( &ctx );
data_unit = mbedtls_test_unhexify_alloc( hex_data_unit_string,
&data_unit_len );
TEST_ASSERT( data_unit_len == AES_BLOCK_SIZE );
key = mbedtls_test_unhexify_alloc( hex_key_string, &key_len );
TEST_ASSERT( key_len % 2 == 0 );
src = mbedtls_test_unhexify_alloc( hex_src_string, &src_len );
dst = mbedtls_test_unhexify_alloc( hex_dst_string, &dst_len );
TEST_ASSERT( src_len == dst_len );
output = mbedtls_test_zero_alloc( dst_len );
TEST_ASSERT( mbedtls_aes_xts_setkey_dec( &ctx, key, key_len * 8 ) == 0 );
TEST_ASSERT( mbedtls_aes_crypt_xts( &ctx, MBEDTLS_AES_DECRYPT, src_len,
data_unit, src, output ) == 0 );
TEST_ASSERT( memcmp( output, dst, dst_len ) == 0 );
exit:
mbedtls_aes_xts_free( &ctx );
mbedtls_free( data_unit );
mbedtls_free( key );
mbedtls_free( src );
mbedtls_free( dst );
mbedtls_free( output );
}
void test_aes_decrypt_xts_wrapper( void ** params )
{
test_aes_decrypt_xts( (char *) params[0], (char *) params[1], (char *) params[2], (char *) params[3] );
}
#endif /* MBEDTLS_CIPHER_MODE_XTS */
#if defined(MBEDTLS_CIPHER_MODE_XTS)
void test_aes_crypt_xts_size( int size, int retval )
{
mbedtls_aes_xts_context ctx;
const unsigned char src[16] = { 0 };
unsigned char output[16];
unsigned char data_unit[16];
size_t length = size;
mbedtls_aes_xts_init( &ctx );
memset( data_unit, 0x00, sizeof( data_unit ) );
/* Valid pointers are passed for builds with MBEDTLS_CHECK_PARAMS, as
* otherwise we wouldn't get to the size check we're interested in. */
TEST_ASSERT( mbedtls_aes_crypt_xts( &ctx, MBEDTLS_AES_ENCRYPT, length, data_unit, src, output ) == retval );
exit:
;
}
void test_aes_crypt_xts_size_wrapper( void ** params )
{
test_aes_crypt_xts_size( *( (int *) params[0] ), *( (int *) params[1] ) );
}
#endif /* MBEDTLS_CIPHER_MODE_XTS */
#if defined(MBEDTLS_CIPHER_MODE_XTS)
void test_aes_crypt_xts_keysize( int size, int retval )
{
mbedtls_aes_xts_context ctx;
const unsigned char key[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
size_t key_len = size;
mbedtls_aes_xts_init( &ctx );
TEST_ASSERT( mbedtls_aes_xts_setkey_enc( &ctx, key, key_len * 8 ) == retval );
TEST_ASSERT( mbedtls_aes_xts_setkey_dec( &ctx, key, key_len * 8 ) == retval );
exit:
mbedtls_aes_xts_free( &ctx );
}
void test_aes_crypt_xts_keysize_wrapper( void ** params )
{
test_aes_crypt_xts_keysize( *( (int *) params[0] ), *( (int *) params[1] ) );
}
#endif /* MBEDTLS_CIPHER_MODE_XTS */
#if defined(MBEDTLS_CIPHER_MODE_CFB)
void test_aes_encrypt_cfb128( data_t * key_str, data_t * iv_str,
data_t * src_str, data_t * dst )
{
unsigned char output[100];
mbedtls_aes_context ctx;
size_t iv_offset = 0;
memset(output, 0x00, 100);
mbedtls_aes_init( &ctx );
mbedtls_aes_setkey_enc( &ctx, key_str->x, key_str->len * 8 );
TEST_ASSERT( mbedtls_aes_crypt_cfb128( &ctx, MBEDTLS_AES_ENCRYPT, 16, &iv_offset, iv_str->x, src_str->x, output ) == 0 );
TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, 16, dst->len ) == 0 );
exit:
mbedtls_aes_free( &ctx );
}
void test_aes_encrypt_cfb128_wrapper( void ** params )
{
data_t data0 = {(uint8_t *) params[0], *( (uint32_t *) params[1] )};
data_t data2 = {(uint8_t *) params[2], *( (uint32_t *) params[3] )};
data_t data4 = {(uint8_t *) params[4], *( (uint32_t *) params[5] )};
data_t data6 = {(uint8_t *) params[6], *( (uint32_t *) params[7] )};
test_aes_encrypt_cfb128( &data0, &data2, &data4, &data6 );
}
#endif /* MBEDTLS_CIPHER_MODE_CFB */
#if defined(MBEDTLS_CIPHER_MODE_CFB)
void test_aes_decrypt_cfb128( data_t * key_str, data_t * iv_str,
data_t * src_str, data_t * dst )
{
unsigned char output[100];
mbedtls_aes_context ctx;
size_t iv_offset = 0;
memset(output, 0x00, 100);
mbedtls_aes_init( &ctx );
mbedtls_aes_setkey_enc( &ctx, key_str->x, key_str->len * 8 );
TEST_ASSERT( mbedtls_aes_crypt_cfb128( &ctx, MBEDTLS_AES_DECRYPT, 16, &iv_offset, iv_str->x, src_str->x, output ) == 0 );
TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, 16, dst->len ) == 0 );
exit:
mbedtls_aes_free( &ctx );
}
void test_aes_decrypt_cfb128_wrapper( void ** params )
{
data_t data0 = {(uint8_t *) params[0], *( (uint32_t *) params[1] )};
data_t data2 = {(uint8_t *) params[2], *( (uint32_t *) params[3] )};
data_t data4 = {(uint8_t *) params[4], *( (uint32_t *) params[5] )};
data_t data6 = {(uint8_t *) params[6], *( (uint32_t *) params[7] )};
test_aes_decrypt_cfb128( &data0, &data2, &data4, &data6 );
}
#endif /* MBEDTLS_CIPHER_MODE_CFB */
#if defined(MBEDTLS_CIPHER_MODE_CFB)
void test_aes_encrypt_cfb8( data_t * key_str, data_t * iv_str,
data_t * src_str, data_t * dst )
{
unsigned char output[100];
mbedtls_aes_context ctx;
memset(output, 0x00, 100);
mbedtls_aes_init( &ctx );
mbedtls_aes_setkey_enc( &ctx, key_str->x, key_str->len * 8 );
TEST_ASSERT( mbedtls_aes_crypt_cfb8( &ctx, MBEDTLS_AES_ENCRYPT, src_str->len, iv_str->x, src_str->x, output ) == 0 );
TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x,
src_str->len, dst->len ) == 0 );
exit:
mbedtls_aes_free( &ctx );
}
void test_aes_encrypt_cfb8_wrapper( void ** params )
{
data_t data0 = {(uint8_t *) params[0], *( (uint32_t *) params[1] )};
data_t data2 = {(uint8_t *) params[2], *( (uint32_t *) params[3] )};
data_t data4 = {(uint8_t *) params[4], *( (uint32_t *) params[5] )};
data_t data6 = {(uint8_t *) params[6], *( (uint32_t *) params[7] )};
test_aes_encrypt_cfb8( &data0, &data2, &data4, &data6 );
}
#endif /* MBEDTLS_CIPHER_MODE_CFB */
#if defined(MBEDTLS_CIPHER_MODE_CFB)
void test_aes_decrypt_cfb8( data_t * key_str, data_t * iv_str,
data_t * src_str, data_t * dst )
{
unsigned char output[100];
mbedtls_aes_context ctx;
memset(output, 0x00, 100);
mbedtls_aes_init( &ctx );
mbedtls_aes_setkey_enc( &ctx, key_str->x, key_str->len * 8 );
TEST_ASSERT( mbedtls_aes_crypt_cfb8( &ctx, MBEDTLS_AES_DECRYPT, src_str->len, iv_str->x, src_str->x, output ) == 0 );
TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x,
src_str->len, dst->len ) == 0 );
exit:
mbedtls_aes_free( &ctx );
}
void test_aes_decrypt_cfb8_wrapper( void ** params )
{
data_t data0 = {(uint8_t *) params[0], *( (uint32_t *) params[1] )};
data_t data2 = {(uint8_t *) params[2], *( (uint32_t *) params[3] )};
data_t data4 = {(uint8_t *) params[4], *( (uint32_t *) params[5] )};
data_t data6 = {(uint8_t *) params[6], *( (uint32_t *) params[7] )};
test_aes_decrypt_cfb8( &data0, &data2, &data4, &data6 );
}
#endif /* MBEDTLS_CIPHER_MODE_CFB */
#if defined(MBEDTLS_CIPHER_MODE_OFB)
void test_aes_encrypt_ofb( int fragment_size, data_t *key_str,
data_t *iv_str, data_t *src_str,
data_t *expected_output )
{
unsigned char output[32];
mbedtls_aes_context ctx;
size_t iv_offset = 0;
int in_buffer_len;
unsigned char* src_str_next;
memset( output, 0x00, sizeof( output ) );
mbedtls_aes_init( &ctx );
TEST_ASSERT( (size_t)fragment_size < sizeof( output ) );
TEST_ASSERT( mbedtls_aes_setkey_enc( &ctx, key_str->x,
key_str->len * 8 ) == 0 );
in_buffer_len = src_str->len;
src_str_next = src_str->x;
while( in_buffer_len > 0 )
{
TEST_ASSERT( mbedtls_aes_crypt_ofb( &ctx, fragment_size, &iv_offset,
iv_str->x, src_str_next, output ) == 0 );
TEST_ASSERT( memcmp( output, expected_output->x, fragment_size ) == 0 );
in_buffer_len -= fragment_size;
expected_output->x += fragment_size;
src_str_next += fragment_size;
if( in_buffer_len < fragment_size )
fragment_size = in_buffer_len;
}
exit:
mbedtls_aes_free( &ctx );
}
void test_aes_encrypt_ofb_wrapper( void ** params )
{
data_t data1 = {(uint8_t *) params[1], *( (uint32_t *) params[2] )};
data_t data3 = {(uint8_t *) params[3], *( (uint32_t *) params[4] )};
data_t data5 = {(uint8_t *) params[5], *( (uint32_t *) params[6] )};
data_t data7 = {(uint8_t *) params[7], *( (uint32_t *) params[8] )};
test_aes_encrypt_ofb( *( (int *) params[0] ), &data1, &data3, &data5, &data7 );
}
#endif /* MBEDTLS_CIPHER_MODE_OFB */
#if defined(MBEDTLS_CHECK_PARAMS)
#if !defined(MBEDTLS_PARAM_FAILED_ALT)
void test_aes_check_params( )
{
mbedtls_aes_context aes_ctx;
#if defined(MBEDTLS_CIPHER_MODE_XTS)
mbedtls_aes_xts_context xts_ctx;
#endif
const unsigned char key[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
const unsigned char in[16] = { 0 };
unsigned char out[16];
size_t size;
const int valid_mode = MBEDTLS_AES_ENCRYPT;
const int invalid_mode = 42;
TEST_INVALID_PARAM( mbedtls_aes_init( NULL ) );
#if defined(MBEDTLS_CIPHER_MODE_XTS)
TEST_INVALID_PARAM( mbedtls_aes_xts_init( NULL ) );
#endif
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_setkey_enc( NULL, key, 128 ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_setkey_enc( &aes_ctx, NULL, 128 ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_setkey_dec( NULL, key, 128 ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_setkey_dec( &aes_ctx, NULL, 128 ) );
#if defined(MBEDTLS_CIPHER_MODE_XTS)
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_xts_setkey_enc( NULL, key, 128 ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_xts_setkey_enc( &xts_ctx, NULL, 128 ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_xts_setkey_dec( NULL, key, 128 ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_xts_setkey_dec( &xts_ctx, NULL, 128 ) );
#endif
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_ecb( NULL,
valid_mode, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_ecb( &aes_ctx,
invalid_mode, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_ecb( &aes_ctx,
valid_mode, NULL, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_ecb( &aes_ctx,
valid_mode, in, NULL ) );
#if defined(MBEDTLS_CIPHER_MODE_CBC)
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_cbc( NULL,
valid_mode, 16,
out, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_cbc( &aes_ctx,
invalid_mode, 16,
out, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_cbc( &aes_ctx,
valid_mode, 16,
NULL, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_cbc( &aes_ctx,
valid_mode, 16,
out, NULL, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_cbc( &aes_ctx,
valid_mode, 16,
out, in, NULL ) );
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#if defined(MBEDTLS_CIPHER_MODE_XTS)
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_xts( NULL,
valid_mode, 16,
in, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_xts( &xts_ctx,
invalid_mode, 16,
in, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_xts( &xts_ctx,
valid_mode, 16,
NULL, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_xts( &xts_ctx,
valid_mode, 16,
in, NULL, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_xts( &xts_ctx,
valid_mode, 16,
in, in, NULL ) );
#endif /* MBEDTLS_CIPHER_MODE_XTS */
#if defined(MBEDTLS_CIPHER_MODE_CFB)
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_cfb128( NULL,
valid_mode, 16,
&size, out, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_cfb128( &aes_ctx,
invalid_mode, 16,
&size, out, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_cfb128( &aes_ctx,
valid_mode, 16,
NULL, out, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_cfb128( &aes_ctx,
valid_mode, 16,
&size, NULL, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_cfb128( &aes_ctx,
valid_mode, 16,
&size, out, NULL, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_cfb128( &aes_ctx,
valid_mode, 16,
&size, out, in, NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_cfb8( NULL,
valid_mode, 16,
out, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_cfb8( &aes_ctx,
invalid_mode, 16,
out, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_cfb8( &aes_ctx,
valid_mode, 16,
NULL, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_cfb8( &aes_ctx,
valid_mode, 16,
out, NULL, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_cfb8( &aes_ctx,
valid_mode, 16,
out, in, NULL ) );
#endif /* MBEDTLS_CIPHER_MODE_CFB */
#if defined(MBEDTLS_CIPHER_MODE_OFB)
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_ofb( NULL, 16,
&size, out, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_ofb( &aes_ctx, 16,
NULL, out, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_ofb( &aes_ctx, 16,
&size, NULL, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_ofb( &aes_ctx, 16,
&size, out, NULL, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_ofb( &aes_ctx, 16,
&size, out, in, NULL ) );
#endif /* MBEDTLS_CIPHER_MODE_OFB */
#if defined(MBEDTLS_CIPHER_MODE_CTR)
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_ctr( NULL, 16, &size, out,
out, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_ctr( &aes_ctx, 16, NULL, out,
out, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_ctr( &aes_ctx, 16, &size, NULL,
out, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_ctr( &aes_ctx, 16, &size, out,
NULL, in, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_ctr( &aes_ctx, 16, &size, out,
out, NULL, out ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
mbedtls_aes_crypt_ctr( &aes_ctx, 16, &size, out,
out, in, NULL ) );
#endif /* MBEDTLS_CIPHER_MODE_CTR */
exit:
;
}
void test_aes_check_params_wrapper( void ** params )
{
(void)params;
test_aes_check_params( );
}
#endif /* !MBEDTLS_PARAM_FAILED_ALT */
#endif /* MBEDTLS_CHECK_PARAMS */
void test_aes_misc_params( )
{
#if defined(MBEDTLS_CIPHER_MODE_CBC) || \
defined(MBEDTLS_CIPHER_MODE_XTS) || \
defined(MBEDTLS_CIPHER_MODE_CFB) || \
defined(MBEDTLS_CIPHER_MODE_OFB)
mbedtls_aes_context aes_ctx;
const unsigned char in[16] = { 0 };
unsigned char out[16];
#endif
#if defined(MBEDTLS_CIPHER_MODE_XTS)
mbedtls_aes_xts_context xts_ctx;
#endif
#if defined(MBEDTLS_CIPHER_MODE_CFB) || \
defined(MBEDTLS_CIPHER_MODE_OFB)
size_t size;
#endif
/* These calls accept NULL */
TEST_VALID_PARAM( mbedtls_aes_free( NULL ) );
#if defined(MBEDTLS_CIPHER_MODE_XTS)
TEST_VALID_PARAM( mbedtls_aes_xts_free( NULL ) );
#endif
#if defined(MBEDTLS_CIPHER_MODE_CBC)
TEST_ASSERT( mbedtls_aes_crypt_cbc( &aes_ctx, MBEDTLS_AES_ENCRYPT,
15,
out, in, out )
== MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH );
TEST_ASSERT( mbedtls_aes_crypt_cbc( &aes_ctx, MBEDTLS_AES_ENCRYPT,
17,
out, in, out )
== MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH );
#endif
#if defined(MBEDTLS_CIPHER_MODE_XTS)
TEST_ASSERT( mbedtls_aes_crypt_xts( &xts_ctx, MBEDTLS_AES_ENCRYPT,
15,
in, in, out )
== MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH );
TEST_ASSERT( mbedtls_aes_crypt_xts( &xts_ctx, MBEDTLS_AES_ENCRYPT,
(1 << 24) + 1,
in, in, out )
== MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH );
#endif
#if defined(MBEDTLS_CIPHER_MODE_CFB)
size = 16;
TEST_ASSERT( mbedtls_aes_crypt_cfb128( &aes_ctx, MBEDTLS_AES_ENCRYPT, 16,
&size, out, in, out )
== MBEDTLS_ERR_AES_BAD_INPUT_DATA );
#endif
#if defined(MBEDTLS_CIPHER_MODE_OFB)
size = 16;
TEST_ASSERT( mbedtls_aes_crypt_ofb( &aes_ctx, 16, &size, out, in, out )
== MBEDTLS_ERR_AES_BAD_INPUT_DATA );
#endif
exit:
;
}
void test_aes_misc_params_wrapper( void ** params )
{
(void)params;
test_aes_misc_params( );
}
#if defined(MBEDTLS_SELF_TEST)
void test_aes_selftest( )
{
TEST_ASSERT( mbedtls_aes_self_test( 1 ) == 0 );
exit:
;
}
void test_aes_selftest_wrapper( void ** params )
{
(void)params;
test_aes_selftest( );
}
#endif /* MBEDTLS_SELF_TEST */
#endif /* MBEDTLS_AES_C */
/*----------------------------------------------------------------------------*/
/* Test dispatch code */
/**
* \brief Evaluates an expression/macro into its literal integer value.
* For optimizing space for embedded targets each expression/macro
* is identified by a unique identifier instead of string literals.
* Identifiers and evaluation code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param exp_id Expression identifier.
* \param out_value Pointer to int to hold the integer.
*
* \return 0 if exp_id is found. 1 otherwise.
*/
int get_expression( int32_t exp_id, int32_t * out_value )
{
int ret = KEY_VALUE_MAPPING_FOUND;
(void) exp_id;
(void) out_value;
switch( exp_id )
{
#if defined(MBEDTLS_AES_C)
case 0:
{
*out_value = MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH;
}
break;
case 1:
{
*out_value = MBEDTLS_ERR_AES_INVALID_KEY_LENGTH;
}
break;
#endif
default:
{
ret = KEY_VALUE_MAPPING_NOT_FOUND;
}
break;
}
return( ret );
}
/**
* \brief Checks if the dependency i.e. the compile flag is set.
* For optimizing space for embedded targets each dependency
* is identified by a unique identifier instead of string literals.
* Identifiers and check code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param dep_id Dependency identifier.
*
* \return DEPENDENCY_SUPPORTED if set else DEPENDENCY_NOT_SUPPORTED
*/
int dep_check( int dep_id )
{
int ret = DEPENDENCY_NOT_SUPPORTED;
(void) dep_id;
switch( dep_id )
{
#if defined(MBEDTLS_AES_C)
#endif
default:
break;
}
return( ret );
}
/**
* \brief Function pointer type for test function wrappers.
*
* A test function wrapper decodes the parameters and passes them to the
* underlying test function. Both the wrapper and the underlying function
* return void. Test wrappers assume that they are passed a suitable
* parameter array and do not perform any error detection.
*
* \param param_array The array of parameters. Each element is a `void *`
* which the wrapper casts to the correct type and
* dereferences. Each wrapper function hard-codes the
* number and types of the parameters.
*/
typedef void (*TestWrapper_t)( void **param_array );
/**
* \brief Table of test function wrappers. Used by dispatch_test().
* This table is populated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
*/
TestWrapper_t test_funcs[] =
{
/* Function Id: 0 */
#if defined(MBEDTLS_AES_C)
test_aes_encrypt_ecb_wrapper,
#else
NULL,
#endif
/* Function Id: 1 */
#if defined(MBEDTLS_AES_C)
test_aes_decrypt_ecb_wrapper,
#else
NULL,
#endif
/* Function Id: 2 */
#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_CIPHER_MODE_CBC)
test_aes_encrypt_cbc_wrapper,
#else
NULL,
#endif
/* Function Id: 3 */
#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_CIPHER_MODE_CBC)
test_aes_decrypt_cbc_wrapper,
#else
NULL,
#endif
/* Function Id: 4 */
#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_CIPHER_MODE_XTS)
test_aes_encrypt_xts_wrapper,
#else
NULL,
#endif
/* Function Id: 5 */
#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_CIPHER_MODE_XTS)
test_aes_decrypt_xts_wrapper,
#else
NULL,
#endif
/* Function Id: 6 */
#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_CIPHER_MODE_XTS)
test_aes_crypt_xts_size_wrapper,
#else
NULL,
#endif
/* Function Id: 7 */
#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_CIPHER_MODE_XTS)
test_aes_crypt_xts_keysize_wrapper,
#else
NULL,
#endif
/* Function Id: 8 */
#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_CIPHER_MODE_CFB)
test_aes_encrypt_cfb128_wrapper,
#else
NULL,
#endif
/* Function Id: 9 */
#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_CIPHER_MODE_CFB)
test_aes_decrypt_cfb128_wrapper,
#else
NULL,
#endif
/* Function Id: 10 */
#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_CIPHER_MODE_CFB)
test_aes_encrypt_cfb8_wrapper,
#else
NULL,
#endif
/* Function Id: 11 */
#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_CIPHER_MODE_CFB)
test_aes_decrypt_cfb8_wrapper,
#else
NULL,
#endif
/* Function Id: 12 */
#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_CIPHER_MODE_OFB)
test_aes_encrypt_ofb_wrapper,
#else
NULL,
#endif
/* Function Id: 13 */
#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_CHECK_PARAMS) && !defined(MBEDTLS_PARAM_FAILED_ALT)
test_aes_check_params_wrapper,
#else
NULL,
#endif
/* Function Id: 14 */
#if defined(MBEDTLS_AES_C)
test_aes_misc_params_wrapper,
#else
NULL,
#endif
/* Function Id: 15 */
#if defined(MBEDTLS_AES_C) && defined(MBEDTLS_SELF_TEST)
test_aes_selftest_wrapper,
#else
NULL,
#endif
};
/**
* \brief Execute the test function.
*
* This is a wrapper function around the test function execution
* to allow the setjmp() call used to catch any calls to the
* parameter failure callback, to be used. Calls to setjmp()
* can invalidate the state of any local auto variables.
*
* \param fp Function pointer to the test function.
* \param params Parameters to pass to the #TestWrapper_t wrapper function.
*
*/
void execute_function_ptr(TestWrapper_t fp, void **params)
{
#if defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG)
mbedtls_test_enable_insecure_external_rng( );
#endif
#if defined(MBEDTLS_CHECK_PARAMS)
mbedtls_test_param_failed_location_record_t location_record;
if ( setjmp( mbedtls_test_param_failed_get_state_buf( ) ) == 0 )
{
fp( params );
}
else
{
/* Unexpected parameter validation error */
mbedtls_test_param_failed_get_location_record( &location_record );
mbedtls_test_fail( location_record.failure_condition,
location_record.line,
location_record.file );
}
mbedtls_test_param_failed_reset_state( );
#else
fp( params );
#endif
#if defined(MBEDTLS_TEST_MUTEX_USAGE)
mbedtls_test_mutex_usage_check( );
#endif /* MBEDTLS_TEST_MUTEX_USAGE */
}
/**
* \brief Dispatches test functions based on function index.
*
* \param func_idx Test function index.
* \param params The array of parameters to pass to the test function.
* It will be decoded by the #TestWrapper_t wrapper function.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int dispatch_test( size_t func_idx, void ** params )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof( test_funcs ) / sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp )
execute_function_ptr(fp, params);
else
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
/**
* \brief Checks if test function is supported in this build-time
* configuration.
*
* \param func_idx Test function index.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int check_test( size_t func_idx )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof(test_funcs)/sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp == NULL )
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
int main( int argc, const char *argv[] )
{
int ret;
mbedtls_test_platform_setup();
ret = execute_tests( argc, argv, "/zip/third_party/mbedtls/test/test_suite_aes.xts.datax" );
mbedtls_test_platform_teardown();
return( ret );
}
| 38,393 | 1,110 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_mdx.c | /* clang-format off */
/*
* Copyright The Mbed TLS Contributors
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "third_party/mbedtls/test/test.inc"
/*
* *** THIS FILE WAS MACHINE GENERATED ***
*
* This file has been machine generated using the script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* Test file : ./test_suite_mdx.c
*
* The following files were used to create this file.
*
* Main code file : suites/main_test.function
* Platform code file : suites/host_test.function
* Helper file : suites/helpers.function
* Test suite file : suites/test_suite_mdx.function
* Test suite data : suites/test_suite_mdx.data
*
*/
#define TEST_SUITE_ACTIVE
#include "third_party/mbedtls/md5.h"
#if defined(MBEDTLS_MD2_C)
void test_md2_text( char * text_src_string, data_t * hash )
{
int ret;
unsigned char src_str[100];
unsigned char output[16];
memset( src_str, 0x00, sizeof src_str );
memset( output, 0x00, sizeof output );
strncpy( (char *) src_str, text_src_string, sizeof(src_str) - 1 );
ret = mbedtls_md2_ret( src_str, strlen( (char *) src_str ), output );
TEST_ASSERT( ret == 0 ) ;
TEST_ASSERT( mbedtls_test_hexcmp( output, hash->x,
sizeof output, hash->len ) == 0 );
exit:
;
}
void test_md2_text_wrapper( void ** params )
{
data_t data1 = {(uint8_t *) params[1], *( (uint32_t *) params[2] )};
test_md2_text( (char *) params[0], &data1 );
}
#endif /* MBEDTLS_MD2_C */
#if defined(MBEDTLS_MD4_C)
void test_md4_text( char * text_src_string, data_t * hash )
{
int ret;
unsigned char src_str[100];
unsigned char output[16];
memset( src_str, 0x00, sizeof src_str );
memset( output, 0x00, sizeof output );
strncpy( (char *) src_str, text_src_string, sizeof(src_str) - 1 );
ret = mbedtls_md4_ret( src_str, strlen( (char *) src_str ), output );
TEST_ASSERT( ret == 0 );
TEST_ASSERT( mbedtls_test_hexcmp( output, hash->x,
sizeof output, hash->len ) == 0 );
exit:
;
}
void test_md4_text_wrapper( void ** params )
{
data_t data1 = {(uint8_t *) params[1], *( (uint32_t *) params[2] )};
test_md4_text( (char *) params[0], &data1 );
}
#endif /* MBEDTLS_MD4_C */
#if defined(MBEDTLS_MD5_C)
void test_md5_text( char * text_src_string, data_t * hash )
{
int ret;
unsigned char src_str[100];
unsigned char output[16];
memset( src_str, 0x00, sizeof src_str );
memset( output, 0x00, sizeof output );
strncpy( (char *) src_str, text_src_string, sizeof(src_str) - 1 );
ret = mbedtls_md5_ret( src_str, strlen( (char *) src_str ), output );
TEST_ASSERT( ret == 0 );
TEST_ASSERT( mbedtls_test_hexcmp( output, hash->x,
sizeof output, hash->len ) == 0 );
exit:
;
}
void test_md5_text_wrapper( void ** params )
{
data_t data1 = {(uint8_t *) params[1], *( (uint32_t *) params[2] )};
test_md5_text( (char *) params[0], &data1 );
}
#endif /* MBEDTLS_MD5_C */
#if defined(MBEDTLS_RIPEMD160_C)
void test_ripemd160_text( char * text_src_string, data_t * hash )
{
int ret;
unsigned char src_str[100];
unsigned char output[20];
memset(src_str, 0x00, sizeof src_str);
memset(output, 0x00, sizeof output);
strncpy( (char *) src_str, text_src_string, sizeof(src_str) - 1 );
ret = mbedtls_ripemd160_ret( src_str, strlen( (char *) src_str ), output );
TEST_ASSERT( ret == 0 );
TEST_ASSERT( mbedtls_test_hexcmp( output, hash->x,
sizeof output, hash->len ) == 0 );
exit:
;
}
void test_ripemd160_text_wrapper( void ** params )
{
data_t data1 = {(uint8_t *) params[1], *( (uint32_t *) params[2] )};
test_ripemd160_text( (char *) params[0], &data1 );
}
#endif /* MBEDTLS_RIPEMD160_C */
#if defined(MBEDTLS_MD2_C)
#if defined(MBEDTLS_SELF_TEST)
void test_md2_selftest( )
{
TEST_ASSERT( mbedtls_md2_self_test( 1 ) == 0 );
exit:
;
}
void test_md2_selftest_wrapper( void ** params )
{
(void)params;
test_md2_selftest( );
}
#endif /* MBEDTLS_SELF_TEST */
#endif /* MBEDTLS_MD2_C */
#if defined(MBEDTLS_MD4_C)
#if defined(MBEDTLS_SELF_TEST)
void test_md4_selftest( )
{
TEST_ASSERT( mbedtls_md4_self_test( 1 ) == 0 );
exit:
;
}
void test_md4_selftest_wrapper( void ** params )
{
(void)params;
test_md4_selftest( );
}
#endif /* MBEDTLS_SELF_TEST */
#endif /* MBEDTLS_MD4_C */
#if defined(MBEDTLS_MD5_C)
#if defined(MBEDTLS_SELF_TEST)
void test_md5_selftest( )
{
TEST_ASSERT( mbedtls_md5_self_test( 1 ) == 0 );
exit:
;
}
void test_md5_selftest_wrapper( void ** params )
{
(void)params;
test_md5_selftest( );
}
#endif /* MBEDTLS_SELF_TEST */
#endif /* MBEDTLS_MD5_C */
#if defined(MBEDTLS_RIPEMD160_C)
#if defined(MBEDTLS_SELF_TEST)
void test_ripemd160_selftest( )
{
TEST_ASSERT( mbedtls_ripemd160_self_test( 1 ) == 0 );
exit:
;
}
void test_ripemd160_selftest_wrapper( void ** params )
{
(void)params;
test_ripemd160_selftest( );
}
#endif /* MBEDTLS_SELF_TEST */
#endif /* MBEDTLS_RIPEMD160_C */
/*----------------------------------------------------------------------------*/
/* Test dispatch code */
/**
* \brief Evaluates an expression/macro into its literal integer value.
* For optimizing space for embedded targets each expression/macro
* is identified by a unique identifier instead of string literals.
* Identifiers and evaluation code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param exp_id Expression identifier.
* \param out_value Pointer to int to hold the integer.
*
* \return 0 if exp_id is found. 1 otherwise.
*/
int get_expression( int32_t exp_id, int32_t * out_value )
{
int ret = KEY_VALUE_MAPPING_FOUND;
(void) exp_id;
(void) out_value;
switch( exp_id )
{
default:
{
ret = KEY_VALUE_MAPPING_NOT_FOUND;
}
break;
}
return( ret );
}
/**
* \brief Checks if the dependency i.e. the compile flag is set.
* For optimizing space for embedded targets each dependency
* is identified by a unique identifier instead of string literals.
* Identifiers and check code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param dep_id Dependency identifier.
*
* \return DEPENDENCY_SUPPORTED if set else DEPENDENCY_NOT_SUPPORTED
*/
int dep_check( int dep_id )
{
int ret = DEPENDENCY_NOT_SUPPORTED;
(void) dep_id;
switch( dep_id )
{
default:
break;
}
return( ret );
}
/**
* \brief Function pointer type for test function wrappers.
*
* A test function wrapper decodes the parameters and passes them to the
* underlying test function. Both the wrapper and the underlying function
* return void. Test wrappers assume that they are passed a suitable
* parameter array and do not perform any error detection.
*
* \param param_array The array of parameters. Each element is a `void *`
* which the wrapper casts to the correct type and
* dereferences. Each wrapper function hard-codes the
* number and types of the parameters.
*/
typedef void (*TestWrapper_t)( void **param_array );
/**
* \brief Table of test function wrappers. Used by dispatch_test().
* This table is populated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
*/
TestWrapper_t test_funcs[] =
{
/* Function Id: 0 */
#if defined(MBEDTLS_MD2_C)
test_md2_text_wrapper,
#else
NULL,
#endif
/* Function Id: 1 */
#if defined(MBEDTLS_MD4_C)
test_md4_text_wrapper,
#else
NULL,
#endif
/* Function Id: 2 */
#if defined(MBEDTLS_MD5_C)
test_md5_text_wrapper,
#else
NULL,
#endif
/* Function Id: 3 */
#if defined(MBEDTLS_RIPEMD160_C)
test_ripemd160_text_wrapper,
#else
NULL,
#endif
/* Function Id: 4 */
#if defined(MBEDTLS_MD2_C) && defined(MBEDTLS_SELF_TEST)
test_md2_selftest_wrapper,
#else
NULL,
#endif
/* Function Id: 5 */
#if defined(MBEDTLS_MD4_C) && defined(MBEDTLS_SELF_TEST)
test_md4_selftest_wrapper,
#else
NULL,
#endif
/* Function Id: 6 */
#if defined(MBEDTLS_MD5_C) && defined(MBEDTLS_SELF_TEST)
test_md5_selftest_wrapper,
#else
NULL,
#endif
/* Function Id: 7 */
#if defined(MBEDTLS_RIPEMD160_C) && defined(MBEDTLS_SELF_TEST)
test_ripemd160_selftest_wrapper,
#else
NULL,
#endif
};
/**
* \brief Execute the test function.
*
* This is a wrapper function around the test function execution
* to allow the setjmp() call used to catch any calls to the
* parameter failure callback, to be used. Calls to setjmp()
* can invalidate the state of any local auto variables.
*
* \param fp Function pointer to the test function.
* \param params Parameters to pass to the #TestWrapper_t wrapper function.
*
*/
void execute_function_ptr(TestWrapper_t fp, void **params)
{
#if defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG)
mbedtls_test_enable_insecure_external_rng( );
#endif
#if defined(MBEDTLS_CHECK_PARAMS)
mbedtls_test_param_failed_location_record_t location_record;
if ( setjmp( mbedtls_test_param_failed_get_state_buf( ) ) == 0 )
{
fp( params );
}
else
{
/* Unexpected parameter validation error */
mbedtls_test_param_failed_get_location_record( &location_record );
mbedtls_test_fail( location_record.failure_condition,
location_record.line,
location_record.file );
}
mbedtls_test_param_failed_reset_state( );
#else
fp( params );
#endif
#if defined(MBEDTLS_TEST_MUTEX_USAGE)
mbedtls_test_mutex_usage_check( );
#endif /* MBEDTLS_TEST_MUTEX_USAGE */
}
/**
* \brief Dispatches test functions based on function index.
*
* \param func_idx Test function index.
* \param params The array of parameters to pass to the test function.
* It will be decoded by the #TestWrapper_t wrapper function.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int dispatch_test( size_t func_idx, void ** params )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof( test_funcs ) / sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp )
execute_function_ptr(fp, params);
else
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
/**
* \brief Checks if test function is supported in this build-time
* configuration.
*
* \param func_idx Test function index.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int check_test( size_t func_idx )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof(test_funcs)/sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp == NULL )
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
int main( int argc, const char *argv[] )
{
int ret;
mbedtls_test_platform_setup();
ret = execute_tests( argc, argv, "/zip/third_party/mbedtls/test/test_suite_mdx.datax" );
mbedtls_test_platform_teardown();
return( ret );
}
| 12,644 | 482 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_gcm.aes192_de.c | /* clang-format off */
/*
* Copyright The Mbed TLS Contributors
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "third_party/mbedtls/test/test.inc"
/*
* *** THIS FILE WAS MACHINE GENERATED ***
*
* This file has been machine generated using the script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* Test file : ./test_suite_gcm.aes192_de.c
*
* The following files were used to create this file.
*
* Main code file : suites/main_test.function
* Platform code file : suites/host_test.function
* Helper file : suites/helpers.function
* Test suite file : suites/test_suite_gcm.function
* Test suite data : suites/test_suite_gcm.aes192_de.data
*
*/
#define TEST_SUITE_ACTIVE
#if defined(MBEDTLS_GCM_C)
#include "third_party/mbedtls/gcm.h"
void test_gcm_bad_parameters( int cipher_id, int direction,
data_t *key_str, data_t *src_str,
data_t *iv_str, data_t *add_str,
int tag_len_bits, int gcm_result )
{
unsigned char output[128];
unsigned char tag_output[16];
mbedtls_gcm_context ctx;
size_t tag_len = tag_len_bits / 8;
mbedtls_gcm_init( &ctx );
memset( output, 0x00, sizeof( output ) );
memset( tag_output, 0x00, sizeof( tag_output ) );
TEST_ASSERT( mbedtls_gcm_setkey( &ctx, cipher_id, key_str->x, key_str->len * 8 ) == 0 );
TEST_ASSERT( mbedtls_gcm_crypt_and_tag( &ctx, direction, src_str->len, iv_str->x, iv_str->len,
add_str->x, add_str->len, src_str->x, output, tag_len, tag_output ) == gcm_result );
exit:
mbedtls_gcm_free( &ctx );
}
void test_gcm_bad_parameters_wrapper( void ** params )
{
data_t data2 = {(uint8_t *) params[2], *( (uint32_t *) params[3] )};
data_t data4 = {(uint8_t *) params[4], *( (uint32_t *) params[5] )};
data_t data6 = {(uint8_t *) params[6], *( (uint32_t *) params[7] )};
data_t data8 = {(uint8_t *) params[8], *( (uint32_t *) params[9] )};
test_gcm_bad_parameters( *( (int *) params[0] ), *( (int *) params[1] ), &data2, &data4, &data6, &data8, *( (int *) params[10] ), *( (int *) params[11] ) );
}
void test_gcm_encrypt_and_tag( int cipher_id, data_t * key_str,
data_t * src_str, data_t * iv_str,
data_t * add_str, data_t * dst,
int tag_len_bits, data_t * tag,
int init_result )
{
unsigned char output[128];
unsigned char tag_output[16];
mbedtls_gcm_context ctx;
size_t tag_len = tag_len_bits / 8;
mbedtls_gcm_init( &ctx );
memset(output, 0x00, 128);
memset(tag_output, 0x00, 16);
TEST_ASSERT( mbedtls_gcm_setkey( &ctx, cipher_id, key_str->x, key_str->len * 8 ) == init_result );
if( init_result == 0 )
{
TEST_ASSERT( mbedtls_gcm_crypt_and_tag( &ctx, MBEDTLS_GCM_ENCRYPT, src_str->len, iv_str->x, iv_str->len, add_str->x, add_str->len, src_str->x, output, tag_len, tag_output ) == 0 );
TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x,
src_str->len, dst->len ) == 0 );
TEST_ASSERT( mbedtls_test_hexcmp( tag_output, tag->x,
tag_len, tag->len ) == 0 );
}
exit:
mbedtls_gcm_free( &ctx );
}
void test_gcm_encrypt_and_tag_wrapper( void ** params )
{
data_t data1 = {(uint8_t *) params[1], *( (uint32_t *) params[2] )};
data_t data3 = {(uint8_t *) params[3], *( (uint32_t *) params[4] )};
data_t data5 = {(uint8_t *) params[5], *( (uint32_t *) params[6] )};
data_t data7 = {(uint8_t *) params[7], *( (uint32_t *) params[8] )};
data_t data9 = {(uint8_t *) params[9], *( (uint32_t *) params[10] )};
data_t data12 = {(uint8_t *) params[12], *( (uint32_t *) params[13] )};
test_gcm_encrypt_and_tag( *( (int *) params[0] ), &data1, &data3, &data5, &data7, &data9, *( (int *) params[11] ), &data12, *( (int *) params[14] ) );
}
void test_gcm_decrypt_and_verify( int cipher_id, data_t * key_str,
data_t * src_str, data_t * iv_str,
data_t * add_str, int tag_len_bits,
data_t * tag_str, char * result,
data_t * pt_result, int init_result )
{
unsigned char output[128];
mbedtls_gcm_context ctx;
int ret;
size_t tag_len = tag_len_bits / 8;
mbedtls_gcm_init( &ctx );
memset(output, 0x00, 128);
TEST_ASSERT( mbedtls_gcm_setkey( &ctx, cipher_id, key_str->x, key_str->len * 8 ) == init_result );
if( init_result == 0 )
{
ret = mbedtls_gcm_auth_decrypt( &ctx, src_str->len, iv_str->x, iv_str->len, add_str->x, add_str->len, tag_str->x, tag_len, src_str->x, output );
if( strcmp( "FAIL", result ) == 0 )
{
TEST_ASSERT( ret == MBEDTLS_ERR_GCM_AUTH_FAILED );
}
else
{
TEST_ASSERT( ret == 0 );
TEST_ASSERT( mbedtls_test_hexcmp( output, pt_result->x,
src_str->len,
pt_result->len ) == 0 );
}
}
exit:
mbedtls_gcm_free( &ctx );
}
void test_gcm_decrypt_and_verify_wrapper( void ** params )
{
data_t data1 = {(uint8_t *) params[1], *( (uint32_t *) params[2] )};
data_t data3 = {(uint8_t *) params[3], *( (uint32_t *) params[4] )};
data_t data5 = {(uint8_t *) params[5], *( (uint32_t *) params[6] )};
data_t data7 = {(uint8_t *) params[7], *( (uint32_t *) params[8] )};
data_t data10 = {(uint8_t *) params[10], *( (uint32_t *) params[11] )};
data_t data13 = {(uint8_t *) params[13], *( (uint32_t *) params[14] )};
test_gcm_decrypt_and_verify( *( (int *) params[0] ), &data1, &data3, &data5, &data7, *( (int *) params[9] ), &data10, (char *) params[12], &data13, *( (int *) params[15] ) );
}
#if defined(MBEDTLS_CHECK_PARAMS)
#if !defined(MBEDTLS_PARAM_FAILED_ALT)
void test_gcm_invalid_param( )
{
mbedtls_gcm_context ctx;
unsigned char valid_buffer[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
mbedtls_cipher_id_t valid_cipher = MBEDTLS_CIPHER_ID_AES;
int valid_mode = MBEDTLS_GCM_ENCRYPT;
int valid_len = sizeof(valid_buffer);
int valid_bitlen = 128, invalid_bitlen = 1;
mbedtls_gcm_init( &ctx );
/* mbedtls_gcm_init() */
TEST_INVALID_PARAM( mbedtls_gcm_init( NULL ) );
/* mbedtls_gcm_setkey */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
mbedtls_gcm_setkey( NULL, valid_cipher, valid_buffer, valid_bitlen ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
mbedtls_gcm_setkey( &ctx, valid_cipher, NULL, valid_bitlen ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
mbedtls_gcm_setkey( &ctx, valid_cipher, valid_buffer, invalid_bitlen ) );
/* mbedtls_gcm_crypt_and_tag() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
mbedtls_gcm_crypt_and_tag( NULL, valid_mode, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_buffer,
valid_len, valid_buffer ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
mbedtls_gcm_crypt_and_tag( &ctx, valid_mode, valid_len,
NULL, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_buffer,
valid_len, valid_buffer ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
mbedtls_gcm_crypt_and_tag( &ctx, valid_mode, valid_len,
valid_buffer, valid_len,
NULL, valid_len,
valid_buffer, valid_buffer,
valid_len, valid_buffer ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
mbedtls_gcm_crypt_and_tag( &ctx, valid_mode, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_len,
NULL, valid_buffer,
valid_len, valid_buffer ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
mbedtls_gcm_crypt_and_tag( &ctx, valid_mode, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_len,
valid_buffer, NULL,
valid_len, valid_buffer ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
mbedtls_gcm_crypt_and_tag( &ctx, valid_mode, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_buffer,
valid_len, NULL ) );
/* mbedtls_gcm_auth_decrypt() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
mbedtls_gcm_auth_decrypt( NULL, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_buffer) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
mbedtls_gcm_auth_decrypt( &ctx, valid_len,
NULL, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_buffer) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
mbedtls_gcm_auth_decrypt( &ctx, valid_len,
valid_buffer, valid_len,
NULL, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_buffer) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
mbedtls_gcm_auth_decrypt( &ctx, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_len,
NULL, valid_len,
valid_buffer, valid_buffer) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
mbedtls_gcm_auth_decrypt( &ctx, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_len,
NULL, valid_buffer) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
mbedtls_gcm_auth_decrypt( &ctx, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_len,
valid_buffer, NULL) );
/* mbedtls_gcm_starts() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
mbedtls_gcm_starts( NULL, valid_mode,
valid_buffer, valid_len,
valid_buffer, valid_len ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
mbedtls_gcm_starts( &ctx, valid_mode,
NULL, valid_len,
valid_buffer, valid_len ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
mbedtls_gcm_starts( &ctx, valid_mode,
valid_buffer, valid_len,
NULL, valid_len ) );
/* mbedtls_gcm_update() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
mbedtls_gcm_update( NULL, valid_len,
valid_buffer, valid_buffer ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
mbedtls_gcm_update( &ctx, valid_len,
NULL, valid_buffer ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
mbedtls_gcm_update( &ctx, valid_len,
valid_buffer, NULL ) );
/* mbedtls_gcm_finish() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
mbedtls_gcm_finish( NULL, valid_buffer, valid_len ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
mbedtls_gcm_finish( &ctx, NULL, valid_len ) );
exit:
mbedtls_gcm_free( &ctx );
}
void test_gcm_invalid_param_wrapper( void ** params )
{
(void)params;
test_gcm_invalid_param( );
}
#endif /* !MBEDTLS_PARAM_FAILED_ALT */
#endif /* MBEDTLS_CHECK_PARAMS */
void test_gcm_valid_param( )
{
TEST_VALID_PARAM( mbedtls_gcm_free( NULL ) );
exit:
return;
}
void test_gcm_valid_param_wrapper( void ** params )
{
(void)params;
test_gcm_valid_param( );
}
#if defined(MBEDTLS_SELF_TEST)
void test_gcm_selftest( )
{
TEST_ASSERT( mbedtls_gcm_self_test( 1 ) == 0 );
exit:
;
}
void test_gcm_selftest_wrapper( void ** params )
{
(void)params;
test_gcm_selftest( );
}
#endif /* MBEDTLS_SELF_TEST */
#endif /* MBEDTLS_GCM_C */
/*----------------------------------------------------------------------------*/
/* Test dispatch code */
/**
* \brief Evaluates an expression/macro into its literal integer value.
* For optimizing space for embedded targets each expression/macro
* is identified by a unique identifier instead of string literals.
* Identifiers and evaluation code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param exp_id Expression identifier.
* \param out_value Pointer to int to hold the integer.
*
* \return 0 if exp_id is found. 1 otherwise.
*/
int get_expression( int32_t exp_id, int32_t * out_value )
{
int ret = KEY_VALUE_MAPPING_FOUND;
(void) exp_id;
(void) out_value;
switch( exp_id )
{
#if defined(MBEDTLS_GCM_C)
case 0:
{
*out_value = MBEDTLS_CIPHER_ID_AES;
}
break;
case 1:
{
*out_value = MBEDTLS_GCM_DECRYPT;
}
break;
case 2:
{
*out_value = MBEDTLS_ERR_GCM_BAD_INPUT;
}
break;
#endif
default:
{
ret = KEY_VALUE_MAPPING_NOT_FOUND;
}
break;
}
return( ret );
}
/**
* \brief Checks if the dependency i.e. the compile flag is set.
* For optimizing space for embedded targets each dependency
* is identified by a unique identifier instead of string literals.
* Identifiers and check code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param dep_id Dependency identifier.
*
* \return DEPENDENCY_SUPPORTED if set else DEPENDENCY_NOT_SUPPORTED
*/
int dep_check( int dep_id )
{
int ret = DEPENDENCY_NOT_SUPPORTED;
(void) dep_id;
switch( dep_id )
{
#if defined(MBEDTLS_GCM_C)
case 0:
{
#if defined(MBEDTLS_AES_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
#endif
default:
break;
}
return( ret );
}
/**
* \brief Function pointer type for test function wrappers.
*
* A test function wrapper decodes the parameters and passes them to the
* underlying test function. Both the wrapper and the underlying function
* return void. Test wrappers assume that they are passed a suitable
* parameter array and do not perform any error detection.
*
* \param param_array The array of parameters. Each element is a `void *`
* which the wrapper casts to the correct type and
* dereferences. Each wrapper function hard-codes the
* number and types of the parameters.
*/
typedef void (*TestWrapper_t)( void **param_array );
/**
* \brief Table of test function wrappers. Used by dispatch_test().
* This table is populated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
*/
TestWrapper_t test_funcs[] =
{
/* Function Id: 0 */
#if defined(MBEDTLS_GCM_C)
test_gcm_bad_parameters_wrapper,
#else
NULL,
#endif
/* Function Id: 1 */
#if defined(MBEDTLS_GCM_C)
test_gcm_encrypt_and_tag_wrapper,
#else
NULL,
#endif
/* Function Id: 2 */
#if defined(MBEDTLS_GCM_C)
test_gcm_decrypt_and_verify_wrapper,
#else
NULL,
#endif
/* Function Id: 3 */
#if defined(MBEDTLS_GCM_C) && defined(MBEDTLS_CHECK_PARAMS) && !defined(MBEDTLS_PARAM_FAILED_ALT)
test_gcm_invalid_param_wrapper,
#else
NULL,
#endif
/* Function Id: 4 */
#if defined(MBEDTLS_GCM_C)
test_gcm_valid_param_wrapper,
#else
NULL,
#endif
/* Function Id: 5 */
#if defined(MBEDTLS_GCM_C) && defined(MBEDTLS_SELF_TEST)
test_gcm_selftest_wrapper,
#else
NULL,
#endif
};
/**
* \brief Execute the test function.
*
* This is a wrapper function around the test function execution
* to allow the setjmp() call used to catch any calls to the
* parameter failure callback, to be used. Calls to setjmp()
* can invalidate the state of any local auto variables.
*
* \param fp Function pointer to the test function.
* \param params Parameters to pass to the #TestWrapper_t wrapper function.
*
*/
void execute_function_ptr(TestWrapper_t fp, void **params)
{
#if defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG)
mbedtls_test_enable_insecure_external_rng( );
#endif
#if defined(MBEDTLS_CHECK_PARAMS)
mbedtls_test_param_failed_location_record_t location_record;
if ( setjmp( mbedtls_test_param_failed_get_state_buf( ) ) == 0 )
{
fp( params );
}
else
{
/* Unexpected parameter validation error */
mbedtls_test_param_failed_get_location_record( &location_record );
mbedtls_test_fail( location_record.failure_condition,
location_record.line,
location_record.file );
}
mbedtls_test_param_failed_reset_state( );
#else
fp( params );
#endif
#if defined(MBEDTLS_TEST_MUTEX_USAGE)
mbedtls_test_mutex_usage_check( );
#endif /* MBEDTLS_TEST_MUTEX_USAGE */
}
/**
* \brief Dispatches test functions based on function index.
*
* \param func_idx Test function index.
* \param params The array of parameters to pass to the test function.
* It will be decoded by the #TestWrapper_t wrapper function.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int dispatch_test( size_t func_idx, void ** params )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof( test_funcs ) / sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp )
execute_function_ptr(fp, params);
else
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
/**
* \brief Checks if test function is supported in this build-time
* configuration.
*
* \param func_idx Test function index.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int check_test( size_t func_idx )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof(test_funcs)/sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp == NULL )
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
int main( int argc, const char *argv[] )
{
int ret;
mbedtls_test_platform_setup();
ret = execute_tests( argc, argv, "/zip/third_party/mbedtls/test/test_suite_gcm.aes192_de.datax" );
mbedtls_test_platform_teardown();
return( ret );
}
| 21,330 | 643 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_timing.datax | Timing: hardclock
0
Timing: get timer
1
Timing: set alarm with no delay
2:int:0
Timing: set alarm with 1s delay
2:int:1
Timing: delay 0ms
3:int:0
Timing: delay 100ms
3:int:100
| 182 | 19 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_aes.cbc.datax | AES-128-CBC Encrypt NIST KAT #1
2:hex:"fffffffffffff8000000000000000000":hex:"00000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"8b527a6aebdaec9eaef8eda2cb7783e5":int:0
AES-128-CBC Encrypt NIST KAT #2
2:hex:"fffffffffffffc000000000000000000":hex:"00000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"43fdaf53ebbc9880c228617d6a9b548b":int:0
AES-128-CBC Encrypt NIST KAT #3
2:hex:"fffffffffffffe000000000000000000":hex:"00000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"53786104b9744b98f052c46f1c850d0b":int:0
AES-128-CBC Encrypt NIST KAT #4
2:hex:"e37b1c6aa2846f6fdb413f238b089f23":hex:"00000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"43c9f7e62f5d288bb27aa40ef8fe1ea8":int:0
AES-128-CBC Encrypt NIST KAT #5
2:hex:"6c002b682483e0cabcc731c253be5674":hex:"00000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"3580d19cff44f1014a7c966a69059de5":int:0
AES-128-CBC Encrypt NIST KAT #6
2:hex:"143ae8ed6555aba96110ab58893a8ae1":hex:"00000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"806da864dd29d48deafbe764f8202aef":int:0
AES-128-CBC Encrypt NIST KAT #7
2:hex:"00000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"6a118a874519e64e9963798a503f1d35":hex:"dc43be40be0e53712f7e2bf5ca707209":int:0
AES-128-CBC Encrypt NIST KAT #8
2:hex:"00000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"cb9fceec81286ca3e989bd979b0cb284":hex:"92beedab1895a94faa69b632e5cc47ce":int:0
AES-128-CBC Encrypt NIST KAT #9
2:hex:"00000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"b26aeb1874e47ca8358ff22378f09144":hex:"459264f4798f6a78bacb89c15ed3d601":int:0
AES-128-CBC Encrypt NIST KAT #10
2:hex:"00000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"ffffffffffffffffffffffc000000000":hex:"90684a2ac55fe1ec2b8ebd5622520b73":int:0
AES-128-CBC Encrypt NIST KAT #11
2:hex:"00000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"ffffffffffffffffffffffe000000000":hex:"7472f9a7988607ca79707795991035e6":int:0
AES-128-CBC Encrypt NIST KAT #12
2:hex:"00000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"fffffffffffffffffffffff000000000":hex:"56aff089878bf3352f8df172a3ae47d8":int:0
AES-128-CBC Decrypt NIST KAT #1
3:hex:"ffffffffe00000000000000000000000":hex:"00000000000000000000000000000000":hex:"23f710842b9bb9c32f26648c786807ca":hex:"00000000000000000000000000000000":int:0
AES-128-CBC Decrypt NIST KAT #2
3:hex:"fffffffff00000000000000000000000":hex:"00000000000000000000000000000000":hex:"44a98bf11e163f632c47ec6a49683a89":hex:"00000000000000000000000000000000":int:0
AES-128-CBC Decrypt NIST KAT #3
3:hex:"fffffffff80000000000000000000000":hex:"00000000000000000000000000000000":hex:"0f18aff94274696d9b61848bd50ac5e5":hex:"00000000000000000000000000000000":int:0
AES-128-CBC Decrypt NIST KAT #4
3:hex:"e234cdca2606b81f29408d5f6da21206":hex:"00000000000000000000000000000000":hex:"fff60a4740086b3b9c56195b98d91a7b":hex:"00000000000000000000000000000000":int:0
AES-128-CBC Decrypt NIST KAT #5
3:hex:"13237c49074a3da078dc1d828bb78c6f":hex:"00000000000000000000000000000000":hex:"8146a08e2357f0caa30ca8c94d1a0544":hex:"00000000000000000000000000000000":int:0
AES-128-CBC Decrypt NIST KAT #6
3:hex:"3071a2a48fe6cbd04f1a129098e308f8":hex:"00000000000000000000000000000000":hex:"4b98e06d356deb07ebb824e5713f7be3":hex:"00000000000000000000000000000000":int:0
AES-128-CBC Decrypt NIST KAT #7
3:hex:"00000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"0336763e966d92595a567cc9ce537f5e":hex:"f34481ec3cc627bacd5dc3fb08f273e6":int:0
AES-128-CBC Decrypt NIST KAT #8
3:hex:"00000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"a9a1631bf4996954ebc093957b234589":hex:"9798c4640bad75c7c3227db910174e72":int:0
AES-128-CBC Decrypt NIST KAT #9
3:hex:"00000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"ff4f8391a6a40ca5b25d23bedd44a597":hex:"96ab5c2ff612d9dfaae8c31f30c42168":int:0
AES-128-CBC Decrypt NIST KAT #10
3:hex:"00000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"f9b0fda0c4a898f5b9e6f661c4ce4d07":hex:"fffffffffffffffffffffffffffffff0":int:0
AES-128-CBC Decrypt NIST KAT #11
3:hex:"00000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"8ade895913685c67c5269f8aae42983e":hex:"fffffffffffffffffffffffffffffff8":int:0
AES-128-CBC Decrypt NIST KAT #12
3:hex:"00000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"39bde67d5c8ed8a8b1c37eb8fa9f5ac0":hex:"fffffffffffffffffffffffffffffffc":int:0
AES-192-CBC Encrypt NIST KAT #1
2:hex:"fffffffffffffffffffffffffffffffffffffffffffffe00":hex:"00000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"ddb505e6cc1384cbaec1df90b80beb20":int:0
AES-192-CBC Encrypt NIST KAT #2
2:hex:"ffffffffffffffffffffffffffffffffffffffffffffff00":hex:"00000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"5674a3bed27bf4bd3622f9f5fe208306":int:0
AES-192-CBC Encrypt NIST KAT #3
2:hex:"ffffffffffffffffffffffffffffffffffffffffffffff80":hex:"00000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"b687f26a89cfbfbb8e5eeac54055315e":int:0
AES-192-CBC Encrypt NIST KAT #4
2:hex:"25a39dbfd8034f71a81f9ceb55026e4037f8f6aa30ab44ce":hex:"00000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"3608c344868e94555d23a120f8a5502d":int:0
AES-192-CBC Encrypt NIST KAT #5
2:hex:"e08c15411774ec4a908b64eadc6ac4199c7cd453f3aaef53":hex:"00000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"77da2021935b840b7f5dcc39132da9e5":int:0
AES-192-CBC Encrypt NIST KAT #6
2:hex:"3b375a1ff7e8d44409696e6326ec9dec86138e2ae010b980":hex:"00000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"3b7c24f825e3bf9873c9f14d39a0e6f4":int:0
AES-192-CBC Encrypt NIST KAT #7
2:hex:"000000000000000000000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"51719783d3185a535bd75adc65071ce1":hex:"4f354592ff7c8847d2d0870ca9481b7c":int:0
AES-192-CBC Encrypt NIST KAT #8
2:hex:"000000000000000000000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"26aa49dcfe7629a8901a69a9914e6dfd":hex:"d5e08bf9a182e857cf40b3a36ee248cc":int:0
AES-192-CBC Encrypt NIST KAT #9
2:hex:"000000000000000000000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"941a4773058224e1ef66d10e0a6ee782":hex:"067cd9d3749207791841562507fa9626":int:0
AES-192-CBC Encrypt NIST KAT #10
2:hex:"000000000000000000000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"ffc00000000000000000000000000000":hex:"030d7e5b64f380a7e4ea5387b5cd7f49":int:0
AES-192-CBC Encrypt NIST KAT #11
2:hex:"000000000000000000000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"ffe00000000000000000000000000000":hex:"0dc9a2610037009b698f11bb7e86c83e":int:0
AES-192-CBC Encrypt NIST KAT #12
2:hex:"000000000000000000000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"fff00000000000000000000000000000":hex:"0046612c766d1840c226364f1fa7ed72":int:0
AES-192-CBC Decrypt NIST KAT #1
3:hex:"000000000000000000000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"902d88d13eae52089abd6143cfe394e9":hex:"ffffffffe00000000000000000000000":int:0
AES-192-CBC Decrypt NIST KAT #2
3:hex:"000000000000000000000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"d49bceb3b823fedd602c305345734bd2":hex:"fffffffff00000000000000000000000":int:0
AES-192-CBC Decrypt NIST KAT #3
3:hex:"000000000000000000000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"707b1dbb0ffa40ef7d95def421233fae":hex:"fffffffff80000000000000000000000":int:0
AES-192-CBC Decrypt NIST KAT #4
3:hex:"fffffffffffffffffffc0000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"8dfd999be5d0cfa35732c0ddc88ff5a5":hex:"00000000000000000000000000000000":int:0
AES-192-CBC Decrypt NIST KAT #5
3:hex:"fffffffffffffffffffe0000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"02647c76a300c3173b841487eb2bae9f":hex:"00000000000000000000000000000000":int:0
AES-192-CBC Decrypt NIST KAT #6
3:hex:"ffffffffffffffffffff0000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"172df8b02f04b53adab028b4e01acd87":hex:"00000000000000000000000000000000":int:0
AES-192-CBC Decrypt NIST KAT #7
3:hex:"b3ad5cea1dddc214ca969ac35f37dae1a9a9d1528f89bb35":hex:"00000000000000000000000000000000":hex:"3cf5e1d21a17956d1dffad6a7c41c659":hex:"00000000000000000000000000000000":int:0
AES-192-CBC Decrypt NIST KAT #8
3:hex:"45899367c3132849763073c435a9288a766c8b9ec2308516":hex:"00000000000000000000000000000000":hex:"69fd12e8505f8ded2fdcb197a121b362":hex:"00000000000000000000000000000000":int:0
AES-192-CBC Decrypt NIST KAT #9
3:hex:"ec250e04c3903f602647b85a401a1ae7ca2f02f67fa4253e":hex:"00000000000000000000000000000000":hex:"8aa584e2cc4d17417a97cb9a28ba29c8":hex:"00000000000000000000000000000000":int:0
AES-192-CBC Decrypt NIST KAT #10
3:hex:"000000000000000000000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"c9b8135ff1b5adc413dfd053b21bd96d":hex:"9c2d8842e5f48f57648205d39a239af1":int:0
AES-192-CBC Decrypt NIST KAT #11
3:hex:"000000000000000000000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"4a3650c3371ce2eb35e389a171427440":hex:"bff52510095f518ecca60af4205444bb":int:0
AES-192-CBC Decrypt NIST KAT #12
3:hex:"000000000000000000000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"4f354592ff7c8847d2d0870ca9481b7c":hex:"51719783d3185a535bd75adc65071ce1":int:0
AES-256-CBC Encrypt NIST KAT #1
2:hex:"8000000000000000000000000000000000000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"e35a6dcb19b201a01ebcfa8aa22b5759":int:0
AES-256-CBC Encrypt NIST KAT #2
2:hex:"c000000000000000000000000000000000000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"b29169cdcf2d83e838125a12ee6aa400":int:0
AES-256-CBC Encrypt NIST KAT #3
2:hex:"e000000000000000000000000000000000000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"d8f3a72fc3cdf74dfaf6c3e6b97b2fa6":int:0
AES-256-CBC Encrypt NIST KAT #4
2:hex:"dc0eba1f2232a7879ded34ed8428eeb8769b056bbaf8ad77cb65c3541430b4cf":hex:"00000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"fc6aec906323480005c58e7e1ab004ad":int:0
AES-256-CBC Encrypt NIST KAT #5
2:hex:"f8be9ba615c5a952cabbca24f68f8593039624d524c816acda2c9183bd917cb9":hex:"00000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"a3944b95ca0b52043584ef02151926a8":int:0
AES-256-CBC Encrypt NIST KAT #6
2:hex:"797f8b3d176dac5b7e34a2d539c4ef367a16f8635f6264737591c5c07bf57a3e":hex:"00000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"a74289fe73a4c123ca189ea1e1b49ad5":int:0
AES-256-CBC Encrypt NIST KAT #7
2:hex:"0000000000000000000000000000000000000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"761c1fe41a18acf20d241650611d90f1":hex:"623a52fcea5d443e48d9181ab32c7421":int:0
AES-256-CBC Encrypt NIST KAT #8
2:hex:"0000000000000000000000000000000000000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"8a560769d605868ad80d819bdba03771":hex:"38f2c7ae10612415d27ca190d27da8b4":int:0
AES-256-CBC Encrypt NIST KAT #9
2:hex:"0000000000000000000000000000000000000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"91fbef2d15a97816060bee1feaa49afe":hex:"1bc704f1bce135ceb810341b216d7abe":int:0
AES-256-CBC Encrypt NIST KAT #10
2:hex:"0000000000000000000000000000000000000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"ffffffffffffff800000000000000000":hex:"0d9ac756eb297695eed4d382eb126d26":int:0
AES-256-CBC Encrypt NIST KAT #11
2:hex:"0000000000000000000000000000000000000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"ffffffffffffffc00000000000000000":hex:"56ede9dda3f6f141bff1757fa689c3e1":int:0
AES-256-CBC Encrypt NIST KAT #12
2:hex:"0000000000000000000000000000000000000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"ffffffffffffffe00000000000000000":hex:"768f520efe0f23e61d3ec8ad9ce91774":int:0
AES-256-CBC Decrypt NIST KAT #1
3:hex:"0000000000000000000000000000000000000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"49af6b372135acef10132e548f217b17":hex:"ff000000000000000000000000000000":int:0
AES-256-CBC Decrypt NIST KAT #2
3:hex:"0000000000000000000000000000000000000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"8bcd40f94ebb63b9f7909676e667f1e7":hex:"ff800000000000000000000000000000":int:0
AES-256-CBC Decrypt NIST KAT #3
3:hex:"0000000000000000000000000000000000000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"fe1cffb83f45dcfb38b29be438dbd3ab":hex:"ffc00000000000000000000000000000":int:0
AES-256-CBC Decrypt NIST KAT #4
3:hex:"fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc00":hex:"00000000000000000000000000000000":hex:"cca7c3086f5f9511b31233da7cab9160":hex:"00000000000000000000000000000000":int:0
AES-256-CBC Decrypt NIST KAT #5
3:hex:"fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe00":hex:"00000000000000000000000000000000":hex:"5b40ff4ec9be536ba23035fa4f06064c":hex:"00000000000000000000000000000000":int:0
AES-256-CBC Decrypt NIST KAT #6
3:hex:"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00":hex:"00000000000000000000000000000000":hex:"60eb5af8416b257149372194e8b88749":hex:"00000000000000000000000000000000":int:0
AES-256-CBC Decrypt NIST KAT #7
3:hex:"90143ae20cd78c5d8ebdd6cb9dc1762427a96c78c639bccc41a61424564eafe1":hex:"00000000000000000000000000000000":hex:"798c7c005dee432b2c8ea5dfa381ecc3":hex:"00000000000000000000000000000000":int:0
AES-256-CBC Decrypt NIST KAT #8
3:hex:"b7a5794d52737475d53d5a377200849be0260a67a2b22ced8bbef12882270d07":hex:"00000000000000000000000000000000":hex:"637c31dc2591a07636f646b72daabbe7":hex:"00000000000000000000000000000000":int:0
AES-256-CBC Decrypt NIST KAT #9
3:hex:"fca02f3d5011cfc5c1e23165d413a049d4526a991827424d896fe3435e0bf68e":hex:"00000000000000000000000000000000":hex:"179a49c712154bbffbe6e7a84a18e220":hex:"00000000000000000000000000000000":int:0
AES-256-CBC Decrypt NIST KAT #10
3:hex:"0000000000000000000000000000000000000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"5c9d844ed46f9885085e5d6a4f94c7d7":hex:"014730f80ac625fe84f026c60bfd547d":int:0
AES-256-CBC Decrypt NIST KAT #11
3:hex:"0000000000000000000000000000000000000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"a9ff75bd7cf6613d3731c77c3b6d0c04":hex:"0b24af36193ce4665f2825d7b4749c98":int:0
AES-256-CBC Decrypt NIST KAT #12
3:hex:"0000000000000000000000000000000000000000000000000000000000000000":hex:"00000000000000000000000000000000":hex:"623a52fcea5d443e48d9181ab32c7421":hex:"761c1fe41a18acf20d241650611d90f1":int:0
| 15,354 | 217 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_pk.c | /* clang-format off */
/*
* Copyright The Mbed TLS Contributors
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "third_party/mbedtls/test/test.inc"
/*
* *** THIS FILE WAS MACHINE GENERATED ***
*
* This file has been machine generated using the script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* Test file : ./test_suite_pk.c
*
* The following files were used to create this file.
*
* Main code file : suites/main_test.function
* Platform code file : suites/host_test.function
* Helper file : suites/helpers.function
* Test suite file : suites/test_suite_pk.function
* Test suite data : suites/test_suite_pk.data
*
*/
#define TEST_SUITE_ACTIVE
#if defined(MBEDTLS_PK_C)
#include "third_party/mbedtls/pk.h"
/* For error codes */
#include "third_party/mbedtls/asn1.h"
#include "third_party/mbedtls/base64.h"
#include "third_party/mbedtls/ecp.h"
#include "third_party/mbedtls/rsa.h"
/* Needed only for test case data under #if defined(MBEDTLS_USE_PSA_CRYPTO),
* but the test code generator requires test case data to be valid C code
* unconditionally (https://github.com/ARMmbed/mbedtls/issues/2023). */
#define RSA_KEY_SIZE 512
#define RSA_KEY_LEN 64
/** Generate a key of the desired type.
*
* \param pk The PK object to fill. It must have been initialized
* with mbedtls_pk_setup().
* \param parameter - For RSA keys, the key size in bits.
* - For EC keys, the curve (\c MBEDTLS_ECP_DP_xxx).
*
* \return The status from the underlying type-specific key
* generation function.
* \return -1 if the key type is not recognized.
*/
static int pk_genkey( mbedtls_pk_context *pk, int parameter )
{
((void) pk);
(void) parameter;
#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_GENPRIME)
if( mbedtls_pk_get_type( pk ) == MBEDTLS_PK_RSA )
return mbedtls_rsa_gen_key( mbedtls_pk_rsa( *pk ),
mbedtls_test_rnd_std_rand, NULL,
parameter, 3 );
#endif
#if defined(MBEDTLS_ECP_C)
if( mbedtls_pk_get_type( pk ) == MBEDTLS_PK_ECKEY ||
mbedtls_pk_get_type( pk ) == MBEDTLS_PK_ECKEY_DH ||
mbedtls_pk_get_type( pk ) == MBEDTLS_PK_ECDSA )
{
int ret;
if( ( ret = mbedtls_ecp_group_load( &mbedtls_pk_ec( *pk )->grp,
parameter ) ) != 0 )
return( ret );
return mbedtls_ecp_gen_keypair( &mbedtls_pk_ec( *pk )->grp,
&mbedtls_pk_ec( *pk )->d,
&mbedtls_pk_ec( *pk )->Q,
mbedtls_test_rnd_std_rand, NULL );
}
#endif
return( -1 );
}
#if defined(MBEDTLS_RSA_C)
int mbedtls_rsa_decrypt_func( void *ctx, int mode, size_t *olen,
const unsigned char *input, unsigned char *output,
size_t output_max_len )
{
return( mbedtls_rsa_pkcs1_decrypt( (mbedtls_rsa_context *) ctx,
mbedtls_test_rnd_std_rand, NULL, mode,
olen, input, output, output_max_len ) );
}
int mbedtls_rsa_sign_func( void *ctx,
int (*f_rng)(void *, unsigned char *, size_t), void *p_rng,
int mode, mbedtls_md_type_t md_alg, unsigned int hashlen,
const unsigned char *hash, unsigned char *sig )
{
((void) f_rng);
((void) p_rng);
return( mbedtls_rsa_pkcs1_sign( (mbedtls_rsa_context *) ctx,
mbedtls_test_rnd_std_rand, NULL, mode,
md_alg, hashlen, hash, sig ) );
}
size_t mbedtls_rsa_key_len_func( void *ctx )
{
return( ((const mbedtls_rsa_context *) ctx)->len );
}
#endif /* MBEDTLS_RSA_C */
#if defined(MBEDTLS_USE_PSA_CRYPTO)
/*
* Generate a key using PSA and return the key identifier of that key,
* or 0 if the key generation failed.
* The key uses NIST P-256 and is usable for signing with SHA-256.
*/
mbedtls_svc_key_id_t pk_psa_genkey( void )
{
mbedtls_svc_key_id_t key;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
const psa_key_type_t type =
PSA_KEY_TYPE_ECC_KEY_PAIR( PSA_ECC_FAMILY_SECP_R1 );
const size_t bits = 256;
psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_HASH );
psa_set_key_algorithm( &attributes, PSA_ALG_ECDSA(PSA_ALG_SHA_256) );
psa_set_key_type( &attributes, type );
psa_set_key_bits( &attributes, bits );
PSA_ASSERT( psa_generate_key( &attributes, &key ) );
exit:
return( key );
}
#endif /* MBEDTLS_USE_PSA_CRYPTO */
#if defined(MBEDTLS_USE_PSA_CRYPTO)
#if defined(MBEDTLS_ECDSA_C)
#if defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED)
void test_pk_psa_utils( )
{
mbedtls_pk_context pk, pk2;
mbedtls_svc_key_id_t key;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
const char * const name = "Opaque";
const size_t bitlen = 256; /* harcoded in genkey() */
mbedtls_md_type_t md_alg = MBEDTLS_MD_NONE;
unsigned char b1[1], b2[1];
size_t len;
mbedtls_pk_debug_item dbg;
PSA_ASSERT( psa_crypto_init( ) );
mbedtls_pk_init( &pk );
mbedtls_pk_init( &pk2 );
TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
TEST_ASSERT( mbedtls_pk_setup_opaque( &pk, MBEDTLS_SVC_KEY_ID_INIT ) ==
MBEDTLS_ERR_PK_BAD_INPUT_DATA );
mbedtls_pk_free( &pk );
mbedtls_pk_init( &pk );
key = pk_psa_genkey();
if( mbedtls_svc_key_id_is_null( key ) )
goto exit;
TEST_ASSERT( mbedtls_pk_setup_opaque( &pk, key ) == 0 );
TEST_ASSERT( mbedtls_pk_get_type( &pk ) == MBEDTLS_PK_OPAQUE );
TEST_ASSERT( strcmp( mbedtls_pk_get_name( &pk), name ) == 0 );
TEST_ASSERT( mbedtls_pk_get_bitlen( &pk ) == bitlen );
TEST_ASSERT( mbedtls_pk_get_len( &pk ) == bitlen / 8 );
TEST_ASSERT( mbedtls_pk_can_do( &pk, MBEDTLS_PK_ECKEY ) == 1 );
TEST_ASSERT( mbedtls_pk_can_do( &pk, MBEDTLS_PK_ECDSA ) == 1 );
TEST_ASSERT( mbedtls_pk_can_do( &pk, MBEDTLS_PK_RSA ) == 0 );
/* unsupported operations: verify, decrypt, encrypt */
TEST_ASSERT( mbedtls_pk_verify( &pk, md_alg,
b1, sizeof( b1), b2, sizeof( b2 ) )
== MBEDTLS_ERR_PK_TYPE_MISMATCH );
TEST_ASSERT( mbedtls_pk_decrypt( &pk, b1, sizeof( b1 ),
b2, &len, sizeof( b2 ),
NULL, NULL )
== MBEDTLS_ERR_PK_TYPE_MISMATCH );
TEST_ASSERT( mbedtls_pk_encrypt( &pk, b1, sizeof( b1 ),
b2, &len, sizeof( b2 ),
NULL, NULL )
== MBEDTLS_ERR_PK_TYPE_MISMATCH );
/* unsupported functions: check_pair, debug */
TEST_ASSERT( mbedtls_pk_setup( &pk2,
mbedtls_pk_info_from_type( MBEDTLS_PK_ECKEY ) ) == 0 );
TEST_ASSERT( mbedtls_pk_check_pair( &pk, &pk2 )
== MBEDTLS_ERR_PK_TYPE_MISMATCH );
TEST_ASSERT( mbedtls_pk_debug( &pk, &dbg )
== MBEDTLS_ERR_PK_TYPE_MISMATCH );
/* test that freeing the context does not destroy the key */
mbedtls_pk_free( &pk );
TEST_ASSERT( PSA_SUCCESS == psa_get_key_attributes( key, &attributes ) );
TEST_ASSERT( PSA_SUCCESS == psa_destroy_key( key ) );
exit:
/*
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
psa_reset_key_attributes( &attributes );
mbedtls_pk_free( &pk ); /* redundant except upon error */
mbedtls_pk_free( &pk2 );
USE_PSA_DONE( );
}
void test_pk_psa_utils_wrapper( void ** params )
{
(void)params;
test_pk_psa_utils( );
}
#endif /* MBEDTLS_ECP_DP_SECP256R1_ENABLED */
#endif /* MBEDTLS_ECDSA_C */
#endif /* MBEDTLS_USE_PSA_CRYPTO */
void test_valid_parameters( )
{
mbedtls_pk_context pk;
unsigned char buf[1];
size_t len;
void *options = NULL;
mbedtls_pk_init( &pk );
TEST_VALID_PARAM( mbedtls_pk_free( NULL ) );
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
TEST_VALID_PARAM( mbedtls_pk_restart_free( NULL ) );
#endif
TEST_ASSERT( mbedtls_pk_setup( &pk, NULL ) ==
MBEDTLS_ERR_PK_BAD_INPUT_DATA );
/* In informational functions, we accept NULL where a context pointer
* is expected because that's what the library has done forever.
* We do not document that NULL is accepted, so we may wish to change
* the behavior in a future version. */
TEST_ASSERT( mbedtls_pk_get_bitlen( NULL ) == 0 );
TEST_ASSERT( mbedtls_pk_get_len( NULL ) == 0 );
TEST_ASSERT( mbedtls_pk_can_do( NULL, MBEDTLS_PK_NONE ) == 0 );
TEST_ASSERT( mbedtls_pk_sign_restartable( &pk,
MBEDTLS_MD_NONE,
NULL, 0,
buf, &len,
mbedtls_test_rnd_std_rand, NULL,
NULL ) ==
MBEDTLS_ERR_PK_BAD_INPUT_DATA );
TEST_ASSERT( mbedtls_pk_sign_restartable( &pk,
MBEDTLS_MD_NONE,
NULL, 0,
buf, &len,
mbedtls_test_rnd_std_rand, NULL,
NULL ) ==
MBEDTLS_ERR_PK_BAD_INPUT_DATA );
TEST_ASSERT( mbedtls_pk_sign( &pk,
MBEDTLS_MD_NONE,
NULL, 0,
buf, &len,
mbedtls_test_rnd_std_rand, NULL ) ==
MBEDTLS_ERR_PK_BAD_INPUT_DATA );
TEST_ASSERT( mbedtls_pk_verify_restartable( &pk,
MBEDTLS_MD_NONE,
NULL, 0,
buf, sizeof( buf ),
NULL ) ==
MBEDTLS_ERR_PK_BAD_INPUT_DATA );
TEST_ASSERT( mbedtls_pk_verify( &pk,
MBEDTLS_MD_NONE,
NULL, 0,
buf, sizeof( buf ) ) ==
MBEDTLS_ERR_PK_BAD_INPUT_DATA );
TEST_ASSERT( mbedtls_pk_verify_ext( MBEDTLS_PK_NONE, options,
&pk,
MBEDTLS_MD_NONE,
NULL, 0,
buf, sizeof( buf ) ) ==
MBEDTLS_ERR_PK_BAD_INPUT_DATA );
TEST_ASSERT( mbedtls_pk_encrypt( &pk,
NULL, 0,
NULL, &len, 0,
mbedtls_test_rnd_std_rand, NULL ) ==
MBEDTLS_ERR_PK_BAD_INPUT_DATA );
TEST_ASSERT( mbedtls_pk_decrypt( &pk,
NULL, 0,
NULL, &len, 0,
mbedtls_test_rnd_std_rand, NULL ) ==
MBEDTLS_ERR_PK_BAD_INPUT_DATA );
#if defined(MBEDTLS_PK_PARSE_C)
TEST_ASSERT( mbedtls_pk_parse_key( &pk, NULL, 0, NULL, 1 ) ==
MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
TEST_ASSERT( mbedtls_pk_parse_public_key( &pk, NULL, 0 ) ==
MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
#endif /* MBEDTLS_PK_PARSE_C */
exit:
;
}
void test_valid_parameters_wrapper( void ** params )
{
(void)params;
test_valid_parameters( );
}
#if defined(MBEDTLS_PK_WRITE_C)
void test_valid_parameters_pkwrite( data_t *key_data )
{
mbedtls_pk_context pk;
/* For the write tests to be effective, we need a valid key pair. */
mbedtls_pk_init( &pk );
TEST_ASSERT( mbedtls_pk_parse_key( &pk,
key_data->x, key_data->len,
NULL, 0 ) == 0 );
TEST_ASSERT( mbedtls_pk_write_key_der( &pk, NULL, 0 ) ==
MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
TEST_ASSERT( mbedtls_pk_write_pubkey_der( &pk, NULL, 0 ) ==
MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
#if defined(MBEDTLS_PEM_WRITE_C)
TEST_ASSERT( mbedtls_pk_write_key_pem( &pk, NULL, 0 ) ==
MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL );
TEST_ASSERT( mbedtls_pk_write_pubkey_pem( &pk, NULL, 0 ) ==
MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL );
#endif /* MBEDTLS_PEM_WRITE_C */
exit:
mbedtls_pk_free( &pk );
}
void test_valid_parameters_pkwrite_wrapper( void ** params )
{
data_t data0 = {(uint8_t *) params[0], *( (uint32_t *) params[1] )};
test_valid_parameters_pkwrite( &data0 );
}
#endif /* MBEDTLS_PK_WRITE_C */
#if defined(MBEDTLS_CHECK_PARAMS)
#if !defined(MBEDTLS_PARAM_FAILED_ALT)
void test_invalid_parameters( )
{
size_t len;
unsigned char *null_buf = NULL;
unsigned char buf[1];
unsigned char *p = buf;
char str[1] = {0};
mbedtls_pk_context pk;
mbedtls_md_type_t valid_md = MBEDTLS_MD_SHA256;
void *options = buf;
(void) null_buf;
(void) p;
(void) str;
mbedtls_pk_init( &pk );
TEST_INVALID_PARAM( mbedtls_pk_init( NULL ) );
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
TEST_INVALID_PARAM( mbedtls_pk_restart_init( NULL ) );
#endif
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_setup( NULL, NULL ) );
#if defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_setup_rsa_alt( NULL, buf,
NULL, NULL, NULL ) );
#endif
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_verify_restartable( NULL,
MBEDTLS_MD_NONE,
buf, sizeof( buf ),
buf, sizeof( buf ),
NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_verify_restartable( &pk,
MBEDTLS_MD_NONE,
NULL, sizeof( buf ),
buf, sizeof( buf ),
NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_verify_restartable( &pk,
valid_md,
NULL, 0,
buf, sizeof( buf ),
NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_verify_restartable( &pk,
MBEDTLS_MD_NONE,
buf, sizeof( buf ),
NULL, sizeof( buf ),
NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_verify( NULL,
MBEDTLS_MD_NONE,
buf, sizeof( buf ),
buf, sizeof( buf ) ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_verify( &pk,
MBEDTLS_MD_NONE,
NULL, sizeof( buf ),
buf, sizeof( buf ) ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_verify( &pk,
valid_md,
NULL, 0,
buf, sizeof( buf ) ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_verify( &pk,
MBEDTLS_MD_NONE,
buf, sizeof( buf ),
NULL, sizeof( buf ) ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_verify_ext( MBEDTLS_PK_NONE, options,
NULL,
MBEDTLS_MD_NONE,
buf, sizeof( buf ),
buf, sizeof( buf ) ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_verify_ext( MBEDTLS_PK_NONE, options,
&pk,
MBEDTLS_MD_NONE,
NULL, sizeof( buf ),
buf, sizeof( buf ) ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_verify_ext( MBEDTLS_PK_NONE, options,
&pk,
valid_md,
NULL, 0,
buf, sizeof( buf ) ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_verify_ext( MBEDTLS_PK_NONE, options,
&pk,
MBEDTLS_MD_NONE,
buf, sizeof( buf ),
NULL, sizeof( buf ) ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_sign_restartable( NULL, MBEDTLS_MD_NONE, buf, sizeof( buf ),
buf, &len, mbedtls_test_rnd_std_rand,
NULL, NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_sign_restartable( &pk, MBEDTLS_MD_NONE, NULL, sizeof( buf ),
buf, &len, mbedtls_test_rnd_std_rand,
NULL, NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_sign_restartable( &pk, valid_md, NULL, 0, buf, &len,
mbedtls_test_rnd_std_rand, NULL, NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_sign_restartable( &pk, MBEDTLS_MD_NONE, buf, sizeof( buf ),
NULL, &len, mbedtls_test_rnd_std_rand,
NULL, NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_sign( NULL, MBEDTLS_MD_NONE, buf, sizeof( buf ),
buf, &len, mbedtls_test_rnd_std_rand, NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_sign( &pk, MBEDTLS_MD_NONE, NULL, sizeof( buf ),
buf, &len, mbedtls_test_rnd_std_rand, NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_sign( &pk, valid_md, NULL, 0, buf, &len,
mbedtls_test_rnd_std_rand, NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_sign( &pk, MBEDTLS_MD_NONE, buf, sizeof( buf ), NULL, &len,
mbedtls_test_rnd_std_rand, NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_decrypt( NULL, buf, sizeof( buf ), buf, &len, sizeof( buf ),
mbedtls_test_rnd_std_rand, NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_decrypt( &pk, NULL, sizeof( buf ), buf, &len, sizeof( buf ),
mbedtls_test_rnd_std_rand, NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_decrypt( &pk, buf, sizeof( buf ), NULL, &len, sizeof( buf ),
mbedtls_test_rnd_std_rand, NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_decrypt( &pk, buf, sizeof( buf ), buf, NULL, sizeof( buf ),
mbedtls_test_rnd_std_rand, NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_encrypt( NULL, buf, sizeof( buf ), buf, &len, sizeof( buf ),
mbedtls_test_rnd_std_rand, NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_encrypt( &pk, NULL, sizeof( buf ), buf, &len, sizeof( buf ),
mbedtls_test_rnd_std_rand, NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_encrypt( &pk, buf, sizeof( buf ), NULL, &len, sizeof( buf ),
mbedtls_test_rnd_std_rand, NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_encrypt( &pk, buf, sizeof( buf ), buf, NULL, sizeof( buf ),
mbedtls_test_rnd_std_rand, NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_check_pair( NULL, &pk ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_check_pair( &pk, NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_debug( NULL, NULL ) );
#if defined(MBEDTLS_PK_PARSE_C)
#if defined(MBEDTLS_FS_IO)
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_load_file( NULL, &p, &len ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_load_file( str, NULL, &len ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_load_file( str, &p, NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_parse_keyfile( NULL, str, NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_parse_keyfile( &pk, NULL, NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_parse_public_keyfile( NULL, str ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_parse_public_keyfile( &pk, NULL ) );
#endif
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_parse_subpubkey( NULL, buf, &pk ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_parse_subpubkey( &null_buf, buf, &pk ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_parse_subpubkey( &p, NULL, &pk ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_parse_subpubkey( &p, buf, NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_parse_key( NULL,
buf, sizeof( buf ),
buf, sizeof( buf ) ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_parse_key( &pk,
NULL, sizeof( buf ),
buf, sizeof( buf ) ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_parse_public_key( NULL,
buf, sizeof( buf ) ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_parse_public_key( &pk,
NULL, sizeof( buf ) ) );
#endif /* MBEDTLS_PK_PARSE_C */
#if defined(MBEDTLS_PK_WRITE_C)
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_write_pubkey( NULL, p, &pk ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_write_pubkey( &null_buf, p, &pk ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_write_pubkey( &p, NULL, &pk ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_write_pubkey( &p, p, NULL ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_write_pubkey_der( NULL,
buf, sizeof( buf ) ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_write_pubkey_der( &pk,
NULL, sizeof( buf ) ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_write_key_der( NULL,
buf, sizeof( buf ) ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_write_key_der( &pk,
NULL, sizeof( buf ) ) );
#if defined(MBEDTLS_PEM_WRITE_C)
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_write_pubkey_pem( NULL,
buf, sizeof( buf ) ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_write_pubkey_pem( &pk,
NULL, sizeof( buf ) ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_write_key_pem( NULL,
buf, sizeof( buf ) ) );
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_write_key_pem( &pk,
NULL, sizeof( buf ) ) );
#endif /* MBEDTLS_PEM_WRITE_C */
#endif /* MBEDTLS_PK_WRITE_C */
exit:
;
}
void test_invalid_parameters_wrapper( void ** params )
{
(void)params;
test_invalid_parameters( );
}
#endif /* !MBEDTLS_PARAM_FAILED_ALT */
#endif /* MBEDTLS_CHECK_PARAMS */
void test_pk_utils( int type, int parameter, int bitlen, int len, char * name )
{
mbedtls_pk_context pk;
mbedtls_pk_init( &pk );
TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( type ) ) == 0 );
TEST_ASSERT( pk_genkey( &pk, parameter ) == 0 );
TEST_ASSERT( (int) mbedtls_pk_get_type( &pk ) == type );
TEST_ASSERT( mbedtls_pk_can_do( &pk, type ) );
TEST_ASSERT( mbedtls_pk_get_bitlen( &pk ) == (unsigned) bitlen );
TEST_ASSERT( mbedtls_pk_get_len( &pk ) == (unsigned) len );
TEST_ASSERT( strcmp( mbedtls_pk_get_name( &pk), name ) == 0 );
exit:
mbedtls_pk_free( &pk );
}
void test_pk_utils_wrapper( void ** params )
{
test_pk_utils( *( (int *) params[0] ), *( (int *) params[1] ), *( (int *) params[2] ), *( (int *) params[3] ), (char *) params[4] );
}
#if defined(MBEDTLS_PK_PARSE_C)
#if defined(MBEDTLS_FS_IO)
void test_mbedtls_pk_check_pair( char * pub_file, char * prv_file, int ret )
{
mbedtls_pk_context pub, prv, alt;
mbedtls_pk_init( &pub );
mbedtls_pk_init( &prv );
mbedtls_pk_init( &alt );
TEST_ASSERT( mbedtls_pk_parse_public_keyfile( &pub, pub_file ) == 0 );
TEST_ASSERT( mbedtls_pk_parse_keyfile( &prv, prv_file, NULL ) == 0 );
TEST_ASSERT( mbedtls_pk_check_pair( &pub, &prv ) == ret );
#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
if( mbedtls_pk_get_type( &prv ) == MBEDTLS_PK_RSA )
{
TEST_ASSERT( mbedtls_pk_setup_rsa_alt( &alt, mbedtls_pk_rsa( prv ),
mbedtls_rsa_decrypt_func, mbedtls_rsa_sign_func,
mbedtls_rsa_key_len_func ) == 0 );
TEST_ASSERT( mbedtls_pk_check_pair( &pub, &alt ) == ret );
}
#endif
mbedtls_pk_free( &pub );
mbedtls_pk_free( &prv );
mbedtls_pk_free( &alt );
exit:
;
}
void test_mbedtls_pk_check_pair_wrapper( void ** params )
{
test_mbedtls_pk_check_pair( (char *) params[0], (char *) params[1], *( (int *) params[2] ) );
}
#endif /* MBEDTLS_FS_IO */
#endif /* MBEDTLS_PK_PARSE_C */
#if defined(MBEDTLS_RSA_C)
void test_pk_rsa_verify_test_vec( data_t * message_str, int digest, int mod,
int radix_N, char * input_N, int radix_E,
char * input_E, data_t * result_str,
int result )
{
unsigned char hash_result[MBEDTLS_MD_MAX_SIZE];
mbedtls_rsa_context *rsa;
mbedtls_pk_context pk;
mbedtls_pk_restart_ctx *rs_ctx = NULL;
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
mbedtls_pk_restart_ctx ctx;
rs_ctx = &ctx;
mbedtls_pk_restart_init( rs_ctx );
// this setting would ensure restart would happen if ECC was used
mbedtls_ecp_set_max_ops( 1 );
#endif
mbedtls_pk_init( &pk );
memset( hash_result, 0x00, MBEDTLS_MD_MAX_SIZE );
TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
rsa = mbedtls_pk_rsa( pk );
rsa->len = mod / 8;
TEST_ASSERT( mbedtls_mpi_read_string( &rsa->N, radix_N, input_N ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &rsa->E, radix_E, input_E ) == 0 );
if( mbedtls_md_info_from_type( digest ) != NULL )
TEST_ASSERT( mbedtls_md( mbedtls_md_info_from_type( digest ), message_str->x, message_str->len, hash_result ) == 0 );
TEST_ASSERT( mbedtls_pk_verify( &pk, digest, hash_result, 0,
result_str->x, mbedtls_pk_get_len( &pk ) ) == result );
TEST_ASSERT( mbedtls_pk_verify_restartable( &pk, digest, hash_result, 0,
result_str->x, mbedtls_pk_get_len( &pk ), rs_ctx ) == result );
exit:
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
mbedtls_pk_restart_free( rs_ctx );
#endif
mbedtls_pk_free( &pk );
}
void test_pk_rsa_verify_test_vec_wrapper( void ** params )
{
data_t data0 = {(uint8_t *) params[0], *( (uint32_t *) params[1] )};
data_t data8 = {(uint8_t *) params[8], *( (uint32_t *) params[9] )};
test_pk_rsa_verify_test_vec( &data0, *( (int *) params[2] ), *( (int *) params[3] ), *( (int *) params[4] ), (char *) params[5], *( (int *) params[6] ), (char *) params[7], &data8, *( (int *) params[10] ) );
}
#endif /* MBEDTLS_RSA_C */
#if defined(MBEDTLS_RSA_C)
void test_pk_rsa_verify_ext_test_vec( data_t * message_str, int digest,
int mod, int radix_N, char * input_N,
int radix_E, char * input_E,
data_t * result_str, int pk_type,
int mgf1_hash_id, int salt_len, int result )
{
unsigned char hash_result[MBEDTLS_MD_MAX_SIZE];
mbedtls_rsa_context *rsa;
mbedtls_pk_context pk;
mbedtls_pk_rsassa_pss_options pss_opts;
void *options;
size_t hash_len;
mbedtls_pk_init( &pk );
memset( hash_result, 0x00, sizeof( hash_result ) );
TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
rsa = mbedtls_pk_rsa( pk );
rsa->len = mod / 8;
TEST_ASSERT( mbedtls_mpi_read_string( &rsa->N, radix_N, input_N ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &rsa->E, radix_E, input_E ) == 0 );
if( digest != MBEDTLS_MD_NONE )
{
TEST_ASSERT( mbedtls_md( mbedtls_md_info_from_type( digest ),
message_str->x, message_str->len, hash_result ) == 0 );
hash_len = 0;
}
else
{
memcpy( hash_result, message_str->x, message_str->len );
hash_len = message_str->len;
}
if( mgf1_hash_id < 0 )
{
options = NULL;
}
else
{
options = &pss_opts;
pss_opts.mgf1_hash_id = mgf1_hash_id;
pss_opts.expected_salt_len = salt_len;
}
TEST_ASSERT( mbedtls_pk_verify_ext( pk_type, options, &pk,
digest, hash_result, hash_len,
result_str->x, mbedtls_pk_get_len( &pk ) ) == result );
exit:
mbedtls_pk_free( &pk );
}
void test_pk_rsa_verify_ext_test_vec_wrapper( void ** params )
{
data_t data0 = {(uint8_t *) params[0], *( (uint32_t *) params[1] )};
data_t data8 = {(uint8_t *) params[8], *( (uint32_t *) params[9] )};
test_pk_rsa_verify_ext_test_vec( &data0, *( (int *) params[2] ), *( (int *) params[3] ), *( (int *) params[4] ), (char *) params[5], *( (int *) params[6] ), (char *) params[7], &data8, *( (int *) params[10] ), *( (int *) params[11] ), *( (int *) params[12] ), *( (int *) params[13] ) );
}
#endif /* MBEDTLS_RSA_C */
#if defined(MBEDTLS_ECDSA_C)
void test_pk_ec_test_vec( int type, int id, data_t * key, data_t * hash,
data_t * sig, int ret )
{
mbedtls_pk_context pk;
mbedtls_ecp_keypair *eckey;
mbedtls_pk_init( &pk );
USE_PSA_INIT( );
TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( type ) ) == 0 );
TEST_ASSERT( mbedtls_pk_can_do( &pk, MBEDTLS_PK_ECDSA ) );
eckey = mbedtls_pk_ec( pk );
TEST_ASSERT( mbedtls_ecp_group_load( &eckey->grp, id ) == 0 );
TEST_ASSERT( mbedtls_ecp_point_read_binary( &eckey->grp, &eckey->Q,
key->x, key->len ) == 0 );
// MBEDTLS_MD_NONE is used since it will be ignored.
TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_NONE,
hash->x, hash->len, sig->x, sig->len ) == ret );
exit:
mbedtls_pk_free( &pk );
USE_PSA_DONE( );
}
void test_pk_ec_test_vec_wrapper( void ** params )
{
data_t data2 = {(uint8_t *) params[2], *( (uint32_t *) params[3] )};
data_t data4 = {(uint8_t *) params[4], *( (uint32_t *) params[5] )};
data_t data6 = {(uint8_t *) params[6], *( (uint32_t *) params[7] )};
test_pk_ec_test_vec( *( (int *) params[0] ), *( (int *) params[1] ), &data2, &data4, &data6, *( (int *) params[8] ) );
}
#endif /* MBEDTLS_ECDSA_C */
#if defined(MBEDTLS_ECP_RESTARTABLE)
#if defined(MBEDTLS_ECDSA_C)
#if defined(MBEDTLS_ECDSA_DETERMINISTIC)
void test_pk_sign_verify_restart( int pk_type, int grp_id, char *d_str,
char *QX_str, char *QY_str,
int md_alg, char *msg, data_t *sig_check,
int max_ops, int min_restart, int max_restart )
{
int ret, cnt_restart;
mbedtls_pk_restart_ctx rs_ctx;
mbedtls_pk_context prv, pub;
unsigned char hash[MBEDTLS_MD_MAX_SIZE];
unsigned char sig[MBEDTLS_ECDSA_MAX_LEN];
size_t hlen, slen;
const mbedtls_md_info_t *md_info;
mbedtls_pk_restart_init( &rs_ctx );
mbedtls_pk_init( &prv );
mbedtls_pk_init( &pub );
memset( hash, 0, sizeof( hash ) );
memset( sig, 0, sizeof( sig ) );
TEST_ASSERT( mbedtls_pk_setup( &prv, mbedtls_pk_info_from_type( pk_type ) ) == 0 );
TEST_ASSERT( mbedtls_ecp_group_load( &mbedtls_pk_ec( prv )->grp, grp_id ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &mbedtls_pk_ec( prv )->d, 16, d_str ) == 0 );
TEST_ASSERT( mbedtls_pk_setup( &pub, mbedtls_pk_info_from_type( pk_type ) ) == 0 );
TEST_ASSERT( mbedtls_ecp_group_load( &mbedtls_pk_ec( pub )->grp, grp_id ) == 0 );
TEST_ASSERT( mbedtls_ecp_point_read_string( &mbedtls_pk_ec( pub )->Q, 16, QX_str, QY_str ) == 0 );
md_info = mbedtls_md_info_from_type( md_alg );
TEST_ASSERT( md_info != NULL );
hlen = mbedtls_md_get_size( md_info );
TEST_ASSERT( mbedtls_md( md_info,
(const unsigned char *) msg, strlen( msg ),
hash ) == 0 );
mbedtls_ecp_set_max_ops( max_ops );
slen = sizeof( sig );
cnt_restart = 0;
do {
ret = mbedtls_pk_sign_restartable( &prv, md_alg, hash, hlen,
sig, &slen, NULL, NULL, &rs_ctx );
} while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restart );
TEST_ASSERT( ret == 0 );
TEST_ASSERT( slen == sig_check->len );
TEST_ASSERT( memcmp( sig, sig_check->x, slen ) == 0 );
TEST_ASSERT( cnt_restart >= min_restart );
TEST_ASSERT( cnt_restart <= max_restart );
cnt_restart = 0;
do {
ret = mbedtls_pk_verify_restartable( &pub, md_alg,
hash, hlen, sig, slen, &rs_ctx );
} while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restart );
TEST_ASSERT( ret == 0 );
TEST_ASSERT( cnt_restart >= min_restart );
TEST_ASSERT( cnt_restart <= max_restart );
hash[0]++;
do {
ret = mbedtls_pk_verify_restartable( &pub, md_alg,
hash, hlen, sig, slen, &rs_ctx );
} while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
TEST_ASSERT( ret != 0 );
hash[0]--;
sig[0]++;
do {
ret = mbedtls_pk_verify_restartable( &pub, md_alg,
hash, hlen, sig, slen, &rs_ctx );
} while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
TEST_ASSERT( ret != 0 );
sig[0]--;
/* Do we leak memory when aborting? try verify then sign
* This test only makes sense when we actually restart */
if( min_restart > 0 )
{
ret = mbedtls_pk_verify_restartable( &pub, md_alg,
hash, hlen, sig, slen, &rs_ctx );
TEST_ASSERT( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
mbedtls_pk_restart_free( &rs_ctx );
slen = sizeof( sig );
ret = mbedtls_pk_sign_restartable( &prv, md_alg, hash, hlen,
sig, &slen, NULL, NULL, &rs_ctx );
TEST_ASSERT( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
}
exit:
mbedtls_pk_restart_free( &rs_ctx );
mbedtls_pk_free( &prv );
mbedtls_pk_free( &pub );
}
void test_pk_sign_verify_restart_wrapper( void ** params )
{
data_t data7 = {(uint8_t *) params[7], *( (uint32_t *) params[8] )};
test_pk_sign_verify_restart( *( (int *) params[0] ), *( (int *) params[1] ), (char *) params[2], (char *) params[3], (char *) params[4], *( (int *) params[5] ), (char *) params[6], &data7, *( (int *) params[9] ), *( (int *) params[10] ), *( (int *) params[11] ) );
}
#endif /* MBEDTLS_ECDSA_DETERMINISTIC */
#endif /* MBEDTLS_ECDSA_C */
#endif /* MBEDTLS_ECP_RESTARTABLE */
#if defined(MBEDTLS_SHA256_C)
void test_pk_sign_verify( int type, int parameter, int sign_ret, int verify_ret )
{
mbedtls_pk_context pk;
size_t sig_len;
unsigned char hash[MBEDTLS_MD_MAX_SIZE];
unsigned char sig[MBEDTLS_PK_SIGNATURE_MAX_SIZE];
void *rs_ctx = NULL;
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
mbedtls_pk_restart_ctx ctx;
rs_ctx = &ctx;
mbedtls_pk_restart_init( rs_ctx );
/* This value is large enough that the operation will complete in one run.
* See comments at the top of ecp_test_vect_restart in
* test_suite_ecp.function for estimates of operation counts. */
mbedtls_ecp_set_max_ops( 42000 );
#endif
mbedtls_pk_init( &pk );
USE_PSA_INIT( );
memset( hash, 0x2a, sizeof hash );
memset( sig, 0, sizeof sig );
TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( type ) ) == 0 );
TEST_ASSERT( pk_genkey( &pk, parameter ) == 0 );
TEST_ASSERT( mbedtls_pk_sign_restartable( &pk, MBEDTLS_MD_SHA256,
hash, sizeof hash, sig, &sig_len,
mbedtls_test_rnd_std_rand, NULL, rs_ctx ) == sign_ret );
if( sign_ret == 0 )
TEST_ASSERT( sig_len <= MBEDTLS_PK_SIGNATURE_MAX_SIZE );
else
sig_len = MBEDTLS_PK_SIGNATURE_MAX_SIZE;
TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_SHA256,
hash, sizeof hash, sig, sig_len ) == verify_ret );
if( verify_ret == 0 )
{
hash[0]++;
TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_SHA256,
hash, sizeof hash, sig, sig_len ) != 0 );
hash[0]--;
sig[0]++;
TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_SHA256,
hash, sizeof hash, sig, sig_len ) != 0 );
sig[0]--;
}
TEST_ASSERT( mbedtls_pk_sign( &pk, MBEDTLS_MD_SHA256, hash, sizeof hash,
sig, &sig_len,
mbedtls_test_rnd_std_rand,
NULL ) == sign_ret );
if( sign_ret == 0 )
TEST_ASSERT( sig_len <= MBEDTLS_PK_SIGNATURE_MAX_SIZE );
else
sig_len = MBEDTLS_PK_SIGNATURE_MAX_SIZE;
TEST_ASSERT( mbedtls_pk_verify_restartable( &pk, MBEDTLS_MD_SHA256,
hash, sizeof hash, sig, sig_len, rs_ctx ) == verify_ret );
if( verify_ret == 0 )
{
hash[0]++;
TEST_ASSERT( mbedtls_pk_verify_restartable( &pk, MBEDTLS_MD_SHA256,
hash, sizeof hash, sig, sig_len, rs_ctx ) != 0 );
hash[0]--;
sig[0]++;
TEST_ASSERT( mbedtls_pk_verify_restartable( &pk, MBEDTLS_MD_SHA256,
hash, sizeof hash, sig, sig_len, rs_ctx ) != 0 );
sig[0]--;
}
exit:
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
mbedtls_pk_restart_free( rs_ctx );
#endif
mbedtls_pk_free( &pk );
USE_PSA_DONE( );
}
void test_pk_sign_verify_wrapper( void ** params )
{
test_pk_sign_verify( *( (int *) params[0] ), *( (int *) params[1] ), *( (int *) params[2] ), *( (int *) params[3] ) );
}
#endif /* MBEDTLS_SHA256_C */
#if defined(MBEDTLS_RSA_C)
void test_pk_rsa_encrypt_test_vec( data_t * message, int mod, int radix_N,
char * input_N, int radix_E, char * input_E,
data_t * result, int ret )
{
unsigned char output[300];
mbedtls_test_rnd_pseudo_info rnd_info;
mbedtls_rsa_context *rsa;
mbedtls_pk_context pk;
size_t olen;
memset( &rnd_info, 0, sizeof( mbedtls_test_rnd_pseudo_info ) );
memset( output, 0, sizeof( output ) );
mbedtls_pk_init( &pk );
TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
rsa = mbedtls_pk_rsa( pk );
rsa->len = mod / 8;
TEST_ASSERT( mbedtls_mpi_read_string( &rsa->N, radix_N, input_N ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &rsa->E, radix_E, input_E ) == 0 );
TEST_ASSERT( mbedtls_pk_encrypt( &pk, message->x, message->len,
output, &olen, sizeof( output ),
mbedtls_test_rnd_pseudo_rand, &rnd_info ) == ret );
TEST_ASSERT( olen == result->len );
TEST_ASSERT( memcmp( output, result->x, olen ) == 0 );
exit:
mbedtls_pk_free( &pk );
}
void test_pk_rsa_encrypt_test_vec_wrapper( void ** params )
{
data_t data0 = {(uint8_t *) params[0], *( (uint32_t *) params[1] )};
data_t data7 = {(uint8_t *) params[7], *( (uint32_t *) params[8] )};
test_pk_rsa_encrypt_test_vec( &data0, *( (int *) params[2] ), *( (int *) params[3] ), (char *) params[4], *( (int *) params[5] ), (char *) params[6], &data7, *( (int *) params[9] ) );
}
#endif /* MBEDTLS_RSA_C */
#if defined(MBEDTLS_RSA_C)
void test_pk_rsa_decrypt_test_vec( data_t * cipher, int mod, int radix_P,
char * input_P, int radix_Q, char * input_Q,
int radix_N, char * input_N, int radix_E,
char * input_E, data_t * clear, int ret )
{
unsigned char output[256];
mbedtls_test_rnd_pseudo_info rnd_info;
mbedtls_mpi N, P, Q, E;
mbedtls_rsa_context *rsa;
mbedtls_pk_context pk;
size_t olen;
mbedtls_pk_init( &pk );
mbedtls_mpi_init( &N ); mbedtls_mpi_init( &P );
mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &E );
memset( &rnd_info, 0, sizeof( mbedtls_test_rnd_pseudo_info ) );
/* init pk-rsa context */
TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
rsa = mbedtls_pk_rsa( pk );
/* load public key */
TEST_ASSERT( mbedtls_mpi_read_string( &N, radix_N, input_N ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &E, radix_E, input_E ) == 0 );
/* load private key */
TEST_ASSERT( mbedtls_mpi_read_string( &P, radix_P, input_P ) == 0 );
TEST_ASSERT( mbedtls_mpi_read_string( &Q, radix_Q, input_Q ) == 0 );
TEST_ASSERT( mbedtls_rsa_import( rsa, &N, &P, &Q, NULL, &E ) == 0 );
TEST_ASSERT( mbedtls_rsa_get_len( rsa ) == (size_t) ( mod / 8 ) );
TEST_ASSERT( mbedtls_rsa_complete( rsa ) == 0 );
/* decryption test */
memset( output, 0, sizeof( output ) );
olen = 0;
TEST_ASSERT( mbedtls_pk_decrypt( &pk, cipher->x, cipher->len,
output, &olen, sizeof( output ),
mbedtls_test_rnd_pseudo_rand, &rnd_info ) == ret );
if( ret == 0 )
{
TEST_ASSERT( olen == clear->len );
TEST_ASSERT( memcmp( output, clear->x, olen ) == 0 );
}
exit:
mbedtls_mpi_free( &N ); mbedtls_mpi_free( &P );
mbedtls_mpi_free( &Q ); mbedtls_mpi_free( &E );
mbedtls_pk_free( &pk );
}
void test_pk_rsa_decrypt_test_vec_wrapper( void ** params )
{
data_t data0 = {(uint8_t *) params[0], *( (uint32_t *) params[1] )};
data_t data11 = {(uint8_t *) params[11], *( (uint32_t *) params[12] )};
test_pk_rsa_decrypt_test_vec( &data0, *( (int *) params[2] ), *( (int *) params[3] ), (char *) params[4], *( (int *) params[5] ), (char *) params[6], *( (int *) params[7] ), (char *) params[8], *( (int *) params[9] ), (char *) params[10], &data11, *( (int *) params[13] ) );
}
#endif /* MBEDTLS_RSA_C */
void test_pk_ec_nocrypt( int type )
{
mbedtls_pk_context pk;
unsigned char output[100];
unsigned char input[100];
mbedtls_test_rnd_pseudo_info rnd_info;
size_t olen = 0;
int ret = MBEDTLS_ERR_PK_TYPE_MISMATCH;
mbedtls_pk_init( &pk );
memset( &rnd_info, 0, sizeof( mbedtls_test_rnd_pseudo_info ) );
memset( output, 0, sizeof( output ) );
memset( input, 0, sizeof( input ) );
TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( type ) ) == 0 );
TEST_ASSERT( mbedtls_pk_encrypt( &pk, input, sizeof( input ),
output, &olen, sizeof( output ),
mbedtls_test_rnd_pseudo_rand, &rnd_info ) == ret );
TEST_ASSERT( mbedtls_pk_decrypt( &pk, input, sizeof( input ),
output, &olen, sizeof( output ),
mbedtls_test_rnd_pseudo_rand, &rnd_info ) == ret );
exit:
mbedtls_pk_free( &pk );
}
void test_pk_ec_nocrypt_wrapper( void ** params )
{
test_pk_ec_nocrypt( *( (int *) params[0] ) );
}
#if defined(MBEDTLS_RSA_C)
void test_pk_rsa_overflow( )
{
mbedtls_pk_context pk;
size_t hash_len = SIZE_MAX, sig_len = SIZE_MAX;
unsigned char hash[50], sig[100];
if( SIZE_MAX <= UINT_MAX )
return;
memset( hash, 0x2a, sizeof hash );
memset( sig, 0, sizeof sig );
mbedtls_pk_init( &pk );
TEST_ASSERT( mbedtls_pk_setup( &pk,
mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
#if defined(MBEDTLS_PKCS1_V21)
TEST_ASSERT( mbedtls_pk_verify_ext( MBEDTLS_PK_RSASSA_PSS, NULL, &pk,
MBEDTLS_MD_NONE, hash, hash_len, sig, sig_len ) ==
MBEDTLS_ERR_PK_BAD_INPUT_DATA );
#endif /* MBEDTLS_PKCS1_V21 */
TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_NONE, hash, hash_len,
sig, sig_len ) == MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
TEST_ASSERT( mbedtls_pk_sign( &pk, MBEDTLS_MD_NONE, hash, hash_len, sig,
&sig_len, mbedtls_test_rnd_std_rand, NULL )
== MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
exit:
mbedtls_pk_free( &pk );
}
void test_pk_rsa_overflow_wrapper( void ** params )
{
(void)params;
test_pk_rsa_overflow( );
}
#endif /* MBEDTLS_RSA_C */
#if defined(MBEDTLS_RSA_C)
#if defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
void test_pk_rsa_alt( )
{
/*
* An rsa_alt context can only do private operations (decrypt, sign).
* Test it against the public operations (encrypt, verify) of a
* corresponding rsa context.
*/
mbedtls_rsa_context raw;
mbedtls_pk_context rsa, alt;
mbedtls_pk_debug_item dbg_items[10];
unsigned char hash[50], sig[64];
unsigned char msg[50], ciph[64], test[50];
size_t sig_len, ciph_len, test_len;
int ret = MBEDTLS_ERR_PK_TYPE_MISMATCH;
mbedtls_rsa_init( &raw, MBEDTLS_RSA_PKCS_V15, MBEDTLS_MD_NONE );
mbedtls_pk_init( &rsa ); mbedtls_pk_init( &alt );
memset( hash, 0x2a, sizeof hash );
memset( sig, 0, sizeof sig );
memset( msg, 0x2a, sizeof msg );
memset( ciph, 0, sizeof ciph );
memset( test, 0, sizeof test );
/* Initiliaze PK RSA context with random key */
TEST_ASSERT( mbedtls_pk_setup( &rsa,
mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
TEST_ASSERT( pk_genkey( &rsa, RSA_KEY_SIZE ) == 0 );
/* Extract key to the raw rsa context */
TEST_ASSERT( mbedtls_rsa_copy( &raw, mbedtls_pk_rsa( rsa ) ) == 0 );
/* Initialize PK RSA_ALT context */
TEST_ASSERT( mbedtls_pk_setup_rsa_alt( &alt, (void *) &raw,
mbedtls_rsa_decrypt_func, mbedtls_rsa_sign_func, mbedtls_rsa_key_len_func ) == 0 );
/* Test administrative functions */
TEST_ASSERT( mbedtls_pk_can_do( &alt, MBEDTLS_PK_RSA ) );
TEST_ASSERT( mbedtls_pk_get_bitlen( &alt ) == RSA_KEY_SIZE );
TEST_ASSERT( mbedtls_pk_get_len( &alt ) == RSA_KEY_LEN );
TEST_ASSERT( mbedtls_pk_get_type( &alt ) == MBEDTLS_PK_RSA_ALT );
TEST_ASSERT( strcmp( mbedtls_pk_get_name( &alt ), "RSA-alt" ) == 0 );
/* Test signature */
#if SIZE_MAX > UINT_MAX
TEST_ASSERT( mbedtls_pk_sign( &alt, MBEDTLS_MD_NONE, hash, SIZE_MAX, sig,
&sig_len, mbedtls_test_rnd_std_rand, NULL )
== MBEDTLS_ERR_PK_BAD_INPUT_DATA );
#endif /* SIZE_MAX > UINT_MAX */
TEST_ASSERT( mbedtls_pk_sign( &alt, MBEDTLS_MD_NONE, hash, sizeof hash, sig,
&sig_len, mbedtls_test_rnd_std_rand, NULL )
== 0 );
TEST_ASSERT( sig_len == RSA_KEY_LEN );
TEST_ASSERT( mbedtls_pk_verify( &rsa, MBEDTLS_MD_NONE,
hash, sizeof hash, sig, sig_len ) == 0 );
/* Test decrypt */
TEST_ASSERT( mbedtls_pk_encrypt( &rsa, msg, sizeof msg,
ciph, &ciph_len, sizeof ciph,
mbedtls_test_rnd_std_rand, NULL ) == 0 );
TEST_ASSERT( mbedtls_pk_decrypt( &alt, ciph, ciph_len,
test, &test_len, sizeof test,
mbedtls_test_rnd_std_rand, NULL ) == 0 );
TEST_ASSERT( test_len == sizeof msg );
TEST_ASSERT( memcmp( test, msg, test_len ) == 0 );
/* Test forbidden operations */
TEST_ASSERT( mbedtls_pk_encrypt( &alt, msg, sizeof msg,
ciph, &ciph_len, sizeof ciph,
mbedtls_test_rnd_std_rand, NULL ) == ret );
TEST_ASSERT( mbedtls_pk_verify( &alt, MBEDTLS_MD_NONE,
hash, sizeof hash, sig, sig_len ) == ret );
TEST_ASSERT( mbedtls_pk_debug( &alt, dbg_items ) == ret );
exit:
mbedtls_rsa_free( &raw );
mbedtls_pk_free( &rsa ); mbedtls_pk_free( &alt );
}
void test_pk_rsa_alt_wrapper( void ** params )
{
(void)params;
test_pk_rsa_alt( );
}
#endif /* MBEDTLS_PK_RSA_ALT_SUPPORT */
#endif /* MBEDTLS_RSA_C */
#if defined(MBEDTLS_SHA256_C)
#if defined(MBEDTLS_USE_PSA_CRYPTO)
#if defined(MBEDTLS_ECDSA_C)
void test_pk_psa_sign( int grpid_arg,
int psa_curve_arg, int expected_bits_arg )
{
mbedtls_ecp_group_id grpid = grpid_arg;
mbedtls_pk_context pk;
unsigned char hash[32];
unsigned char sig[MBEDTLS_ECDSA_MAX_LEN];
unsigned char pkey_legacy[200];
unsigned char pkey_psa[200];
unsigned char *pkey_legacy_start, *pkey_psa_start;
size_t sig_len, klen_legacy, klen_psa;
int ret;
mbedtls_svc_key_id_t key_id;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
psa_key_type_t expected_type = PSA_KEY_TYPE_ECC_KEY_PAIR( psa_curve_arg );
size_t expected_bits = expected_bits_arg;
/*
* This tests making signatures with a wrapped PSA key:
* - generate a fresh ECP legacy PK context
* - wrap it in a PK context and make a signature this way
* - extract the public key
* - parse it to a PK context and verify the signature this way
*/
PSA_ASSERT( psa_crypto_init( ) );
/* Create legacy EC public/private key in PK context. */
mbedtls_pk_init( &pk );
TEST_ASSERT( mbedtls_pk_setup( &pk,
mbedtls_pk_info_from_type( MBEDTLS_PK_ECKEY ) ) == 0 );
TEST_ASSERT( mbedtls_ecp_gen_key( grpid,
(mbedtls_ecp_keypair*) pk.pk_ctx,
mbedtls_test_rnd_std_rand, NULL ) == 0 );
/* Export underlying public key for re-importing in a legacy context. */
ret = mbedtls_pk_write_pubkey_der( &pk, pkey_legacy,
sizeof( pkey_legacy ) );
TEST_ASSERT( ret >= 0 );
klen_legacy = (size_t) ret;
/* mbedtls_pk_write_pubkey_der() writes backwards in the data buffer. */
pkey_legacy_start = pkey_legacy + sizeof( pkey_legacy ) - klen_legacy;
/* Turn PK context into an opaque one. */
TEST_ASSERT( mbedtls_pk_wrap_as_opaque( &pk, &key_id,
PSA_ALG_SHA_256 ) == 0 );
PSA_ASSERT( psa_get_key_attributes( key_id, &attributes ) );
TEST_EQUAL( psa_get_key_type( &attributes ), expected_type );
TEST_EQUAL( psa_get_key_bits( &attributes ), expected_bits );
TEST_EQUAL( psa_get_key_lifetime( &attributes ),
PSA_KEY_LIFETIME_VOLATILE );
memset( hash, 0x2a, sizeof hash );
memset( sig, 0, sizeof sig );
TEST_ASSERT( mbedtls_pk_sign( &pk, MBEDTLS_MD_SHA256,
hash, sizeof hash, sig, &sig_len,
NULL, NULL ) == 0 );
/* Export underlying public key for re-importing in a psa context. */
ret = mbedtls_pk_write_pubkey_der( &pk, pkey_psa,
sizeof( pkey_psa ) );
TEST_ASSERT( ret >= 0 );
klen_psa = (size_t) ret;
/* mbedtls_pk_write_pubkey_der() writes backwards in the data buffer. */
pkey_psa_start = pkey_psa + sizeof( pkey_psa ) - klen_psa;
TEST_ASSERT( klen_psa == klen_legacy );
TEST_ASSERT( memcmp( pkey_psa_start, pkey_legacy_start, klen_psa ) == 0 );
mbedtls_pk_free( &pk );
TEST_ASSERT( PSA_SUCCESS == psa_destroy_key( key_id ) );
mbedtls_pk_init( &pk );
TEST_ASSERT( mbedtls_pk_parse_public_key( &pk, pkey_legacy_start,
klen_legacy ) == 0 );
TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_SHA256,
hash, sizeof hash, sig, sig_len ) == 0 );
exit:
/*
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
psa_reset_key_attributes( &attributes );
mbedtls_pk_free( &pk );
USE_PSA_DONE( );
}
void test_pk_psa_sign_wrapper( void ** params )
{
test_pk_psa_sign( *( (int *) params[0] ), *( (int *) params[1] ), *( (int *) params[2] ) );
}
#endif /* MBEDTLS_ECDSA_C */
#endif /* MBEDTLS_USE_PSA_CRYPTO */
#endif /* MBEDTLS_SHA256_C */
#endif /* MBEDTLS_PK_C */
/*----------------------------------------------------------------------------*/
/* Test dispatch code */
/**
* \brief Evaluates an expression/macro into its literal integer value.
* For optimizing space for embedded targets each expression/macro
* is identified by a unique identifier instead of string literals.
* Identifiers and evaluation code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param exp_id Expression identifier.
* \param out_value Pointer to int to hold the integer.
*
* \return 0 if exp_id is found. 1 otherwise.
*/
int get_expression( int32_t exp_id, int32_t * out_value )
{
int ret = KEY_VALUE_MAPPING_FOUND;
(void) exp_id;
(void) out_value;
switch( exp_id )
{
#if defined(MBEDTLS_PK_C)
case 0:
{
*out_value = MBEDTLS_PK_RSA;
}
break;
case 1:
{
*out_value = MBEDTLS_PK_ECKEY;
}
break;
case 2:
{
*out_value = MBEDTLS_ECP_DP_SECP192R1;
}
break;
case 3:
{
*out_value = MBEDTLS_PK_ECKEY_DH;
}
break;
case 4:
{
*out_value = MBEDTLS_ECP_DP_CURVE25519;
}
break;
case 5:
{
*out_value = MBEDTLS_ECP_DP_CURVE448;
}
break;
case 6:
{
*out_value = MBEDTLS_PK_ECDSA;
}
break;
case 7:
{
*out_value = MBEDTLS_ECP_DP_SECP256R1;
}
break;
case 8:
{
*out_value = MBEDTLS_ECP_DP_SECP384R1;
}
break;
case 9:
{
*out_value = MBEDTLS_ECP_DP_SECP521R1;
}
break;
case 10:
{
*out_value = MBEDTLS_MD_SHA1;
}
break;
case 11:
{
*out_value = MBEDTLS_ERR_RSA_VERIFY_FAILED;
}
break;
case 12:
{
*out_value = MBEDTLS_ERR_ECP_VERIFY_FAILED;
}
break;
case 13:
{
*out_value = MBEDTLS_ECP_DP_BP256R1;
}
break;
case 14:
{
*out_value = MBEDTLS_ECP_DP_BP512R1;
}
break;
case 15:
{
*out_value = MBEDTLS_ERR_PK_TYPE_MISMATCH;
}
break;
case 16:
{
*out_value = MBEDTLS_ERR_RSA_INVALID_PADDING;
}
break;
case 17:
{
*out_value = MBEDTLS_MD_SHA256;
}
break;
case 18:
{
*out_value = MBEDTLS_PK_RSASSA_PSS;
}
break;
case 19:
{
*out_value = MBEDTLS_RSA_SALT_LEN_ANY;
}
break;
case 20:
{
*out_value = MBEDTLS_MD_NONE;
}
break;
case 21:
{
*out_value = -1;
}
break;
case 22:
{
*out_value = MBEDTLS_ERR_PK_BAD_INPUT_DATA;
}
break;
case 23:
{
*out_value = MBEDTLS_ERR_ECP_BAD_INPUT_DATA;
}
break;
case 24:
{
*out_value = MBEDTLS_ERR_RSA_KEY_CHECK_FAILED;
}
break;
case 25:
{
*out_value = PSA_ECC_FAMILY_SECP_R1;
}
break;
case 26:
{
*out_value = MBEDTLS_ECP_DP_SECP192K1;
}
break;
case 27:
{
*out_value = PSA_ECC_FAMILY_SECP_K1;
}
break;
case 28:
{
*out_value = MBEDTLS_ECP_DP_SECP256K1;
}
break;
case 29:
{
*out_value = PSA_ECC_FAMILY_BRAINPOOL_P_R1;
}
break;
case 30:
{
*out_value = MBEDTLS_ECP_DP_BP384R1;
}
break;
#endif
default:
{
ret = KEY_VALUE_MAPPING_NOT_FOUND;
}
break;
}
return( ret );
}
/**
* \brief Checks if the dependency i.e. the compile flag is set.
* For optimizing space for embedded targets each dependency
* is identified by a unique identifier instead of string literals.
* Identifiers and check code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
* \param dep_id Dependency identifier.
*
* \return DEPENDENCY_SUPPORTED if set else DEPENDENCY_NOT_SUPPORTED
*/
int dep_check( int dep_id )
{
int ret = DEPENDENCY_NOT_SUPPORTED;
(void) dep_id;
switch( dep_id )
{
#if defined(MBEDTLS_PK_C)
case 0:
{
#if defined(MBEDTLS_RSA_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 1:
{
#if defined(MBEDTLS_GENPRIME)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 2:
{
#if defined(MBEDTLS_ECP_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 3:
{
#if defined(MBEDTLS_ECP_DP_SECP192R1_ENABLED)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 4:
{
#if defined(MBEDTLS_ECP_DP_CURVE25519_ENABLED)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 5:
{
#if defined(MBEDTLS_ECP_DP_CURVE448_ENABLED)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 6:
{
#if defined(MBEDTLS_ECDSA_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 7:
{
#if defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 8:
{
#if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 9:
{
#if defined(MBEDTLS_ECP_DP_SECP521R1_ENABLED)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 10:
{
#if defined(MBEDTLS_SHA1_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 11:
{
#if defined(MBEDTLS_PKCS1_V15)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 12:
{
#if defined(MBEDTLS_ECP_DP_BP256R1_ENABLED)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 13:
{
#if defined(MBEDTLS_ECP_DP_BP512R1_ENABLED)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 14:
{
#if defined(MBEDTLS_PKCS1_V21)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 15:
{
#if defined(MBEDTLS_SHA256_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 16:
{
#if defined(MBEDTLS_HAVE_INT64)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 17:
{
#if defined(MBEDTLS_ECP_DP_SECP192K1_ENABLED)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 18:
{
#if defined(MBEDTLS_ECP_DP_SECP256K1_ENABLED)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 19:
{
#if defined(MBEDTLS_ECP_DP_BP384R1_ENABLED)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
#endif
default:
break;
}
return( ret );
}
/**
* \brief Function pointer type for test function wrappers.
*
* A test function wrapper decodes the parameters and passes them to the
* underlying test function. Both the wrapper and the underlying function
* return void. Test wrappers assume that they are passed a suitable
* parameter array and do not perform any error detection.
*
* \param param_array The array of parameters. Each element is a `void *`
* which the wrapper casts to the correct type and
* dereferences. Each wrapper function hard-codes the
* number and types of the parameters.
*/
typedef void (*TestWrapper_t)( void **param_array );
/**
* \brief Table of test function wrappers. Used by dispatch_test().
* This table is populated by script:
* generate_test_code.py and then mbedtls_test_suite.sh and then mbedtls_test_suite.sh
*
*/
TestWrapper_t test_funcs[] =
{
/* Function Id: 0 */
#if defined(MBEDTLS_PK_C) && defined(MBEDTLS_USE_PSA_CRYPTO) && defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED)
test_pk_psa_utils_wrapper,
#else
NULL,
#endif
/* Function Id: 1 */
#if defined(MBEDTLS_PK_C)
test_valid_parameters_wrapper,
#else
NULL,
#endif
/* Function Id: 2 */
#if defined(MBEDTLS_PK_C) && defined(MBEDTLS_PK_WRITE_C)
test_valid_parameters_pkwrite_wrapper,
#else
NULL,
#endif
/* Function Id: 3 */
#if defined(MBEDTLS_PK_C) && defined(MBEDTLS_CHECK_PARAMS) && !defined(MBEDTLS_PARAM_FAILED_ALT)
test_invalid_parameters_wrapper,
#else
NULL,
#endif
/* Function Id: 4 */
#if defined(MBEDTLS_PK_C)
test_pk_utils_wrapper,
#else
NULL,
#endif
/* Function Id: 5 */
#if defined(MBEDTLS_PK_C) && defined(MBEDTLS_PK_PARSE_C) && defined(MBEDTLS_FS_IO)
test_mbedtls_pk_check_pair_wrapper,
#else
NULL,
#endif
/* Function Id: 6 */
#if defined(MBEDTLS_PK_C) && defined(MBEDTLS_RSA_C)
test_pk_rsa_verify_test_vec_wrapper,
#else
NULL,
#endif
/* Function Id: 7 */
#if defined(MBEDTLS_PK_C) && defined(MBEDTLS_RSA_C)
test_pk_rsa_verify_ext_test_vec_wrapper,
#else
NULL,
#endif
/* Function Id: 8 */
#if defined(MBEDTLS_PK_C) && defined(MBEDTLS_ECDSA_C)
test_pk_ec_test_vec_wrapper,
#else
NULL,
#endif
/* Function Id: 9 */
#if defined(MBEDTLS_PK_C) && defined(MBEDTLS_ECP_RESTARTABLE) && defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECDSA_DETERMINISTIC)
test_pk_sign_verify_restart_wrapper,
#else
NULL,
#endif
/* Function Id: 10 */
#if defined(MBEDTLS_PK_C) && defined(MBEDTLS_SHA256_C)
test_pk_sign_verify_wrapper,
#else
NULL,
#endif
/* Function Id: 11 */
#if defined(MBEDTLS_PK_C) && defined(MBEDTLS_RSA_C)
test_pk_rsa_encrypt_test_vec_wrapper,
#else
NULL,
#endif
/* Function Id: 12 */
#if defined(MBEDTLS_PK_C) && defined(MBEDTLS_RSA_C)
test_pk_rsa_decrypt_test_vec_wrapper,
#else
NULL,
#endif
/* Function Id: 13 */
#if defined(MBEDTLS_PK_C)
test_pk_ec_nocrypt_wrapper,
#else
NULL,
#endif
/* Function Id: 14 */
#if defined(MBEDTLS_PK_C) && defined(MBEDTLS_RSA_C)
test_pk_rsa_overflow_wrapper,
#else
NULL,
#endif
/* Function Id: 15 */
#if defined(MBEDTLS_PK_C) && defined(MBEDTLS_RSA_C) && defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
test_pk_rsa_alt_wrapper,
#else
NULL,
#endif
/* Function Id: 16 */
#if defined(MBEDTLS_PK_C) && defined(MBEDTLS_SHA256_C) && defined(MBEDTLS_USE_PSA_CRYPTO) && defined(MBEDTLS_ECDSA_C)
test_pk_psa_sign_wrapper,
#else
NULL,
#endif
};
/**
* \brief Execute the test function.
*
* This is a wrapper function around the test function execution
* to allow the setjmp() call used to catch any calls to the
* parameter failure callback, to be used. Calls to setjmp()
* can invalidate the state of any local auto variables.
*
* \param fp Function pointer to the test function.
* \param params Parameters to pass to the #TestWrapper_t wrapper function.
*
*/
void execute_function_ptr(TestWrapper_t fp, void **params)
{
#if defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG)
mbedtls_test_enable_insecure_external_rng( );
#endif
#if defined(MBEDTLS_CHECK_PARAMS)
mbedtls_test_param_failed_location_record_t location_record;
if ( setjmp( mbedtls_test_param_failed_get_state_buf( ) ) == 0 )
{
fp( params );
}
else
{
/* Unexpected parameter validation error */
mbedtls_test_param_failed_get_location_record( &location_record );
mbedtls_test_fail( location_record.failure_condition,
location_record.line,
location_record.file );
}
mbedtls_test_param_failed_reset_state( );
#else
fp( params );
#endif
#if defined(MBEDTLS_TEST_MUTEX_USAGE)
mbedtls_test_mutex_usage_check( );
#endif /* MBEDTLS_TEST_MUTEX_USAGE */
}
/**
* \brief Dispatches test functions based on function index.
*
* \param func_idx Test function index.
* \param params The array of parameters to pass to the test function.
* It will be decoded by the #TestWrapper_t wrapper function.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int dispatch_test( size_t func_idx, void ** params )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof( test_funcs ) / sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp )
execute_function_ptr(fp, params);
else
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
/**
* \brief Checks if test function is supported in this build-time
* configuration.
*
* \param func_idx Test function index.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int check_test( size_t func_idx )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof(test_funcs)/sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp == NULL )
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
int main( int argc, const char *argv[] )
{
int ret;
mbedtls_test_platform_setup();
ret = execute_tests( argc, argv, "/zip/third_party/mbedtls/test/test_suite_pk.datax" );
mbedtls_test_platform_teardown();
return( ret );
}
| 73,451 | 2,114 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_ccm.c | /* clang-format off */
/*
* Copyright The Mbed TLS Contributors
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "third_party/mbedtls/test/test.inc"
/*
* *** THIS FILE WAS MACHINE GENERATED ***
*
* This file has been machine generated using the script:
* generate_test_code.py and then mbedtls_test_suite.sh
*
* Test file : ./test_suite_ccm.c
*
* The following files were used to create this file.
*
* Main code file : suites/main_test.function
* Platform code file : suites/host_test.function
* Helper file : suites/helpers.function
* Test suite file : suites/test_suite_ccm.function
* Test suite data : suites/test_suite_ccm.data
*
*/
#define TEST_SUITE_ACTIVE
#if defined(MBEDTLS_CCM_C)
#include "third_party/mbedtls/ccm.h"
#if defined(MBEDTLS_SELF_TEST)
#if defined(MBEDTLS_AES_C)
void test_mbedtls_ccm_self_test( )
{
TEST_ASSERT( mbedtls_ccm_self_test( 1 ) == 0 );
exit:
;
}
void test_mbedtls_ccm_self_test_wrapper( void ** params )
{
(void)params;
test_mbedtls_ccm_self_test( );
}
#endif /* MBEDTLS_AES_C */
#endif /* MBEDTLS_SELF_TEST */
void test_mbedtls_ccm_setkey( int cipher_id, int key_size, int result )
{
mbedtls_ccm_context ctx;
unsigned char key[32];
int ret;
mbedtls_ccm_init( &ctx );
memset( key, 0x2A, sizeof( key ) );
TEST_ASSERT( (unsigned) key_size <= 8 * sizeof( key ) );
ret = mbedtls_ccm_setkey( &ctx, cipher_id, key, key_size );
TEST_ASSERT( ret == result );
exit:
mbedtls_ccm_free( &ctx );
}
void test_mbedtls_ccm_setkey_wrapper( void ** params )
{
test_mbedtls_ccm_setkey( *( (int *) params[0] ), *( (int *) params[1] ), *( (int *) params[2] ) );
}
#if defined(MBEDTLS_AES_C)
void test_ccm_lengths( int msg_len, int iv_len, int add_len, int tag_len, int res )
{
mbedtls_ccm_context ctx;
unsigned char key[16];
unsigned char msg[10];
unsigned char iv[14];
unsigned char *add = NULL;
unsigned char out[10];
unsigned char tag[18];
int decrypt_ret;
mbedtls_ccm_init( &ctx );
ASSERT_ALLOC_WEAK( add, add_len );
memset( key, 0, sizeof( key ) );
memset( msg, 0, sizeof( msg ) );
memset( iv, 0, sizeof( iv ) );
memset( out, 0, sizeof( out ) );
memset( tag, 0, sizeof( tag ) );
TEST_ASSERT( mbedtls_ccm_setkey( &ctx, MBEDTLS_CIPHER_ID_AES,
key, 8 * sizeof( key ) ) == 0 );
TEST_ASSERT( mbedtls_ccm_encrypt_and_tag( &ctx, msg_len, iv, iv_len, add, add_len,
msg, out, tag, tag_len ) == res );
decrypt_ret = mbedtls_ccm_auth_decrypt( &ctx, msg_len, iv, iv_len, add, add_len,
msg, out, tag, tag_len );
if( res == 0 )
TEST_ASSERT( decrypt_ret == MBEDTLS_ERR_CCM_AUTH_FAILED );
else
TEST_ASSERT( decrypt_ret == res );
exit:
mbedtls_free( add );
mbedtls_ccm_free( &ctx );
}
void test_ccm_lengths_wrapper( void ** params )
{
test_ccm_lengths( *( (int *) params[0] ), *( (int *) params[1] ), *( (int *) params[2] ), *( (int *) params[3] ), *( (int *) params[4] ) );
}
#endif /* MBEDTLS_AES_C */
#if defined(MBEDTLS_AES_C)
void test_ccm_star_lengths( int msg_len, int iv_len, int add_len, int tag_len,
int res )
{
mbedtls_ccm_context ctx;
unsigned char key[16];
unsigned char msg[10];
unsigned char iv[14];
unsigned char add[10];
unsigned char out[10];
unsigned char tag[18];
int decrypt_ret;
mbedtls_ccm_init( &ctx );
memset( key, 0, sizeof( key ) );
memset( msg, 0, sizeof( msg ) );
memset( iv, 0, sizeof( iv ) );
memset( add, 0, sizeof( add ) );
memset( out, 0, sizeof( out ) );
memset( tag, 0, sizeof( tag ) );
TEST_ASSERT( mbedtls_ccm_setkey( &ctx, MBEDTLS_CIPHER_ID_AES,
key, 8 * sizeof( key ) ) == 0 );
TEST_ASSERT( mbedtls_ccm_star_encrypt_and_tag( &ctx, msg_len, iv, iv_len,
add, add_len, msg, out, tag, tag_len ) == res );
decrypt_ret = mbedtls_ccm_star_auth_decrypt( &ctx, msg_len, iv, iv_len, add,
add_len, msg, out, tag, tag_len );
if( res == 0 && tag_len != 0 )
TEST_ASSERT( decrypt_ret == MBEDTLS_ERR_CCM_AUTH_FAILED );
else
TEST_ASSERT( decrypt_ret == res );
exit:
mbedtls_ccm_free( &ctx );
}
void test_ccm_star_lengths_wrapper( void ** params )
{
test_ccm_star_lengths( *( (int *) params[0] ), *( (int *) params[1] ), *( (int *) params[2] ), *( (int *) params[3] ), *( (int *) params[4] ) );
}
#endif /* MBEDTLS_AES_C */
void test_mbedtls_ccm_encrypt_and_tag( int cipher_id, data_t * key,
data_t * msg, data_t * iv,
data_t * add, data_t * result )
{
mbedtls_ccm_context ctx;
size_t tag_len;
uint8_t * msg_n_tag = (uint8_t *)malloc( result->len + 2 );
mbedtls_ccm_init( &ctx );
memset( msg_n_tag, 0, result->len + 2 );
memcpy( msg_n_tag, msg->x, msg->len );
tag_len = result->len - msg->len;
TEST_ASSERT( mbedtls_ccm_setkey( &ctx, cipher_id, key->x, key->len * 8 ) == 0 );
/* Test with input == output */
TEST_ASSERT( mbedtls_ccm_encrypt_and_tag( &ctx, msg->len, iv->x, iv->len, add->x, add->len,
msg_n_tag, msg_n_tag, msg_n_tag + msg->len, tag_len ) == 0 );
TEST_ASSERT( memcmp( msg_n_tag, result->x, result->len ) == 0 );
/* Check we didn't write past the end */
TEST_ASSERT( msg_n_tag[result->len] == 0 && msg_n_tag[result->len + 1] == 0 );
exit:
mbedtls_ccm_free( &ctx );
free( msg_n_tag );
}
void test_mbedtls_ccm_encrypt_and_tag_wrapper( void ** params )
{
data_t data1 = {(uint8_t *) params[1], *( (uint32_t *) params[2] )};
data_t data3 = {(uint8_t *) params[3], *( (uint32_t *) params[4] )};
data_t data5 = {(uint8_t *) params[5], *( (uint32_t *) params[6] )};
data_t data7 = {(uint8_t *) params[7], *( (uint32_t *) params[8] )};
data_t data9 = {(uint8_t *) params[9], *( (uint32_t *) params[10] )};
test_mbedtls_ccm_encrypt_and_tag( *( (int *) params[0] ), &data1, &data3, &data5, &data7, &data9 );
}
void test_mbedtls_ccm_auth_decrypt( int cipher_id, data_t * key,
data_t * msg, data_t * iv,
data_t * add, int tag_len, int result,
data_t * expected_msg )
{
unsigned char tag[16];
mbedtls_ccm_context ctx;
mbedtls_ccm_init( &ctx );
memset( tag, 0x00, sizeof( tag ) );
msg->len -= tag_len;
memcpy( tag, msg->x + msg->len, tag_len );
TEST_ASSERT( mbedtls_ccm_setkey( &ctx, cipher_id, key->x, key->len * 8 ) == 0 );
/* Test with input == output */
TEST_ASSERT( mbedtls_ccm_auth_decrypt( &ctx, msg->len, iv->x, iv->len, add->x, add->len,
msg->x, msg->x, msg->x + msg->len, tag_len ) == result );
if( result == 0 )
{
TEST_ASSERT( memcmp( msg->x, expected_msg->x, expected_msg->len ) == 0 );
}
else
{
size_t i;
for( i = 0; i < msg->len; i++ )
TEST_ASSERT( msg->x[i] == 0 );
}
/* Check we didn't write past the end (where the original tag is) */
TEST_ASSERT( memcmp( msg->x + msg->len, tag, tag_len ) == 0 );
exit:
mbedtls_ccm_free( &ctx );
}
void test_mbedtls_ccm_auth_decrypt_wrapper( void ** params )
{
data_t data1 = {(uint8_t *) params[1], *( (uint32_t *) params[2] )};
data_t data3 = {(uint8_t *) params[3], *( (uint32_t *) params[4] )};
data_t data5 = {(uint8_t *) params[5], *( (uint32_t *) params[6] )};
data_t data7 = {(uint8_t *) params[7], *( (uint32_t *) params[8] )};
data_t data11 = {(uint8_t *) params[11], *( (uint32_t *) params[12] )};
test_mbedtls_ccm_auth_decrypt( *( (int *) params[0] ), &data1, &data3, &data5, &data7, *( (int *) params[9] ), *( (int *) params[10] ), &data11 );
}
void test_mbedtls_ccm_star_encrypt_and_tag( int cipher_id,
data_t *key, data_t *msg,
data_t *source_address, data_t *frame_counter,
int sec_level, data_t *add,
data_t *expected_result, int output_ret )
{
unsigned char iv[13];
unsigned char result[50];
mbedtls_ccm_context ctx;
size_t iv_len, tag_len;
int ret;
mbedtls_ccm_init( &ctx );
memset( result, 0x00, sizeof( result ) );
if( sec_level % 4 == 0)
tag_len = 0;
else
tag_len = 1 << ( sec_level % 4 + 1);
TEST_ASSERT( source_address->len == 8 );
TEST_ASSERT( frame_counter->len == 4 );
memcpy( iv, source_address->x, source_address->len );
memcpy( iv + source_address->len, frame_counter->x, frame_counter->len );
iv[source_address->len + frame_counter->len] = sec_level;
iv_len = sizeof( iv );
TEST_ASSERT( mbedtls_ccm_setkey( &ctx, cipher_id,
key->x, key->len * 8 ) == 0 );
ret = mbedtls_ccm_star_encrypt_and_tag( &ctx, msg->len, iv, iv_len,
add->x, add->len, msg->x,
result, result + msg->len, tag_len );
TEST_ASSERT( ret == output_ret );
TEST_ASSERT( memcmp( result,
expected_result->x, expected_result->len ) == 0 );
/* Check we didn't write past the end */
TEST_ASSERT( result[expected_result->len] == 0 &&
result[expected_result->len + 1] == 0 );
exit:
mbedtls_ccm_free( &ctx );
}
void test_mbedtls_ccm_star_encrypt_and_tag_wrapper( void ** params )
{
data_t data1 = {(uint8_t *) params[1], *( (uint32_t *) params[2] )};
data_t data3 = {(uint8_t *) params[3], *( (uint32_t *) params[4] )};
data_t data5 = {(uint8_t *) params[5], *( (uint32_t *) params[6] )};
data_t data7 = {(uint8_t *) params[7], *( (uint32_t *) params[8] )};
data_t data10 = {(uint8_t *) params[10], *( (uint32_t *) params[11] )};
data_t data12 = {(uint8_t *) params[12], *( (uint32_t *) params[13] )};
test_mbedtls_ccm_star_encrypt_and_tag( *( (int *) params[0] ), &data1, &data3, &data5, &data7, *( (int *) params[9] ), &data10, &data12, *( (int *) params[14] ) );
}
void test_mbedtls_ccm_star_auth_decrypt( int cipher_id,
data_t *key, data_t *msg,
data_t *source_address, data_t *frame_counter,
int sec_level, data_t *add,
data_t *expected_result, int output_ret )
{
unsigned char iv[13];
unsigned char result[50];
mbedtls_ccm_context ctx;
size_t iv_len, tag_len;
int ret;
mbedtls_ccm_init( &ctx );
memset( iv, 0x00, sizeof( iv ) );
memset( result, '+', sizeof( result ) );
if( sec_level % 4 == 0)
tag_len = 0;
else
tag_len = 1 << ( sec_level % 4 + 1);
TEST_ASSERT( source_address->len == 8 );
TEST_ASSERT( frame_counter->len == 4 );
memcpy( iv, source_address->x, source_address->len );
memcpy( iv + source_address->len, frame_counter->x, frame_counter->len );
iv[source_address->len + frame_counter->len] = sec_level;
iv_len = sizeof( iv );
TEST_ASSERT( mbedtls_ccm_setkey( &ctx, cipher_id, key->x, key->len * 8 ) == 0 );
ret = mbedtls_ccm_star_auth_decrypt( &ctx, msg->len - tag_len, iv, iv_len,
add->x, add->len, msg->x, result,
msg->x + msg->len - tag_len, tag_len );
TEST_ASSERT( ret == output_ret );
TEST_ASSERT( memcmp( result, expected_result->x,
expected_result->len ) == 0 );
/* Check we didn't write past the end (where the original tag is) */
TEST_ASSERT( ( msg->len + 2 ) <= sizeof( result ) );
TEST_EQUAL( result[msg->len], '+' );
TEST_EQUAL( result[msg->len + 1], '+' );
exit:
mbedtls_ccm_free( &ctx );
}
void test_mbedtls_ccm_star_auth_decrypt_wrapper( void ** params )
{
data_t data1 = {(uint8_t *) params[1], *( (uint32_t *) params[2] )};
data_t data3 = {(uint8_t *) params[3], *( (uint32_t *) params[4] )};
data_t data5 = {(uint8_t *) params[5], *( (uint32_t *) params[6] )};
data_t data7 = {(uint8_t *) params[7], *( (uint32_t *) params[8] )};
data_t data10 = {(uint8_t *) params[10], *( (uint32_t *) params[11] )};
data_t data12 = {(uint8_t *) params[12], *( (uint32_t *) params[13] )};
test_mbedtls_ccm_star_auth_decrypt( *( (int *) params[0] ), &data1, &data3, &data5, &data7, *( (int *) params[9] ), &data10, &data12, *( (int *) params[14] ) );
}
#if defined(MBEDTLS_CHECK_PARAMS)
#if !defined(MBEDTLS_PARAM_FAILED_ALT)
void test_ccm_invalid_param( )
{
struct mbedtls_ccm_context ctx;
unsigned char valid_buffer[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
mbedtls_cipher_id_t valid_cipher = MBEDTLS_CIPHER_ID_AES;
int valid_len = sizeof(valid_buffer);
int valid_bitlen = valid_len * 8;
mbedtls_ccm_init( &ctx );
/* mbedtls_ccm_init() */
TEST_INVALID_PARAM( mbedtls_ccm_init( NULL ) );
/* mbedtls_ccm_setkey() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
mbedtls_ccm_setkey( NULL, valid_cipher, valid_buffer, valid_bitlen ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
mbedtls_ccm_setkey( &ctx, valid_cipher, NULL, valid_bitlen ) );
/* mbedtls_ccm_encrypt_and_tag() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
mbedtls_ccm_encrypt_and_tag( NULL, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_buffer,
valid_buffer, valid_len ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
mbedtls_ccm_encrypt_and_tag( &ctx, valid_len,
NULL, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_buffer,
valid_buffer, valid_len ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
mbedtls_ccm_encrypt_and_tag( &ctx, valid_len,
valid_buffer, valid_len,
NULL, valid_len,
valid_buffer, valid_buffer,
valid_buffer, valid_len ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
mbedtls_ccm_encrypt_and_tag( &ctx, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_len,
NULL, valid_buffer,
valid_buffer, valid_len ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
mbedtls_ccm_encrypt_and_tag( &ctx, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_len,
valid_buffer, NULL,
valid_buffer, valid_len ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
mbedtls_ccm_encrypt_and_tag( &ctx, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_buffer,
NULL, valid_len ) );
/* mbedtls_ccm_star_encrypt_and_tag() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
mbedtls_ccm_star_encrypt_and_tag( NULL, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_buffer,
valid_buffer, valid_len) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
mbedtls_ccm_star_encrypt_and_tag( &ctx, valid_len,
NULL, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_buffer,
valid_buffer, valid_len ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
mbedtls_ccm_star_encrypt_and_tag( &ctx, valid_len,
valid_buffer, valid_len,
NULL, valid_len,
valid_buffer, valid_buffer,
valid_buffer, valid_len ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
mbedtls_ccm_star_encrypt_and_tag( &ctx, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_len,
NULL, valid_buffer,
valid_buffer, valid_len ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
mbedtls_ccm_star_encrypt_and_tag( &ctx, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_len,
valid_buffer, NULL,
valid_buffer, valid_len ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
mbedtls_ccm_star_encrypt_and_tag( &ctx, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_buffer,
NULL, valid_len ) );
/* mbedtls_ccm_auth_decrypt() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
mbedtls_ccm_auth_decrypt( NULL, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_buffer,
valid_buffer, valid_len ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
mbedtls_ccm_auth_decrypt( &ctx, valid_len,
NULL, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_buffer,
valid_buffer, valid_len ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
mbedtls_ccm_auth_decrypt( &ctx, valid_len,
valid_buffer, valid_len,
NULL, valid_len,
valid_buffer, valid_buffer,
valid_buffer, valid_len ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
mbedtls_ccm_auth_decrypt( &ctx, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_len,
NULL, valid_buffer,
valid_buffer, valid_len ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
mbedtls_ccm_auth_decrypt( &ctx, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_len,
valid_buffer, NULL,
valid_buffer, valid_len ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
mbedtls_ccm_auth_decrypt( &ctx, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_buffer,
NULL, valid_len ) );
/* mbedtls_ccm_star_auth_decrypt() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
mbedtls_ccm_star_auth_decrypt( NULL, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_buffer,
valid_buffer, valid_len ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
mbedtls_ccm_star_auth_decrypt( &ctx, valid_len,
NULL, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_buffer,
valid_buffer, valid_len ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
mbedtls_ccm_star_auth_decrypt( &ctx, valid_len,
valid_buffer, valid_len,
NULL, valid_len,
valid_buffer, valid_buffer,
valid_buffer, valid_len ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
mbedtls_ccm_star_auth_decrypt( &ctx, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_len,
NULL, valid_buffer,
valid_buffer, valid_len ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
mbedtls_ccm_star_auth_decrypt( &ctx, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_len,
valid_buffer, NULL,
valid_buffer, valid_len ) );
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
mbedtls_ccm_star_auth_decrypt( &ctx, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_len,
valid_buffer, valid_buffer,
NULL, valid_len ) );
exit:
mbedtls_ccm_free( &ctx );
return;
}
void test_ccm_invalid_param_wrapper( void ** params )
{
(void)params;
test_ccm_invalid_param( );
}
#endif /* !MBEDTLS_PARAM_FAILED_ALT */
#endif /* MBEDTLS_CHECK_PARAMS */
void test_ccm_valid_param( )
{
TEST_VALID_PARAM( mbedtls_ccm_free( NULL ) );
exit:
return;
}
void test_ccm_valid_param_wrapper( void ** params )
{
(void)params;
test_ccm_valid_param( );
}
#endif /* MBEDTLS_CCM_C */
/*----------------------------------------------------------------------------*/
/* Test dispatch code */
/**
* \brief Evaluates an expression/macro into its literal integer value.
* For optimizing space for embedded targets each expression/macro
* is identified by a unique identifier instead of string literals.
* Identifiers and evaluation code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh
*
* \param exp_id Expression identifier.
* \param out_value Pointer to int to hold the integer.
*
* \return 0 if exp_id is found. 1 otherwise.
*/
int get_expression( int32_t exp_id, int32_t * out_value )
{
int ret = KEY_VALUE_MAPPING_FOUND;
(void) exp_id;
(void) out_value;
switch( exp_id )
{
#if defined(MBEDTLS_CCM_C)
case 0:
{
*out_value = MBEDTLS_CIPHER_ID_AES;
}
break;
case 1:
{
*out_value = MBEDTLS_CIPHER_ID_CAMELLIA;
}
break;
case 2:
{
*out_value = MBEDTLS_ERR_CCM_BAD_INPUT;
}
break;
case 3:
{
*out_value = MBEDTLS_CIPHER_ID_BLOWFISH;
}
break;
case 4:
{
*out_value = MBEDTLS_ERR_CCM_AUTH_FAILED;
}
break;
#endif
default:
{
ret = KEY_VALUE_MAPPING_NOT_FOUND;
}
break;
}
return( ret );
}
/**
* \brief Checks if the dependency i.e. the compile flag is set.
* For optimizing space for embedded targets each dependency
* is identified by a unique identifier instead of string literals.
* Identifiers and check code is generated by script:
* generate_test_code.py and then mbedtls_test_suite.sh
*
* \param dep_id Dependency identifier.
*
* \return DEPENDENCY_SUPPORTED if set else DEPENDENCY_NOT_SUPPORTED
*/
int dep_check( int dep_id )
{
int ret = DEPENDENCY_NOT_SUPPORTED;
(void) dep_id;
switch( dep_id )
{
#if defined(MBEDTLS_CCM_C)
case 0:
{
#if defined(MBEDTLS_AES_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 1:
{
#if defined(MBEDTLS_CAMELLIA_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 2:
{
#if defined(MBEDTLS_BLOWFISH_C)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
case 3:
{
#if !defined(MBEDTLS_CCM_ALT)
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}
break;
#endif
default:
break;
}
return( ret );
}
/**
* \brief Function pointer type for test function wrappers.
*
* A test function wrapper decodes the parameters and passes them to the
* underlying test function. Both the wrapper and the underlying function
* return void. Test wrappers assume that they are passed a suitable
* parameter array and do not perform any error detection.
*
* \param param_array The array of parameters. Each element is a `void *`
* which the wrapper casts to the correct type and
* dereferences. Each wrapper function hard-codes the
* number and types of the parameters.
*/
typedef void (*TestWrapper_t)( void **param_array );
/**
* \brief Table of test function wrappers. Used by dispatch_test().
* This table is populated by script:
* generate_test_code.py and then mbedtls_test_suite.sh
*
*/
TestWrapper_t test_funcs[] =
{
/* Function Id: 0 */
#if defined(MBEDTLS_CCM_C) && defined(MBEDTLS_SELF_TEST) && defined(MBEDTLS_AES_C)
test_mbedtls_ccm_self_test_wrapper,
#else
NULL,
#endif
/* Function Id: 1 */
#if defined(MBEDTLS_CCM_C)
test_mbedtls_ccm_setkey_wrapper,
#else
NULL,
#endif
/* Function Id: 2 */
#if defined(MBEDTLS_CCM_C) && defined(MBEDTLS_AES_C)
test_ccm_lengths_wrapper,
#else
NULL,
#endif
/* Function Id: 3 */
#if defined(MBEDTLS_CCM_C) && defined(MBEDTLS_AES_C)
test_ccm_star_lengths_wrapper,
#else
NULL,
#endif
/* Function Id: 4 */
#if defined(MBEDTLS_CCM_C)
test_mbedtls_ccm_encrypt_and_tag_wrapper,
#else
NULL,
#endif
/* Function Id: 5 */
#if defined(MBEDTLS_CCM_C)
test_mbedtls_ccm_auth_decrypt_wrapper,
#else
NULL,
#endif
/* Function Id: 6 */
#if defined(MBEDTLS_CCM_C)
test_mbedtls_ccm_star_encrypt_and_tag_wrapper,
#else
NULL,
#endif
/* Function Id: 7 */
#if defined(MBEDTLS_CCM_C)
test_mbedtls_ccm_star_auth_decrypt_wrapper,
#else
NULL,
#endif
/* Function Id: 8 */
#if defined(MBEDTLS_CCM_C) && defined(MBEDTLS_CHECK_PARAMS) && !defined(MBEDTLS_PARAM_FAILED_ALT)
test_ccm_invalid_param_wrapper,
#else
NULL,
#endif
/* Function Id: 9 */
#if defined(MBEDTLS_CCM_C)
test_ccm_valid_param_wrapper,
#else
NULL,
#endif
};
/**
* \brief Execute the test function.
*
* This is a wrapper function around the test function execution
* to allow the setjmp() call used to catch any calls to the
* parameter failure callback, to be used. Calls to setjmp()
* can invalidate the state of any local auto variables.
*
* \param fp Function pointer to the test function.
* \param params Parameters to pass to the #TestWrapper_t wrapper function.
*
*/
void execute_function_ptr(TestWrapper_t fp, void **params)
{
#if defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG)
mbedtls_test_enable_insecure_external_rng( );
#endif
#if defined(MBEDTLS_CHECK_PARAMS)
mbedtls_test_param_failed_location_record_t location_record;
if ( setjmp( mbedtls_test_param_failed_get_state_buf( ) ) == 0 )
{
fp( params );
}
else
{
/* Unexpected parameter validation error */
mbedtls_test_param_failed_get_location_record( &location_record );
mbedtls_test_fail( location_record.failure_condition,
location_record.line,
location_record.file );
}
mbedtls_test_param_failed_reset_state( );
#else
fp( params );
#endif
#if defined(MBEDTLS_TEST_MUTEX_USAGE)
mbedtls_test_mutex_usage_check( );
#endif /* MBEDTLS_TEST_MUTEX_USAGE */
}
/**
* \brief Dispatches test functions based on function index.
*
* \param func_idx Test function index.
* \param params The array of parameters to pass to the test function.
* It will be decoded by the #TestWrapper_t wrapper function.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int dispatch_test( size_t func_idx, void ** params )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof( test_funcs ) / sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp )
execute_function_ptr(fp, params);
else
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
/**
* \brief Checks if test function is supported in this build-time
* configuration.
*
* \param func_idx Test function index.
*
* \return DISPATCH_TEST_SUCCESS if found
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
int check_test( size_t func_idx )
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
if ( func_idx < (int)( sizeof(test_funcs)/sizeof( TestWrapper_t ) ) )
{
fp = test_funcs[func_idx];
if ( fp == NULL )
ret = DISPATCH_UNSUPPORTED_SUITE;
}
else
{
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
return( ret );
}
int main( int argc, const char *argv[] )
{
int ret;
mbedtls_test_platform_setup();
ret = execute_tests( argc, argv, "/zip/third_party/mbedtls/test/test_suite_ccm.datax" );
mbedtls_test_platform_teardown();
return( ret );
}
| 32,094 | 954 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_cipher.ccm.datax | AES-128-CCM test vector NIST #1 (P=0, N=7, A=0, T=4)
depends_on:0:1
9:exp:0:hex:"4ae701103c63deca5b5a3939d7d05992":hex:"5a8aa485c316e9":hex:"":hex:"":hex:"02209f55":char*:"":hex:"":int:0
AES-128-CCM test vector NIST #2 (P=0, N=7, A=0, T=4)
depends_on:0:1
9:exp:0:hex:"4ae701103c63deca5b5a3939d7d05992":hex:"3796cf51b87266":hex:"":hex:"":hex:"9a04c241":char*:"FAIL":hex:"":int:0
AES-128-CCM test vector NIST #3 (P=0, N=7, A=0, T=16)
depends_on:0:1
9:exp:0:hex:"4bb3c4a4f893ad8c9bdc833c325d62b3":hex:"5a8aa485c316e9":hex:"":hex:"":hex:"75d582db43ce9b13ab4b6f7f14341330":char*:"":hex:"":int:0
AES-128-CCM test vector NIST #4 (P=0, N=7, A=0, T=16)
depends_on:0:1
9:exp:0:hex:"4bb3c4a4f893ad8c9bdc833c325d62b3":hex:"3796cf51b87266":hex:"":hex:"":hex:"3a65e03af37b81d05acc7ec1bc39deb0":char*:"FAIL":hex:"":int:0
AES-128-CCM test vector NIST #5 (P=0, N=13, A=0, T=4)
depends_on:0:1
9:exp:0:hex:"4bb3c4a4f893ad8c9bdc833c325d62b3":hex:"5a8aa485c316e9403aff859fbb":hex:"":hex:"":hex:"90156f3f":char*:"":hex:"":int:0
AES-128-CCM test vector NIST #6 (P=0, N=13, A=0, T=4)
depends_on:0:1
9:exp:0:hex:"4bb3c4a4f893ad8c9bdc833c325d62b3":hex:"a16a2e741f1cd9717285b6d882":hex:"":hex:"":hex:"88909016":char*:"FAIL":hex:"":int:0
AES-128-CCM test vector NIST #7 (P=0, N=13, A=0, T=16)
depends_on:0:1
9:exp:0:hex:"19ebfde2d5468ba0a3031bde629b11fd":hex:"5a8aa485c316e9403aff859fbb":hex:"":hex:"":hex:"fb04dc5a44c6bb000f2440f5154364b4":char*:"":hex:"":int:0
AES-128-CCM test vector NIST #8 (P=0, N=13, A=0, T=16)
depends_on:0:1
9:exp:0:hex:"19ebfde2d5468ba0a3031bde629b11fd":hex:"a16a2e741f1cd9717285b6d882":hex:"":hex:"":hex:"5447075bf42a59b91f08064738b015ab":char*:"FAIL":hex:"":int:0
AES-128-CCM test vector NIST #9 (P=24, N=7, A=0, T=4)
depends_on:0:1
9:exp:0:hex:"19ebfde2d5468ba0a3031bde629b11fd":hex:"5a8aa485c316e9":hex:"":hex:"a90e8ea44085ced791b2fdb7fd44b5cf0bd7d27718029bb7":hex:"03e1fa6b":char*:"":hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22":int:0
AES-128-CCM test vector NIST #10 (P=24, N=7, A=0, T=4)
depends_on:0:1
9:exp:0:hex:"19ebfde2d5468ba0a3031bde629b11fd":hex:"31f8fa25827d48":hex:"":hex:"50aafe0578c115c4a8e126ff7b3ccb64dce8ccaa8ceda69f":hex:"23e5d81c":char*:"FAIL":hex:"":int:0
AES-128-CCM test vector NIST #11 (P=24, N=7, A=0, T=16)
depends_on:0:1
9:exp:0:hex:"197afb02ffbd8f699dacae87094d5243":hex:"5a8aa485c316e9":hex:"":hex:"24ab9eeb0e5508cae80074f1070ee188a637171860881f1f":hex:"2d9a3fbc210595b7b8b1b41523111a8e":char*:"":hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22":int:0
AES-128-CCM test vector NIST #12 (P=24, N=7, A=0, T=16)
depends_on:0:1
9:exp:0:hex:"197afb02ffbd8f699dacae87094d5243":hex:"31f8fa25827d48":hex:"":hex:"7ebfda6fa5da1dbffd82dc29b875798fbcef8ba0084fbd24":hex:"63af747cc88a001fa94e060290f209c4":char*:"FAIL":hex:"":int:0
AES-128-CCM test vector NIST #13 (P=24, N=13, A=0, T=4)
depends_on:0:1
9:exp:0:hex:"197afb02ffbd8f699dacae87094d5243":hex:"5a8aa485c316e9403aff859fbb":hex:"":hex:"4a550134f94455979ec4bf89ad2bd80d25a77ae94e456134":hex:"a3e138b9":char*:"":hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697":int:0
AES-128-CCM test vector NIST #14 (P=24, N=13, A=0, T=4)
depends_on:0:1
9:exp:0:hex:"197afb02ffbd8f699dacae87094d5243":hex:"49004912fdd7269279b1f06a89":hex:"":hex:"118ec53dd1bfbe52d5b9fe5dfebecf2ee674ec983eada654":hex:"091a5ae9":char*:"FAIL":hex:"":int:0
AES-128-CCM test vector NIST #15 (P=24, N=13, A=0, T=16)
depends_on:0:1
9:exp:0:hex:"90929a4b0ac65b350ad1591611fe4829":hex:"5a8aa485c316e9403aff859fbb":hex:"":hex:"4bfe4e35784f0a65b545477e5e2f4bae0e1e6fa717eaf2cb":hex:"6a9a970b9beb2ac1bd4fd62168f8378a":char*:"":hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697":int:0
AES-128-CCM test vector NIST #16 (P=24, N=13, A=0, T=16)
depends_on:0:1
9:exp:0:hex:"90929a4b0ac65b350ad1591611fe4829":hex:"49004912fdd7269279b1f06a89":hex:"":hex:"0c56a503aa2c12e87450d45a7b714db980fd348f327c0065":hex:"a65666144994bad0c8195bcb4ade1337":char*:"FAIL":hex:"":int:0
AES-128-CCM test vector NIST #17 (P=0, N=7, A=32, T=4)
depends_on:0:1
9:exp:0:hex:"90929a4b0ac65b350ad1591611fe4829":hex:"5a8aa485c316e9":hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22ec22b1a268f88e2c":hex:"":hex:"782e4318":char*:"":hex:"":int:0
AES-128-CCM test vector NIST #18 (P=0, N=7, A=32, T=4)
depends_on:0:1
9:exp:0:hex:"90929a4b0ac65b350ad1591611fe4829":hex:"a265480ca88d5f":hex:"a2248a882ecbf850daf91933a389e78e81623d233dfd47bf8321361a38f138fe":hex:"":hex:"a04f270a":char*:"FAIL":hex:"":int:0
AES-128-CCM test vector NIST #19 (P=0, N=7, A=32, T=16)
depends_on:0:1
9:exp:0:hex:"6a798d7c5e1a72b43e20ad5c7b08567b":hex:"5a8aa485c316e9":hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22ec22b1a268f88e2c":hex:"":hex:"41b476013f45e4a781f253a6f3b1e530":char*:"":hex:"":int:0
AES-128-CCM test vector NIST #20 (P=0, N=7, A=32, T=16)
depends_on:0:1
9:exp:0:hex:"6a798d7c5e1a72b43e20ad5c7b08567b":hex:"a265480ca88d5f":hex:"a2248a882ecbf850daf91933a389e78e81623d233dfd47bf8321361a38f138fe":hex:"":hex:"f9f018fcd125822616083fffebc4c8e6":char*:"FAIL":hex:"":int:0
AES-128-CCM test vector NIST #21 (P=0, N=13, A=32, T=4)
depends_on:0:1
9:exp:0:hex:"6a798d7c5e1a72b43e20ad5c7b08567b":hex:"5a8aa485c316e9403aff859fbb":hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697a7ee6410184c7982":hex:"":hex:"9f69f24f":char*:"":hex:"":int:0
AES-128-CCM test vector NIST #22 (P=0, N=13, A=32, T=4)
depends_on:0:1
9:exp:0:hex:"6a798d7c5e1a72b43e20ad5c7b08567b":hex:"8739b4bea1a099fe547499cbc6":hex:"f6107696edb332b2ea059d8860fee26be42e5e12e1a4f79a8d0eafce1b2278a7":hex:"":hex:"e17afaa4":char*:"FAIL":hex:"":int:0
AES-128-CCM test vector NIST #23 (P=0, N=13, A=32, T=16)
depends_on:0:1
9:exp:0:hex:"f9fdca4ac64fe7f014de0f43039c7571":hex:"5a8aa485c316e9403aff859fbb":hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697a7ee6410184c7982":hex:"":hex:"1859ac36a40a6b28b34266253627797a":char*:"":hex:"":int:0
AES-128-CCM test vector NIST #24 (P=0, N=13, A=32, T=16)
depends_on:0:1
9:exp:0:hex:"f9fdca4ac64fe7f014de0f43039c7571":hex:"8739b4bea1a099fe547499cbc6":hex:"f6107696edb332b2ea059d8860fee26be42e5e12e1a4f79a8d0eafce1b2278a7":hex:"":hex:"edf8b46eb69ac0044116019dec183072":char*:"FAIL":hex:"":int:0
AES-128-CCM test vector NIST #25 (P=24, N=7, A=32, T=4)
depends_on:0:1
9:exp:0:hex:"f9fdca4ac64fe7f014de0f43039c7571":hex:"5a8aa485c316e9":hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22ec22b1a268f88e2c":hex:"6be31860ca271ef448de8f8d8b39346daf4b81d7e92d65b3":hex:"38f125fa":char*:"":hex:"a265480ca88d5f536db0dc6abc40faf0d05be7a966977768":int:0
AES-128-CCM test vector NIST #26 (P=24, N=7, A=32, T=4)
depends_on:0:1
9:exp:0:hex:"f9fdca4ac64fe7f014de0f43039c7571":hex:"fdd2d6f503c915":hex:"5b92394f21ddc3ad49d9b0881b829a5935cb3a4d23e292a62fb66b5e7ab7020e":hex:"4cc57a9927a6bc401441870d3193bf89ebd163f5c01501c7":hex:"28a66b69":char*:"FAIL":hex:"":int:0
AES-128-CCM test vector NIST #27 (P=24, N=7, A=32, T=16)
depends_on:0:1
9:exp:0:hex:"a7aa635ea51b0bb20a092bd5573e728c":hex:"5a8aa485c316e9":hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22ec22b1a268f88e2c":hex:"b351ab96b2e45515254558d5212673ee6c776d42dbca3b51":hex:"2cf3a20b7fd7c49e6e79bef475c2906f":char*:"":hex:"a265480ca88d5f536db0dc6abc40faf0d05be7a966977768":int:0
AES-128-CCM test vector NIST #28 (P=24, N=7, A=32, T=16)
depends_on:0:1
9:exp:0:hex:"a7aa635ea51b0bb20a092bd5573e728c":hex:"fdd2d6f503c915":hex:"5b92394f21ddc3ad49d9b0881b829a5935cb3a4d23e292a62fb66b5e7ab7020e":hex:"df1a5285caa41b4bb47f6e5ceceba4e82721828d68427a30":hex:"81d18ca149d6766bfaccec88f194eb5b":char*:"FAIL":hex:"":int:0
AES-128-CCM test vector NIST #29 (P=24, N=13, A=32, T=4)
depends_on:0:1
9:exp:0:hex:"a7aa635ea51b0bb20a092bd5573e728c":hex:"5a8aa485c316e9403aff859fbb":hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697a7ee6410184c7982":hex:"934f893824e880f743d196b22d1f340a52608155087bd28a":hex:"c25e5329":char*:"":hex:"8739b4bea1a099fe547499cbc6d1b13d849b8084c9b6acc5":int:0
AES-128-CCM test vector NIST #30 (P=24, N=13, A=32, T=4)
depends_on:0:1
9:exp:0:hex:"a7aa635ea51b0bb20a092bd5573e728c":hex:"0812757ad0cc4d17c4cfe7a642":hex:"ec6c44a7e94e51a3ca6dee229098391575ec7213c85267fbf7492fdbeee61b10":hex:"f43ba9d834ad85dfab3f1c0c27c3441fe4e411a38a261a65":hex:"59b3b3ee":char*:"FAIL":hex:"":int:0
AES-128-CCM test vector NIST #31 (P=24, N=13, A=32, T=16)
depends_on:0:1
9:exp:0:hex:"26511fb51fcfa75cb4b44da75a6e5a0e":hex:"5a8aa485c316e9403aff859fbb":hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697a7ee6410184c7982":hex:"50038b5fdd364ee747b70d00bd36840ece4ea19998123375":hex:"c0a458bfcafa3b2609afe0f825cbf503":char*:"":hex:"8739b4bea1a099fe547499cbc6d1b13d849b8084c9b6acc5":int:0
AES-128-CCM test vector NIST #32 (P=24, N=13, A=32, T=16)
depends_on:0:1
9:exp:0:hex:"26511fb51fcfa75cb4b44da75a6e5a0e":hex:"0812757ad0cc4d17c4cfe7a642":hex:"ec6c44a7e94e51a3ca6dee229098391575ec7213c85267fbf7492fdbeee61b10":hex:"78ed8ff6b5a1255d0fbd0a719a9c27b059ff5f83d0c4962c":hex:"390042ba8bb5f6798dab01c5afad7306":char*:"FAIL":hex:"":int:0
AES-192-CCM test vector NIST #1 (P=0, N=7, A=0, T=4)
depends_on:0:1
9:exp:1:hex:"c98ad7f38b2c7e970c9b965ec87a08208384718f78206c6c":hex:"5a8aa485c316e9":hex:"":hex:"":hex:"9d4b7f3b":char*:"":hex:"":int:0
AES-192-CCM test vector NIST #2 (P=0, N=7, A=0, T=4)
depends_on:0:1
9:exp:1:hex:"c98ad7f38b2c7e970c9b965ec87a08208384718f78206c6c":hex:"3796cf51b87266":hex:"":hex:"":hex:"80745de9":char*:"FAIL":hex:"":int:0
AES-192-CCM test vector NIST #3 (P=0, N=7, A=0, T=16)
depends_on:0:1
9:exp:1:hex:"4bb3c4a4f893ad8c9bdc833c325d62b3d3ad1bccf9282a65":hex:"5a8aa485c316e9":hex:"":hex:"":hex:"17223038fa99d53681ca1beabe78d1b4":char*:"":hex:"":int:0
AES-192-CCM test vector NIST #4 (P=0, N=7, A=0, T=16)
depends_on:0:1
9:exp:1:hex:"4bb3c4a4f893ad8c9bdc833c325d62b3d3ad1bccf9282a65":hex:"3796cf51b87266":hex:"":hex:"":hex:"d0e1eeef4d2a264536bb1c2c1bde7c35":char*:"FAIL":hex:"":int:0
AES-192-CCM test vector NIST #5 (P=0, N=13, A=0, T=4)
depends_on:0:1
9:exp:1:hex:"4bb3c4a4f893ad8c9bdc833c325d62b3d3ad1bccf9282a65":hex:"5a8aa485c316e9403aff859fbb":hex:"":hex:"":hex:"fe69ed84":char*:"":hex:"":int:0
AES-192-CCM test vector NIST #6 (P=0, N=13, A=0, T=4)
depends_on:0:1
9:exp:1:hex:"4bb3c4a4f893ad8c9bdc833c325d62b3d3ad1bccf9282a65":hex:"a16a2e741f1cd9717285b6d882":hex:"":hex:"":hex:"db7ffc82":char*:"FAIL":hex:"":int:0
AES-192-CCM test vector NIST #7 (P=0, N=13, A=0, T=16)
depends_on:0:1
9:exp:1:hex:"19ebfde2d5468ba0a3031bde629b11fd4094afcb205393fa":hex:"5a8aa485c316e9403aff859fbb":hex:"":hex:"":hex:"0c66a8e547ed4f8c2c9a9a1eb5d455b9":char*:"":hex:"":int:0
AES-192-CCM test vector NIST #8 (P=0, N=13, A=0, T=16)
depends_on:0:1
9:exp:1:hex:"19ebfde2d5468ba0a3031bde629b11fd4094afcb205393fa":hex:"a16a2e741f1cd9717285b6d882":hex:"":hex:"":hex:"38757b3a61a4dc97ca3ab88bf1240695":char*:"FAIL":hex:"":int:0
AES-192-CCM test vector NIST #9 (P=24, N=7, A=0, T=4)
depends_on:0:1
9:exp:1:hex:"19ebfde2d5468ba0a3031bde629b11fd4094afcb205393fa":hex:"5a8aa485c316e9":hex:"":hex:"411986d04d6463100bff03f7d0bde7ea2c3488784378138c":hex:"ddc93a54":char*:"":hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22":int:0
AES-192-CCM test vector NIST #10 (P=24, N=7, A=0, T=4)
depends_on:0:1
9:exp:1:hex:"19ebfde2d5468ba0a3031bde629b11fd4094afcb205393fa":hex:"31f8fa25827d48":hex:"":hex:"32b649ab56162e55d4148a1292d6a225a988eb1308298273":hex:"b6889036":char*:"FAIL":hex:"":int:0
AES-192-CCM test vector NIST #11 (P=24, N=7, A=0, T=16)
depends_on:0:1
9:exp:1:hex:"197afb02ffbd8f699dacae87094d524324576b99844f75e1":hex:"5a8aa485c316e9":hex:"":hex:"cba4b4aeb85f0492fd8d905c4a6d8233139833373ef188a8":hex:"c5a5ebecf7ac8607fe412189e83d9d20":char*:"":hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22":int:0
AES-192-CCM test vector NIST #12 (P=24, N=7, A=0, T=16)
depends_on:0:1
9:exp:1:hex:"197afb02ffbd8f699dacae87094d524324576b99844f75e1":hex:"31f8fa25827d48":hex:"":hex:"ca62713728b5c9d652504b0ae8fd4fee5d297ee6a8d19cb6":hex:"e699f15f14d34dcaf9ba8ed4b877c97d":char*:"FAIL":hex:"":int:0
AES-192-CCM test vector NIST #13 (P=24, N=13, A=0, T=4)
depends_on:0:1
9:exp:1:hex:"197afb02ffbd8f699dacae87094d524324576b99844f75e1":hex:"5a8aa485c316e9403aff859fbb":hex:"":hex:"042653c674ef2a90f7fb11d30848e530ae59478f1051633a":hex:"34fad277":char*:"":hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697":int:0
AES-192-CCM test vector NIST #14 (P=24, N=13, A=0, T=4)
depends_on:0:1
9:exp:1:hex:"197afb02ffbd8f699dacae87094d524324576b99844f75e1":hex:"49004912fdd7269279b1f06a89":hex:"":hex:"1902d9769a7ba3d3268e1257395c8c2e5f98eef295dcbfa5":hex:"a35df775":char*:"FAIL":hex:"":int:0
AES-192-CCM test vector NIST #15 (P=24, N=13, A=0, T=16)
depends_on:0:1
9:exp:1:hex:"90929a4b0ac65b350ad1591611fe48297e03956f6083e451":hex:"5a8aa485c316e9403aff859fbb":hex:"":hex:"a5b7d8cca2069908d1ed88e6a9fe2c9bede3131dad54671e":hex:"a7ade30a07d185692ab0ebdf4c78cf7a":char*:"":hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697":int:0
AES-192-CCM test vector NIST #16 (P=24, N=13, A=0, T=16)
depends_on:0:1
9:exp:1:hex:"90929a4b0ac65b350ad1591611fe48297e03956f6083e451":hex:"49004912fdd7269279b1f06a89":hex:"":hex:"9a98617fb97a0dfe466be692272dcdaec1c5443a3b51312e":hex:"f042c86363cc05afb98c66e16be8a445":char*:"FAIL":hex:"":int:0
AES-192-CCM test vector NIST #17 (P=0, N=7, A=32, T=4)
depends_on:0:1
9:exp:1:hex:"90929a4b0ac65b350ad1591611fe48297e03956f6083e451":hex:"5a8aa485c316e9":hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22ec22b1a268f88e2c":hex:"":hex:"1d089a5f":char*:"":hex:"":int:0
AES-192-CCM test vector NIST #18 (P=0, N=7, A=32, T=4)
depends_on:0:1
9:exp:1:hex:"90929a4b0ac65b350ad1591611fe48297e03956f6083e451":hex:"a265480ca88d5f":hex:"a2248a882ecbf850daf91933a389e78e81623d233dfd47bf8321361a38f138fe":hex:"":hex:"2f46022a":char*:"FAIL":hex:"":int:0
AES-192-CCM test vector NIST #19 (P=0, N=7, A=32, T=16)
depends_on:0:1
9:exp:1:hex:"6a798d7c5e1a72b43e20ad5c7b08567b12ab744b61c070e2":hex:"5a8aa485c316e9":hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22ec22b1a268f88e2c":hex:"":hex:"5280a2137fee3deefcfe9b63a1199fb3":char*:"":hex:"":int:0
AES-192-CCM test vector NIST #20 (P=0, N=7, A=32, T=16)
depends_on:0:1
9:exp:1:hex:"6a798d7c5e1a72b43e20ad5c7b08567b12ab744b61c070e2":hex:"a265480ca88d5f":hex:"a2248a882ecbf850daf91933a389e78e81623d233dfd47bf8321361a38f138fe":hex:"":hex:"d40a7318c5f2d82f838c0beeefe0d598":char*:"FAIL":hex:"":int:0
AES-192-CCM test vector NIST #21 (P=0, N=13, A=32, T=4)
depends_on:0:1
9:exp:1:hex:"6a798d7c5e1a72b43e20ad5c7b08567b12ab744b61c070e2":hex:"5a8aa485c316e9403aff859fbb":hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697a7ee6410184c7982":hex:"":hex:"5e0eaebd":char*:"":hex:"":int:0
AES-192-CCM test vector NIST #22 (P=0, N=13, A=32, T=4)
depends_on:0:1
9:exp:1:hex:"6a798d7c5e1a72b43e20ad5c7b08567b12ab744b61c070e2":hex:"8739b4bea1a099fe547499cbc6":hex:"f6107696edb332b2ea059d8860fee26be42e5e12e1a4f79a8d0eafce1b2278a7":hex:"":hex:"71b7fc33":char*:"FAIL":hex:"":int:0
AES-192-CCM test vector NIST #23 (P=0, N=13, A=32, T=16)
depends_on:0:1
9:exp:1:hex:"f9fdca4ac64fe7f014de0f43039c757194d544ce5d15eed4":hex:"5a8aa485c316e9403aff859fbb":hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697a7ee6410184c7982":hex:"":hex:"d07ccf9fdc3d33aa94cda3d230da707c":char*:"":hex:"":int:0
AES-192-CCM test vector NIST #24 (P=0, N=13, A=32, T=16)
depends_on:0:1
9:exp:1:hex:"f9fdca4ac64fe7f014de0f43039c757194d544ce5d15eed4":hex:"8739b4bea1a099fe547499cbc6":hex:"f6107696edb332b2ea059d8860fee26be42e5e12e1a4f79a8d0eafce1b2278a7":hex:"":hex:"65fe32b649dc328c9f531584897e85b3":char*:"FAIL":hex:"":int:0
AES-192-CCM test vector NIST #25 (P=24, N=7, A=32, T=4)
depends_on:0:1
9:exp:1:hex:"f9fdca4ac64fe7f014de0f43039c757194d544ce5d15eed4":hex:"5a8aa485c316e9":hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22ec22b1a268f88e2c":hex:"9f6ca4af9b159148c889a6584d1183ea26e2614874b05045":hex:"75dea8d1":char*:"":hex:"a265480ca88d5f536db0dc6abc40faf0d05be7a966977768":int:0
AES-192-CCM test vector NIST #26 (P=24, N=7, A=32, T=4)
depends_on:0:1
9:exp:1:hex:"f9fdca4ac64fe7f014de0f43039c757194d544ce5d15eed4":hex:"fdd2d6f503c915":hex:"5b92394f21ddc3ad49d9b0881b829a5935cb3a4d23e292a62fb66b5e7ab7020e":hex:"84d8212e9cfc2121252baa3b065b1edcf50497b9594db1eb":hex:"d7965825":char*:"FAIL":hex:"":int:0
AES-192-CCM test vector NIST #27 (P=24, N=7, A=32, T=16)
depends_on:0:1
9:exp:1:hex:"a7aa635ea51b0bb20a092bd5573e728ccd4b3e8cdd2ab33d":hex:"5a8aa485c316e9":hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22ec22b1a268f88e2c":hex:"6aab64c4787599d8f213446beadb16e08dba60e97f56dbd1":hex:"4d1d980d6fe0fb44b421992662b97975":char*:"":hex:"a265480ca88d5f536db0dc6abc40faf0d05be7a966977768":int:0
AES-192-CCM test vector NIST #28 (P=24, N=7, A=32, T=16)
depends_on:0:1
9:exp:1:hex:"a7aa635ea51b0bb20a092bd5573e728ccd4b3e8cdd2ab33d":hex:"fdd2d6f503c915":hex:"5b92394f21ddc3ad49d9b0881b829a5935cb3a4d23e292a62fb66b5e7ab7020e":hex:"4980b2ee49b1aaf393175f5ab9bae95ec7904557dfa20660":hex:"3c51d36c826f01384100886198a7f6a3":char*:"FAIL":hex:"":int:0
AES-192-CCM test vector NIST #29 (P=24, N=13, A=32, T=4)
depends_on:0:1
9:exp:1:hex:"a7aa635ea51b0bb20a092bd5573e728ccd4b3e8cdd2ab33d":hex:"5a8aa485c316e9403aff859fbb":hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697a7ee6410184c7982":hex:"16e543d0e20615ff0df15acd9927ddfe40668a54bb854ccc":hex:"c25e9fce":char*:"":hex:"8739b4bea1a099fe547499cbc6d1b13d849b8084c9b6acc5":int:0
AES-192-CCM test vector NIST #30 (P=24, N=13, A=32, T=4)
depends_on:0:1
9:exp:1:hex:"a7aa635ea51b0bb20a092bd5573e728ccd4b3e8cdd2ab33d":hex:"0812757ad0cc4d17c4cfe7a642":hex:"ec6c44a7e94e51a3ca6dee229098391575ec7213c85267fbf7492fdbeee61b10":hex:"df35b109caf690656ae278bbd8f8bba687a2ce11b105dae9":hex:"8ecedb3e":char*:"FAIL":hex:"":int:0
AES-192-CCM test vector NIST #31 (P=24, N=13, A=32, T=16)
depends_on:0:1
9:exp:1:hex:"26511fb51fcfa75cb4b44da75a6e5a0eb8d9c8f3b906f886":hex:"5a8aa485c316e9403aff859fbb":hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697a7ee6410184c7982":hex:"c5b0b2ef17498c5570eb335df4588032958ba3d69bf6f317":hex:"8464a6f7fa2b76744e8e8d95691cecb8":char*:"":hex:"8739b4bea1a099fe547499cbc6d1b13d849b8084c9b6acc5":int:0
AES-192-CCM test vector NIST #32 (P=24, N=13, A=32, T=16)
depends_on:0:1
9:exp:1:hex:"26511fb51fcfa75cb4b44da75a6e5a0eb8d9c8f3b906f886":hex:"0812757ad0cc4d17c4cfe7a642":hex:"ec6c44a7e94e51a3ca6dee229098391575ec7213c85267fbf7492fdbeee61b10":hex:"d1f0518929f4ae2f0543de2a7dfe4bb0110bb3057e524a1c":hex:"06bd6dc2e6bcc3436cffb969ae900388":char*:"FAIL":hex:"":int:0
AES-256-CCM test vector NIST #1 (P=0, N=7, A=0, T=4)
depends_on:0:1
9:exp:2:hex:"eda32f751456e33195f1f499cf2dc7c97ea127b6d488f211ccc5126fbb24afa6":hex:"a544218dadd3c1":hex:"":hex:"":hex:"469c90bb":char*:"":hex:"":int:0
AES-256-CCM test vector NIST #2 (P=0, N=7, A=0, T=4)
depends_on:0:1
9:exp:2:hex:"eda32f751456e33195f1f499cf2dc7c97ea127b6d488f211ccc5126fbb24afa6":hex:"d3d5424e20fbec":hex:"":hex:"":hex:"46a908ed":char*:"FAIL":hex:"":int:0
AES-256-CCM test vector NIST #3 (P=0, N=7, A=0, T=16)
depends_on:0:1
9:exp:2:hex:"e1b8a927a95efe94656677b692662000278b441c79e879dd5c0ddc758bdc9ee8":hex:"a544218dadd3c1":hex:"":hex:"":hex:"8207eb14d33855a52acceed17dbcbf6e":char*:"":hex:"":int:0
AES-256-CCM test vector NIST #4 (P=0, N=7, A=0, T=16)
depends_on:0:1
9:exp:2:hex:"e1b8a927a95efe94656677b692662000278b441c79e879dd5c0ddc758bdc9ee8":hex:"d3d5424e20fbec":hex:"":hex:"":hex:"60f8e127cb4d30db6df0622158cd931d":char*:"FAIL":hex:"":int:0
AES-256-CCM test vector NIST #5 (P=0, N=13, A=0, T=4)
depends_on:0:1
9:exp:2:hex:"e1b8a927a95efe94656677b692662000278b441c79e879dd5c0ddc758bdc9ee8":hex:"a544218dadd3c10583db49cf39":hex:"":hex:"":hex:"8a19a133":char*:"":hex:"":int:0
AES-256-CCM test vector NIST #6 (P=0, N=13, A=0, T=4)
depends_on:0:1
9:exp:2:hex:"e1b8a927a95efe94656677b692662000278b441c79e879dd5c0ddc758bdc9ee8":hex:"3c0e2815d37d844f7ac240ba9d":hex:"":hex:"":hex:"2e317f1b":char*:"FAIL":hex:"":int:0
AES-256-CCM test vector NIST #7 (P=0, N=13, A=0, T=16)
depends_on:0:1
9:exp:2:hex:"af063639e66c284083c5cf72b70d8bc277f5978e80d9322d99f2fdc718cda569":hex:"a544218dadd3c10583db49cf39":hex:"":hex:"":hex:"97e1a8dd4259ccd2e431e057b0397fcf":char*:"":hex:"":int:0
AES-256-CCM test vector NIST #8 (P=0, N=13, A=0, T=16)
depends_on:0:1
9:exp:2:hex:"af063639e66c284083c5cf72b70d8bc277f5978e80d9322d99f2fdc718cda569":hex:"3c0e2815d37d844f7ac240ba9d":hex:"":hex:"":hex:"5a9596c511ea6a8671adefc4f2157d8b":char*:"FAIL":hex:"":int:0
AES-256-CCM test vector NIST #9 (P=24, N=7, A=0, T=4)
depends_on:0:1
9:exp:2:hex:"af063639e66c284083c5cf72b70d8bc277f5978e80d9322d99f2fdc718cda569":hex:"a544218dadd3c1":hex:"":hex:"64a1341679972dc5869fcf69b19d5c5ea50aa0b5e985f5b7":hex:"22aa8d59":char*:"":hex:"d3d5424e20fbec43ae495353ed830271515ab104f8860c98":int:0
AES-256-CCM test vector NIST #10 (P=24, N=7, A=0, T=4)
depends_on:0:1
9:exp:2:hex:"af063639e66c284083c5cf72b70d8bc277f5978e80d9322d99f2fdc718cda569":hex:"bfcda8b5a2d0d2":hex:"":hex:"c5b7f802bffc498c1626e3774f1d9f94045dfd8e1a10a202":hex:"77d00a75":char*:"FAIL":hex:"":int:0
AES-256-CCM test vector NIST #11 (P=24, N=7, A=0, T=16)
depends_on:0:1
9:exp:2:hex:"f7079dfa3b5c7b056347d7e437bcded683abd6e2c9e069d333284082cbb5d453":hex:"a544218dadd3c1":hex:"":hex:"bc51c3925a960e7732533e4ef3a4f69ee6826de952bcb0fd":hex:"374f3bb6db8377ebfc79674858c4f305":char*:"":hex:"d3d5424e20fbec43ae495353ed830271515ab104f8860c98":int:0
AES-256-CCM test vector NIST #12 (P=24, N=7, A=0, T=16)
depends_on:0:1
9:exp:2:hex:"f7079dfa3b5c7b056347d7e437bcded683abd6e2c9e069d333284082cbb5d453":hex:"bfcda8b5a2d0d2":hex:"":hex:"afa1fa8e8a70e26b02161150556d604101fdf423f332c336":hex:"3275f2a4907d51b734fe7238cebbd48f":char*:"FAIL":hex:"":int:0
AES-256-CCM test vector NIST #13 (P=24, N=13, A=0, T=4)
depends_on:0:1
9:exp:2:hex:"f7079dfa3b5c7b056347d7e437bcded683abd6e2c9e069d333284082cbb5d453":hex:"a544218dadd3c10583db49cf39":hex:"":hex:"63e00d30e4b08fd2a1cc8d70fab327b2368e77a93be4f412":hex:"3d14fb3f":char*:"":hex:"3c0e2815d37d844f7ac240ba9d6e3a0b2a86f706e885959e":int:0
AES-256-CCM test vector NIST #14 (P=24, N=13, A=0, T=4)
depends_on:0:1
9:exp:2:hex:"f7079dfa3b5c7b056347d7e437bcded683abd6e2c9e069d333284082cbb5d453":hex:"894dcaa61008eb8fb052c60d41":hex:"":hex:"bb5425b3869b76856ec58e39886fb6f6f2ac13fe44cb132d":hex:"8d0c0099":char*:"FAIL":hex:"":int:0
AES-256-CCM test vector NIST #15 (P=24, N=13, A=0, T=16)
depends_on:0:1
9:exp:2:hex:"1b0e8df63c57f05d9ac457575ea764524b8610ae5164e6215f426f5a7ae6ede4":hex:"a544218dadd3c10583db49cf39":hex:"":hex:"f0050ad16392021a3f40207bed3521fb1e9f808f49830c42":hex:"3a578d179902f912f9ea1afbce1120b3":char*:"":hex:"3c0e2815d37d844f7ac240ba9d6e3a0b2a86f706e885959e":int:0
AES-256-CCM test vector NIST #16 (P=24, N=13, A=0, T=16)
depends_on:0:1
9:exp:2:hex:"1b0e8df63c57f05d9ac457575ea764524b8610ae5164e6215f426f5a7ae6ede4":hex:"894dcaa61008eb8fb052c60d41":hex:"":hex:"c408190d0fbf5034f83b24a8ed9657331a7ce141de4fae76":hex:"9084607b83bd06e6442eac8dacf583cc":char*:"FAIL":hex:"":int:0
AES-256-CCM test vector NIST #17 (P=0, N=7, A=32, T=4)
depends_on:0:1
9:exp:2:hex:"1b0e8df63c57f05d9ac457575ea764524b8610ae5164e6215f426f5a7ae6ede4":hex:"a544218dadd3c1":hex:"d3d5424e20fbec43ae495353ed830271515ab104f8860c988d15b6d36c038eab":hex:"":hex:"92d00fbe":char*:"":hex:"":int:0
AES-256-CCM test vector NIST #18 (P=0, N=7, A=32, T=4)
depends_on:0:1
9:exp:2:hex:"1b0e8df63c57f05d9ac457575ea764524b8610ae5164e6215f426f5a7ae6ede4":hex:"78c46e3249ca28":hex:"232e957c65ffa11988e830d4617d500f1c4a35c1221f396c41ab214f074ca2dc":hex:"":hex:"9143e5c4":char*:"FAIL":hex:"":int:0
AES-256-CCM test vector NIST #19 (P=0, N=7, A=32, T=16)
depends_on:0:1
9:exp:2:hex:"a4bc10b1a62c96d459fbaf3a5aa3face7313bb9e1253e696f96a7a8e36801088":hex:"a544218dadd3c1":hex:"d3d5424e20fbec43ae495353ed830271515ab104f8860c988d15b6d36c038eab":hex:"":hex:"93af11a08379eb37a16aa2837f09d69d":char*:"":hex:"":int:0
AES-256-CCM test vector NIST #20 (P=0, N=7, A=32, T=16)
depends_on:0:1
9:exp:2:hex:"a4bc10b1a62c96d459fbaf3a5aa3face7313bb9e1253e696f96a7a8e36801088":hex:"78c46e3249ca28":hex:"232e957c65ffa11988e830d4617d500f1c4a35c1221f396c41ab214f074ca2dc":hex:"":hex:"d19b0c14ec686a7961ca7c386d125a65":char*:"FAIL":hex:"":int:0
AES-256-CCM test vector NIST #21 (P=0, N=13, A=32, T=4)
depends_on:0:1
9:exp:2:hex:"a4bc10b1a62c96d459fbaf3a5aa3face7313bb9e1253e696f96a7a8e36801088":hex:"a544218dadd3c10583db49cf39":hex:"3c0e2815d37d844f7ac240ba9d6e3a0b2a86f706e885959e09a1005e024f6907":hex:"":hex:"866d4227":char*:"":hex:"":int:0
AES-256-CCM test vector NIST #22 (P=0, N=13, A=32, T=4)
depends_on:0:1
9:exp:2:hex:"a4bc10b1a62c96d459fbaf3a5aa3face7313bb9e1253e696f96a7a8e36801088":hex:"e8de970f6ee8e80ede933581b5":hex:"89f8b068d34f56bc49d839d8e47b347e6dae737b903b278632447e6c0485d26a":hex:"":hex:"94cb1127":char*:"FAIL":hex:"":int:0
AES-256-CCM test vector NIST #23 (P=0, N=13, A=32, T=16)
depends_on:0:1
9:exp:2:hex:"8c5cf3457ff22228c39c051c4e05ed4093657eb303f859a9d4b0f8be0127d88a":hex:"a544218dadd3c10583db49cf39":hex:"3c0e2815d37d844f7ac240ba9d6e3a0b2a86f706e885959e09a1005e024f6907":hex:"":hex:"867b0d87cf6e0f718200a97b4f6d5ad5":char*:"":hex:"":int:0
AES-256-CCM test vector NIST #24 (P=0, N=13, A=32, T=16)
depends_on:0:1
9:exp:2:hex:"8c5cf3457ff22228c39c051c4e05ed4093657eb303f859a9d4b0f8be0127d88a":hex:"e8de970f6ee8e80ede933581b5":hex:"89f8b068d34f56bc49d839d8e47b347e6dae737b903b278632447e6c0485d26a":hex:"":hex:"677a040d46ee3f2b7838273bdad14f16":char*:"FAIL":hex:"":int:0
AES-256-CCM test vector NIST #25 (P=24, N=7, A=32, T=4)
depends_on:0:1
9:exp:2:hex:"8c5cf3457ff22228c39c051c4e05ed4093657eb303f859a9d4b0f8be0127d88a":hex:"a544218dadd3c1":hex:"d3d5424e20fbec43ae495353ed830271515ab104f8860c988d15b6d36c038eab":hex:"c2fe12658139f5d0dd22cadf2e901695b579302a72fc5608":hex:"3ebc7720":char*:"":hex:"78c46e3249ca28e1ef0531d80fd37c124d9aecb7be6668e3":int:0
AES-256-CCM test vector NIST #26 (P=24, N=7, A=32, T=4)
depends_on:0:1
9:exp:2:hex:"8c5cf3457ff22228c39c051c4e05ed4093657eb303f859a9d4b0f8be0127d88a":hex:"6ba004fd176791":hex:"5a053b2a1bb87e85d56527bfcdcd3ecafb991bb10e4c862bb0751c700a29f54b":hex:"94748ba81229e53c38583a8564b23ebbafc6f6efdf4c2a81":hex:"c44db2c9":char*:"FAIL":hex:"":int:0
AES-256-CCM test vector NIST #27 (P=24, N=7, A=32, T=16)
depends_on:0:1
9:exp:2:hex:"705334e30f53dd2f92d190d2c1437c8772f940c55aa35e562214ed45bd458ffe":hex:"a544218dadd3c1":hex:"d3d5424e20fbec43ae495353ed830271515ab104f8860c988d15b6d36c038eab":hex:"3341168eb8c48468c414347fb08f71d2086f7c2d1bd581ce":hex:"1ac68bd42f5ec7fa7e068cc0ecd79c2a":char*:"":hex:"78c46e3249ca28e1ef0531d80fd37c124d9aecb7be6668e3":int:0
AES-256-CCM test vector NIST #28 (P=24, N=7, A=32, T=16)
depends_on:0:1
9:exp:2:hex:"705334e30f53dd2f92d190d2c1437c8772f940c55aa35e562214ed45bd458ffe":hex:"6ba004fd176791":hex:"5a053b2a1bb87e85d56527bfcdcd3ecafb991bb10e4c862bb0751c700a29f54b":hex:"d543acda712b898cbb27b8f598b2e4438ce587a836e27851":hex:"47c3338a2400809e739b63ba8227d2f9":char*:"FAIL":hex:"":int:0
AES-256-CCM test vector NIST #29 (P=24, N=13, A=32, T=4)
depends_on:0:1
9:exp:2:hex:"705334e30f53dd2f92d190d2c1437c8772f940c55aa35e562214ed45bd458ffe":hex:"a544218dadd3c10583db49cf39":hex:"3c0e2815d37d844f7ac240ba9d6e3a0b2a86f706e885959e09a1005e024f6907":hex:"c0ea400b599561e7905b99262b4565d5c3dc49fad84d7c69":hex:"ef891339":char*:"":hex:"e8de970f6ee8e80ede933581b5bcf4d837e2b72baa8b00c3":int:0
AES-256-CCM test vector NIST #30 (P=24, N=13, A=32, T=4)
depends_on:0:1
9:exp:2:hex:"705334e30f53dd2f92d190d2c1437c8772f940c55aa35e562214ed45bd458ffe":hex:"8fa501c5dd9ac9b868144c9fa5":hex:"5bb40e3bb72b4509324a7edc852f72535f1f6283156e63f6959ffaf39dcde800":hex:"60871e03ea0eb968536c99f926ea24ef43d41272ad9fb7f6":hex:"3d488623":char*:"FAIL":hex:"":int:0
AES-256-CCM test vector NIST #31 (P=24, N=13, A=32, T=16)
depends_on:0:1
9:exp:2:hex:"314a202f836f9f257e22d8c11757832ae5131d357a72df88f3eff0ffcee0da4e":hex:"a544218dadd3c10583db49cf39":hex:"3c0e2815d37d844f7ac240ba9d6e3a0b2a86f706e885959e09a1005e024f6907":hex:"8d34cdca37ce77be68f65baf3382e31efa693e63f914a781":hex:"367f30f2eaad8c063ca50795acd90203":char*:"":hex:"e8de970f6ee8e80ede933581b5bcf4d837e2b72baa8b00c3":int:0
AES-256-CCM test vector NIST #32 (P=24, N=13, A=32, T=16)
depends_on:0:1
9:exp:2:hex:"314a202f836f9f257e22d8c11757832ae5131d357a72df88f3eff0ffcee0da4e":hex:"8fa501c5dd9ac9b868144c9fa5":hex:"5bb40e3bb72b4509324a7edc852f72535f1f6283156e63f6959ffaf39dcde800":hex:"516c0095cc3d85fd55e48da17c592e0c7014b9daafb82bdc":hex:"4b41096dfdbe9cc1ab610f8f3e038d16":char*:"FAIL":hex:"":int:0
Camellia-CCM test vector RFC 5528 #1
depends_on:2:1
9:exp:3:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"00000003020100A0A1A2A3A4A5":hex:"0001020304050607":hex:"BA737185E719310492F38A5F1251DA55FAFBC949848A0D":hex:"FCAECE746B3DB9AD":char*:"":hex:"08090A0B0C0D0E0F101112131415161718191A1B1C1D1E":int:0
Camellia-CCM test vector RFC 5528 #2
depends_on:2:1
9:exp:3:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"00000004030201A0A1A2A3A4A5":hex:"0001020304050607":hex:"5D2564BF8EAFE1D99526EC016D1BF0424CFBD2CD62848F33":hex:"60B2295DF24283E8":char*:"":hex:"08090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F":int:0
Camellia-CCM test vector RFC 5528 #3
depends_on:2:1
9:exp:3:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"00000005040302A0A1A2A3A4A5":hex:"0001020304050607":hex:"81F663D6C7787817F9203608B982AD15DC2BBD87D756F79204":hex:"F551D6682F23AA46":char*:"":hex:"08090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F20":int:0
Camellia-CCM test vector RFC 5528 #4
depends_on:2:1
9:exp:3:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"00000006050403A0A1A2A3A4A5":hex:"000102030405060708090A0B":hex:"CAEF1E827211B08F7BD90F08C77288C070A4A0":hex:"8B3A933A63E497A0":char*:"":hex:"0C0D0E0F101112131415161718191A1B1C1D1E":int:0
Camellia-CCM test vector RFC 5528 #5
depends_on:2:1
9:exp:3:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"00000007060504A0A1A2A3A4A5":hex:"000102030405060708090A0B":hex:"2AD3BAD94FC52E92BE438E827C1023B96A8A7725":hex:"8FA17BA7F331DB09":char*:"":hex:"0C0D0E0F101112131415161718191A1B1C1D1E1F":int:0
Camellia-CCM test vector RFC 5528 #6
depends_on:2:1
9:exp:3:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"00000008070605A0A1A2A3A4A5":hex:"000102030405060708090A0B":hex:"FEA5480BA53FA8D3C34422AACE4DE67FFA3BB73BAB":hex:"AB36A1EE4FE0FE28":char*:"":hex:"0C0D0E0F101112131415161718191A1B1C1D1E1F20":int:0
Camellia-CCM test vector RFC 5528 #7
depends_on:2:1
9:exp:3:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"00000009080706A0A1A2A3A4A5":hex:"0001020304050607":hex:"54532026E54C119A8D36D9EC6E1ED97416C8708C4B5C2C":hex:"ACAFA3BCCF7A4EBF9573":char*:"":hex:"08090A0B0C0D0E0F101112131415161718191A1B1C1D1E":int:0
Camellia-CCM test vector RFC 5528 #8
depends_on:2:1
9:exp:3:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"0000000A090807A0A1A2A3A4A5":hex:"0001020304050607":hex:"8AD19B001A87D148F4D92BEF34525CCCE3A63C6512A6F575":hex:"7388E4913EF14701F441":char*:"":hex:"08090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F":int:0
Camellia-CCM test vector RFC 5528 #9
depends_on:2:1
9:exp:3:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"0000000B0A0908A0A1A2A3A4A5":hex:"0001020304050607":hex:"5DB08D62407E6E31D60F9CA2C60474219AC0BE50C0D4A57787":hex:"94D6E230CD25C9FEBF87":char*:"":hex:"08090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F20":int:0
Camellia-CCM test vector RFC 5528 #10
depends_on:2:1
9:exp:3:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"0000000C0B0A09A0A1A2A3A4A5":hex:"000102030405060708090A0B":hex:"DB118CCEC1B8761C877CD8963A67D6F3BBBC5C":hex:"D09299EB11F312F23237":char*:"":hex:"0C0D0E0F101112131415161718191A1B1C1D1E":int:0
Camellia-CCM test vector RFC 5528 #11
depends_on:2:1
9:exp:3:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"0000000D0C0B0AA0A1A2A3A4A5":hex:"000102030405060708090A0B":hex:"7CC83D8DC49103525B483DC5CA7EA9AB812B7056":hex:"079DAFFADA16CCCF2C4E":char*:"":hex:"0C0D0E0F101112131415161718191A1B1C1D1E1F":int:0
Camellia-CCM test vector RFC 5528 #12
depends_on:2:1
9:exp:3:hex:"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF":hex:"0000000E0D0C0BA0A1A2A3A4A5":hex:"000102030405060708090A0B":hex:"2CD35B8820D23E7AA351B0E92FC79367238B2CC748":hex:"CBB94C2947793D64AF75":char*:"":hex:"0C0D0E0F101112131415161718191A1B1C1D1E1F20":int:0
Camellia-CCM test vector RFC 5528 #13
depends_on:2:1
9:exp:3:hex:"D75C2778078CA93D971F96FDE720F4CD":hex:"00A970110E1927B160B6A31C1C":hex:"6B7F464507FAE496":hex:"A435D727348DDD22907F7EB8F5FDBB4D939DA6524DB4F6":hex:"4558C02D25B127EE":char*:"":hex:"C6B5F3E6CA2311AEF7472B203E735EA561ADB17D56C5A3":int:0
Camellia-CCM test vector RFC 5528 #14
depends_on:2:1
9:exp:3:hex:"D75C2778078CA93D971F96FDE720F4CD":hex:"0083CD8CE0CB42B160B6A31C1C":hex:"986605B43DF15DE7":hex:"8AE052508FBECA932E346F05E0DC0DFBCF939EAFFA3E587C":hex:"867D6E1C48703806":char*:"":hex:"01F6CE6764C574483BB02E6BBF1E0ABD26A22572B4D80EE7":int:0
Camellia-CCM test vector RFC 5528 #15
depends_on:2:1
9:exp:3:hex:"D75C2778078CA93D971F96FDE720F4CD":hex:"005F54950B18F2B160B6A31C1C":hex:"48F2E7E1A7671A51":hex:"08B67EE21C8BF26E473E408599E9C0836D6AF0BB18DF55466C":hex:"A80878A790476DE5":char*:"":hex:"CDF1D8406FC2E9014953897005FBFB8BA57276F92404608E08":int:0
Camellia-CCM test vector RFC 5528 #16
depends_on:2:1
9:exp:3:hex:"D75C2778078CA93D971F96FDE720F4CD":hex:"00EC600863319AB160B6A31C1C":hex:"DE97DF3B8CBD6D8E5030DA4C":hex:"63B78B4967B19EDBB733CD1114F64EB2260893":hex:"68C354828D950CC5":char*:"":hex:"B005DCFA0B59181426A961685A993D8C43185B":int:0
Camellia-CCM test vector RFC 5528 #17
depends_on:2:1
9:exp:3:hex:"D75C2778078CA93D971F96FDE720F4CD":hex:"0060CFF1A31EA1B160B6A31C1C":hex:"A5EE93E457DF05466E782DCF":hex:"0BC6BBE2A8B909F4629EE6DC148DA44410E18AF4":hex:"3147383276F66A9F":char*:"":hex:"2E20211298105F129D5ED95B93F72D30B2FACCD7":int:0
Camellia-CCM test vector RFC 5528 #18
depends_on:2:1
9:exp:3:hex:"D75C2778078CA93D971F96FDE720F4CD":hex:"000F85CD995C97B160B6A31C1C":hex:"24AA1BF9A5CD876182A25074":hex:"222AD632FA31D6AF970C345F7E77CA3BD0DC25B340":hex:"A1A3D31F8D4B44B7":char*:"":hex:"2645941E75632D3491AF0FC0C9876C3BE4AA7468C9":int:0
Camellia-CCM test vector RFC 5528 #19
depends_on:2:1
9:exp:3:hex:"D75C2778078CA93D971F96FDE720F4CD":hex:"00C29B2CAAC4CDB160B6A31C1C":hex:"691946B9CA07BE87":hex:"05B8E1B9C49CFD56CF130AA6251DC2ECC06CCC508FE697":hex:"A0066D57C84BEC182768":char*:"":hex:"070135A6437C9DB120CD61D8F6C39C3EA125FD95A0D23D":int:0
Camellia-CCM test vector RFC 5528 #20
depends_on:2:1
9:exp:3:hex:"D75C2778078CA93D971F96FDE720F4CD":hex:"002C6B7595EE62B160B6A31C1C":hex:"D0C54ECB84627DC4":hex:"54CEB968DEE23611575EC003DFAA1CD48849BDF5AE2EDB6B":hex:"7FA775B150ED4383C5A9":char*:"":hex:"C8C0880E6C636E20093DD6594217D2E18877DB264E71A5CC":int:0
Camellia-CCM test vector RFC 5528 #21
depends_on:2:1
9:exp:3:hex:"D75C2778078CA93D971F96FDE720F4CD":hex:"00C53CD4C2AA24B160B6A31C1C":hex:"E285E0E4808CDA3D":hex:"B1404546BF667210CA28E309B39BD6CA7E9FC8285FE698D43C":hex:"D20A02E0BDCAED2010D3":char*:"":hex:"F75DAA0710C4E64297794DC2B7D2A20757B1AA4E448002FFAB":int:0
Camellia-CCM test vector RFC 5528 #22
depends_on:2:1
9:exp:3:hex:"D75C2778078CA93D971F96FDE720F4CD":hex:"00BEE9267FBADCB160B6A31C1C":hex:"6CAEF9941141570D7C813405":hex:"94C8959C11569A297831A721005857AB61B87A":hex:"2DEA0936B6EB5F625F5D":char*:"":hex:"C238822FAC5F98FF929405B0AD127A4E41854E":int:0
Camellia-CCM test vector RFC 5528 #23
depends_on:2:1
9:exp:3:hex:"D75C2778078CA93D971F96FDE720F4CD":hex:"00DFA8B1245007B160B6A31C1C":hex:"36A52CF16B19A2037AB7011E":hex:"5869E3AAD2447C74E0FC05F9A4EA74577F4DE8CA":hex:"8924764296AD04119CE7":char*:"":hex:"4DBF3E774AD245E5D5891F9D1C32A0AE022C85D7":int:0
Camellia-CCM test vector RFC 5528 #24
depends_on:2:1
9:exp:3:hex:"D75C2778078CA93D971F96FDE720F4CD":hex:"003B8FD8D3A937B160B6A31C1C":hex:"A4D499F78419728C19178B0C":hex:"4B198156393B0F7796086AAFB454F8C3F034CCA966":hex:"945F1FCEA7E11BEE6A2F":char*:"":hex:"9DC9EDAE2FF5DF8636E8C6DE0EED55F7867E33337D":int:0
AES-128-CCM test vector NIST #1 PSA (P=0, N=7, A=0, T=4)
depends_on:3:0:1
9:exp:0:hex:"4ae701103c63deca5b5a3939d7d05992":hex:"5a8aa485c316e9":hex:"":hex:"":hex:"02209f55":char*:"":hex:"":int:1
AES-128-CCM test vector NIST #2 PSA (P=0, N=7, A=0, T=4)
depends_on:3:0:1
9:exp:0:hex:"4ae701103c63deca5b5a3939d7d05992":hex:"3796cf51b87266":hex:"":hex:"":hex:"9a04c241":char*:"FAIL":hex:"":int:1
AES-128-CCM test vector NIST #3 PSA (P=0, N=7, A=0, T=16)
depends_on:3:0:1
9:exp:0:hex:"4bb3c4a4f893ad8c9bdc833c325d62b3":hex:"5a8aa485c316e9":hex:"":hex:"":hex:"75d582db43ce9b13ab4b6f7f14341330":char*:"":hex:"":int:1
AES-128-CCM test vector NIST #4 PSA (P=0, N=7, A=0, T=16)
depends_on:3:0:1
9:exp:0:hex:"4bb3c4a4f893ad8c9bdc833c325d62b3":hex:"3796cf51b87266":hex:"":hex:"":hex:"3a65e03af37b81d05acc7ec1bc39deb0":char*:"FAIL":hex:"":int:1
AES-128-CCM test vector NIST #5 PSA (P=0, N=13, A=0, T=4)
depends_on:3:0:1
9:exp:0:hex:"4bb3c4a4f893ad8c9bdc833c325d62b3":hex:"5a8aa485c316e9403aff859fbb":hex:"":hex:"":hex:"90156f3f":char*:"":hex:"":int:1
AES-128-CCM test vector NIST #6 PSA (P=0, N=13, A=0, T=4)
depends_on:3:0:1
9:exp:0:hex:"4bb3c4a4f893ad8c9bdc833c325d62b3":hex:"a16a2e741f1cd9717285b6d882":hex:"":hex:"":hex:"88909016":char*:"FAIL":hex:"":int:1
AES-128-CCM test vector NIST #7 PSA (P=0, N=13, A=0, T=16)
depends_on:3:0:1
9:exp:0:hex:"19ebfde2d5468ba0a3031bde629b11fd":hex:"5a8aa485c316e9403aff859fbb":hex:"":hex:"":hex:"fb04dc5a44c6bb000f2440f5154364b4":char*:"":hex:"":int:1
AES-128-CCM test vector NIST #8 PSA (P=0, N=13, A=0, T=16)
depends_on:3:0:1
9:exp:0:hex:"19ebfde2d5468ba0a3031bde629b11fd":hex:"a16a2e741f1cd9717285b6d882":hex:"":hex:"":hex:"5447075bf42a59b91f08064738b015ab":char*:"FAIL":hex:"":int:1
AES-128-CCM test vector NIST #9 PSA (P=24, N=7, A=0, T=4)
depends_on:3:0:1
9:exp:0:hex:"19ebfde2d5468ba0a3031bde629b11fd":hex:"5a8aa485c316e9":hex:"":hex:"a90e8ea44085ced791b2fdb7fd44b5cf0bd7d27718029bb7":hex:"03e1fa6b":char*:"":hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22":int:1
AES-128-CCM test vector NIST #10 PSA (P=24, N=7, A=0, T=4)
depends_on:3:0:1
9:exp:0:hex:"19ebfde2d5468ba0a3031bde629b11fd":hex:"31f8fa25827d48":hex:"":hex:"50aafe0578c115c4a8e126ff7b3ccb64dce8ccaa8ceda69f":hex:"23e5d81c":char*:"FAIL":hex:"":int:1
AES-128-CCM test vector NIST #11 PSA (P=24, N=7, A=0, T=16)
depends_on:3:0:1
9:exp:0:hex:"197afb02ffbd8f699dacae87094d5243":hex:"5a8aa485c316e9":hex:"":hex:"24ab9eeb0e5508cae80074f1070ee188a637171860881f1f":hex:"2d9a3fbc210595b7b8b1b41523111a8e":char*:"":hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22":int:1
AES-128-CCM test vector NIST #12 PSA (P=24, N=7, A=0, T=16)
depends_on:3:0:1
9:exp:0:hex:"197afb02ffbd8f699dacae87094d5243":hex:"31f8fa25827d48":hex:"":hex:"7ebfda6fa5da1dbffd82dc29b875798fbcef8ba0084fbd24":hex:"63af747cc88a001fa94e060290f209c4":char*:"FAIL":hex:"":int:1
AES-128-CCM test vector NIST #13 PSA (P=24, N=13, A=0, T=4)
depends_on:3:0:1
9:exp:0:hex:"197afb02ffbd8f699dacae87094d5243":hex:"5a8aa485c316e9403aff859fbb":hex:"":hex:"4a550134f94455979ec4bf89ad2bd80d25a77ae94e456134":hex:"a3e138b9":char*:"":hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697":int:1
AES-128-CCM test vector NIST #14 PSA (P=24, N=13, A=0, T=4)
depends_on:3:0:1
9:exp:0:hex:"197afb02ffbd8f699dacae87094d5243":hex:"49004912fdd7269279b1f06a89":hex:"":hex:"118ec53dd1bfbe52d5b9fe5dfebecf2ee674ec983eada654":hex:"091a5ae9":char*:"FAIL":hex:"":int:1
AES-128-CCM test vector NIST #15 PSA (P=24, N=13, A=0, T=16)
depends_on:3:0:1
9:exp:0:hex:"90929a4b0ac65b350ad1591611fe4829":hex:"5a8aa485c316e9403aff859fbb":hex:"":hex:"4bfe4e35784f0a65b545477e5e2f4bae0e1e6fa717eaf2cb":hex:"6a9a970b9beb2ac1bd4fd62168f8378a":char*:"":hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697":int:1
AES-128-CCM test vector NIST #16 PSA (P=24, N=13, A=0, T=16)
depends_on:3:0:1
9:exp:0:hex:"90929a4b0ac65b350ad1591611fe4829":hex:"49004912fdd7269279b1f06a89":hex:"":hex:"0c56a503aa2c12e87450d45a7b714db980fd348f327c0065":hex:"a65666144994bad0c8195bcb4ade1337":char*:"FAIL":hex:"":int:1
AES-128-CCM test vector NIST #17 PSA (P=0, N=7, A=32, T=4)
depends_on:3:0:1
9:exp:0:hex:"90929a4b0ac65b350ad1591611fe4829":hex:"5a8aa485c316e9":hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22ec22b1a268f88e2c":hex:"":hex:"782e4318":char*:"":hex:"":int:1
AES-128-CCM test vector NIST #18 PSA (P=0, N=7, A=32, T=4)
depends_on:3:0:1
9:exp:0:hex:"90929a4b0ac65b350ad1591611fe4829":hex:"a265480ca88d5f":hex:"a2248a882ecbf850daf91933a389e78e81623d233dfd47bf8321361a38f138fe":hex:"":hex:"a04f270a":char*:"FAIL":hex:"":int:1
AES-128-CCM test vector NIST #19 PSA (P=0, N=7, A=32, T=16)
depends_on:3:0:1
9:exp:0:hex:"6a798d7c5e1a72b43e20ad5c7b08567b":hex:"5a8aa485c316e9":hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22ec22b1a268f88e2c":hex:"":hex:"41b476013f45e4a781f253a6f3b1e530":char*:"":hex:"":int:1
AES-128-CCM test vector NIST #20 PSA (P=0, N=7, A=32, T=16)
depends_on:3:0:1
9:exp:0:hex:"6a798d7c5e1a72b43e20ad5c7b08567b":hex:"a265480ca88d5f":hex:"a2248a882ecbf850daf91933a389e78e81623d233dfd47bf8321361a38f138fe":hex:"":hex:"f9f018fcd125822616083fffebc4c8e6":char*:"FAIL":hex:"":int:1
AES-128-CCM test vector NIST #21 PSA (P=0, N=13, A=32, T=4)
depends_on:3:0:1
9:exp:0:hex:"6a798d7c5e1a72b43e20ad5c7b08567b":hex:"5a8aa485c316e9403aff859fbb":hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697a7ee6410184c7982":hex:"":hex:"9f69f24f":char*:"":hex:"":int:1
AES-128-CCM test vector NIST #22 PSA (P=0, N=13, A=32, T=4)
depends_on:3:0:1
9:exp:0:hex:"6a798d7c5e1a72b43e20ad5c7b08567b":hex:"8739b4bea1a099fe547499cbc6":hex:"f6107696edb332b2ea059d8860fee26be42e5e12e1a4f79a8d0eafce1b2278a7":hex:"":hex:"e17afaa4":char*:"FAIL":hex:"":int:1
AES-128-CCM test vector NIST #23 PSA (P=0, N=13, A=32, T=16)
depends_on:3:0:1
9:exp:0:hex:"f9fdca4ac64fe7f014de0f43039c7571":hex:"5a8aa485c316e9403aff859fbb":hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697a7ee6410184c7982":hex:"":hex:"1859ac36a40a6b28b34266253627797a":char*:"":hex:"":int:1
AES-128-CCM test vector NIST #24 PSA (P=0, N=13, A=32, T=16)
depends_on:3:0:1
9:exp:0:hex:"f9fdca4ac64fe7f014de0f43039c7571":hex:"8739b4bea1a099fe547499cbc6":hex:"f6107696edb332b2ea059d8860fee26be42e5e12e1a4f79a8d0eafce1b2278a7":hex:"":hex:"edf8b46eb69ac0044116019dec183072":char*:"FAIL":hex:"":int:1
AES-128-CCM test vector NIST #25 PSA (P=24, N=7, A=32, T=4)
depends_on:3:0:1
9:exp:0:hex:"f9fdca4ac64fe7f014de0f43039c7571":hex:"5a8aa485c316e9":hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22ec22b1a268f88e2c":hex:"6be31860ca271ef448de8f8d8b39346daf4b81d7e92d65b3":hex:"38f125fa":char*:"":hex:"a265480ca88d5f536db0dc6abc40faf0d05be7a966977768":int:1
AES-128-CCM test vector NIST #26 PSA (P=24, N=7, A=32, T=4)
depends_on:3:0:1
9:exp:0:hex:"f9fdca4ac64fe7f014de0f43039c7571":hex:"fdd2d6f503c915":hex:"5b92394f21ddc3ad49d9b0881b829a5935cb3a4d23e292a62fb66b5e7ab7020e":hex:"4cc57a9927a6bc401441870d3193bf89ebd163f5c01501c7":hex:"28a66b69":char*:"FAIL":hex:"":int:1
AES-128-CCM test vector NIST #27 PSA (P=24, N=7, A=32, T=16)
depends_on:3:0:1
9:exp:0:hex:"a7aa635ea51b0bb20a092bd5573e728c":hex:"5a8aa485c316e9":hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22ec22b1a268f88e2c":hex:"b351ab96b2e45515254558d5212673ee6c776d42dbca3b51":hex:"2cf3a20b7fd7c49e6e79bef475c2906f":char*:"":hex:"a265480ca88d5f536db0dc6abc40faf0d05be7a966977768":int:1
AES-128-CCM test vector NIST #28 PSA (P=24, N=7, A=32, T=16)
depends_on:3:0:1
9:exp:0:hex:"a7aa635ea51b0bb20a092bd5573e728c":hex:"fdd2d6f503c915":hex:"5b92394f21ddc3ad49d9b0881b829a5935cb3a4d23e292a62fb66b5e7ab7020e":hex:"df1a5285caa41b4bb47f6e5ceceba4e82721828d68427a30":hex:"81d18ca149d6766bfaccec88f194eb5b":char*:"FAIL":hex:"":int:1
AES-128-CCM test vector NIST #29 PSA (P=24, N=13, A=32, T=4)
depends_on:3:0:1
9:exp:0:hex:"a7aa635ea51b0bb20a092bd5573e728c":hex:"5a8aa485c316e9403aff859fbb":hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697a7ee6410184c7982":hex:"934f893824e880f743d196b22d1f340a52608155087bd28a":hex:"c25e5329":char*:"":hex:"8739b4bea1a099fe547499cbc6d1b13d849b8084c9b6acc5":int:1
AES-128-CCM test vector NIST #30 PSA (P=24, N=13, A=32, T=4)
depends_on:3:0:1
9:exp:0:hex:"a7aa635ea51b0bb20a092bd5573e728c":hex:"0812757ad0cc4d17c4cfe7a642":hex:"ec6c44a7e94e51a3ca6dee229098391575ec7213c85267fbf7492fdbeee61b10":hex:"f43ba9d834ad85dfab3f1c0c27c3441fe4e411a38a261a65":hex:"59b3b3ee":char*:"FAIL":hex:"":int:1
AES-128-CCM test vector NIST #31 PSA (P=24, N=13, A=32, T=16)
depends_on:3:0:1
9:exp:0:hex:"26511fb51fcfa75cb4b44da75a6e5a0e":hex:"5a8aa485c316e9403aff859fbb":hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697a7ee6410184c7982":hex:"50038b5fdd364ee747b70d00bd36840ece4ea19998123375":hex:"c0a458bfcafa3b2609afe0f825cbf503":char*:"":hex:"8739b4bea1a099fe547499cbc6d1b13d849b8084c9b6acc5":int:1
AES-128-CCM test vector NIST #32 PSA (P=24, N=13, A=32, T=16)
depends_on:3:0:1
9:exp:0:hex:"26511fb51fcfa75cb4b44da75a6e5a0e":hex:"0812757ad0cc4d17c4cfe7a642":hex:"ec6c44a7e94e51a3ca6dee229098391575ec7213c85267fbf7492fdbeee61b10":hex:"78ed8ff6b5a1255d0fbd0a719a9c27b059ff5f83d0c4962c":hex:"390042ba8bb5f6798dab01c5afad7306":char*:"FAIL":hex:"":int:1
AES-192-CCM test vector NIST #1 PSA (P=0, N=7, A=0, T=4)
depends_on:3:0:1
9:exp:1:hex:"c98ad7f38b2c7e970c9b965ec87a08208384718f78206c6c":hex:"5a8aa485c316e9":hex:"":hex:"":hex:"9d4b7f3b":char*:"":hex:"":int:1
AES-192-CCM test vector NIST #2 PSA (P=0, N=7, A=0, T=4)
depends_on:3:0:1
9:exp:1:hex:"c98ad7f38b2c7e970c9b965ec87a08208384718f78206c6c":hex:"3796cf51b87266":hex:"":hex:"":hex:"80745de9":char*:"FAIL":hex:"":int:1
AES-192-CCM test vector NIST #3 PSA (P=0, N=7, A=0, T=16)
depends_on:3:0:1
9:exp:1:hex:"4bb3c4a4f893ad8c9bdc833c325d62b3d3ad1bccf9282a65":hex:"5a8aa485c316e9":hex:"":hex:"":hex:"17223038fa99d53681ca1beabe78d1b4":char*:"":hex:"":int:1
AES-192-CCM test vector NIST #4 PSA (P=0, N=7, A=0, T=16)
depends_on:3:0:1
9:exp:1:hex:"4bb3c4a4f893ad8c9bdc833c325d62b3d3ad1bccf9282a65":hex:"3796cf51b87266":hex:"":hex:"":hex:"d0e1eeef4d2a264536bb1c2c1bde7c35":char*:"FAIL":hex:"":int:1
AES-192-CCM test vector NIST #5 PSA (P=0, N=13, A=0, T=4)
depends_on:3:0:1
9:exp:1:hex:"4bb3c4a4f893ad8c9bdc833c325d62b3d3ad1bccf9282a65":hex:"5a8aa485c316e9403aff859fbb":hex:"":hex:"":hex:"fe69ed84":char*:"":hex:"":int:1
AES-192-CCM test vector NIST #6 PSA (P=0, N=13, A=0, T=4)
depends_on:3:0:1
9:exp:1:hex:"4bb3c4a4f893ad8c9bdc833c325d62b3d3ad1bccf9282a65":hex:"a16a2e741f1cd9717285b6d882":hex:"":hex:"":hex:"db7ffc82":char*:"FAIL":hex:"":int:1
AES-192-CCM test vector NIST #7 PSA (P=0, N=13, A=0, T=16)
depends_on:3:0:1
9:exp:1:hex:"19ebfde2d5468ba0a3031bde629b11fd4094afcb205393fa":hex:"5a8aa485c316e9403aff859fbb":hex:"":hex:"":hex:"0c66a8e547ed4f8c2c9a9a1eb5d455b9":char*:"":hex:"":int:1
AES-192-CCM test vector NIST #8 PSA (P=0, N=13, A=0, T=16)
depends_on:3:0:1
9:exp:1:hex:"19ebfde2d5468ba0a3031bde629b11fd4094afcb205393fa":hex:"a16a2e741f1cd9717285b6d882":hex:"":hex:"":hex:"38757b3a61a4dc97ca3ab88bf1240695":char*:"FAIL":hex:"":int:1
AES-192-CCM test vector NIST #9 PSA (P=24, N=7, A=0, T=4)
depends_on:3:0:1
9:exp:1:hex:"19ebfde2d5468ba0a3031bde629b11fd4094afcb205393fa":hex:"5a8aa485c316e9":hex:"":hex:"411986d04d6463100bff03f7d0bde7ea2c3488784378138c":hex:"ddc93a54":char*:"":hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22":int:1
AES-192-CCM test vector NIST #10 PSA (P=24, N=7, A=0, T=4)
depends_on:3:0:1
9:exp:1:hex:"19ebfde2d5468ba0a3031bde629b11fd4094afcb205393fa":hex:"31f8fa25827d48":hex:"":hex:"32b649ab56162e55d4148a1292d6a225a988eb1308298273":hex:"b6889036":char*:"FAIL":hex:"":int:1
AES-192-CCM test vector NIST #11 PSA (P=24, N=7, A=0, T=16)
depends_on:3:0:1
9:exp:1:hex:"197afb02ffbd8f699dacae87094d524324576b99844f75e1":hex:"5a8aa485c316e9":hex:"":hex:"cba4b4aeb85f0492fd8d905c4a6d8233139833373ef188a8":hex:"c5a5ebecf7ac8607fe412189e83d9d20":char*:"":hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22":int:1
AES-192-CCM test vector NIST #12 PSA (P=24, N=7, A=0, T=16)
depends_on:3:0:1
9:exp:1:hex:"197afb02ffbd8f699dacae87094d524324576b99844f75e1":hex:"31f8fa25827d48":hex:"":hex:"ca62713728b5c9d652504b0ae8fd4fee5d297ee6a8d19cb6":hex:"e699f15f14d34dcaf9ba8ed4b877c97d":char*:"FAIL":hex:"":int:1
AES-192-CCM test vector NIST #13 PSA (P=24, N=13, A=0, T=4)
depends_on:3:0:1
9:exp:1:hex:"197afb02ffbd8f699dacae87094d524324576b99844f75e1":hex:"5a8aa485c316e9403aff859fbb":hex:"":hex:"042653c674ef2a90f7fb11d30848e530ae59478f1051633a":hex:"34fad277":char*:"":hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697":int:1
AES-192-CCM test vector NIST #14 PSA (P=24, N=13, A=0, T=4)
depends_on:3:0:1
9:exp:1:hex:"197afb02ffbd8f699dacae87094d524324576b99844f75e1":hex:"49004912fdd7269279b1f06a89":hex:"":hex:"1902d9769a7ba3d3268e1257395c8c2e5f98eef295dcbfa5":hex:"a35df775":char*:"FAIL":hex:"":int:1
AES-192-CCM test vector NIST #15 PSA (P=24, N=13, A=0, T=16)
depends_on:3:0:1
9:exp:1:hex:"90929a4b0ac65b350ad1591611fe48297e03956f6083e451":hex:"5a8aa485c316e9403aff859fbb":hex:"":hex:"a5b7d8cca2069908d1ed88e6a9fe2c9bede3131dad54671e":hex:"a7ade30a07d185692ab0ebdf4c78cf7a":char*:"":hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697":int:1
AES-192-CCM test vector NIST #16 PSA (P=24, N=13, A=0, T=16)
depends_on:3:0:1
9:exp:1:hex:"90929a4b0ac65b350ad1591611fe48297e03956f6083e451":hex:"49004912fdd7269279b1f06a89":hex:"":hex:"9a98617fb97a0dfe466be692272dcdaec1c5443a3b51312e":hex:"f042c86363cc05afb98c66e16be8a445":char*:"FAIL":hex:"":int:1
AES-192-CCM test vector NIST #17 PSA (P=0, N=7, A=32, T=4)
depends_on:3:0:1
9:exp:1:hex:"90929a4b0ac65b350ad1591611fe48297e03956f6083e451":hex:"5a8aa485c316e9":hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22ec22b1a268f88e2c":hex:"":hex:"1d089a5f":char*:"":hex:"":int:1
AES-192-CCM test vector NIST #18 PSA (P=0, N=7, A=32, T=4)
depends_on:3:0:1
9:exp:1:hex:"90929a4b0ac65b350ad1591611fe48297e03956f6083e451":hex:"a265480ca88d5f":hex:"a2248a882ecbf850daf91933a389e78e81623d233dfd47bf8321361a38f138fe":hex:"":hex:"2f46022a":char*:"FAIL":hex:"":int:1
AES-192-CCM test vector NIST #19 PSA (P=0, N=7, A=32, T=16)
depends_on:3:0:1
9:exp:1:hex:"6a798d7c5e1a72b43e20ad5c7b08567b12ab744b61c070e2":hex:"5a8aa485c316e9":hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22ec22b1a268f88e2c":hex:"":hex:"5280a2137fee3deefcfe9b63a1199fb3":char*:"":hex:"":int:1
AES-192-CCM test vector NIST #20 PSA (P=0, N=7, A=32, T=16)
depends_on:3:0:1
9:exp:1:hex:"6a798d7c5e1a72b43e20ad5c7b08567b12ab744b61c070e2":hex:"a265480ca88d5f":hex:"a2248a882ecbf850daf91933a389e78e81623d233dfd47bf8321361a38f138fe":hex:"":hex:"d40a7318c5f2d82f838c0beeefe0d598":char*:"FAIL":hex:"":int:1
AES-192-CCM test vector NIST #21 PSA (P=0, N=13, A=32, T=4)
depends_on:3:0:1
9:exp:1:hex:"6a798d7c5e1a72b43e20ad5c7b08567b12ab744b61c070e2":hex:"5a8aa485c316e9403aff859fbb":hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697a7ee6410184c7982":hex:"":hex:"5e0eaebd":char*:"":hex:"":int:1
AES-192-CCM test vector NIST #22 PSA (P=0, N=13, A=32, T=4)
depends_on:3:0:1
9:exp:1:hex:"6a798d7c5e1a72b43e20ad5c7b08567b12ab744b61c070e2":hex:"8739b4bea1a099fe547499cbc6":hex:"f6107696edb332b2ea059d8860fee26be42e5e12e1a4f79a8d0eafce1b2278a7":hex:"":hex:"71b7fc33":char*:"FAIL":hex:"":int:1
AES-192-CCM test vector NIST #23 PSA (P=0, N=13, A=32, T=16)
depends_on:3:0:1
9:exp:1:hex:"f9fdca4ac64fe7f014de0f43039c757194d544ce5d15eed4":hex:"5a8aa485c316e9403aff859fbb":hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697a7ee6410184c7982":hex:"":hex:"d07ccf9fdc3d33aa94cda3d230da707c":char*:"":hex:"":int:1
AES-192-CCM test vector NIST #24 PSA (P=0, N=13, A=32, T=16)
depends_on:3:0:1
9:exp:1:hex:"f9fdca4ac64fe7f014de0f43039c757194d544ce5d15eed4":hex:"8739b4bea1a099fe547499cbc6":hex:"f6107696edb332b2ea059d8860fee26be42e5e12e1a4f79a8d0eafce1b2278a7":hex:"":hex:"65fe32b649dc328c9f531584897e85b3":char*:"FAIL":hex:"":int:1
AES-192-CCM test vector NIST #25 PSA (P=24, N=7, A=32, T=4)
depends_on:3:0:1
9:exp:1:hex:"f9fdca4ac64fe7f014de0f43039c757194d544ce5d15eed4":hex:"5a8aa485c316e9":hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22ec22b1a268f88e2c":hex:"9f6ca4af9b159148c889a6584d1183ea26e2614874b05045":hex:"75dea8d1":char*:"":hex:"a265480ca88d5f536db0dc6abc40faf0d05be7a966977768":int:1
AES-192-CCM test vector NIST #26 PSA (P=24, N=7, A=32, T=4)
depends_on:3:0:1
9:exp:1:hex:"f9fdca4ac64fe7f014de0f43039c757194d544ce5d15eed4":hex:"fdd2d6f503c915":hex:"5b92394f21ddc3ad49d9b0881b829a5935cb3a4d23e292a62fb66b5e7ab7020e":hex:"84d8212e9cfc2121252baa3b065b1edcf50497b9594db1eb":hex:"d7965825":char*:"FAIL":hex:"":int:1
AES-192-CCM test vector NIST #27 PSA (P=24, N=7, A=32, T=16)
depends_on:3:0:1
9:exp:1:hex:"a7aa635ea51b0bb20a092bd5573e728ccd4b3e8cdd2ab33d":hex:"5a8aa485c316e9":hex:"3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22ec22b1a268f88e2c":hex:"6aab64c4787599d8f213446beadb16e08dba60e97f56dbd1":hex:"4d1d980d6fe0fb44b421992662b97975":char*:"":hex:"a265480ca88d5f536db0dc6abc40faf0d05be7a966977768":int:1
AES-192-CCM test vector NIST #28 PSA (P=24, N=7, A=32, T=16)
depends_on:3:0:1
9:exp:1:hex:"a7aa635ea51b0bb20a092bd5573e728ccd4b3e8cdd2ab33d":hex:"fdd2d6f503c915":hex:"5b92394f21ddc3ad49d9b0881b829a5935cb3a4d23e292a62fb66b5e7ab7020e":hex:"4980b2ee49b1aaf393175f5ab9bae95ec7904557dfa20660":hex:"3c51d36c826f01384100886198a7f6a3":char*:"FAIL":hex:"":int:1
AES-192-CCM test vector NIST #29 PSA (P=24, N=13, A=32, T=4)
depends_on:3:0:1
9:exp:1:hex:"a7aa635ea51b0bb20a092bd5573e728ccd4b3e8cdd2ab33d":hex:"5a8aa485c316e9403aff859fbb":hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697a7ee6410184c7982":hex:"16e543d0e20615ff0df15acd9927ddfe40668a54bb854ccc":hex:"c25e9fce":char*:"":hex:"8739b4bea1a099fe547499cbc6d1b13d849b8084c9b6acc5":int:1
AES-192-CCM test vector NIST #30 PSA (P=24, N=13, A=32, T=4)
depends_on:3:0:1
9:exp:1:hex:"a7aa635ea51b0bb20a092bd5573e728ccd4b3e8cdd2ab33d":hex:"0812757ad0cc4d17c4cfe7a642":hex:"ec6c44a7e94e51a3ca6dee229098391575ec7213c85267fbf7492fdbeee61b10":hex:"df35b109caf690656ae278bbd8f8bba687a2ce11b105dae9":hex:"8ecedb3e":char*:"FAIL":hex:"":int:1
AES-192-CCM test vector NIST #31 PSA (P=24, N=13, A=32, T=16)
depends_on:3:0:1
9:exp:1:hex:"26511fb51fcfa75cb4b44da75a6e5a0eb8d9c8f3b906f886":hex:"5a8aa485c316e9403aff859fbb":hex:"a16a2e741f1cd9717285b6d882c1fc53655e9773761ad697a7ee6410184c7982":hex:"c5b0b2ef17498c5570eb335df4588032958ba3d69bf6f317":hex:"8464a6f7fa2b76744e8e8d95691cecb8":char*:"":hex:"8739b4bea1a099fe547499cbc6d1b13d849b8084c9b6acc5":int:1
AES-192-CCM test vector NIST #32 PSA (P=24, N=13, A=32, T=16)
depends_on:3:0:1
9:exp:1:hex:"26511fb51fcfa75cb4b44da75a6e5a0eb8d9c8f3b906f886":hex:"0812757ad0cc4d17c4cfe7a642":hex:"ec6c44a7e94e51a3ca6dee229098391575ec7213c85267fbf7492fdbeee61b10":hex:"d1f0518929f4ae2f0543de2a7dfe4bb0110bb3057e524a1c":hex:"06bd6dc2e6bcc3436cffb969ae900388":char*:"FAIL":hex:"":int:1
AES-256-CCM test vector NIST #1 PSA (P=0, N=7, A=0, T=4)
depends_on:3:0:1
9:exp:2:hex:"eda32f751456e33195f1f499cf2dc7c97ea127b6d488f211ccc5126fbb24afa6":hex:"a544218dadd3c1":hex:"":hex:"":hex:"469c90bb":char*:"":hex:"":int:1
AES-256-CCM test vector NIST #2 PSA (P=0, N=7, A=0, T=4)
depends_on:3:0:1
9:exp:2:hex:"eda32f751456e33195f1f499cf2dc7c97ea127b6d488f211ccc5126fbb24afa6":hex:"d3d5424e20fbec":hex:"":hex:"":hex:"46a908ed":char*:"FAIL":hex:"":int:1
AES-256-CCM test vector NIST #3 PSA (P=0, N=7, A=0, T=16)
depends_on:3:0:1
9:exp:2:hex:"e1b8a927a95efe94656677b692662000278b441c79e879dd5c0ddc758bdc9ee8":hex:"a544218dadd3c1":hex:"":hex:"":hex:"8207eb14d33855a52acceed17dbcbf6e":char*:"":hex:"":int:1
AES-256-CCM test vector NIST #4 PSA (P=0, N=7, A=0, T=16)
depends_on:3:0:1
9:exp:2:hex:"e1b8a927a95efe94656677b692662000278b441c79e879dd5c0ddc758bdc9ee8":hex:"d3d5424e20fbec":hex:"":hex:"":hex:"60f8e127cb4d30db6df0622158cd931d":char*:"FAIL":hex:"":int:1
AES-256-CCM test vector NIST #5 PSA (P=0, N=13, A=0, T=4)
depends_on:3:0:1
9:exp:2:hex:"e1b8a927a95efe94656677b692662000278b441c79e879dd5c0ddc758bdc9ee8":hex:"a544218dadd3c10583db49cf39":hex:"":hex:"":hex:"8a19a133":char*:"":hex:"":int:1
AES-256-CCM test vector NIST #6 PSA (P=0, N=13, A=0, T=4)
depends_on:3:0:1
9:exp:2:hex:"e1b8a927a95efe94656677b692662000278b441c79e879dd5c0ddc758bdc9ee8":hex:"3c0e2815d37d844f7ac240ba9d":hex:"":hex:"":hex:"2e317f1b":char*:"FAIL":hex:"":int:1
AES-256-CCM test vector NIST #7 PSA (P=0, N=13, A=0, T=16)
depends_on:3:0:1
9:exp:2:hex:"af063639e66c284083c5cf72b70d8bc277f5978e80d9322d99f2fdc718cda569":hex:"a544218dadd3c10583db49cf39":hex:"":hex:"":hex:"97e1a8dd4259ccd2e431e057b0397fcf":char*:"":hex:"":int:1
AES-256-CCM test vector NIST #8 PSA (P=0, N=13, A=0, T=16)
depends_on:3:0:1
9:exp:2:hex:"af063639e66c284083c5cf72b70d8bc277f5978e80d9322d99f2fdc718cda569":hex:"3c0e2815d37d844f7ac240ba9d":hex:"":hex:"":hex:"5a9596c511ea6a8671adefc4f2157d8b":char*:"FAIL":hex:"":int:1
AES-256-CCM test vector NIST #9 PSA (P=24, N=7, A=0, T=4)
depends_on:3:0:1
9:exp:2:hex:"af063639e66c284083c5cf72b70d8bc277f5978e80d9322d99f2fdc718cda569":hex:"a544218dadd3c1":hex:"":hex:"64a1341679972dc5869fcf69b19d5c5ea50aa0b5e985f5b7":hex:"22aa8d59":char*:"":hex:"d3d5424e20fbec43ae495353ed830271515ab104f8860c98":int:1
AES-256-CCM test vector NIST #10 PSA (P=24, N=7, A=0, T=4)
depends_on:3:0:1
9:exp:2:hex:"af063639e66c284083c5cf72b70d8bc277f5978e80d9322d99f2fdc718cda569":hex:"bfcda8b5a2d0d2":hex:"":hex:"c5b7f802bffc498c1626e3774f1d9f94045dfd8e1a10a202":hex:"77d00a75":char*:"FAIL":hex:"":int:1
AES-256-CCM test vector NIST #11 PSA (P=24, N=7, A=0, T=16)
depends_on:3:0:1
9:exp:2:hex:"f7079dfa3b5c7b056347d7e437bcded683abd6e2c9e069d333284082cbb5d453":hex:"a544218dadd3c1":hex:"":hex:"bc51c3925a960e7732533e4ef3a4f69ee6826de952bcb0fd":hex:"374f3bb6db8377ebfc79674858c4f305":char*:"":hex:"d3d5424e20fbec43ae495353ed830271515ab104f8860c98":int:1
AES-256-CCM test vector NIST #12 PSA (P=24, N=7, A=0, T=16)
depends_on:3:0:1
9:exp:2:hex:"f7079dfa3b5c7b056347d7e437bcded683abd6e2c9e069d333284082cbb5d453":hex:"bfcda8b5a2d0d2":hex:"":hex:"afa1fa8e8a70e26b02161150556d604101fdf423f332c336":hex:"3275f2a4907d51b734fe7238cebbd48f":char*:"FAIL":hex:"":int:1
AES-256-CCM test vector NIST #13 PSA (P=24, N=13, A=0, T=4)
depends_on:3:0:1
9:exp:2:hex:"f7079dfa3b5c7b056347d7e437bcded683abd6e2c9e069d333284082cbb5d453":hex:"a544218dadd3c10583db49cf39":hex:"":hex:"63e00d30e4b08fd2a1cc8d70fab327b2368e77a93be4f412":hex:"3d14fb3f":char*:"":hex:"3c0e2815d37d844f7ac240ba9d6e3a0b2a86f706e885959e":int:1
AES-256-CCM test vector NIST #14 PSA (P=24, N=13, A=0, T=4)
depends_on:3:0:1
9:exp:2:hex:"f7079dfa3b5c7b056347d7e437bcded683abd6e2c9e069d333284082cbb5d453":hex:"894dcaa61008eb8fb052c60d41":hex:"":hex:"bb5425b3869b76856ec58e39886fb6f6f2ac13fe44cb132d":hex:"8d0c0099":char*:"FAIL":hex:"":int:1
AES-256-CCM test vector NIST #15 PSA (P=24, N=13, A=0, T=16)
depends_on:3:0:1
9:exp:2:hex:"1b0e8df63c57f05d9ac457575ea764524b8610ae5164e6215f426f5a7ae6ede4":hex:"a544218dadd3c10583db49cf39":hex:"":hex:"f0050ad16392021a3f40207bed3521fb1e9f808f49830c42":hex:"3a578d179902f912f9ea1afbce1120b3":char*:"":hex:"3c0e2815d37d844f7ac240ba9d6e3a0b2a86f706e885959e":int:1
AES-256-CCM test vector NIST #16 PSA (P=24, N=13, A=0, T=16)
depends_on:3:0:1
9:exp:2:hex:"1b0e8df63c57f05d9ac457575ea764524b8610ae5164e6215f426f5a7ae6ede4":hex:"894dcaa61008eb8fb052c60d41":hex:"":hex:"c408190d0fbf5034f83b24a8ed9657331a7ce141de4fae76":hex:"9084607b83bd06e6442eac8dacf583cc":char*:"FAIL":hex:"":int:1
AES-256-CCM test vector NIST #17 PSA (P=0, N=7, A=32, T=4)
depends_on:3:0:1
9:exp:2:hex:"1b0e8df63c57f05d9ac457575ea764524b8610ae5164e6215f426f5a7ae6ede4":hex:"a544218dadd3c1":hex:"d3d5424e20fbec43ae495353ed830271515ab104f8860c988d15b6d36c038eab":hex:"":hex:"92d00fbe":char*:"":hex:"":int:1
AES-256-CCM test vector NIST #18 PSA (P=0, N=7, A=32, T=4)
depends_on:3:0:1
9:exp:2:hex:"1b0e8df63c57f05d9ac457575ea764524b8610ae5164e6215f426f5a7ae6ede4":hex:"78c46e3249ca28":hex:"232e957c65ffa11988e830d4617d500f1c4a35c1221f396c41ab214f074ca2dc":hex:"":hex:"9143e5c4":char*:"FAIL":hex:"":int:1
AES-256-CCM test vector NIST #19 PSA (P=0, N=7, A=32, T=16)
depends_on:3:0:1
9:exp:2:hex:"a4bc10b1a62c96d459fbaf3a5aa3face7313bb9e1253e696f96a7a8e36801088":hex:"a544218dadd3c1":hex:"d3d5424e20fbec43ae495353ed830271515ab104f8860c988d15b6d36c038eab":hex:"":hex:"93af11a08379eb37a16aa2837f09d69d":char*:"":hex:"":int:1
AES-256-CCM test vector NIST #20 PSA (P=0, N=7, A=32, T=16)
depends_on:3:0:1
9:exp:2:hex:"a4bc10b1a62c96d459fbaf3a5aa3face7313bb9e1253e696f96a7a8e36801088":hex:"78c46e3249ca28":hex:"232e957c65ffa11988e830d4617d500f1c4a35c1221f396c41ab214f074ca2dc":hex:"":hex:"d19b0c14ec686a7961ca7c386d125a65":char*:"FAIL":hex:"":int:1
AES-256-CCM test vector NIST #21 PSA (P=0, N=13, A=32, T=4)
depends_on:3:0:1
9:exp:2:hex:"a4bc10b1a62c96d459fbaf3a5aa3face7313bb9e1253e696f96a7a8e36801088":hex:"a544218dadd3c10583db49cf39":hex:"3c0e2815d37d844f7ac240ba9d6e3a0b2a86f706e885959e09a1005e024f6907":hex:"":hex:"866d4227":char*:"":hex:"":int:1
AES-256-CCM test vector NIST #22 PSA (P=0, N=13, A=32, T=4)
depends_on:3:0:1
9:exp:2:hex:"a4bc10b1a62c96d459fbaf3a5aa3face7313bb9e1253e696f96a7a8e36801088":hex:"e8de970f6ee8e80ede933581b5":hex:"89f8b068d34f56bc49d839d8e47b347e6dae737b903b278632447e6c0485d26a":hex:"":hex:"94cb1127":char*:"FAIL":hex:"":int:1
AES-256-CCM test vector NIST #23 PSA (P=0, N=13, A=32, T=16)
depends_on:3:0:1
9:exp:2:hex:"8c5cf3457ff22228c39c051c4e05ed4093657eb303f859a9d4b0f8be0127d88a":hex:"a544218dadd3c10583db49cf39":hex:"3c0e2815d37d844f7ac240ba9d6e3a0b2a86f706e885959e09a1005e024f6907":hex:"":hex:"867b0d87cf6e0f718200a97b4f6d5ad5":char*:"":hex:"":int:1
AES-256-CCM test vector NIST #24 PSA (P=0, N=13, A=32, T=16)
depends_on:3:0:1
9:exp:2:hex:"8c5cf3457ff22228c39c051c4e05ed4093657eb303f859a9d4b0f8be0127d88a":hex:"e8de970f6ee8e80ede933581b5":hex:"89f8b068d34f56bc49d839d8e47b347e6dae737b903b278632447e6c0485d26a":hex:"":hex:"677a040d46ee3f2b7838273bdad14f16":char*:"FAIL":hex:"":int:1
AES-256-CCM test vector NIST #25 PSA (P=24, N=7, A=32, T=4)
depends_on:3:0:1
9:exp:2:hex:"8c5cf3457ff22228c39c051c4e05ed4093657eb303f859a9d4b0f8be0127d88a":hex:"a544218dadd3c1":hex:"d3d5424e20fbec43ae495353ed830271515ab104f8860c988d15b6d36c038eab":hex:"c2fe12658139f5d0dd22cadf2e901695b579302a72fc5608":hex:"3ebc7720":char*:"":hex:"78c46e3249ca28e1ef0531d80fd37c124d9aecb7be6668e3":int:1
AES-256-CCM test vector NIST #26 PSA (P=24, N=7, A=32, T=4)
depends_on:3:0:1
9:exp:2:hex:"8c5cf3457ff22228c39c051c4e05ed4093657eb303f859a9d4b0f8be0127d88a":hex:"6ba004fd176791":hex:"5a053b2a1bb87e85d56527bfcdcd3ecafb991bb10e4c862bb0751c700a29f54b":hex:"94748ba81229e53c38583a8564b23ebbafc6f6efdf4c2a81":hex:"c44db2c9":char*:"FAIL":hex:"":int:1
AES-256-CCM test vector NIST #27 PSA (P=24, N=7, A=32, T=16)
depends_on:3:0:1
9:exp:2:hex:"705334e30f53dd2f92d190d2c1437c8772f940c55aa35e562214ed45bd458ffe":hex:"a544218dadd3c1":hex:"d3d5424e20fbec43ae495353ed830271515ab104f8860c988d15b6d36c038eab":hex:"3341168eb8c48468c414347fb08f71d2086f7c2d1bd581ce":hex:"1ac68bd42f5ec7fa7e068cc0ecd79c2a":char*:"":hex:"78c46e3249ca28e1ef0531d80fd37c124d9aecb7be6668e3":int:1
AES-256-CCM test vector NIST #28 PSA (P=24, N=7, A=32, T=16)
depends_on:3:0:1
9:exp:2:hex:"705334e30f53dd2f92d190d2c1437c8772f940c55aa35e562214ed45bd458ffe":hex:"6ba004fd176791":hex:"5a053b2a1bb87e85d56527bfcdcd3ecafb991bb10e4c862bb0751c700a29f54b":hex:"d543acda712b898cbb27b8f598b2e4438ce587a836e27851":hex:"47c3338a2400809e739b63ba8227d2f9":char*:"FAIL":hex:"":int:1
AES-256-CCM test vector NIST #29 PSA (P=24, N=13, A=32, T=4)
depends_on:3:0:1
9:exp:2:hex:"705334e30f53dd2f92d190d2c1437c8772f940c55aa35e562214ed45bd458ffe":hex:"a544218dadd3c10583db49cf39":hex:"3c0e2815d37d844f7ac240ba9d6e3a0b2a86f706e885959e09a1005e024f6907":hex:"c0ea400b599561e7905b99262b4565d5c3dc49fad84d7c69":hex:"ef891339":char*:"":hex:"e8de970f6ee8e80ede933581b5bcf4d837e2b72baa8b00c3":int:1
AES-256-CCM test vector NIST #30 PSA (P=24, N=13, A=32, T=4)
depends_on:3:0:1
9:exp:2:hex:"705334e30f53dd2f92d190d2c1437c8772f940c55aa35e562214ed45bd458ffe":hex:"8fa501c5dd9ac9b868144c9fa5":hex:"5bb40e3bb72b4509324a7edc852f72535f1f6283156e63f6959ffaf39dcde800":hex:"60871e03ea0eb968536c99f926ea24ef43d41272ad9fb7f6":hex:"3d488623":char*:"FAIL":hex:"":int:1
AES-256-CCM test vector NIST #31 PSA (P=24, N=13, A=32, T=16)
depends_on:3:0:1
9:exp:2:hex:"314a202f836f9f257e22d8c11757832ae5131d357a72df88f3eff0ffcee0da4e":hex:"a544218dadd3c10583db49cf39":hex:"3c0e2815d37d844f7ac240ba9d6e3a0b2a86f706e885959e09a1005e024f6907":hex:"8d34cdca37ce77be68f65baf3382e31efa693e63f914a781":hex:"367f30f2eaad8c063ca50795acd90203":char*:"":hex:"e8de970f6ee8e80ede933581b5bcf4d837e2b72baa8b00c3":int:1
AES-256-CCM test vector NIST #32 PSA (P=24, N=13, A=32, T=16)
depends_on:3:0:1
9:exp:2:hex:"314a202f836f9f257e22d8c11757832ae5131d357a72df88f3eff0ffcee0da4e":hex:"8fa501c5dd9ac9b868144c9fa5":hex:"5bb40e3bb72b4509324a7edc852f72535f1f6283156e63f6959ffaf39dcde800":hex:"516c0095cc3d85fd55e48da17c592e0c7014b9daafb82bdc":hex:"4b41096dfdbe9cc1ab610f8f3e038d16":char*:"FAIL":hex:"":int:1
| 64,425 | 865 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_ssl.datax | Test calback buffer sanity
0
Callback buffer test: Exercise simple write/read
1:int:50:int:25:int:25:int:25:int:25:int:0:int:0:int:0:int:0
Callback buffer test: Filling up the buffer
1:int:50:int:50:int:50:int:50:int:50:int:0:int:0:int:0:int:0
Callback buffer test: Filling up the buffer in two steps
1:int:50:int:20:int:20:int:0:int:0:int:30:int:30:int:50:int:50
Callback buffer test: Reading out the buffer in two steps
1:int:50:int:50:int:50:int:30:int:30:int:0:int:0:int:20:int:20
Callback buffer test: Data wraps in buffer
1:int:50:int:45:int:45:int:10:int:10:int:10:int:10:int:45:int:45
Callback buffer test: Data starts at the end
1:int:50:int:50:int:50:int:49:int:49:int:10:int:10:int:11:int:11
Callback buffer test: Can write less than requested
1:int:50:int:75:int:50:int:30:int:30:int:25:int:25:int:45:int:45
Callback buffer test: Can read less than requested
1:int:50:int:25:int:25:int:30:int:25:int:5:int:5:int:5:int:5
Callback buffer test: Writing to full buffer
1:int:50:int:50:int:50:int:0:int:0:int:10:int:0:int:60:int:50
Callback buffer test: Reading from empty buffer
1:int:50:int:0:int:0:int:10:int:0:int:0:int:0:int:0:int:0
Test mock socket sanity
2
Test mock blocking TCP connection
3:int:1
Test mock non-blocking TCP connection
3:int:0
Test mock blocking TCP connection (interleaving)
4:int:1
Test mock non-blocking TCP connection (interleaving)
4:int:0
Message queue - sanity
5
Message queue - basic test
6
Message queue - overflow/underflow
7
Message queue - interleaved
8
Message queue - insufficient buffer
9
Message transport mock - uninitialized structures
10
Message transport mock - basic test
11
Message transport mock - queue overflow/underflow
12
Message transport mock - socket overflow
13
Message transport mock - truncated message
14
Message transport mock - socket read error
15
Message transport mock - one-way interleaved sends/reads
16
Message transport mock - two-way interleaved sends/reads
17
Test mbedtls_endpoint sanity for the client
33:exp:0
Test mbedtls_endpoint sanity for the server
33:exp:1
Test moving clients handshake to state: HELLO_REQUEST
34:exp:0:exp:2:int:1
Test moving clients handshake to state: CLIENT_HELLO
34:exp:0:exp:3:int:1
Test moving clients handshake to state: SERVER_HELLO
34:exp:0:exp:4:int:1
Test moving clients handshake to state: SERVER_CERTIFICATE
34:exp:0:exp:5:int:1
Test moving clients handshake to state: SERVER_KEY_EXCHANGE
34:exp:0:exp:6:int:1
Test moving clients handshake to state: CERTIFICATE_REQUEST
34:exp:0:exp:7:int:1
Test moving clients handshake to state: SERVER_HELLO_DONE
34:exp:0:exp:8:int:1
Test moving clients handshake to state: CLIENT_CERTIFICATE
34:exp:0:exp:9:int:1
Test moving clients handshake to state: CLIENT_KEY_EXCHANGE
34:exp:0:exp:10:int:1
Test moving clients handshake to state: CERTIFICATE_VERIFY
34:exp:0:exp:11:int:1
Test moving clients handshake to state: CLIENT_CHANGE_CIPHER_SPEC
34:exp:0:exp:12:int:1
Test moving clients handshake to state: CLIENT_FINISHED
34:exp:0:exp:13:int:1
Test moving clients handshake to state: SERVER_CHANGE_CIPHER_SPEC
34:exp:0:exp:14:int:1
Test moving clients handshake to state: SERVER_FINISHED
34:exp:0:exp:15:int:1
Test moving clients handshake to state: FLUSH_BUFFERS
34:exp:0:exp:16:int:1
Test moving clients handshake to state: HANDSHAKE_WRAPUP
34:exp:0:exp:17:int:1
Test moving clients handshake to state: HANDSHAKE_OVER
34:exp:0:exp:18:int:1
Test moving servers handshake to state: HELLO_REQUEST
34:exp:1:exp:2:int:1
Test moving servers handshake to state: CLIENT_HELLO
34:exp:1:exp:3:int:1
Test moving servers handshake to state: SERVER_HELLO
34:exp:1:exp:4:int:1
Test moving servers handshake to state: SERVER_CERTIFICATE
34:exp:1:exp:5:int:1
Test moving servers handshake to state: SERVER_KEY_EXCHANGE
34:exp:1:exp:6:int:1
Test moving servers handshake to state: CERTIFICATE_REQUEST
34:exp:1:exp:7:int:1
Test moving servers handshake to state: SERVER_HELLO_DONE
34:exp:1:exp:8:int:1
Test moving servers handshake to state: CLIENT_CERTIFICATE
34:exp:1:exp:9:int:1
Test moving servers handshake to state: CLIENT_KEY_EXCHANGE
34:exp:1:exp:10:int:1
Test moving servers handshake to state: CERTIFICATE_VERIFY
34:exp:1:exp:11:int:1
Test moving servers handshake to state: CLIENT_CHANGE_CIPHER_SPEC
34:exp:1:exp:12:int:1
Test moving servers handshake to state: CLIENT_FINISHED
34:exp:1:exp:13:int:1
Test moving servers handshake to state: SERVER_CHANGE_CIPHER_SPEC
34:exp:1:exp:14:int:1
Test moving servers handshake to state: SERVER_FINISHED
34:exp:1:exp:15:int:1
Test moving servers handshake to state: FLUSH_BUFFERS
34:exp:1:exp:16:int:1
Test moving servers handshake to state: HANDSHAKE_WRAPUP
34:exp:1:exp:17:int:1
Test moving servers handshake to state: HANDSHAKE_OVER
34:exp:1:exp:18:int:1
Negative test moving clients ssl to state: VERIFY_REQUEST_SENT
34:exp:0:exp:19:int:0
Negative test moving servers ssl to state: NEW_SESSION_TICKET
34:exp:1:exp:20:int:0
Handshake, SSL3
depends_on:0:1:2
35:int:0:exp:21:exp:21:exp:21:exp:21:exp:21
Handshake, tls1
depends_on:3:4
35:int:0:exp:22:exp:22:exp:22:exp:22:exp:22
Handshake, tls1_1
depends_on:5:4
35:int:0:exp:23:exp:23:exp:23:exp:23:exp:23
Handshake, tls1_2
depends_on:6
35:int:0:exp:24:exp:24:exp:24:exp:24:exp:24
Handshake, ECDHE-RSA-AES256-GCM-SHA384
depends_on:7:8:9:10:1:2:11
37:char*:"ECDHE-RSA-AES256-GCM-SHA384":exp:25:int:0
Handshake, RSA-AES128-CCM
depends_on:12:9:1:2
37:char*:"RSA-AES128-CCM":exp:25:int:0
Handshake, DHE-RSA-AES256-CBC-SHA256
depends_on:4:9:13:1:2:40
37:char*:"DHE-RSA-AES256-CBC-SHA256":exp:25:int:0
Handshake, ECDHE-ECDSA-AES256-CCM
depends_on:9:12:14:15:2
37:char*:"ECDHE-ECDSA-AES256-CCM":exp:26:int:0
Handshake, ECDH-ECDSA-CAMELLIA-256-CBC-SHA384
depends_on:7:8:4:14:15:2:16
37:char*:"ECDH-ECDSA-CAMELLIA-256-CBC-SHA384":exp:26:int:0
Handshake, PSK-AES128-CBC-SHA
depends_on:9:4:1:2:41
36:char*:"PSK-AES128-CBC-SHA":exp:25:hex:"abc123":int:0
DTLS Handshake, tls1_1
depends_on:5:4:17
35:int:1:exp:23:exp:23:exp:23:exp:23:exp:23
DTLS Handshake, tls1_2
depends_on:6:17
35:int:1:exp:24:exp:24:exp:24:exp:24:exp:24
DTLS Handshake, ECDHE-RSA-AES256-GCM-SHA384
depends_on:7:8:9:10:1:2:11:17
37:char*:"ECDHE-RSA-AES256-GCM-SHA384":exp:25:int:1
DTLS Handshake, RSA-AES128-CCM
depends_on:12:9:1:2:17
37:char*:"RSA-AES128-CCM":exp:25:int:1
DTLS Handshake, DHE-RSA-AES256-CBC-SHA256
depends_on:4:9:13:1:2:17:40
37:char*:"DHE-RSA-AES256-CBC-SHA256":exp:25:int:1
DTLS Handshake, ECDHE-ECDSA-AES256-CCM
depends_on:9:12:14:15:2:17
37:char*:"ECDHE-ECDSA-AES256-CCM":exp:26:int:1
DTLS Handshake, ECDH-ECDSA-CAMELLIA-256-CBC-SHA384
depends_on:7:8:4:14:15:2:16:17
37:char*:"ECDH-ECDSA-CAMELLIA-256-CBC-SHA384":exp:26:int:1
DTLS Handshake, PSK-AES128-CBC-SHA
depends_on:9:4:1:2:17:41
36:char*:"PSK-AES128-CBC-SHA":exp:25:hex:"abc123":int:1
DTLS Handshake with serialization, tls1_2
depends_on:1:2:17
41
DTLS Handshake fragmentation, MFL=512
depends_on:1:2:17
42:exp:27:int:1:int:1
DTLS Handshake fragmentation, MFL=1024
depends_on:1:2:17
42:exp:28:int:0:int:1
Handshake min/max version check, all -> 1.2
depends_on:6
35:int:0:exp:29:exp:29:exp:29:exp:29:exp:24
Handshake min/max version check, cli max 1.1 -> 1.1
depends_on:5:4
35:int:0:exp:29:exp:22:exp:29:exp:29:exp:22
Handshake min/max version check, srv max 1.1 -> 1.1
depends_on:5:4
35:int:0:exp:29:exp:29:exp:29:exp:22:exp:22
Handshake min/max version check, cli+srv max 1.1 -> 1.1
depends_on:5:4
35:int:0:exp:29:exp:22:exp:29:exp:22:exp:22
Handshake min/max version check, cli max 1.1, srv min 1.1 -> 1.1
depends_on:5:4
35:int:0:exp:29:exp:22:exp:22:exp:29:exp:22
Handshake min/max version check, cli min 1.1, srv max 1.1 -> 1.1
depends_on:5:4
35:int:0:exp:22:exp:29:exp:29:exp:22:exp:22
Handshake min/max version check, cli min 1.2, srv max 1.1 -> fail
depends_on:5:4:6
35:int:0:exp:23:exp:29:exp:29:exp:22:exp:29
Handshake min/max version check, srv min 1.2, cli max 1.1 -> fail
depends_on:5:4:6
35:int:0:exp:29:exp:22:exp:23:exp:29:exp:29
Sending app data via TLS, MFL=512 without fragmentation
depends_on:18
39:exp:27:int:400:int:512:int:1:int:1
Sending app data via TLS, MFL=512 with fragmentation
depends_on:18
39:exp:27:int:513:int:1536:int:2:int:3
Sending app data via TLS, MFL=1024 without fragmentation
depends_on:18
39:exp:28:int:1000:int:1024:int:1:int:1
Sending app data via TLS, MFL=1024 with fragmentation
depends_on:18
39:exp:28:int:1025:int:5120:int:2:int:5
Sending app data via TLS, MFL=2048 without fragmentation
depends_on:18
39:exp:30:int:2000:int:2048:int:1:int:1
Sending app data via TLS, MFL=2048 with fragmentation
depends_on:18
39:exp:30:int:2049:int:8192:int:2:int:4
Sending app data via TLS, MFL=4096 without fragmentation
depends_on:18
39:exp:31:int:4000:int:4096:int:1:int:1
Sending app data via TLS, MFL=4096 with fragmentation
depends_on:18
39:exp:31:int:4097:int:12288:int:2:int:3
Sending app data via TLS without MFL and without fragmentation
39:exp:32:int:16001:int:16384:int:1:int:1
Sending app data via TLS without MFL and with fragmentation
39:exp:32:int:16385:int:100000:int:2:int:7
Sending app data via DTLS, MFL=512 without fragmentation
depends_on:18
40:exp:27:int:400:int:512:int:1:int:1
Sending app data via DTLS, MFL=512 with fragmentation
depends_on:18
40:exp:27:int:513:int:1536:int:0:int:0
Sending app data via DTLS, MFL=1024 without fragmentation
depends_on:18
40:exp:28:int:1000:int:1024:int:1:int:1
Sending app data via DTLS, MFL=1024 with fragmentation
depends_on:18
40:exp:28:int:1025:int:5120:int:0:int:0
Sending app data via DTLS, MFL=2048 without fragmentation
depends_on:18
40:exp:30:int:2000:int:2048:int:1:int:1
Sending app data via DTLS, MFL=2048 with fragmentation
depends_on:18
40:exp:30:int:2049:int:8192:int:0:int:0
Sending app data via DTLS, MFL=4096 without fragmentation
depends_on:18
40:exp:31:int:4000:int:4096:int:1:int:1
Sending app data via DTLS, MFL=4096 with fragmentation
depends_on:18
40:exp:31:int:4097:int:12288:int:0:int:0
Sending app data via DTLS, without MFL and without fragmentation
40:exp:32:int:16001:int:16384:int:1:int:1
Sending app data via DTLS, without MFL and with fragmentation
40:exp:32:int:16385:int:100000:int:0:int:0
DTLS renegotiation: no legacy renegotiation
43:exp:33
DTLS renegotiation: legacy renegotiation
43:exp:34
DTLS renegotiation: legacy break handshake
43:exp:35
DTLS serialization with MFL=512
45:exp:27
DTLS serialization with MFL=1024
45:exp:28
DTLS serialization with MFL=2048
45:exp:30
DTLS serialization with MFL=4096
45:exp:31
DTLS no legacy renegotiation with MFL=512
46:exp:27:exp:33:char*:""
DTLS no legacy renegotiation with MFL=1024
46:exp:28:exp:33:char*:""
DTLS no legacy renegotiation with MFL=2048
46:exp:30:exp:33:char*:""
DTLS no legacy renegotiation with MFL=4096
46:exp:31:exp:33:char*:""
DTLS legacy allow renegotiation with MFL=512
46:exp:27:exp:34:char*:""
DTLS legacy allow renegotiation with MFL=1024
46:exp:28:exp:34:char*:""
DTLS legacy allow renegotiation with MFL=2048
46:exp:30:exp:34:char*:""
DTLS legacy allow renegotiation with MFL=4096
46:exp:31:exp:34:char*:""
DTLS legacy break handshake renegotiation with MFL=512
46:exp:27:exp:35:char*:""
DTLS legacy break handshake renegotiation with MFL=1024
46:exp:28:exp:35:char*:""
DTLS legacy break handshake renegotiation with MFL=2048
46:exp:30:exp:35:char*:""
DTLS legacy break handshake renegotiation with MFL=4096
46:exp:31:exp:35:char*:""
DTLS no legacy renegotiation with MFL=512, ECDHE-RSA-AES256-GCM-SHA384
depends_on:7:8:9:10:11
46:exp:27:exp:33:char*:"ECDHE-RSA-AES256-GCM-SHA384"
DTLS no legacy renegotiation with MFL=1024, ECDHE-RSA-AES256-GCM-SHA384
depends_on:7:8:9:10:11
46:exp:28:exp:33:char*:"ECDHE-RSA-AES256-GCM-SHA384"
DTLS no legacy renegotiation with MFL=2048, ECDHE-RSA-AES256-GCM-SHA384
depends_on:7:8:9:10:11
46:exp:30:exp:33:char*:"ECDHE-RSA-AES256-GCM-SHA384"
DTLS no legacy renegotiation with MFL=4096, ECDHE-RSA-AES256-GCM-SHA384
depends_on:7:8:9:10:11
46:exp:31:exp:33:char*:"ECDHE-RSA-AES256-GCM-SHA384"
DTLS legacy allow renegotiation with MFL=512, ECDHE-RSA-AES256-GCM-SHA384
depends_on:7:8:9:10:11
46:exp:27:exp:34:char*:"ECDHE-RSA-AES256-GCM-SHA384"
DTLS legacy allow renegotiation with MFL=1024, ECDHE-RSA-AES256-GCM-SHA384
depends_on:7:8:9:10:11
46:exp:28:exp:34:char*:"ECDHE-RSA-AES256-GCM-SHA384"
DTLS legacy allow renegotiation with MFL=2048, ECDHE-RSA-AES256-GCM-SHA384
depends_on:7:8:9:10:11
46:exp:30:exp:34:char*:"ECDHE-RSA-AES256-GCM-SHA384"
DTLS legacy allow renegotiation with MFL=4096, ECDHE-RSA-AES256-GCM-SHA384
depends_on:7:8:9:10:11
46:exp:31:exp:34:char*:"ECDHE-RSA-AES256-GCM-SHA384"
DTLS legacy break handshake renegotiation with MFL=512, ECDHE-RSA-AES256-GCM-SHA384
depends_on:7:8:9:10:11
46:exp:27:exp:35:char*:"ECDHE-RSA-AES256-GCM-SHA384"
DTLS legacy break handshake renegotiation with MFL=1024, ECDHE-RSA-AES256-GCM-SHA384
depends_on:7:8:9:10:11
46:exp:28:exp:35:char*:"ECDHE-RSA-AES256-GCM-SHA384"
DTLS legacy break handshake renegotiation with MFL=2048, ECDHE-RSA-AES256-GCM-SHA384
depends_on:7:8:9:10:11
46:exp:30:exp:35:char*:"ECDHE-RSA-AES256-GCM-SHA384"
DTLS legacy break handshake renegotiation with MFL=4096, ECDHE-RSA-AES256-GCM-SHA384
depends_on:7:8:9:10:11
46:exp:31:exp:35:char*:"ECDHE-RSA-AES256-GCM-SHA384"
DTLS no legacy renegotiation with MFL=512, RSA-AES128-CCM
depends_on:12:9
46:exp:27:exp:33:char*:"RSA-AES128-CCM"
DTLS no legacy renegotiation with MFL=1024, RSA-AES128-CCM
depends_on:12:9
46:exp:28:exp:33:char*:"RSA-AES128-CCM"
DTLS no legacy renegotiation with MFL=2048, RSA-AES128-CCM
depends_on:12:9
46:exp:30:exp:33:char*:"RSA-AES128-CCM"
DTLS no legacy renegotiation with MFL=4096, RSA-AES128-CCM
depends_on:12:9
46:exp:31:exp:33:char*:"RSA-AES128-CCM"
DTLS legacy allow renegotiation with MFL=512, RSA-AES128-CCM
depends_on:12:9
46:exp:27:exp:34:char*:"RSA-AES128-CCM"
DTLS legacy allow renegotiation with MFL=1024, RSA-AES128-CCM
depends_on:12:9
46:exp:28:exp:34:char*:"RSA-AES128-CCM"
DTLS legacy allow renegotiation with MFL=2048, RSA-AES128-CCM
depends_on:12:9
46:exp:30:exp:34:char*:"RSA-AES128-CCM"
DTLS legacy allow renegotiation with MFL=4096, RSA-AES128-CCM
depends_on:12:9
46:exp:31:exp:34:char*:"RSA-AES128-CCM"
DTLS legacy break handshake renegotiation with MFL=512, RSA-AES128-CCM
depends_on:12:9
46:exp:27:exp:35:char*:"RSA-AES128-CCM"
DTLS legacy break handshake renegotiation with MFL=1024, RSA-AES128-CCM
depends_on:12:9
46:exp:28:exp:35:char*:"RSA-AES128-CCM"
DTLS legacy break handshake renegotiation with MFL=2048, RSA-AES128-CCM
depends_on:12:9
46:exp:30:exp:35:char*:"RSA-AES128-CCM"
DTLS legacy break handshake renegotiation with MFL=4096, RSA-AES128-CCM
depends_on:12:9
46:exp:31:exp:35:char*:"RSA-AES128-CCM"
DTLS no legacy renegotiation with MFL=512, DHE-RSA-AES256-CBC-SHA256
depends_on:4:9:13
46:exp:27:exp:33:char*:"DHE-RSA-AES256-CBC-SHA256"
DTLS no legacy renegotiation with MFL=1024, DHE-RSA-AES256-CBC-SHA256
depends_on:4:9:13
46:exp:28:exp:33:char*:"DHE-RSA-AES256-CBC-SHA256"
DTLS no legacy renegotiation with MFL=2048, DHE-RSA-AES256-CBC-SHA256
depends_on:4:9:13
46:exp:30:exp:33:char*:"DHE-RSA-AES256-CBC-SHA256"
DTLS no legacy renegotiation with MFL=4096, DHE-RSA-AES256-CBC-SHA256
depends_on:4:9:13
46:exp:31:exp:33:char*:"DHE-RSA-AES256-CBC-SHA256"
DTLS legacy allow renegotiation with MFL=512, DHE-RSA-AES256-CBC-SHA256
depends_on:4:9:13
46:exp:27:exp:34:char*:"DHE-RSA-AES256-CBC-SHA256"
DTLS legacy allow renegotiation with MFL=1024, DHE-RSA-AES256-CBC-SHA256
depends_on:4:9:13
46:exp:28:exp:34:char*:"DHE-RSA-AES256-CBC-SHA256"
DTLS legacy allow renegotiation with MFL=2048, DHE-RSA-AES256-CBC-SHA256
depends_on:4:9:13
46:exp:30:exp:34:char*:"DHE-RSA-AES256-CBC-SHA256"
DTLS legacy allow renegotiation with MFL=4096, DHE-RSA-AES256-CBC-SHA256
depends_on:4:9:13
46:exp:31:exp:34:char*:"DHE-RSA-AES256-CBC-SHA256"
DTLS legacy break handshake renegotiation with MFL=512, DHE-RSA-AES256-CBC-SHA256
depends_on:4:9:13
46:exp:27:exp:35:char*:"DHE-RSA-AES256-CBC-SHA256"
DTLS legacy break handshake renegotiation with MFL=1024, DHE-RSA-AES256-CBC-SHA256
depends_on:4:9:13
46:exp:28:exp:35:char*:"DHE-RSA-AES256-CBC-SHA256"
DTLS legacy break handshake renegotiation with MFL=2048, DHE-RSA-AES256-CBC-SHA256
depends_on:4:9:13
46:exp:30:exp:35:char*:"DHE-RSA-AES256-CBC-SHA256"
DTLS legacy break handshake renegotiation with MFL=4096, DHE-RSA-AES256-CBC-SHA256
depends_on:4:9:13
46:exp:31:exp:35:char*:"DHE-RSA-AES256-CBC-SHA256"
SSL DTLS replay: initial state, seqnum 0
18:hex:"":hex:"000000000000":int:0
SSL DTLS replay: 0 seen, 1 arriving
18:hex:"000000000000":hex:"000000000001":int:0
SSL DTLS replay: 0 seen, 0 replayed
18:hex:"000000000000":hex:"000000000000":exp:36
SSL DTLS replay: 0-1 seen, 2 arriving
18:hex:"000000000000000000000001":hex:"000000000002":int:0
SSL DTLS replay: 0-1 seen, 1 replayed
18:hex:"000000000000000000000001":hex:"000000000001":exp:36
SSL DTLS replay: 0-1 seen, 0 replayed
18:hex:"000000000000000000000001":hex:"000000000000":exp:36
SSL DTLS replay: new
18:hex:"abcd12340000abcd12340001abcd12340003":hex:"abcd12340004":int:0
SSL DTLS replay: way new
18:hex:"abcd12340000abcd12340001abcd12340003":hex:"abcd12350000":int:0
SSL DTLS replay: delayed
18:hex:"abcd12340000abcd12340001abcd12340003":hex:"abcd12340002":int:0
SSL DTLS replay: lastest replayed
18:hex:"abcd12340000abcd12340001abcd12340003":hex:"abcd12340003":exp:36
SSL DTLS replay: older replayed
18:hex:"abcd12340000abcd12340001abcd12340003":hex:"abcd12340001":exp:36
SSL DTLS replay: most recent in window, replayed
18:hex:"abcd12340000abcd12340002abcd12340003":hex:"abcd12340002":exp:36
SSL DTLS replay: oldest in window, replayed
18:hex:"abcd12340000abcd12340001abcd1234003f":hex:"abcd12340000":exp:36
SSL DTLS replay: oldest in window, not replayed
18:hex:"abcd12340001abcd12340002abcd1234003f":hex:"abcd12340000":int:0
SSL DTLS replay: just out of the window
18:hex:"abcd12340001abcd12340002abcd1234003f":hex:"abcd1233ffff":exp:36
SSL DTLS replay: way out of the window
18:hex:"abcd12340001abcd12340002abcd1234003f":hex:"abcd12330000":exp:36
SSL DTLS replay: big jump then replay
18:hex:"abcd12340000abcd12340100":hex:"abcd12340100":exp:36
SSL DTLS replay: big jump then new
18:hex:"abcd12340000abcd12340100":hex:"abcd12340101":int:0
SSL DTLS replay: big jump then just delayed
18:hex:"abcd12340000abcd12340100":hex:"abcd123400ff":int:0
SSL SET_HOSTNAME memory leak: call ssl_set_hostname twice
19:char*:"server0":char*:"server1"
SSL session serialization: Wrong major version
32:int:1:int:0:int:0:int:0
SSL session serialization: Wrong minor version
32:int:0:int:1:int:0:int:0
SSL session serialization: Wrong patch version
32:int:0:int:0:int:1:int:0
SSL session serialization: Wrong config
32:int:0:int:0:int:0:int:1
Record crypt, AES128-CBC, 1.2, SHA-384
depends_on:4:9:6:7:8
20:exp:37:exp:38:int:0:int:0:exp:24:int:0:int:0
Record crypt, AES128-CBC, 1.2, SHA-384, CID 4+4
depends_on:19:4:9:6:7:8
20:exp:37:exp:38:int:0:int:0:exp:24:int:4:int:4
Record crypt, AES128-CBC, 1.2, SHA-384, CID 4+0
depends_on:19:4:9:6:7:8
20:exp:37:exp:38:int:0:int:0:exp:24:int:4:int:0
Record crypt, AES128-CBC, 1.2, SHA-384, EtM
depends_on:4:9:6:7:8:20
20:exp:37:exp:38:int:1:int:0:exp:24:int:0:int:0
Record crypt, AES128-CBC, 1.2, SHA-384, EtM, CID 4+4
depends_on:19:4:9:6:7:8:20
20:exp:37:exp:38:int:1:int:0:exp:24:int:4:int:4
Record crypt, AES128-CBC, 1.2, SHA-384, EtM, CID 4+0
depends_on:19:4:9:6:7:8:20
20:exp:37:exp:38:int:1:int:0:exp:24:int:4:int:0
Record crypt, AES128-CBC, 1.2, SHA-384, short tag
depends_on:4:9:6:7:8
20:exp:37:exp:38:int:0:int:1:exp:24:int:0:int:0
Record crypt, AES128-CBC, 1.2, SHA-384, short tag, CID 4+4
depends_on:19:4:9:6:7:8
20:exp:37:exp:38:int:0:int:1:exp:24:int:4:int:4
Record crypt, AES128-CBC, 1.2, SHA-384, short tag, CID 4+0
depends_on:19:4:9:6:7:8
20:exp:37:exp:38:int:0:int:1:exp:24:int:4:int:0
Record crypt, AES128-CBC, 1.2, SHA-384, short tag, EtM
depends_on:4:9:6:7:8:20
20:exp:37:exp:38:int:1:int:1:exp:24:int:0:int:0
Record crypt, AES128-CBC, 1.2, SHA-384, short tag, EtM, CID 4+4
depends_on:19:4:9:6:7:8:20
20:exp:37:exp:38:int:1:int:1:exp:24:int:4:int:4
Record crypt, AES128-CBC, 1.2, SHA-384, short tag, EtM, CID 4+0
depends_on:19:4:9:6:7:8:20
20:exp:37:exp:38:int:1:int:1:exp:24:int:4:int:0
Record crypt, AES128-CBC, 1.2, SHA-256
depends_on:4:9:6:13
20:exp:37:exp:39:int:0:int:0:exp:24:int:0:int:0
Record crypt, AES128-CBC, 1.2, SHA-256, CID 4+4
depends_on:19:4:9:6:13
20:exp:37:exp:39:int:0:int:0:exp:24:int:4:int:4
Record crypt, AES128-CBC, 1.2, SHA-256, CID 4+0
depends_on:19:4:9:6:13
20:exp:37:exp:39:int:0:int:0:exp:24:int:4:int:0
Record crypt, AES128-CBC, 1.2, SHA-256, EtM
depends_on:4:9:6:13:20
20:exp:37:exp:39:int:1:int:0:exp:24:int:0:int:0
Record crypt, AES128-CBC, 1.2, SHA-256, EtM, CID 4+4
depends_on:19:4:9:6:13:20
20:exp:37:exp:39:int:1:int:0:exp:24:int:4:int:4
Record crypt, AES128-CBC, 1.2, SHA-256, EtM, CID 4+0
depends_on:19:4:9:6:13:20
20:exp:37:exp:39:int:1:int:0:exp:24:int:4:int:0
Record crypt, AES128-CBC, 1.2, SHA-256, short tag
depends_on:4:9:6:13
20:exp:37:exp:39:int:0:int:1:exp:24:int:0:int:0
Record crypt, AES128-CBC, 1.2, SHA-256, short tag, CID 4+4
depends_on:19:4:9:6:13
20:exp:37:exp:39:int:0:int:1:exp:24:int:4:int:4
Record crypt, AES128-CBC, 1.2, SHA-256, short tag, CID 4+0
depends_on:19:4:9:6:13
20:exp:37:exp:39:int:0:int:1:exp:24:int:4:int:0
Record crypt, AES128-CBC, 1.2, SHA-256, short tag, EtM
depends_on:4:9:6:13:20
20:exp:37:exp:39:int:1:int:1:exp:24:int:0:int:0
Record crypt, AES128-CBC, 1.2, SHA-256, short tag, EtM, CID 4+4
depends_on:19:4:9:6:13:20
20:exp:37:exp:39:int:1:int:1:exp:24:int:4:int:4
Record crypt, AES128-CBC, 1.2, SHA-256, short tag, EtM, CID 4+0
depends_on:19:4:9:6:13:20
20:exp:37:exp:39:int:1:int:1:exp:24:int:4:int:0
Record crypt, AES128-CBC, 1.2, SHA-1
depends_on:4:9:6:21
20:exp:37:exp:40:int:0:int:0:exp:24:int:0:int:0
Record crypt, AES128-CBC, 1.2, SHA-1, CID 4+4
depends_on:19:4:9:6:21
20:exp:37:exp:40:int:0:int:0:exp:24:int:4:int:4
Record crypt, AES128-CBC, 1.2, SHA-1, CID 4+0
depends_on:19:4:9:6:21
20:exp:37:exp:40:int:0:int:0:exp:24:int:4:int:0
Record crypt, AES128-CBC, 1.2, SHA-1, EtM
depends_on:4:9:6:21:20
20:exp:37:exp:40:int:1:int:0:exp:24:int:0:int:0
Record crypt, AES128-CBC, 1.2, SHA-1, EtM, CID 4+4
depends_on:19:4:9:6:21:20
20:exp:37:exp:40:int:1:int:0:exp:24:int:4:int:4
Record crypt, AES128-CBC, 1.2, SHA-1, EtM, CID 4+0
depends_on:19:4:9:6:21:20
20:exp:37:exp:40:int:1:int:0:exp:24:int:4:int:0
Record crypt, AES128-CBC, 1.2, SHA-1, short tag
depends_on:4:9:6:21
20:exp:37:exp:40:int:0:int:1:exp:24:int:0:int:0
Record crypt, AES128-CBC, 1.2, SHA-1, short tag, CID 4+4
depends_on:19:4:9:6:21
20:exp:37:exp:40:int:0:int:1:exp:24:int:4:int:4
Record crypt, AES128-CBC, 1.2, SHA-1, short tag, CID 4+0
depends_on:19:4:9:6:21
20:exp:37:exp:40:int:0:int:1:exp:24:int:4:int:0
Record crypt, AES128-CBC, 1.2, SHA-1, short tag, EtM
depends_on:4:9:6:21:20
20:exp:37:exp:40:int:1:int:1:exp:24:int:0:int:0
Record crypt, AES128-CBC, 1.2, SHA-1, short tag, EtM, CID 4+4
depends_on:19:4:9:6:21:20
20:exp:37:exp:40:int:1:int:1:exp:24:int:4:int:4
Record crypt, AES128-CBC, 1.2, SHA-1, short tag, EtM, CID 4+0
depends_on:19:4:9:6:21:20
20:exp:37:exp:40:int:1:int:1:exp:24:int:4:int:0
Record crypt, AES128-CBC, 1.2, MD5
depends_on:4:9:6:22
20:exp:37:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, AES128-CBC, 1.2, MD5, CID 4+4
depends_on:19:4:9:6:22
20:exp:37:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, AES128-CBC, 1.2, MD5, CID 4+0
depends_on:19:4:9:6:22
20:exp:37:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, AES128-CBC, 1.2, MD5, EtM
depends_on:4:9:6:22:20
20:exp:37:exp:41:int:1:int:0:exp:24:int:0:int:0
Record crypt, AES128-CBC, 1.2, MD5, EtM, CID 4+4
depends_on:19:4:9:6:22:20
20:exp:37:exp:41:int:1:int:0:exp:24:int:4:int:4
Record crypt, AES128-CBC, 1.2, MD5, EtM, CID 4+0
depends_on:19:4:9:6:22:20
20:exp:37:exp:41:int:1:int:0:exp:24:int:4:int:0
Record crypt, AES128-CBC, 1.2, MD5, short tag
depends_on:4:9:6:22
20:exp:37:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, AES128-CBC, 1.2, MD5, short tag, CID 4+4
depends_on:19:4:9:6:22
20:exp:37:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, AES128-CBC, 1.2, MD5, short tag, CID 4+0
depends_on:19:4:9:6:22
20:exp:37:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, AES128-CBC, 1.2, MD5, short tag, EtM
depends_on:4:9:6:22:20
20:exp:37:exp:41:int:1:int:1:exp:24:int:0:int:0
Record crypt, AES128-CBC, 1.2, MD5, short tag, EtM, CID 4+4
depends_on:19:4:9:6:22:20
20:exp:37:exp:41:int:1:int:1:exp:24:int:4:int:4
Record crypt, AES128-CBC, 1.2, MD5, short tag, EtM, CID 4+0
depends_on:19:4:9:6:22:20
20:exp:37:exp:41:int:1:int:1:exp:24:int:4:int:0
Record crypt, AES128-CBC, 1.1, SHA-384
depends_on:4:9:5:7:8
20:exp:37:exp:38:int:0:int:0:exp:23:int:0:int:0
Record crypt, AES128-CBC, 1.1, SHA-384, EtM
depends_on:4:9:5:7:8:20
20:exp:37:exp:38:int:1:int:0:exp:23:int:0:int:0
Record crypt, AES128-CBC, 1.1, SHA-384, short tag
depends_on:4:9:5:7:8
20:exp:37:exp:38:int:0:int:1:exp:23:int:0:int:0
Record crypt, AES128-CBC, 1.1, SHA-384, short tag, EtM
depends_on:4:9:5:7:8:20
20:exp:37:exp:38:int:1:int:1:exp:23:int:0:int:0
Record crypt, AES128-CBC, 1.1, SHA-256
depends_on:4:9:5:13
20:exp:37:exp:39:int:0:int:0:exp:23:int:0:int:0
Record crypt, AES128-CBC, 1.1, SHA-256, EtM
depends_on:4:9:5:13:20
20:exp:37:exp:39:int:1:int:0:exp:23:int:0:int:0
Record crypt, AES128-CBC, 1.1, SHA-256, short tag
depends_on:4:9:5:13
20:exp:37:exp:39:int:0:int:1:exp:23:int:0:int:0
Record crypt, AES128-CBC, 1.1, SHA-256, short tag, EtM
depends_on:4:9:5:13:20
20:exp:37:exp:39:int:1:int:1:exp:23:int:0:int:0
Record crypt, AES128-CBC, 1.1, SHA-1
depends_on:4:9:5:21
20:exp:37:exp:40:int:0:int:0:exp:23:int:0:int:0
Record crypt, AES128-CBC, 1.1, SHA-1, EtM
depends_on:4:9:5:21:20
20:exp:37:exp:40:int:1:int:0:exp:23:int:0:int:0
Record crypt, AES128-CBC, 1.1, SHA-1, short tag
depends_on:4:9:5:21
20:exp:37:exp:40:int:0:int:1:exp:23:int:0:int:0
Record crypt, AES128-CBC, 1.1, SHA-1, short tag, EtM
depends_on:4:9:5:21:20
20:exp:37:exp:40:int:1:int:1:exp:23:int:0:int:0
Record crypt, AES128-CBC, 1.1, MD5
depends_on:4:9:5:22
20:exp:37:exp:41:int:0:int:0:exp:23:int:0:int:0
Record crypt, AES128-CBC, 1.1, MD5, EtM
depends_on:4:9:5:22:20
20:exp:37:exp:41:int:1:int:0:exp:23:int:0:int:0
Record crypt, AES128-CBC, 1.1, MD5, short tag
depends_on:4:9:5:22
20:exp:37:exp:41:int:0:int:1:exp:23:int:0:int:0
Record crypt, AES128-CBC, 1.1, MD5, short tag, EtM
depends_on:4:9:5:22:20
20:exp:37:exp:41:int:1:int:1:exp:23:int:0:int:0
Record crypt, AES128-CBC, 1.0, SHA-384
depends_on:4:9:3:7:8
20:exp:37:exp:38:int:0:int:0:exp:22:int:0:int:0
Record crypt, AES128-CBC, 1.0, SHA-384, EtM
depends_on:4:9:3:7:8:20
20:exp:37:exp:38:int:1:int:0:exp:22:int:0:int:0
Record crypt, AES128-CBC, 1.0, SHA-384, short tag
depends_on:4:9:3:7:8
20:exp:37:exp:38:int:0:int:1:exp:22:int:0:int:0
Record crypt, AES128-CBC, 1.0, SHA-384, short tag, EtM
depends_on:4:9:3:7:8:20
20:exp:37:exp:38:int:1:int:1:exp:22:int:0:int:0
Record crypt, AES128-CBC, 1.0, SHA-256
depends_on:4:9:3:13
20:exp:37:exp:39:int:0:int:0:exp:22:int:0:int:0
Record crypt, AES128-CBC, 1.0, SHA-256, EtM
depends_on:4:9:3:13:20
20:exp:37:exp:39:int:1:int:0:exp:22:int:0:int:0
Record crypt, AES128-CBC, 1.0, SHA-256, short tag
depends_on:4:9:3:13
20:exp:37:exp:39:int:0:int:1:exp:22:int:0:int:0
Record crypt, AES128-CBC, 1.0, SHA-256, short tag, EtM
depends_on:4:9:3:13:20
20:exp:37:exp:39:int:1:int:1:exp:22:int:0:int:0
Record crypt, AES128-CBC, 1.0, SHA-1
depends_on:4:9:3:21
20:exp:37:exp:40:int:0:int:0:exp:22:int:0:int:0
Record crypt, AES128-CBC, 1.0, SHA-1, EtM
depends_on:4:9:3:21:20
20:exp:37:exp:40:int:1:int:0:exp:22:int:0:int:0
Record crypt, AES128-CBC, 1.0, SHA-1, short tag
depends_on:4:9:3:21
20:exp:37:exp:40:int:0:int:1:exp:22:int:0:int:0
Record crypt, AES128-CBC, 1.0, SHA-1, short tag, EtM
depends_on:4:9:3:21:20
20:exp:37:exp:40:int:1:int:1:exp:22:int:0:int:0
Record crypt, AES128-CBC, 1.0, MD5
depends_on:4:9:3:22
20:exp:37:exp:41:int:0:int:0:exp:22:int:0:int:0
Record crypt, AES128-CBC, 1.0, MD5, EtM
depends_on:4:9:3:22:20
20:exp:37:exp:41:int:1:int:0:exp:22:int:0:int:0
Record crypt, AES128-CBC, 1.0, MD5, short tag
depends_on:4:9:3:22
20:exp:37:exp:41:int:0:int:1:exp:22:int:0:int:0
Record crypt, AES128-CBC, 1.0, MD5, short tag, EtM
depends_on:4:9:3:22:20
20:exp:37:exp:41:int:1:int:1:exp:22:int:0:int:0
Record crypt, AES128-CBC, SSL3, SHA-1
depends_on:4:9:0:21
20:exp:37:exp:40:int:0:int:0:exp:21:int:0:int:0
Record crypt, AES128-CBC, SSL3, SHA-1, EtM
depends_on:4:9:0:21:20
20:exp:37:exp:40:int:1:int:0:exp:21:int:0:int:0
Record crypt, AES128-CBC, SSL3, SHA-1, short tag
depends_on:4:9:0:21
20:exp:37:exp:40:int:0:int:1:exp:21:int:0:int:0
Record crypt, AES128-CBC, SSL3, SHA-1, short tag, EtM
depends_on:4:9:0:21:20
20:exp:37:exp:40:int:1:int:1:exp:21:int:0:int:0
Record crypt, AES128-CBC, SSL3, MD5
depends_on:4:9:0:22
20:exp:37:exp:41:int:0:int:0:exp:21:int:0:int:0
Record crypt, AES128-CBC, SSL3, MD5, EtM
depends_on:4:9:0:22:20
20:exp:37:exp:41:int:1:int:0:exp:21:int:0:int:0
Record crypt, AES128-CBC, SSL3, MD5, short tag
depends_on:4:9:0:22
20:exp:37:exp:41:int:0:int:1:exp:21:int:0:int:0
Record crypt, AES128-CBC, SSL3, MD5, short tag, EtM
depends_on:4:9:0:22:20
20:exp:37:exp:41:int:1:int:1:exp:21:int:0:int:0
Record crypt, AES-192-CBC, 1.2, SHA-384
depends_on:4:9:6:7:8
20:exp:42:exp:38:int:0:int:0:exp:24:int:0:int:0
Record crypt, AES-192-CBC, 1.2, SHA-384, CID 4+4
depends_on:19:4:9:6:7:8
20:exp:42:exp:38:int:0:int:0:exp:24:int:4:int:4
Record crypt, AES-192-CBC, 1.2, SHA-384, CID 4+0
depends_on:19:4:9:6:7:8
20:exp:42:exp:38:int:0:int:0:exp:24:int:4:int:0
Record crypt, AES-192-CBC, 1.2, SHA-384, EtM
depends_on:4:9:6:7:8:20
20:exp:42:exp:38:int:1:int:0:exp:24:int:0:int:0
Record crypt, AES-192-CBC, 1.2, SHA-384, EtM, CID 4+4
depends_on:19:4:9:6:7:8:20
20:exp:42:exp:38:int:1:int:0:exp:24:int:4:int:4
Record crypt, AES-192-CBC, 1.2, SHA-384, EtM, CID 4+0
depends_on:19:4:9:6:7:8:20
20:exp:42:exp:38:int:1:int:0:exp:24:int:4:int:0
Record crypt, AES-192-CBC, 1.2, SHA-384, short tag
depends_on:4:9:6:7:8
20:exp:42:exp:38:int:0:int:1:exp:24:int:0:int:0
Record crypt, AES-192-CBC, 1.2, SHA-384, short tag, CID 4+4
depends_on:19:4:9:6:7:8
20:exp:42:exp:38:int:0:int:1:exp:24:int:4:int:4
Record crypt, AES-192-CBC, 1.2, SHA-384, short tag, CID 4+0
depends_on:19:4:9:6:7:8
20:exp:42:exp:38:int:0:int:1:exp:24:int:4:int:0
Record crypt, AES-192-CBC, 1.2, SHA-384, short tag, EtM
depends_on:4:9:6:7:8:20
20:exp:42:exp:38:int:1:int:1:exp:24:int:0:int:0
Record crypt, AES-192-CBC, 1.2, SHA-384, short tag, EtM, CID 4+4
depends_on:19:4:9:6:7:8:20
20:exp:42:exp:38:int:1:int:1:exp:24:int:4:int:4
Record crypt, AES-192-CBC, 1.2, SHA-384, short tag, EtM, CID 4+0
depends_on:19:4:9:6:7:8:20
20:exp:42:exp:38:int:1:int:1:exp:24:int:4:int:0
Record crypt, AES-192-CBC, 1.2, SHA-256
depends_on:4:9:6:13
20:exp:42:exp:39:int:0:int:0:exp:24:int:0:int:0
Record crypt, AES-192-CBC, 1.2, SHA-256, CID 4+4
depends_on:19:4:9:6:13
20:exp:42:exp:39:int:0:int:0:exp:24:int:4:int:4
Record crypt, AES-192-CBC, 1.2, SHA-256, CID 4+0
depends_on:19:4:9:6:13
20:exp:42:exp:39:int:0:int:0:exp:24:int:4:int:0
Record crypt, AES-192-CBC, 1.2, SHA-256, EtM
depends_on:4:9:6:13:20
20:exp:42:exp:39:int:1:int:0:exp:24:int:0:int:0
Record crypt, AES-192-CBC, 1.2, SHA-256, EtM, CID 4+4
depends_on:19:4:9:6:13:20
20:exp:42:exp:39:int:1:int:0:exp:24:int:4:int:4
Record crypt, AES-192-CBC, 1.2, SHA-256, EtM, CID 4+0
depends_on:19:4:9:6:13:20
20:exp:42:exp:39:int:1:int:0:exp:24:int:4:int:0
Record crypt, AES-192-CBC, 1.2, SHA-256, short tag
depends_on:4:9:6:13
20:exp:42:exp:39:int:0:int:1:exp:24:int:0:int:0
Record crypt, AES-192-CBC, 1.2, SHA-256, short tag, CID 4+4
depends_on:19:4:9:6:13
20:exp:42:exp:39:int:0:int:1:exp:24:int:4:int:4
Record crypt, AES-192-CBC, 1.2, SHA-256, short tag, CID 4+0
depends_on:19:4:9:6:13
20:exp:42:exp:39:int:0:int:1:exp:24:int:4:int:0
Record crypt, AES-192-CBC, 1.2, SHA-256, short tag, EtM
depends_on:4:9:6:13:20
20:exp:42:exp:39:int:1:int:1:exp:24:int:0:int:0
Record crypt, AES-192-CBC, 1.2, SHA-256, short tag, EtM, CID 4+4
depends_on:19:4:9:6:13:20
20:exp:42:exp:39:int:1:int:1:exp:24:int:4:int:4
Record crypt, AES-192-CBC, 1.2, SHA-256, short tag, EtM, CID 4+0
depends_on:19:4:9:6:13:20
20:exp:42:exp:39:int:1:int:1:exp:24:int:4:int:0
Record crypt, AES-192-CBC, 1.2, SHA-1
depends_on:4:9:6:21
20:exp:42:exp:40:int:0:int:0:exp:24:int:0:int:0
Record crypt, AES-192-CBC, 1.2, SHA-1, CID 4+4
depends_on:19:4:9:6:21
20:exp:42:exp:40:int:0:int:0:exp:24:int:4:int:4
Record crypt, AES-192-CBC, 1.2, SHA-1, CID 4+0
depends_on:19:4:9:6:21
20:exp:42:exp:40:int:0:int:0:exp:24:int:4:int:0
Record crypt, AES-192-CBC, 1.2, SHA-1, EtM
depends_on:4:9:6:21:20
20:exp:42:exp:40:int:1:int:0:exp:24:int:0:int:0
Record crypt, AES-192-CBC, 1.2, SHA-1, EtM, CID 4+4
depends_on:19:4:9:6:21:20
20:exp:42:exp:40:int:1:int:0:exp:24:int:4:int:4
Record crypt, AES-192-CBC, 1.2, SHA-1, EtM, CID 4+0
depends_on:19:4:9:6:21:20
20:exp:42:exp:40:int:1:int:0:exp:24:int:4:int:0
Record crypt, AES-192-CBC, 1.2, SHA-1, short tag
depends_on:4:9:6:21
20:exp:42:exp:40:int:0:int:1:exp:24:int:0:int:0
Record crypt, AES-192-CBC, 1.2, SHA-1, short tag, CID 4+4
depends_on:19:4:9:6:21
20:exp:42:exp:40:int:0:int:1:exp:24:int:4:int:4
Record crypt, AES-192-CBC, 1.2, SHA-1, short tag, CID 4+0
depends_on:19:4:9:6:21
20:exp:42:exp:40:int:0:int:1:exp:24:int:4:int:0
Record crypt, AES-192-CBC, 1.2, SHA-1, short tag, EtM
depends_on:4:9:6:21:20
20:exp:42:exp:40:int:1:int:1:exp:24:int:0:int:0
Record crypt, AES-192-CBC, 1.2, SHA-1, short tag, EtM, CID 4+4
depends_on:19:4:9:6:21:20
20:exp:42:exp:40:int:1:int:1:exp:24:int:4:int:4
Record crypt, AES-192-CBC, 1.2, SHA-1, short tag, EtM, CID 4+0
depends_on:19:4:9:6:21:20
20:exp:42:exp:40:int:1:int:1:exp:24:int:4:int:0
Record crypt, AES-192-CBC, 1.2, MD5
depends_on:4:9:6:22
20:exp:42:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, AES-192-CBC, 1.2, MD5, CID 4+4
depends_on:19:4:9:6:22
20:exp:42:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, AES-192-CBC, 1.2, MD5, CID 4+0
depends_on:19:4:9:6:22
20:exp:42:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, AES-192-CBC, 1.2, MD5, EtM
depends_on:4:9:6:22:20
20:exp:42:exp:41:int:1:int:0:exp:24:int:0:int:0
Record crypt, AES-192-CBC, 1.2, MD5, EtM, CID 4+4
depends_on:19:4:9:6:22:20
20:exp:42:exp:41:int:1:int:0:exp:24:int:4:int:4
Record crypt, AES-192-CBC, 1.2, MD5, EtM, CID 4+0
depends_on:19:4:9:6:22:20
20:exp:42:exp:41:int:1:int:0:exp:24:int:4:int:0
Record crypt, AES-192-CBC, 1.2, MD5, short tag
depends_on:4:9:6:22
20:exp:42:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, AES-192-CBC, 1.2, MD5, short tag, CID 4+4
depends_on:19:4:9:6:22
20:exp:42:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, AES-192-CBC, 1.2, MD5, short tag, CID 4+0
depends_on:19:4:9:6:22
20:exp:42:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, AES-192-CBC, 1.2, MD5, short tag, EtM
depends_on:4:9:6:22:20
20:exp:42:exp:41:int:1:int:1:exp:24:int:0:int:0
Record crypt, AES-192-CBC, 1.2, MD5, short tag, EtM, CID 4+4
depends_on:19:4:9:6:22:20
20:exp:42:exp:41:int:1:int:1:exp:24:int:4:int:4
Record crypt, AES-192-CBC, 1.2, MD5, short tag, EtM, CID 4+0
depends_on:19:4:9:6:22:20
20:exp:42:exp:41:int:1:int:1:exp:24:int:4:int:0
Record crypt, AES-192-CBC, 1.1, SHA-384
depends_on:4:9:5:7:8
20:exp:42:exp:38:int:0:int:0:exp:23:int:0:int:0
Record crypt, AES-192-CBC, 1.1, SHA-384, EtM
depends_on:4:9:5:7:8:20
20:exp:42:exp:38:int:1:int:0:exp:23:int:0:int:0
Record crypt, AES-192-CBC, 1.1, SHA-384, short tag
depends_on:4:9:5:7:8
20:exp:42:exp:38:int:0:int:1:exp:23:int:0:int:0
Record crypt, AES-192-CBC, 1.1, SHA-384, short tag, EtM
depends_on:4:9:5:7:8:20
20:exp:42:exp:38:int:1:int:1:exp:23:int:0:int:0
Record crypt, AES-192-CBC, 1.1, SHA-256
depends_on:4:9:5:13
20:exp:42:exp:39:int:0:int:0:exp:23:int:0:int:0
Record crypt, AES-192-CBC, 1.1, SHA-256, EtM
depends_on:4:9:5:13:20
20:exp:42:exp:39:int:1:int:0:exp:23:int:0:int:0
Record crypt, AES-192-CBC, 1.1, SHA-256, short tag
depends_on:4:9:5:13
20:exp:42:exp:39:int:0:int:1:exp:23:int:0:int:0
Record crypt, AES-192-CBC, 1.1, SHA-256, short tag, EtM
depends_on:4:9:5:13:20
20:exp:42:exp:39:int:1:int:1:exp:23:int:0:int:0
Record crypt, AES-192-CBC, 1.1, SHA-1
depends_on:4:9:5:21
20:exp:42:exp:40:int:0:int:0:exp:23:int:0:int:0
Record crypt, AES-192-CBC, 1.1, SHA-1, EtM
depends_on:4:9:5:21:20
20:exp:42:exp:40:int:1:int:0:exp:23:int:0:int:0
Record crypt, AES-192-CBC, 1.1, SHA-1, short tag
depends_on:4:9:5:21
20:exp:42:exp:40:int:0:int:1:exp:23:int:0:int:0
Record crypt, AES-192-CBC, 1.1, SHA-1, short tag, EtM
depends_on:4:9:5:21:20
20:exp:42:exp:40:int:1:int:1:exp:23:int:0:int:0
Record crypt, AES-192-CBC, 1.1, MD5
depends_on:4:9:5:22
20:exp:42:exp:41:int:0:int:0:exp:23:int:0:int:0
Record crypt, AES-192-CBC, 1.1, MD5, EtM
depends_on:4:9:5:22:20
20:exp:42:exp:41:int:1:int:0:exp:23:int:0:int:0
Record crypt, AES-192-CBC, 1.1, MD5, short tag
depends_on:4:9:5:22
20:exp:42:exp:41:int:0:int:1:exp:23:int:0:int:0
Record crypt, AES-192-CBC, 1.1, MD5, short tag, EtM
depends_on:4:9:5:22:20
20:exp:42:exp:41:int:1:int:1:exp:23:int:0:int:0
Record crypt, AES-192-CBC, 1.0, SHA-384
depends_on:4:9:3:7:8
20:exp:42:exp:38:int:0:int:0:exp:22:int:0:int:0
Record crypt, AES-192-CBC, 1.0, SHA-384, EtM
depends_on:4:9:3:7:8:20
20:exp:42:exp:38:int:1:int:0:exp:22:int:0:int:0
Record crypt, AES-192-CBC, 1.0, SHA-384, short tag
depends_on:4:9:3:7:8
20:exp:42:exp:38:int:0:int:1:exp:22:int:0:int:0
Record crypt, AES-192-CBC, 1.0, SHA-384, short tag, EtM
depends_on:4:9:3:7:8:20
20:exp:42:exp:38:int:1:int:1:exp:22:int:0:int:0
Record crypt, AES-192-CBC, 1.0, SHA-256
depends_on:4:9:3:13
20:exp:42:exp:39:int:0:int:0:exp:22:int:0:int:0
Record crypt, AES-192-CBC, 1.0, SHA-256, EtM
depends_on:4:9:3:13:20
20:exp:42:exp:39:int:1:int:0:exp:22:int:0:int:0
Record crypt, AES-192-CBC, 1.0, SHA-256, short tag
depends_on:4:9:3:13
20:exp:42:exp:39:int:0:int:1:exp:22:int:0:int:0
Record crypt, AES-192-CBC, 1.0, SHA-256, short tag, EtM
depends_on:4:9:3:13:20
20:exp:42:exp:39:int:1:int:1:exp:22:int:0:int:0
Record crypt, AES-192-CBC, 1.0, SHA-1
depends_on:4:9:3:21
20:exp:42:exp:40:int:0:int:0:exp:22:int:0:int:0
Record crypt, AES-192-CBC, 1.0, SHA-1, EtM
depends_on:4:9:3:21:20
20:exp:42:exp:40:int:1:int:0:exp:22:int:0:int:0
Record crypt, AES-192-CBC, 1.0, SHA-1, short tag
depends_on:4:9:3:21
20:exp:42:exp:40:int:0:int:1:exp:22:int:0:int:0
Record crypt, AES-192-CBC, 1.0, SHA-1, short tag, EtM
depends_on:4:9:3:21:20
20:exp:42:exp:40:int:1:int:1:exp:22:int:0:int:0
Record crypt, AES-192-CBC, 1.0, MD5
depends_on:4:9:3:22
20:exp:42:exp:41:int:0:int:0:exp:22:int:0:int:0
Record crypt, AES-192-CBC, 1.0, MD5, EtM
depends_on:4:9:3:22:20
20:exp:42:exp:41:int:1:int:0:exp:22:int:0:int:0
Record crypt, AES-192-CBC, 1.0, MD5, short tag
depends_on:4:9:3:22
20:exp:42:exp:41:int:0:int:1:exp:22:int:0:int:0
Record crypt, AES-192-CBC, 1.0, MD5, short tag, EtM
depends_on:4:9:3:22:20
20:exp:42:exp:41:int:1:int:1:exp:22:int:0:int:0
Record crypt, AES-192-CBC, SSL3, SHA-1
depends_on:4:9:0:21
20:exp:42:exp:40:int:0:int:0:exp:21:int:0:int:0
Record crypt, AES-192-CBC, SSL3, SHA-1, EtM
depends_on:4:9:0:21:20
20:exp:42:exp:40:int:1:int:0:exp:21:int:0:int:0
Record crypt, AES-192-CBC, SSL3, SHA-1, short tag
depends_on:4:9:0:21
20:exp:42:exp:40:int:0:int:1:exp:21:int:0:int:0
Record crypt, AES-192-CBC, SSL3, SHA-1, short tag, EtM
depends_on:4:9:0:21:20
20:exp:42:exp:40:int:1:int:1:exp:21:int:0:int:0
Record crypt, AES-192-CBC, SSL3, MD5
depends_on:4:9:0:22
20:exp:42:exp:41:int:0:int:0:exp:21:int:0:int:0
Record crypt, AES-192-CBC, SSL3, MD5, EtM
depends_on:4:9:0:22:20
20:exp:42:exp:41:int:1:int:0:exp:21:int:0:int:0
Record crypt, AES-192-CBC, SSL3, MD5, short tag
depends_on:4:9:0:22
20:exp:42:exp:41:int:0:int:1:exp:21:int:0:int:0
Record crypt, AES-192-CBC, SSL3, MD5, short tag, EtM
depends_on:4:9:0:22:20
20:exp:42:exp:41:int:1:int:1:exp:21:int:0:int:0
Record crypt, AES256-CBC, 1.2, SHA-384
depends_on:4:9:6:7:8
20:exp:43:exp:38:int:0:int:0:exp:24:int:0:int:0
Record crypt, AES256-CBC, 1.2, SHA-384, CID 4+4
depends_on:19:4:9:6:7:8
20:exp:43:exp:38:int:0:int:0:exp:24:int:4:int:4
Record crypt, AES256-CBC, 1.2, SHA-384, CID 4+0
depends_on:19:4:9:6:7:8
20:exp:43:exp:38:int:0:int:0:exp:24:int:4:int:0
Record crypt, AES256-CBC, 1.2, SHA-384, EtM
depends_on:4:9:6:7:8:20
20:exp:43:exp:38:int:1:int:0:exp:24:int:0:int:0
Record crypt, AES256-CBC, 1.2, SHA-384, EtM, CID 4+4
depends_on:19:4:9:6:7:8:20
20:exp:43:exp:38:int:1:int:0:exp:24:int:4:int:4
Record crypt, AES256-CBC, 1.2, SHA-384, EtM, CID 4+0
depends_on:19:4:9:6:7:8:20
20:exp:43:exp:38:int:1:int:0:exp:24:int:4:int:0
Record crypt, AES256-CBC, 1.2, SHA-384, short tag
depends_on:4:9:6:7:8
20:exp:43:exp:38:int:0:int:1:exp:24:int:0:int:0
Record crypt, AES256-CBC, 1.2, SHA-384, short tag, CID 4+4
depends_on:19:4:9:6:7:8
20:exp:43:exp:38:int:0:int:1:exp:24:int:4:int:4
Record crypt, AES256-CBC, 1.2, SHA-384, short tag, CID 4+0
depends_on:19:4:9:6:7:8
20:exp:43:exp:38:int:0:int:1:exp:24:int:4:int:0
Record crypt, AES256-CBC, 1.2, SHA-384, short tag, EtM
depends_on:4:9:6:7:8:20
20:exp:43:exp:38:int:1:int:1:exp:24:int:0:int:0
Record crypt, AES256-CBC, 1.2, SHA-384, short tag, EtM, CID 4+4
depends_on:19:4:9:6:7:8:20
20:exp:43:exp:38:int:1:int:1:exp:24:int:4:int:4
Record crypt, AES256-CBC, 1.2, SHA-384, short tag, EtM, CID 4+0
depends_on:19:4:9:6:7:8:20
20:exp:43:exp:38:int:1:int:1:exp:24:int:4:int:0
Record crypt, AES256-CBC, 1.2, SHA-256
depends_on:4:9:6:13
20:exp:43:exp:39:int:0:int:0:exp:24:int:0:int:0
Record crypt, AES256-CBC, 1.2, SHA-256, CID 4+4
depends_on:19:4:9:6:13
20:exp:43:exp:39:int:0:int:0:exp:24:int:4:int:4
Record crypt, AES256-CBC, 1.2, SHA-256, CID 4+0
depends_on:19:4:9:6:13
20:exp:43:exp:39:int:0:int:0:exp:24:int:4:int:0
Record crypt, AES256-CBC, 1.2, SHA-256, EtM
depends_on:4:9:6:13:20
20:exp:43:exp:39:int:1:int:0:exp:24:int:0:int:0
Record crypt, AES256-CBC, 1.2, SHA-256, EtM, CID 4+4
depends_on:19:4:9:6:13:20
20:exp:43:exp:39:int:1:int:0:exp:24:int:4:int:4
Record crypt, AES256-CBC, 1.2, SHA-256, EtM, CID 4+0
depends_on:19:4:9:6:13:20
20:exp:43:exp:39:int:1:int:0:exp:24:int:4:int:0
Record crypt, AES256-CBC, 1.2, SHA-256, short tag
depends_on:4:9:6:13
20:exp:43:exp:39:int:0:int:1:exp:24:int:0:int:0
Record crypt, AES256-CBC, 1.2, SHA-256, short tag, CID 4+4
depends_on:19:4:9:6:13
20:exp:43:exp:39:int:0:int:1:exp:24:int:4:int:4
Record crypt, AES256-CBC, 1.2, SHA-256, short tag, CID 4+0
depends_on:19:4:9:6:13
20:exp:43:exp:39:int:0:int:1:exp:24:int:4:int:0
Record crypt, AES256-CBC, 1.2, SHA-256, short tag, EtM
depends_on:4:9:6:13:20
20:exp:43:exp:39:int:1:int:1:exp:24:int:0:int:0
Record crypt, AES256-CBC, 1.2, SHA-256, short tag, EtM, CID 4+4
depends_on:19:4:9:6:13:20
20:exp:43:exp:39:int:1:int:1:exp:24:int:4:int:4
Record crypt, AES256-CBC, 1.2, SHA-256, short tag, EtM, CID 4+0
depends_on:19:4:9:6:13:20
20:exp:43:exp:39:int:1:int:1:exp:24:int:4:int:0
Record crypt, AES256-CBC, 1.2, SHA-1
depends_on:4:9:6:21
20:exp:43:exp:40:int:0:int:0:exp:24:int:0:int:0
Record crypt, AES256-CBC, 1.2, SHA-1, CID 4+4
depends_on:19:4:9:6:21
20:exp:43:exp:40:int:0:int:0:exp:24:int:4:int:4
Record crypt, AES256-CBC, 1.2, SHA-1, CID 4+0
depends_on:19:4:9:6:21
20:exp:43:exp:40:int:0:int:0:exp:24:int:4:int:0
Record crypt, AES256-CBC, 1.2, SHA-1, EtM
depends_on:4:9:6:21:20
20:exp:43:exp:40:int:1:int:0:exp:24:int:0:int:0
Record crypt, AES256-CBC, 1.2, SHA-1, EtM, CID 4+4
depends_on:19:4:9:6:21:20
20:exp:43:exp:40:int:1:int:0:exp:24:int:4:int:4
Record crypt, AES256-CBC, 1.2, SHA-1, EtM, CID 4+0
depends_on:19:4:9:6:21:20
20:exp:43:exp:40:int:1:int:0:exp:24:int:4:int:0
Record crypt, AES256-CBC, 1.2, SHA-1, short tag
depends_on:4:9:6:21
20:exp:43:exp:40:int:0:int:1:exp:24:int:0:int:0
Record crypt, AES256-CBC, 1.2, SHA-1, short tag, CID 4+4
depends_on:19:4:9:6:21
20:exp:43:exp:40:int:0:int:1:exp:24:int:4:int:4
Record crypt, AES256-CBC, 1.2, SHA-1, short tag, CID 4+0
depends_on:19:4:9:6:21
20:exp:43:exp:40:int:0:int:1:exp:24:int:4:int:0
Record crypt, AES256-CBC, 1.2, SHA-1, short tag, EtM
depends_on:4:9:6:21:20
20:exp:43:exp:40:int:1:int:1:exp:24:int:0:int:0
Record crypt, AES256-CBC, 1.2, SHA-1, short tag, EtM, CID 4+4
depends_on:19:4:9:6:21:20
20:exp:43:exp:40:int:1:int:1:exp:24:int:4:int:4
Record crypt, AES256-CBC, 1.2, SHA-1, short tag, EtM, CID 4+0
depends_on:19:4:9:6:21:20
20:exp:43:exp:40:int:1:int:1:exp:24:int:4:int:0
Record crypt, AES256-CBC, 1.2, MD5
depends_on:4:9:6:22
20:exp:43:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, AES256-CBC, 1.2, MD5, CID 4+4
depends_on:19:4:9:6:22
20:exp:43:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, AES256-CBC, 1.2, MD5, CID 4+0
depends_on:19:4:9:6:22
20:exp:43:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, AES256-CBC, 1.2, MD5, EtM
depends_on:4:9:6:22:20
20:exp:43:exp:41:int:1:int:0:exp:24:int:0:int:0
Record crypt, AES256-CBC, 1.2, MD5, EtM, CID 4+4
depends_on:19:4:9:6:22:20
20:exp:43:exp:41:int:1:int:0:exp:24:int:4:int:4
Record crypt, AES256-CBC, 1.2, MD5, EtM, CID 4+0
depends_on:19:4:9:6:22:20
20:exp:43:exp:41:int:1:int:0:exp:24:int:4:int:0
Record crypt, AES256-CBC, 1.2, MD5, short tag
depends_on:4:9:6:22
20:exp:43:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, AES256-CBC, 1.2, MD5, short tag, CID 4+4
depends_on:19:4:9:6:22
20:exp:43:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, AES256-CBC, 1.2, MD5, short tag, CID 4+0
depends_on:19:4:9:6:22
20:exp:43:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, AES256-CBC, 1.2, MD5, short tag, EtM
depends_on:4:9:6:22:20
20:exp:43:exp:41:int:1:int:1:exp:24:int:0:int:0
Record crypt, AES256-CBC, 1.2, MD5, short tag, EtM, CID 4+4
depends_on:19:4:9:6:22:20
20:exp:43:exp:41:int:1:int:1:exp:24:int:4:int:4
Record crypt, AES256-CBC, 1.2, MD5, short tag, EtM, CID 4+0
depends_on:19:4:9:6:22:20
20:exp:43:exp:41:int:1:int:1:exp:24:int:4:int:0
Record crypt, AES256-CBC, 1.1, SHA-384
depends_on:4:9:5:7:8
20:exp:43:exp:38:int:0:int:0:exp:23:int:0:int:0
Record crypt, AES256-CBC, 1.1, SHA-384, EtM
depends_on:4:9:5:7:8:20
20:exp:43:exp:38:int:1:int:0:exp:23:int:0:int:0
Record crypt, AES256-CBC, 1.1, SHA-384, short tag
depends_on:4:9:5:7:8
20:exp:43:exp:38:int:0:int:1:exp:23:int:0:int:0
Record crypt, AES256-CBC, 1.1, SHA-384, short tag, EtM
depends_on:4:9:5:7:8:20
20:exp:43:exp:38:int:1:int:1:exp:23:int:0:int:0
Record crypt, AES256-CBC, 1.1, SHA-256
depends_on:4:9:5:13
20:exp:43:exp:39:int:0:int:0:exp:23:int:0:int:0
Record crypt, AES256-CBC, 1.1, SHA-256, EtM
depends_on:4:9:5:13:20
20:exp:43:exp:39:int:1:int:0:exp:23:int:0:int:0
Record crypt, AES256-CBC, 1.1, SHA-256, short tag
depends_on:4:9:5:13
20:exp:43:exp:39:int:0:int:1:exp:23:int:0:int:0
Record crypt, AES256-CBC, 1.1, SHA-256, short tag, EtM
depends_on:4:9:5:13:20
20:exp:43:exp:39:int:1:int:1:exp:23:int:0:int:0
Record crypt, AES256-CBC, 1.1, SHA-1
depends_on:4:9:5:21
20:exp:43:exp:40:int:0:int:0:exp:23:int:0:int:0
Record crypt, AES256-CBC, 1.1, SHA-1, EtM
depends_on:4:9:5:21:20
20:exp:43:exp:40:int:1:int:0:exp:23:int:0:int:0
Record crypt, AES256-CBC, 1.1, SHA-1, short tag
depends_on:4:9:5:21
20:exp:43:exp:40:int:0:int:1:exp:23:int:0:int:0
Record crypt, AES256-CBC, 1.1, SHA-1, short tag, EtM
depends_on:4:9:5:21:20
20:exp:43:exp:40:int:1:int:1:exp:23:int:0:int:0
Record crypt, AES256-CBC, 1.1, MD5
depends_on:4:9:5:22
20:exp:43:exp:41:int:0:int:0:exp:23:int:0:int:0
Record crypt, AES256-CBC, 1.1, MD5, EtM
depends_on:4:9:5:22:20
20:exp:43:exp:41:int:1:int:0:exp:23:int:0:int:0
Record crypt, AES256-CBC, 1.1, MD5, short tag
depends_on:4:9:5:22
20:exp:43:exp:41:int:0:int:1:exp:23:int:0:int:0
Record crypt, AES256-CBC, 1.1, MD5, short tag, EtM
depends_on:4:9:5:22:20
20:exp:43:exp:41:int:1:int:1:exp:23:int:0:int:0
Record crypt, AES256-CBC, 1.0, SHA-384
depends_on:4:9:3:7:8
20:exp:43:exp:38:int:0:int:0:exp:22:int:0:int:0
Record crypt, AES256-CBC, 1.0, SHA-384, EtM
depends_on:4:9:3:7:8:20
20:exp:43:exp:38:int:1:int:0:exp:22:int:0:int:0
Record crypt, AES256-CBC, 1.0, SHA-384, short tag
depends_on:4:9:3:7:8
20:exp:43:exp:38:int:0:int:1:exp:22:int:0:int:0
Record crypt, AES256-CBC, 1.0, SHA-384, short tag, EtM
depends_on:4:9:3:7:8:20
20:exp:43:exp:38:int:1:int:1:exp:22:int:0:int:0
Record crypt, AES256-CBC, 1.0, SHA-256
depends_on:4:9:3:13
20:exp:43:exp:39:int:0:int:0:exp:22:int:0:int:0
Record crypt, AES256-CBC, 1.0, SHA-256, EtM
depends_on:4:9:3:13:20
20:exp:43:exp:39:int:1:int:0:exp:22:int:0:int:0
Record crypt, AES256-CBC, 1.0, SHA-256, short tag
depends_on:4:9:3:13
20:exp:43:exp:39:int:0:int:1:exp:22:int:0:int:0
Record crypt, AES256-CBC, 1.0, SHA-256, short tag, EtM
depends_on:4:9:3:13:20
20:exp:43:exp:39:int:1:int:1:exp:22:int:0:int:0
Record crypt, AES256-CBC, 1.0, SHA-1
depends_on:4:9:3:21
20:exp:43:exp:40:int:0:int:0:exp:22:int:0:int:0
Record crypt, AES256-CBC, 1.0, SHA-1, EtM
depends_on:4:9:3:21:20
20:exp:43:exp:40:int:1:int:0:exp:22:int:0:int:0
Record crypt, AES256-CBC, 1.0, SHA-1, short tag
depends_on:4:9:3:21
20:exp:43:exp:40:int:0:int:1:exp:22:int:0:int:0
Record crypt, AES256-CBC, 1.0, SHA-1, short tag, EtM
depends_on:4:9:3:21:20
20:exp:43:exp:40:int:1:int:1:exp:22:int:0:int:0
Record crypt, AES256-CBC, 1.0, MD5
depends_on:4:9:3:22
20:exp:43:exp:41:int:0:int:0:exp:22:int:0:int:0
Record crypt, AES256-CBC, 1.0, MD5, EtM
depends_on:4:9:3:22:20
20:exp:43:exp:41:int:1:int:0:exp:22:int:0:int:0
Record crypt, AES256-CBC, 1.0, MD5, short tag
depends_on:4:9:3:22
20:exp:43:exp:41:int:0:int:1:exp:22:int:0:int:0
Record crypt, AES256-CBC, 1.0, MD5, short tag, EtM
depends_on:4:9:3:22:20
20:exp:43:exp:41:int:1:int:1:exp:22:int:0:int:0
Record crypt, AES256-CBC, SSL3, SHA-1
depends_on:4:9:0:21
20:exp:43:exp:40:int:0:int:0:exp:21:int:0:int:0
Record crypt, AES256-CBC, SSL3, SHA-1, EtM
depends_on:4:9:0:21:20
20:exp:43:exp:40:int:1:int:0:exp:21:int:0:int:0
Record crypt, AES256-CBC, SSL3, SHA-1, short tag
depends_on:4:9:0:21
20:exp:43:exp:40:int:0:int:1:exp:21:int:0:int:0
Record crypt, AES256-CBC, SSL3, SHA-1, short tag, EtM
depends_on:4:9:0:21:20
20:exp:43:exp:40:int:1:int:1:exp:21:int:0:int:0
Record crypt, AES256-CBC, SSL3, MD5
depends_on:4:9:0:22
20:exp:43:exp:41:int:0:int:0:exp:21:int:0:int:0
Record crypt, AES256-CBC, SSL3, MD5, EtM
depends_on:4:9:0:22:20
20:exp:43:exp:41:int:1:int:0:exp:21:int:0:int:0
Record crypt, AES256-CBC, SSL3, MD5, short tag
depends_on:4:9:0:22
20:exp:43:exp:41:int:0:int:1:exp:21:int:0:int:0
Record crypt, AES256-CBC, SSL3, MD5, short tag, EtM
depends_on:4:9:0:22:20
20:exp:43:exp:41:int:1:int:1:exp:21:int:0:int:0
Record crypt, ARIA-128-CBC, 1.2, SHA-384
depends_on:4:23:6:7:8
20:exp:44:exp:38:int:0:int:0:exp:24:int:0:int:0
Record crypt, ARIA-128-CBC, 1.2, SHA-384, CID 4+4
depends_on:19:4:23:6:7:8
20:exp:44:exp:38:int:0:int:0:exp:24:int:4:int:4
Record crypt, ARIA-128-CBC, 1.2, SHA-384, CID 4+0
depends_on:19:4:23:6:7:8
20:exp:44:exp:38:int:0:int:0:exp:24:int:4:int:0
Record crypt, ARIA-128-CBC, 1.2, SHA-384, EtM
depends_on:4:23:6:7:8:20
20:exp:44:exp:38:int:1:int:0:exp:24:int:0:int:0
Record crypt, ARIA-128-CBC, 1.2, SHA-384, EtM, CID 4+4
depends_on:19:4:23:6:7:8:20
20:exp:44:exp:38:int:1:int:0:exp:24:int:4:int:4
Record crypt, ARIA-128-CBC, 1.2, SHA-384, EtM, CID 4+0
depends_on:19:4:23:6:7:8:20
20:exp:44:exp:38:int:1:int:0:exp:24:int:4:int:0
Record crypt, ARIA-128-CBC, 1.2, SHA-384, short tag
depends_on:4:23:6:7:8
20:exp:44:exp:38:int:0:int:1:exp:24:int:0:int:0
Record crypt, ARIA-128-CBC, 1.2, SHA-384, short tag, CID 4+4
depends_on:19:4:23:6:7:8
20:exp:44:exp:38:int:0:int:1:exp:24:int:4:int:4
Record crypt, ARIA-128-CBC, 1.2, SHA-384, short tag, CID 4+0
depends_on:19:4:23:6:7:8
20:exp:44:exp:38:int:0:int:1:exp:24:int:4:int:0
Record crypt, ARIA-128-CBC, 1.2, SHA-384, short tag, EtM
depends_on:4:23:6:7:8:20
20:exp:44:exp:38:int:1:int:1:exp:24:int:0:int:0
Record crypt, ARIA-128-CBC, 1.2, SHA-384, short tag, EtM, CID 4+4
depends_on:19:4:23:6:7:8:20
20:exp:44:exp:38:int:1:int:1:exp:24:int:4:int:4
Record crypt, ARIA-128-CBC, 1.2, SHA-384, short tag, EtM, CID 4+0
depends_on:19:4:23:6:7:8:20
20:exp:44:exp:38:int:1:int:1:exp:24:int:4:int:0
Record crypt, ARIA-128-CBC, 1.2, SHA-256
depends_on:4:23:6:13
20:exp:44:exp:39:int:0:int:0:exp:24:int:0:int:0
Record crypt, ARIA-128-CBC, 1.2, SHA-256, CID 4+4
depends_on:19:4:23:6:13
20:exp:44:exp:39:int:0:int:0:exp:24:int:4:int:4
Record crypt, ARIA-128-CBC, 1.2, SHA-256, CID 4+0
depends_on:19:4:23:6:13
20:exp:44:exp:39:int:0:int:0:exp:24:int:4:int:0
Record crypt, ARIA-128-CBC, 1.2, SHA-256, EtM
depends_on:4:23:6:13:20
20:exp:44:exp:39:int:1:int:0:exp:24:int:0:int:0
Record crypt, ARIA-128-CBC, 1.2, SHA-256, EtM, CID 4+4
depends_on:19:4:23:6:13:20
20:exp:44:exp:39:int:1:int:0:exp:24:int:4:int:4
Record crypt, ARIA-128-CBC, 1.2, SHA-256, EtM, CID 4+0
depends_on:19:4:23:6:13:20
20:exp:44:exp:39:int:1:int:0:exp:24:int:4:int:0
Record crypt, ARIA-128-CBC, 1.2, SHA-256, short tag
depends_on:4:23:6:13
20:exp:44:exp:39:int:0:int:1:exp:24:int:0:int:0
Record crypt, ARIA-128-CBC, 1.2, SHA-256, short tag, CID 4+4
depends_on:19:4:23:6:13
20:exp:44:exp:39:int:0:int:1:exp:24:int:4:int:4
Record crypt, ARIA-128-CBC, 1.2, SHA-256, short tag, CID 4+0
depends_on:19:4:23:6:13
20:exp:44:exp:39:int:0:int:1:exp:24:int:4:int:0
Record crypt, ARIA-128-CBC, 1.2, SHA-256, short tag, EtM
depends_on:4:23:6:13:20
20:exp:44:exp:39:int:1:int:1:exp:24:int:0:int:0
Record crypt, ARIA-128-CBC, 1.2, SHA-256, short tag, EtM, CID 4+4
depends_on:19:4:23:6:13:20
20:exp:44:exp:39:int:1:int:1:exp:24:int:4:int:4
Record crypt, ARIA-128-CBC, 1.2, SHA-256, short tag, EtM, CID 4+0
depends_on:19:4:23:6:13:20
20:exp:44:exp:39:int:1:int:1:exp:24:int:4:int:0
Record crypt, ARIA-128-CBC, 1.2, SHA-1
depends_on:4:23:6:21
20:exp:44:exp:40:int:0:int:0:exp:24:int:0:int:0
Record crypt, ARIA-128-CBC, 1.2, SHA-1, CID 4+4
depends_on:19:4:23:6:21
20:exp:44:exp:40:int:0:int:0:exp:24:int:4:int:4
Record crypt, ARIA-128-CBC, 1.2, SHA-1, CID 4+0
depends_on:19:4:23:6:21
20:exp:44:exp:40:int:0:int:0:exp:24:int:4:int:0
Record crypt, ARIA-128-CBC, 1.2, SHA-1, EtM
depends_on:4:23:6:21:20
20:exp:44:exp:40:int:1:int:0:exp:24:int:0:int:0
Record crypt, ARIA-128-CBC, 1.2, SHA-1, EtM, CID 4+4
depends_on:19:4:23:6:21:20
20:exp:44:exp:40:int:1:int:0:exp:24:int:4:int:4
Record crypt, ARIA-128-CBC, 1.2, SHA-1, EtM, CID 4+0
depends_on:19:4:23:6:21:20
20:exp:44:exp:40:int:1:int:0:exp:24:int:4:int:0
Record crypt, ARIA-128-CBC, 1.2, SHA-1, short tag
depends_on:4:23:6:21
20:exp:44:exp:40:int:0:int:1:exp:24:int:0:int:0
Record crypt, ARIA-128-CBC, 1.2, SHA-1, short tag, CID 4+4
depends_on:19:4:23:6:21
20:exp:44:exp:40:int:0:int:1:exp:24:int:4:int:4
Record crypt, ARIA-128-CBC, 1.2, SHA-1, short tag, CID 4+0
depends_on:19:4:23:6:21
20:exp:44:exp:40:int:0:int:1:exp:24:int:4:int:0
Record crypt, ARIA-128-CBC, 1.2, SHA-1, short tag, EtM
depends_on:4:23:6:21:20
20:exp:44:exp:40:int:1:int:1:exp:24:int:0:int:0
Record crypt, ARIA-128-CBC, 1.2, SHA-1, short tag, EtM, CID 4+4
depends_on:19:4:23:6:21:20
20:exp:44:exp:40:int:1:int:1:exp:24:int:4:int:4
Record crypt, ARIA-128-CBC, 1.2, SHA-1, short tag, EtM, CID 4+0
depends_on:19:4:23:6:21:20
20:exp:44:exp:40:int:1:int:1:exp:24:int:4:int:0
Record crypt, ARIA-128-CBC, 1.2, MD5
depends_on:4:23:6:22
20:exp:44:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, ARIA-128-CBC, 1.2, MD5, CID 4+4
depends_on:19:4:23:6:22
20:exp:44:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, ARIA-128-CBC, 1.2, MD5, CID 4+0
depends_on:19:4:23:6:22
20:exp:44:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, ARIA-128-CBC, 1.2, MD5, EtM
depends_on:4:23:6:22:20
20:exp:44:exp:41:int:1:int:0:exp:24:int:0:int:0
Record crypt, ARIA-128-CBC, 1.2, MD5, EtM, CID 4+4
depends_on:19:4:23:6:22:20
20:exp:44:exp:41:int:1:int:0:exp:24:int:4:int:4
Record crypt, ARIA-128-CBC, 1.2, MD5, EtM, CID 4+0
depends_on:19:4:23:6:22:20
20:exp:44:exp:41:int:1:int:0:exp:24:int:4:int:0
Record crypt, ARIA-128-CBC, 1.2, MD5, short tag
depends_on:4:23:6:22
20:exp:44:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, ARIA-128-CBC, 1.2, MD5, short tag, CID 4+4
depends_on:19:4:23:6:22
20:exp:44:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, ARIA-128-CBC, 1.2, MD5, short tag, CID 4+0
depends_on:19:4:23:6:22
20:exp:44:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, ARIA-128-CBC, 1.2, MD5, short tag, EtM
depends_on:4:23:6:22:20
20:exp:44:exp:41:int:1:int:1:exp:24:int:0:int:0
Record crypt, ARIA-128-CBC, 1.2, MD5, short tag, EtM, CID 4+4
depends_on:19:4:23:6:22:20
20:exp:44:exp:41:int:1:int:1:exp:24:int:4:int:4
Record crypt, ARIA-128-CBC, 1.2, MD5, short tag, EtM, CID 4+0
depends_on:19:4:23:6:22:20
20:exp:44:exp:41:int:1:int:1:exp:24:int:4:int:0
Record crypt, ARIA-128-CBC, 1.1, SHA-384
depends_on:4:23:5:7:8
20:exp:44:exp:38:int:0:int:0:exp:23:int:0:int:0
Record crypt, ARIA-128-CBC, 1.1, SHA-384, EtM
depends_on:4:23:5:7:8:20
20:exp:44:exp:38:int:1:int:0:exp:23:int:0:int:0
Record crypt, ARIA-128-CBC, 1.1, SHA-384, short tag
depends_on:4:23:5:7:8
20:exp:44:exp:38:int:0:int:1:exp:23:int:0:int:0
Record crypt, ARIA-128-CBC, 1.1, SHA-384, short tag, EtM
depends_on:4:23:5:7:8:20
20:exp:44:exp:38:int:1:int:1:exp:23:int:0:int:0
Record crypt, ARIA-128-CBC, 1.1, SHA-256
depends_on:4:23:5:13
20:exp:44:exp:39:int:0:int:0:exp:23:int:0:int:0
Record crypt, ARIA-128-CBC, 1.1, SHA-256, EtM
depends_on:4:23:5:13:20
20:exp:44:exp:39:int:1:int:0:exp:23:int:0:int:0
Record crypt, ARIA-128-CBC, 1.1, SHA-256, short tag
depends_on:4:23:5:13
20:exp:44:exp:39:int:0:int:1:exp:23:int:0:int:0
Record crypt, ARIA-128-CBC, 1.1, SHA-256, short tag, EtM
depends_on:4:23:5:13:20
20:exp:44:exp:39:int:1:int:1:exp:23:int:0:int:0
Record crypt, ARIA-128-CBC, 1.1, SHA-1
depends_on:4:23:5:21
20:exp:44:exp:40:int:0:int:0:exp:23:int:0:int:0
Record crypt, ARIA-128-CBC, 1.1, SHA-1, EtM
depends_on:4:23:5:21:20
20:exp:44:exp:40:int:1:int:0:exp:23:int:0:int:0
Record crypt, ARIA-128-CBC, 1.1, SHA-1, short tag
depends_on:4:23:5:21
20:exp:44:exp:40:int:0:int:1:exp:23:int:0:int:0
Record crypt, ARIA-128-CBC, 1.1, SHA-1, short tag, EtM
depends_on:4:23:5:21:20
20:exp:44:exp:40:int:1:int:1:exp:23:int:0:int:0
Record crypt, ARIA-128-CBC, 1.1, MD5
depends_on:4:23:5:22
20:exp:44:exp:41:int:0:int:0:exp:23:int:0:int:0
Record crypt, ARIA-128-CBC, 1.1, MD5, EtM
depends_on:4:23:5:22:20
20:exp:44:exp:41:int:1:int:0:exp:23:int:0:int:0
Record crypt, ARIA-128-CBC, 1.1, MD5, short tag
depends_on:4:23:5:22
20:exp:44:exp:41:int:0:int:1:exp:23:int:0:int:0
Record crypt, ARIA-128-CBC, 1.1, MD5, short tag, EtM
depends_on:4:23:5:22:20
20:exp:44:exp:41:int:1:int:1:exp:23:int:0:int:0
Record crypt, ARIA-128-CBC, 1.0, SHA-384
depends_on:4:23:3:7:8
20:exp:44:exp:38:int:0:int:0:exp:22:int:0:int:0
Record crypt, ARIA-128-CBC, 1.0, SHA-384, EtM
depends_on:4:23:3:7:8:20
20:exp:44:exp:38:int:1:int:0:exp:22:int:0:int:0
Record crypt, ARIA-128-CBC, 1.0, SHA-384, short tag
depends_on:4:23:3:7:8
20:exp:44:exp:38:int:0:int:1:exp:22:int:0:int:0
Record crypt, ARIA-128-CBC, 1.0, SHA-384, short tag, EtM
depends_on:4:23:3:7:8:20
20:exp:44:exp:38:int:1:int:1:exp:22:int:0:int:0
Record crypt, ARIA-128-CBC, 1.0, SHA-256
depends_on:4:23:3:13
20:exp:44:exp:39:int:0:int:0:exp:22:int:0:int:0
Record crypt, ARIA-128-CBC, 1.0, SHA-256, EtM
depends_on:4:23:3:13:20
20:exp:44:exp:39:int:1:int:0:exp:22:int:0:int:0
Record crypt, ARIA-128-CBC, 1.0, SHA-256, short tag
depends_on:4:23:3:13
20:exp:44:exp:39:int:0:int:1:exp:22:int:0:int:0
Record crypt, ARIA-128-CBC, 1.0, SHA-256, short tag, EtM
depends_on:4:23:3:13:20
20:exp:44:exp:39:int:1:int:1:exp:22:int:0:int:0
Record crypt, ARIA-128-CBC, 1.0, SHA-1
depends_on:4:23:3:21
20:exp:44:exp:40:int:0:int:0:exp:22:int:0:int:0
Record crypt, ARIA-128-CBC, 1.0, SHA-1, EtM
depends_on:4:23:3:21:20
20:exp:44:exp:40:int:1:int:0:exp:22:int:0:int:0
Record crypt, ARIA-128-CBC, 1.0, SHA-1, short tag
depends_on:4:23:3:21
20:exp:44:exp:40:int:0:int:1:exp:22:int:0:int:0
Record crypt, ARIA-128-CBC, 1.0, SHA-1, short tag, EtM
depends_on:4:23:3:21:20
20:exp:44:exp:40:int:1:int:1:exp:22:int:0:int:0
Record crypt, ARIA-128-CBC, 1.0, MD5
depends_on:4:23:3:22
20:exp:44:exp:41:int:0:int:0:exp:22:int:0:int:0
Record crypt, ARIA-128-CBC, 1.0, MD5, EtM
depends_on:4:23:3:22:20
20:exp:44:exp:41:int:1:int:0:exp:22:int:0:int:0
Record crypt, ARIA-128-CBC, 1.0, MD5, short tag
depends_on:4:23:3:22
20:exp:44:exp:41:int:0:int:1:exp:22:int:0:int:0
Record crypt, ARIA-128-CBC, 1.0, MD5, short tag, EtM
depends_on:4:23:3:22:20
20:exp:44:exp:41:int:1:int:1:exp:22:int:0:int:0
Record crypt, ARIA-128-CBC, SSL3, SHA-1
depends_on:4:23:0:21
20:exp:44:exp:40:int:0:int:0:exp:21:int:0:int:0
Record crypt, ARIA-128-CBC, SSL3, SHA-1, EtM
depends_on:4:23:0:21:20
20:exp:44:exp:40:int:1:int:0:exp:21:int:0:int:0
Record crypt, ARIA-128-CBC, SSL3, SHA-1, short tag
depends_on:4:23:0:21
20:exp:44:exp:40:int:0:int:1:exp:21:int:0:int:0
Record crypt, ARIA-128-CBC, SSL3, SHA-1, short tag, EtM
depends_on:4:23:0:21:20
20:exp:44:exp:40:int:1:int:1:exp:21:int:0:int:0
Record crypt, ARIA-128-CBC, SSL3, MD5
depends_on:4:23:0:22
20:exp:44:exp:41:int:0:int:0:exp:21:int:0:int:0
Record crypt, ARIA-128-CBC, SSL3, MD5, EtM
depends_on:4:23:0:22:20
20:exp:44:exp:41:int:1:int:0:exp:21:int:0:int:0
Record crypt, ARIA-128-CBC, SSL3, MD5, short tag
depends_on:4:23:0:22
20:exp:44:exp:41:int:0:int:1:exp:21:int:0:int:0
Record crypt, ARIA-128-CBC, SSL3, MD5, short tag, EtM
depends_on:4:23:0:22:20
20:exp:44:exp:41:int:1:int:1:exp:21:int:0:int:0
Record crypt, ARIA-192-CBC, 1.2, SHA-384
depends_on:4:23:6:7:8
20:exp:45:exp:38:int:0:int:0:exp:24:int:0:int:0
Record crypt, ARIA-192-CBC, 1.2, SHA-384, CID 4+4
depends_on:19:4:23:6:7:8
20:exp:45:exp:38:int:0:int:0:exp:24:int:4:int:4
Record crypt, ARIA-192-CBC, 1.2, SHA-384, CID 4+0
depends_on:19:4:23:6:7:8
20:exp:45:exp:38:int:0:int:0:exp:24:int:4:int:0
Record crypt, ARIA-192-CBC, 1.2, SHA-384, EtM
depends_on:4:23:6:7:8:20
20:exp:45:exp:38:int:1:int:0:exp:24:int:0:int:0
Record crypt, ARIA-192-CBC, 1.2, SHA-384, EtM, CID 4+4
depends_on:19:4:23:6:7:8:20
20:exp:45:exp:38:int:1:int:0:exp:24:int:4:int:4
Record crypt, ARIA-192-CBC, 1.2, SHA-384, EtM, CID 4+0
depends_on:19:4:23:6:7:8:20
20:exp:45:exp:38:int:1:int:0:exp:24:int:4:int:0
Record crypt, ARIA-192-CBC, 1.2, SHA-384, short tag
depends_on:4:23:6:7:8
20:exp:45:exp:38:int:0:int:1:exp:24:int:0:int:0
Record crypt, ARIA-192-CBC, 1.2, SHA-384, short tag, CID 4+4
depends_on:19:4:23:6:7:8
20:exp:45:exp:38:int:0:int:1:exp:24:int:4:int:4
Record crypt, ARIA-192-CBC, 1.2, SHA-384, short tag, CID 4+0
depends_on:19:4:23:6:7:8
20:exp:45:exp:38:int:0:int:1:exp:24:int:4:int:0
Record crypt, ARIA-192-CBC, 1.2, SHA-384, short tag, EtM
depends_on:4:23:6:7:8:20
20:exp:45:exp:38:int:1:int:1:exp:24:int:0:int:0
Record crypt, ARIA-192-CBC, 1.2, SHA-384, short tag, EtM, CID 4+4
depends_on:19:4:23:6:7:8:20
20:exp:45:exp:38:int:1:int:1:exp:24:int:4:int:4
Record crypt, ARIA-192-CBC, 1.2, SHA-384, short tag, EtM, CID 4+0
depends_on:19:4:23:6:7:8:20
20:exp:45:exp:38:int:1:int:1:exp:24:int:4:int:0
Record crypt, ARIA-192-CBC, 1.2, SHA-256
depends_on:4:23:6:13
20:exp:45:exp:39:int:0:int:0:exp:24:int:0:int:0
Record crypt, ARIA-192-CBC, 1.2, SHA-256, CID 4+4
depends_on:19:4:23:6:13
20:exp:45:exp:39:int:0:int:0:exp:24:int:4:int:4
Record crypt, ARIA-192-CBC, 1.2, SHA-256, CID 4+0
depends_on:19:4:23:6:13
20:exp:45:exp:39:int:0:int:0:exp:24:int:4:int:0
Record crypt, ARIA-192-CBC, 1.2, SHA-256, EtM
depends_on:4:23:6:13:20
20:exp:45:exp:39:int:1:int:0:exp:24:int:0:int:0
Record crypt, ARIA-192-CBC, 1.2, SHA-256, EtM, CID 4+4
depends_on:19:4:23:6:13:20
20:exp:45:exp:39:int:1:int:0:exp:24:int:4:int:4
Record crypt, ARIA-192-CBC, 1.2, SHA-256, EtM, CID 4+0
depends_on:19:4:23:6:13:20
20:exp:45:exp:39:int:1:int:0:exp:24:int:4:int:0
Record crypt, ARIA-192-CBC, 1.2, SHA-256, short tag
depends_on:4:23:6:13
20:exp:45:exp:39:int:0:int:1:exp:24:int:0:int:0
Record crypt, ARIA-192-CBC, 1.2, SHA-256, short tag, CID 4+4
depends_on:19:4:23:6:13
20:exp:45:exp:39:int:0:int:1:exp:24:int:4:int:4
Record crypt, ARIA-192-CBC, 1.2, SHA-256, short tag, CID 4+0
depends_on:19:4:23:6:13
20:exp:45:exp:39:int:0:int:1:exp:24:int:4:int:0
Record crypt, ARIA-192-CBC, 1.2, SHA-256, short tag, EtM
depends_on:4:23:6:13:20
20:exp:45:exp:39:int:1:int:1:exp:24:int:0:int:0
Record crypt, ARIA-192-CBC, 1.2, SHA-256, short tag, EtM, CID 4+4
depends_on:19:4:23:6:13:20
20:exp:45:exp:39:int:1:int:1:exp:24:int:4:int:4
Record crypt, ARIA-192-CBC, 1.2, SHA-256, short tag, EtM, CID 4+0
depends_on:19:4:23:6:13:20
20:exp:45:exp:39:int:1:int:1:exp:24:int:4:int:0
Record crypt, ARIA-192-CBC, 1.2, SHA-1
depends_on:4:23:6:21
20:exp:45:exp:40:int:0:int:0:exp:24:int:0:int:0
Record crypt, ARIA-192-CBC, 1.2, SHA-1, CID 4+4
depends_on:19:4:23:6:21
20:exp:45:exp:40:int:0:int:0:exp:24:int:4:int:4
Record crypt, ARIA-192-CBC, 1.2, SHA-1, CID 4+0
depends_on:19:4:23:6:21
20:exp:45:exp:40:int:0:int:0:exp:24:int:4:int:0
Record crypt, ARIA-192-CBC, 1.2, SHA-1, EtM
depends_on:4:23:6:21:20
20:exp:45:exp:40:int:1:int:0:exp:24:int:0:int:0
Record crypt, ARIA-192-CBC, 1.2, SHA-1, EtM, CID 4+4
depends_on:19:4:23:6:21:20
20:exp:45:exp:40:int:1:int:0:exp:24:int:4:int:4
Record crypt, ARIA-192-CBC, 1.2, SHA-1, EtM, CID 4+0
depends_on:19:4:23:6:21:20
20:exp:45:exp:40:int:1:int:0:exp:24:int:4:int:0
Record crypt, ARIA-192-CBC, 1.2, SHA-1, short tag
depends_on:4:23:6:21
20:exp:45:exp:40:int:0:int:1:exp:24:int:0:int:0
Record crypt, ARIA-192-CBC, 1.2, SHA-1, short tag, CID 4+4
depends_on:19:4:23:6:21
20:exp:45:exp:40:int:0:int:1:exp:24:int:4:int:4
Record crypt, ARIA-192-CBC, 1.2, SHA-1, short tag, CID 4+0
depends_on:19:4:23:6:21
20:exp:45:exp:40:int:0:int:1:exp:24:int:4:int:0
Record crypt, ARIA-192-CBC, 1.2, SHA-1, short tag, EtM
depends_on:4:23:6:21:20
20:exp:45:exp:40:int:1:int:1:exp:24:int:0:int:0
Record crypt, ARIA-192-CBC, 1.2, SHA-1, short tag, EtM, CID 4+4
depends_on:19:4:23:6:21:20
20:exp:45:exp:40:int:1:int:1:exp:24:int:4:int:4
Record crypt, ARIA-192-CBC, 1.2, SHA-1, short tag, EtM, CID 4+0
depends_on:19:4:23:6:21:20
20:exp:45:exp:40:int:1:int:1:exp:24:int:4:int:0
Record crypt, ARIA-192-CBC, 1.2, MD5
depends_on:4:23:6:22
20:exp:45:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, ARIA-192-CBC, 1.2, MD5, CID 4+4
depends_on:19:4:23:6:22
20:exp:45:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, ARIA-192-CBC, 1.2, MD5, CID 4+0
depends_on:19:4:23:6:22
20:exp:45:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, ARIA-192-CBC, 1.2, MD5, EtM
depends_on:4:23:6:22:20
20:exp:45:exp:41:int:1:int:0:exp:24:int:0:int:0
Record crypt, ARIA-192-CBC, 1.2, MD5, EtM, CID 4+4
depends_on:19:4:23:6:22:20
20:exp:45:exp:41:int:1:int:0:exp:24:int:4:int:4
Record crypt, ARIA-192-CBC, 1.2, MD5, EtM, CID 4+0
depends_on:19:4:23:6:22:20
20:exp:45:exp:41:int:1:int:0:exp:24:int:4:int:0
Record crypt, ARIA-192-CBC, 1.2, MD5, short tag
depends_on:4:23:6:22
20:exp:45:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, ARIA-192-CBC, 1.2, MD5, short tag, CID 4+4
depends_on:19:4:23:6:22
20:exp:45:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, ARIA-192-CBC, 1.2, MD5, short tag, CID 4+0
depends_on:19:4:23:6:22
20:exp:45:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, ARIA-192-CBC, 1.2, MD5, short tag, EtM
depends_on:4:23:6:22:20
20:exp:45:exp:41:int:1:int:1:exp:24:int:0:int:0
Record crypt, ARIA-192-CBC, 1.2, MD5, short tag, EtM, CID 4+4
depends_on:19:4:23:6:22:20
20:exp:45:exp:41:int:1:int:1:exp:24:int:4:int:4
Record crypt, ARIA-192-CBC, 1.2, MD5, short tag, EtM, CID 4+0
depends_on:19:4:23:6:22:20
20:exp:45:exp:41:int:1:int:1:exp:24:int:4:int:0
Record crypt, ARIA-192-CBC, 1.1, SHA-384
depends_on:4:23:5:7:8
20:exp:45:exp:38:int:0:int:0:exp:23:int:0:int:0
Record crypt, ARIA-192-CBC, 1.1, SHA-384, EtM
depends_on:4:23:5:7:8:20
20:exp:45:exp:38:int:1:int:0:exp:23:int:0:int:0
Record crypt, ARIA-192-CBC, 1.1, SHA-384, short tag
depends_on:4:23:5:7:8
20:exp:45:exp:38:int:0:int:1:exp:23:int:0:int:0
Record crypt, ARIA-192-CBC, 1.1, SHA-384, short tag, EtM
depends_on:4:23:5:7:8:20
20:exp:45:exp:38:int:1:int:1:exp:23:int:0:int:0
Record crypt, ARIA-192-CBC, 1.1, SHA-256
depends_on:4:23:5:13
20:exp:45:exp:39:int:0:int:0:exp:23:int:0:int:0
Record crypt, ARIA-192-CBC, 1.1, SHA-256, EtM
depends_on:4:23:5:13:20
20:exp:45:exp:39:int:1:int:0:exp:23:int:0:int:0
Record crypt, ARIA-192-CBC, 1.1, SHA-256, short tag
depends_on:4:23:5:13
20:exp:45:exp:39:int:0:int:1:exp:23:int:0:int:0
Record crypt, ARIA-192-CBC, 1.1, SHA-256, short tag, EtM
depends_on:4:23:5:13:20
20:exp:45:exp:39:int:1:int:1:exp:23:int:0:int:0
Record crypt, ARIA-192-CBC, 1.1, SHA-1
depends_on:4:23:5:21
20:exp:45:exp:40:int:0:int:0:exp:23:int:0:int:0
Record crypt, ARIA-192-CBC, 1.1, SHA-1, EtM
depends_on:4:23:5:21:20
20:exp:45:exp:40:int:1:int:0:exp:23:int:0:int:0
Record crypt, ARIA-192-CBC, 1.1, SHA-1, short tag
depends_on:4:23:5:21
20:exp:45:exp:40:int:0:int:1:exp:23:int:0:int:0
Record crypt, ARIA-192-CBC, 1.1, SHA-1, short tag, EtM
depends_on:4:23:5:21:20
20:exp:45:exp:40:int:1:int:1:exp:23:int:0:int:0
Record crypt, ARIA-192-CBC, 1.1, MD5
depends_on:4:23:5:22
20:exp:45:exp:41:int:0:int:0:exp:23:int:0:int:0
Record crypt, ARIA-192-CBC, 1.1, MD5, EtM
depends_on:4:23:5:22:20
20:exp:45:exp:41:int:1:int:0:exp:23:int:0:int:0
Record crypt, ARIA-192-CBC, 1.1, MD5, short tag
depends_on:4:23:5:22
20:exp:45:exp:41:int:0:int:1:exp:23:int:0:int:0
Record crypt, ARIA-192-CBC, 1.1, MD5, short tag, EtM
depends_on:4:23:5:22:20
20:exp:45:exp:41:int:1:int:1:exp:23:int:0:int:0
Record crypt, ARIA-192-CBC, 1.0, SHA-384
depends_on:4:23:3:7:8
20:exp:45:exp:38:int:0:int:0:exp:22:int:0:int:0
Record crypt, ARIA-192-CBC, 1.0, SHA-384, EtM
depends_on:4:23:3:7:8:20
20:exp:45:exp:38:int:1:int:0:exp:22:int:0:int:0
Record crypt, ARIA-192-CBC, 1.0, SHA-384, short tag
depends_on:4:23:3:7:8
20:exp:45:exp:38:int:0:int:1:exp:22:int:0:int:0
Record crypt, ARIA-192-CBC, 1.0, SHA-384, short tag, EtM
depends_on:4:23:3:7:8:20
20:exp:45:exp:38:int:1:int:1:exp:22:int:0:int:0
Record crypt, ARIA-192-CBC, 1.0, SHA-256
depends_on:4:23:3:13
20:exp:45:exp:39:int:0:int:0:exp:22:int:0:int:0
Record crypt, ARIA-192-CBC, 1.0, SHA-256, EtM
depends_on:4:23:3:13:20
20:exp:45:exp:39:int:1:int:0:exp:22:int:0:int:0
Record crypt, ARIA-192-CBC, 1.0, SHA-256, short tag
depends_on:4:23:3:13
20:exp:45:exp:39:int:0:int:1:exp:22:int:0:int:0
Record crypt, ARIA-192-CBC, 1.0, SHA-256, short tag, EtM
depends_on:4:23:3:13:20
20:exp:45:exp:39:int:1:int:1:exp:22:int:0:int:0
Record crypt, ARIA-192-CBC, 1.0, SHA-1
depends_on:4:23:3:21
20:exp:45:exp:40:int:0:int:0:exp:22:int:0:int:0
Record crypt, ARIA-192-CBC, 1.0, SHA-1, EtM
depends_on:4:23:3:21:20
20:exp:45:exp:40:int:1:int:0:exp:22:int:0:int:0
Record crypt, ARIA-192-CBC, 1.0, SHA-1, short tag
depends_on:4:23:3:21
20:exp:45:exp:40:int:0:int:1:exp:22:int:0:int:0
Record crypt, ARIA-192-CBC, 1.0, SHA-1, short tag, EtM
depends_on:4:23:3:21:20
20:exp:45:exp:40:int:1:int:1:exp:22:int:0:int:0
Record crypt, ARIA-192-CBC, 1.0, MD5
depends_on:4:23:3:22
20:exp:45:exp:41:int:0:int:0:exp:22:int:0:int:0
Record crypt, ARIA-192-CBC, 1.0, MD5, EtM
depends_on:4:23:3:22:20
20:exp:45:exp:41:int:1:int:0:exp:22:int:0:int:0
Record crypt, ARIA-192-CBC, 1.0, MD5, short tag
depends_on:4:23:3:22
20:exp:45:exp:41:int:0:int:1:exp:22:int:0:int:0
Record crypt, ARIA-192-CBC, 1.0, MD5, short tag, EtM
depends_on:4:23:3:22:20
20:exp:45:exp:41:int:1:int:1:exp:22:int:0:int:0
Record crypt, ARIA-192-CBC, SSL3, SHA-1
depends_on:4:23:0:21
20:exp:45:exp:40:int:0:int:0:exp:21:int:0:int:0
Record crypt, ARIA-192-CBC, SSL3, SHA-1, EtM
depends_on:4:23:0:21:20
20:exp:45:exp:40:int:1:int:0:exp:21:int:0:int:0
Record crypt, ARIA-192-CBC, SSL3, SHA-1, short tag
depends_on:4:23:0:21
20:exp:45:exp:40:int:0:int:1:exp:21:int:0:int:0
Record crypt, ARIA-192-CBC, SSL3, SHA-1, short tag, EtM
depends_on:4:23:0:21:20
20:exp:45:exp:40:int:1:int:1:exp:21:int:0:int:0
Record crypt, ARIA-192-CBC, SSL3, MD5
depends_on:4:23:0:22
20:exp:45:exp:41:int:0:int:0:exp:21:int:0:int:0
Record crypt, ARIA-192-CBC, SSL3, MD5, EtM
depends_on:4:23:0:22:20
20:exp:45:exp:41:int:1:int:0:exp:21:int:0:int:0
Record crypt, ARIA-192-CBC, SSL3, MD5, short tag
depends_on:4:23:0:22
20:exp:45:exp:41:int:0:int:1:exp:21:int:0:int:0
Record crypt, ARIA-192-CBC, SSL3, MD5, short tag, EtM
depends_on:4:23:0:22:20
20:exp:45:exp:41:int:1:int:1:exp:21:int:0:int:0
Record crypt, ARIA-256-CBC, 1.2, SHA-384
depends_on:4:23:6:7:8
20:exp:46:exp:38:int:0:int:0:exp:24:int:0:int:0
Record crypt, ARIA-256-CBC, 1.2, SHA-384, CID 4+4
depends_on:19:4:23:6:7:8
20:exp:46:exp:38:int:0:int:0:exp:24:int:4:int:4
Record crypt, ARIA-256-CBC, 1.2, SHA-384, CID 4+0
depends_on:19:4:23:6:7:8
20:exp:46:exp:38:int:0:int:0:exp:24:int:4:int:0
Record crypt, ARIA-256-CBC, 1.2, SHA-384, EtM
depends_on:4:23:6:7:8:20
20:exp:46:exp:38:int:1:int:0:exp:24:int:0:int:0
Record crypt, ARIA-256-CBC, 1.2, SHA-384, EtM, CID 4+4
depends_on:19:4:23:6:7:8:20
20:exp:46:exp:38:int:1:int:0:exp:24:int:4:int:4
Record crypt, ARIA-256-CBC, 1.2, SHA-384, EtM, CID 4+0
depends_on:19:4:23:6:7:8:20
20:exp:46:exp:38:int:1:int:0:exp:24:int:4:int:0
Record crypt, ARIA-256-CBC, 1.2, SHA-384, short tag
depends_on:4:23:6:7:8
20:exp:46:exp:38:int:0:int:1:exp:24:int:0:int:0
Record crypt, ARIA-256-CBC, 1.2, SHA-384, short tag, CID 4+4
depends_on:19:4:23:6:7:8
20:exp:46:exp:38:int:0:int:1:exp:24:int:4:int:4
Record crypt, ARIA-256-CBC, 1.2, SHA-384, short tag, CID 4+0
depends_on:19:4:23:6:7:8
20:exp:46:exp:38:int:0:int:1:exp:24:int:4:int:0
Record crypt, ARIA-256-CBC, 1.2, SHA-384, short tag, EtM
depends_on:4:23:6:7:8:20
20:exp:46:exp:38:int:1:int:1:exp:24:int:0:int:0
Record crypt, ARIA-256-CBC, 1.2, SHA-384, short tag, EtM, CID 4+4
depends_on:19:4:23:6:7:8:20
20:exp:46:exp:38:int:1:int:1:exp:24:int:4:int:4
Record crypt, ARIA-256-CBC, 1.2, SHA-384, short tag, EtM, CID 4+0
depends_on:19:4:23:6:7:8:20
20:exp:46:exp:38:int:1:int:1:exp:24:int:4:int:0
Record crypt, ARIA-256-CBC, 1.2, SHA-256
depends_on:4:23:6:13
20:exp:46:exp:39:int:0:int:0:exp:24:int:0:int:0
Record crypt, ARIA-256-CBC, 1.2, SHA-256, CID 4+4
depends_on:19:4:23:6:13
20:exp:46:exp:39:int:0:int:0:exp:24:int:4:int:4
Record crypt, ARIA-256-CBC, 1.2, SHA-256, CID 4+0
depends_on:19:4:23:6:13
20:exp:46:exp:39:int:0:int:0:exp:24:int:4:int:0
Record crypt, ARIA-256-CBC, 1.2, SHA-256, EtM
depends_on:4:23:6:13:20
20:exp:46:exp:39:int:1:int:0:exp:24:int:0:int:0
Record crypt, ARIA-256-CBC, 1.2, SHA-256, EtM, CID 4+4
depends_on:19:4:23:6:13:20
20:exp:46:exp:39:int:1:int:0:exp:24:int:4:int:4
Record crypt, ARIA-256-CBC, 1.2, SHA-256, EtM, CID 4+0
depends_on:19:4:23:6:13:20
20:exp:46:exp:39:int:1:int:0:exp:24:int:4:int:0
Record crypt, ARIA-256-CBC, 1.2, SHA-256, short tag
depends_on:4:23:6:13
20:exp:46:exp:39:int:0:int:1:exp:24:int:0:int:0
Record crypt, ARIA-256-CBC, 1.2, SHA-256, short tag, CID 4+4
depends_on:19:4:23:6:13
20:exp:46:exp:39:int:0:int:1:exp:24:int:4:int:4
Record crypt, ARIA-256-CBC, 1.2, SHA-256, short tag, CID 4+0
depends_on:19:4:23:6:13
20:exp:46:exp:39:int:0:int:1:exp:24:int:4:int:0
Record crypt, ARIA-256-CBC, 1.2, SHA-256, short tag, EtM
depends_on:4:23:6:13:20
20:exp:46:exp:39:int:1:int:1:exp:24:int:0:int:0
Record crypt, ARIA-256-CBC, 1.2, SHA-256, short tag, EtM, CID 4+4
depends_on:19:4:23:6:13:20
20:exp:46:exp:39:int:1:int:1:exp:24:int:4:int:4
Record crypt, ARIA-256-CBC, 1.2, SHA-256, short tag, EtM, CID 4+0
depends_on:19:4:23:6:13:20
20:exp:46:exp:39:int:1:int:1:exp:24:int:4:int:0
Record crypt, ARIA-256-CBC, 1.2, SHA-1
depends_on:4:23:6:21
20:exp:46:exp:40:int:0:int:0:exp:24:int:0:int:0
Record crypt, ARIA-256-CBC, 1.2, SHA-1, CID 4+4
depends_on:19:4:23:6:21
20:exp:46:exp:40:int:0:int:0:exp:24:int:4:int:4
Record crypt, ARIA-256-CBC, 1.2, SHA-1, CID 4+0
depends_on:19:4:23:6:21
20:exp:46:exp:40:int:0:int:0:exp:24:int:4:int:0
Record crypt, ARIA-256-CBC, 1.2, SHA-1, EtM
depends_on:4:23:6:21:20
20:exp:46:exp:40:int:1:int:0:exp:24:int:0:int:0
Record crypt, ARIA-256-CBC, 1.2, SHA-1, EtM, CID 4+4
depends_on:19:4:23:6:21:20
20:exp:46:exp:40:int:1:int:0:exp:24:int:4:int:4
Record crypt, ARIA-256-CBC, 1.2, SHA-1, EtM, CID 4+0
depends_on:19:4:23:6:21:20
20:exp:46:exp:40:int:1:int:0:exp:24:int:4:int:0
Record crypt, ARIA-256-CBC, 1.2, SHA-1, short tag
depends_on:4:23:6:21
20:exp:46:exp:40:int:0:int:1:exp:24:int:0:int:0
Record crypt, ARIA-256-CBC, 1.2, SHA-1, short tag, CID 4+4
depends_on:19:4:23:6:21
20:exp:46:exp:40:int:0:int:1:exp:24:int:4:int:4
Record crypt, ARIA-256-CBC, 1.2, SHA-1, short tag, CID 4+0
depends_on:19:4:23:6:21
20:exp:46:exp:40:int:0:int:1:exp:24:int:4:int:0
Record crypt, ARIA-256-CBC, 1.2, SHA-1, short tag, EtM
depends_on:4:23:6:21:20
20:exp:46:exp:40:int:1:int:1:exp:24:int:0:int:0
Record crypt, ARIA-256-CBC, 1.2, SHA-1, short tag, EtM, CID 4+4
depends_on:19:4:23:6:21:20
20:exp:46:exp:40:int:1:int:1:exp:24:int:4:int:4
Record crypt, ARIA-256-CBC, 1.2, SHA-1, short tag, EtM, CID 4+0
depends_on:19:4:23:6:21:20
20:exp:46:exp:40:int:1:int:1:exp:24:int:4:int:0
Record crypt, ARIA-256-CBC, 1.2, MD5
depends_on:4:23:6:22
20:exp:46:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, ARIA-256-CBC, 1.2, MD5, CID 4+4
depends_on:19:4:23:6:22
20:exp:46:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, ARIA-256-CBC, 1.2, MD5, CID 4+0
depends_on:19:4:23:6:22
20:exp:46:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, ARIA-256-CBC, 1.2, MD5, EtM
depends_on:4:23:6:22:20
20:exp:46:exp:41:int:1:int:0:exp:24:int:0:int:0
Record crypt, ARIA-256-CBC, 1.2, MD5, EtM, CID 4+4
depends_on:19:4:23:6:22:20
20:exp:46:exp:41:int:1:int:0:exp:24:int:4:int:4
Record crypt, ARIA-256-CBC, 1.2, MD5, EtM, CID 4+0
depends_on:19:4:23:6:22:20
20:exp:46:exp:41:int:1:int:0:exp:24:int:4:int:0
Record crypt, ARIA-256-CBC, 1.2, MD5, short tag
depends_on:4:23:6:22
20:exp:46:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, ARIA-256-CBC, 1.2, MD5, short tag, CID 4+4
depends_on:19:4:23:6:22
20:exp:46:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, ARIA-256-CBC, 1.2, MD5, short tag, CID 4+0
depends_on:19:4:23:6:22
20:exp:46:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, ARIA-256-CBC, 1.2, MD5, short tag, EtM
depends_on:4:23:6:22:20
20:exp:46:exp:41:int:1:int:1:exp:24:int:0:int:0
Record crypt, ARIA-256-CBC, 1.2, MD5, short tag, EtM, CID 4+4
depends_on:19:4:23:6:22:20
20:exp:46:exp:41:int:1:int:1:exp:24:int:4:int:4
Record crypt, ARIA-256-CBC, 1.2, MD5, short tag, EtM, CID 4+0
depends_on:19:4:23:6:22:20
20:exp:46:exp:41:int:1:int:1:exp:24:int:4:int:0
Record crypt, ARIA-256-CBC, 1.1, SHA-384
depends_on:4:23:5:7:8
20:exp:46:exp:38:int:0:int:0:exp:23:int:0:int:0
Record crypt, ARIA-256-CBC, 1.1, SHA-384, EtM
depends_on:4:23:5:7:8:20
20:exp:46:exp:38:int:1:int:0:exp:23:int:0:int:0
Record crypt, ARIA-256-CBC, 1.1, SHA-384, short tag
depends_on:4:23:5:7:8
20:exp:46:exp:38:int:0:int:1:exp:23:int:0:int:0
Record crypt, ARIA-256-CBC, 1.1, SHA-384, short tag, EtM
depends_on:4:23:5:7:8:20
20:exp:46:exp:38:int:1:int:1:exp:23:int:0:int:0
Record crypt, ARIA-256-CBC, 1.1, SHA-256
depends_on:4:23:5:13
20:exp:46:exp:39:int:0:int:0:exp:23:int:0:int:0
Record crypt, ARIA-256-CBC, 1.1, SHA-256, EtM
depends_on:4:23:5:13:20
20:exp:46:exp:39:int:1:int:0:exp:23:int:0:int:0
Record crypt, ARIA-256-CBC, 1.1, SHA-256, short tag
depends_on:4:23:5:13
20:exp:46:exp:39:int:0:int:1:exp:23:int:0:int:0
Record crypt, ARIA-256-CBC, 1.1, SHA-256, short tag, EtM
depends_on:4:23:5:13:20
20:exp:46:exp:39:int:1:int:1:exp:23:int:0:int:0
Record crypt, ARIA-256-CBC, 1.1, SHA-1
depends_on:4:23:5:21
20:exp:46:exp:40:int:0:int:0:exp:23:int:0:int:0
Record crypt, ARIA-256-CBC, 1.1, SHA-1, EtM
depends_on:4:23:5:21:20
20:exp:46:exp:40:int:1:int:0:exp:23:int:0:int:0
Record crypt, ARIA-256-CBC, 1.1, SHA-1, short tag
depends_on:4:23:5:21
20:exp:46:exp:40:int:0:int:1:exp:23:int:0:int:0
Record crypt, ARIA-256-CBC, 1.1, SHA-1, short tag, EtM
depends_on:4:23:5:21:20
20:exp:46:exp:40:int:1:int:1:exp:23:int:0:int:0
Record crypt, ARIA-256-CBC, 1.1, MD5
depends_on:4:23:5:22
20:exp:46:exp:41:int:0:int:0:exp:23:int:0:int:0
Record crypt, ARIA-256-CBC, 1.1, MD5, EtM
depends_on:4:23:5:22:20
20:exp:46:exp:41:int:1:int:0:exp:23:int:0:int:0
Record crypt, ARIA-256-CBC, 1.1, MD5, short tag
depends_on:4:23:5:22
20:exp:46:exp:41:int:0:int:1:exp:23:int:0:int:0
Record crypt, ARIA-256-CBC, 1.1, MD5, short tag, EtM
depends_on:4:23:5:22:20
20:exp:46:exp:41:int:1:int:1:exp:23:int:0:int:0
Record crypt, ARIA-256-CBC, 1.0, SHA-384
depends_on:4:23:3:7:8
20:exp:46:exp:38:int:0:int:0:exp:22:int:0:int:0
Record crypt, ARIA-256-CBC, 1.0, SHA-384, EtM
depends_on:4:23:3:7:8:20
20:exp:46:exp:38:int:1:int:0:exp:22:int:0:int:0
Record crypt, ARIA-256-CBC, 1.0, SHA-384, short tag
depends_on:4:23:3:7:8
20:exp:46:exp:38:int:0:int:1:exp:22:int:0:int:0
Record crypt, ARIA-256-CBC, 1.0, SHA-384, short tag, EtM
depends_on:4:23:3:7:8:20
20:exp:46:exp:38:int:1:int:1:exp:22:int:0:int:0
Record crypt, ARIA-256-CBC, 1.0, SHA-256
depends_on:4:23:3:13
20:exp:46:exp:39:int:0:int:0:exp:22:int:0:int:0
Record crypt, ARIA-256-CBC, 1.0, SHA-256, EtM
depends_on:4:23:3:13:20
20:exp:46:exp:39:int:1:int:0:exp:22:int:0:int:0
Record crypt, ARIA-256-CBC, 1.0, SHA-256, short tag
depends_on:4:23:3:13
20:exp:46:exp:39:int:0:int:1:exp:22:int:0:int:0
Record crypt, ARIA-256-CBC, 1.0, SHA-256, short tag, EtM
depends_on:4:23:3:13:20
20:exp:46:exp:39:int:1:int:1:exp:22:int:0:int:0
Record crypt, ARIA-256-CBC, 1.0, SHA-1
depends_on:4:23:3:21
20:exp:46:exp:40:int:0:int:0:exp:22:int:0:int:0
Record crypt, ARIA-256-CBC, 1.0, SHA-1, EtM
depends_on:4:23:3:21:20
20:exp:46:exp:40:int:1:int:0:exp:22:int:0:int:0
Record crypt, ARIA-256-CBC, 1.0, SHA-1, short tag
depends_on:4:23:3:21
20:exp:46:exp:40:int:0:int:1:exp:22:int:0:int:0
Record crypt, ARIA-256-CBC, 1.0, SHA-1, short tag, EtM
depends_on:4:23:3:21:20
20:exp:46:exp:40:int:1:int:1:exp:22:int:0:int:0
Record crypt, ARIA-256-CBC, 1.0, MD5
depends_on:4:23:3:22
20:exp:46:exp:41:int:0:int:0:exp:22:int:0:int:0
Record crypt, ARIA-256-CBC, 1.0, MD5, EtM
depends_on:4:23:3:22:20
20:exp:46:exp:41:int:1:int:0:exp:22:int:0:int:0
Record crypt, ARIA-256-CBC, 1.0, MD5, short tag
depends_on:4:23:3:22
20:exp:46:exp:41:int:0:int:1:exp:22:int:0:int:0
Record crypt, ARIA-256-CBC, 1.0, MD5, short tag, EtM
depends_on:4:23:3:22:20
20:exp:46:exp:41:int:1:int:1:exp:22:int:0:int:0
Record crypt, ARIA-256-CBC, SSL3, SHA-1
depends_on:4:23:0:21
20:exp:46:exp:40:int:0:int:0:exp:21:int:0:int:0
Record crypt, ARIA-256-CBC, SSL3, SHA-1, EtM
depends_on:4:23:0:21:20
20:exp:46:exp:40:int:1:int:0:exp:21:int:0:int:0
Record crypt, ARIA-256-CBC, SSL3, SHA-1, short tag
depends_on:4:23:0:21
20:exp:46:exp:40:int:0:int:1:exp:21:int:0:int:0
Record crypt, ARIA-256-CBC, SSL3, SHA-1, short tag, EtM
depends_on:4:23:0:21:20
20:exp:46:exp:40:int:1:int:1:exp:21:int:0:int:0
Record crypt, ARIA-256-CBC, SSL3, MD5
depends_on:4:23:0:22
20:exp:46:exp:41:int:0:int:0:exp:21:int:0:int:0
Record crypt, ARIA-256-CBC, SSL3, MD5, EtM
depends_on:4:23:0:22:20
20:exp:46:exp:41:int:1:int:0:exp:21:int:0:int:0
Record crypt, ARIA-256-CBC, SSL3, MD5, short tag
depends_on:4:23:0:22
20:exp:46:exp:41:int:0:int:1:exp:21:int:0:int:0
Record crypt, ARIA-256-CBC, SSL3, MD5, short tag, EtM
depends_on:4:23:0:22:20
20:exp:46:exp:41:int:1:int:1:exp:21:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-384
depends_on:4:16:6:7:8
20:exp:47:exp:38:int:0:int:0:exp:24:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-384, CID 4+4
depends_on:19:4:16:6:7:8
20:exp:47:exp:38:int:0:int:0:exp:24:int:4:int:4
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-384, CID 4+0
depends_on:19:4:16:6:7:8
20:exp:47:exp:38:int:0:int:0:exp:24:int:4:int:0
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-384, EtM
depends_on:4:16:6:7:8:20
20:exp:47:exp:38:int:1:int:0:exp:24:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-384, EtM, CID 4+4
depends_on:19:4:16:6:7:8:20
20:exp:47:exp:38:int:1:int:0:exp:24:int:4:int:4
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-384, EtM, CID 4+0
depends_on:19:4:16:6:7:8:20
20:exp:47:exp:38:int:1:int:0:exp:24:int:4:int:0
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-384, short tag
depends_on:4:16:6:7:8
20:exp:47:exp:38:int:0:int:1:exp:24:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-384, short tag, CID 4+4
depends_on:19:4:16:6:7:8
20:exp:47:exp:38:int:0:int:1:exp:24:int:4:int:4
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-384, short tag, CID 4+0
depends_on:19:4:16:6:7:8
20:exp:47:exp:38:int:0:int:1:exp:24:int:4:int:0
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-384, short tag, EtM
depends_on:4:16:6:7:8:20
20:exp:47:exp:38:int:1:int:1:exp:24:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-384, short tag, EtM, CID 4+4
depends_on:19:4:16:6:7:8:20
20:exp:47:exp:38:int:1:int:1:exp:24:int:4:int:4
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-384, short tag, EtM, CID 4+0
depends_on:19:4:16:6:7:8:20
20:exp:47:exp:38:int:1:int:1:exp:24:int:4:int:0
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-256
depends_on:4:16:6:13
20:exp:47:exp:39:int:0:int:0:exp:24:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-256, CID 4+4
depends_on:19:4:16:6:13
20:exp:47:exp:39:int:0:int:0:exp:24:int:4:int:4
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-256, CID 4+0
depends_on:19:4:16:6:13
20:exp:47:exp:39:int:0:int:0:exp:24:int:4:int:0
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-256, EtM
depends_on:4:16:6:13:20
20:exp:47:exp:39:int:1:int:0:exp:24:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-256, EtM, CID 4+4
depends_on:19:4:16:6:13:20
20:exp:47:exp:39:int:1:int:0:exp:24:int:4:int:4
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-256, EtM, CID 4+0
depends_on:19:4:16:6:13:20
20:exp:47:exp:39:int:1:int:0:exp:24:int:4:int:0
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-256, short tag
depends_on:4:16:6:13
20:exp:47:exp:39:int:0:int:1:exp:24:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-256, short tag, CID 4+4
depends_on:19:4:16:6:13
20:exp:47:exp:39:int:0:int:1:exp:24:int:4:int:4
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-256, short tag, CID 4+0
depends_on:19:4:16:6:13
20:exp:47:exp:39:int:0:int:1:exp:24:int:4:int:0
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-256, short tag, EtM
depends_on:4:16:6:13:20
20:exp:47:exp:39:int:1:int:1:exp:24:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-256, short tag, EtM, CID 4+4
depends_on:19:4:16:6:13:20
20:exp:47:exp:39:int:1:int:1:exp:24:int:4:int:4
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-256, short tag, EtM, CID 4+0
depends_on:19:4:16:6:13:20
20:exp:47:exp:39:int:1:int:1:exp:24:int:4:int:0
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-1
depends_on:4:16:6:21
20:exp:47:exp:40:int:0:int:0:exp:24:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-1, CID 4+4
depends_on:19:4:16:6:21
20:exp:47:exp:40:int:0:int:0:exp:24:int:4:int:4
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-1, CID 4+0
depends_on:19:4:16:6:21
20:exp:47:exp:40:int:0:int:0:exp:24:int:4:int:0
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-1, EtM
depends_on:4:16:6:21:20
20:exp:47:exp:40:int:1:int:0:exp:24:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-1, EtM, CID 4+4
depends_on:19:4:16:6:21:20
20:exp:47:exp:40:int:1:int:0:exp:24:int:4:int:4
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-1, EtM, CID 4+0
depends_on:19:4:16:6:21:20
20:exp:47:exp:40:int:1:int:0:exp:24:int:4:int:0
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-1, short tag
depends_on:4:16:6:21
20:exp:47:exp:40:int:0:int:1:exp:24:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-1, short tag, CID 4+4
depends_on:19:4:16:6:21
20:exp:47:exp:40:int:0:int:1:exp:24:int:4:int:4
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-1, short tag, CID 4+0
depends_on:19:4:16:6:21
20:exp:47:exp:40:int:0:int:1:exp:24:int:4:int:0
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-1, short tag, EtM
depends_on:4:16:6:21:20
20:exp:47:exp:40:int:1:int:1:exp:24:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-1, short tag, EtM, CID 4+4
depends_on:19:4:16:6:21:20
20:exp:47:exp:40:int:1:int:1:exp:24:int:4:int:4
Record crypt, CAMELLIA-128-CBC, 1.2, SHA-1, short tag, EtM, CID 4+0
depends_on:19:4:16:6:21:20
20:exp:47:exp:40:int:1:int:1:exp:24:int:4:int:0
Record crypt, CAMELLIA-128-CBC, 1.2, MD5
depends_on:4:16:6:22
20:exp:47:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.2, MD5, CID 4+4
depends_on:19:4:16:6:22
20:exp:47:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, CAMELLIA-128-CBC, 1.2, MD5, CID 4+0
depends_on:19:4:16:6:22
20:exp:47:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, CAMELLIA-128-CBC, 1.2, MD5, EtM
depends_on:4:16:6:22:20
20:exp:47:exp:41:int:1:int:0:exp:24:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.2, MD5, EtM, CID 4+4
depends_on:19:4:16:6:22:20
20:exp:47:exp:41:int:1:int:0:exp:24:int:4:int:4
Record crypt, CAMELLIA-128-CBC, 1.2, MD5, EtM, CID 4+0
depends_on:19:4:16:6:22:20
20:exp:47:exp:41:int:1:int:0:exp:24:int:4:int:0
Record crypt, CAMELLIA-128-CBC, 1.2, MD5, short tag
depends_on:4:16:6:22
20:exp:47:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.2, MD5, short tag, CID 4+4
depends_on:19:4:16:6:22
20:exp:47:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, CAMELLIA-128-CBC, 1.2, MD5, short tag, CID 4+0
depends_on:19:4:16:6:22
20:exp:47:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, CAMELLIA-128-CBC, 1.2, MD5, short tag, EtM
depends_on:4:16:6:22:20
20:exp:47:exp:41:int:1:int:1:exp:24:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.2, MD5, short tag, EtM, CID 4+4
depends_on:19:4:16:6:22:20
20:exp:47:exp:41:int:1:int:1:exp:24:int:4:int:4
Record crypt, CAMELLIA-128-CBC, 1.2, MD5, short tag, EtM, CID 4+0
depends_on:19:4:16:6:22:20
20:exp:47:exp:41:int:1:int:1:exp:24:int:4:int:0
Record crypt, CAMELLIA-128-CBC, 1.1, SHA-384
depends_on:4:16:5:7:8
20:exp:47:exp:38:int:0:int:0:exp:23:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.1, SHA-384, EtM
depends_on:4:16:5:7:8:20
20:exp:47:exp:38:int:1:int:0:exp:23:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.1, SHA-384, short tag
depends_on:4:16:5:7:8
20:exp:47:exp:38:int:0:int:1:exp:23:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.1, SHA-384, short tag, EtM
depends_on:4:16:5:7:8:20
20:exp:47:exp:38:int:1:int:1:exp:23:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.1, SHA-256
depends_on:4:16:5:13
20:exp:47:exp:39:int:0:int:0:exp:23:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.1, SHA-256, EtM
depends_on:4:16:5:13:20
20:exp:47:exp:39:int:1:int:0:exp:23:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.1, SHA-256, short tag
depends_on:4:16:5:13
20:exp:47:exp:39:int:0:int:1:exp:23:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.1, SHA-256, short tag, EtM
depends_on:4:16:5:13:20
20:exp:47:exp:39:int:1:int:1:exp:23:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.1, SHA-1
depends_on:4:16:5:21
20:exp:47:exp:40:int:0:int:0:exp:23:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.1, SHA-1, EtM
depends_on:4:16:5:21:20
20:exp:47:exp:40:int:1:int:0:exp:23:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.1, SHA-1, short tag
depends_on:4:16:5:21
20:exp:47:exp:40:int:0:int:1:exp:23:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.1, SHA-1, short tag, EtM
depends_on:4:16:5:21:20
20:exp:47:exp:40:int:1:int:1:exp:23:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.1, MD5
depends_on:4:16:5:22
20:exp:47:exp:41:int:0:int:0:exp:23:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.1, MD5, EtM
depends_on:4:16:5:22:20
20:exp:47:exp:41:int:1:int:0:exp:23:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.1, MD5, short tag
depends_on:4:16:5:22
20:exp:47:exp:41:int:0:int:1:exp:23:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.1, MD5, short tag, EtM
depends_on:4:16:5:22:20
20:exp:47:exp:41:int:1:int:1:exp:23:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.0, SHA-384
depends_on:4:16:3:7:8
20:exp:47:exp:38:int:0:int:0:exp:22:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.0, SHA-384, EtM
depends_on:4:16:3:7:8:20
20:exp:47:exp:38:int:1:int:0:exp:22:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.0, SHA-384, short tag
depends_on:4:16:3:7:8
20:exp:47:exp:38:int:0:int:1:exp:22:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.0, SHA-384, short tag, EtM
depends_on:4:16:3:7:8:20
20:exp:47:exp:38:int:1:int:1:exp:22:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.0, SHA-256
depends_on:4:16:3:13
20:exp:47:exp:39:int:0:int:0:exp:22:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.0, SHA-256, EtM
depends_on:4:16:3:13:20
20:exp:47:exp:39:int:1:int:0:exp:22:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.0, SHA-256, short tag
depends_on:4:16:3:13
20:exp:47:exp:39:int:0:int:1:exp:22:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.0, SHA-256, short tag, EtM
depends_on:4:16:3:13:20
20:exp:47:exp:39:int:1:int:1:exp:22:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.0, SHA-1
depends_on:4:16:3:21
20:exp:47:exp:40:int:0:int:0:exp:22:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.0, SHA-1, EtM
depends_on:4:16:3:21:20
20:exp:47:exp:40:int:1:int:0:exp:22:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.0, SHA-1, short tag
depends_on:4:16:3:21
20:exp:47:exp:40:int:0:int:1:exp:22:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.0, SHA-1, short tag, EtM
depends_on:4:16:3:21:20
20:exp:47:exp:40:int:1:int:1:exp:22:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.0, MD5
depends_on:4:16:3:22
20:exp:47:exp:41:int:0:int:0:exp:22:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.0, MD5, EtM
depends_on:4:16:3:22:20
20:exp:47:exp:41:int:1:int:0:exp:22:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.0, MD5, short tag
depends_on:4:16:3:22
20:exp:47:exp:41:int:0:int:1:exp:22:int:0:int:0
Record crypt, CAMELLIA-128-CBC, 1.0, MD5, short tag, EtM
depends_on:4:16:3:22:20
20:exp:47:exp:41:int:1:int:1:exp:22:int:0:int:0
Record crypt, CAMELLIA-128-CBC, SSL3, SHA-1
depends_on:4:16:0:21
20:exp:47:exp:40:int:0:int:0:exp:21:int:0:int:0
Record crypt, CAMELLIA-128-CBC, SSL3, SHA-1, EtM
depends_on:4:16:0:21:20
20:exp:47:exp:40:int:1:int:0:exp:21:int:0:int:0
Record crypt, CAMELLIA-128-CBC, SSL3, SHA-1, short tag
depends_on:4:16:0:21
20:exp:47:exp:40:int:0:int:1:exp:21:int:0:int:0
Record crypt, CAMELLIA-128-CBC, SSL3, SHA-1, short tag, EtM
depends_on:4:16:0:21:20
20:exp:47:exp:40:int:1:int:1:exp:21:int:0:int:0
Record crypt, CAMELLIA-128-CBC, SSL3, MD5
depends_on:4:16:0:22
20:exp:47:exp:41:int:0:int:0:exp:21:int:0:int:0
Record crypt, CAMELLIA-128-CBC, SSL3, MD5, EtM
depends_on:4:16:0:22:20
20:exp:47:exp:41:int:1:int:0:exp:21:int:0:int:0
Record crypt, CAMELLIA-128-CBC, SSL3, MD5, short tag
depends_on:4:16:0:22
20:exp:47:exp:41:int:0:int:1:exp:21:int:0:int:0
Record crypt, CAMELLIA-128-CBC, SSL3, MD5, short tag, EtM
depends_on:4:16:0:22:20
20:exp:47:exp:41:int:1:int:1:exp:21:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-384
depends_on:4:16:6:7:8
20:exp:48:exp:38:int:0:int:0:exp:24:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-384, CID 4+4
depends_on:19:4:16:6:7:8
20:exp:48:exp:38:int:0:int:0:exp:24:int:4:int:4
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-384, CID 4+0
depends_on:19:4:16:6:7:8
20:exp:48:exp:38:int:0:int:0:exp:24:int:4:int:0
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-384, EtM
depends_on:4:16:6:7:8:20
20:exp:48:exp:38:int:1:int:0:exp:24:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-384, EtM, CID 4+4
depends_on:19:4:16:6:7:8:20
20:exp:48:exp:38:int:1:int:0:exp:24:int:4:int:4
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-384, EtM, CID 4+0
depends_on:19:4:16:6:7:8:20
20:exp:48:exp:38:int:1:int:0:exp:24:int:4:int:0
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-384, short tag
depends_on:4:16:6:7:8
20:exp:48:exp:38:int:0:int:1:exp:24:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-384, short tag, CID 4+4
depends_on:19:4:16:6:7:8
20:exp:48:exp:38:int:0:int:1:exp:24:int:4:int:4
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-384, short tag, CID 4+0
depends_on:19:4:16:6:7:8
20:exp:48:exp:38:int:0:int:1:exp:24:int:4:int:0
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-384, short tag, EtM
depends_on:4:16:6:7:8:20
20:exp:48:exp:38:int:1:int:1:exp:24:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-384, short tag, EtM, CID 4+4
depends_on:19:4:16:6:7:8:20
20:exp:48:exp:38:int:1:int:1:exp:24:int:4:int:4
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-384, short tag, EtM, CID 4+0
depends_on:19:4:16:6:7:8:20
20:exp:48:exp:38:int:1:int:1:exp:24:int:4:int:0
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-256
depends_on:4:16:6:13
20:exp:48:exp:39:int:0:int:0:exp:24:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-256, CID 4+4
depends_on:19:4:16:6:13
20:exp:48:exp:39:int:0:int:0:exp:24:int:4:int:4
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-256, CID 4+0
depends_on:19:4:16:6:13
20:exp:48:exp:39:int:0:int:0:exp:24:int:4:int:0
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-256, EtM
depends_on:4:16:6:13:20
20:exp:48:exp:39:int:1:int:0:exp:24:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-256, EtM, CID 4+4
depends_on:19:4:16:6:13:20
20:exp:48:exp:39:int:1:int:0:exp:24:int:4:int:4
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-256, EtM, CID 4+0
depends_on:19:4:16:6:13:20
20:exp:48:exp:39:int:1:int:0:exp:24:int:4:int:0
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-256, short tag
depends_on:4:16:6:13
20:exp:48:exp:39:int:0:int:1:exp:24:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-256, short tag, CID 4+4
depends_on:19:4:16:6:13
20:exp:48:exp:39:int:0:int:1:exp:24:int:4:int:4
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-256, short tag, CID 4+0
depends_on:19:4:16:6:13
20:exp:48:exp:39:int:0:int:1:exp:24:int:4:int:0
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-256, short tag, EtM
depends_on:4:16:6:13:20
20:exp:48:exp:39:int:1:int:1:exp:24:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-256, short tag, EtM, CID 4+4
depends_on:19:4:16:6:13:20
20:exp:48:exp:39:int:1:int:1:exp:24:int:4:int:4
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-256, short tag, EtM, CID 4+0
depends_on:19:4:16:6:13:20
20:exp:48:exp:39:int:1:int:1:exp:24:int:4:int:0
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-1
depends_on:4:16:6:21
20:exp:48:exp:40:int:0:int:0:exp:24:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-1, CID 4+4
depends_on:19:4:16:6:21
20:exp:48:exp:40:int:0:int:0:exp:24:int:4:int:4
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-1, CID 4+0
depends_on:19:4:16:6:21
20:exp:48:exp:40:int:0:int:0:exp:24:int:4:int:0
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-1, EtM
depends_on:4:16:6:21:20
20:exp:48:exp:40:int:1:int:0:exp:24:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-1, EtM, CID 4+4
depends_on:19:4:16:6:21:20
20:exp:48:exp:40:int:1:int:0:exp:24:int:4:int:4
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-1, EtM, CID 4+0
depends_on:19:4:16:6:21:20
20:exp:48:exp:40:int:1:int:0:exp:24:int:4:int:0
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-1, short tag
depends_on:4:16:6:21
20:exp:48:exp:40:int:0:int:1:exp:24:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-1, short tag, CID 4+4
depends_on:19:4:16:6:21
20:exp:48:exp:40:int:0:int:1:exp:24:int:4:int:4
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-1, short tag, CID 4+0
depends_on:19:4:16:6:21
20:exp:48:exp:40:int:0:int:1:exp:24:int:4:int:0
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-1, short tag, EtM
depends_on:4:16:6:21:20
20:exp:48:exp:40:int:1:int:1:exp:24:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-1, short tag, EtM, CID 4+4
depends_on:19:4:16:6:21:20
20:exp:48:exp:40:int:1:int:1:exp:24:int:4:int:4
Record crypt, CAMELLIA-192-CBC, 1.2, SHA-1, short tag, EtM, CID 4+0
depends_on:19:4:16:6:21:20
20:exp:48:exp:40:int:1:int:1:exp:24:int:4:int:0
Record crypt, CAMELLIA-192-CBC, 1.2, MD5
depends_on:4:16:6:22
20:exp:48:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.2, MD5, CID 4+4
depends_on:19:4:16:6:22
20:exp:48:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, CAMELLIA-192-CBC, 1.2, MD5, CID 4+0
depends_on:19:4:16:6:22
20:exp:48:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, CAMELLIA-192-CBC, 1.2, MD5, EtM
depends_on:4:16:6:22:20
20:exp:48:exp:41:int:1:int:0:exp:24:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.2, MD5, EtM, CID 4+4
depends_on:19:4:16:6:22:20
20:exp:48:exp:41:int:1:int:0:exp:24:int:4:int:4
Record crypt, CAMELLIA-192-CBC, 1.2, MD5, EtM, CID 4+0
depends_on:19:4:16:6:22:20
20:exp:48:exp:41:int:1:int:0:exp:24:int:4:int:0
Record crypt, CAMELLIA-192-CBC, 1.2, MD5, short tag
depends_on:4:16:6:22
20:exp:48:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.2, MD5, short tag, CID 4+4
depends_on:19:4:16:6:22
20:exp:48:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, CAMELLIA-192-CBC, 1.2, MD5, short tag, CID 4+0
depends_on:19:4:16:6:22
20:exp:48:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, CAMELLIA-192-CBC, 1.2, MD5, short tag, EtM
depends_on:4:16:6:22:20
20:exp:48:exp:41:int:1:int:1:exp:24:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.2, MD5, short tag, EtM, CID 4+4
depends_on:19:4:16:6:22:20
20:exp:48:exp:41:int:1:int:1:exp:24:int:4:int:4
Record crypt, CAMELLIA-192-CBC, 1.2, MD5, short tag, EtM, CID 4+0
depends_on:19:4:16:6:22:20
20:exp:48:exp:41:int:1:int:1:exp:24:int:4:int:0
Record crypt, CAMELLIA-192-CBC, 1.1, SHA-384
depends_on:4:16:5:7:8
20:exp:48:exp:38:int:0:int:0:exp:23:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.1, SHA-384, EtM
depends_on:4:16:5:7:8:20
20:exp:48:exp:38:int:1:int:0:exp:23:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.1, SHA-384, short tag
depends_on:4:16:5:7:8
20:exp:48:exp:38:int:0:int:1:exp:23:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.1, SHA-384, short tag, EtM
depends_on:4:16:5:7:8:20
20:exp:48:exp:38:int:1:int:1:exp:23:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.1, SHA-256
depends_on:4:16:5:13
20:exp:48:exp:39:int:0:int:0:exp:23:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.1, SHA-256, EtM
depends_on:4:16:5:13:20
20:exp:48:exp:39:int:1:int:0:exp:23:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.1, SHA-256, short tag
depends_on:4:16:5:13
20:exp:48:exp:39:int:0:int:1:exp:23:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.1, SHA-256, short tag, EtM
depends_on:4:16:5:13:20
20:exp:48:exp:39:int:1:int:1:exp:23:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.1, SHA-1
depends_on:4:16:5:21
20:exp:48:exp:40:int:0:int:0:exp:23:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.1, SHA-1, EtM
depends_on:4:16:5:21:20
20:exp:48:exp:40:int:1:int:0:exp:23:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.1, SHA-1, short tag
depends_on:4:16:5:21
20:exp:48:exp:40:int:0:int:1:exp:23:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.1, SHA-1, short tag, EtM
depends_on:4:16:5:21:20
20:exp:48:exp:40:int:1:int:1:exp:23:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.1, MD5
depends_on:4:16:5:22
20:exp:48:exp:41:int:0:int:0:exp:23:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.1, MD5, EtM
depends_on:4:16:5:22:20
20:exp:48:exp:41:int:1:int:0:exp:23:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.1, MD5, short tag
depends_on:4:16:5:22
20:exp:48:exp:41:int:0:int:1:exp:23:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.1, MD5, short tag, EtM
depends_on:4:16:5:22:20
20:exp:48:exp:41:int:1:int:1:exp:23:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.0, SHA-384
depends_on:4:16:3:7:8
20:exp:48:exp:38:int:0:int:0:exp:22:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.0, SHA-384, EtM
depends_on:4:16:3:7:8:20
20:exp:48:exp:38:int:1:int:0:exp:22:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.0, SHA-384, short tag
depends_on:4:16:3:7:8
20:exp:48:exp:38:int:0:int:1:exp:22:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.0, SHA-384, short tag, EtM
depends_on:4:16:3:7:8:20
20:exp:48:exp:38:int:1:int:1:exp:22:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.0, SHA-256
depends_on:4:16:3:13
20:exp:48:exp:39:int:0:int:0:exp:22:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.0, SHA-256, EtM
depends_on:4:16:3:13:20
20:exp:48:exp:39:int:1:int:0:exp:22:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.0, SHA-256, short tag
depends_on:4:16:3:13
20:exp:48:exp:39:int:0:int:1:exp:22:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.0, SHA-256, short tag, EtM
depends_on:4:16:3:13:20
20:exp:48:exp:39:int:1:int:1:exp:22:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.0, SHA-1
depends_on:4:16:3:21
20:exp:48:exp:40:int:0:int:0:exp:22:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.0, SHA-1, EtM
depends_on:4:16:3:21:20
20:exp:48:exp:40:int:1:int:0:exp:22:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.0, SHA-1, short tag
depends_on:4:16:3:21
20:exp:48:exp:40:int:0:int:1:exp:22:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.0, SHA-1, short tag, EtM
depends_on:4:16:3:21:20
20:exp:48:exp:40:int:1:int:1:exp:22:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.0, MD5
depends_on:4:16:3:22
20:exp:48:exp:41:int:0:int:0:exp:22:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.0, MD5, EtM
depends_on:4:16:3:22:20
20:exp:48:exp:41:int:1:int:0:exp:22:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.0, MD5, short tag
depends_on:4:16:3:22
20:exp:48:exp:41:int:0:int:1:exp:22:int:0:int:0
Record crypt, CAMELLIA-192-CBC, 1.0, MD5, short tag, EtM
depends_on:4:16:3:22:20
20:exp:48:exp:41:int:1:int:1:exp:22:int:0:int:0
Record crypt, CAMELLIA-192-CBC, SSL3, SHA-1
depends_on:4:16:0:21
20:exp:48:exp:40:int:0:int:0:exp:21:int:0:int:0
Record crypt, CAMELLIA-192-CBC, SSL3, SHA-1, EtM
depends_on:4:16:0:21:20
20:exp:48:exp:40:int:1:int:0:exp:21:int:0:int:0
Record crypt, CAMELLIA-192-CBC, SSL3, SHA-1, short tag
depends_on:4:16:0:21
20:exp:48:exp:40:int:0:int:1:exp:21:int:0:int:0
Record crypt, CAMELLIA-192-CBC, SSL3, SHA-1, short tag, EtM
depends_on:4:16:0:21:20
20:exp:48:exp:40:int:1:int:1:exp:21:int:0:int:0
Record crypt, CAMELLIA-192-CBC, SSL3, MD5
depends_on:4:16:0:22
20:exp:48:exp:41:int:0:int:0:exp:21:int:0:int:0
Record crypt, CAMELLIA-192-CBC, SSL3, MD5, EtM
depends_on:4:16:0:22:20
20:exp:48:exp:41:int:1:int:0:exp:21:int:0:int:0
Record crypt, CAMELLIA-192-CBC, SSL3, MD5, short tag
depends_on:4:16:0:22
20:exp:48:exp:41:int:0:int:1:exp:21:int:0:int:0
Record crypt, CAMELLIA-192-CBC, SSL3, MD5, short tag, EtM
depends_on:4:16:0:22:20
20:exp:48:exp:41:int:1:int:1:exp:21:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-384
depends_on:4:16:6:7:8
20:exp:49:exp:38:int:0:int:0:exp:24:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-384, CID 4+4
depends_on:19:4:16:6:7:8
20:exp:49:exp:38:int:0:int:0:exp:24:int:4:int:4
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-384, CID 4+0
depends_on:19:4:16:6:7:8
20:exp:49:exp:38:int:0:int:0:exp:24:int:4:int:0
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-384, EtM
depends_on:4:16:6:7:8:20
20:exp:49:exp:38:int:1:int:0:exp:24:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-384, EtM, CID 4+4
depends_on:19:4:16:6:7:8:20
20:exp:49:exp:38:int:1:int:0:exp:24:int:4:int:4
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-384, EtM, CID 4+0
depends_on:19:4:16:6:7:8:20
20:exp:49:exp:38:int:1:int:0:exp:24:int:4:int:0
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-384, short tag
depends_on:4:16:6:7:8
20:exp:49:exp:38:int:0:int:1:exp:24:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-384, short tag, CID 4+4
depends_on:19:4:16:6:7:8
20:exp:49:exp:38:int:0:int:1:exp:24:int:4:int:4
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-384, short tag, CID 4+0
depends_on:19:4:16:6:7:8
20:exp:49:exp:38:int:0:int:1:exp:24:int:4:int:0
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-384, short tag, EtM
depends_on:4:16:6:7:8:20
20:exp:49:exp:38:int:1:int:1:exp:24:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-384, short tag, EtM, CID 4+4
depends_on:19:4:16:6:7:8:20
20:exp:49:exp:38:int:1:int:1:exp:24:int:4:int:4
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-384, short tag, EtM, CID 4+0
depends_on:19:4:16:6:7:8:20
20:exp:49:exp:38:int:1:int:1:exp:24:int:4:int:0
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-256
depends_on:4:16:6:13
20:exp:49:exp:39:int:0:int:0:exp:24:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-256, CID 4+4
depends_on:19:4:16:6:13
20:exp:49:exp:39:int:0:int:0:exp:24:int:4:int:4
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-256, CID 4+0
depends_on:19:4:16:6:13
20:exp:49:exp:39:int:0:int:0:exp:24:int:4:int:0
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-256, EtM
depends_on:4:16:6:13:20
20:exp:49:exp:39:int:1:int:0:exp:24:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-256, EtM, CID 4+4
depends_on:19:4:16:6:13:20
20:exp:49:exp:39:int:1:int:0:exp:24:int:4:int:4
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-256, EtM, CID 4+0
depends_on:19:4:16:6:13:20
20:exp:49:exp:39:int:1:int:0:exp:24:int:4:int:0
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-256, short tag
depends_on:4:16:6:13
20:exp:49:exp:39:int:0:int:1:exp:24:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-256, short tag, CID 4+4
depends_on:19:4:16:6:13
20:exp:49:exp:39:int:0:int:1:exp:24:int:4:int:4
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-256, short tag, CID 4+0
depends_on:19:4:16:6:13
20:exp:49:exp:39:int:0:int:1:exp:24:int:4:int:0
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-256, short tag, EtM
depends_on:4:16:6:13:20
20:exp:49:exp:39:int:1:int:1:exp:24:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-256, short tag, EtM, CID 4+4
depends_on:19:4:16:6:13:20
20:exp:49:exp:39:int:1:int:1:exp:24:int:4:int:4
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-256, short tag, EtM, CID 4+0
depends_on:19:4:16:6:13:20
20:exp:49:exp:39:int:1:int:1:exp:24:int:4:int:0
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-1
depends_on:4:16:6:21
20:exp:49:exp:40:int:0:int:0:exp:24:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-1, CID 4+4
depends_on:19:4:16:6:21
20:exp:49:exp:40:int:0:int:0:exp:24:int:4:int:4
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-1, CID 4+0
depends_on:19:4:16:6:21
20:exp:49:exp:40:int:0:int:0:exp:24:int:4:int:0
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-1, EtM
depends_on:4:16:6:21:20
20:exp:49:exp:40:int:1:int:0:exp:24:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-1, EtM, CID 4+4
depends_on:19:4:16:6:21:20
20:exp:49:exp:40:int:1:int:0:exp:24:int:4:int:4
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-1, EtM, CID 4+0
depends_on:19:4:16:6:21:20
20:exp:49:exp:40:int:1:int:0:exp:24:int:4:int:0
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-1, short tag
depends_on:4:16:6:21
20:exp:49:exp:40:int:0:int:1:exp:24:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-1, short tag, CID 4+4
depends_on:19:4:16:6:21
20:exp:49:exp:40:int:0:int:1:exp:24:int:4:int:4
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-1, short tag, CID 4+0
depends_on:19:4:16:6:21
20:exp:49:exp:40:int:0:int:1:exp:24:int:4:int:0
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-1, short tag, EtM
depends_on:4:16:6:21:20
20:exp:49:exp:40:int:1:int:1:exp:24:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-1, short tag, EtM, CID 4+4
depends_on:19:4:16:6:21:20
20:exp:49:exp:40:int:1:int:1:exp:24:int:4:int:4
Record crypt, CAMELLIA-256-CBC, 1.2, SHA-1, short tag, EtM, CID 4+0
depends_on:19:4:16:6:21:20
20:exp:49:exp:40:int:1:int:1:exp:24:int:4:int:0
Record crypt, CAMELLIA-256-CBC, 1.2, MD5
depends_on:4:16:6:22
20:exp:49:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.2, MD5, CID 4+4
depends_on:19:4:16:6:22
20:exp:49:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, CAMELLIA-256-CBC, 1.2, MD5, CID 4+0
depends_on:19:4:16:6:22
20:exp:49:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, CAMELLIA-256-CBC, 1.2, MD5, EtM
depends_on:4:16:6:22:20
20:exp:49:exp:41:int:1:int:0:exp:24:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.2, MD5, EtM, CID 4+4
depends_on:19:4:16:6:22:20
20:exp:49:exp:41:int:1:int:0:exp:24:int:4:int:4
Record crypt, CAMELLIA-256-CBC, 1.2, MD5, EtM, CID 4+0
depends_on:19:4:16:6:22:20
20:exp:49:exp:41:int:1:int:0:exp:24:int:4:int:0
Record crypt, CAMELLIA-256-CBC, 1.2, MD5, short tag
depends_on:4:16:6:22
20:exp:49:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.2, MD5, short tag, CID 4+4
depends_on:19:4:16:6:22
20:exp:49:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, CAMELLIA-256-CBC, 1.2, MD5, short tag, CID 4+0
depends_on:19:4:16:6:22
20:exp:49:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, CAMELLIA-256-CBC, 1.2, MD5, short tag, EtM
depends_on:4:16:6:22:20
20:exp:49:exp:41:int:1:int:1:exp:24:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.2, MD5, short tag, EtM, CID 4+4
depends_on:19:4:16:6:22:20
20:exp:49:exp:41:int:1:int:1:exp:24:int:4:int:4
Record crypt, CAMELLIA-256-CBC, 1.2, MD5, short tag, EtM, CID 4+0
depends_on:19:4:16:6:22:20
20:exp:49:exp:41:int:1:int:1:exp:24:int:4:int:0
Record crypt, CAMELLIA-256-CBC, 1.1, SHA-384
depends_on:4:16:5:7:8
20:exp:49:exp:38:int:0:int:0:exp:23:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.1, SHA-384, EtM
depends_on:4:16:5:7:8:20
20:exp:49:exp:38:int:1:int:0:exp:23:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.1, SHA-384, short tag
depends_on:4:16:5:7:8
20:exp:49:exp:38:int:0:int:1:exp:23:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.1, SHA-384, short tag, EtM
depends_on:4:16:5:7:8:20
20:exp:49:exp:38:int:1:int:1:exp:23:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.1, SHA-256
depends_on:4:16:5:13
20:exp:49:exp:39:int:0:int:0:exp:23:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.1, SHA-256, EtM
depends_on:4:16:5:13:20
20:exp:49:exp:39:int:1:int:0:exp:23:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.1, SHA-256, short tag
depends_on:4:16:5:13
20:exp:49:exp:39:int:0:int:1:exp:23:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.1, SHA-256, short tag, EtM
depends_on:4:16:5:13:20
20:exp:49:exp:39:int:1:int:1:exp:23:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.1, SHA-1
depends_on:4:16:5:21
20:exp:49:exp:40:int:0:int:0:exp:23:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.1, SHA-1, EtM
depends_on:4:16:5:21:20
20:exp:49:exp:40:int:1:int:0:exp:23:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.1, SHA-1, short tag
depends_on:4:16:5:21
20:exp:49:exp:40:int:0:int:1:exp:23:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.1, SHA-1, short tag, EtM
depends_on:4:16:5:21:20
20:exp:49:exp:40:int:1:int:1:exp:23:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.1, MD5
depends_on:4:16:5:22
20:exp:49:exp:41:int:0:int:0:exp:23:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.1, MD5, EtM
depends_on:4:16:5:22:20
20:exp:49:exp:41:int:1:int:0:exp:23:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.1, MD5, short tag
depends_on:4:16:5:22
20:exp:49:exp:41:int:0:int:1:exp:23:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.1, MD5, short tag, EtM
depends_on:4:16:5:22:20
20:exp:49:exp:41:int:1:int:1:exp:23:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.0, SHA-384
depends_on:4:16:3:7:8
20:exp:49:exp:38:int:0:int:0:exp:22:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.0, SHA-384, EtM
depends_on:4:16:3:7:8:20
20:exp:49:exp:38:int:1:int:0:exp:22:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.0, SHA-384, short tag
depends_on:4:16:3:7:8
20:exp:49:exp:38:int:0:int:1:exp:22:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.0, SHA-384, short tag, EtM
depends_on:4:16:3:7:8:20
20:exp:49:exp:38:int:1:int:1:exp:22:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.0, SHA-256
depends_on:4:16:3:13
20:exp:49:exp:39:int:0:int:0:exp:22:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.0, SHA-256, EtM
depends_on:4:16:3:13:20
20:exp:49:exp:39:int:1:int:0:exp:22:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.0, SHA-256, short tag
depends_on:4:16:3:13
20:exp:49:exp:39:int:0:int:1:exp:22:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.0, SHA-256, short tag, EtM
depends_on:4:16:3:13:20
20:exp:49:exp:39:int:1:int:1:exp:22:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.0, SHA-1
depends_on:4:16:3:21
20:exp:49:exp:40:int:0:int:0:exp:22:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.0, SHA-1, EtM
depends_on:4:16:3:21:20
20:exp:49:exp:40:int:1:int:0:exp:22:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.0, SHA-1, short tag
depends_on:4:16:3:21
20:exp:49:exp:40:int:0:int:1:exp:22:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.0, SHA-1, short tag, EtM
depends_on:4:16:3:21:20
20:exp:49:exp:40:int:1:int:1:exp:22:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.0, MD5
depends_on:4:16:3:22
20:exp:49:exp:41:int:0:int:0:exp:22:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.0, MD5, EtM
depends_on:4:16:3:22:20
20:exp:49:exp:41:int:1:int:0:exp:22:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.0, MD5, short tag
depends_on:4:16:3:22
20:exp:49:exp:41:int:0:int:1:exp:22:int:0:int:0
Record crypt, CAMELLIA-256-CBC, 1.0, MD5, short tag, EtM
depends_on:4:16:3:22:20
20:exp:49:exp:41:int:1:int:1:exp:22:int:0:int:0
Record crypt, CAMELLIA-256-CBC, SSL3, SHA-1
depends_on:4:16:0:21
20:exp:49:exp:40:int:0:int:0:exp:21:int:0:int:0
Record crypt, CAMELLIA-256-CBC, SSL3, SHA-1, EtM
depends_on:4:16:0:21:20
20:exp:49:exp:40:int:1:int:0:exp:21:int:0:int:0
Record crypt, CAMELLIA-256-CBC, SSL3, SHA-1, short tag
depends_on:4:16:0:21
20:exp:49:exp:40:int:0:int:1:exp:21:int:0:int:0
Record crypt, CAMELLIA-256-CBC, SSL3, SHA-1, short tag, EtM
depends_on:4:16:0:21:20
20:exp:49:exp:40:int:1:int:1:exp:21:int:0:int:0
Record crypt, CAMELLIA-256-CBC, SSL3, MD5
depends_on:4:16:0:22
20:exp:49:exp:41:int:0:int:0:exp:21:int:0:int:0
Record crypt, CAMELLIA-256-CBC, SSL3, MD5, EtM
depends_on:4:16:0:22:20
20:exp:49:exp:41:int:1:int:0:exp:21:int:0:int:0
Record crypt, CAMELLIA-256-CBC, SSL3, MD5, short tag
depends_on:4:16:0:22
20:exp:49:exp:41:int:0:int:1:exp:21:int:0:int:0
Record crypt, CAMELLIA-256-CBC, SSL3, MD5, short tag, EtM
depends_on:4:16:0:22:20
20:exp:49:exp:41:int:1:int:1:exp:21:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.2, SHA-384
depends_on:4:24:6:7:8
20:exp:50:exp:38:int:0:int:0:exp:24:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.2, SHA-384, CID 4+4
depends_on:19:4:24:6:7:8
20:exp:50:exp:38:int:0:int:0:exp:24:int:4:int:4
Record crypt, BLOWFISH-CBC, 1.2, SHA-384, CID 4+0
depends_on:19:4:24:6:7:8
20:exp:50:exp:38:int:0:int:0:exp:24:int:4:int:0
Record crypt, BLOWFISH-CBC, 1.2, SHA-384, EtM
depends_on:4:24:6:7:8:20
20:exp:50:exp:38:int:1:int:0:exp:24:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.2, SHA-384, EtM, CID 4+4
depends_on:19:4:24:6:7:8:20
20:exp:50:exp:38:int:1:int:0:exp:24:int:4:int:4
Record crypt, BLOWFISH-CBC, 1.2, SHA-384, EtM, CID 4+0
depends_on:19:4:24:6:7:8:20
20:exp:50:exp:38:int:1:int:0:exp:24:int:4:int:0
Record crypt, BLOWFISH-CBC, 1.2, SHA-384, short tag
depends_on:4:24:6:7:8
20:exp:50:exp:38:int:0:int:1:exp:24:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.2, SHA-384, short tag, CID 4+4
depends_on:19:4:24:6:7:8
20:exp:50:exp:38:int:0:int:1:exp:24:int:4:int:4
Record crypt, BLOWFISH-CBC, 1.2, SHA-384, short tag, CID 4+0
depends_on:19:4:24:6:7:8
20:exp:50:exp:38:int:0:int:1:exp:24:int:4:int:0
Record crypt, BLOWFISH-CBC, 1.2, SHA-384, short tag, EtM
depends_on:4:24:6:7:8:20
20:exp:50:exp:38:int:1:int:1:exp:24:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.2, SHA-384, short tag, EtM, CID 4+4
depends_on:19:4:24:6:7:8:20
20:exp:50:exp:38:int:1:int:1:exp:24:int:4:int:4
Record crypt, BLOWFISH-CBC, 1.2, SHA-384, short tag, EtM, CID 4+0
depends_on:19:4:24:6:7:8:20
20:exp:50:exp:38:int:1:int:1:exp:24:int:4:int:0
Record crypt, BLOWFISH-CBC, 1.2, SHA-256
depends_on:4:24:6:13
20:exp:50:exp:39:int:0:int:0:exp:24:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.2, SHA-256, CID 4+4
depends_on:19:4:24:6:13
20:exp:50:exp:39:int:0:int:0:exp:24:int:4:int:4
Record crypt, BLOWFISH-CBC, 1.2, SHA-256, CID 4+0
depends_on:19:4:24:6:13
20:exp:50:exp:39:int:0:int:0:exp:24:int:4:int:0
Record crypt, BLOWFISH-CBC, 1.2, SHA-256, EtM
depends_on:4:24:6:13:20
20:exp:50:exp:39:int:1:int:0:exp:24:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.2, SHA-256, EtM, CID 4+4
depends_on:19:4:24:6:13:20
20:exp:50:exp:39:int:1:int:0:exp:24:int:4:int:4
Record crypt, BLOWFISH-CBC, 1.2, SHA-256, EtM, CID 4+0
depends_on:19:4:24:6:13:20
20:exp:50:exp:39:int:1:int:0:exp:24:int:4:int:0
Record crypt, BLOWFISH-CBC, 1.2, SHA-256, short tag
depends_on:4:24:6:13
20:exp:50:exp:39:int:0:int:1:exp:24:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.2, SHA-256, short tag, CID 4+4
depends_on:19:4:24:6:13
20:exp:50:exp:39:int:0:int:1:exp:24:int:4:int:4
Record crypt, BLOWFISH-CBC, 1.2, SHA-256, short tag, CID 4+0
depends_on:19:4:24:6:13
20:exp:50:exp:39:int:0:int:1:exp:24:int:4:int:0
Record crypt, BLOWFISH-CBC, 1.2, SHA-256, short tag, EtM
depends_on:4:24:6:13:20
20:exp:50:exp:39:int:1:int:1:exp:24:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.2, SHA-256, short tag, EtM, CID 4+4
depends_on:19:4:24:6:13:20
20:exp:50:exp:39:int:1:int:1:exp:24:int:4:int:4
Record crypt, BLOWFISH-CBC, 1.2, SHA-256, short tag, EtM, CID 4+0
depends_on:19:4:24:6:13:20
20:exp:50:exp:39:int:1:int:1:exp:24:int:4:int:0
Record crypt, BLOWFISH-CBC, 1.2, SHA-1
depends_on:4:24:6:21
20:exp:50:exp:40:int:0:int:0:exp:24:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.2, SHA-1, CID 4+4
depends_on:19:4:24:6:21
20:exp:50:exp:40:int:0:int:0:exp:24:int:4:int:4
Record crypt, BLOWFISH-CBC, 1.2, SHA-1, CID 4+0
depends_on:19:4:24:6:21
20:exp:50:exp:40:int:0:int:0:exp:24:int:4:int:0
Record crypt, BLOWFISH-CBC, 1.2, SHA-1, EtM
depends_on:4:24:6:21:20
20:exp:50:exp:40:int:1:int:0:exp:24:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.2, SHA-1, EtM, CID 4+4
depends_on:19:4:24:6:21:20
20:exp:50:exp:40:int:1:int:0:exp:24:int:4:int:4
Record crypt, BLOWFISH-CBC, 1.2, SHA-1, EtM, CID 4+0
depends_on:19:4:24:6:21:20
20:exp:50:exp:40:int:1:int:0:exp:24:int:4:int:0
Record crypt, BLOWFISH-CBC, 1.2, SHA-1, short tag
depends_on:4:24:6:21
20:exp:50:exp:40:int:0:int:1:exp:24:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.2, SHA-1, short tag, CID 4+4
depends_on:19:4:24:6:21
20:exp:50:exp:40:int:0:int:1:exp:24:int:4:int:4
Record crypt, BLOWFISH-CBC, 1.2, SHA-1, short tag, CID 4+0
depends_on:19:4:24:6:21
20:exp:50:exp:40:int:0:int:1:exp:24:int:4:int:0
Record crypt, BLOWFISH-CBC, 1.2, SHA-1, short tag, EtM
depends_on:4:24:6:21:20
20:exp:50:exp:40:int:1:int:1:exp:24:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.2, SHA-1, short tag, EtM, CID 4+4
depends_on:19:4:24:6:21:20
20:exp:50:exp:40:int:1:int:1:exp:24:int:4:int:4
Record crypt, BLOWFISH-CBC, 1.2, SHA-1, short tag, EtM, CID 4+0
depends_on:19:4:24:6:21:20
20:exp:50:exp:40:int:1:int:1:exp:24:int:4:int:0
Record crypt, BLOWFISH-CBC, 1.2, MD5
depends_on:4:24:6:22
20:exp:50:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.2, MD5, CID 4+4
depends_on:19:4:24:6:22
20:exp:50:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, BLOWFISH-CBC, 1.2, MD5, CID 4+0
depends_on:19:4:24:6:22
20:exp:50:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, BLOWFISH-CBC, 1.2, MD5, EtM
depends_on:4:24:6:22:20
20:exp:50:exp:41:int:1:int:0:exp:24:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.2, MD5, EtM, CID 4+4
depends_on:19:4:24:6:22:20
20:exp:50:exp:41:int:1:int:0:exp:24:int:4:int:4
Record crypt, BLOWFISH-CBC, 1.2, MD5, EtM, CID 4+0
depends_on:19:4:24:6:22:20
20:exp:50:exp:41:int:1:int:0:exp:24:int:4:int:0
Record crypt, BLOWFISH-CBC, 1.2, MD5, short tag
depends_on:4:24:6:22
20:exp:50:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.2, MD5, short tag, CID 4+4
depends_on:19:4:24:6:22
20:exp:50:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, BLOWFISH-CBC, 1.2, MD5, short tag, CID 4+0
depends_on:19:4:24:6:22
20:exp:50:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, BLOWFISH-CBC, 1.2, MD5, short tag, EtM
depends_on:4:24:6:22:20
20:exp:50:exp:41:int:1:int:1:exp:24:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.2, MD5, short tag, EtM, CID 4+4
depends_on:19:4:24:6:22:20
20:exp:50:exp:41:int:1:int:1:exp:24:int:4:int:4
Record crypt, BLOWFISH-CBC, 1.2, MD5, short tag, EtM, CID 4+0
depends_on:19:4:24:6:22:20
20:exp:50:exp:41:int:1:int:1:exp:24:int:4:int:0
Record crypt, BLOWFISH-CBC, 1.1, SHA-384
depends_on:4:24:5:7:8
20:exp:50:exp:38:int:0:int:0:exp:23:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.1, SHA-384, EtM
depends_on:4:24:5:7:8:20
20:exp:50:exp:38:int:1:int:0:exp:23:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.1, SHA-384, short tag
depends_on:4:24:5:7:8
20:exp:50:exp:38:int:0:int:1:exp:23:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.1, SHA-384, short tag, EtM
depends_on:4:24:5:7:8:20
20:exp:50:exp:38:int:1:int:1:exp:23:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.1, SHA-256
depends_on:4:24:5:13
20:exp:50:exp:39:int:0:int:0:exp:23:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.1, SHA-256, EtM
depends_on:4:24:5:13:20
20:exp:50:exp:39:int:1:int:0:exp:23:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.1, SHA-256, short tag
depends_on:4:24:5:13
20:exp:50:exp:39:int:0:int:1:exp:23:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.1, SHA-256, short tag, EtM
depends_on:4:24:5:13:20
20:exp:50:exp:39:int:1:int:1:exp:23:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.1, SHA-1
depends_on:4:24:5:21
20:exp:50:exp:40:int:0:int:0:exp:23:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.1, SHA-1, EtM
depends_on:4:24:5:21:20
20:exp:50:exp:40:int:1:int:0:exp:23:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.1, SHA-1, short tag
depends_on:4:24:5:21
20:exp:50:exp:40:int:0:int:1:exp:23:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.1, SHA-1, short tag, EtM
depends_on:4:24:5:21:20
20:exp:50:exp:40:int:1:int:1:exp:23:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.1, MD5
depends_on:4:24:5:22
20:exp:50:exp:41:int:0:int:0:exp:23:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.1, MD5, EtM
depends_on:4:24:5:22:20
20:exp:50:exp:41:int:1:int:0:exp:23:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.1, MD5, short tag
depends_on:4:24:5:22
20:exp:50:exp:41:int:0:int:1:exp:23:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.1, MD5, short tag, EtM
depends_on:4:24:5:22:20
20:exp:50:exp:41:int:1:int:1:exp:23:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.0, SHA-384
depends_on:4:24:3:7:8
20:exp:50:exp:38:int:0:int:0:exp:22:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.0, SHA-384, EtM
depends_on:4:24:3:7:8:20
20:exp:50:exp:38:int:1:int:0:exp:22:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.0, SHA-384, short tag
depends_on:4:24:3:7:8
20:exp:50:exp:38:int:0:int:1:exp:22:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.0, SHA-384, short tag, EtM
depends_on:4:24:3:7:8:20
20:exp:50:exp:38:int:1:int:1:exp:22:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.0, SHA-256
depends_on:4:24:3:13
20:exp:50:exp:39:int:0:int:0:exp:22:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.0, SHA-256, EtM
depends_on:4:24:3:13:20
20:exp:50:exp:39:int:1:int:0:exp:22:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.0, SHA-256, short tag
depends_on:4:24:3:13
20:exp:50:exp:39:int:0:int:1:exp:22:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.0, SHA-256, short tag, EtM
depends_on:4:24:3:13:20
20:exp:50:exp:39:int:1:int:1:exp:22:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.0, SHA-1
depends_on:4:24:3:21
20:exp:50:exp:40:int:0:int:0:exp:22:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.0, SHA-1, EtM
depends_on:4:24:3:21:20
20:exp:50:exp:40:int:1:int:0:exp:22:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.0, SHA-1, short tag
depends_on:4:24:3:21
20:exp:50:exp:40:int:0:int:1:exp:22:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.0, SHA-1, short tag, EtM
depends_on:4:24:3:21:20
20:exp:50:exp:40:int:1:int:1:exp:22:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.0, MD5
depends_on:4:24:3:22
20:exp:50:exp:41:int:0:int:0:exp:22:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.0, MD5, EtM
depends_on:4:24:3:22:20
20:exp:50:exp:41:int:1:int:0:exp:22:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.0, MD5, short tag
depends_on:4:24:3:22
20:exp:50:exp:41:int:0:int:1:exp:22:int:0:int:0
Record crypt, BLOWFISH-CBC, 1.0, MD5, short tag, EtM
depends_on:4:24:3:22:20
20:exp:50:exp:41:int:1:int:1:exp:22:int:0:int:0
Record crypt, BLOWFISH-CBC, SSL3, SHA-1
depends_on:4:24:0:21
20:exp:50:exp:40:int:0:int:0:exp:21:int:0:int:0
Record crypt, BLOWFISH-CBC, SSL3, SHA-1, EtM
depends_on:4:24:0:21:20
20:exp:50:exp:40:int:1:int:0:exp:21:int:0:int:0
Record crypt, BLOWFISH-CBC, SSL3, SHA-1, short tag
depends_on:4:24:0:21
20:exp:50:exp:40:int:0:int:1:exp:21:int:0:int:0
Record crypt, BLOWFISH-CBC, SSL3, SHA-1, short tag, EtM
depends_on:4:24:0:21:20
20:exp:50:exp:40:int:1:int:1:exp:21:int:0:int:0
Record crypt, BLOWFISH-CBC, SSL3, MD5
depends_on:4:24:0:22
20:exp:50:exp:41:int:0:int:0:exp:21:int:0:int:0
Record crypt, BLOWFISH-CBC, SSL3, MD5, EtM
depends_on:4:24:0:22:20
20:exp:50:exp:41:int:1:int:0:exp:21:int:0:int:0
Record crypt, BLOWFISH-CBC, SSL3, MD5, short tag
depends_on:4:24:0:22
20:exp:50:exp:41:int:0:int:1:exp:21:int:0:int:0
Record crypt, BLOWFISH-CBC, SSL3, MD5, short tag, EtM
depends_on:4:24:0:22:20
20:exp:50:exp:41:int:1:int:1:exp:21:int:0:int:0
Record crypt, AES128-GCM, 1.2
depends_on:9:6:10
20:exp:51:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, AES128-GCM, 1.3
depends_on:9:25:10
20:exp:51:exp:41:int:0:int:0:exp:52:int:0:int:0
Record crypt, AES128-GCM, 1.2, CID 4+4
depends_on:19:9:6:10
20:exp:51:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, AES128-GCM, 1.2, CID 4+0
depends_on:19:9:6:10
20:exp:51:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, AES128-GCM, 1.2, short tag
depends_on:9:6:10
20:exp:51:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, AES128-GCM, 1.2, short tag, CID 4+4
depends_on:19:9:6:10
20:exp:51:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, AES128-GCM, 1.2, short tag, CID 4+0
depends_on:19:9:6:10
20:exp:51:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, AES-192-GCM, 1.2
depends_on:9:6:10
20:exp:53:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, AES-192-GCM, 1.3
depends_on:9:25:10
20:exp:53:exp:41:int:0:int:0:exp:52:int:0:int:0
Record crypt, AES-192-GCM, 1.2, CID 4+4
depends_on:19:9:6:10
20:exp:53:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, AES-192-GCM, 1.2, CID 4+0
depends_on:19:9:6:10
20:exp:53:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, AES-192-GCM, 1.2, short tag
depends_on:9:6:10
20:exp:53:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, AES-192-GCM, 1.2, short tag, CID 4+4
depends_on:19:9:6:10
20:exp:53:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, AES-192-GCM, 1.2, short tag, CID 4+0
depends_on:19:9:6:10
20:exp:53:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, AES256-GCM, 1.2
depends_on:9:6:10
20:exp:54:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, AES256-GCM, 1.3
depends_on:9:25:10
20:exp:54:exp:41:int:0:int:0:exp:52:int:0:int:0
Record crypt, AES256-GCM, 1.2, CID 4+4
depends_on:19:9:6:10
20:exp:54:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, AES256-GCM, 1.2, CID 4+0
depends_on:19:9:6:10
20:exp:54:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, AES256-GCM, 1.2, short tag
depends_on:9:6:10
20:exp:54:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, AES256-GCM, 1.2, short tag, CID 4+4
depends_on:19:9:6:10
20:exp:54:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, AES256-GCM, 1.2, short tag, CID 4+0
depends_on:19:9:6:10
20:exp:54:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, CAMELLIA-128-GCM, 1.2
depends_on:16:6:10
20:exp:55:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, CAMELLIA-128-GCM, 1.2, CID 4+4
depends_on:19:16:6:10
20:exp:55:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, CAMELLIA-128-GCM, 1.2, CID 4+0
depends_on:19:16:6:10
20:exp:55:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, CAMELLIA-128-GCM, 1.2, short tag
depends_on:16:6:10
20:exp:55:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, CAMELLIA-128-GCM, 1.2, short tag, CID 4+4
depends_on:19:16:6:10
20:exp:55:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, CAMELLIA-128-GCM, 1.2, short tag, CID 4+0
depends_on:19:16:6:10
20:exp:55:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, CAMELLIA-192-GCM, 1.2
depends_on:16:6:10
20:exp:56:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, CAMELLIA-192-GCM, 1.2, CID 4+4
depends_on:19:16:6:10
20:exp:56:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, CAMELLIA-192-GCM, 1.2, CID 4+0
depends_on:19:16:6:10
20:exp:56:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, CAMELLIA-192-GCM, 1.2, short tag
depends_on:16:6:10
20:exp:56:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, CAMELLIA-192-GCM, 1.2, short tag, CID 4+4
depends_on:19:16:6:10
20:exp:56:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, CAMELLIA-192-GCM, 1.2, short tag, CID 4+0
depends_on:19:16:6:10
20:exp:56:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, CAMELLIA-256-GCM, 1.2
depends_on:16:6:10
20:exp:57:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, CAMELLIA-256-GCM, 1.2, CID 4+4
depends_on:19:16:6:10
20:exp:57:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, CAMELLIA-256-GCM, 1.2, CID 4+0
depends_on:19:16:6:10
20:exp:57:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, CAMELLIA-256-GCM, 1.2, short tag
depends_on:16:6:10
20:exp:57:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, CAMELLIA-256-GCM, 1.2, short tag, CID 4+4
depends_on:19:16:6:10
20:exp:57:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, CAMELLIA-256-GCM, 1.2, short tag, CID 4+0
depends_on:19:16:6:10
20:exp:57:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, AES128-CCM, 1.2
depends_on:9:6:12
20:exp:58:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, AES128-CCM, 1.3
depends_on:9:25:12
20:exp:58:exp:41:int:0:int:0:exp:52:int:0:int:0
Record crypt, AES128-CCM, 1.2, CID 4+4
depends_on:19:9:6:12
20:exp:58:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, AES128-CCM, 1.2, CID 4+0
depends_on:19:9:6:12
20:exp:58:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, AES128-CCM, 1.2, short tag
depends_on:9:6:12
20:exp:58:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, AES128-CCM, 1.2, short tag, CID 4+4
depends_on:19:9:6:12
20:exp:58:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, AES128-CCM, 1.2, short tag, CID 4+0
depends_on:19:9:6:12
20:exp:58:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, AES-192-CCM, 1.2
depends_on:9:6:12
20:exp:59:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, AES-192-CCM, 1.3
depends_on:9:25:12
20:exp:59:exp:41:int:0:int:0:exp:52:int:0:int:0
Record crypt, AES-192-CCM, 1.2, CID 4+4
depends_on:19:9:6:12
20:exp:59:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, AES-192-CCM, 1.2, CID 4+0
depends_on:19:9:6:12
20:exp:59:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, AES-192-CCM, 1.2, short tag
depends_on:9:6:12
20:exp:59:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, AES-192-CCM, 1.2, short tag, CID 4+4
depends_on:19:9:6:12
20:exp:59:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, AES-192-CCM, 1.2, short tag, CID 4+0
depends_on:19:9:6:12
20:exp:59:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, AES256-CCM, 1.2
depends_on:9:6:12
20:exp:60:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, AES256-CCM, 1.3
depends_on:9:25:12
20:exp:60:exp:41:int:0:int:0:exp:52:int:0:int:0
Record crypt, AES256-CCM, 1.2, CID 4+4
depends_on:19:9:6:12
20:exp:60:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, AES256-CCM, 1.2, CID 4+0
depends_on:19:9:6:12
20:exp:60:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, AES256-CCM, 1.2, short tag
depends_on:9:6:12
20:exp:60:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, AES256-CCM, 1.2, short tag, CID 4+4
depends_on:19:9:6:12
20:exp:60:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, AES256-CCM, 1.2, short tag, CID 4+0
depends_on:19:9:6:12
20:exp:60:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, CAMELLIA-128-CCM, 1.2
depends_on:16:6:12
20:exp:61:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, CAMELLIA-128-CCM, 1.2, CID 4+4
depends_on:19:16:6:12
20:exp:61:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, CAMELLIA-128-CCM, 1.2, CID 4+0
depends_on:19:16:6:12
20:exp:61:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, CAMELLIA-128-CCM, 1.2, short tag
depends_on:16:6:12
20:exp:61:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, CAMELLIA-128-CCM, 1.2, short tag, CID 4+4
depends_on:19:16:6:12
20:exp:61:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, CAMELLIA-128-CCM, 1.2, short tag, CID 4+0
depends_on:19:16:6:12
20:exp:61:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, CAMELLIA-192-CCM, 1.2
depends_on:16:6:12
20:exp:62:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, CAMELLIA-192-CCM, 1.2, CID 4+4
depends_on:19:16:6:12
20:exp:62:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, CAMELLIA-192-CCM, 1.2, CID 4+0
depends_on:19:16:6:12
20:exp:62:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, CAMELLIA-192-CCM, 1.2, short tag
depends_on:16:6:12
20:exp:62:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, CAMELLIA-192-CCM, 1.2, short tag, CID 4+4
depends_on:19:16:6:12
20:exp:62:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, CAMELLIA-192-CCM, 1.2, short tag, CID 4+0
depends_on:19:16:6:12
20:exp:62:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, CAMELLIA-256-CCM, 1.2
depends_on:16:6:12
20:exp:63:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, CAMELLIA-256-CCM, 1.2, CID 4+4
depends_on:19:16:6:12
20:exp:63:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, CAMELLIA-256-CCM, 1.2, CID 4+0
depends_on:19:16:6:12
20:exp:63:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, CAMELLIA-256-CCM, 1.2, short tag
depends_on:16:6:12
20:exp:63:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, CAMELLIA-256-CCM, 1.2, short tag, CID 4+4
depends_on:19:16:6:12
20:exp:63:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, CAMELLIA-256-CCM, 1.2, short tag, CID 4+0
depends_on:19:16:6:12
20:exp:63:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, ARC4-128, 1.2, SHA-384
depends_on:26:6:7:8
20:exp:64:exp:38:int:0:int:0:exp:24:int:0:int:0
Record crypt, ARC4-128, 1.2, SHA-384, CID 4+4
depends_on:19:26:6:7:8
20:exp:64:exp:38:int:0:int:0:exp:24:int:4:int:4
Record crypt, ARC4-128, 1.2, SHA-384, CID 4+0
depends_on:19:26:6:7:8
20:exp:64:exp:38:int:0:int:0:exp:24:int:4:int:0
Record crypt, ARC4-128, 1.2, SHA-384, EtM
depends_on:26:6:7:8:20
20:exp:64:exp:38:int:1:int:0:exp:24:int:0:int:0
Record crypt, ARC4-128, 1.2, SHA-384, EtM, CID 4+4
depends_on:19:26:6:7:8:20
20:exp:64:exp:38:int:1:int:0:exp:24:int:4:int:4
Record crypt, ARC4-128, 1.2, SHA-384, EtM, CID 4+0
depends_on:19:26:6:7:8:20
20:exp:64:exp:38:int:1:int:0:exp:24:int:4:int:0
Record crypt, ARC4-128, 1.2, SHA-384, short tag
depends_on:26:6:7:8
20:exp:64:exp:38:int:0:int:1:exp:24:int:0:int:0
Record crypt, ARC4-128, 1.2, SHA-384, short tag, CID 4+4
depends_on:19:26:6:7:8
20:exp:64:exp:38:int:0:int:1:exp:24:int:4:int:4
Record crypt, ARC4-128, 1.2, SHA-384, short tag, CID 4+0
depends_on:19:26:6:7:8
20:exp:64:exp:38:int:0:int:1:exp:24:int:4:int:0
Record crypt, ARC4-128, 1.2, SHA-384, short tag, EtM
depends_on:26:6:7:8:20
20:exp:64:exp:38:int:1:int:1:exp:24:int:0:int:0
Record crypt, ARC4-128, 1.2, SHA-384, short tag, EtM, CID 4+4
depends_on:19:26:6:7:8:20
20:exp:64:exp:38:int:1:int:1:exp:24:int:4:int:4
Record crypt, ARC4-128, 1.2, SHA-384, short tag, EtM, CID 4+0
depends_on:19:26:6:7:8:20
20:exp:64:exp:38:int:1:int:1:exp:24:int:4:int:0
Record crypt, ARC4-128, 1.2, SHA-256
depends_on:26:6:13
20:exp:64:exp:39:int:0:int:0:exp:24:int:0:int:0
Record crypt, ARC4-128, 1.2, SHA-256, CID 4+4
depends_on:19:26:6:13
20:exp:64:exp:39:int:0:int:0:exp:24:int:4:int:4
Record crypt, ARC4-128, 1.2, SHA-256, CID 4+0
depends_on:19:26:6:13
20:exp:64:exp:39:int:0:int:0:exp:24:int:4:int:0
Record crypt, ARC4-128, 1.2, SHA-256, EtM
depends_on:26:6:13:20
20:exp:64:exp:39:int:1:int:0:exp:24:int:0:int:0
Record crypt, ARC4-128, 1.2, SHA-256, EtM, CID 4+4
depends_on:19:26:6:13:20
20:exp:64:exp:39:int:1:int:0:exp:24:int:4:int:4
Record crypt, ARC4-128, 1.2, SHA-256, EtM, CID 4+0
depends_on:19:26:6:13:20
20:exp:64:exp:39:int:1:int:0:exp:24:int:4:int:0
Record crypt, ARC4-128, 1.2, SHA-256, short tag
depends_on:26:6:13
20:exp:64:exp:39:int:0:int:1:exp:24:int:0:int:0
Record crypt, ARC4-128, 1.2, SHA-256, short tag, CID 4+4
depends_on:19:26:6:13
20:exp:64:exp:39:int:0:int:1:exp:24:int:4:int:4
Record crypt, ARC4-128, 1.2, SHA-256, short tag, CID 4+0
depends_on:19:26:6:13
20:exp:64:exp:39:int:0:int:1:exp:24:int:4:int:0
Record crypt, ARC4-128, 1.2, SHA-256, short tag, EtM
depends_on:26:6:13:20
20:exp:64:exp:39:int:1:int:1:exp:24:int:0:int:0
Record crypt, ARC4-128, 1.2, SHA-256, short tag, EtM, CID 4+4
depends_on:19:26:6:13:20
20:exp:64:exp:39:int:1:int:1:exp:24:int:4:int:4
Record crypt, ARC4-128, 1.2, SHA-256, short tag, EtM, CID 4+0
depends_on:19:26:6:13:20
20:exp:64:exp:39:int:1:int:1:exp:24:int:4:int:0
Record crypt, ARC4-128, 1.2, SHA-1
depends_on:26:6:21
20:exp:64:exp:40:int:0:int:0:exp:24:int:0:int:0
Record crypt, ARC4-128, 1.2, SHA-1, CID 4+4
depends_on:19:26:6:21
20:exp:64:exp:40:int:0:int:0:exp:24:int:4:int:4
Record crypt, ARC4-128, 1.2, SHA-1, CID 4+0
depends_on:19:26:6:21
20:exp:64:exp:40:int:0:int:0:exp:24:int:4:int:0
Record crypt, ARC4-128, 1.2, SHA-1, EtM
depends_on:26:6:21:20
20:exp:64:exp:40:int:1:int:0:exp:24:int:0:int:0
Record crypt, ARC4-128, 1.2, SHA-1, EtM, CID 4+4
depends_on:19:26:6:21:20
20:exp:64:exp:40:int:1:int:0:exp:24:int:4:int:4
Record crypt, ARC4-128, 1.2, SHA-1, EtM, CID 4+0
depends_on:19:26:6:21:20
20:exp:64:exp:40:int:1:int:0:exp:24:int:4:int:0
Record crypt, ARC4-128, 1.2, SHA-1, short tag
depends_on:26:6:21
20:exp:64:exp:40:int:0:int:1:exp:24:int:0:int:0
Record crypt, ARC4-128, 1.2, SHA-1, short tag, CID 4+4
depends_on:19:26:6:21
20:exp:64:exp:40:int:0:int:1:exp:24:int:4:int:4
Record crypt, ARC4-128, 1.2, SHA-1, short tag, CID 4+0
depends_on:19:26:6:21
20:exp:64:exp:40:int:0:int:1:exp:24:int:4:int:0
Record crypt, ARC4-128, 1.2, SHA-1, short tag, EtM
depends_on:26:6:21:20
20:exp:64:exp:40:int:1:int:1:exp:24:int:0:int:0
Record crypt, ARC4-128, 1.2, SHA-1, short tag, EtM, CID 4+4
depends_on:19:26:6:21:20
20:exp:64:exp:40:int:1:int:1:exp:24:int:4:int:4
Record crypt, ARC4-128, 1.2, SHA-1, short tag, EtM, CID 4+0
depends_on:19:26:6:21:20
20:exp:64:exp:40:int:1:int:1:exp:24:int:4:int:0
Record crypt, ARC4-128, 1.2, MD5
depends_on:26:6:22
20:exp:64:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, ARC4-128, 1.2, MD5, CID 4+4
depends_on:19:26:6:22
20:exp:64:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, ARC4-128, 1.2, MD5, CID 4+0
depends_on:19:26:6:22
20:exp:64:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, ARC4-128, 1.2, MD5, EtM
depends_on:26:6:22:20
20:exp:64:exp:41:int:1:int:0:exp:24:int:0:int:0
Record crypt, ARC4-128, 1.2, MD5, EtM, CID 4+4
depends_on:19:26:6:22:20
20:exp:64:exp:41:int:1:int:0:exp:24:int:4:int:4
Record crypt, ARC4-128, 1.2, MD5, EtM, CID 4+0
depends_on:19:26:6:22:20
20:exp:64:exp:41:int:1:int:0:exp:24:int:4:int:0
Record crypt, ARC4-128, 1.2, MD5, short tag
depends_on:26:6:22
20:exp:64:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, ARC4-128, 1.2, MD5, short tag, CID 4+4
depends_on:19:26:6:22
20:exp:64:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, ARC4-128, 1.2, MD5, short tag, CID 4+0
depends_on:19:26:6:22
20:exp:64:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, ARC4-128, 1.2, MD5, short tag, EtM
depends_on:26:6:22:20
20:exp:64:exp:41:int:1:int:1:exp:24:int:0:int:0
Record crypt, ARC4-128, 1.2, MD5, short tag, EtM, CID 4+4
depends_on:19:26:6:22:20
20:exp:64:exp:41:int:1:int:1:exp:24:int:4:int:4
Record crypt, ARC4-128, 1.2, MD5, short tag, EtM, CID 4+0
depends_on:19:26:6:22:20
20:exp:64:exp:41:int:1:int:1:exp:24:int:4:int:0
Record crypt, ARC4-128, 1.1, SHA-384
depends_on:26:5:7:8
20:exp:64:exp:38:int:0:int:0:exp:23:int:0:int:0
Record crypt, ARC4-128, 1.1, SHA-384, EtM
depends_on:26:5:7:8:20
20:exp:64:exp:38:int:1:int:0:exp:23:int:0:int:0
Record crypt, ARC4-128, 1.1, SHA-384, short tag
depends_on:26:5:7:8
20:exp:64:exp:38:int:0:int:1:exp:23:int:0:int:0
Record crypt, ARC4-128, 1.1, SHA-384, short tag, EtM
depends_on:26:5:7:8:20
20:exp:64:exp:38:int:1:int:1:exp:23:int:0:int:0
Record crypt, ARC4-128, 1.1, SHA-256
depends_on:26:5:13
20:exp:64:exp:39:int:0:int:0:exp:23:int:0:int:0
Record crypt, ARC4-128, 1.1, SHA-256, EtM
depends_on:26:5:13:20
20:exp:64:exp:39:int:1:int:0:exp:23:int:0:int:0
Record crypt, ARC4-128, 1.1, SHA-256, short tag
depends_on:26:5:13
20:exp:64:exp:39:int:0:int:1:exp:23:int:0:int:0
Record crypt, ARC4-128, 1.1, SHA-256, short tag, EtM
depends_on:26:5:13:20
20:exp:64:exp:39:int:1:int:1:exp:23:int:0:int:0
Record crypt, ARC4-128, 1.1, SHA-1
depends_on:26:5:21
20:exp:64:exp:40:int:0:int:0:exp:23:int:0:int:0
Record crypt, ARC4-128, 1.1, SHA-1, EtM
depends_on:26:5:21:20
20:exp:64:exp:40:int:1:int:0:exp:23:int:0:int:0
Record crypt, ARC4-128, 1.1, SHA-1, short tag
depends_on:26:5:21
20:exp:64:exp:40:int:0:int:1:exp:23:int:0:int:0
Record crypt, ARC4-128, 1.1, SHA-1, short tag, EtM
depends_on:26:5:21:20
20:exp:64:exp:40:int:1:int:1:exp:23:int:0:int:0
Record crypt, ARC4-128, 1.1, MD5
depends_on:26:5:22
20:exp:64:exp:41:int:0:int:0:exp:23:int:0:int:0
Record crypt, ARC4-128, 1.1, MD5, EtM
depends_on:26:5:22:20
20:exp:64:exp:41:int:1:int:0:exp:23:int:0:int:0
Record crypt, ARC4-128, 1.1, MD5, short tag
depends_on:26:5:22
20:exp:64:exp:41:int:0:int:1:exp:23:int:0:int:0
Record crypt, ARC4-128, 1.1, MD5, short tag, EtM
depends_on:26:5:22:20
20:exp:64:exp:41:int:1:int:1:exp:23:int:0:int:0
Record crypt, ARC4-128, 1.0, SHA-384
depends_on:26:3:7:8
20:exp:64:exp:38:int:0:int:0:exp:22:int:0:int:0
Record crypt, ARC4-128, 1.0, SHA-384, EtM
depends_on:26:3:7:8:20
20:exp:64:exp:38:int:1:int:0:exp:22:int:0:int:0
Record crypt, ARC4-128, 1.0, SHA-384, short tag
depends_on:26:3:7:8
20:exp:64:exp:38:int:0:int:1:exp:22:int:0:int:0
Record crypt, ARC4-128, 1.0, SHA-384, short tag, EtM
depends_on:26:3:7:8:20
20:exp:64:exp:38:int:1:int:1:exp:22:int:0:int:0
Record crypt, ARC4-128, 1.0, SHA-256
depends_on:26:3:13
20:exp:64:exp:39:int:0:int:0:exp:22:int:0:int:0
Record crypt, ARC4-128, 1.0, SHA-256, EtM
depends_on:26:3:13:20
20:exp:64:exp:39:int:1:int:0:exp:22:int:0:int:0
Record crypt, ARC4-128, 1.0, SHA-256, short tag
depends_on:26:3:13
20:exp:64:exp:39:int:0:int:1:exp:22:int:0:int:0
Record crypt, ARC4-128, 1.0, SHA-256, short tag, EtM
depends_on:26:3:13:20
20:exp:64:exp:39:int:1:int:1:exp:22:int:0:int:0
Record crypt, ARC4-128, 1.0, SHA-1
depends_on:26:3:21
20:exp:64:exp:40:int:0:int:0:exp:22:int:0:int:0
Record crypt, ARC4-128, 1.0, SHA-1, EtM
depends_on:26:3:21:20
20:exp:64:exp:40:int:1:int:0:exp:22:int:0:int:0
Record crypt, ARC4-128, 1.0, SHA-1, short tag
depends_on:26:3:21
20:exp:64:exp:40:int:0:int:1:exp:22:int:0:int:0
Record crypt, ARC4-128, 1.0, SHA-1, short tag, EtM
depends_on:26:3:21:20
20:exp:64:exp:40:int:1:int:1:exp:22:int:0:int:0
Record crypt, ARC4-128, 1.0, MD5
depends_on:26:3:22
20:exp:64:exp:41:int:0:int:0:exp:22:int:0:int:0
Record crypt, ARC4-128, 1.0, MD5, EtM
depends_on:26:3:22:20
20:exp:64:exp:41:int:1:int:0:exp:22:int:0:int:0
Record crypt, ARC4-128, 1.0, MD5, short tag
depends_on:26:3:22
20:exp:64:exp:41:int:0:int:1:exp:22:int:0:int:0
Record crypt, ARC4-128, 1.0, MD5, short tag, EtM
depends_on:26:3:22:20
20:exp:64:exp:41:int:1:int:1:exp:22:int:0:int:0
Record crypt, ARC4-128, SSL3, SHA-1
depends_on:26:0:21
20:exp:64:exp:40:int:0:int:0:exp:21:int:0:int:0
Record crypt, ARC4-128, SSL3, SHA-1, EtM
depends_on:26:0:21:20
20:exp:64:exp:40:int:1:int:0:exp:21:int:0:int:0
Record crypt, ARC4-128, SSL3, SHA-1, short tag
depends_on:26:0:21
20:exp:64:exp:40:int:0:int:1:exp:21:int:0:int:0
Record crypt, ARC4-128, SSL3, SHA-1, short tag, EtM
depends_on:26:0:21:20
20:exp:64:exp:40:int:1:int:1:exp:21:int:0:int:0
Record crypt, ARC4-128, SSL3, MD5
depends_on:26:0:22
20:exp:64:exp:41:int:0:int:0:exp:21:int:0:int:0
Record crypt, ARC4-128, SSL3, MD5, EtM
depends_on:26:0:22:20
20:exp:64:exp:41:int:1:int:0:exp:21:int:0:int:0
Record crypt, ARC4-128, SSL3, MD5, short tag
depends_on:26:0:22
20:exp:64:exp:41:int:0:int:1:exp:21:int:0:int:0
Record crypt, ARC4-128, SSL3, MD5, short tag, EtM
depends_on:26:0:22:20
20:exp:64:exp:41:int:1:int:1:exp:21:int:0:int:0
Record crypt, NULL cipher, 1.2, SHA-384
depends_on:27:6:7:8
20:exp:65:exp:38:int:0:int:0:exp:24:int:0:int:0
Record crypt, NULL cipher, 1.2, SHA-384, EtM
depends_on:27:6:7:8:20
20:exp:65:exp:38:int:1:int:0:exp:24:int:0:int:0
Record crypt, NULL cipher, 1.2, SHA-384, short tag
depends_on:27:6:7:8
20:exp:65:exp:38:int:0:int:1:exp:24:int:0:int:0
Record crypt, NULL cipher, 1.2, SHA-384, short tag, EtM
depends_on:27:6:7:8:20
20:exp:65:exp:38:int:1:int:1:exp:24:int:0:int:0
Record crypt, NULL cipher, 1.2, SHA-256
depends_on:27:6:13
20:exp:65:exp:39:int:0:int:0:exp:24:int:0:int:0
Record crypt, NULL cipher, 1.2, SHA-256, EtM
depends_on:27:6:13:20
20:exp:65:exp:39:int:1:int:0:exp:24:int:0:int:0
Record crypt, NULL cipher, 1.2, SHA-256, short tag
depends_on:27:6:13
20:exp:65:exp:39:int:0:int:1:exp:24:int:0:int:0
Record crypt, NULL cipher, 1.2, SHA-256, short tag, EtM
depends_on:27:6:13:20
20:exp:65:exp:39:int:1:int:1:exp:24:int:0:int:0
Record crypt, NULL cipher, 1.2, SHA-1
depends_on:27:6:21
20:exp:65:exp:40:int:0:int:0:exp:24:int:0:int:0
Record crypt, NULL cipher, 1.2, SHA-1, EtM
depends_on:27:6:21:20
20:exp:65:exp:40:int:1:int:0:exp:24:int:0:int:0
Record crypt, NULL cipher, 1.2, SHA-1, short tag
depends_on:27:6:21
20:exp:65:exp:40:int:0:int:1:exp:24:int:0:int:0
Record crypt, NULL cipher, 1.2, SHA-1, short tag, EtM
depends_on:27:6:21:20
20:exp:65:exp:40:int:1:int:1:exp:24:int:0:int:0
Record crypt, NULL cipher, 1.2, MD5
depends_on:27:6:22
20:exp:65:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, NULL cipher, 1.2, MD5, EtM
depends_on:27:6:22:20
20:exp:65:exp:41:int:1:int:0:exp:24:int:0:int:0
Record crypt, NULL cipher, 1.2, MD5, short tag
depends_on:27:6:22
20:exp:65:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, NULL cipher, 1.2, MD5, short tag, EtM
depends_on:27:6:22:20
20:exp:65:exp:41:int:1:int:1:exp:24:int:0:int:0
Record crypt, NULL cipher, 1.1, SHA-384
depends_on:27:5:7:8
20:exp:65:exp:38:int:0:int:0:exp:23:int:0:int:0
Record crypt, NULL cipher, 1.1, SHA-384, EtM
depends_on:27:5:7:8:20
20:exp:65:exp:38:int:1:int:0:exp:23:int:0:int:0
Record crypt, NULL cipher, 1.1, SHA-384, short tag
depends_on:27:5:7:8
20:exp:65:exp:38:int:0:int:1:exp:23:int:0:int:0
Record crypt, NULL cipher, 1.1, SHA-384, short tag, EtM
depends_on:27:5:7:8:20
20:exp:65:exp:38:int:1:int:1:exp:23:int:0:int:0
Record crypt, NULL cipher, 1.1, SHA-256
depends_on:27:5:13
20:exp:65:exp:39:int:0:int:0:exp:23:int:0:int:0
Record crypt, NULL cipher, 1.1, SHA-256, EtM
depends_on:27:5:13:20
20:exp:65:exp:39:int:1:int:0:exp:23:int:0:int:0
Record crypt, NULL cipher, 1.1, SHA-256, short tag
depends_on:27:5:13
20:exp:65:exp:39:int:0:int:1:exp:23:int:0:int:0
Record crypt, NULL cipher, 1.1, SHA-256, short tag, EtM
depends_on:27:5:13:20
20:exp:65:exp:39:int:1:int:1:exp:23:int:0:int:0
Record crypt, NULL cipher, 1.1, SHA-1
depends_on:27:5:21
20:exp:65:exp:40:int:0:int:0:exp:23:int:0:int:0
Record crypt, NULL cipher, 1.1, SHA-1, EtM
depends_on:27:5:21:20
20:exp:65:exp:40:int:1:int:0:exp:23:int:0:int:0
Record crypt, NULL cipher, 1.1, SHA-1, short tag
depends_on:27:5:21
20:exp:65:exp:40:int:0:int:1:exp:23:int:0:int:0
Record crypt, NULL cipher, 1.1, SHA-1, short tag, EtM
depends_on:27:5:21:20
20:exp:65:exp:40:int:1:int:1:exp:23:int:0:int:0
Record crypt, NULL cipher, 1.1, MD5
depends_on:27:5:22
20:exp:65:exp:41:int:0:int:0:exp:23:int:0:int:0
Record crypt, NULL cipher, 1.1, MD5, EtM
depends_on:27:5:22:20
20:exp:65:exp:41:int:1:int:0:exp:23:int:0:int:0
Record crypt, NULL cipher, 1.1, MD5, short tag
depends_on:27:5:22
20:exp:65:exp:41:int:0:int:1:exp:23:int:0:int:0
Record crypt, NULL cipher, 1.1, MD5, short tag, EtM
depends_on:27:5:22:20
20:exp:65:exp:41:int:1:int:1:exp:23:int:0:int:0
Record crypt, NULL cipher, 1.0, SHA-384
depends_on:27:3:7:8
20:exp:65:exp:38:int:0:int:0:exp:22:int:0:int:0
Record crypt, NULL cipher, 1.0, SHA-384, EtM
depends_on:27:3:7:8:20
20:exp:65:exp:38:int:1:int:0:exp:22:int:0:int:0
Record crypt, NULL cipher, 1.0, SHA-384, short tag
depends_on:27:3:7:8
20:exp:65:exp:38:int:0:int:1:exp:22:int:0:int:0
Record crypt, NULL cipher, 1.0, SHA-384, short tag, EtM
depends_on:27:3:7:8:20
20:exp:65:exp:38:int:1:int:1:exp:22:int:0:int:0
Record crypt, NULL cipher, 1.0, SHA-256
depends_on:27:3:13
20:exp:65:exp:39:int:0:int:0:exp:22:int:0:int:0
Record crypt, NULL cipher, 1.0, SHA-256, EtM
depends_on:27:3:13:20
20:exp:65:exp:39:int:1:int:0:exp:22:int:0:int:0
Record crypt, NULL cipher, 1.0, SHA-256, short tag
depends_on:27:3:13
20:exp:65:exp:39:int:0:int:1:exp:22:int:0:int:0
Record crypt, NULL cipher, 1.0, SHA-256, short tag, EtM
depends_on:27:3:13:20
20:exp:65:exp:39:int:1:int:1:exp:22:int:0:int:0
Record crypt, NULL cipher, 1.0, SHA-1
depends_on:27:3:21
20:exp:65:exp:40:int:0:int:0:exp:22:int:0:int:0
Record crypt, NULL cipher, 1.0, SHA-1, EtM
depends_on:27:3:21:20
20:exp:65:exp:40:int:1:int:0:exp:22:int:0:int:0
Record crypt, NULL cipher, 1.0, SHA-1, short tag
depends_on:27:3:21
20:exp:65:exp:40:int:0:int:1:exp:22:int:0:int:0
Record crypt, NULL cipher, 1.0, SHA-1, short tag, EtM
depends_on:27:3:21:20
20:exp:65:exp:40:int:1:int:1:exp:22:int:0:int:0
Record crypt, NULL cipher, 1.0, MD5
depends_on:27:3:22
20:exp:65:exp:41:int:0:int:0:exp:22:int:0:int:0
Record crypt, NULL cipher, 1.0, MD5, EtM
depends_on:27:3:22:20
20:exp:65:exp:41:int:1:int:0:exp:22:int:0:int:0
Record crypt, NULL cipher, 1.0, MD5, short tag
depends_on:27:3:22
20:exp:65:exp:41:int:0:int:1:exp:22:int:0:int:0
Record crypt, NULL cipher, 1.0, MD5, short tag, EtM
depends_on:27:3:22:20
20:exp:65:exp:41:int:1:int:1:exp:22:int:0:int:0
Record crypt, NULL cipher, SSL3, SHA-1
depends_on:27:0:21
20:exp:65:exp:40:int:0:int:0:exp:21:int:0:int:0
Record crypt, NULL cipher, SSL3, SHA-1, EtM
depends_on:27:0:21:20
20:exp:65:exp:40:int:1:int:0:exp:21:int:0:int:0
Record crypt, NULL cipher, SSL3, SHA-1, short tag
depends_on:27:0:21
20:exp:65:exp:40:int:0:int:1:exp:21:int:0:int:0
Record crypt, NULL cipher, SSL3, SHA-1, short tag, EtM
depends_on:27:0:21:20
20:exp:65:exp:40:int:1:int:1:exp:21:int:0:int:0
Record crypt, NULL cipher, SSL3, MD5
depends_on:27:0:22
20:exp:65:exp:41:int:0:int:0:exp:21:int:0:int:0
Record crypt, NULL cipher, SSL3, MD5, EtM
depends_on:27:0:22:20
20:exp:65:exp:41:int:1:int:0:exp:21:int:0:int:0
Record crypt, NULL cipher, SSL3, MD5, short tag
depends_on:27:0:22
20:exp:65:exp:41:int:0:int:1:exp:21:int:0:int:0
Record crypt, NULL cipher, SSL3, MD5, short tag, EtM
depends_on:27:0:22:20
20:exp:65:exp:41:int:1:int:1:exp:21:int:0:int:0
Record crypt, ChachaPoly
depends_on:28:6
20:exp:66:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, ChachaPoly, 1.3
depends_on:28:25
20:exp:66:exp:41:int:0:int:0:exp:52:int:0:int:0
Record crypt, little space, ChachaPoly
depends_on:28:6
21:exp:66:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, ChachaPoly, 1.3
depends_on:28:25
21:exp:66:exp:41:int:0:int:0:exp:52:int:0:int:0
Record crypt, little space, ChachaPoly, CID 4+4
depends_on:19:28:6
21:exp:66:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, ChachaPoly, CID 4+0
depends_on:19:28:6
21:exp:66:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, AES128-CBC, 1.2, SHA-384
depends_on:4:9:6:7:8
21:exp:37:exp:38:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, AES128-CBC, 1.2, SHA-384, CID 4+4
depends_on:19:4:9:6:7:8
21:exp:37:exp:38:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, AES128-CBC, 1.2, SHA-384, CID 4+0
depends_on:19:4:9:6:7:8
21:exp:37:exp:38:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, AES128-CBC, 1.2, SHA-384, EtM
depends_on:4:9:6:7:8:20
21:exp:37:exp:38:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, AES128-CBC, 1.2, SHA-384, EtM, CID 4+4
depends_on:19:4:9:6:7:8:20
21:exp:37:exp:38:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, AES128-CBC, 1.2, SHA-384, EtM, CID 4+0
depends_on:19:4:9:6:7:8:20
21:exp:37:exp:38:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, AES128-CBC, 1.2, SHA-384, short tag
depends_on:4:9:6:7:8
21:exp:37:exp:38:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, AES128-CBC, 1.2, SHA-384, short tag, CID 4+4
depends_on:19:4:9:6:7:8
21:exp:37:exp:38:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, AES128-CBC, 1.2, SHA-384, short tag, CID 4+0
depends_on:19:4:9:6:7:8
21:exp:37:exp:38:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, AES128-CBC, 1.2, SHA-384, short tag, EtM
depends_on:4:9:6:7:8:20
21:exp:37:exp:38:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, AES128-CBC, 1.2, SHA-384, short tag, EtM, CID 4+4
depends_on:19:4:9:6:7:8:20
21:exp:37:exp:38:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, AES128-CBC, 1.2, SHA-384, short tag, EtM, CID 4+0
depends_on:19:4:9:6:7:8:20
21:exp:37:exp:38:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, AES128-CBC, 1.2, SHA-256
depends_on:4:9:6:13
21:exp:37:exp:39:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, AES128-CBC, 1.2, SHA-256, CID 4+4
depends_on:19:4:9:6:13
21:exp:37:exp:39:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, AES128-CBC, 1.2, SHA-256, CID 4+0
depends_on:19:4:9:6:13
21:exp:37:exp:39:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, AES128-CBC, 1.2, SHA-256, EtM
depends_on:4:9:6:13:20
21:exp:37:exp:39:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, AES128-CBC, 1.2, SHA-256, EtM, CID 4+4
depends_on:19:4:9:6:13:20
21:exp:37:exp:39:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, AES128-CBC, 1.2, SHA-256, EtM, CID 4+0
depends_on:19:4:9:6:13:20
21:exp:37:exp:39:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, AES128-CBC, 1.2, SHA-256, short tag
depends_on:4:9:6:13
21:exp:37:exp:39:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, AES128-CBC, 1.2, SHA-256, short tag, CID 4+4
depends_on:19:4:9:6:13
21:exp:37:exp:39:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, AES128-CBC, 1.2, SHA-256, short tag, CID 4+0
depends_on:19:4:9:6:13
21:exp:37:exp:39:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, AES128-CBC, 1.2, SHA-256, short tag, EtM
depends_on:4:9:6:13:20
21:exp:37:exp:39:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, AES128-CBC, 1.2, SHA-256, short tag, EtM, CID 4+4
depends_on:19:4:9:6:13:20
21:exp:37:exp:39:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, AES128-CBC, 1.2, SHA-256, short tag, EtM, CID 4+0
depends_on:19:4:9:6:13:20
21:exp:37:exp:39:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, AES128-CBC, 1.2, SHA-1
depends_on:4:9:6:21
21:exp:37:exp:40:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, AES128-CBC, 1.2, SHA-1, CID 4+4
depends_on:19:4:9:6:21
21:exp:37:exp:40:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, AES128-CBC, 1.2, SHA-1, CID 4+0
depends_on:19:4:9:6:21
21:exp:37:exp:40:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, AES128-CBC, 1.2, SHA-1, EtM
depends_on:4:9:6:21:20
21:exp:37:exp:40:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, AES128-CBC, 1.2, SHA-1, EtM, CID 4+4
depends_on:19:4:9:6:21:20
21:exp:37:exp:40:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, AES128-CBC, 1.2, SHA-1, EtM, CID 4+0
depends_on:19:4:9:6:21:20
21:exp:37:exp:40:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, AES128-CBC, 1.2, SHA-1, short tag
depends_on:4:9:6:21
21:exp:37:exp:40:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, AES128-CBC, 1.2, SHA-1, short tag, CID 4+4
depends_on:19:4:9:6:21
21:exp:37:exp:40:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, AES128-CBC, 1.2, SHA-1, short tag, CID 4+0
depends_on:19:4:9:6:21
21:exp:37:exp:40:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, AES128-CBC, 1.2, SHA-1, short tag, EtM
depends_on:4:9:6:21:20
21:exp:37:exp:40:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, AES128-CBC, 1.2, SHA-1, short tag, EtM, CID 4+4
depends_on:19:4:9:6:21:20
21:exp:37:exp:40:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, AES128-CBC, 1.2, SHA-1, short tag, EtM, CID 4+0
depends_on:19:4:9:6:21:20
21:exp:37:exp:40:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, AES128-CBC, 1.2, MD5
depends_on:4:9:6:22
21:exp:37:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, AES128-CBC, 1.2, MD5, CID 4+4
depends_on:19:4:9:6:22
21:exp:37:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, AES128-CBC, 1.2, MD5, CID 4+0
depends_on:19:4:9:6:22
21:exp:37:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, AES128-CBC, 1.2, MD5, EtM
depends_on:4:9:6:22:20
21:exp:37:exp:41:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, AES128-CBC, 1.2, MD5, EtM, CID 4+4
depends_on:19:4:9:6:22:20
21:exp:37:exp:41:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, AES128-CBC, 1.2, MD5, EtM, CID 4+0
depends_on:19:4:9:6:22:20
21:exp:37:exp:41:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, AES128-CBC, 1.2, MD5, short tag
depends_on:4:9:6:22
21:exp:37:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, AES128-CBC, 1.2, MD5, short tag, CID 4+4
depends_on:19:4:9:6:22
21:exp:37:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, AES128-CBC, 1.2, MD5, short tag, CID 4+0
depends_on:19:4:9:6:22
21:exp:37:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, AES128-CBC, 1.2, MD5, short tag, EtM
depends_on:4:9:6:22:20
21:exp:37:exp:41:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, AES128-CBC, 1.2, MD5, short tag, EtM, CID 4+4
depends_on:19:4:9:6:22:20
21:exp:37:exp:41:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, AES128-CBC, 1.2, MD5, short tag, EtM, CID 4+0
depends_on:19:4:9:6:22:20
21:exp:37:exp:41:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, AES128-CBC, 1.1, SHA-384
depends_on:4:9:5:7:8
21:exp:37:exp:38:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, AES128-CBC, 1.1, SHA-384, EtM
depends_on:4:9:5:7:8:20
21:exp:37:exp:38:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, AES128-CBC, 1.1, SHA-384, short tag
depends_on:4:9:5:7:8
21:exp:37:exp:38:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, AES128-CBC, 1.1, SHA-384, short tag, EtM
depends_on:4:9:5:7:8:20
21:exp:37:exp:38:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, AES128-CBC, 1.1, SHA-256
depends_on:4:9:5:13
21:exp:37:exp:39:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, AES128-CBC, 1.1, SHA-256, EtM
depends_on:4:9:5:13:20
21:exp:37:exp:39:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, AES128-CBC, 1.1, SHA-256, short tag
depends_on:4:9:5:13
21:exp:37:exp:39:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, AES128-CBC, 1.1, SHA-256, short tag, EtM
depends_on:4:9:5:13:20
21:exp:37:exp:39:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, AES128-CBC, 1.1, SHA-1
depends_on:4:9:5:21
21:exp:37:exp:40:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, AES128-CBC, 1.1, SHA-1, EtM
depends_on:4:9:5:21:20
21:exp:37:exp:40:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, AES128-CBC, 1.1, SHA-1, short tag
depends_on:4:9:5:21
21:exp:37:exp:40:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, AES128-CBC, 1.1, SHA-1, short tag, EtM
depends_on:4:9:5:21:20
21:exp:37:exp:40:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, AES128-CBC, 1.1, MD5
depends_on:4:9:5:22
21:exp:37:exp:41:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, AES128-CBC, 1.1, MD5, EtM
depends_on:4:9:5:22:20
21:exp:37:exp:41:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, AES128-CBC, 1.1, MD5, short tag
depends_on:4:9:5:22
21:exp:37:exp:41:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, AES128-CBC, 1.1, MD5, short tag, EtM
depends_on:4:9:5:22:20
21:exp:37:exp:41:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, AES128-CBC, 1.0, SHA-384
depends_on:4:9:3:7:8
21:exp:37:exp:38:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, AES128-CBC, 1.0, SHA-384, EtM
depends_on:4:9:3:7:8:20
21:exp:37:exp:38:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, AES128-CBC, 1.0, SHA-384, short tag
depends_on:4:9:3:7:8
21:exp:37:exp:38:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, AES128-CBC, 1.0, SHA-384, short tag, EtM
depends_on:4:9:3:7:8:20
21:exp:37:exp:38:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, AES128-CBC, 1.0, SHA-256
depends_on:4:9:3:13
21:exp:37:exp:39:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, AES128-CBC, 1.0, SHA-256, EtM
depends_on:4:9:3:13:20
21:exp:37:exp:39:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, AES128-CBC, 1.0, SHA-256, short tag
depends_on:4:9:3:13
21:exp:37:exp:39:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, AES128-CBC, 1.0, SHA-256, short tag, EtM
depends_on:4:9:3:13:20
21:exp:37:exp:39:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, AES128-CBC, 1.0, SHA-1
depends_on:4:9:3:21
21:exp:37:exp:40:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, AES128-CBC, 1.0, SHA-1, EtM
depends_on:4:9:3:21:20
21:exp:37:exp:40:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, AES128-CBC, 1.0, SHA-1, short tag
depends_on:4:9:3:21
21:exp:37:exp:40:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, AES128-CBC, 1.0, SHA-1, short tag, EtM
depends_on:4:9:3:21:20
21:exp:37:exp:40:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, AES128-CBC, 1.0, MD5
depends_on:4:9:3:22
21:exp:37:exp:41:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, AES128-CBC, 1.0, MD5, EtM
depends_on:4:9:3:22:20
21:exp:37:exp:41:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, AES128-CBC, 1.0, MD5, short tag
depends_on:4:9:3:22
21:exp:37:exp:41:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, AES128-CBC, 1.0, MD5, short tag, EtM
depends_on:4:9:3:22:20
21:exp:37:exp:41:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, AES128-CBC, SSL3, SHA-1
depends_on:4:9:0:21
21:exp:37:exp:40:int:0:int:0:exp:21:int:0:int:0
Record crypt, little space, AES128-CBC, SSL3, SHA-1, EtM
depends_on:4:9:0:21:20
21:exp:37:exp:40:int:1:int:0:exp:21:int:0:int:0
Record crypt, little space, AES128-CBC, SSL3, SHA-1, short tag
depends_on:4:9:0:21
21:exp:37:exp:40:int:0:int:1:exp:21:int:0:int:0
Record crypt, little space, AES128-CBC, SSL3, SHA-1, short tag, EtM
depends_on:4:9:0:21:20
21:exp:37:exp:40:int:1:int:1:exp:21:int:0:int:0
Record crypt, little space, AES128-CBC, SSL3, MD5
depends_on:4:9:0:22
21:exp:37:exp:41:int:0:int:0:exp:21:int:0:int:0
Record crypt, little space, AES128-CBC, SSL3, MD5, EtM
depends_on:4:9:0:22:20
21:exp:37:exp:41:int:1:int:0:exp:21:int:0:int:0
Record crypt, little space, AES128-CBC, SSL3, MD5, short tag
depends_on:4:9:0:22
21:exp:37:exp:41:int:0:int:1:exp:21:int:0:int:0
Record crypt, little space, AES128-CBC, SSL3, MD5, short tag, EtM
depends_on:4:9:0:22:20
21:exp:37:exp:41:int:1:int:1:exp:21:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.2, SHA-384
depends_on:4:9:6:7:8
21:exp:42:exp:38:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.2, SHA-384, CID 4+4
depends_on:19:4:9:6:7:8
21:exp:42:exp:38:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, AES-192-CBC, 1.2, SHA-384, CID 4+0
depends_on:19:4:9:6:7:8
21:exp:42:exp:38:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, AES-192-CBC, 1.2, SHA-384, EtM
depends_on:4:9:6:7:8:20
21:exp:42:exp:38:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.2, SHA-384, EtM, CID 4+4
depends_on:19:4:9:6:7:8:20
21:exp:42:exp:38:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, AES-192-CBC, 1.2, SHA-384, EtM, CID 4+0
depends_on:19:4:9:6:7:8:20
21:exp:42:exp:38:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, AES-192-CBC, 1.2, SHA-384, short tag
depends_on:4:9:6:7:8
21:exp:42:exp:38:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.2, SHA-384, short tag, CID 4+4
depends_on:19:4:9:6:7:8
21:exp:42:exp:38:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, AES-192-CBC, 1.2, SHA-384, short tag, CID 4+0
depends_on:19:4:9:6:7:8
21:exp:42:exp:38:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, AES-192-CBC, 1.2, SHA-384, short tag, EtM
depends_on:4:9:6:7:8:20
21:exp:42:exp:38:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.2, SHA-384, short tag, EtM, CID 4+4
depends_on:19:4:9:6:7:8:20
21:exp:42:exp:38:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, AES-192-CBC, 1.2, SHA-384, short tag, EtM, CID 4+0
depends_on:19:4:9:6:7:8:20
21:exp:42:exp:38:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, AES-192-CBC, 1.2, SHA-256
depends_on:4:9:6:13
21:exp:42:exp:39:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.2, SHA-256, CID 4+4
depends_on:19:4:9:6:13
21:exp:42:exp:39:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, AES-192-CBC, 1.2, SHA-256, CID 4+0
depends_on:19:4:9:6:13
21:exp:42:exp:39:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, AES-192-CBC, 1.2, SHA-256, EtM
depends_on:4:9:6:13:20
21:exp:42:exp:39:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.2, SHA-256, EtM, CID 4+4
depends_on:19:4:9:6:13:20
21:exp:42:exp:39:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, AES-192-CBC, 1.2, SHA-256, EtM, CID 4+0
depends_on:19:4:9:6:13:20
21:exp:42:exp:39:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, AES-192-CBC, 1.2, SHA-256, short tag
depends_on:4:9:6:13
21:exp:42:exp:39:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.2, SHA-256, short tag, CID 4+4
depends_on:19:4:9:6:13
21:exp:42:exp:39:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, AES-192-CBC, 1.2, SHA-256, short tag, CID 4+0
depends_on:19:4:9:6:13
21:exp:42:exp:39:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, AES-192-CBC, 1.2, SHA-256, short tag, EtM
depends_on:4:9:6:13:20
21:exp:42:exp:39:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.2, SHA-256, short tag, EtM, CID 4+4
depends_on:19:4:9:6:13:20
21:exp:42:exp:39:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, AES-192-CBC, 1.2, SHA-256, short tag, EtM, CID 4+0
depends_on:19:4:9:6:13:20
21:exp:42:exp:39:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, AES-192-CBC, 1.2, SHA-1
depends_on:4:9:6:21
21:exp:42:exp:40:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.2, SHA-1, CID 4+4
depends_on:19:4:9:6:21
21:exp:42:exp:40:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, AES-192-CBC, 1.2, SHA-1, CID 4+0
depends_on:19:4:9:6:21
21:exp:42:exp:40:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, AES-192-CBC, 1.2, SHA-1, EtM
depends_on:4:9:6:21:20
21:exp:42:exp:40:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.2, SHA-1, EtM, CID 4+4
depends_on:19:4:9:6:21:20
21:exp:42:exp:40:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, AES-192-CBC, 1.2, SHA-1, EtM, CID 4+0
depends_on:19:4:9:6:21:20
21:exp:42:exp:40:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, AES-192-CBC, 1.2, SHA-1, short tag
depends_on:4:9:6:21
21:exp:42:exp:40:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.2, SHA-1, short tag, CID 4+4
depends_on:19:4:9:6:21
21:exp:42:exp:40:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, AES-192-CBC, 1.2, SHA-1, short tag, CID 4+0
depends_on:19:4:9:6:21
21:exp:42:exp:40:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, AES-192-CBC, 1.2, SHA-1, short tag, EtM
depends_on:4:9:6:21:20
21:exp:42:exp:40:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.2, SHA-1, short tag, EtM, CID 4+4
depends_on:19:4:9:6:21:20
21:exp:42:exp:40:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, AES-192-CBC, 1.2, SHA-1, short tag, EtM, CID 4+0
depends_on:19:4:9:6:21:20
21:exp:42:exp:40:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, AES-192-CBC, 1.2, MD5
depends_on:4:9:6:22
21:exp:42:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.2, MD5, CID 4+4
depends_on:19:4:9:6:22
21:exp:42:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, AES-192-CBC, 1.2, MD5, CID 4+0
depends_on:19:4:9:6:22
21:exp:42:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, AES-192-CBC, 1.2, MD5, EtM
depends_on:4:9:6:22:20
21:exp:42:exp:41:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.2, MD5, EtM, CID 4+4
depends_on:19:4:9:6:22:20
21:exp:42:exp:41:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, AES-192-CBC, 1.2, MD5, EtM, CID 4+0
depends_on:19:4:9:6:22:20
21:exp:42:exp:41:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, AES-192-CBC, 1.2, MD5, short tag
depends_on:4:9:6:22
21:exp:42:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.2, MD5, short tag, CID 4+4
depends_on:19:4:9:6:22
21:exp:42:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, AES-192-CBC, 1.2, MD5, short tag, CID 4+0
depends_on:19:4:9:6:22
21:exp:42:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, AES-192-CBC, 1.2, MD5, short tag, EtM
depends_on:4:9:6:22:20
21:exp:42:exp:41:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.2, MD5, short tag, EtM, CID 4+4
depends_on:19:4:9:6:22:20
21:exp:42:exp:41:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, AES-192-CBC, 1.2, MD5, short tag, EtM, CID 4+0
depends_on:19:4:9:6:22:20
21:exp:42:exp:41:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, AES-192-CBC, 1.1, SHA-384
depends_on:4:9:5:7:8
21:exp:42:exp:38:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.1, SHA-384, EtM
depends_on:4:9:5:7:8:20
21:exp:42:exp:38:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.1, SHA-384, short tag
depends_on:4:9:5:7:8
21:exp:42:exp:38:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.1, SHA-384, short tag, EtM
depends_on:4:9:5:7:8:20
21:exp:42:exp:38:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.1, SHA-256
depends_on:4:9:5:13
21:exp:42:exp:39:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.1, SHA-256, EtM
depends_on:4:9:5:13:20
21:exp:42:exp:39:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.1, SHA-256, short tag
depends_on:4:9:5:13
21:exp:42:exp:39:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.1, SHA-256, short tag, EtM
depends_on:4:9:5:13:20
21:exp:42:exp:39:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.1, SHA-1
depends_on:4:9:5:21
21:exp:42:exp:40:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.1, SHA-1, EtM
depends_on:4:9:5:21:20
21:exp:42:exp:40:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.1, SHA-1, short tag
depends_on:4:9:5:21
21:exp:42:exp:40:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.1, SHA-1, short tag, EtM
depends_on:4:9:5:21:20
21:exp:42:exp:40:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.1, MD5
depends_on:4:9:5:22
21:exp:42:exp:41:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.1, MD5, EtM
depends_on:4:9:5:22:20
21:exp:42:exp:41:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.1, MD5, short tag
depends_on:4:9:5:22
21:exp:42:exp:41:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.1, MD5, short tag, EtM
depends_on:4:9:5:22:20
21:exp:42:exp:41:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.0, SHA-384
depends_on:4:9:3:7:8
21:exp:42:exp:38:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.0, SHA-384, EtM
depends_on:4:9:3:7:8:20
21:exp:42:exp:38:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.0, SHA-384, short tag
depends_on:4:9:3:7:8
21:exp:42:exp:38:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.0, SHA-384, short tag, EtM
depends_on:4:9:3:7:8:20
21:exp:42:exp:38:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.0, SHA-256
depends_on:4:9:3:13
21:exp:42:exp:39:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.0, SHA-256, EtM
depends_on:4:9:3:13:20
21:exp:42:exp:39:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.0, SHA-256, short tag
depends_on:4:9:3:13
21:exp:42:exp:39:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.0, SHA-256, short tag, EtM
depends_on:4:9:3:13:20
21:exp:42:exp:39:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.0, SHA-1
depends_on:4:9:3:21
21:exp:42:exp:40:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.0, SHA-1, EtM
depends_on:4:9:3:21:20
21:exp:42:exp:40:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.0, SHA-1, short tag
depends_on:4:9:3:21
21:exp:42:exp:40:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.0, SHA-1, short tag, EtM
depends_on:4:9:3:21:20
21:exp:42:exp:40:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.0, MD5
depends_on:4:9:3:22
21:exp:42:exp:41:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.0, MD5, EtM
depends_on:4:9:3:22:20
21:exp:42:exp:41:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.0, MD5, short tag
depends_on:4:9:3:22
21:exp:42:exp:41:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, AES-192-CBC, 1.0, MD5, short tag, EtM
depends_on:4:9:3:22:20
21:exp:42:exp:41:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, AES-192-CBC, SSL3, SHA-1
depends_on:4:9:0:21
21:exp:42:exp:40:int:0:int:0:exp:21:int:0:int:0
Record crypt, little space, AES-192-CBC, SSL3, SHA-1, EtM
depends_on:4:9:0:21:20
21:exp:42:exp:40:int:1:int:0:exp:21:int:0:int:0
Record crypt, little space, AES-192-CBC, SSL3, SHA-1, short tag
depends_on:4:9:0:21
21:exp:42:exp:40:int:0:int:1:exp:21:int:0:int:0
Record crypt, little space, AES-192-CBC, SSL3, SHA-1, short tag, EtM
depends_on:4:9:0:21:20
21:exp:42:exp:40:int:1:int:1:exp:21:int:0:int:0
Record crypt, little space, AES-192-CBC, SSL3, MD5
depends_on:4:9:0:22
21:exp:42:exp:41:int:0:int:0:exp:21:int:0:int:0
Record crypt, little space, AES-192-CBC, SSL3, MD5, EtM
depends_on:4:9:0:22:20
21:exp:42:exp:41:int:1:int:0:exp:21:int:0:int:0
Record crypt, little space, AES-192-CBC, SSL3, MD5, short tag
depends_on:4:9:0:22
21:exp:42:exp:41:int:0:int:1:exp:21:int:0:int:0
Record crypt, little space, AES-192-CBC, SSL3, MD5, short tag, EtM
depends_on:4:9:0:22:20
21:exp:42:exp:41:int:1:int:1:exp:21:int:0:int:0
Record crypt, little space, AES256-CBC, 1.2, SHA-384
depends_on:4:9:6:7:8
21:exp:43:exp:38:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, AES256-CBC, 1.2, SHA-384, CID 4+4
depends_on:19:4:9:6:7:8
21:exp:43:exp:38:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, AES256-CBC, 1.2, SHA-384, CID 4+0
depends_on:19:4:9:6:7:8
21:exp:43:exp:38:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, AES256-CBC, 1.2, SHA-384, EtM
depends_on:4:9:6:7:8:20
21:exp:43:exp:38:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, AES256-CBC, 1.2, SHA-384, EtM, CID 4+4
depends_on:19:4:9:6:7:8:20
21:exp:43:exp:38:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, AES256-CBC, 1.2, SHA-384, EtM, CID 4+0
depends_on:19:4:9:6:7:8:20
21:exp:43:exp:38:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, AES256-CBC, 1.2, SHA-384, short tag
depends_on:4:9:6:7:8
21:exp:43:exp:38:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, AES256-CBC, 1.2, SHA-384, short tag, CID 4+4
depends_on:19:4:9:6:7:8
21:exp:43:exp:38:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, AES256-CBC, 1.2, SHA-384, short tag, CID 4+0
depends_on:19:4:9:6:7:8
21:exp:43:exp:38:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, AES256-CBC, 1.2, SHA-384, short tag, EtM
depends_on:4:9:6:7:8:20
21:exp:43:exp:38:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, AES256-CBC, 1.2, SHA-384, short tag, EtM, CID 4+4
depends_on:19:4:9:6:7:8:20
21:exp:43:exp:38:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, AES256-CBC, 1.2, SHA-384, short tag, EtM, CID 4+0
depends_on:19:4:9:6:7:8:20
21:exp:43:exp:38:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, AES256-CBC, 1.2, SHA-256
depends_on:4:9:6:13
21:exp:43:exp:39:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, AES256-CBC, 1.2, SHA-256, CID 4+4
depends_on:19:4:9:6:13
21:exp:43:exp:39:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, AES256-CBC, 1.2, SHA-256, CID 4+0
depends_on:19:4:9:6:13
21:exp:43:exp:39:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, AES256-CBC, 1.2, SHA-256, EtM
depends_on:4:9:6:13:20
21:exp:43:exp:39:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, AES256-CBC, 1.2, SHA-256, EtM, CID 4+4
depends_on:19:4:9:6:13:20
21:exp:43:exp:39:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, AES256-CBC, 1.2, SHA-256, EtM, CID 4+0
depends_on:19:4:9:6:13:20
21:exp:43:exp:39:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, AES256-CBC, 1.2, SHA-256, short tag
depends_on:4:9:6:13
21:exp:43:exp:39:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, AES256-CBC, 1.2, SHA-256, short tag, CID 4+4
depends_on:19:4:9:6:13
21:exp:43:exp:39:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, AES256-CBC, 1.2, SHA-256, short tag, CID 4+0
depends_on:19:4:9:6:13
21:exp:43:exp:39:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, AES256-CBC, 1.2, SHA-256, short tag, EtM
depends_on:4:9:6:13:20
21:exp:43:exp:39:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, AES256-CBC, 1.2, SHA-256, short tag, EtM, CID 4+4
depends_on:19:4:9:6:13:20
21:exp:43:exp:39:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, AES256-CBC, 1.2, SHA-256, short tag, EtM, CID 4+0
depends_on:19:4:9:6:13:20
21:exp:43:exp:39:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, AES256-CBC, 1.2, SHA-1
depends_on:4:9:6:21
21:exp:43:exp:40:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, AES256-CBC, 1.2, SHA-1, CID 4+4
depends_on:19:4:9:6:21
21:exp:43:exp:40:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, AES256-CBC, 1.2, SHA-1, CID 4+0
depends_on:19:4:9:6:21
21:exp:43:exp:40:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, AES256-CBC, 1.2, SHA-1, EtM
depends_on:4:9:6:21:20
21:exp:43:exp:40:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, AES256-CBC, 1.2, SHA-1, EtM, CID 4+4
depends_on:19:4:9:6:21:20
21:exp:43:exp:40:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, AES256-CBC, 1.2, SHA-1, EtM, CID 4+0
depends_on:19:4:9:6:21:20
21:exp:43:exp:40:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, AES256-CBC, 1.2, SHA-1, short tag
depends_on:4:9:6:21
21:exp:43:exp:40:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, AES256-CBC, 1.2, SHA-1, short tag, CID 4+4
depends_on:19:4:9:6:21
21:exp:43:exp:40:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, AES256-CBC, 1.2, SHA-1, short tag, CID 4+0
depends_on:19:4:9:6:21
21:exp:43:exp:40:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, AES256-CBC, 1.2, SHA-1, short tag, EtM
depends_on:4:9:6:21:20
21:exp:43:exp:40:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, AES256-CBC, 1.2, SHA-1, short tag, EtM, CID 4+4
depends_on:19:4:9:6:21:20
21:exp:43:exp:40:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, AES256-CBC, 1.2, SHA-1, short tag, EtM, CID 4+0
depends_on:19:4:9:6:21:20
21:exp:43:exp:40:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, AES256-CBC, 1.2, MD5
depends_on:4:9:6:22
21:exp:43:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, AES256-CBC, 1.2, MD5, CID 4+4
depends_on:19:4:9:6:22
21:exp:43:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, AES256-CBC, 1.2, MD5, CID 4+0
depends_on:19:4:9:6:22
21:exp:43:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, AES256-CBC, 1.2, MD5, EtM
depends_on:4:9:6:22:20
21:exp:43:exp:41:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, AES256-CBC, 1.2, MD5, EtM, CID 4+4
depends_on:19:4:9:6:22:20
21:exp:43:exp:41:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, AES256-CBC, 1.2, MD5, EtM, CID 4+0
depends_on:19:4:9:6:22:20
21:exp:43:exp:41:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, AES256-CBC, 1.2, MD5, short tag
depends_on:4:9:6:22
21:exp:43:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, AES256-CBC, 1.2, MD5, short tag, CID 4+4
depends_on:19:4:9:6:22
21:exp:43:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, AES256-CBC, 1.2, MD5, short tag, CID 4+0
depends_on:19:4:9:6:22
21:exp:43:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, AES256-CBC, 1.2, MD5, short tag, EtM
depends_on:4:9:6:22:20
21:exp:43:exp:41:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, AES256-CBC, 1.2, MD5, short tag, EtM, CID 4+4
depends_on:19:4:9:6:22:20
21:exp:43:exp:41:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, AES256-CBC, 1.2, MD5, short tag, EtM, CID 4+0
depends_on:19:4:9:6:22:20
21:exp:43:exp:41:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, AES256-CBC, 1.1, SHA-384
depends_on:4:9:5:7:8
21:exp:43:exp:38:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, AES256-CBC, 1.1, SHA-384, EtM
depends_on:4:9:5:7:8:20
21:exp:43:exp:38:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, AES256-CBC, 1.1, SHA-384, short tag
depends_on:4:9:5:7:8
21:exp:43:exp:38:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, AES256-CBC, 1.1, SHA-384, short tag, EtM
depends_on:4:9:5:7:8:20
21:exp:43:exp:38:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, AES256-CBC, 1.1, SHA-256
depends_on:4:9:5:13
21:exp:43:exp:39:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, AES256-CBC, 1.1, SHA-256, EtM
depends_on:4:9:5:13:20
21:exp:43:exp:39:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, AES256-CBC, 1.1, SHA-256, short tag
depends_on:4:9:5:13
21:exp:43:exp:39:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, AES256-CBC, 1.1, SHA-256, short tag, EtM
depends_on:4:9:5:13:20
21:exp:43:exp:39:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, AES256-CBC, 1.1, SHA-1
depends_on:4:9:5:21
21:exp:43:exp:40:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, AES256-CBC, 1.1, SHA-1, EtM
depends_on:4:9:5:21:20
21:exp:43:exp:40:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, AES256-CBC, 1.1, SHA-1, short tag
depends_on:4:9:5:21
21:exp:43:exp:40:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, AES256-CBC, 1.1, SHA-1, short tag, EtM
depends_on:4:9:5:21:20
21:exp:43:exp:40:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, AES256-CBC, 1.1, MD5
depends_on:4:9:5:22
21:exp:43:exp:41:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, AES256-CBC, 1.1, MD5, EtM
depends_on:4:9:5:22:20
21:exp:43:exp:41:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, AES256-CBC, 1.1, MD5, short tag
depends_on:4:9:5:22
21:exp:43:exp:41:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, AES256-CBC, 1.1, MD5, short tag, EtM
depends_on:4:9:5:22:20
21:exp:43:exp:41:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, AES256-CBC, 1.0, SHA-384
depends_on:4:9:3:7:8
21:exp:43:exp:38:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, AES256-CBC, 1.0, SHA-384, EtM
depends_on:4:9:3:7:8:20
21:exp:43:exp:38:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, AES256-CBC, 1.0, SHA-384, short tag
depends_on:4:9:3:7:8
21:exp:43:exp:38:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, AES256-CBC, 1.0, SHA-384, short tag, EtM
depends_on:4:9:3:7:8:20
21:exp:43:exp:38:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, AES256-CBC, 1.0, SHA-256
depends_on:4:9:3:13
21:exp:43:exp:39:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, AES256-CBC, 1.0, SHA-256, EtM
depends_on:4:9:3:13:20
21:exp:43:exp:39:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, AES256-CBC, 1.0, SHA-256, short tag
depends_on:4:9:3:13
21:exp:43:exp:39:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, AES256-CBC, 1.0, SHA-256, short tag, EtM
depends_on:4:9:3:13:20
21:exp:43:exp:39:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, AES256-CBC, 1.0, SHA-1
depends_on:4:9:3:21
21:exp:43:exp:40:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, AES256-CBC, 1.0, SHA-1, EtM
depends_on:4:9:3:21:20
21:exp:43:exp:40:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, AES256-CBC, 1.0, SHA-1, short tag
depends_on:4:9:3:21
21:exp:43:exp:40:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, AES256-CBC, 1.0, SHA-1, short tag, EtM
depends_on:4:9:3:21:20
21:exp:43:exp:40:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, AES256-CBC, 1.0, MD5
depends_on:4:9:3:22
21:exp:43:exp:41:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, AES256-CBC, 1.0, MD5, EtM
depends_on:4:9:3:22:20
21:exp:43:exp:41:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, AES256-CBC, 1.0, MD5, short tag
depends_on:4:9:3:22
21:exp:43:exp:41:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, AES256-CBC, 1.0, MD5, short tag, EtM
depends_on:4:9:3:22:20
21:exp:43:exp:41:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, AES256-CBC, SSL3, SHA-1
depends_on:4:9:0:21
21:exp:43:exp:40:int:0:int:0:exp:21:int:0:int:0
Record crypt, little space, AES256-CBC, SSL3, SHA-1, EtM
depends_on:4:9:0:21:20
21:exp:43:exp:40:int:1:int:0:exp:21:int:0:int:0
Record crypt, little space, AES256-CBC, SSL3, SHA-1, short tag
depends_on:4:9:0:21
21:exp:43:exp:40:int:0:int:1:exp:21:int:0:int:0
Record crypt, little space, AES256-CBC, SSL3, SHA-1, short tag, EtM
depends_on:4:9:0:21:20
21:exp:43:exp:40:int:1:int:1:exp:21:int:0:int:0
Record crypt, little space, AES256-CBC, SSL3, MD5
depends_on:4:9:0:22
21:exp:43:exp:41:int:0:int:0:exp:21:int:0:int:0
Record crypt, little space, AES256-CBC, SSL3, MD5, EtM
depends_on:4:9:0:22:20
21:exp:43:exp:41:int:1:int:0:exp:21:int:0:int:0
Record crypt, little space, AES256-CBC, SSL3, MD5, short tag
depends_on:4:9:0:22
21:exp:43:exp:41:int:0:int:1:exp:21:int:0:int:0
Record crypt, little space, AES256-CBC, SSL3, MD5, short tag, EtM
depends_on:4:9:0:22:20
21:exp:43:exp:41:int:1:int:1:exp:21:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-384
depends_on:4:23:6:7:8
21:exp:44:exp:38:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-384, CID 4+4
depends_on:19:4:23:6:7:8
21:exp:44:exp:38:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-384, CID 4+0
depends_on:19:4:23:6:7:8
21:exp:44:exp:38:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-384, EtM
depends_on:4:23:6:7:8:20
21:exp:44:exp:38:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-384, EtM, CID 4+4
depends_on:19:4:23:6:7:8:20
21:exp:44:exp:38:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-384, EtM, CID 4+0
depends_on:19:4:23:6:7:8:20
21:exp:44:exp:38:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-384, short tag
depends_on:4:23:6:7:8
21:exp:44:exp:38:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-384, short tag, CID 4+4
depends_on:19:4:23:6:7:8
21:exp:44:exp:38:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-384, short tag, CID 4+0
depends_on:19:4:23:6:7:8
21:exp:44:exp:38:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-384, short tag, EtM
depends_on:4:23:6:7:8:20
21:exp:44:exp:38:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-384, short tag, EtM, CID 4+4
depends_on:19:4:23:6:7:8:20
21:exp:44:exp:38:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-384, short tag, EtM, CID 4+0
depends_on:19:4:23:6:7:8:20
21:exp:44:exp:38:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-256
depends_on:4:23:6:13
21:exp:44:exp:39:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-256, CID 4+4
depends_on:19:4:23:6:13
21:exp:44:exp:39:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-256, CID 4+0
depends_on:19:4:23:6:13
21:exp:44:exp:39:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-256, EtM
depends_on:4:23:6:13:20
21:exp:44:exp:39:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-256, EtM, CID 4+4
depends_on:19:4:23:6:13:20
21:exp:44:exp:39:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-256, EtM, CID 4+0
depends_on:19:4:23:6:13:20
21:exp:44:exp:39:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-256, short tag
depends_on:4:23:6:13
21:exp:44:exp:39:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-256, short tag, CID 4+4
depends_on:19:4:23:6:13
21:exp:44:exp:39:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-256, short tag, CID 4+0
depends_on:19:4:23:6:13
21:exp:44:exp:39:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-256, short tag, EtM
depends_on:4:23:6:13:20
21:exp:44:exp:39:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-256, short tag, EtM, CID 4+4
depends_on:19:4:23:6:13:20
21:exp:44:exp:39:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-256, short tag, EtM, CID 4+0
depends_on:19:4:23:6:13:20
21:exp:44:exp:39:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-1
depends_on:4:23:6:21
21:exp:44:exp:40:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-1, CID 4+4
depends_on:19:4:23:6:21
21:exp:44:exp:40:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-1, CID 4+0
depends_on:19:4:23:6:21
21:exp:44:exp:40:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-1, EtM
depends_on:4:23:6:21:20
21:exp:44:exp:40:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-1, EtM, CID 4+4
depends_on:19:4:23:6:21:20
21:exp:44:exp:40:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-1, EtM, CID 4+0
depends_on:19:4:23:6:21:20
21:exp:44:exp:40:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-1, short tag
depends_on:4:23:6:21
21:exp:44:exp:40:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-1, short tag, CID 4+4
depends_on:19:4:23:6:21
21:exp:44:exp:40:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-1, short tag, CID 4+0
depends_on:19:4:23:6:21
21:exp:44:exp:40:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-1, short tag, EtM
depends_on:4:23:6:21:20
21:exp:44:exp:40:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-1, short tag, EtM, CID 4+4
depends_on:19:4:23:6:21:20
21:exp:44:exp:40:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, ARIA-128-CBC, 1.2, SHA-1, short tag, EtM, CID 4+0
depends_on:19:4:23:6:21:20
21:exp:44:exp:40:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, ARIA-128-CBC, 1.2, MD5
depends_on:4:23:6:22
21:exp:44:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.2, MD5, CID 4+4
depends_on:19:4:23:6:22
21:exp:44:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, ARIA-128-CBC, 1.2, MD5, CID 4+0
depends_on:19:4:23:6:22
21:exp:44:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, ARIA-128-CBC, 1.2, MD5, EtM
depends_on:4:23:6:22:20
21:exp:44:exp:41:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.2, MD5, EtM, CID 4+4
depends_on:19:4:23:6:22:20
21:exp:44:exp:41:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, ARIA-128-CBC, 1.2, MD5, EtM, CID 4+0
depends_on:19:4:23:6:22:20
21:exp:44:exp:41:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, ARIA-128-CBC, 1.2, MD5, short tag
depends_on:4:23:6:22
21:exp:44:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.2, MD5, short tag, CID 4+4
depends_on:19:4:23:6:22
21:exp:44:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, ARIA-128-CBC, 1.2, MD5, short tag, CID 4+0
depends_on:19:4:23:6:22
21:exp:44:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, ARIA-128-CBC, 1.2, MD5, short tag, EtM
depends_on:4:23:6:22:20
21:exp:44:exp:41:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.2, MD5, short tag, EtM, CID 4+4
depends_on:19:4:23:6:22:20
21:exp:44:exp:41:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, ARIA-128-CBC, 1.2, MD5, short tag, EtM, CID 4+0
depends_on:19:4:23:6:22:20
21:exp:44:exp:41:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, ARIA-128-CBC, 1.1, SHA-384
depends_on:4:23:5:7:8
21:exp:44:exp:38:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.1, SHA-384, EtM
depends_on:4:23:5:7:8:20
21:exp:44:exp:38:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.1, SHA-384, short tag
depends_on:4:23:5:7:8
21:exp:44:exp:38:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.1, SHA-384, short tag, EtM
depends_on:4:23:5:7:8:20
21:exp:44:exp:38:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.1, SHA-256
depends_on:4:23:5:13
21:exp:44:exp:39:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.1, SHA-256, EtM
depends_on:4:23:5:13:20
21:exp:44:exp:39:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.1, SHA-256, short tag
depends_on:4:23:5:13
21:exp:44:exp:39:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.1, SHA-256, short tag, EtM
depends_on:4:23:5:13:20
21:exp:44:exp:39:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.1, SHA-1
depends_on:4:23:5:21
21:exp:44:exp:40:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.1, SHA-1, EtM
depends_on:4:23:5:21:20
21:exp:44:exp:40:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.1, SHA-1, short tag
depends_on:4:23:5:21
21:exp:44:exp:40:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.1, SHA-1, short tag, EtM
depends_on:4:23:5:21:20
21:exp:44:exp:40:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.1, MD5
depends_on:4:23:5:22
21:exp:44:exp:41:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.1, MD5, EtM
depends_on:4:23:5:22:20
21:exp:44:exp:41:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.1, MD5, short tag
depends_on:4:23:5:22
21:exp:44:exp:41:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.1, MD5, short tag, EtM
depends_on:4:23:5:22:20
21:exp:44:exp:41:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.0, SHA-384
depends_on:4:23:3:7:8
21:exp:44:exp:38:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.0, SHA-384, EtM
depends_on:4:23:3:7:8:20
21:exp:44:exp:38:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.0, SHA-384, short tag
depends_on:4:23:3:7:8
21:exp:44:exp:38:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.0, SHA-384, short tag, EtM
depends_on:4:23:3:7:8:20
21:exp:44:exp:38:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.0, SHA-256
depends_on:4:23:3:13
21:exp:44:exp:39:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.0, SHA-256, EtM
depends_on:4:23:3:13:20
21:exp:44:exp:39:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.0, SHA-256, short tag
depends_on:4:23:3:13
21:exp:44:exp:39:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.0, SHA-256, short tag, EtM
depends_on:4:23:3:13:20
21:exp:44:exp:39:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.0, SHA-1
depends_on:4:23:3:21
21:exp:44:exp:40:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.0, SHA-1, EtM
depends_on:4:23:3:21:20
21:exp:44:exp:40:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.0, SHA-1, short tag
depends_on:4:23:3:21
21:exp:44:exp:40:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.0, SHA-1, short tag, EtM
depends_on:4:23:3:21:20
21:exp:44:exp:40:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.0, MD5
depends_on:4:23:3:22
21:exp:44:exp:41:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.0, MD5, EtM
depends_on:4:23:3:22:20
21:exp:44:exp:41:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.0, MD5, short tag
depends_on:4:23:3:22
21:exp:44:exp:41:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, ARIA-128-CBC, 1.0, MD5, short tag, EtM
depends_on:4:23:3:22:20
21:exp:44:exp:41:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, ARIA-128-CBC, SSL3, SHA-1
depends_on:4:23:0:21
21:exp:44:exp:40:int:0:int:0:exp:21:int:0:int:0
Record crypt, little space, ARIA-128-CBC, SSL3, SHA-1, EtM
depends_on:4:23:0:21:20
21:exp:44:exp:40:int:1:int:0:exp:21:int:0:int:0
Record crypt, little space, ARIA-128-CBC, SSL3, SHA-1, short tag
depends_on:4:23:0:21
21:exp:44:exp:40:int:0:int:1:exp:21:int:0:int:0
Record crypt, little space, ARIA-128-CBC, SSL3, SHA-1, short tag, EtM
depends_on:4:23:0:21:20
21:exp:44:exp:40:int:1:int:1:exp:21:int:0:int:0
Record crypt, little space, ARIA-128-CBC, SSL3, MD5
depends_on:4:23:0:22
21:exp:44:exp:41:int:0:int:0:exp:21:int:0:int:0
Record crypt, little space, ARIA-128-CBC, SSL3, MD5, EtM
depends_on:4:23:0:22:20
21:exp:44:exp:41:int:1:int:0:exp:21:int:0:int:0
Record crypt, little space, ARIA-128-CBC, SSL3, MD5, short tag
depends_on:4:23:0:22
21:exp:44:exp:41:int:0:int:1:exp:21:int:0:int:0
Record crypt, little space, ARIA-128-CBC, SSL3, MD5, short tag, EtM
depends_on:4:23:0:22:20
21:exp:44:exp:41:int:1:int:1:exp:21:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-384
depends_on:4:23:6:7:8
21:exp:45:exp:38:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-384, CID 4+4
depends_on:19:4:23:6:7:8
21:exp:45:exp:38:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-384, CID 4+0
depends_on:19:4:23:6:7:8
21:exp:45:exp:38:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-384, EtM
depends_on:4:23:6:7:8:20
21:exp:45:exp:38:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-384, EtM, CID 4+4
depends_on:19:4:23:6:7:8:20
21:exp:45:exp:38:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-384, EtM, CID 4+0
depends_on:19:4:23:6:7:8:20
21:exp:45:exp:38:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-384, short tag
depends_on:4:23:6:7:8
21:exp:45:exp:38:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-384, short tag, CID 4+4
depends_on:19:4:23:6:7:8
21:exp:45:exp:38:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-384, short tag, CID 4+0
depends_on:19:4:23:6:7:8
21:exp:45:exp:38:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-384, short tag, EtM
depends_on:4:23:6:7:8:20
21:exp:45:exp:38:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-384, short tag, EtM, CID 4+4
depends_on:19:4:23:6:7:8:20
21:exp:45:exp:38:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-384, short tag, EtM, CID 4+0
depends_on:19:4:23:6:7:8:20
21:exp:45:exp:38:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-256
depends_on:4:23:6:13
21:exp:45:exp:39:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-256, CID 4+4
depends_on:19:4:23:6:13
21:exp:45:exp:39:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-256, CID 4+0
depends_on:19:4:23:6:13
21:exp:45:exp:39:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-256, EtM
depends_on:4:23:6:13:20
21:exp:45:exp:39:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-256, EtM, CID 4+4
depends_on:19:4:23:6:13:20
21:exp:45:exp:39:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-256, EtM, CID 4+0
depends_on:19:4:23:6:13:20
21:exp:45:exp:39:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-256, short tag
depends_on:4:23:6:13
21:exp:45:exp:39:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-256, short tag, CID 4+4
depends_on:19:4:23:6:13
21:exp:45:exp:39:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-256, short tag, CID 4+0
depends_on:19:4:23:6:13
21:exp:45:exp:39:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-256, short tag, EtM
depends_on:4:23:6:13:20
21:exp:45:exp:39:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-256, short tag, EtM, CID 4+4
depends_on:19:4:23:6:13:20
21:exp:45:exp:39:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-256, short tag, EtM, CID 4+0
depends_on:19:4:23:6:13:20
21:exp:45:exp:39:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-1
depends_on:4:23:6:21
21:exp:45:exp:40:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-1, CID 4+4
depends_on:19:4:23:6:21
21:exp:45:exp:40:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-1, CID 4+0
depends_on:19:4:23:6:21
21:exp:45:exp:40:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-1, EtM
depends_on:4:23:6:21:20
21:exp:45:exp:40:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-1, EtM, CID 4+4
depends_on:19:4:23:6:21:20
21:exp:45:exp:40:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-1, EtM, CID 4+0
depends_on:19:4:23:6:21:20
21:exp:45:exp:40:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-1, short tag
depends_on:4:23:6:21
21:exp:45:exp:40:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-1, short tag, CID 4+4
depends_on:19:4:23:6:21
21:exp:45:exp:40:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-1, short tag, CID 4+0
depends_on:19:4:23:6:21
21:exp:45:exp:40:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-1, short tag, EtM
depends_on:4:23:6:21:20
21:exp:45:exp:40:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-1, short tag, EtM, CID 4+4
depends_on:19:4:23:6:21:20
21:exp:45:exp:40:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, ARIA-192-CBC, 1.2, SHA-1, short tag, EtM, CID 4+0
depends_on:19:4:23:6:21:20
21:exp:45:exp:40:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, ARIA-192-CBC, 1.2, MD5
depends_on:4:23:6:22
21:exp:45:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.2, MD5, CID 4+4
depends_on:19:4:23:6:22
21:exp:45:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, ARIA-192-CBC, 1.2, MD5, CID 4+0
depends_on:19:4:23:6:22
21:exp:45:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, ARIA-192-CBC, 1.2, MD5, EtM
depends_on:4:23:6:22:20
21:exp:45:exp:41:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.2, MD5, EtM, CID 4+4
depends_on:19:4:23:6:22:20
21:exp:45:exp:41:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, ARIA-192-CBC, 1.2, MD5, EtM, CID 4+0
depends_on:19:4:23:6:22:20
21:exp:45:exp:41:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, ARIA-192-CBC, 1.2, MD5, short tag
depends_on:4:23:6:22
21:exp:45:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.2, MD5, short tag, CID 4+4
depends_on:19:4:23:6:22
21:exp:45:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, ARIA-192-CBC, 1.2, MD5, short tag, CID 4+0
depends_on:19:4:23:6:22
21:exp:45:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, ARIA-192-CBC, 1.2, MD5, short tag, EtM
depends_on:4:23:6:22:20
21:exp:45:exp:41:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.2, MD5, short tag, EtM, CID 4+4
depends_on:19:4:23:6:22:20
21:exp:45:exp:41:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, ARIA-192-CBC, 1.2, MD5, short tag, EtM, CID 4+0
depends_on:19:4:23:6:22:20
21:exp:45:exp:41:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, ARIA-192-CBC, 1.1, SHA-384
depends_on:4:23:5:7:8
21:exp:45:exp:38:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.1, SHA-384, EtM
depends_on:4:23:5:7:8:20
21:exp:45:exp:38:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.1, SHA-384, short tag
depends_on:4:23:5:7:8
21:exp:45:exp:38:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.1, SHA-384, short tag, EtM
depends_on:4:23:5:7:8:20
21:exp:45:exp:38:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.1, SHA-256
depends_on:4:23:5:13
21:exp:45:exp:39:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.1, SHA-256, EtM
depends_on:4:23:5:13:20
21:exp:45:exp:39:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.1, SHA-256, short tag
depends_on:4:23:5:13
21:exp:45:exp:39:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.1, SHA-256, short tag, EtM
depends_on:4:23:5:13:20
21:exp:45:exp:39:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.1, SHA-1
depends_on:4:23:5:21
21:exp:45:exp:40:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.1, SHA-1, EtM
depends_on:4:23:5:21:20
21:exp:45:exp:40:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.1, SHA-1, short tag
depends_on:4:23:5:21
21:exp:45:exp:40:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.1, SHA-1, short tag, EtM
depends_on:4:23:5:21:20
21:exp:45:exp:40:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.1, MD5
depends_on:4:23:5:22
21:exp:45:exp:41:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.1, MD5, EtM
depends_on:4:23:5:22:20
21:exp:45:exp:41:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.1, MD5, short tag
depends_on:4:23:5:22
21:exp:45:exp:41:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.1, MD5, short tag, EtM
depends_on:4:23:5:22:20
21:exp:45:exp:41:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.0, SHA-384
depends_on:4:23:3:7:8
21:exp:45:exp:38:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.0, SHA-384, EtM
depends_on:4:23:3:7:8:20
21:exp:45:exp:38:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.0, SHA-384, short tag
depends_on:4:23:3:7:8
21:exp:45:exp:38:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.0, SHA-384, short tag, EtM
depends_on:4:23:3:7:8:20
21:exp:45:exp:38:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.0, SHA-256
depends_on:4:23:3:13
21:exp:45:exp:39:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.0, SHA-256, EtM
depends_on:4:23:3:13:20
21:exp:45:exp:39:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.0, SHA-256, short tag
depends_on:4:23:3:13
21:exp:45:exp:39:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.0, SHA-256, short tag, EtM
depends_on:4:23:3:13:20
21:exp:45:exp:39:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.0, SHA-1
depends_on:4:23:3:21
21:exp:45:exp:40:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.0, SHA-1, EtM
depends_on:4:23:3:21:20
21:exp:45:exp:40:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.0, SHA-1, short tag
depends_on:4:23:3:21
21:exp:45:exp:40:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.0, SHA-1, short tag, EtM
depends_on:4:23:3:21:20
21:exp:45:exp:40:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.0, MD5
depends_on:4:23:3:22
21:exp:45:exp:41:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.0, MD5, EtM
depends_on:4:23:3:22:20
21:exp:45:exp:41:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.0, MD5, short tag
depends_on:4:23:3:22
21:exp:45:exp:41:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, ARIA-192-CBC, 1.0, MD5, short tag, EtM
depends_on:4:23:3:22:20
21:exp:45:exp:41:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, ARIA-192-CBC, SSL3, SHA-1
depends_on:4:23:0:21
21:exp:45:exp:40:int:0:int:0:exp:21:int:0:int:0
Record crypt, little space, ARIA-192-CBC, SSL3, SHA-1, EtM
depends_on:4:23:0:21:20
21:exp:45:exp:40:int:1:int:0:exp:21:int:0:int:0
Record crypt, little space, ARIA-192-CBC, SSL3, SHA-1, short tag
depends_on:4:23:0:21
21:exp:45:exp:40:int:0:int:1:exp:21:int:0:int:0
Record crypt, little space, ARIA-192-CBC, SSL3, SHA-1, short tag, EtM
depends_on:4:23:0:21:20
21:exp:45:exp:40:int:1:int:1:exp:21:int:0:int:0
Record crypt, little space, ARIA-192-CBC, SSL3, MD5
depends_on:4:23:0:22
21:exp:45:exp:41:int:0:int:0:exp:21:int:0:int:0
Record crypt, little space, ARIA-192-CBC, SSL3, MD5, EtM
depends_on:4:23:0:22:20
21:exp:45:exp:41:int:1:int:0:exp:21:int:0:int:0
Record crypt, little space, ARIA-192-CBC, SSL3, MD5, short tag
depends_on:4:23:0:22
21:exp:45:exp:41:int:0:int:1:exp:21:int:0:int:0
Record crypt, little space, ARIA-192-CBC, SSL3, MD5, short tag, EtM
depends_on:4:23:0:22:20
21:exp:45:exp:41:int:1:int:1:exp:21:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-384
depends_on:4:23:6:7:8
21:exp:46:exp:38:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-384, CID 4+4
depends_on:19:4:23:6:7:8
21:exp:46:exp:38:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-384, CID 4+0
depends_on:19:4:23:6:7:8
21:exp:46:exp:38:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-384, EtM
depends_on:4:23:6:7:8:20
21:exp:46:exp:38:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-384, EtM, CID 4+4
depends_on:19:4:23:6:7:8:20
21:exp:46:exp:38:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-384, EtM, CID 4+0
depends_on:19:4:23:6:7:8:20
21:exp:46:exp:38:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-384, short tag
depends_on:4:23:6:7:8
21:exp:46:exp:38:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-384, short tag, CID 4+4
depends_on:19:4:23:6:7:8
21:exp:46:exp:38:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-384, short tag, CID 4+0
depends_on:19:4:23:6:7:8
21:exp:46:exp:38:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-384, short tag, EtM
depends_on:4:23:6:7:8:20
21:exp:46:exp:38:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-384, short tag, EtM, CID 4+4
depends_on:19:4:23:6:7:8:20
21:exp:46:exp:38:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-384, short tag, EtM, CID 4+0
depends_on:19:4:23:6:7:8:20
21:exp:46:exp:38:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-256
depends_on:4:23:6:13
21:exp:46:exp:39:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-256, CID 4+4
depends_on:19:4:23:6:13
21:exp:46:exp:39:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-256, CID 4+0
depends_on:19:4:23:6:13
21:exp:46:exp:39:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-256, EtM
depends_on:4:23:6:13:20
21:exp:46:exp:39:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-256, EtM, CID 4+4
depends_on:19:4:23:6:13:20
21:exp:46:exp:39:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-256, EtM, CID 4+0
depends_on:19:4:23:6:13:20
21:exp:46:exp:39:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-256, short tag
depends_on:4:23:6:13
21:exp:46:exp:39:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-256, short tag, CID 4+4
depends_on:19:4:23:6:13
21:exp:46:exp:39:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-256, short tag, CID 4+0
depends_on:19:4:23:6:13
21:exp:46:exp:39:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-256, short tag, EtM
depends_on:4:23:6:13:20
21:exp:46:exp:39:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-256, short tag, EtM, CID 4+4
depends_on:19:4:23:6:13:20
21:exp:46:exp:39:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-256, short tag, EtM, CID 4+0
depends_on:19:4:23:6:13:20
21:exp:46:exp:39:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-1
depends_on:4:23:6:21
21:exp:46:exp:40:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-1, CID 4+4
depends_on:19:4:23:6:21
21:exp:46:exp:40:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-1, CID 4+0
depends_on:19:4:23:6:21
21:exp:46:exp:40:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-1, EtM
depends_on:4:23:6:21:20
21:exp:46:exp:40:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-1, EtM, CID 4+4
depends_on:19:4:23:6:21:20
21:exp:46:exp:40:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-1, EtM, CID 4+0
depends_on:19:4:23:6:21:20
21:exp:46:exp:40:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-1, short tag
depends_on:4:23:6:21
21:exp:46:exp:40:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-1, short tag, CID 4+4
depends_on:19:4:23:6:21
21:exp:46:exp:40:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-1, short tag, CID 4+0
depends_on:19:4:23:6:21
21:exp:46:exp:40:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-1, short tag, EtM
depends_on:4:23:6:21:20
21:exp:46:exp:40:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-1, short tag, EtM, CID 4+4
depends_on:19:4:23:6:21:20
21:exp:46:exp:40:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, ARIA-256-CBC, 1.2, SHA-1, short tag, EtM, CID 4+0
depends_on:19:4:23:6:21:20
21:exp:46:exp:40:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, ARIA-256-CBC, 1.2, MD5
depends_on:4:23:6:22
21:exp:46:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.2, MD5, CID 4+4
depends_on:19:4:23:6:22
21:exp:46:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, ARIA-256-CBC, 1.2, MD5, CID 4+0
depends_on:19:4:23:6:22
21:exp:46:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, ARIA-256-CBC, 1.2, MD5, EtM
depends_on:4:23:6:22:20
21:exp:46:exp:41:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.2, MD5, EtM, CID 4+4
depends_on:19:4:23:6:22:20
21:exp:46:exp:41:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, ARIA-256-CBC, 1.2, MD5, EtM, CID 4+0
depends_on:19:4:23:6:22:20
21:exp:46:exp:41:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, ARIA-256-CBC, 1.2, MD5, short tag
depends_on:4:23:6:22
21:exp:46:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.2, MD5, short tag, CID 4+4
depends_on:19:4:23:6:22
21:exp:46:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, ARIA-256-CBC, 1.2, MD5, short tag, CID 4+0
depends_on:19:4:23:6:22
21:exp:46:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, ARIA-256-CBC, 1.2, MD5, short tag, EtM
depends_on:4:23:6:22:20
21:exp:46:exp:41:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.2, MD5, short tag, EtM, CID 4+4
depends_on:19:4:23:6:22:20
21:exp:46:exp:41:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, ARIA-256-CBC, 1.2, MD5, short tag, EtM, CID 4+0
depends_on:19:4:23:6:22:20
21:exp:46:exp:41:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, ARIA-256-CBC, 1.1, SHA-384
depends_on:4:23:5:7:8
21:exp:46:exp:38:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.1, SHA-384, EtM
depends_on:4:23:5:7:8:20
21:exp:46:exp:38:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.1, SHA-384, short tag
depends_on:4:23:5:7:8
21:exp:46:exp:38:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.1, SHA-384, short tag, EtM
depends_on:4:23:5:7:8:20
21:exp:46:exp:38:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.1, SHA-256
depends_on:4:23:5:13
21:exp:46:exp:39:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.1, SHA-256, EtM
depends_on:4:23:5:13:20
21:exp:46:exp:39:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.1, SHA-256, short tag
depends_on:4:23:5:13
21:exp:46:exp:39:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.1, SHA-256, short tag, EtM
depends_on:4:23:5:13:20
21:exp:46:exp:39:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.1, SHA-1
depends_on:4:23:5:21
21:exp:46:exp:40:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.1, SHA-1, EtM
depends_on:4:23:5:21:20
21:exp:46:exp:40:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.1, SHA-1, short tag
depends_on:4:23:5:21
21:exp:46:exp:40:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.1, SHA-1, short tag, EtM
depends_on:4:23:5:21:20
21:exp:46:exp:40:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.1, MD5
depends_on:4:23:5:22
21:exp:46:exp:41:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.1, MD5, EtM
depends_on:4:23:5:22:20
21:exp:46:exp:41:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.1, MD5, short tag
depends_on:4:23:5:22
21:exp:46:exp:41:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.1, MD5, short tag, EtM
depends_on:4:23:5:22:20
21:exp:46:exp:41:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.0, SHA-384
depends_on:4:23:3:7:8
21:exp:46:exp:38:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.0, SHA-384, EtM
depends_on:4:23:3:7:8:20
21:exp:46:exp:38:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.0, SHA-384, short tag
depends_on:4:23:3:7:8
21:exp:46:exp:38:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.0, SHA-384, short tag, EtM
depends_on:4:23:3:7:8:20
21:exp:46:exp:38:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.0, SHA-256
depends_on:4:23:3:13
21:exp:46:exp:39:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.0, SHA-256, EtM
depends_on:4:23:3:13:20
21:exp:46:exp:39:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.0, SHA-256, short tag
depends_on:4:23:3:13
21:exp:46:exp:39:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.0, SHA-256, short tag, EtM
depends_on:4:23:3:13:20
21:exp:46:exp:39:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.0, SHA-1
depends_on:4:23:3:21
21:exp:46:exp:40:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.0, SHA-1, EtM
depends_on:4:23:3:21:20
21:exp:46:exp:40:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.0, SHA-1, short tag
depends_on:4:23:3:21
21:exp:46:exp:40:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.0, SHA-1, short tag, EtM
depends_on:4:23:3:21:20
21:exp:46:exp:40:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.0, MD5
depends_on:4:23:3:22
21:exp:46:exp:41:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.0, MD5, EtM
depends_on:4:23:3:22:20
21:exp:46:exp:41:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.0, MD5, short tag
depends_on:4:23:3:22
21:exp:46:exp:41:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, ARIA-256-CBC, 1.0, MD5, short tag, EtM
depends_on:4:23:3:22:20
21:exp:46:exp:41:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, ARIA-256-CBC, SSL3, SHA-1
depends_on:4:23:0:21
21:exp:46:exp:40:int:0:int:0:exp:21:int:0:int:0
Record crypt, little space, ARIA-256-CBC, SSL3, SHA-1, EtM
depends_on:4:23:0:21:20
21:exp:46:exp:40:int:1:int:0:exp:21:int:0:int:0
Record crypt, little space, ARIA-256-CBC, SSL3, SHA-1, short tag
depends_on:4:23:0:21
21:exp:46:exp:40:int:0:int:1:exp:21:int:0:int:0
Record crypt, little space, ARIA-256-CBC, SSL3, SHA-1, short tag, EtM
depends_on:4:23:0:21:20
21:exp:46:exp:40:int:1:int:1:exp:21:int:0:int:0
Record crypt, little space, ARIA-256-CBC, SSL3, MD5
depends_on:4:23:0:22
21:exp:46:exp:41:int:0:int:0:exp:21:int:0:int:0
Record crypt, little space, ARIA-256-CBC, SSL3, MD5, EtM
depends_on:4:23:0:22:20
21:exp:46:exp:41:int:1:int:0:exp:21:int:0:int:0
Record crypt, little space, ARIA-256-CBC, SSL3, MD5, short tag
depends_on:4:23:0:22
21:exp:46:exp:41:int:0:int:1:exp:21:int:0:int:0
Record crypt, little space, ARIA-256-CBC, SSL3, MD5, short tag, EtM
depends_on:4:23:0:22:20
21:exp:46:exp:41:int:1:int:1:exp:21:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-384
depends_on:4:16:6:7:8
21:exp:47:exp:38:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-384, CID 4+4
depends_on:19:4:16:6:7:8
21:exp:47:exp:38:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-384, CID 4+0
depends_on:19:4:16:6:7:8
21:exp:47:exp:38:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-384, EtM
depends_on:4:16:6:7:8:20
21:exp:47:exp:38:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-384, EtM, CID 4+4
depends_on:19:4:16:6:7:8:20
21:exp:47:exp:38:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-384, EtM, CID 4+0
depends_on:19:4:16:6:7:8:20
21:exp:47:exp:38:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-384, short tag
depends_on:4:16:6:7:8
21:exp:47:exp:38:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-384, short tag, CID 4+4
depends_on:19:4:16:6:7:8
21:exp:47:exp:38:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-384, short tag, CID 4+0
depends_on:19:4:16:6:7:8
21:exp:47:exp:38:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-384, short tag, EtM
depends_on:4:16:6:7:8:20
21:exp:47:exp:38:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-384, short tag, EtM, CID 4+4
depends_on:19:4:16:6:7:8:20
21:exp:47:exp:38:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-384, short tag, EtM, CID 4+0
depends_on:19:4:16:6:7:8:20
21:exp:47:exp:38:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-256
depends_on:4:16:6:13
21:exp:47:exp:39:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-256, CID 4+4
depends_on:19:4:16:6:13
21:exp:47:exp:39:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-256, CID 4+0
depends_on:19:4:16:6:13
21:exp:47:exp:39:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-256, EtM
depends_on:4:16:6:13:20
21:exp:47:exp:39:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-256, EtM, CID 4+4
depends_on:19:4:16:6:13:20
21:exp:47:exp:39:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-256, EtM, CID 4+0
depends_on:19:4:16:6:13:20
21:exp:47:exp:39:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-256, short tag
depends_on:4:16:6:13
21:exp:47:exp:39:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-256, short tag, CID 4+4
depends_on:19:4:16:6:13
21:exp:47:exp:39:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-256, short tag, CID 4+0
depends_on:19:4:16:6:13
21:exp:47:exp:39:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-256, short tag, EtM
depends_on:4:16:6:13:20
21:exp:47:exp:39:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-256, short tag, EtM, CID 4+4
depends_on:19:4:16:6:13:20
21:exp:47:exp:39:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-256, short tag, EtM, CID 4+0
depends_on:19:4:16:6:13:20
21:exp:47:exp:39:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-1
depends_on:4:16:6:21
21:exp:47:exp:40:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-1, CID 4+4
depends_on:19:4:16:6:21
21:exp:47:exp:40:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-1, CID 4+0
depends_on:19:4:16:6:21
21:exp:47:exp:40:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-1, EtM
depends_on:4:16:6:21:20
21:exp:47:exp:40:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-1, EtM, CID 4+4
depends_on:19:4:16:6:21:20
21:exp:47:exp:40:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-1, EtM, CID 4+0
depends_on:19:4:16:6:21:20
21:exp:47:exp:40:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-1, short tag
depends_on:4:16:6:21
21:exp:47:exp:40:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-1, short tag, CID 4+4
depends_on:19:4:16:6:21
21:exp:47:exp:40:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-1, short tag, CID 4+0
depends_on:19:4:16:6:21
21:exp:47:exp:40:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-1, short tag, EtM
depends_on:4:16:6:21:20
21:exp:47:exp:40:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-1, short tag, EtM, CID 4+4
depends_on:19:4:16:6:21:20
21:exp:47:exp:40:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-128-CBC, 1.2, SHA-1, short tag, EtM, CID 4+0
depends_on:19:4:16:6:21:20
21:exp:47:exp:40:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.2, MD5
depends_on:4:16:6:22
21:exp:47:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.2, MD5, CID 4+4
depends_on:19:4:16:6:22
21:exp:47:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-128-CBC, 1.2, MD5, CID 4+0
depends_on:19:4:16:6:22
21:exp:47:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.2, MD5, EtM
depends_on:4:16:6:22:20
21:exp:47:exp:41:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.2, MD5, EtM, CID 4+4
depends_on:19:4:16:6:22:20
21:exp:47:exp:41:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-128-CBC, 1.2, MD5, EtM, CID 4+0
depends_on:19:4:16:6:22:20
21:exp:47:exp:41:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.2, MD5, short tag
depends_on:4:16:6:22
21:exp:47:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.2, MD5, short tag, CID 4+4
depends_on:19:4:16:6:22
21:exp:47:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-128-CBC, 1.2, MD5, short tag, CID 4+0
depends_on:19:4:16:6:22
21:exp:47:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.2, MD5, short tag, EtM
depends_on:4:16:6:22:20
21:exp:47:exp:41:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.2, MD5, short tag, EtM, CID 4+4
depends_on:19:4:16:6:22:20
21:exp:47:exp:41:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-128-CBC, 1.2, MD5, short tag, EtM, CID 4+0
depends_on:19:4:16:6:22:20
21:exp:47:exp:41:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.1, SHA-384
depends_on:4:16:5:7:8
21:exp:47:exp:38:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.1, SHA-384, EtM
depends_on:4:16:5:7:8:20
21:exp:47:exp:38:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.1, SHA-384, short tag
depends_on:4:16:5:7:8
21:exp:47:exp:38:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.1, SHA-384, short tag, EtM
depends_on:4:16:5:7:8:20
21:exp:47:exp:38:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.1, SHA-256
depends_on:4:16:5:13
21:exp:47:exp:39:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.1, SHA-256, EtM
depends_on:4:16:5:13:20
21:exp:47:exp:39:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.1, SHA-256, short tag
depends_on:4:16:5:13
21:exp:47:exp:39:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.1, SHA-256, short tag, EtM
depends_on:4:16:5:13:20
21:exp:47:exp:39:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.1, SHA-1
depends_on:4:16:5:21
21:exp:47:exp:40:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.1, SHA-1, EtM
depends_on:4:16:5:21:20
21:exp:47:exp:40:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.1, SHA-1, short tag
depends_on:4:16:5:21
21:exp:47:exp:40:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.1, SHA-1, short tag, EtM
depends_on:4:16:5:21:20
21:exp:47:exp:40:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.1, MD5
depends_on:4:16:5:22
21:exp:47:exp:41:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.1, MD5, EtM
depends_on:4:16:5:22:20
21:exp:47:exp:41:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.1, MD5, short tag
depends_on:4:16:5:22
21:exp:47:exp:41:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.1, MD5, short tag, EtM
depends_on:4:16:5:22:20
21:exp:47:exp:41:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.0, SHA-384
depends_on:4:16:3:7:8
21:exp:47:exp:38:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.0, SHA-384, EtM
depends_on:4:16:3:7:8:20
21:exp:47:exp:38:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.0, SHA-384, short tag
depends_on:4:16:3:7:8
21:exp:47:exp:38:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.0, SHA-384, short tag, EtM
depends_on:4:16:3:7:8:20
21:exp:47:exp:38:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.0, SHA-256
depends_on:4:16:3:13
21:exp:47:exp:39:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.0, SHA-256, EtM
depends_on:4:16:3:13:20
21:exp:47:exp:39:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.0, SHA-256, short tag
depends_on:4:16:3:13
21:exp:47:exp:39:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.0, SHA-256, short tag, EtM
depends_on:4:16:3:13:20
21:exp:47:exp:39:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.0, SHA-1
depends_on:4:16:3:21
21:exp:47:exp:40:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.0, SHA-1, EtM
depends_on:4:16:3:21:20
21:exp:47:exp:40:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.0, SHA-1, short tag
depends_on:4:16:3:21
21:exp:47:exp:40:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.0, SHA-1, short tag, EtM
depends_on:4:16:3:21:20
21:exp:47:exp:40:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.0, MD5
depends_on:4:16:3:22
21:exp:47:exp:41:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.0, MD5, EtM
depends_on:4:16:3:22:20
21:exp:47:exp:41:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.0, MD5, short tag
depends_on:4:16:3:22
21:exp:47:exp:41:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, 1.0, MD5, short tag, EtM
depends_on:4:16:3:22:20
21:exp:47:exp:41:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, SSL3, SHA-1
depends_on:4:16:0:21
21:exp:47:exp:40:int:0:int:0:exp:21:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, SSL3, SHA-1, EtM
depends_on:4:16:0:21:20
21:exp:47:exp:40:int:1:int:0:exp:21:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, SSL3, SHA-1, short tag
depends_on:4:16:0:21
21:exp:47:exp:40:int:0:int:1:exp:21:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, SSL3, SHA-1, short tag, EtM
depends_on:4:16:0:21:20
21:exp:47:exp:40:int:1:int:1:exp:21:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, SSL3, MD5
depends_on:4:16:0:22
21:exp:47:exp:41:int:0:int:0:exp:21:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, SSL3, MD5, EtM
depends_on:4:16:0:22:20
21:exp:47:exp:41:int:1:int:0:exp:21:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, SSL3, MD5, short tag
depends_on:4:16:0:22
21:exp:47:exp:41:int:0:int:1:exp:21:int:0:int:0
Record crypt, little space, CAMELLIA-128-CBC, SSL3, MD5, short tag, EtM
depends_on:4:16:0:22:20
21:exp:47:exp:41:int:1:int:1:exp:21:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-384
depends_on:4:16:6:7:8
21:exp:48:exp:38:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-384, CID 4+4
depends_on:19:4:16:6:7:8
21:exp:48:exp:38:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-384, CID 4+0
depends_on:19:4:16:6:7:8
21:exp:48:exp:38:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-384, EtM
depends_on:4:16:6:7:8:20
21:exp:48:exp:38:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-384, EtM, CID 4+4
depends_on:19:4:16:6:7:8:20
21:exp:48:exp:38:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-384, EtM, CID 4+0
depends_on:19:4:16:6:7:8:20
21:exp:48:exp:38:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-384, short tag
depends_on:4:16:6:7:8
21:exp:48:exp:38:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-384, short tag, CID 4+4
depends_on:19:4:16:6:7:8
21:exp:48:exp:38:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-384, short tag, CID 4+0
depends_on:19:4:16:6:7:8
21:exp:48:exp:38:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-384, short tag, EtM
depends_on:4:16:6:7:8:20
21:exp:48:exp:38:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-384, short tag, EtM, CID 4+4
depends_on:19:4:16:6:7:8:20
21:exp:48:exp:38:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-384, short tag, EtM, CID 4+0
depends_on:19:4:16:6:7:8:20
21:exp:48:exp:38:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-256
depends_on:4:16:6:13
21:exp:48:exp:39:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-256, CID 4+4
depends_on:19:4:16:6:13
21:exp:48:exp:39:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-256, CID 4+0
depends_on:19:4:16:6:13
21:exp:48:exp:39:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-256, EtM
depends_on:4:16:6:13:20
21:exp:48:exp:39:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-256, EtM, CID 4+4
depends_on:19:4:16:6:13:20
21:exp:48:exp:39:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-256, EtM, CID 4+0
depends_on:19:4:16:6:13:20
21:exp:48:exp:39:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-256, short tag
depends_on:4:16:6:13
21:exp:48:exp:39:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-256, short tag, CID 4+4
depends_on:19:4:16:6:13
21:exp:48:exp:39:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-256, short tag, CID 4+0
depends_on:19:4:16:6:13
21:exp:48:exp:39:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-256, short tag, EtM
depends_on:4:16:6:13:20
21:exp:48:exp:39:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-256, short tag, EtM, CID 4+4
depends_on:19:4:16:6:13:20
21:exp:48:exp:39:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-256, short tag, EtM, CID 4+0
depends_on:19:4:16:6:13:20
21:exp:48:exp:39:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-1
depends_on:4:16:6:21
21:exp:48:exp:40:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-1, CID 4+4
depends_on:19:4:16:6:21
21:exp:48:exp:40:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-1, CID 4+0
depends_on:19:4:16:6:21
21:exp:48:exp:40:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-1, EtM
depends_on:4:16:6:21:20
21:exp:48:exp:40:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-1, EtM, CID 4+4
depends_on:19:4:16:6:21:20
21:exp:48:exp:40:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-1, EtM, CID 4+0
depends_on:19:4:16:6:21:20
21:exp:48:exp:40:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-1, short tag
depends_on:4:16:6:21
21:exp:48:exp:40:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-1, short tag, CID 4+4
depends_on:19:4:16:6:21
21:exp:48:exp:40:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-1, short tag, CID 4+0
depends_on:19:4:16:6:21
21:exp:48:exp:40:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-1, short tag, EtM
depends_on:4:16:6:21:20
21:exp:48:exp:40:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-1, short tag, EtM, CID 4+4
depends_on:19:4:16:6:21:20
21:exp:48:exp:40:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-192-CBC, 1.2, SHA-1, short tag, EtM, CID 4+0
depends_on:19:4:16:6:21:20
21:exp:48:exp:40:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.2, MD5
depends_on:4:16:6:22
21:exp:48:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.2, MD5, CID 4+4
depends_on:19:4:16:6:22
21:exp:48:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-192-CBC, 1.2, MD5, CID 4+0
depends_on:19:4:16:6:22
21:exp:48:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.2, MD5, EtM
depends_on:4:16:6:22:20
21:exp:48:exp:41:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.2, MD5, EtM, CID 4+4
depends_on:19:4:16:6:22:20
21:exp:48:exp:41:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-192-CBC, 1.2, MD5, EtM, CID 4+0
depends_on:19:4:16:6:22:20
21:exp:48:exp:41:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.2, MD5, short tag
depends_on:4:16:6:22
21:exp:48:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.2, MD5, short tag, CID 4+4
depends_on:19:4:16:6:22
21:exp:48:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-192-CBC, 1.2, MD5, short tag, CID 4+0
depends_on:19:4:16:6:22
21:exp:48:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.2, MD5, short tag, EtM
depends_on:4:16:6:22:20
21:exp:48:exp:41:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.2, MD5, short tag, EtM, CID 4+4
depends_on:19:4:16:6:22:20
21:exp:48:exp:41:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-192-CBC, 1.2, MD5, short tag, EtM, CID 4+0
depends_on:19:4:16:6:22:20
21:exp:48:exp:41:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.1, SHA-384
depends_on:4:16:5:7:8
21:exp:48:exp:38:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.1, SHA-384, EtM
depends_on:4:16:5:7:8:20
21:exp:48:exp:38:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.1, SHA-384, short tag
depends_on:4:16:5:7:8
21:exp:48:exp:38:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.1, SHA-384, short tag, EtM
depends_on:4:16:5:7:8:20
21:exp:48:exp:38:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.1, SHA-256
depends_on:4:16:5:13
21:exp:48:exp:39:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.1, SHA-256, EtM
depends_on:4:16:5:13:20
21:exp:48:exp:39:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.1, SHA-256, short tag
depends_on:4:16:5:13
21:exp:48:exp:39:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.1, SHA-256, short tag, EtM
depends_on:4:16:5:13:20
21:exp:48:exp:39:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.1, SHA-1
depends_on:4:16:5:21
21:exp:48:exp:40:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.1, SHA-1, EtM
depends_on:4:16:5:21:20
21:exp:48:exp:40:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.1, SHA-1, short tag
depends_on:4:16:5:21
21:exp:48:exp:40:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.1, SHA-1, short tag, EtM
depends_on:4:16:5:21:20
21:exp:48:exp:40:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.1, MD5
depends_on:4:16:5:22
21:exp:48:exp:41:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.1, MD5, EtM
depends_on:4:16:5:22:20
21:exp:48:exp:41:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.1, MD5, short tag
depends_on:4:16:5:22
21:exp:48:exp:41:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.1, MD5, short tag, EtM
depends_on:4:16:5:22:20
21:exp:48:exp:41:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.0, SHA-384
depends_on:4:16:3:7:8
21:exp:48:exp:38:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.0, SHA-384, EtM
depends_on:4:16:3:7:8:20
21:exp:48:exp:38:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.0, SHA-384, short tag
depends_on:4:16:3:7:8
21:exp:48:exp:38:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.0, SHA-384, short tag, EtM
depends_on:4:16:3:7:8:20
21:exp:48:exp:38:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.0, SHA-256
depends_on:4:16:3:13
21:exp:48:exp:39:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.0, SHA-256, EtM
depends_on:4:16:3:13:20
21:exp:48:exp:39:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.0, SHA-256, short tag
depends_on:4:16:3:13
21:exp:48:exp:39:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.0, SHA-256, short tag, EtM
depends_on:4:16:3:13:20
21:exp:48:exp:39:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.0, SHA-1
depends_on:4:16:3:21
21:exp:48:exp:40:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.0, SHA-1, EtM
depends_on:4:16:3:21:20
21:exp:48:exp:40:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.0, SHA-1, short tag
depends_on:4:16:3:21
21:exp:48:exp:40:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.0, SHA-1, short tag, EtM
depends_on:4:16:3:21:20
21:exp:48:exp:40:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.0, MD5
depends_on:4:16:3:22
21:exp:48:exp:41:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.0, MD5, EtM
depends_on:4:16:3:22:20
21:exp:48:exp:41:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.0, MD5, short tag
depends_on:4:16:3:22
21:exp:48:exp:41:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, 1.0, MD5, short tag, EtM
depends_on:4:16:3:22:20
21:exp:48:exp:41:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, SSL3, SHA-1
depends_on:4:16:0:21
21:exp:48:exp:40:int:0:int:0:exp:21:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, SSL3, SHA-1, EtM
depends_on:4:16:0:21:20
21:exp:48:exp:40:int:1:int:0:exp:21:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, SSL3, SHA-1, short tag
depends_on:4:16:0:21
21:exp:48:exp:40:int:0:int:1:exp:21:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, SSL3, SHA-1, short tag, EtM
depends_on:4:16:0:21:20
21:exp:48:exp:40:int:1:int:1:exp:21:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, SSL3, MD5
depends_on:4:16:0:22
21:exp:48:exp:41:int:0:int:0:exp:21:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, SSL3, MD5, EtM
depends_on:4:16:0:22:20
21:exp:48:exp:41:int:1:int:0:exp:21:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, SSL3, MD5, short tag
depends_on:4:16:0:22
21:exp:48:exp:41:int:0:int:1:exp:21:int:0:int:0
Record crypt, little space, CAMELLIA-192-CBC, SSL3, MD5, short tag, EtM
depends_on:4:16:0:22:20
21:exp:48:exp:41:int:1:int:1:exp:21:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-384
depends_on:4:16:6:7:8
21:exp:49:exp:38:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-384, CID 4+4
depends_on:19:4:16:6:7:8
21:exp:49:exp:38:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-384, CID 4+0
depends_on:19:4:16:6:7:8
21:exp:49:exp:38:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-384, EtM
depends_on:4:16:6:7:8:20
21:exp:49:exp:38:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-384, EtM, CID 4+4
depends_on:19:4:16:6:7:8:20
21:exp:49:exp:38:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-384, EtM, CID 4+0
depends_on:19:4:16:6:7:8:20
21:exp:49:exp:38:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-384, short tag
depends_on:4:16:6:7:8
21:exp:49:exp:38:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-384, short tag, CID 4+4
depends_on:19:4:16:6:7:8
21:exp:49:exp:38:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-384, short tag, CID 4+0
depends_on:19:4:16:6:7:8
21:exp:49:exp:38:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-384, short tag, EtM
depends_on:4:16:6:7:8:20
21:exp:49:exp:38:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-384, short tag, EtM, CID 4+4
depends_on:19:4:16:6:7:8:20
21:exp:49:exp:38:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-384, short tag, EtM, CID 4+0
depends_on:19:4:16:6:7:8:20
21:exp:49:exp:38:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-256
depends_on:4:16:6:13
21:exp:49:exp:39:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-256, CID 4+4
depends_on:19:4:16:6:13
21:exp:49:exp:39:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-256, CID 4+0
depends_on:19:4:16:6:13
21:exp:49:exp:39:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-256, EtM
depends_on:4:16:6:13:20
21:exp:49:exp:39:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-256, EtM, CID 4+4
depends_on:19:4:16:6:13:20
21:exp:49:exp:39:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-256, EtM, CID 4+0
depends_on:19:4:16:6:13:20
21:exp:49:exp:39:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-256, short tag
depends_on:4:16:6:13
21:exp:49:exp:39:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-256, short tag, CID 4+4
depends_on:19:4:16:6:13
21:exp:49:exp:39:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-256, short tag, CID 4+0
depends_on:19:4:16:6:13
21:exp:49:exp:39:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-256, short tag, EtM
depends_on:4:16:6:13:20
21:exp:49:exp:39:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-256, short tag, EtM, CID 4+4
depends_on:19:4:16:6:13:20
21:exp:49:exp:39:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-256, short tag, EtM, CID 4+0
depends_on:19:4:16:6:13:20
21:exp:49:exp:39:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-1
depends_on:4:16:6:21
21:exp:49:exp:40:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-1, CID 4+4
depends_on:19:4:16:6:21
21:exp:49:exp:40:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-1, CID 4+0
depends_on:19:4:16:6:21
21:exp:49:exp:40:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-1, EtM
depends_on:4:16:6:21:20
21:exp:49:exp:40:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-1, EtM, CID 4+4
depends_on:19:4:16:6:21:20
21:exp:49:exp:40:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-1, EtM, CID 4+0
depends_on:19:4:16:6:21:20
21:exp:49:exp:40:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-1, short tag
depends_on:4:16:6:21
21:exp:49:exp:40:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-1, short tag, CID 4+4
depends_on:19:4:16:6:21
21:exp:49:exp:40:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-1, short tag, CID 4+0
depends_on:19:4:16:6:21
21:exp:49:exp:40:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-1, short tag, EtM
depends_on:4:16:6:21:20
21:exp:49:exp:40:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-1, short tag, EtM, CID 4+4
depends_on:19:4:16:6:21:20
21:exp:49:exp:40:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-256-CBC, 1.2, SHA-1, short tag, EtM, CID 4+0
depends_on:19:4:16:6:21:20
21:exp:49:exp:40:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.2, MD5
depends_on:4:16:6:22
21:exp:49:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.2, MD5, CID 4+4
depends_on:19:4:16:6:22
21:exp:49:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-256-CBC, 1.2, MD5, CID 4+0
depends_on:19:4:16:6:22
21:exp:49:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.2, MD5, EtM
depends_on:4:16:6:22:20
21:exp:49:exp:41:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.2, MD5, EtM, CID 4+4
depends_on:19:4:16:6:22:20
21:exp:49:exp:41:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-256-CBC, 1.2, MD5, EtM, CID 4+0
depends_on:19:4:16:6:22:20
21:exp:49:exp:41:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.2, MD5, short tag
depends_on:4:16:6:22
21:exp:49:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.2, MD5, short tag, CID 4+4
depends_on:19:4:16:6:22
21:exp:49:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-256-CBC, 1.2, MD5, short tag, CID 4+0
depends_on:19:4:16:6:22
21:exp:49:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.2, MD5, short tag, EtM
depends_on:4:16:6:22:20
21:exp:49:exp:41:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.2, MD5, short tag, EtM, CID 4+4
depends_on:19:4:16:6:22:20
21:exp:49:exp:41:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-256-CBC, 1.2, MD5, short tag, EtM, CID 4+0
depends_on:19:4:16:6:22:20
21:exp:49:exp:41:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.1, SHA-384
depends_on:4:16:5:7:8
21:exp:49:exp:38:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.1, SHA-384, EtM
depends_on:4:16:5:7:8:20
21:exp:49:exp:38:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.1, SHA-384, short tag
depends_on:4:16:5:7:8
21:exp:49:exp:38:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.1, SHA-384, short tag, EtM
depends_on:4:16:5:7:8:20
21:exp:49:exp:38:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.1, SHA-256
depends_on:4:16:5:13
21:exp:49:exp:39:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.1, SHA-256, EtM
depends_on:4:16:5:13:20
21:exp:49:exp:39:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.1, SHA-256, short tag
depends_on:4:16:5:13
21:exp:49:exp:39:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.1, SHA-256, short tag, EtM
depends_on:4:16:5:13:20
21:exp:49:exp:39:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.1, SHA-1
depends_on:4:16:5:21
21:exp:49:exp:40:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.1, SHA-1, EtM
depends_on:4:16:5:21:20
21:exp:49:exp:40:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.1, SHA-1, short tag
depends_on:4:16:5:21
21:exp:49:exp:40:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.1, SHA-1, short tag, EtM
depends_on:4:16:5:21:20
21:exp:49:exp:40:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.1, MD5
depends_on:4:16:5:22
21:exp:49:exp:41:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.1, MD5, EtM
depends_on:4:16:5:22:20
21:exp:49:exp:41:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.1, MD5, short tag
depends_on:4:16:5:22
21:exp:49:exp:41:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.1, MD5, short tag, EtM
depends_on:4:16:5:22:20
21:exp:49:exp:41:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.0, SHA-384
depends_on:4:16:3:7:8
21:exp:49:exp:38:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.0, SHA-384, EtM
depends_on:4:16:3:7:8:20
21:exp:49:exp:38:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.0, SHA-384, short tag
depends_on:4:16:3:7:8
21:exp:49:exp:38:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.0, SHA-384, short tag, EtM
depends_on:4:16:3:7:8:20
21:exp:49:exp:38:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.0, SHA-256
depends_on:4:16:3:13
21:exp:49:exp:39:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.0, SHA-256, EtM
depends_on:4:16:3:13:20
21:exp:49:exp:39:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.0, SHA-256, short tag
depends_on:4:16:3:13
21:exp:49:exp:39:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.0, SHA-256, short tag, EtM
depends_on:4:16:3:13:20
21:exp:49:exp:39:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.0, SHA-1
depends_on:4:16:3:21
21:exp:49:exp:40:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.0, SHA-1, EtM
depends_on:4:16:3:21:20
21:exp:49:exp:40:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.0, SHA-1, short tag
depends_on:4:16:3:21
21:exp:49:exp:40:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.0, SHA-1, short tag, EtM
depends_on:4:16:3:21:20
21:exp:49:exp:40:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.0, MD5
depends_on:4:16:3:22
21:exp:49:exp:41:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.0, MD5, EtM
depends_on:4:16:3:22:20
21:exp:49:exp:41:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.0, MD5, short tag
depends_on:4:16:3:22
21:exp:49:exp:41:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, 1.0, MD5, short tag, EtM
depends_on:4:16:3:22:20
21:exp:49:exp:41:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, SSL3, SHA-1
depends_on:4:16:0:21
21:exp:49:exp:40:int:0:int:0:exp:21:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, SSL3, SHA-1, EtM
depends_on:4:16:0:21:20
21:exp:49:exp:40:int:1:int:0:exp:21:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, SSL3, SHA-1, short tag
depends_on:4:16:0:21
21:exp:49:exp:40:int:0:int:1:exp:21:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, SSL3, SHA-1, short tag, EtM
depends_on:4:16:0:21:20
21:exp:49:exp:40:int:1:int:1:exp:21:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, SSL3, MD5
depends_on:4:16:0:22
21:exp:49:exp:41:int:0:int:0:exp:21:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, SSL3, MD5, EtM
depends_on:4:16:0:22:20
21:exp:49:exp:41:int:1:int:0:exp:21:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, SSL3, MD5, short tag
depends_on:4:16:0:22
21:exp:49:exp:41:int:0:int:1:exp:21:int:0:int:0
Record crypt, little space, CAMELLIA-256-CBC, SSL3, MD5, short tag, EtM
depends_on:4:16:0:22:20
21:exp:49:exp:41:int:1:int:1:exp:21:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-384
depends_on:4:24:6:7:8
21:exp:50:exp:38:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-384, CID 4+4
depends_on:19:4:24:6:7:8
21:exp:50:exp:38:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-384, CID 4+0
depends_on:19:4:24:6:7:8
21:exp:50:exp:38:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-384, EtM
depends_on:4:24:6:7:8:20
21:exp:50:exp:38:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-384, EtM, CID 4+4
depends_on:19:4:24:6:7:8:20
21:exp:50:exp:38:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-384, EtM, CID 4+0
depends_on:19:4:24:6:7:8:20
21:exp:50:exp:38:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-384, short tag
depends_on:4:24:6:7:8
21:exp:50:exp:38:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-384, short tag, CID 4+4
depends_on:19:4:24:6:7:8
21:exp:50:exp:38:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-384, short tag, CID 4+0
depends_on:19:4:24:6:7:8
21:exp:50:exp:38:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-384, short tag, EtM
depends_on:4:24:6:7:8:20
21:exp:50:exp:38:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-384, short tag, EtM, CID 4+4
depends_on:19:4:24:6:7:8:20
21:exp:50:exp:38:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-384, short tag, EtM, CID 4+0
depends_on:19:4:24:6:7:8:20
21:exp:50:exp:38:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-256
depends_on:4:24:6:13
21:exp:50:exp:39:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-256, CID 4+4
depends_on:19:4:24:6:13
21:exp:50:exp:39:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-256, CID 4+0
depends_on:19:4:24:6:13
21:exp:50:exp:39:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-256, EtM
depends_on:4:24:6:13:20
21:exp:50:exp:39:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-256, EtM, CID 4+4
depends_on:19:4:24:6:13:20
21:exp:50:exp:39:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-256, EtM, CID 4+0
depends_on:19:4:24:6:13:20
21:exp:50:exp:39:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-256, short tag
depends_on:4:24:6:13
21:exp:50:exp:39:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-256, short tag, CID 4+4
depends_on:19:4:24:6:13
21:exp:50:exp:39:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-256, short tag, CID 4+0
depends_on:19:4:24:6:13
21:exp:50:exp:39:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-256, short tag, EtM
depends_on:4:24:6:13:20
21:exp:50:exp:39:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-256, short tag, EtM, CID 4+4
depends_on:19:4:24:6:13:20
21:exp:50:exp:39:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-256, short tag, EtM, CID 4+0
depends_on:19:4:24:6:13:20
21:exp:50:exp:39:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-1
depends_on:4:24:6:21
21:exp:50:exp:40:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-1, CID 4+4
depends_on:19:4:24:6:21
21:exp:50:exp:40:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-1, CID 4+0
depends_on:19:4:24:6:21
21:exp:50:exp:40:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-1, EtM
depends_on:4:24:6:21:20
21:exp:50:exp:40:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-1, EtM, CID 4+4
depends_on:19:4:24:6:21:20
21:exp:50:exp:40:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-1, EtM, CID 4+0
depends_on:19:4:24:6:21:20
21:exp:50:exp:40:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-1, short tag
depends_on:4:24:6:21
21:exp:50:exp:40:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-1, short tag, CID 4+4
depends_on:19:4:24:6:21
21:exp:50:exp:40:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-1, short tag, CID 4+0
depends_on:19:4:24:6:21
21:exp:50:exp:40:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-1, short tag, EtM
depends_on:4:24:6:21:20
21:exp:50:exp:40:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-1, short tag, EtM, CID 4+4
depends_on:19:4:24:6:21:20
21:exp:50:exp:40:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, BLOWFISH-CBC, 1.2, SHA-1, short tag, EtM, CID 4+0
depends_on:19:4:24:6:21:20
21:exp:50:exp:40:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, BLOWFISH-CBC, 1.2, MD5
depends_on:4:24:6:22
21:exp:50:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.2, MD5, CID 4+4
depends_on:19:4:24:6:22
21:exp:50:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, BLOWFISH-CBC, 1.2, MD5, CID 4+0
depends_on:19:4:24:6:22
21:exp:50:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, BLOWFISH-CBC, 1.2, MD5, EtM
depends_on:4:24:6:22:20
21:exp:50:exp:41:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.2, MD5, EtM, CID 4+4
depends_on:19:4:24:6:22:20
21:exp:50:exp:41:int:1:int:0:exp:24:int:4:int:4
Record crypt, little space, BLOWFISH-CBC, 1.2, MD5, EtM, CID 4+0
depends_on:19:4:24:6:22:20
21:exp:50:exp:41:int:1:int:0:exp:24:int:4:int:0
Record crypt, little space, BLOWFISH-CBC, 1.2, MD5, short tag
depends_on:4:24:6:22
21:exp:50:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.2, MD5, short tag, CID 4+4
depends_on:19:4:24:6:22
21:exp:50:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, BLOWFISH-CBC, 1.2, MD5, short tag, CID 4+0
depends_on:19:4:24:6:22
21:exp:50:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, BLOWFISH-CBC, 1.2, MD5, short tag, EtM
depends_on:4:24:6:22:20
21:exp:50:exp:41:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.2, MD5, short tag, EtM, CID 4+4
depends_on:19:4:24:6:22:20
21:exp:50:exp:41:int:1:int:1:exp:24:int:4:int:4
Record crypt, little space, BLOWFISH-CBC, 1.2, MD5, short tag, EtM, CID 4+0
depends_on:19:4:24:6:22:20
21:exp:50:exp:41:int:1:int:1:exp:24:int:4:int:0
Record crypt, little space, BLOWFISH-CBC, 1.1, SHA-384
depends_on:4:24:5:7:8
21:exp:50:exp:38:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.1, SHA-384, EtM
depends_on:4:24:5:7:8:20
21:exp:50:exp:38:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.1, SHA-384, short tag
depends_on:4:24:5:7:8
21:exp:50:exp:38:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.1, SHA-384, short tag, EtM
depends_on:4:24:5:7:8:20
21:exp:50:exp:38:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.1, SHA-256
depends_on:4:24:5:13
21:exp:50:exp:39:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.1, SHA-256, EtM
depends_on:4:24:5:13:20
21:exp:50:exp:39:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.1, SHA-256, short tag
depends_on:4:24:5:13
21:exp:50:exp:39:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.1, SHA-256, short tag, EtM
depends_on:4:24:5:13:20
21:exp:50:exp:39:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.1, SHA-1
depends_on:4:24:5:21
21:exp:50:exp:40:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.1, SHA-1, EtM
depends_on:4:24:5:21:20
21:exp:50:exp:40:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.1, SHA-1, short tag
depends_on:4:24:5:21
21:exp:50:exp:40:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.1, SHA-1, short tag, EtM
depends_on:4:24:5:21:20
21:exp:50:exp:40:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.1, MD5
depends_on:4:24:5:22
21:exp:50:exp:41:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.1, MD5, EtM
depends_on:4:24:5:22:20
21:exp:50:exp:41:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.1, MD5, short tag
depends_on:4:24:5:22
21:exp:50:exp:41:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.1, MD5, short tag, EtM
depends_on:4:24:5:22:20
21:exp:50:exp:41:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.0, SHA-384
depends_on:4:24:3:7:8
21:exp:50:exp:38:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.0, SHA-384, EtM
depends_on:4:24:3:7:8:20
21:exp:50:exp:38:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.0, SHA-384, short tag
depends_on:4:24:3:7:8
21:exp:50:exp:38:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.0, SHA-384, short tag, EtM
depends_on:4:24:3:7:8:20
21:exp:50:exp:38:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.0, SHA-256
depends_on:4:24:3:13
21:exp:50:exp:39:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.0, SHA-256, EtM
depends_on:4:24:3:13:20
21:exp:50:exp:39:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.0, SHA-256, short tag
depends_on:4:24:3:13
21:exp:50:exp:39:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.0, SHA-256, short tag, EtM
depends_on:4:24:3:13:20
21:exp:50:exp:39:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.0, SHA-1
depends_on:4:24:3:21
21:exp:50:exp:40:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.0, SHA-1, EtM
depends_on:4:24:3:21:20
21:exp:50:exp:40:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.0, SHA-1, short tag
depends_on:4:24:3:21
21:exp:50:exp:40:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.0, SHA-1, short tag, EtM
depends_on:4:24:3:21:20
21:exp:50:exp:40:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.0, MD5
depends_on:4:24:3:22
21:exp:50:exp:41:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.0, MD5, EtM
depends_on:4:24:3:22:20
21:exp:50:exp:41:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.0, MD5, short tag
depends_on:4:24:3:22
21:exp:50:exp:41:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, 1.0, MD5, short tag, EtM
depends_on:4:24:3:22:20
21:exp:50:exp:41:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, SSL3, SHA-1
depends_on:4:24:0:21
21:exp:50:exp:40:int:0:int:0:exp:21:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, SSL3, SHA-1, EtM
depends_on:4:24:0:21:20
21:exp:50:exp:40:int:1:int:0:exp:21:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, SSL3, SHA-1, short tag
depends_on:4:24:0:21
21:exp:50:exp:40:int:0:int:1:exp:21:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, SSL3, SHA-1, short tag, EtM
depends_on:4:24:0:21:20
21:exp:50:exp:40:int:1:int:1:exp:21:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, SSL3, MD5
depends_on:4:24:0:22
21:exp:50:exp:41:int:0:int:0:exp:21:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, SSL3, MD5, EtM
depends_on:4:24:0:22:20
21:exp:50:exp:41:int:1:int:0:exp:21:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, SSL3, MD5, short tag
depends_on:4:24:0:22
21:exp:50:exp:41:int:0:int:1:exp:21:int:0:int:0
Record crypt, little space, BLOWFISH-CBC, SSL3, MD5, short tag, EtM
depends_on:4:24:0:22:20
21:exp:50:exp:41:int:1:int:1:exp:21:int:0:int:0
Record crypt, little space, AES128-GCM, 1.2
depends_on:9:6:10
21:exp:51:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, AES128-GCM, 1.3
depends_on:9:25:10
21:exp:51:exp:41:int:0:int:0:exp:52:int:0:int:0
Record crypt, little space, AES128-GCM, 1.2, CID 4+4
depends_on:19:9:6:10
21:exp:51:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, AES128-GCM, 1.2, CID 4+0
depends_on:19:9:6:10
21:exp:51:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, AES128-GCM, 1.2, short tag
depends_on:9:6:10
21:exp:51:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, AES128-GCM, 1.2, short tag, CID 4+4
depends_on:19:9:6:10
21:exp:51:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, AES128-GCM, 1.2, short tag, CID 4+0
depends_on:19:9:6:10
21:exp:51:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, AES-192-GCM, 1.2
depends_on:9:6:10
21:exp:53:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, AES-192-GCM, 1.3
depends_on:9:25:10
21:exp:53:exp:41:int:0:int:0:exp:52:int:0:int:0
Record crypt, little space, AES-192-GCM, 1.2, CID 4+4
depends_on:19:9:6:10
21:exp:53:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, AES-192-GCM, 1.2, CID 4+0
depends_on:19:9:6:10
21:exp:53:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, AES-192-GCM, 1.2, short tag
depends_on:9:6:10
21:exp:53:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, AES-192-GCM, 1.2, short tag, CID 4+4
depends_on:19:9:6:10
21:exp:53:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, AES-192-GCM, 1.2, short tag, CID 4+0
depends_on:19:9:6:10
21:exp:53:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, AES256-GCM, 1.2
depends_on:9:6:10
21:exp:54:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, AES256-GCM, 1.3
depends_on:9:25:10
21:exp:54:exp:41:int:0:int:0:exp:52:int:0:int:0
Record crypt, little space, AES256-GCM, 1.2, CID 4+4
depends_on:19:9:6:10
21:exp:54:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, AES256-GCM, 1.2, CID 4+0
depends_on:19:9:6:10
21:exp:54:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, AES256-GCM, 1.2, short tag
depends_on:9:6:10
21:exp:54:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, AES256-GCM, 1.2, short tag, CID 4+4
depends_on:19:9:6:10
21:exp:54:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, AES256-GCM, 1.2, short tag, CID 4+0
depends_on:19:9:6:10
21:exp:54:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-128-GCM, 1.2
depends_on:16:6:10
21:exp:55:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-128-GCM, 1.2, CID 4+4
depends_on:19:16:6:10
21:exp:55:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-128-GCM, 1.2, CID 4+0
depends_on:19:16:6:10
21:exp:55:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-128-GCM, 1.2, short tag
depends_on:16:6:10
21:exp:55:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-128-GCM, 1.2, short tag, CID 4+4
depends_on:19:16:6:10
21:exp:55:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-128-GCM, 1.2, short tag, CID 4+0
depends_on:19:16:6:10
21:exp:55:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-192-GCM, 1.2
depends_on:16:6:10
21:exp:56:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-192-GCM, 1.2, CID 4+4
depends_on:19:16:6:10
21:exp:56:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-192-GCM, 1.2, CID 4+0
depends_on:19:16:6:10
21:exp:56:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-192-GCM, 1.2, short tag
depends_on:16:6:10
21:exp:56:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-192-GCM, 1.2, short tag, CID 4+4
depends_on:19:16:6:10
21:exp:56:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-192-GCM, 1.2, short tag, CID 4+0
depends_on:19:16:6:10
21:exp:56:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-256-GCM, 1.2
depends_on:16:6:10
21:exp:57:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-256-GCM, 1.2, CID 4+4
depends_on:19:16:6:10
21:exp:57:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-256-GCM, 1.2, CID 4+0
depends_on:19:16:6:10
21:exp:57:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-256-GCM, 1.2, short tag
depends_on:16:6:10
21:exp:57:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-256-GCM, 1.2, short tag, CID 4+4
depends_on:19:16:6:10
21:exp:57:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-256-GCM, 1.2, short tag, CID 4+0
depends_on:19:16:6:10
21:exp:57:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, AES128-CCM, 1.2
depends_on:9:6:12
21:exp:58:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, AES128-CCM, 1.3
depends_on:9:25:12
21:exp:58:exp:41:int:0:int:0:exp:52:int:0:int:0
Record crypt, little space, AES128-CCM, 1.2, CID 4+4
depends_on:19:9:6:12
21:exp:58:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, AES128-CCM, 1.2, CID 4+0
depends_on:19:9:6:12
21:exp:58:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, AES128-CCM, 1.2, short tag
depends_on:9:6:12
21:exp:58:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, AES128-CCM, 1.2, short tag, CID 4+4
depends_on:19:9:6:12
21:exp:58:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, AES128-CCM, 1.2, short tag, CID 4+0
depends_on:19:9:6:12
21:exp:58:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, AES-192-CCM, 1.2
depends_on:9:6:12
21:exp:59:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, AES-192-CCM, 1.3
depends_on:9:25:12
21:exp:59:exp:41:int:0:int:0:exp:52:int:0:int:0
Record crypt, little space, AES-192-CCM, 1.2, CID 4+4
depends_on:19:9:6:12
21:exp:59:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, AES-192-CCM, 1.2, CID 4+0
depends_on:19:9:6:12
21:exp:59:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, AES-192-CCM, 1.2, short tag
depends_on:9:6:12
21:exp:59:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, AES-192-CCM, 1.2, short tag, CID 4+4
depends_on:19:9:6:12
21:exp:59:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, AES-192-CCM, 1.2, short tag, CID 4+0
depends_on:19:9:6:12
21:exp:59:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, AES256-CCM, 1.2
depends_on:9:6:12
21:exp:60:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, AES256-CCM, 1.3
depends_on:9:25:12
21:exp:60:exp:41:int:0:int:0:exp:52:int:0:int:0
Record crypt, little space, AES256-CCM, 1.2, CID 4+4
depends_on:19:9:6:12
21:exp:60:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, AES256-CCM, 1.2, CID 4+0
depends_on:19:9:6:12
21:exp:60:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, AES256-CCM, 1.2, short tag
depends_on:9:6:12
21:exp:60:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, AES256-CCM, 1.2, short tag, CID 4+4
depends_on:19:9:6:12
21:exp:60:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, AES256-CCM, 1.2, short tag, CID 4+0
depends_on:19:9:6:12
21:exp:60:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-128-CCM, 1.2
depends_on:16:6:12
21:exp:61:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-128-CCM, 1.2, CID 4+4
depends_on:19:16:6:12
21:exp:61:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-128-CCM, 1.2, CID 4+0
depends_on:19:16:6:12
21:exp:61:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-128-CCM, 1.2, short tag
depends_on:16:6:12
21:exp:61:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-128-CCM, 1.2, short tag, CID 4+4
depends_on:19:16:6:12
21:exp:61:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-128-CCM, 1.2, short tag, CID 4+0
depends_on:19:16:6:12
21:exp:61:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-192-CCM, 1.2
depends_on:16:6:12
21:exp:62:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-192-CCM, 1.2, CID 4+4
depends_on:19:16:6:12
21:exp:62:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-192-CCM, 1.2, CID 4+0
depends_on:19:16:6:12
21:exp:62:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-192-CCM, 1.2, short tag
depends_on:16:6:12
21:exp:62:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-192-CCM, 1.2, short tag, CID 4+4
depends_on:19:16:6:12
21:exp:62:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-192-CCM, 1.2, short tag, CID 4+0
depends_on:19:16:6:12
21:exp:62:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-256-CCM, 1.2
depends_on:16:6:12
21:exp:63:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-256-CCM, 1.2, CID 4+4
depends_on:19:16:6:12
21:exp:63:exp:41:int:0:int:0:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-256-CCM, 1.2, CID 4+0
depends_on:19:16:6:12
21:exp:63:exp:41:int:0:int:0:exp:24:int:4:int:0
Record crypt, little space, CAMELLIA-256-CCM, 1.2, short tag
depends_on:16:6:12
21:exp:63:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, CAMELLIA-256-CCM, 1.2, short tag, CID 4+4
depends_on:19:16:6:12
21:exp:63:exp:41:int:0:int:1:exp:24:int:4:int:4
Record crypt, little space, CAMELLIA-256-CCM, 1.2, short tag, CID 4+0
depends_on:19:16:6:12
21:exp:63:exp:41:int:0:int:1:exp:24:int:4:int:0
Record crypt, little space, ARC4-128, 1.2, SHA-384
depends_on:26:6:7:8
21:exp:64:exp:38:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, ARC4-128, 1.2, SHA-384, EtM
depends_on:26:6:7:8:20
21:exp:64:exp:38:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, ARC4-128, 1.2, SHA-384, short tag
depends_on:26:6:7:8
21:exp:64:exp:38:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, ARC4-128, 1.2, SHA-384, short tag, EtM
depends_on:26:6:7:8:20
21:exp:64:exp:38:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, ARC4-128, 1.2, SHA-256
depends_on:26:6:13
21:exp:64:exp:39:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, ARC4-128, 1.2, SHA-256, EtM
depends_on:26:6:13:20
21:exp:64:exp:39:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, ARC4-128, 1.2, SHA-256, short tag
depends_on:26:6:13
21:exp:64:exp:39:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, ARC4-128, 1.2, SHA-256, short tag, EtM
depends_on:26:6:13:20
21:exp:64:exp:39:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, ARC4-128, 1.2, SHA-1
depends_on:26:6:21
21:exp:64:exp:40:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, ARC4-128, 1.2, SHA-1, EtM
depends_on:26:6:21:20
21:exp:64:exp:40:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, ARC4-128, 1.2, SHA-1, short tag
depends_on:26:6:21
21:exp:64:exp:40:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, ARC4-128, 1.2, SHA-1, short tag, EtM
depends_on:26:6:21:20
21:exp:64:exp:40:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, ARC4-128, 1.2, MD5
depends_on:26:6:22
21:exp:64:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, ARC4-128, 1.2, MD5, EtM
depends_on:26:6:22:20
21:exp:64:exp:41:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, ARC4-128, 1.2, MD5, short tag
depends_on:26:6:22
21:exp:64:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, ARC4-128, 1.2, MD5, short tag, EtM
depends_on:26:6:22:20
21:exp:64:exp:41:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, ARC4-128, 1.1, SHA-384
depends_on:26:5:7:8
21:exp:64:exp:38:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, ARC4-128, 1.1, SHA-384, EtM
depends_on:26:5:7:8:20
21:exp:64:exp:38:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, ARC4-128, 1.1, SHA-384, short tag
depends_on:26:5:7:8
21:exp:64:exp:38:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, ARC4-128, 1.1, SHA-384, short tag, EtM
depends_on:26:5:7:8:20
21:exp:64:exp:38:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, ARC4-128, 1.1, SHA-256
depends_on:26:5:13
21:exp:64:exp:39:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, ARC4-128, 1.1, SHA-256, EtM
depends_on:26:5:13:20
21:exp:64:exp:39:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, ARC4-128, 1.1, SHA-256, short tag
depends_on:26:5:13
21:exp:64:exp:39:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, ARC4-128, 1.1, SHA-256, short tag, EtM
depends_on:26:5:13:20
21:exp:64:exp:39:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, ARC4-128, 1.1, SHA-1
depends_on:26:5:21
21:exp:64:exp:40:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, ARC4-128, 1.1, SHA-1, EtM
depends_on:26:5:21:20
21:exp:64:exp:40:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, ARC4-128, 1.1, SHA-1, short tag
depends_on:26:5:21
21:exp:64:exp:40:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, ARC4-128, 1.1, SHA-1, short tag, EtM
depends_on:26:5:21:20
21:exp:64:exp:40:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, ARC4-128, 1.1, MD5
depends_on:26:5:22
21:exp:64:exp:41:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, ARC4-128, 1.1, MD5, EtM
depends_on:26:5:22:20
21:exp:64:exp:41:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, ARC4-128, 1.1, MD5, short tag
depends_on:26:5:22
21:exp:64:exp:41:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, ARC4-128, 1.1, MD5, short tag, EtM
depends_on:26:5:22:20
21:exp:64:exp:41:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, ARC4-128, 1.0, SHA-384
depends_on:26:3:7:8
21:exp:64:exp:38:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, ARC4-128, 1.0, SHA-384, EtM
depends_on:26:3:7:8:20
21:exp:64:exp:38:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, ARC4-128, 1.0, SHA-384, short tag
depends_on:26:3:7:8
21:exp:64:exp:38:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, ARC4-128, 1.0, SHA-384, short tag, EtM
depends_on:26:3:7:8:20
21:exp:64:exp:38:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, ARC4-128, 1.0, SHA-256
depends_on:26:3:13
21:exp:64:exp:39:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, ARC4-128, 1.0, SHA-256, EtM
depends_on:26:3:13:20
21:exp:64:exp:39:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, ARC4-128, 1.0, SHA-256, short tag
depends_on:26:3:13
21:exp:64:exp:39:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, ARC4-128, 1.0, SHA-256, short tag, EtM
depends_on:26:3:13:20
21:exp:64:exp:39:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, ARC4-128, 1.0, SHA-1
depends_on:26:3:21
21:exp:64:exp:40:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, ARC4-128, 1.0, SHA-1, EtM
depends_on:26:3:21:20
21:exp:64:exp:40:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, ARC4-128, 1.0, SHA-1, short tag
depends_on:26:3:21
21:exp:64:exp:40:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, ARC4-128, 1.0, SHA-1, short tag, EtM
depends_on:26:3:21:20
21:exp:64:exp:40:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, ARC4-128, 1.0, MD5
depends_on:26:3:22
21:exp:64:exp:41:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, ARC4-128, 1.0, MD5, EtM
depends_on:26:3:22:20
21:exp:64:exp:41:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, ARC4-128, 1.0, MD5, short tag
depends_on:26:3:22
21:exp:64:exp:41:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, ARC4-128, 1.0, MD5, short tag, EtM
depends_on:26:3:22:20
21:exp:64:exp:41:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, ARC4-128, SSL3, SHA-1
depends_on:26:0:21
21:exp:64:exp:40:int:0:int:0:exp:21:int:0:int:0
Record crypt, little space, ARC4-128, SSL3, SHA-1, EtM
depends_on:26:0:21:20
21:exp:64:exp:40:int:1:int:0:exp:21:int:0:int:0
Record crypt, little space, ARC4-128, SSL3, SHA-1, short tag
depends_on:26:0:21
21:exp:64:exp:40:int:0:int:1:exp:21:int:0:int:0
Record crypt, little space, ARC4-128, SSL3, SHA-1, short tag, EtM
depends_on:26:0:21:20
21:exp:64:exp:40:int:1:int:1:exp:21:int:0:int:0
Record crypt, little space, ARC4-128, SSL3, MD5
depends_on:26:0:22
21:exp:64:exp:41:int:0:int:0:exp:21:int:0:int:0
Record crypt, little space, ARC4-128, SSL3, MD5, EtM
depends_on:26:0:22:20
21:exp:64:exp:41:int:1:int:0:exp:21:int:0:int:0
Record crypt, little space, ARC4-128, SSL3, MD5, short tag
depends_on:26:0:22
21:exp:64:exp:41:int:0:int:1:exp:21:int:0:int:0
Record crypt, little space, ARC4-128, SSL3, MD5, short tag, EtM
depends_on:26:0:22:20
21:exp:64:exp:41:int:1:int:1:exp:21:int:0:int:0
Record crypt, little space, NULL cipher, 1.2, SHA-384
depends_on:27:6:7:8
21:exp:65:exp:38:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, NULL cipher, 1.2, SHA-384, EtM
depends_on:27:6:7:8:20
21:exp:65:exp:38:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, NULL cipher, 1.2, SHA-384, short tag
depends_on:27:6:7:8
21:exp:65:exp:38:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, NULL cipher, 1.2, SHA-384, short tag, EtM
depends_on:27:6:7:8:20
21:exp:65:exp:38:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, NULL cipher, 1.2, SHA-256
depends_on:27:6:13
21:exp:65:exp:39:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, NULL cipher, 1.2, SHA-256, EtM
depends_on:27:6:13:20
21:exp:65:exp:39:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, NULL cipher, 1.2, SHA-256, short tag
depends_on:27:6:13
21:exp:65:exp:39:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, NULL cipher, 1.2, SHA-256, short tag, EtM
depends_on:27:6:13:20
21:exp:65:exp:39:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, NULL cipher, 1.2, SHA-1
depends_on:27:6:21
21:exp:65:exp:40:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, NULL cipher, 1.2, SHA-1, EtM
depends_on:27:6:21:20
21:exp:65:exp:40:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, NULL cipher, 1.2, SHA-1, short tag
depends_on:27:6:21
21:exp:65:exp:40:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, NULL cipher, 1.2, SHA-1, short tag, EtM
depends_on:27:6:21:20
21:exp:65:exp:40:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, NULL cipher, 1.2, MD5
depends_on:27:6:22
21:exp:65:exp:41:int:0:int:0:exp:24:int:0:int:0
Record crypt, little space, NULL cipher, 1.2, MD5, EtM
depends_on:27:6:22:20
21:exp:65:exp:41:int:1:int:0:exp:24:int:0:int:0
Record crypt, little space, NULL cipher, 1.2, MD5, short tag
depends_on:27:6:22
21:exp:65:exp:41:int:0:int:1:exp:24:int:0:int:0
Record crypt, little space, NULL cipher, 1.2, MD5, short tag, EtM
depends_on:27:6:22:20
21:exp:65:exp:41:int:1:int:1:exp:24:int:0:int:0
Record crypt, little space, NULL cipher, 1.1, SHA-384
depends_on:27:5:7:8
21:exp:65:exp:38:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, NULL cipher, 1.1, SHA-384, EtM
depends_on:27:5:7:8:20
21:exp:65:exp:38:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, NULL cipher, 1.1, SHA-384, short tag
depends_on:27:5:7:8
21:exp:65:exp:38:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, NULL cipher, 1.1, SHA-384, short tag, EtM
depends_on:27:5:7:8:20
21:exp:65:exp:38:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, NULL cipher, 1.1, SHA-256
depends_on:27:5:13
21:exp:65:exp:39:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, NULL cipher, 1.1, SHA-256, EtM
depends_on:27:5:13:20
21:exp:65:exp:39:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, NULL cipher, 1.1, SHA-256, short tag
depends_on:27:5:13
21:exp:65:exp:39:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, NULL cipher, 1.1, SHA-256, short tag, EtM
depends_on:27:5:13:20
21:exp:65:exp:39:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, NULL cipher, 1.1, SHA-1
depends_on:27:5:21
21:exp:65:exp:40:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, NULL cipher, 1.1, SHA-1, EtM
depends_on:27:5:21:20
21:exp:65:exp:40:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, NULL cipher, 1.1, SHA-1, short tag
depends_on:27:5:21
21:exp:65:exp:40:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, NULL cipher, 1.1, SHA-1, short tag, EtM
depends_on:27:5:21:20
21:exp:65:exp:40:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, NULL cipher, 1.1, MD5
depends_on:27:5:22
21:exp:65:exp:41:int:0:int:0:exp:23:int:0:int:0
Record crypt, little space, NULL cipher, 1.1, MD5, EtM
depends_on:27:5:22:20
21:exp:65:exp:41:int:1:int:0:exp:23:int:0:int:0
Record crypt, little space, NULL cipher, 1.1, MD5, short tag
depends_on:27:5:22
21:exp:65:exp:41:int:0:int:1:exp:23:int:0:int:0
Record crypt, little space, NULL cipher, 1.1, MD5, short tag, EtM
depends_on:27:5:22:20
21:exp:65:exp:41:int:1:int:1:exp:23:int:0:int:0
Record crypt, little space, NULL cipher, 1.0, SHA-384
depends_on:27:3:7:8
21:exp:65:exp:38:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, NULL cipher, 1.0, SHA-384, EtM
depends_on:27:3:7:8:20
21:exp:65:exp:38:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, NULL cipher, 1.0, SHA-384, short tag
depends_on:27:3:7:8
21:exp:65:exp:38:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, NULL cipher, 1.0, SHA-384, short tag, EtM
depends_on:27:3:7:8:20
21:exp:65:exp:38:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, NULL cipher, 1.0, SHA-256
depends_on:27:3:13
21:exp:65:exp:39:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, NULL cipher, 1.0, SHA-256, EtM
depends_on:27:3:13:20
21:exp:65:exp:39:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, NULL cipher, 1.0, SHA-256, short tag
depends_on:27:3:13
21:exp:65:exp:39:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, NULL cipher, 1.0, SHA-256, short tag, EtM
depends_on:27:3:13:20
21:exp:65:exp:39:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, NULL cipher, 1.0, SHA-1
depends_on:27:3:21
21:exp:65:exp:40:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, NULL cipher, 1.0, SHA-1, EtM
depends_on:27:3:21:20
21:exp:65:exp:40:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, NULL cipher, 1.0, SHA-1, short tag
depends_on:27:3:21
21:exp:65:exp:40:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, NULL cipher, 1.0, SHA-1, short tag, EtM
depends_on:27:3:21:20
21:exp:65:exp:40:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, NULL cipher, 1.0, MD5
depends_on:27:3:22
21:exp:65:exp:41:int:0:int:0:exp:22:int:0:int:0
Record crypt, little space, NULL cipher, 1.0, MD5, EtM
depends_on:27:3:22:20
21:exp:65:exp:41:int:1:int:0:exp:22:int:0:int:0
Record crypt, little space, NULL cipher, 1.0, MD5, short tag
depends_on:27:3:22
21:exp:65:exp:41:int:0:int:1:exp:22:int:0:int:0
Record crypt, little space, NULL cipher, 1.0, MD5, short tag, EtM
depends_on:27:3:22:20
21:exp:65:exp:41:int:1:int:1:exp:22:int:0:int:0
Record crypt, little space, NULL cipher, SSL3, SHA-1
depends_on:27:0:21
21:exp:65:exp:40:int:0:int:0:exp:21:int:0:int:0
Record crypt, little space, NULL cipher, SSL3, SHA-1, EtM
depends_on:27:0:21:20
21:exp:65:exp:40:int:1:int:0:exp:21:int:0:int:0
Record crypt, little space, NULL cipher, SSL3, SHA-1, short tag
depends_on:27:0:21
21:exp:65:exp:40:int:0:int:1:exp:21:int:0:int:0
Record crypt, little space, NULL cipher, SSL3, SHA-1, short tag, EtM
depends_on:27:0:21:20
21:exp:65:exp:40:int:1:int:1:exp:21:int:0:int:0
Record crypt, little space, NULL cipher, SSL3, MD5
depends_on:27:0:22
21:exp:65:exp:41:int:0:int:0:exp:21:int:0:int:0
Record crypt, little space, NULL cipher, SSL3, MD5, EtM
depends_on:27:0:22:20
21:exp:65:exp:41:int:1:int:0:exp:21:int:0:int:0
Record crypt, little space, NULL cipher, SSL3, MD5, short tag
depends_on:27:0:22
21:exp:65:exp:41:int:0:int:1:exp:21:int:0:int:0
Record crypt, little space, NULL cipher, SSL3, MD5, short tag, EtM
depends_on:27:0:22:20
21:exp:65:exp:41:int:1:int:1:exp:21:int:0:int:0
Decrypt CBC !EtM, AES MD5 !trunc, empty plaintext, minpad
depends_on:9:22
22:exp:37:exp:41:int:0:exp:36
Decrypt CBC !EtM, AES MD5 !trunc, empty plaintext, maxpad
depends_on:9:22
22:exp:37:exp:41:int:0:exp:67
Decrypt CBC !EtM, AES MD5 trunc, empty plaintext, minpad
depends_on:9:22
22:exp:37:exp:41:int:1:exp:36
Decrypt CBC !EtM, AES MD5 trunc, empty plaintext, maxpad
depends_on:9:22
22:exp:37:exp:41:int:1:exp:67
Decrypt CBC !EtM, AES MD5 !trunc, padlen=0
depends_on:9:22
22:exp:37:exp:41:int:0:int:0
Decrypt CBC !EtM, AES MD5 !trunc, padlen=240
depends_on:9:22
22:exp:37:exp:41:int:0:int:240
Decrypt CBC !EtM, AES MD5 trunc, padlen=0
depends_on:9:22
22:exp:37:exp:41:int:1:int:0
Decrypt CBC !EtM, AES MD5 trunc, padlen=240
depends_on:9:22
22:exp:37:exp:41:int:1:int:240
Decrypt CBC !EtM, AES MD5 !trunc, padlen=1
depends_on:9:22
22:exp:37:exp:41:int:0:int:1
Decrypt CBC !EtM, AES MD5 !trunc, padlen=241
depends_on:9:22
22:exp:37:exp:41:int:0:int:241
Decrypt CBC !EtM, AES MD5 trunc, padlen=1
depends_on:9:22
22:exp:37:exp:41:int:1:int:1
Decrypt CBC !EtM, AES MD5 trunc, padlen=241
depends_on:9:22
22:exp:37:exp:41:int:1:int:241
Decrypt CBC !EtM, AES MD5 !trunc, padlen=15
depends_on:9:22
22:exp:37:exp:41:int:0:int:15
Decrypt CBC !EtM, AES MD5 !trunc, padlen=255
depends_on:9:22
22:exp:37:exp:41:int:0:int:255
Decrypt CBC !EtM, AES MD5 trunc, padlen=15
depends_on:9:22
22:exp:37:exp:41:int:1:int:15
Decrypt CBC !EtM, AES MD5 trunc, padlen=255
depends_on:9:22
22:exp:37:exp:41:int:1:int:255
Decrypt CBC !EtM, AES SHA1 !trunc, empty plaintext, minpad
depends_on:9:21
22:exp:37:exp:40:int:0:exp:36
Decrypt CBC !EtM, AES SHA1 !trunc, empty plaintext, maxpad
depends_on:9:21
22:exp:37:exp:40:int:0:exp:67
Decrypt CBC !EtM, AES SHA1 trunc, empty plaintext, minpad
depends_on:9:21
22:exp:37:exp:40:int:1:exp:36
Decrypt CBC !EtM, AES SHA1 trunc, empty plaintext, maxpad
depends_on:9:21
22:exp:37:exp:40:int:1:exp:67
Decrypt CBC !EtM, AES SHA1 !trunc, padlen=0
depends_on:9:21
22:exp:37:exp:40:int:0:int:0
Decrypt CBC !EtM, AES SHA1 !trunc, padlen=240
depends_on:9:21
22:exp:37:exp:40:int:0:int:240
Decrypt CBC !EtM, AES SHA1 trunc, padlen=0
depends_on:9:21
22:exp:37:exp:40:int:1:int:0
Decrypt CBC !EtM, AES SHA1 trunc, padlen=240
depends_on:9:21
22:exp:37:exp:40:int:1:int:240
Decrypt CBC !EtM, AES SHA1 !trunc, padlen=1
depends_on:9:21
22:exp:37:exp:40:int:0:int:1
Decrypt CBC !EtM, AES SHA1 !trunc, padlen=241
depends_on:9:21
22:exp:37:exp:40:int:0:int:241
Decrypt CBC !EtM, AES SHA1 trunc, padlen=1
depends_on:9:21
22:exp:37:exp:40:int:1:int:1
Decrypt CBC !EtM, AES SHA1 trunc, padlen=241
depends_on:9:21
22:exp:37:exp:40:int:1:int:241
Decrypt CBC !EtM, AES SHA1 !trunc, padlen=15
depends_on:9:21
22:exp:37:exp:40:int:0:int:15
Decrypt CBC !EtM, AES SHA1 !trunc, padlen=255
depends_on:9:21
22:exp:37:exp:40:int:0:int:255
Decrypt CBC !EtM, AES SHA1 trunc, padlen=15
depends_on:9:21
22:exp:37:exp:40:int:1:int:15
Decrypt CBC !EtM, AES SHA1 trunc, padlen=255
depends_on:9:21
22:exp:37:exp:40:int:1:int:255
Decrypt CBC !EtM, AES SHA256 !trunc, empty plaintext, minpad
depends_on:9:13
22:exp:37:exp:39:int:0:exp:36
Decrypt CBC !EtM, AES SHA256 !trunc, empty plaintext, maxpad
depends_on:9:13
22:exp:37:exp:39:int:0:exp:67
Decrypt CBC !EtM, AES SHA256 trunc, empty plaintext, minpad
depends_on:9:13
22:exp:37:exp:39:int:1:exp:36
Decrypt CBC !EtM, AES SHA256 trunc, empty plaintext, maxpad
depends_on:9:13
22:exp:37:exp:39:int:1:exp:67
Decrypt CBC !EtM, AES SHA256 !trunc, padlen=0
depends_on:9:13
22:exp:37:exp:39:int:0:int:0
Decrypt CBC !EtM, AES SHA256 !trunc, padlen=240
depends_on:9:13
22:exp:37:exp:39:int:0:int:240
Decrypt CBC !EtM, AES SHA256 trunc, padlen=0
depends_on:9:13
22:exp:37:exp:39:int:1:int:0
Decrypt CBC !EtM, AES SHA256 trunc, padlen=240
depends_on:9:13
22:exp:37:exp:39:int:1:int:240
Decrypt CBC !EtM, AES SHA256 !trunc, padlen=1
depends_on:9:13
22:exp:37:exp:39:int:0:int:1
Decrypt CBC !EtM, AES SHA256 !trunc, padlen=241
depends_on:9:13
22:exp:37:exp:39:int:0:int:241
Decrypt CBC !EtM, AES SHA256 trunc, padlen=1
depends_on:9:13
22:exp:37:exp:39:int:1:int:1
Decrypt CBC !EtM, AES SHA256 trunc, padlen=241
depends_on:9:13
22:exp:37:exp:39:int:1:int:241
Decrypt CBC !EtM, AES SHA256 !trunc, padlen=15
depends_on:9:13
22:exp:37:exp:39:int:0:int:15
Decrypt CBC !EtM, AES SHA256 !trunc, padlen=255
depends_on:9:13
22:exp:37:exp:39:int:0:int:255
Decrypt CBC !EtM, AES SHA256 trunc, padlen=15
depends_on:9:13
22:exp:37:exp:39:int:1:int:15
Decrypt CBC !EtM, AES SHA256 trunc, padlen=255
depends_on:9:13
22:exp:37:exp:39:int:1:int:255
Decrypt CBC !EtM, AES SHA384 !trunc, empty plaintext, minpad
depends_on:9:7:8
22:exp:37:exp:38:int:0:exp:36
Decrypt CBC !EtM, AES SHA384 !trunc, empty plaintext, maxpad
depends_on:9:7:8
22:exp:37:exp:38:int:0:exp:67
Decrypt CBC !EtM, AES SHA384 trunc, empty plaintext, minpad
depends_on:9:7:8
22:exp:37:exp:38:int:1:exp:36
Decrypt CBC !EtM, AES SHA384 trunc, empty plaintext, maxpad
depends_on:9:7:8
22:exp:37:exp:38:int:1:exp:67
Decrypt CBC !EtM, AES SHA384 !trunc, padlen=0
depends_on:9:7:8
22:exp:37:exp:38:int:0:int:0
Decrypt CBC !EtM, AES SHA384 !trunc, padlen=240
depends_on:9:7:8
22:exp:37:exp:38:int:0:int:240
Decrypt CBC !EtM, AES SHA384 trunc, padlen=0
depends_on:9:7:8
22:exp:37:exp:38:int:1:int:0
Decrypt CBC !EtM, AES SHA384 trunc, padlen=240
depends_on:9:7:8
22:exp:37:exp:38:int:1:int:240
Decrypt CBC !EtM, AES SHA384 !trunc, padlen=1
depends_on:9:7:8
22:exp:37:exp:38:int:0:int:1
Decrypt CBC !EtM, AES SHA384 !trunc, padlen=241
depends_on:9:7:8
22:exp:37:exp:38:int:0:int:241
Decrypt CBC !EtM, AES SHA384 trunc, padlen=1
depends_on:9:7:8
22:exp:37:exp:38:int:1:int:1
Decrypt CBC !EtM, AES SHA384 trunc, padlen=241
depends_on:9:7:8
22:exp:37:exp:38:int:1:int:241
Decrypt CBC !EtM, AES SHA384 !trunc, padlen=15
depends_on:9:7:8
22:exp:37:exp:38:int:0:int:15
Decrypt CBC !EtM, AES SHA384 !trunc, padlen=255
depends_on:9:7:8
22:exp:37:exp:38:int:0:int:255
Decrypt CBC !EtM, AES SHA384 trunc, padlen=15
depends_on:9:7:8
22:exp:37:exp:38:int:1:int:15
Decrypt CBC !EtM, AES SHA384 trunc, padlen=255
depends_on:9:7:8
22:exp:37:exp:38:int:1:int:255
Decrypt CBC !EtM, ARIA MD5 !trunc, empty plaintext, minpad
depends_on:23:22
22:exp:44:exp:41:int:0:exp:36
Decrypt CBC !EtM, ARIA MD5 !trunc, empty plaintext, maxpad
depends_on:23:22
22:exp:44:exp:41:int:0:exp:67
Decrypt CBC !EtM, ARIA MD5 trunc, empty plaintext, minpad
depends_on:23:22
22:exp:44:exp:41:int:1:exp:36
Decrypt CBC !EtM, ARIA MD5 trunc, empty plaintext, maxpad
depends_on:23:22
22:exp:44:exp:41:int:1:exp:67
Decrypt CBC !EtM, ARIA MD5 !trunc, padlen=0
depends_on:23:22
22:exp:44:exp:41:int:0:int:0
Decrypt CBC !EtM, ARIA MD5 !trunc, padlen=240
depends_on:23:22
22:exp:44:exp:41:int:0:int:240
Decrypt CBC !EtM, ARIA MD5 trunc, padlen=0
depends_on:23:22
22:exp:44:exp:41:int:1:int:0
Decrypt CBC !EtM, ARIA MD5 trunc, padlen=240
depends_on:23:22
22:exp:44:exp:41:int:1:int:240
Decrypt CBC !EtM, ARIA MD5 !trunc, padlen=1
depends_on:23:22
22:exp:44:exp:41:int:0:int:1
Decrypt CBC !EtM, ARIA MD5 !trunc, padlen=241
depends_on:23:22
22:exp:44:exp:41:int:0:int:241
Decrypt CBC !EtM, ARIA MD5 trunc, padlen=1
depends_on:23:22
22:exp:44:exp:41:int:1:int:1
Decrypt CBC !EtM, ARIA MD5 trunc, padlen=241
depends_on:23:22
22:exp:44:exp:41:int:1:int:241
Decrypt CBC !EtM, ARIA MD5 !trunc, padlen=15
depends_on:23:22
22:exp:44:exp:41:int:0:int:15
Decrypt CBC !EtM, ARIA MD5 !trunc, padlen=255
depends_on:23:22
22:exp:44:exp:41:int:0:int:255
Decrypt CBC !EtM, ARIA MD5 trunc, padlen=15
depends_on:23:22
22:exp:44:exp:41:int:1:int:15
Decrypt CBC !EtM, ARIA MD5 trunc, padlen=255
depends_on:23:22
22:exp:44:exp:41:int:1:int:255
Decrypt CBC !EtM, ARIA SHA1 !trunc, empty plaintext, minpad
depends_on:23:21
22:exp:44:exp:40:int:0:exp:36
Decrypt CBC !EtM, ARIA SHA1 !trunc, empty plaintext, maxpad
depends_on:23:21
22:exp:44:exp:40:int:0:exp:67
Decrypt CBC !EtM, ARIA SHA1 trunc, empty plaintext, minpad
depends_on:23:21
22:exp:44:exp:40:int:1:exp:36
Decrypt CBC !EtM, ARIA SHA1 trunc, empty plaintext, maxpad
depends_on:23:21
22:exp:44:exp:40:int:1:exp:67
Decrypt CBC !EtM, ARIA SHA1 !trunc, padlen=0
depends_on:23:21
22:exp:44:exp:40:int:0:int:0
Decrypt CBC !EtM, ARIA SHA1 !trunc, padlen=240
depends_on:23:21
22:exp:44:exp:40:int:0:int:240
Decrypt CBC !EtM, ARIA SHA1 trunc, padlen=0
depends_on:23:21
22:exp:44:exp:40:int:1:int:0
Decrypt CBC !EtM, ARIA SHA1 trunc, padlen=240
depends_on:23:21
22:exp:44:exp:40:int:1:int:240
Decrypt CBC !EtM, ARIA SHA1 !trunc, padlen=1
depends_on:23:21
22:exp:44:exp:40:int:0:int:1
Decrypt CBC !EtM, ARIA SHA1 !trunc, padlen=241
depends_on:23:21
22:exp:44:exp:40:int:0:int:241
Decrypt CBC !EtM, ARIA SHA1 trunc, padlen=1
depends_on:23:21
22:exp:44:exp:40:int:1:int:1
Decrypt CBC !EtM, ARIA SHA1 trunc, padlen=241
depends_on:23:21
22:exp:44:exp:40:int:1:int:241
Decrypt CBC !EtM, ARIA SHA1 !trunc, padlen=15
depends_on:23:21
22:exp:44:exp:40:int:0:int:15
Decrypt CBC !EtM, ARIA SHA1 !trunc, padlen=255
depends_on:23:21
22:exp:44:exp:40:int:0:int:255
Decrypt CBC !EtM, ARIA SHA1 trunc, padlen=15
depends_on:23:21
22:exp:44:exp:40:int:1:int:15
Decrypt CBC !EtM, ARIA SHA1 trunc, padlen=255
depends_on:23:21
22:exp:44:exp:40:int:1:int:255
Decrypt CBC !EtM, ARIA SHA256 !trunc, empty plaintext, minpad
depends_on:23:13
22:exp:44:exp:39:int:0:exp:36
Decrypt CBC !EtM, ARIA SHA256 !trunc, empty plaintext, maxpad
depends_on:23:13
22:exp:44:exp:39:int:0:exp:67
Decrypt CBC !EtM, ARIA SHA256 trunc, empty plaintext, minpad
depends_on:23:13
22:exp:44:exp:39:int:1:exp:36
Decrypt CBC !EtM, ARIA SHA256 trunc, empty plaintext, maxpad
depends_on:23:13
22:exp:44:exp:39:int:1:exp:67
Decrypt CBC !EtM, ARIA SHA256 !trunc, padlen=0
depends_on:23:13
22:exp:44:exp:39:int:0:int:0
Decrypt CBC !EtM, ARIA SHA256 !trunc, padlen=240
depends_on:23:13
22:exp:44:exp:39:int:0:int:240
Decrypt CBC !EtM, ARIA SHA256 trunc, padlen=0
depends_on:23:13
22:exp:44:exp:39:int:1:int:0
Decrypt CBC !EtM, ARIA SHA256 trunc, padlen=240
depends_on:23:13
22:exp:44:exp:39:int:1:int:240
Decrypt CBC !EtM, ARIA SHA256 !trunc, padlen=1
depends_on:23:13
22:exp:44:exp:39:int:0:int:1
Decrypt CBC !EtM, ARIA SHA256 !trunc, padlen=241
depends_on:23:13
22:exp:44:exp:39:int:0:int:241
Decrypt CBC !EtM, ARIA SHA256 trunc, padlen=1
depends_on:23:13
22:exp:44:exp:39:int:1:int:1
Decrypt CBC !EtM, ARIA SHA256 trunc, padlen=241
depends_on:23:13
22:exp:44:exp:39:int:1:int:241
Decrypt CBC !EtM, ARIA SHA256 !trunc, padlen=15
depends_on:23:13
22:exp:44:exp:39:int:0:int:15
Decrypt CBC !EtM, ARIA SHA256 !trunc, padlen=255
depends_on:23:13
22:exp:44:exp:39:int:0:int:255
Decrypt CBC !EtM, ARIA SHA256 trunc, padlen=15
depends_on:23:13
22:exp:44:exp:39:int:1:int:15
Decrypt CBC !EtM, ARIA SHA256 trunc, padlen=255
depends_on:23:13
22:exp:44:exp:39:int:1:int:255
Decrypt CBC !EtM, ARIA SHA384 !trunc, empty plaintext, minpad
depends_on:23:7:8
22:exp:44:exp:38:int:0:exp:36
Decrypt CBC !EtM, ARIA SHA384 !trunc, empty plaintext, maxpad
depends_on:23:7:8
22:exp:44:exp:38:int:0:exp:67
Decrypt CBC !EtM, ARIA SHA384 trunc, empty plaintext, minpad
depends_on:23:7:8
22:exp:44:exp:38:int:1:exp:36
Decrypt CBC !EtM, ARIA SHA384 trunc, empty plaintext, maxpad
depends_on:23:7:8
22:exp:44:exp:38:int:1:exp:67
Decrypt CBC !EtM, ARIA SHA384 !trunc, padlen=0
depends_on:23:7:8
22:exp:44:exp:38:int:0:int:0
Decrypt CBC !EtM, ARIA SHA384 !trunc, padlen=240
depends_on:23:7:8
22:exp:44:exp:38:int:0:int:240
Decrypt CBC !EtM, ARIA SHA384 trunc, padlen=0
depends_on:23:7:8
22:exp:44:exp:38:int:1:int:0
Decrypt CBC !EtM, ARIA SHA384 trunc, padlen=240
depends_on:23:7:8
22:exp:44:exp:38:int:1:int:240
Decrypt CBC !EtM, ARIA SHA384 !trunc, padlen=1
depends_on:23:7:8
22:exp:44:exp:38:int:0:int:1
Decrypt CBC !EtM, ARIA SHA384 !trunc, padlen=241
depends_on:23:7:8
22:exp:44:exp:38:int:0:int:241
Decrypt CBC !EtM, ARIA SHA384 trunc, padlen=1
depends_on:23:7:8
22:exp:44:exp:38:int:1:int:1
Decrypt CBC !EtM, ARIA SHA384 trunc, padlen=241
depends_on:23:7:8
22:exp:44:exp:38:int:1:int:241
Decrypt CBC !EtM, ARIA SHA384 !trunc, padlen=15
depends_on:23:7:8
22:exp:44:exp:38:int:0:int:15
Decrypt CBC !EtM, ARIA SHA384 !trunc, padlen=255
depends_on:23:7:8
22:exp:44:exp:38:int:0:int:255
Decrypt CBC !EtM, ARIA SHA384 trunc, padlen=15
depends_on:23:7:8
22:exp:44:exp:38:int:1:int:15
Decrypt CBC !EtM, ARIA SHA384 trunc, padlen=255
depends_on:23:7:8
22:exp:44:exp:38:int:1:int:255
Decrypt CBC !EtM, CAMELLIA MD5 !trunc, empty plaintext, minpad
depends_on:16:22
22:exp:47:exp:41:int:0:exp:36
Decrypt CBC !EtM, CAMELLIA MD5 !trunc, empty plaintext, maxpad
depends_on:16:22
22:exp:47:exp:41:int:0:exp:67
Decrypt CBC !EtM, CAMELLIA MD5 trunc, empty plaintext, minpad
depends_on:16:22
22:exp:47:exp:41:int:1:exp:36
Decrypt CBC !EtM, CAMELLIA MD5 trunc, empty plaintext, maxpad
depends_on:16:22
22:exp:47:exp:41:int:1:exp:67
Decrypt CBC !EtM, CAMELLIA MD5 !trunc, padlen=0
depends_on:16:22
22:exp:47:exp:41:int:0:int:0
Decrypt CBC !EtM, CAMELLIA MD5 !trunc, padlen=240
depends_on:16:22
22:exp:47:exp:41:int:0:int:240
Decrypt CBC !EtM, CAMELLIA MD5 trunc, padlen=0
depends_on:16:22
22:exp:47:exp:41:int:1:int:0
Decrypt CBC !EtM, CAMELLIA MD5 trunc, padlen=240
depends_on:16:22
22:exp:47:exp:41:int:1:int:240
Decrypt CBC !EtM, CAMELLIA MD5 !trunc, padlen=1
depends_on:16:22
22:exp:47:exp:41:int:0:int:1
Decrypt CBC !EtM, CAMELLIA MD5 !trunc, padlen=241
depends_on:16:22
22:exp:47:exp:41:int:0:int:241
Decrypt CBC !EtM, CAMELLIA MD5 trunc, padlen=1
depends_on:16:22
22:exp:47:exp:41:int:1:int:1
Decrypt CBC !EtM, CAMELLIA MD5 trunc, padlen=241
depends_on:16:22
22:exp:47:exp:41:int:1:int:241
Decrypt CBC !EtM, CAMELLIA MD5 !trunc, padlen=15
depends_on:16:22
22:exp:47:exp:41:int:0:int:15
Decrypt CBC !EtM, CAMELLIA MD5 !trunc, padlen=255
depends_on:16:22
22:exp:47:exp:41:int:0:int:255
Decrypt CBC !EtM, CAMELLIA MD5 trunc, padlen=15
depends_on:16:22
22:exp:47:exp:41:int:1:int:15
Decrypt CBC !EtM, CAMELLIA MD5 trunc, padlen=255
depends_on:16:22
22:exp:47:exp:41:int:1:int:255
Decrypt CBC !EtM, CAMELLIA SHA1 !trunc, empty plaintext, minpad
depends_on:16:21
22:exp:47:exp:40:int:0:exp:36
Decrypt CBC !EtM, CAMELLIA SHA1 !trunc, empty plaintext, maxpad
depends_on:16:21
22:exp:47:exp:40:int:0:exp:67
Decrypt CBC !EtM, CAMELLIA SHA1 trunc, empty plaintext, minpad
depends_on:16:21
22:exp:47:exp:40:int:1:exp:36
Decrypt CBC !EtM, CAMELLIA SHA1 trunc, empty plaintext, maxpad
depends_on:16:21
22:exp:47:exp:40:int:1:exp:67
Decrypt CBC !EtM, CAMELLIA SHA1 !trunc, padlen=0
depends_on:16:21
22:exp:47:exp:40:int:0:int:0
Decrypt CBC !EtM, CAMELLIA SHA1 !trunc, padlen=240
depends_on:16:21
22:exp:47:exp:40:int:0:int:240
Decrypt CBC !EtM, CAMELLIA SHA1 trunc, padlen=0
depends_on:16:21
22:exp:47:exp:40:int:1:int:0
Decrypt CBC !EtM, CAMELLIA SHA1 trunc, padlen=240
depends_on:16:21
22:exp:47:exp:40:int:1:int:240
Decrypt CBC !EtM, CAMELLIA SHA1 !trunc, padlen=1
depends_on:16:21
22:exp:47:exp:40:int:0:int:1
Decrypt CBC !EtM, CAMELLIA SHA1 !trunc, padlen=241
depends_on:16:21
22:exp:47:exp:40:int:0:int:241
Decrypt CBC !EtM, CAMELLIA SHA1 trunc, padlen=1
depends_on:16:21
22:exp:47:exp:40:int:1:int:1
Decrypt CBC !EtM, CAMELLIA SHA1 trunc, padlen=241
depends_on:16:21
22:exp:47:exp:40:int:1:int:241
Decrypt CBC !EtM, CAMELLIA SHA1 !trunc, padlen=15
depends_on:16:21
22:exp:47:exp:40:int:0:int:15
Decrypt CBC !EtM, CAMELLIA SHA1 !trunc, padlen=255
depends_on:16:21
22:exp:47:exp:40:int:0:int:255
Decrypt CBC !EtM, CAMELLIA SHA1 trunc, padlen=15
depends_on:16:21
22:exp:47:exp:40:int:1:int:15
Decrypt CBC !EtM, CAMELLIA SHA1 trunc, padlen=255
depends_on:16:21
22:exp:47:exp:40:int:1:int:255
Decrypt CBC !EtM, CAMELLIA SHA256 !trunc, empty plaintext, minpad
depends_on:16:13
22:exp:47:exp:39:int:0:exp:36
Decrypt CBC !EtM, CAMELLIA SHA256 !trunc, empty plaintext, maxpad
depends_on:16:13
22:exp:47:exp:39:int:0:exp:67
Decrypt CBC !EtM, CAMELLIA SHA256 trunc, empty plaintext, minpad
depends_on:16:13
22:exp:47:exp:39:int:1:exp:36
Decrypt CBC !EtM, CAMELLIA SHA256 trunc, empty plaintext, maxpad
depends_on:16:13
22:exp:47:exp:39:int:1:exp:67
Decrypt CBC !EtM, CAMELLIA SHA256 !trunc, padlen=0
depends_on:16:13
22:exp:47:exp:39:int:0:int:0
Decrypt CBC !EtM, CAMELLIA SHA256 !trunc, padlen=240
depends_on:16:13
22:exp:47:exp:39:int:0:int:240
Decrypt CBC !EtM, CAMELLIA SHA256 trunc, padlen=0
depends_on:16:13
22:exp:47:exp:39:int:1:int:0
Decrypt CBC !EtM, CAMELLIA SHA256 trunc, padlen=240
depends_on:16:13
22:exp:47:exp:39:int:1:int:240
Decrypt CBC !EtM, CAMELLIA SHA256 !trunc, padlen=1
depends_on:16:13
22:exp:47:exp:39:int:0:int:1
Decrypt CBC !EtM, CAMELLIA SHA256 !trunc, padlen=241
depends_on:16:13
22:exp:47:exp:39:int:0:int:241
Decrypt CBC !EtM, CAMELLIA SHA256 trunc, padlen=1
depends_on:16:13
22:exp:47:exp:39:int:1:int:1
Decrypt CBC !EtM, CAMELLIA SHA256 trunc, padlen=241
depends_on:16:13
22:exp:47:exp:39:int:1:int:241
Decrypt CBC !EtM, CAMELLIA SHA256 !trunc, padlen=15
depends_on:16:13
22:exp:47:exp:39:int:0:int:15
Decrypt CBC !EtM, CAMELLIA SHA256 !trunc, padlen=255
depends_on:16:13
22:exp:47:exp:39:int:0:int:255
Decrypt CBC !EtM, CAMELLIA SHA256 trunc, padlen=15
depends_on:16:13
22:exp:47:exp:39:int:1:int:15
Decrypt CBC !EtM, CAMELLIA SHA256 trunc, padlen=255
depends_on:16:13
22:exp:47:exp:39:int:1:int:255
Decrypt CBC !EtM, CAMELLIA SHA384 !trunc, empty plaintext, minpad
depends_on:16:7:8
22:exp:47:exp:38:int:0:exp:36
Decrypt CBC !EtM, CAMELLIA SHA384 !trunc, empty plaintext, maxpad
depends_on:16:7:8
22:exp:47:exp:38:int:0:exp:67
Decrypt CBC !EtM, CAMELLIA SHA384 trunc, empty plaintext, minpad
depends_on:16:7:8
22:exp:47:exp:38:int:1:exp:36
Decrypt CBC !EtM, CAMELLIA SHA384 trunc, empty plaintext, maxpad
depends_on:16:7:8
22:exp:47:exp:38:int:1:exp:67
Decrypt CBC !EtM, CAMELLIA SHA384 !trunc, padlen=0
depends_on:16:7:8
22:exp:47:exp:38:int:0:int:0
Decrypt CBC !EtM, CAMELLIA SHA384 !trunc, padlen=240
depends_on:16:7:8
22:exp:47:exp:38:int:0:int:240
Decrypt CBC !EtM, CAMELLIA SHA384 trunc, padlen=0
depends_on:16:7:8
22:exp:47:exp:38:int:1:int:0
Decrypt CBC !EtM, CAMELLIA SHA384 trunc, padlen=240
depends_on:16:7:8
22:exp:47:exp:38:int:1:int:240
Decrypt CBC !EtM, CAMELLIA SHA384 !trunc, padlen=1
depends_on:16:7:8
22:exp:47:exp:38:int:0:int:1
Decrypt CBC !EtM, CAMELLIA SHA384 !trunc, padlen=241
depends_on:16:7:8
22:exp:47:exp:38:int:0:int:241
Decrypt CBC !EtM, CAMELLIA SHA384 trunc, padlen=1
depends_on:16:7:8
22:exp:47:exp:38:int:1:int:1
Decrypt CBC !EtM, CAMELLIA SHA384 trunc, padlen=241
depends_on:16:7:8
22:exp:47:exp:38:int:1:int:241
Decrypt CBC !EtM, CAMELLIA SHA384 !trunc, padlen=15
depends_on:16:7:8
22:exp:47:exp:38:int:0:int:15
Decrypt CBC !EtM, CAMELLIA SHA384 !trunc, padlen=255
depends_on:16:7:8
22:exp:47:exp:38:int:0:int:255
Decrypt CBC !EtM, CAMELLIA SHA384 trunc, padlen=15
depends_on:16:7:8
22:exp:47:exp:38:int:1:int:15
Decrypt CBC !EtM, CAMELLIA SHA384 trunc, padlen=255
depends_on:16:7:8
22:exp:47:exp:38:int:1:int:255
Decrypt CBC !EtM, 3DES MD5 !trunc, empty plaintext, minpad
depends_on:29:22
22:exp:68:exp:41:int:0:exp:36
Decrypt CBC !EtM, 3DES MD5 !trunc, empty plaintext, maxpad
depends_on:29:22
22:exp:68:exp:41:int:0:exp:67
Decrypt CBC !EtM, 3DES MD5 trunc, empty plaintext, minpad
depends_on:29:22
22:exp:68:exp:41:int:1:exp:36
Decrypt CBC !EtM, 3DES MD5 trunc, empty plaintext, maxpad
depends_on:29:22
22:exp:68:exp:41:int:1:exp:67
Decrypt CBC !EtM, 3DES MD5 !trunc, padlen=0
depends_on:29:22
22:exp:68:exp:41:int:0:int:0
Decrypt CBC !EtM, 3DES MD5 !trunc, padlen=248
depends_on:29:22
22:exp:68:exp:41:int:0:int:248
Decrypt CBC !EtM, 3DES MD5 trunc, padlen=0
depends_on:29:22
22:exp:68:exp:41:int:1:int:0
Decrypt CBC !EtM, 3DES MD5 trunc, padlen=248
depends_on:29:22
22:exp:68:exp:41:int:1:int:248
Decrypt CBC !EtM, 3DES MD5 !trunc, padlen=1
depends_on:29:22
22:exp:68:exp:41:int:0:int:1
Decrypt CBC !EtM, 3DES MD5 !trunc, padlen=249
depends_on:29:22
22:exp:68:exp:41:int:0:int:249
Decrypt CBC !EtM, 3DES MD5 trunc, padlen=1
depends_on:29:22
22:exp:68:exp:41:int:1:int:1
Decrypt CBC !EtM, 3DES MD5 trunc, padlen=249
depends_on:29:22
22:exp:68:exp:41:int:1:int:249
Decrypt CBC !EtM, 3DES MD5 !trunc, padlen=7
depends_on:29:22
22:exp:68:exp:41:int:0:int:7
Decrypt CBC !EtM, 3DES MD5 !trunc, padlen=255
depends_on:29:22
22:exp:68:exp:41:int:0:int:255
Decrypt CBC !EtM, 3DES MD5 trunc, padlen=7
depends_on:29:22
22:exp:68:exp:41:int:1:int:7
Decrypt CBC !EtM, 3DES MD5 trunc, padlen=255
depends_on:29:22
22:exp:68:exp:41:int:1:int:255
Decrypt CBC !EtM, 3DES SHA1 !trunc, empty plaintext, minpad
depends_on:29:21
22:exp:68:exp:40:int:0:exp:36
Decrypt CBC !EtM, 3DES SHA1 !trunc, empty plaintext, maxpad
depends_on:29:21
22:exp:68:exp:40:int:0:exp:67
Decrypt CBC !EtM, 3DES SHA1 trunc, empty plaintext, minpad
depends_on:29:21
22:exp:68:exp:40:int:1:exp:36
Decrypt CBC !EtM, 3DES SHA1 trunc, empty plaintext, maxpad
depends_on:29:21
22:exp:68:exp:40:int:1:exp:67
Decrypt CBC !EtM, 3DES SHA1 !trunc, padlen=0
depends_on:29:21
22:exp:68:exp:40:int:0:int:0
Decrypt CBC !EtM, 3DES SHA1 !trunc, padlen=248
depends_on:29:21
22:exp:68:exp:40:int:0:int:248
Decrypt CBC !EtM, 3DES SHA1 trunc, padlen=0
depends_on:29:21
22:exp:68:exp:40:int:1:int:0
Decrypt CBC !EtM, 3DES SHA1 trunc, padlen=248
depends_on:29:21
22:exp:68:exp:40:int:1:int:248
Decrypt CBC !EtM, 3DES SHA1 !trunc, padlen=1
depends_on:29:21
22:exp:68:exp:40:int:0:int:1
Decrypt CBC !EtM, 3DES SHA1 !trunc, padlen=249
depends_on:29:21
22:exp:68:exp:40:int:0:int:249
Decrypt CBC !EtM, 3DES SHA1 trunc, padlen=1
depends_on:29:21
22:exp:68:exp:40:int:1:int:1
Decrypt CBC !EtM, 3DES SHA1 trunc, padlen=249
depends_on:29:21
22:exp:68:exp:40:int:1:int:249
Decrypt CBC !EtM, 3DES SHA1 !trunc, padlen=7
depends_on:29:21
22:exp:68:exp:40:int:0:int:7
Decrypt CBC !EtM, 3DES SHA1 !trunc, padlen=255
depends_on:29:21
22:exp:68:exp:40:int:0:int:255
Decrypt CBC !EtM, 3DES SHA1 trunc, padlen=7
depends_on:29:21
22:exp:68:exp:40:int:1:int:7
Decrypt CBC !EtM, 3DES SHA1 trunc, padlen=255
depends_on:29:21
22:exp:68:exp:40:int:1:int:255
Decrypt CBC !EtM, 3DES SHA256 !trunc, empty plaintext, minpad
depends_on:29:13
22:exp:68:exp:39:int:0:exp:36
Decrypt CBC !EtM, 3DES SHA256 !trunc, empty plaintext, maxpad
depends_on:29:13
22:exp:68:exp:39:int:0:exp:67
Decrypt CBC !EtM, 3DES SHA256 trunc, empty plaintext, minpad
depends_on:29:13
22:exp:68:exp:39:int:1:exp:36
Decrypt CBC !EtM, 3DES SHA256 trunc, empty plaintext, maxpad
depends_on:29:13
22:exp:68:exp:39:int:1:exp:67
Decrypt CBC !EtM, 3DES SHA256 !trunc, padlen=0
depends_on:29:13
22:exp:68:exp:39:int:0:int:0
Decrypt CBC !EtM, 3DES SHA256 !trunc, padlen=248
depends_on:29:13
22:exp:68:exp:39:int:0:int:248
Decrypt CBC !EtM, 3DES SHA256 trunc, padlen=0
depends_on:29:13
22:exp:68:exp:39:int:1:int:0
Decrypt CBC !EtM, 3DES SHA256 trunc, padlen=248
depends_on:29:13
22:exp:68:exp:39:int:1:int:248
Decrypt CBC !EtM, 3DES SHA256 !trunc, padlen=1
depends_on:29:13
22:exp:68:exp:39:int:0:int:1
Decrypt CBC !EtM, 3DES SHA256 !trunc, padlen=249
depends_on:29:13
22:exp:68:exp:39:int:0:int:249
Decrypt CBC !EtM, 3DES SHA256 trunc, padlen=1
depends_on:29:13
22:exp:68:exp:39:int:1:int:1
Decrypt CBC !EtM, 3DES SHA256 trunc, padlen=249
depends_on:29:13
22:exp:68:exp:39:int:1:int:249
Decrypt CBC !EtM, 3DES SHA256 !trunc, padlen=7
depends_on:29:13
22:exp:68:exp:39:int:0:int:7
Decrypt CBC !EtM, 3DES SHA256 !trunc, padlen=255
depends_on:29:13
22:exp:68:exp:39:int:0:int:255
Decrypt CBC !EtM, 3DES SHA256 trunc, padlen=7
depends_on:29:13
22:exp:68:exp:39:int:1:int:7
Decrypt CBC !EtM, 3DES SHA256 trunc, padlen=255
depends_on:29:13
22:exp:68:exp:39:int:1:int:255
Decrypt CBC !EtM, 3DES SHA384 !trunc, empty plaintext, minpad
depends_on:29:7:8
22:exp:68:exp:38:int:0:exp:36
Decrypt CBC !EtM, 3DES SHA384 !trunc, empty plaintext, maxpad
depends_on:29:7:8
22:exp:68:exp:38:int:0:exp:67
Decrypt CBC !EtM, 3DES SHA384 trunc, empty plaintext, minpad
depends_on:29:7:8
22:exp:68:exp:38:int:1:exp:36
Decrypt CBC !EtM, 3DES SHA384 trunc, empty plaintext, maxpad
depends_on:29:7:8
22:exp:68:exp:38:int:1:exp:67
Decrypt CBC !EtM, 3DES SHA384 !trunc, padlen=0
depends_on:29:7:8
22:exp:68:exp:38:int:0:int:0
Decrypt CBC !EtM, 3DES SHA384 !trunc, padlen=248
depends_on:29:7:8
22:exp:68:exp:38:int:0:int:248
Decrypt CBC !EtM, 3DES SHA384 trunc, padlen=0
depends_on:29:7:8
22:exp:68:exp:38:int:1:int:0
Decrypt CBC !EtM, 3DES SHA384 trunc, padlen=248
depends_on:29:7:8
22:exp:68:exp:38:int:1:int:248
Decrypt CBC !EtM, 3DES SHA384 !trunc, padlen=1
depends_on:29:7:8
22:exp:68:exp:38:int:0:int:1
Decrypt CBC !EtM, 3DES SHA384 !trunc, padlen=249
depends_on:29:7:8
22:exp:68:exp:38:int:0:int:249
Decrypt CBC !EtM, 3DES SHA384 trunc, padlen=1
depends_on:29:7:8
22:exp:68:exp:38:int:1:int:1
Decrypt CBC !EtM, 3DES SHA384 trunc, padlen=249
depends_on:29:7:8
22:exp:68:exp:38:int:1:int:249
Decrypt CBC !EtM, 3DES SHA384 !trunc, padlen=7
depends_on:29:7:8
22:exp:68:exp:38:int:0:int:7
Decrypt CBC !EtM, 3DES SHA384 !trunc, padlen=255
depends_on:29:7:8
22:exp:68:exp:38:int:0:int:255
Decrypt CBC !EtM, 3DES SHA384 trunc, padlen=7
depends_on:29:7:8
22:exp:68:exp:38:int:1:int:7
Decrypt CBC !EtM, 3DES SHA384 trunc, padlen=255
depends_on:29:7:8
22:exp:68:exp:38:int:1:int:255
SSL TLS 1.3 Key schedule: Secret evolution #1
depends_on:25
26:exp:39:hex:"":hex:"":hex:"33ad0a1c607ec03b09e6cd9893680ce210adf300aa1f2660e1b22e10f170f92a"
SSL TLS 1.3 Key schedule: Secret evolution #2
26:exp:39:hex:"33ad0a1c607ec03b09e6cd9893680ce210adf300aa1f2660e1b22e10f170f92a":hex:"df4a291baa1eb7cfa6934b29b474baad2697e29f1f920dcc77c8a0a088447624":hex:"fb9fc80689b3a5d02c33243bf69a1b1b20705588a794304a6e7120155edf149a"
SSL TLS 1.3 Key schedule: Secret evolution #3
26:exp:39:hex:"fb9fc80689b3a5d02c33243bf69a1b1b20705588a794304a6e7120155edf149a":hex:"":hex:"7f2882bb9b9a46265941653e9c2f19067118151e21d12e57a7b6aca1f8150c8d"
SSL TLS 1.3 Key schedule: HKDF Expand Label #1
23:exp:39:hex:"a2067265e7f0652a923d5d72ab0467c46132eeb968b6a32d311c805868548814":exp:69:hex:"":int:16:hex:"844780a7acad9f980fa25c114e43402a"
SSL TLS 1.3 Key schedule: HKDF Expand Label #2
23:exp:39:hex:"a2067265e7f0652a923d5d72ab0467c46132eeb968b6a32d311c805868548814":exp:70:hex:"":int:12:hex:"4c042ddc120a38d1417fc815"
SSL TLS 1.3 Key schedule: HKDF Expand Label #3
23:exp:39:hex:"ff0e5b965291c608c1e8cd267eefc0afcc5e98a2786373f0db47b04786d72aea":exp:69:hex:"":int:16:hex:"7154f314e6be7dc008df2c832baa1d39"
SSL TLS 1.3 Key schedule: HKDF Expand Label #4
23:exp:39:hex:"ff0e5b965291c608c1e8cd267eefc0afcc5e98a2786373f0db47b04786d72aea":exp:70:hex:"":int:12:hex:"71abc2cae4c699d47c600268"
SSL TLS 1.3 Key schedule: HKDF Expand Label #5 (RFC 8448)
23:exp:39:hex:"b67b7d690cc16c4e75e54213cb2d37b4e9c912bcded9105d42befd59d391ad38":exp:70:hex:"":int:12:hex:"5d313eb2671276ee13000b30"
SSL TLS 1.3 Key schedule: HKDF Expand Label #6 (RFC 8448)
23:exp:39:hex:"b67b7d690cc16c4e75e54213cb2d37b4e9c912bcded9105d42befd59d391ad38":exp:69:hex:"":int:16:hex:"3fce516009c21727d0f2e4e86ee403bc"
SSL TLS 1.3 Key schedule: HKDF Expand Label #7 (RFC 8448)
23:exp:39:hex:"b3eddb126e067f35a780b3abf45e2d8f3b1a950738f52e9600746a0e27a55a21":exp:70:hex:"":int:12:hex:"5bd3c71b836e0b76bb73265f"
SSL TLS 1.3 Key schedule: HKDF Expand Label #8 (RFC 8448)
23:exp:39:hex:"b3eddb126e067f35a780b3abf45e2d8f3b1a950738f52e9600746a0e27a55a21":exp:69:hex:"":int:16:hex:"dbfaa693d1762c5b666af5d950258d01"
SSL TLS 1.3 Key schedule: HKDF Expand Label #9 (RFC 8448)
23:exp:39:hex:"2faac08f851d35fea3604fcb4de82dc62c9b164a70974d0462e27f1ab278700f":exp:71:hex:"":int:32:hex:"5ace394c26980d581243f627d1150ae27e37fa52364e0a7f20ac686d09cd0e8e"
SSL TLS 1.3 Key schedule: HKDF Expand Label #10 (RFC 8448)
23:exp:39:hex:"7df235f2031d2a051287d02b0241b0bfdaf86cc856231f2d5aba46c434ec196c":exp:72:hex:"0000":int:32:hex:"4ecd0eb6ec3b4d87f5d6028f922ca4c5851a277fd41311c9e62d2c9492e1c4f3"
SSL TLS 1.3 Key schedule: Traffic key generation #1
24:exp:39:hex:"a2067265e7f0652a923d5d72ab0467c46132eeb968b6a32d311c805868548814":hex:"ff0e5b965291c608c1e8cd267eefc0afcc5e98a2786373f0db47b04786d72aea":int:12:int:16:hex:"844780a7acad9f980fa25c114e43402a":hex:"4c042ddc120a38d1417fc815":hex:"7154f314e6be7dc008df2c832baa1d39":hex:"71abc2cae4c699d47c600268"
SSL TLS 1.3 Key schedule: Traffic key generation #2 (RFC 8448)
24:exp:39:hex:"a2067265e7f0652a923d5d72ab0467c46132eeb968b6a32d311c805868548814":hex:"ff0e5b965291c608c1e8cd267eefc0afcc5e98a2786373f0db47b04786d72aea":int:12:int:16:hex:"844780a7acad9f980fa25c114e43402a":hex:"4c042ddc120a38d1417fc815":hex:"7154f314e6be7dc008df2c832baa1d39":hex:"71abc2cae4c699d47c600268"
SSL TLS 1.3 Key schedule: Derive-Secret( ., "derived", "")
25:exp:39:hex:"33ad0a1c607ec03b09e6cd9893680ce210adf300aa1f2660e1b22e10f170f92a":exp:73:hex:"":int:32:exp:74:hex:"6f2615a108c702c5678f54fc9dbab69716c076189c48250cebeac3576c3611ba"
SSL TLS 1.3 Key schedule: Derive-Secret( ., "s ap traffic", hash) #1
25:exp:39:hex:"7f2882bb9b9a46265941653e9c2f19067118151e21d12e57a7b6aca1f8150c8d":exp:75:hex:"22844b930e5e0a59a09d5ac35fc032fc91163b193874a265236e568077378d8b":int:32:exp:76:hex:"3fc35ea70693069a277956afa23b8f4543ce68ac595f2aace05cd7a1c92023d5"
SSL TLS 1.3 Key schedule: Derive-Secret( ., "c e traffic", hash)
25:exp:39:hex:"9b2188e9b2fc6d64d71dc329900e20bb41915000f678aa839cbb797cb7d8332c":exp:77:hex:"08ad0fa05d7c7233b1775ba2ff9f4c5b8b59276b7f227f13a976245f5d960913":int:32:exp:76:hex:"3fbbe6a60deb66c30a32795aba0eff7eaa10105586e7be5c09678d63b6caab62"
SSL TLS 1.3 Key schedule: Derive-Secret( ., "e exp master", hash)
25:exp:39:hex:"9b2188e9b2fc6d64d71dc329900e20bb41915000f678aa839cbb797cb7d8332c":exp:78:hex:"08ad0fa05d7c7233b1775ba2ff9f4c5b8b59276b7f227f13a976245f5d960913":int:32:exp:76:hex:"b2026866610937d7423e5be90862ccf24c0e6091186d34f812089ff5be2ef7df"
SSL TLS 1.3 Key schedule: Derive-Secret( ., "c hs traffic", hash)
25:exp:39:hex:"005cb112fd8eb4ccc623bb88a07c64b3ede1605363fc7d0df8c7ce4ff0fb4ae6":exp:79:hex:"f736cb34fe25e701551bee6fd24c1cc7102a7daf9405cb15d97aafe16f757d03":int:32:exp:76:hex:"2faac08f851d35fea3604fcb4de82dc62c9b164a70974d0462e27f1ab278700f"
SSL TLS 1.3 Key schedule: Derive-Secret( ., "s hs traffic", hash)
25:exp:39:hex:"005cb112fd8eb4ccc623bb88a07c64b3ede1605363fc7d0df8c7ce4ff0fb4ae6":exp:80:hex:"f736cb34fe25e701551bee6fd24c1cc7102a7daf9405cb15d97aafe16f757d03":int:32:exp:76:hex:"fe927ae271312e8bf0275b581c54eef020450dc4ecffaa05a1a35d27518e7803"
SSL TLS 1.3 Key schedule: Derive-Secret( ., "c ap traffic", hash)
25:exp:39:hex:"e2d32d4ed66dd37897a0e80c84107503ce58bf8aad4cb55a5002d77ecb890ece":exp:81:hex:"b0aeffc46a2cfe33114e6fd7d51f9f04b1ca3c497dab08934a774a9d9ad7dbf3":int:32:exp:76:hex:"2abbf2b8e381d23dbebe1dd2a7d16a8bf484cb4950d23fb7fb7fa8547062d9a1"
SSL TLS 1.3 Key schedule: Derive-Secret( ., "s ap traffic", hash) #2
25:exp:39:hex:"e2d32d4ed66dd37897a0e80c84107503ce58bf8aad4cb55a5002d77ecb890ece":exp:75:hex:"b0aeffc46a2cfe33114e6fd7d51f9f04b1ca3c497dab08934a774a9d9ad7dbf3":int:32:exp:76:hex:"cc21f1bf8feb7dd5fa505bd9c4b468a9984d554a993dc49e6d285598fb672691"
SSL TLS 1.3 Key schedule: Derive-Secret( ., "exp master", hash)
25:exp:39:hex:"e2d32d4ed66dd37897a0e80c84107503ce58bf8aad4cb55a5002d77ecb890ece":exp:82:hex:"b0aeffc46a2cfe33114e6fd7d51f9f04b1ca3c497dab08934a774a9d9ad7dbf3":int:32:exp:76:hex:"3fd93d4ffddc98e64b14dd107aedf8ee4add23f4510f58a4592d0b201bee56b4"
SSL TLS 1.3 Key schedule: Derive-Secret( ., "res master", hash)
25:exp:39:hex:"e2d32d4ed66dd37897a0e80c84107503ce58bf8aad4cb55a5002d77ecb890ece":exp:83:hex:"c3c122e0bd907a4a3ff6112d8fd53dbf89c773d9552e8b6b9d56d361b3a97bf6":int:32:exp:76:hex:"5e95bdf1f89005ea2e9aa0ba85e728e3c19c5fe0c699e3f5bee59faebd0b5406"
SSL TLS_PRF MBEDTLS_SSL_TLS_PRF_NONE
27:exp:84:hex:"":hex:"":char*:"test tls_prf label":hex:"":exp:85
SSL TLS_PRF MBEDTLS_SSL_TLS_PRF_SSL3
depends_on:0
27:exp:86:hex:"1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef":hex:"1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef":char*:"test tls_prf label":hex:"3ff3d192aa599255339def5a9723444a":int:0
SSL TLS_PRF MBEDTLS_SSL_TLS_PRF_TLS1 TLS 1.0 enabled
depends_on:3
27:exp:87:hex:"1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef":hex:"1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef":char*:"test tls_prf label":hex:"8defca540d41d4c79d390027295bb4e6":int:0
SSL TLS_PRF MBEDTLS_SSL_TLS_PRF_TLS1 TLS 1.1 enabled
depends_on:5
27:exp:87:hex:"1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef":hex:"1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef":char*:"test tls_prf label":hex:"8defca540d41d4c79d390027295bb4e6":int:0
SSL TLS_PRF MBEDTLS_SSL_TLS_PRF_SHA384
depends_on:7:8:6
27:exp:88:hex:"1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef":hex:"1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef":char*:"test tls_prf label":hex:"a4206a36eef93f496611c2b7806625c3":int:0
SSL TLS_PRF MBEDTLS_SSL_TLS_PRF_SHA256
depends_on:13:6
27:exp:89:hex:"1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef":hex:"1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef":char*:"test tls_prf label":hex:"7f9998393198a02c8d731ccc2ef90b2c":int:0
SSL TLS_PRF MBEDTLS_SSL_TLS_PRF_SSL3 not enabled
depends_on:30
27:exp:86:hex:"1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef":hex:"1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef":char*:"test tls_prf label":hex:"3ff3d192aa599255339def5a9723444a":exp:85
SSL TLS_PRF MBEDTLS_SSL_TLS_PRF_TLS1 TLS 1.X not enabled
depends_on:31:32
27:exp:87:hex:"1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef":hex:"1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef":char*:"test tls_prf label":hex:"8defca540d41d4c79d390027295bb4e6":exp:85
SSL TLS_PRF MBEDTLS_SSL_TLS_PRF_SHA384 SHA-512 not enabled
depends_on:33
27:exp:88:hex:"1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef":hex:"1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef":char*:"test tls_prf label":hex:"a4206a36eef93f496611c2b7806625c3":exp:85
SSL TLS_PRF MBEDTLS_SSL_TLS_PRF_SHA256 SHA-256 not enabled
depends_on:34
27:exp:89:hex:"1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef":hex:"1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef":char*:"test tls_prf label":hex:"7f9998393198a02c8d731ccc2ef90b2c":exp:85
Session serialization, save-load: no ticket, no cert
28:int:0:char*:""
Session serialization, save-load: small ticket, no cert
depends_on:35:36
28:int:42:char*:""
Session serialization, save-load: large ticket, no cert
depends_on:35:36
28:int:1023:char*:""
Session serialization, save-load: no ticket, cert
depends_on:37:38:14:15:13:39
28:int:0:char*:"/zip/third_party/mbedtls/test/data/server5.crt"
Session serialization, save-load: small ticket, cert
depends_on:35:36:37:38:14:15:13:39
28:int:42:char*:"/zip/third_party/mbedtls/test/data/server5.crt"
Session serialization, save-load: large ticket, cert
depends_on:35:36:37:38:14:15:13:39
28:int:1023:char*:"/zip/third_party/mbedtls/test/data/server5.crt"
Session serialization, load-save: no ticket, no cert
29:int:0:char*:""
Session serialization, load-save: small ticket, no cert
depends_on:35:36
29:int:42:char*:""
Session serialization, load-save: large ticket, no cert
depends_on:35:36
29:int:1023:char*:""
Session serialization, load-save: no ticket, cert
depends_on:37:38:14:15:13:39
29:int:0:char*:"/zip/third_party/mbedtls/test/data/server5.crt"
Session serialization, load-save: small ticket, cert
depends_on:35:36:37:38:14:15:13:39
29:int:42:char*:"/zip/third_party/mbedtls/test/data/server5.crt"
Session serialization, load-save: large ticket, cert
depends_on:35:36:37:38:14:15:13:39
29:int:1023:char*:"/zip/third_party/mbedtls/test/data/server5.crt"
Session serialization, save buffer size: no ticket, no cert
30:int:0:char*:""
Session serialization, save buffer size: small ticket, no cert
depends_on:35:36
30:int:42:char*:""
Session serialization, save buffer size: large ticket, no cert
depends_on:35:36
30:int:1023:char*:""
Session serialization, save buffer size: no ticket, cert
depends_on:37:38:14:15:13:39
30:int:0:char*:"/zip/third_party/mbedtls/test/data/server5.crt"
Session serialization, save buffer size: small ticket, cert
depends_on:35:36:37:38:14:15:13:39
30:int:42:char*:"/zip/third_party/mbedtls/test/data/server5.crt"
Session serialization, save buffer size: large ticket, cert
depends_on:35:36:37:38:14:15:13:39
30:int:1023:char*:"/zip/third_party/mbedtls/test/data/server5.crt"
Session serialization, load buffer size: no ticket, no cert
31:int:0:char*:""
Session serialization, load buffer size: small ticket, no cert
depends_on:35:36
31:int:42:char*:""
Session serialization, load buffer size: large ticket, no cert
depends_on:35:36
31:int:1023:char*:""
Session serialization, load buffer size: no ticket, cert
depends_on:37:38:14:15:13:39
31:int:0:char*:"/zip/third_party/mbedtls/test/data/server5.crt"
Session serialization, load buffer size: small ticket, cert
depends_on:35:36:37:38:14:15:13:39
31:int:42:char*:"/zip/third_party/mbedtls/test/data/server5.crt"
Session serialization, load buffer size: large ticket, cert
depends_on:35:36:37:38:14:15:13:39
31:int:1023:char*:"/zip/third_party/mbedtls/test/data/server5.crt"
Constant-flow HMAC: MD5
depends_on:22
47:exp:41
Constant-flow HMAC: SHA1
depends_on:21
47:exp:40
Constant-flow HMAC: SHA256
depends_on:13
47:exp:39
Constant-flow HMAC: SHA384
depends_on:7:8
47:exp:38
Constant-flow memcpy from offset: small
48:int:0:int:5:int:10
Constant-flow memcpy from offset: medium
48:int:0:int:255:int:32
Constant-flow memcpy from offset: large
48:int:100:int:339:int:48
| 338,428 | 10,635 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_pkcs5.datax | PBKDF2 RFC 6070 Test Vector #1 (SHA1)
depends_on:0
0:exp:0:hex:"70617373776f7264":hex:"73616c74":int:1:int:20:hex:"0c60c80f961f0e71f3a9b524af6012062fe037a6"
PBKDF2 RFC 6070 Test Vector #2 (SHA1)
depends_on:0
0:exp:0:hex:"70617373776f7264":hex:"73616c74":int:2:int:20:hex:"ea6c014dc72d6f8ccd1ed92ace1d41f0d8de8957"
PBKDF2 RFC 6070 Test Vector #3 (SHA1)
depends_on:0
0:exp:0:hex:"70617373776f7264":hex:"73616c74":int:4096:int:20:hex:"4b007901b765489abead49d926f721d065a429c1"
PBKDF2 RFC 6070 Test Vector #5 (SHA1)
depends_on:0
0:exp:0:hex:"70617373776f726450415353574f524470617373776f7264":hex:"73616c7453414c5473616c7453414c5473616c7453414c5473616c7453414c5473616c74":int:4096:int:25:hex:"3d2eec4fe41c849b80c8d83662c0e44a8b291a964cf2f07038"
PBKDF2 RFC 6070 Test Vector #6 (SHA1)
depends_on:0
0:exp:0:hex:"7061737300776f7264":hex:"7361006c74":int:4096:int:16:hex:"56fa6aa75548099dcc37d7f03425e0c3"
PBKDF2 Python hashlib Test Vector #1 (SHA224)
depends_on:1
0:exp:1:hex:"70617373776f7264":hex:"73616c74":int:1:int:20:hex:"3c198cbdb9464b7857966bd05b7bc92bc1cc4e6e"
PBKDF2 Python hashlib Test Vector #2 (SHA224)
depends_on:1
0:exp:1:hex:"70617373776f7264":hex:"73616c74":int:2:int:20:hex:"93200ffa96c5776d38fa10abdf8f5bfc0054b971"
PBKDF2 Python hashlib Test Vector #3 (SHA224)
depends_on:1
0:exp:1:hex:"70617373776f7264":hex:"73616c74":int:4096:int:20:hex:"218c453bf90635bd0a21a75d172703ff6108ef60"
PBKDF2 Python hashlib Test Vector #5 (SHA224)
depends_on:1
0:exp:1:hex:"70617373776f726450415353574f524470617373776f7264":hex:"73616c7453414c5473616c7453414c5473616c7453414c5473616c7453414c5473616c74":int:4096:int:25:hex:"056c4ba438ded91fc14e0594e6f52b87e1f3690c0dc0fbc057"
PBKDF2 Python hashlib Test Vector #6 (SHA224)
depends_on:1
0:exp:1:hex:"7061737300776f7264":hex:"7361006c74":int:4096:int:16:hex:"9b4011b641f40a2a500a31d4a392d15c"
PBKDF2 RFC 7914 Sec 11 Test Vector #1 (SHA256)
depends_on:1
0:exp:2:hex:"706173737764":hex:"73616c74":int:1:int:64:hex:"55ac046e56e3089fec1691c22544b605f94185216dde0465e68b9d57c20dacbc49ca9cccf179b645991664b39d77ef317c71b845b1e30bd509112041d3a19783"
PBKDF2 RFC 7914 Sec 11 Test Vector #2 (SHA256)
depends_on:1
0:exp:2:hex:"50617373776f7264":hex:"4e61436c":int:80000:int:64:hex:"4ddcd8f60b98be21830cee5ef22701f9641a4418d04c0414aeff08876b34ab56a1d425a1225833549adb841b51c9b3176a272bdebba1d078478f62b397f33c8d"
PBKDF2 Python hashlib Test Vector #1 (SHA256)
depends_on:1
0:exp:2:hex:"70617373776f7264":hex:"73616c74":int:1:int:20:hex:"120fb6cffcf8b32c43e7225256c4f837a86548c9"
PBKDF2 Python hashlib Test Vector #2 (SHA256)
depends_on:1
0:exp:2:hex:"70617373776f7264":hex:"73616c74":int:2:int:20:hex:"ae4d0c95af6b46d32d0adff928f06dd02a303f8e"
PBKDF2 Python hashlib Test Vector #3 (SHA256)
depends_on:1
0:exp:2:hex:"70617373776f7264":hex:"73616c74":int:4096:int:20:hex:"c5e478d59288c841aa530db6845c4c8d962893a0"
PBKDF2 Python hashlib Test Vector #5 (SHA256)
depends_on:1
0:exp:2:hex:"70617373776f726450415353574f524470617373776f7264":hex:"73616c7453414c5473616c7453414c5473616c7453414c5473616c7453414c5473616c74":int:4096:int:25:hex:"348c89dbcbd32b2f32d814b8116e84cf2b17347ebc1800181c"
PBKDF2 Python hashlib Test Vector #6 (SHA256)
depends_on:1
0:exp:2:hex:"7061737300776f7264":hex:"7361006c74":int:4096:int:16:hex:"89b69d0516f829893c696226650a8687"
PBKDF2 Python hashlib Test Vector #1 (SHA384)
depends_on:2:3
0:exp:3:hex:"70617373776f7264":hex:"73616c74":int:1:int:20:hex:"c0e14f06e49e32d73f9f52ddf1d0c5c719160923"
PBKDF2 Python hashlib Test Vector #2 (SHA384)
depends_on:2:3
0:exp:3:hex:"70617373776f7264":hex:"73616c74":int:2:int:20:hex:"54f775c6d790f21930459162fc535dbf04a93918"
PBKDF2 Python hashlib Test Vector #3 (SHA384)
depends_on:2:3
0:exp:3:hex:"70617373776f7264":hex:"73616c74":int:4096:int:20:hex:"559726be38db125bc85ed7895f6e3cf574c7a01c"
PBKDF2 Python hashlib Test Vector #5 (SHA384)
depends_on:2:3
0:exp:3:hex:"70617373776f726450415353574f524470617373776f7264":hex:"73616c7453414c5473616c7453414c5473616c7453414c5473616c7453414c5473616c74":int:4096:int:25:hex:"819143ad66df9a552559b9e131c52ae6c5c1b0eed18f4d283b"
PBKDF2 Python hashlib Test Vector #6 (SHA384)
depends_on:2:3
0:exp:3:hex:"7061737300776f7264":hex:"7361006c74":int:4096:int:16:hex:"a3f00ac8657e095f8e0823d232fc60b3"
PBKDF2 Python hashlib Test Vector #1 (SHA512)
depends_on:2
0:exp:4:hex:"70617373776f7264":hex:"73616c74":int:1:int:20:hex:"867f70cf1ade02cff3752599a3a53dc4af34c7a6"
PBKDF2 Python hashlib Test Vector #2 (SHA512)
depends_on:2
0:exp:4:hex:"70617373776f7264":hex:"73616c74":int:2:int:20:hex:"e1d9c16aa681708a45f5c7c4e215ceb66e011a2e"
PBKDF2 Python hashlib Test Vector #3 (SHA512)
depends_on:2
0:exp:4:hex:"70617373776f7264":hex:"73616c74":int:4096:int:20:hex:"d197b1b33db0143e018b12f3d1d1479e6cdebdcc"
PBKDF2 Python hashlib Test Vector #5 (SHA512)
depends_on:2
0:exp:4:hex:"70617373776f726450415353574f524470617373776f7264":hex:"73616c7453414c5473616c7453414c5473616c7453414c5473616c7453414c5473616c74":int:4096:int:25:hex:"8c0511f4c6e597c6ac6315d8f0362e225f3c501495ba23b868"
PBKDF2 Python hashlib Test Vector #6 (SHA512)
depends_on:2
0:exp:4:hex:"7061737300776f7264":hex:"7361006c74":int:4096:int:16:hex:"9d9e9c4cd21fe4be24d5b8244c759665"
PBES2 Decrypt (OK)
depends_on:0:4:5
1:exp:5:hex:"301B06092A864886F70D01050C300E04082ED7F24A1D516DD702020800301406082A864886F70D030704088A4FCC9DCC394910":hex:"70617373776f7264":hex:"1B60098D4834CA752D37B430E70B7A085CFF86E21F4849F969DD1DF623342662443F8BD1252BF83CEF6917551B08EF55A69C8F2BFFC93BCB2DFE2E354DA28F896D1BD1BFB972A1251219A6EC7183B0A4CF2C4998449ED786CAE2138437289EB2203974000C38619DA57A4E685D29649284602BD1806131772DA11A682674DC22B2CF109128DDB7FD980E1C5741FC0DB7":int:0:hex:"308187020100301306072A8648CE3D020106082A8648CE3D030107046D306B0201010420F12A1320760270A83CBFFD53F6031EF76A5D86C8A204F2C30CA9EBF51F0F0EA7A1440342000437CC56D976091E5A723EC7592DFF206EEE7CF9069174D0AD14B5F768225962924EE500D82311FFEA2FD2345D5D16BD8A88C26B770D55CD8A2A0EFA01C8B4EDFF060606060606"
PBES2 Decrypt (bad params tag)
depends_on:0:4
1:exp:6:hex:"":hex:"":hex:"":exp:7:hex:""
PBES2 Decrypt (bad KDF AlgId: not a sequence)
depends_on:0:4
1:exp:5:hex:"31":hex:"":hex:"":exp:7:hex:""
PBES2 Decrypt (bad KDF AlgId: overlong)
depends_on:0:4
1:exp:5:hex:"3001":hex:"":hex:"":exp:8:hex:""
PBES2 Decrypt (KDF != PBKDF2)
depends_on:0:4
1:exp:5:hex:"300B06092A864886F70D01050D":hex:"":hex:"":exp:9:hex:""
PBES2 Decrypt (bad PBKDF2 params: not a sequence)
depends_on:0:4
1:exp:5:hex:"300D06092A864886F70D01050C3100":hex:"":hex:"":exp:7:hex:""
PBES2 Decrypt (bad PBKDF2 params: overlong)
depends_on:0:4
1:exp:5:hex:"300D06092A864886F70D01050C3001":hex:"":hex:"":exp:8:hex:""
PBES2 Decrypt (bad PBKDF2 params salt: not an octet string)
depends_on:0:4:5
1:exp:5:hex:"300E06092A864886F70D01050C30010500":hex:"":hex:"":exp:7:hex:""
PBES2 Decrypt (bad PBKDF2 params salt: overlong)
depends_on:0:4
1:exp:5:hex:"300E06092A864886F70D01050C30010401":hex:"":hex:"":exp:8:hex:""
PBES2 Decrypt (bad PBKDF2 params iter: not an int)
depends_on:0:4
1:exp:5:hex:"301906092A864886F70D01050C300C04082ED7F24A1D516DD70300":hex:"":hex:"":exp:7:hex:""
PBES2 Decrypt (bad PBKDF2 params iter: overlong)
depends_on:0:4
1:exp:5:hex:"301906092A864886F70D01050C300C04082ED7F24A1D516DD70201":hex:"":hex:"":exp:8:hex:""
PBES2 Decrypt (OK, PBKDF2 params explicit keylen)
depends_on:0:4:5
1:exp:5:hex:"301E06092A864886F70D01050C301104082ED7F24A1D516DD702020800020118301406082A864886F70D030704088A4FCC9DCC394910":hex:"70617373776f7264":hex:"1B60098D4834CA752D37B430E70B7A085CFF86E21F4849F969DD1DF623342662443F8BD1252BF83CEF6917551B08EF55A69C8F2BFFC93BCB2DFE2E354DA28F896D1BD1BFB972A1251219A6EC7183B0A4CF2C4998449ED786CAE2138437289EB2203974000C38619DA57A4E685D29649284602BD1806131772DA11A682674DC22B2CF109128DDB7FD980E1C5741FC0DB7":int:0:hex:"308187020100301306072A8648CE3D020106082A8648CE3D030107046D306B0201010420F12A1320760270A83CBFFD53F6031EF76A5D86C8A204F2C30CA9EBF51F0F0EA7A1440342000437CC56D976091E5A723EC7592DFF206EEE7CF9069174D0AD14B5F768225962924EE500D82311FFEA2FD2345D5D16BD8A88C26B770D55CD8A2A0EFA01C8B4EDFF060606060606"
PBES2 Decrypt (bad PBKDF2 params explicit keylen: overlong)
depends_on:0:4
1:exp:5:hex:"301D06092A864886F70D01050C301004082ED7F24A1D516DD7020208000201":hex:"":hex:"":exp:8:hex:""
PBES2 Decrypt (OK, PBKDF2 params explicit prf_alg)
depends_on:0:4:5
1:exp:5:hex:"302706092A864886F70D01050C301A04082ED7F24A1D516DD702020800300A06082A864886F70D0207301406082A864886F70D030704088A4FCC9DCC394910":hex:"70617373776f7264":hex:"1B60098D4834CA752D37B430E70B7A085CFF86E21F4849F969DD1DF623342662443F8BD1252BF83CEF6917551B08EF55A69C8F2BFFC93BCB2DFE2E354DA28F896D1BD1BFB972A1251219A6EC7183B0A4CF2C4998449ED786CAE2138437289EB2203974000C38619DA57A4E685D29649284602BD1806131772DA11A682674DC22B2CF109128DDB7FD980E1C5741FC0DB7":int:0:hex:"308187020100301306072A8648CE3D020106082A8648CE3D030107046D306B0201010420F12A1320760270A83CBFFD53F6031EF76A5D86C8A204F2C30CA9EBF51F0F0EA7A1440342000437CC56D976091E5A723EC7592DFF206EEE7CF9069174D0AD14B5F768225962924EE500D82311FFEA2FD2345D5D16BD8A88C26B770D55CD8A2A0EFA01C8B4EDFF060606060606"
PBES2 Decrypt (bad, PBKDF2 params explicit prf_alg not a sequence)
depends_on:0:4
1:exp:5:hex:"301D06092A864886F70D01050C301004082ED7F24A1D516DD7020208003100":hex:"":hex:"":exp:7:hex:""
PBES2 Decrypt (bad, PBKDF2 params explicit prf_alg overlong)
depends_on:0:4
1:exp:5:hex:"301D06092A864886F70D01050C301004082ED7F24A1D516DD7020208003001":hex:"":hex:"":exp:8:hex:""
PBES2 Decrypt (bad, PBKDF2 params explicit prf_alg != HMAC-SHA*)
depends_on:0:4
1:exp:5:hex:"302706092A864886F70D01050C301A04082ED7F24A1D516DD702020800300A06082A864886F70D0206":hex:"":hex:"":exp:9:hex:""
PBES2 Decrypt (bad, PBKDF2 params extra data)
depends_on:0:4
1:exp:5:hex:"302806092A864886F70D01050C301B04082ED7F24A1D516DD702020800300A06082A864886F70D020700":hex:"":hex:"":exp:10:hex:""
PBES2 Decrypt (bad enc_scheme_alg: not a sequence)
depends_on:0:4
1:exp:5:hex:"301B06092A864886F70D01050C300E04082ED7F24A1D516DD7020208003100":hex:"":hex:"":exp:7:hex:""
PBES2 Decrypt (bad enc_scheme_alg: overlong)
depends_on:0:4
1:exp:5:hex:"301B06092A864886F70D01050C300E04082ED7F24A1D516DD7020208003001":hex:"":hex:"":exp:8:hex:""
PBES2 Decrypt (bad enc_scheme_alg: unknown oid)
depends_on:0:4
1:exp:5:hex:"301B06092A864886F70D01050C300E04082ED7F24A1D516DD702020800300A06082A864886F70D03FF":hex:"":hex:"":exp:9:hex:""
PBES2 Decrypt (bad enc_scheme_alg params: not an octet string)
depends_on:0:4:5
1:exp:5:hex:"301B06092A864886F70D01050C300E04082ED7F24A1D516DD702020800300C06082A864886F70D03070500":hex:"":hex:"":exp:11:hex:""
PBES2 Decrypt (bad enc_scheme_alg params: overlong)
depends_on:0:4
1:exp:5:hex:"301B06092A864886F70D01050C300E04082ED7F24A1D516DD702020800300C06082A864886F70D03070401":hex:"":hex:"":exp:8:hex:""
PBES2 Decrypt (bad enc_scheme_alg params: len != iv_len)
depends_on:0:4:5
1:exp:5:hex:"301B06092A864886F70D01050C300E04082ED7F24A1D516DD702020800301306082A864886F70D030704078A4FCC9DCC3949":hex:"":hex:"":exp:11:hex:""
PBES2 Decrypt (bad password)
depends_on:0:4:5
1:exp:5:hex:"301B06092A864886F70D01050C300E04082ED7F24A1D516DD702020800301406082A864886F70D030704088A4FCC9DCC394910":hex:"F0617373776f7264":hex:"1B60098D4834CA752D37B430E70B7A085CFF86E21F4849F969DD1DF623342662443F8BD1252BF83CEF6917551B08EF55A69C8F2BFFC93BCB2DFE2E354DA28F896D1BD1BFB972A1251219A6EC7183B0A4CF2C4998449ED786CAE2138437289EB2203974000C38619DA57A4E685D29649284602BD1806131772DA11A682674DC22B2CF109128DDB7FD980E1C5741FC0DB7":exp:12:hex:"308187020100301306072A8648CE3D020106082A8648CE3D030107046D306B0201010420F12A1320760270A83CBFFD53F6031EF76A5D86C8A204F2C30CA9EBF51F0F0EA7A1440342000437CC56D976091E5A723EC7592DFF206EEE7CF9069174D0AD14B5F768225962924EE500D82311FFEA2FD2345D5D16BD8A88C26B770D55CD8A2A0EFA01C8B4EDFF060606060606"
PBES2 Decrypt (bad iter value)
depends_on:0:4:5
1:exp:5:hex:"301B06092A864886F70D01050C300E04082ED7F24A1D516DD702020801301406082A864886F70D030704088A4FCC9DCC394910":hex:"70617373776f7264":hex:"1B60098D4834CA752D37B430E70B7A085CFF86E21F4849F969DD1DF623342662443F8BD1252BF83CEF6917551B08EF55A69C8F2BFFC93BCB2DFE2E354DA28F896D1BD1BFB972A1251219A6EC7183B0A4CF2C4998449ED786CAE2138437289EB2203974000C38619DA57A4E685D29649284602BD1806131772DA11A682674DC22B2CF109128DDB7FD980E1C5741FC0DB7":exp:12:hex:"308187020100301306072A8648CE3D020106082A8648CE3D030107046D306B0201010420F12A1320760270A83CBFFD53F6031EF76A5D86C8A204F2C30CA9EBF51F0F0EA7A1440342000437CC56D976091E5A723EC7592DFF206EEE7CF9069174D0AD14B5F768225962924EE500D82311FFEA2FD2345D5D16BD8A88C26B770D55CD8A2A0EFA01C8B4EDFF060606060606"
PKCS#5 Selftest
2
| 12,576 | 216 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/lib.c | /*
* Copyright The Mbed TLS Contributors
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "third_party/mbedtls/test/lib.h"
#include "libc/calls/calls.h"
#include "libc/dce.h"
#include "libc/fmt/conv.h"
#include "libc/fmt/fmt.h"
#include "libc/intrin/bits.h"
#include "libc/intrin/safemacros.internal.h"
#include "libc/log/backtrace.internal.h"
#include "libc/log/check.h"
#include "libc/log/libfatal.internal.h"
#include "libc/log/log.h"
#include "libc/mem/mem.h"
#include "libc/nexgen32e/vendor.internal.h"
#include "libc/nt/runtime.h"
#include "libc/runtime/internal.h"
#include "libc/runtime/runtime.h"
#include "libc/runtime/symbols.internal.h"
#include "libc/stdio/append.h"
#include "libc/stdio/rand.h"
#include "libc/stdio/stdio.h"
#include "libc/str/str.h"
#include "libc/sysv/consts/exit.h"
#include "libc/sysv/consts/nr.h"
#include "libc/time/time.h"
#include "libc/x/xasprintf.h"
#include "third_party/mbedtls/config.h"
#include "third_party/mbedtls/endian.h"
#include "third_party/mbedtls/error.h"
#include "third_party/mbedtls/platform.h"
asm(".ident\t\"\\n\\n\
Mbed TLS (Apache 2.0)\\n\
Copyright ARM Limited\\n\
Copyright Mbed TLS Contributors\"");
asm(".include \"libc/disclaimer.inc\"");
STATIC_YOINK("zip_uri_support");
#if defined(MBEDTLS_PLATFORM_C)
static mbedtls_platform_context platform_ctx;
#endif
#if defined(MBEDTLS_CHECK_PARAMS)
typedef struct {
uint8_t expected_call;
uint8_t expected_call_happened;
jmp_buf state;
mbedtls_test_param_failed_location_record_t location_record;
} param_failed_ctx_t;
static param_failed_ctx_t param_failed_ctx;
#endif
struct Buffer {
size_t i, n;
char *p;
};
char *output;
jmp_buf jmp_tmp;
int option_verbose = 1;
mbedtls_test_info_t mbedtls_test_info;
int mbedtls_test_platform_setup(void) {
char *p;
int ret = 0;
static char mybuf[2][BUFSIZ];
ShowCrashReports();
makedirs("o/tmp", 0755);
setvbuf(stdout, mybuf[0], _IOLBF, BUFSIZ);
setvbuf(stderr, mybuf[1], _IOLBF, BUFSIZ);
#if defined(MBEDTLS_PLATFORM_C)
ret = mbedtls_platform_setup(&platform_ctx);
#endif /* MBEDTLS_PLATFORM_C */
return ret;
}
void mbedtls_test_platform_teardown(void) {
#if defined(MBEDTLS_PLATFORM_C)
mbedtls_platform_teardown(&platform_ctx);
#endif /* MBEDTLS_PLATFORM_C */
}
wontreturn void exit(int rc) {
if (rc) xwrite(1, output, appendz(output).i);
free(output);
output = 0;
__cxa_finalize(0);
_Exit(rc);
}
char *GetTlsError(long r) {
char s[128];
if (-0x10000 < r && r < 0) {
mbedtls_strerror(r, s, sizeof(s));
return xasprintf("-0x%04lx %s", -r, s);
} else {
return xasprintf("%#lx", r);
}
}
int mbedtls_hardware_poll(void *wut, unsigned char *p, size_t n, size_t *olen) {
uint64_t x;
size_t i, j;
unsigned char b[8];
for (i = 0; i < n; ++i) {
x = lemur64();
WRITE64LE(b, x);
for (j = 0; j < 8 && i + j < n; ++j) {
p[i + j] = b[j];
}
}
*olen = n;
return 0;
}
int mbedtls_test_write(const char *fmt, ...) {
int i, n;
char *p;
va_list va;
va_start(va, fmt);
if (option_verbose) {
n = vfprintf(stderr, fmt, va);
} else {
n = vappendf(&output, fmt, va);
}
va_end(va);
return n;
}
static int ascii2uc(const char c, unsigned char *uc) {
if ((c >= '0') && (c <= '9')) {
*uc = c - '0';
} else if ((c >= 'a') && (c <= 'f')) {
*uc = c - 'a' + 10;
} else if ((c >= 'A') && (c <= 'F')) {
*uc = c - 'A' + 10;
} else {
return -1;
}
return 0;
}
int mbedtls_test_hexcmp(uint8_t *a, uint8_t *b, uint32_t a_len,
uint32_t b_len) {
int ret = 0;
uint32_t i = 0;
if (a_len != b_len) return -1;
for (i = 0; i < a_len; i++) {
if (a[i] != b[i]) {
ret = -1;
break;
}
}
return ret;
}
/**
* \brief Record the current test case as a failure.
*
* This function can be called directly however it is usually
* called via macros such as TEST_ASSERT, TEST_EQUAL,
* PSA_ASSERT, etc...
*
* \note If the test case was already marked as failed, calling
* `mbedtls_test_fail( )` again will not overwrite any
* previous information about the failure.
*
* \param test Description of the failure or assertion that failed. This
* MUST be a string literal.
* \param line_no Line number where the failure originated.
* \param filename Filename where the failure originated.
*/
void mbedtls_test_fail(const char *test, int line_no, const char *filename) {
if (mbedtls_test_info.result == MBEDTLS_TEST_RESULT_FAILED) {
/* We've already recorded the test as having failed. Don't
* overwrite any previous information about the failure. */
return;
}
mbedtls_test_info.result = MBEDTLS_TEST_RESULT_FAILED;
mbedtls_test_info.test = test;
mbedtls_test_info.line_no = line_no;
mbedtls_test_info.filename = filename;
}
#ifdef MBEDTLS_CHECK_PARAMS
void mbedtls_param_failed(const char *msg, const char *file, int line) {
/* Record the location of the failure */
param_failed_ctx.location_record.failure_condition = msg;
param_failed_ctx.location_record.file = file;
param_failed_ctx.location_record.line = line;
/* If we are testing the callback function... */
if (param_failed_ctx.expected_call != 0) {
param_failed_ctx.expected_call = 0;
param_failed_ctx.expected_call_happened = 1;
} else {
/* ...else try a long jump. If the execution state has not been set-up
* or reset then the long jump buffer is all zero's and the call will
* with high probability fault, emphasizing there is something to look
* at.
*/
longjmp(param_failed_ctx.state, 1);
}
}
#endif
/**
* \brief Record the current test case as skipped.
*
* This function can be called directly however it is usually
* called via the TEST_ASSUME macro.
*
* \param test Description of the assumption that caused the test case to
* be skipped. This MUST be a string literal.
* \param line_no Line number where the test case was skipped.
* \param filename Filename where the test case was skipped.
*/
void mbedtls_test_skip(const char *test, int line_no, const char *filename) {
mbedtls_test_info.result = MBEDTLS_TEST_RESULT_SKIPPED;
mbedtls_test_info.test = test;
mbedtls_test_info.line_no = line_no;
mbedtls_test_info.filename = filename;
}
/**
* \brief Set the test step number for failure reports.
*
* Call this function to display "step NNN" in addition to the
* line number and file name if a test fails. Typically the "step
* number" is the index of a for loop but it can be whatever you
* want.
*
* \param step The step number to report.
*/
void mbedtls_test_set_step(unsigned long step) {
mbedtls_test_info.step = step;
}
/**
* \brief Reset mbedtls_test_info to a ready/starting state.
*/
void mbedtls_test_info_reset(void) {
mbedtls_test_info.result = MBEDTLS_TEST_RESULT_SUCCESS;
mbedtls_test_info.step = -1;
mbedtls_test_info.test = 0;
mbedtls_test_info.line_no = 0;
mbedtls_test_info.filename = 0;
}
/**
* \brief This function decodes the hexadecimal representation of
* data.
*
* \note The output buffer can be the same as the input buffer. For
* any other overlapping of the input and output buffers, the
* behavior is undefined.
*
* \param obuf Output buffer.
* \param obufmax Size in number of bytes of \p obuf.
* \param ibuf Input buffer.
* \param len The number of unsigned char written in \p obuf. This must
* not be \c NULL.
*
* \return \c 0 on success.
* \return \c -1 if the output buffer is too small or the input string
* is not a valid hexadecimal representation.
*/
int mbedtls_test_unhexify(unsigned char *obuf, size_t obufmax, const char *ibuf,
size_t *len) {
unsigned char uc, uc2;
*len = strlen(ibuf);
/* Must be even number of bytes. */
if ((*len) & 1) return -1;
*len /= 2;
if ((*len) > obufmax) return -1;
while (*ibuf != 0) {
if (ascii2uc(*(ibuf++), &uc) != 0) return -1;
if (ascii2uc(*(ibuf++), &uc2) != 0) return -1;
*(obuf++) = (uc << 4) | uc2;
}
return 0;
}
void mbedtls_test_hexify(unsigned char *obuf, const unsigned char *ibuf,
int len) {
unsigned char l, h;
while (len != 0) {
h = *ibuf / 16;
l = *ibuf % 16;
if (h < 10) {
*obuf++ = '0' + h;
} else {
*obuf++ = 'a' + h - 10;
}
if (l < 10) {
*obuf++ = '0' + l;
} else {
*obuf++ = 'a' + l - 10;
}
++ibuf;
len--;
}
}
/**
* Allocate and zeroize a buffer.
*
* If the size if zero, a pointer to a zeroized 1-byte buffer is returned.
*
* For convenience, dies if allocation fails.
*/
unsigned char *mbedtls_test_zero_alloc(size_t len) {
void *p;
size_t actual_len = (len != 0) ? len : 1;
p = mbedtls_calloc(1, actual_len);
TEST_HELPER_ASSERT(p != NULL);
memset(p, 0x00, actual_len);
return (p);
}
/**
* Allocate and fill a buffer from hex data.
*
* The buffer is sized exactly as needed. This allows to detect buffer
* overruns (including overreads) when running the test suite under valgrind.
*
* If the size if zero, a pointer to a zeroized 1-byte buffer is returned.
*
* For convenience, dies if allocation fails.
*/
unsigned char *mbedtls_test_unhexify_alloc(const char *ibuf, size_t *olen) {
unsigned char *obuf;
size_t len;
*olen = strlen(ibuf) / 2;
if (*olen == 0) return (mbedtls_test_zero_alloc(*olen));
obuf = mbedtls_calloc(1, *olen);
TEST_HELPER_ASSERT(obuf != NULL);
TEST_HELPER_ASSERT(mbedtls_test_unhexify(obuf, *olen, ibuf, &len) == 0);
return (obuf);
}
#ifdef MBEDTLS_CHECK_PARAMS
/**
* \brief Get the location record of the last call to
* mbedtls_test_param_failed().
*
* \note The call expectation is set up and active until the next call to
* mbedtls_test_param_failed_check_expected_call() or
* mbedtls_param_failed() that cancels it.
*/
void mbedtls_test_param_failed_get_location_record(
mbedtls_test_param_failed_location_record_t *location_record) {
*location_record = param_failed_ctx.location_record;
}
#endif
#ifdef MBEDTLS_CHECK_PARAMS
/**
* \brief State that a call to mbedtls_param_failed() is expected.
*
* \note The call expectation is set up and active until the next call to
* mbedtls_test_param_failed_check_expected_call() or
* mbedtls_param_failed that cancel it.
*/
void mbedtls_test_param_failed_expect_call(void) {
param_failed_ctx.expected_call_happened = 0;
param_failed_ctx.expected_call = 1;
}
#endif
#ifdef MBEDTLS_CHECK_PARAMS
/**
* \brief Check whether mbedtls_param_failed() has been called as expected.
*
* \note Check whether mbedtls_param_failed() has been called between the
* last call to mbedtls_test_param_failed_expect_call() and the call
* to this function.
*
* \return \c 0 Since the last call to mbedtls_param_failed_expect_call(),
* mbedtls_param_failed() has been called.
* \c -1 Otherwise.
*/
int mbedtls_test_param_failed_check_expected_call(void) {
param_failed_ctx.expected_call = 0;
if (param_failed_ctx.expected_call_happened != 0) return 0;
return -1;
}
#endif
#ifdef MBEDTLS_CHECK_PARAMS
/**
* \brief Get the address of the object of type jmp_buf holding the execution
* state information used by mbedtls_param_failed() to do a long jump.
*
* \note If a call to mbedtls_param_failed() is not expected in the sense
* that there is no call to mbedtls_test_param_failed_expect_call()
* preceding it, then mbedtls_param_failed() will try to restore the
* execution to the state stored in the jmp_buf object whose address
* is returned by the present function.
*
* \note This function is intended to provide the parameter of the
* setjmp() function to set-up where mbedtls_param_failed() should
* long-jump if it has to. It is foreseen to be used as:
*
* setjmp( mbedtls_test_param_failed_get_state_buf() ).
*
* \note The type of the returned value is not jmp_buf as jmp_buf is an
* an array type (C specification) and a function cannot return an
* array type.
*
* \note The type of the returned value is not jmp_buf* as then the return
* value couldn't be used by setjmp(), as its parameter's type is
* jmp_buf.
*
* \return Address of the object of type jmp_buf holding the execution state
* information used by mbedtls_param_failed() to do a long jump.
*/
void *mbedtls_test_param_failed_get_state_buf(void) {
return ¶m_failed_ctx.state;
}
#endif
#ifdef MBEDTLS_CHECK_PARAMS
/**
* \brief Reset the execution state used by mbedtls_param_failed() to do a
* long jump.
*
* \note If a call to mbedtls_param_failed() is not expected in the sense
* that there is no call to mbedtls_test_param_failed_expect_call()
* preceding it, then mbedtls_param_failed() will try to restore the
* execution state that this function reset.
*
* \note It is recommended to reset the execution state when the state
* is not relevant anymore. That way an unexpected call to
* mbedtls_param_failed() will not trigger a long jump with
* undefined behavior but rather a long jump that will rather fault.
*/
void mbedtls_test_param_failed_reset_state(void) {
memset(param_failed_ctx.state, 0, sizeof(param_failed_ctx.state));
}
#endif
/**
* This function just returns data from rand().
* Although predictable and often similar on multiple
* runs, this does not result in identical random on
* each run. So do not use this if the results of a
* test depend on the random data that is generated.
*
* rng_state shall be NULL.
*/
int mbedtls_test_rnd_std_rand(void *rng_state, unsigned char *output,
size_t len) {
size_t i;
if (rng_state != NULL) rng_state = NULL;
for (i = 0; i < len; ++i) output[i] = rand();
return 0;
}
/**
* This function only returns zeros
*
* rng_state shall be NULL.
*/
int mbedtls_test_rnd_zero_rand(void *rng_state, unsigned char *output,
size_t len) {
if (rng_state != NULL) rng_state = NULL;
memset(output, 0, len);
return 0;
}
/**
* This function returns random based on a buffer it receives.
*
* rng_state shall be a pointer to a rnd_buf_info structure.
*
* The number of bytes released from the buffer on each call to
* the random function is specified by per_call. (Can be between
* 1 and 4)
*
* After the buffer is empty it will return rand();
*/
int mbedtls_test_rnd_buffer_rand(void *rng_state, unsigned char *output,
size_t len) {
mbedtls_test_rnd_buf_info *info = (mbedtls_test_rnd_buf_info *)rng_state;
size_t use_len;
if (rng_state == NULL) return (mbedtls_test_rnd_std_rand(NULL, output, len));
use_len = len;
if (len > info->length) use_len = info->length;
if (use_len) {
memcpy(output, info->buf, use_len);
info->buf += use_len;
info->length -= use_len;
}
if (len - use_len > 0)
return (mbedtls_test_rnd_std_rand(NULL, output + use_len, len - use_len));
return 0;
}
/**
* This function returns random based on a pseudo random function.
* This means the results should be identical on all systems.
* Pseudo random is based on the XTEA encryption algorithm to
* generate pseudorandom.
*
* rng_state shall be a pointer to a rnd_pseudo_info structure.
*/
int mbedtls_test_rnd_pseudo_rand(void *rng_state, unsigned char *output,
size_t len) {
mbedtls_test_rnd_pseudo_info *info =
(mbedtls_test_rnd_pseudo_info *)rng_state;
uint32_t i, *k, sum, delta = 0x9E3779B9;
unsigned char result[4], *out = output;
if (rng_state == NULL) return (mbedtls_test_rnd_std_rand(NULL, output, len));
k = info->key;
while (len > 0) {
size_t use_len = (len > 4) ? 4 : len;
sum = 0;
for (i = 0; i < 32; i++) {
info->v0 +=
(((info->v1 << 4) ^ (info->v1 >> 5)) + info->v1) ^ (sum + k[sum & 3]);
sum += delta;
info->v1 += (((info->v0 << 4) ^ (info->v0 >> 5)) + info->v0) ^
(sum + k[(sum >> 11) & 3]);
}
PUT_UINT32_BE(info->v0, result, 0);
memcpy(out, result, use_len);
len -= use_len;
out += 4;
}
return 0;
}
/**
* \brief Verifies that string is in string parameter format i.e. "<str>"
* It also strips enclosing '"' from the input string.
*
* \param str String parameter.
*
* \return 0 if success else 1
*/
int verify_string(char **str) {
if ((*str)[0] != '"' || (*str)[strlen(*str) - 1] != '"') {
WRITE("Expected string (with \"\") for parameter and got: %`'s\n", *str);
return -1;
}
(*str)++;
(*str)[strlen(*str) - 1] = '\0';
return 0;
}
/**
* \brief Verifies that string is an integer. Also gives the converted
* integer value.
*
* \param str Input string.
* \param value Pointer to int for output value.
*
* \return 0 if success else 1
*/
int verify_int(char *str, int *value) {
size_t i;
int minus = 0;
int digits = 1;
int hex = 0;
for (i = 0; i < strlen(str); i++) {
if (i == 0 && str[i] == '-') {
minus = 1;
continue;
}
if (((minus && i == 2) || (!minus && i == 1)) && str[i - 1] == '0' &&
(str[i] == 'x' || str[i] == 'X')) {
hex = 1;
continue;
}
if (!((str[i] >= '0' && str[i] <= '9') ||
(hex && ((str[i] >= 'a' && str[i] <= 'f') ||
(str[i] >= 'A' && str[i] <= 'F'))))) {
digits = 0;
break;
}
}
if (digits) {
if (hex)
*value = strtol(str, NULL, 16);
else
*value = strtol(str, NULL, 10);
return 0;
}
WRITE("Expected integer for parameter and got: %s\n", str);
return KEY_VALUE_MAPPING_NOT_FOUND;
}
/**
* \brief Read a line from the passed file pointer.
*
* \param f FILE pointer
* \param buf Pointer to memory to hold read line.
* \param len Length of the buf.
*
* \return 0 if success else -1
*/
int get_line(FILE *f, char *buf, size_t len) {
char *ret;
int i = 0, str_len = 0, has_string = 0;
/* Read until we get a valid line */
do {
ret = fgets(buf, len, f);
if (ret == NULL) return -1;
str_len = strlen(buf);
/* Skip empty line and comment */
if (str_len == 0 || buf[0] == '#') continue;
has_string = 0;
for (i = 0; i < str_len; i++) {
char c = buf[i];
if (c != ' ' && c != '\t' && c != '\n' && c != '\v' && c != '\f' &&
c != '\r') {
has_string = 1;
break;
}
}
} while (!has_string);
/* Strip new line and carriage return */
ret = buf + strlen(buf);
if (ret-- > buf && *ret == '\n') *ret = '\0';
if (ret-- > buf && *ret == '\r') *ret = '\0';
return 0;
}
/**
* \brief Splits string delimited by ':'. Ignores '\:'.
*
* \param buf Input string
* \param len Input string length
* \param params Out params found
* \param params_len Out params array len
*
* \return Count of strings found.
*/
static int parse_arguments(char *buf, size_t len, char **params,
size_t params_len) {
int t = 0;
size_t cnt = 0, i;
char *cur = buf;
char *p = buf, *q;
params[cnt++] = cur;
while (*p != '\0' && p < (buf + len)) {
if (*p == '"') {
if (t) {
t = 0;
} else {
t = 1;
}
}
if (*p == '\\') {
p++;
p++;
continue;
}
if (*p == ':' && !t) {
if (p + 1 < buf + len) {
cur = p + 1;
TEST_HELPER_ASSERT(cnt < params_len);
params[cnt++] = cur;
}
*p = '\0';
}
p++;
}
/* Replace newlines, question marks and colons in strings */
for (i = 0; i < cnt; i++) {
p = params[i];
q = params[i];
while (*p != '\0') {
if (*p == '\\' && *(p + 1) == 'n') {
p += 2;
*(q++) = '\n';
} else if (*p == '\\' && *(p + 1) == ':') {
p += 2;
*(q++) = ':';
} else if (*p == '\\' && *(p + 1) == '?') {
p += 2;
*(q++) = '?';
} else
*(q++) = *(p++);
}
*q = '\0';
}
return (cnt);
}
/**
* \brief Converts parameters into test function consumable parameters.
* Example: Input: {"int", "0", "char*", "Hello",
* "hex", "abef", "exp", "1"}
* Output: {
* 0, // Verified int
* "Hello", // Verified string
* 2, { 0xab, 0xef },// Converted len,hex pair
* 9600 // Evaluated expression
* }
*
*
* \param cnt Parameter array count.
* \param params Out array of found parameters.
* \param int_params_store Memory for storing processed integer parameters.
*
* \return 0 for success else 1
*/
static int convert_params(size_t cnt, char **params, int *int_params_store) {
char **cur = params;
char **out = params;
int ret = DISPATCH_TEST_SUCCESS;
while (cur < params + cnt) {
char *type = *cur++;
char *val = *cur++;
if (strcmp(type, "char*") == 0) {
if (verify_string(&val) == 0) {
*out++ = val;
} else {
ret = (DISPATCH_INVALID_TEST_DATA);
break;
}
} else if (strcmp(type, "int") == 0) {
if (verify_int(val, int_params_store) == 0) {
*out++ = (char *)int_params_store++;
} else {
ret = (DISPATCH_INVALID_TEST_DATA);
break;
}
} else if (strcmp(type, "hex") == 0) {
if (verify_string(&val) == 0) {
size_t len;
TEST_HELPER_ASSERT(mbedtls_test_unhexify((unsigned char *)val,
strlen(val), val, &len) == 0);
*int_params_store = len;
*out++ = val;
*out++ = (char *)(int_params_store++);
} else {
ret = (DISPATCH_INVALID_TEST_DATA);
break;
}
} else if (strcmp(type, "exp") == 0) {
int exp_id = strtol(val, NULL, 10);
if (get_expression(exp_id, int_params_store) == 0) {
*out++ = (char *)int_params_store++;
} else {
ret = (DISPATCH_INVALID_TEST_DATA);
break;
}
} else {
ret = (DISPATCH_INVALID_TEST_DATA);
break;
}
}
return (ret);
}
/**
* \brief Tests snprintf implementation with test input.
*
* \note
* At high optimization levels (e.g. gcc -O3), this function may be
* inlined in run_test_snprintf. This can trigger a spurious warning about
* potential misuse of snprintf from gcc -Wformat-truncation (observed with
* gcc 7.2). This warning makes tests in run_test_snprintf redundant on gcc
* only. They are still valid for other compilers. Avoid this warning by
* forbidding inlining of this function by gcc.
*
* \param n Buffer test length.
* \param ref_buf Expected buffer.
* \param ref_ret Expected snprintf return value.
*
* \return 0 for success else 1
*/
static dontinline int test_snprintf(size_t n, const char *ref_buf,
int ref_ret) {
int ret;
char buf[10] = "xxxxxxxxx";
const char ref[10] = "xxxxxxxxx";
if (n >= sizeof(buf)) return -1;
ret = mbedtls_snprintf(buf, n, "%s", "123");
if (ret < 0 || (size_t)ret >= n) ret = -1;
if (strncmp(ref_buf, buf, sizeof(buf)) != 0 || ref_ret != ret ||
memcmp(buf + n, ref + n, sizeof(buf) - n) != 0) {
return 1;
}
return 0;
}
/**
* \brief Tests snprintf implementation.
*
* \return 0 for success else 1
*/
static int run_test_snprintf(void) {
return (test_snprintf(0, "xxxxxxxxx", -1) != 0 ||
test_snprintf(1, "", -1) != 0 || test_snprintf(2, "1", -1) != 0 ||
test_snprintf(3, "12", -1) != 0 || test_snprintf(4, "123", 3) != 0 ||
test_snprintf(5, "123", 3) != 0);
}
/**
* \brief Write the description of the test case to the outcome CSV file.
*
* \param outcome_file The file to write to.
* If this is \c NULL, this function does nothing.
* \param argv0 The test suite name.
* \param test_case The test case description.
*/
static void write_outcome_entry(FILE *outcome_file, const char *argv0,
const char *test_case) {
/* The non-varying fields are initialized on first use. */
static const char *platform = NULL;
static const char *configuration = NULL;
static const char *test_suite = NULL;
if (outcome_file == NULL) return;
if (platform == NULL) {
platform = getenv("MBEDTLS_TEST_PLATFORM");
if (platform == NULL) platform = "unknown";
}
if (configuration == NULL) {
configuration = getenv("MBEDTLS_TEST_CONFIGURATION");
if (configuration == NULL) configuration = "unknown";
}
if (test_suite == NULL) {
test_suite = strrchr(argv0, '/');
if (test_suite != NULL)
test_suite += 1; // skip the '/'
else
test_suite = argv0;
}
/* Write the beginning of the outcome line.
* Ignore errors: writing the outcome file is on a best-effort basis. */
WRITE("%s;%s;%s;%s;", platform, configuration, test_suite, test_case);
}
/**
* \brief Write the result of the test case to the outcome CSV file.
*
* \param outcome_file The file to write to.
* If this is \c NULL, this function does nothing.
* \param unmet_dep_count The number of unmet dependencies.
* \param unmet_dependencies The array of unmet dependencies.
* \param missing_unmet_dependencies Non-zero if there was a problem tracking
* all unmet dependencies, 0 otherwise.
* \param ret The test dispatch status (DISPATCH_xxx).
* \param info A pointer to the test info structure.
*/
static void write_outcome_result(FILE *outcome_file, size_t unmet_dep_count,
int unmet_dependencies[],
int missing_unmet_dependencies, int ret,
const mbedtls_test_info_t *info) {
if (outcome_file == NULL) return;
/* Write the end of the outcome line.
* Ignore errors: writing the outcome file is on a best-effort basis. */
switch (ret) {
case DISPATCH_TEST_SUCCESS:
if (unmet_dep_count > 0) {
size_t i;
WRITE("SKIP");
for (i = 0; i < unmet_dep_count; i++) {
WRITE("%c%d", i == 0 ? ';' : ':', unmet_dependencies[i]);
}
if (missing_unmet_dependencies) WRITE(":...");
break;
}
switch (info->result) {
case MBEDTLS_TEST_RESULT_SUCCESS:
WRITE("PASS;");
break;
case MBEDTLS_TEST_RESULT_SKIPPED:
WRITE("SKIP;Runtime skip");
break;
default:
WRITE("FAIL;%s:%d:%s", info->filename, info->line_no, info->test);
break;
}
break;
case DISPATCH_TEST_FN_NOT_FOUND:
WRITE("FAIL;Test function not found");
break;
case DISPATCH_INVALID_TEST_DATA:
WRITE("FAIL;Invalid test data");
break;
case DISPATCH_UNSUPPORTED_SUITE:
WRITE("SKIP;Unsupported suite");
break;
default:
WRITE("FAIL;Unknown cause");
break;
}
WRITE("\n");
fflush(outcome_file);
}
/**
* \brief Desktop implementation of execute_tests().
* Parses command line and executes tests from
* supplied or default data file.
*
* \param argc Command line argument count.
* \param argv Argument array.
*
* \return Program exit status.
*/
int execute_tests(int argc, const char **argv, const char *default_filename) {
/* Local Configurations and options */
long double t1, t2;
const char *test_filename = NULL;
const char **test_files = NULL;
size_t testfile_count = 0;
size_t function_id = 0;
/* Other Local variables */
int arg_index = 1;
const char *next_arg;
size_t testfile_index, i, cnt;
int ret;
unsigned total_errors = 0, total_tests = 0, total_skipped = 0;
FILE *file;
char buf[5000];
char *params[50];
/* Store for proccessed integer params. */
int int_params[50];
void *pointer;
const char *outcome_file_name = getenv("MBEDTLS_TEST_OUTCOME_FILE");
FILE *outcome_file = NULL;
/*
* The C standard doesn't guarantee that all-bits-0 is the representation
* of a NULL pointer. We do however use that in our code for initializing
* structures, which should work on every modern platform. Let's be sure.
*/
memset(&pointer, 0, sizeof(void *));
if (pointer != NULL) {
WRITE("all-bits-zero is not a NULL pointer\n");
return 1;
}
/*
* Make sure we have a snprintf that correctly zero-terminates
*/
if (run_test_snprintf() != 0) {
WRITE("the snprintf implementation is broken\n");
return 1;
}
if (outcome_file_name != NULL && *outcome_file_name != '\0') {
outcome_file = fopen(outcome_file_name, "a");
if (outcome_file == NULL) {
WRITE("Unable to open outcome file. Continuing anyway.\n");
}
}
while (arg_index < argc) {
next_arg = argv[arg_index];
if (strcmp(next_arg, "--verbose") == 0 || strcmp(next_arg, "-v") == 0) {
option_verbose = 1;
} else if (strcmp(next_arg, "--help") == 0 || strcmp(next_arg, "-h") == 0) {
WRITE(
"Usage: %s [OPTIONS] files...\n\n"
" Command line arguments:\n"
" files... One or more test data files. If no file is\n"
" specified the following default test case\n"
" file is used:\n"
" %s\n\n"
" Options:\n"
" -v | --verbose Display full information about each test\n"
" -h | --help Display this information\n\n",
argv[0], "TESTCASE_FILENAME");
exit(EXIT_SUCCESS);
} else {
/* Not an option, therefore treat all further arguments as the file
* list.
*/
test_files = &argv[arg_index];
testfile_count = argc - arg_index;
}
arg_index++;
}
/* If no files were specified, assume a default */
if (test_files == NULL || testfile_count == 0) {
test_files = &default_filename;
testfile_count = 1;
}
/* Initialize the struct that holds information about the last test */
mbedtls_test_info_reset();
/* Now begin to execute the tests in the testfiles */
for (testfile_index = 0; testfile_index < testfile_count; testfile_index++) {
size_t unmet_dep_count = 0;
int unmet_dependencies[20];
int missing_unmet_dependencies = 0;
test_filename = test_files[testfile_index];
file = fopen(test_filename, "r");
if (file == NULL) {
WRITE("%s (%s) failed to open test file: %s %m\n",
firstnonnull(program_invocation_short_name, "unknown"),
GetProgramExecutableName(), test_filename);
if (outcome_file != NULL) fclose(outcome_file);
return 1;
}
while (!feof(file)) {
if (unmet_dep_count > 0) {
WRITE("FATAL: Dep count larger than zero at start of loop\n");
exit(EXIT_FAILURE);
}
unmet_dep_count = 0;
missing_unmet_dependencies = 0;
if ((ret = get_line(file, buf, sizeof(buf))) != 0) break;
WRITE("%s%.66s",
mbedtls_test_info.result == MBEDTLS_TEST_RESULT_FAILED ? "\n" : "",
buf);
WRITE(" ");
for (i = strlen(buf) + 1; i < 67; i++) WRITE(".");
WRITE(" ");
fflush(stdout);
write_outcome_entry(outcome_file, argv[0], buf);
total_tests++;
if ((ret = get_line(file, buf, sizeof(buf))) != 0) break;
cnt = parse_arguments(buf, strlen(buf), params,
sizeof(params) / sizeof(params[0]));
if (strcmp(params[0], "depends_on") == 0) {
for (i = 1; i < cnt; i++) {
int dep_id = strtol(params[i], NULL, 10);
if (dep_check(dep_id) != DEPENDENCY_SUPPORTED) {
if (unmet_dep_count < ARRAY_LENGTH(unmet_dependencies)) {
unmet_dependencies[unmet_dep_count] = dep_id;
unmet_dep_count++;
} else {
missing_unmet_dependencies = 1;
}
}
}
if ((ret = get_line(file, buf, sizeof(buf))) != 0) break;
cnt = parse_arguments(buf, strlen(buf), params,
sizeof(params) / sizeof(params[0]));
}
// If there are no unmet dependencies execute the test
t1 = nowl();
if (unmet_dep_count == 0) {
mbedtls_test_info_reset();
function_id = strtoul(params[0], NULL, 10);
if ((ret = check_test(function_id)) == DISPATCH_TEST_SUCCESS) {
ret = convert_params(cnt - 1, params + 1, int_params);
if (DISPATCH_TEST_SUCCESS == ret) {
ret = dispatch_test(function_id, (void **)(params + 1));
}
}
}
t2 = nowl();
write_outcome_result(outcome_file, unmet_dep_count, unmet_dependencies,
missing_unmet_dependencies, ret, &mbedtls_test_info);
if (unmet_dep_count > 0 || ret == DISPATCH_UNSUPPORTED_SUITE) {
total_skipped++;
WRITE("----");
if (1 == option_verbose && unmet_dep_count > 0) {
WRITE(" (unmet dependencies: ");
for (i = 0; i < unmet_dep_count; i++) {
if (i) WRITE(",");
WRITE("%d", unmet_dependencies[i]);
}
if (missing_unmet_dependencies) WRITE("...");
}
WRITE(")\n");
fflush(stdout);
unmet_dep_count = 0;
missing_unmet_dependencies = 0;
} else if (ret == DISPATCH_TEST_SUCCESS) {
if (mbedtls_test_info.result == MBEDTLS_TEST_RESULT_SUCCESS) {
WRITE("PASS (%,ldus)\n", (int64_t)((t2 - t1) * 1e6));
} else if (mbedtls_test_info.result == MBEDTLS_TEST_RESULT_SKIPPED) {
WRITE("----");
total_skipped++;
} else {
total_errors++;
WRITE("FAILED\n");
WRITE(" %s\n at ", mbedtls_test_info.test);
if (mbedtls_test_info.step != -1) {
WRITE("step %lu, ", mbedtls_test_info.step);
}
WRITE("line %d, %s", mbedtls_test_info.line_no,
mbedtls_test_info.filename);
}
fflush(stdout);
} else if (ret == DISPATCH_INVALID_TEST_DATA) {
WRITE("FAILED: FATAL PARSE ERROR\n");
fclose(file);
exit(2);
} else if (ret == DISPATCH_TEST_FN_NOT_FOUND) {
WRITE("FAILED: FATAL TEST FUNCTION NOT FOUND\n");
fclose(file);
exit(2);
} else
total_errors++;
}
fclose(file);
}
if (outcome_file != NULL) fclose(outcome_file);
WRITE("\n--------------------------------------------------"
"--------------------------\n\n");
if (total_errors == 0)
WRITE("PASSED");
else
WRITE("FAILED");
WRITE(" (%u / %u tests (%u skipped))\n", total_tests - total_errors,
total_tests, total_skipped);
#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C) && \
!defined(TEST_SUITE_MEMORY_BUFFER_ALLOC)
#if defined(MBEDTLS_MEMORY_DEBUG)
mbedtls_memory_buffer_alloc_status();
#endif
mbedtls_memory_buffer_alloc_free();
#endif
return total_errors != 0;
}
| 36,312 | 1,127 | jart/cosmopolitan | false |
cosmopolitan/third_party/mbedtls/test/test_suite_nist_kw.datax | NIST KW self test
0
NIST KW mix contexts and modes
1
NIST KW init #1 wrapping AES-128: OK
depends_on:0
2:exp:0:int:128:int:1:int:0
NIST KW init #2 unwrapping AES-128: OK
depends_on:0
2:exp:0:int:128:int:1:int:0
NIST KW init #3 CAMELLIA-256: unsupported cipher
depends_on:1
2:exp:1:int:256:int:0:exp:2
NIST KW init #4 AES-224: bad key size
depends_on:0
2:exp:0:int:224:int:1:exp:3
NIST KW init #5 BLOWFISH-128: bad cipher
depends_on:2
2:exp:4:int:128:int:0:exp:3
NIST KW lengths #1 KW plaintext OK (2 to 2^54 - 1 semiblocks)
3:int:16:int:24:exp:5:int:0
NIST KW lengths #2 KWP plaintext OK (1 to 2^32 - 1 octets)
3:int:5:int:16:exp:6:int:0
NIST KW lengths #3 KW ciphertext OK (3 to 2^54 semiblocks)
4:int:32:int:24:exp:5:int:0
NIST KW lengths #4 KWP ciphertext OK (2 to 2^29 semiblocks)
4:int:24:int:16:exp:6:int:0
NIST KW lengths #5 KW plaintext too short (2 to 2^54 - 1 semiblocks)
3:int:5:int:13:exp:5:exp:3
NIST KW lengths #6 KWP plaintext too short (1 to 2^32 - 1 octets)
3:int:0:int:8:exp:6:exp:3
NIST KW lengths #8 KW ciphertext too short (3 to 2^54 semiblocks)
4:int:16:int:8:exp:5:exp:3
NIST KW lengths #9 KWP ciphertext too short (2 to 2^29 semiblocks)
4:int:8:int:8:exp:6:exp:3
NIST KW lengths #10 KW plaintext not a multiple of semiblocks.
3:int:21:int:29:exp:5:exp:3
NIST KW lengths #11 KW ciphertext not a multiple of semiblocks.
4:int:34:int:26:exp:5:exp:3
NIST KW lengths #12 KWP ciphertext not a multiple of semiblocks.
4:int:30:int:22:exp:6:exp:3
NIST KW lengths #13 KW wrapping output buffer too short
3:int:16:int:16:exp:5:exp:3
NIST KW lengths #14 KWP wrapping output buffer too short
3:int:5:int:10:exp:6:exp:3
NIST KW lengths #15 KW unwrapping output buffer too short
4:int:32:int:16:exp:5:exp:3
NIST KW lengths #16 KWP unwrapping output buffer too short
4:int:24:int:12:exp:6:exp:3
NIST KW lengths #17 KW plaintext NULL (2 to 2^54 - 1 semiblocks)
3:int:0:int:8:exp:5:exp:3
NIST KW lengths #18 KW wrapping output NULL
3:int:8:int:0:exp:5:exp:3
NIST KW lengths #19 KWP wrapping output NULL
3:int:8:int:0:exp:6:exp:3
NIST KW lengths #20 KW ciphertext NULL
4:int:0:int:8:exp:5:exp:3
NIST KW lengths #21 KWP ciphertext NULL
4:int:0:int:8:exp:6:exp:3
NIST KW lengths #15 KW unwrapping output NULL
4:int:32:int:0:exp:5:exp:3
NIST KW lengths #16 KWP unwrapping output NULL
4:int:24:int:0:exp:6:exp:3
NIST KW wrap AES-128 CAVS 17.4 PLAINTEXT LENGTH = 128 count 7
depends_on:0
5:exp:0:exp:5:hex:"095e293f31e317ba6861114b95c90792":hex:"64349d506ae85ecd84459c7a5c423f55":hex:"97de4425572274bd7fb2d6688d5afd4454d992348d42a643"
NIST KW wrap AES-128 CAVS 17.4 PLAINTEXT LENGTH = 256 count 11
depends_on:0
5:exp:0:exp:5:hex:"ca8f6c56a9c9300549e9eae75a4604b8":hex:"1542b8662136245162c64d45af1a982302f69f1d01a1a6bc29ef8facafbeaea0":hex:"4d340c10bbbddf5b2014ded264bffce49901bd22adaee074b0f25a2d19c134eb3c7f38c5d0444766"
NIST KW wrap AES-128 CAVS 17.4 PLAINTEXT LENGTH = 192 count 8
depends_on:0
5:exp:0:exp:5:hex:"b4902b13ea73f17829b4e334fb359ec4":hex:"2073399c7794c8b73dd782dc250dab31c80a8cba33477ab2":hex:"37eda4eec3096135f5193c37bdeaf498b71e3a205c5638682fe746f236566b11"
NIST KW wrap AES-128 CAVS 17.4 PLAINTEXT LENGTH = 320 count 14
depends_on:0
5:exp:0:exp:5:hex:"579448a3d638f093742ae6b24d729849":hex:"464d3162469899955d8bc8bfc0a22555bce609b2415bedf17a942abfe96ad4e124d4a832fbcff49f":hex:"dadd1440a06946eabddf18e784b7719d36caa33cb626aa03aca057585584ea07a8714ecb90ceb232d6b0760845105fbb"
NIST KW wrap AES-128 CAVS 17.4 PLAINTEXT LENGTH = 4096 count 0
depends_on:0
5:exp:0:exp:5:hex:"98311985c4661d7e811ee56070e6fecf":hex:"18840c96813864ef3093b48cdde6ac5d78248b96d4a2cd1f15f0b56f98213dbf87e1ccad04e0d4f1954c233ea3e48fdad8f2b1156e54e19e3b5f4a66d2e9149032b876c51249165fe8c28e112a685b2d228a8ac308017574274af36a4ea3877bcc9850bafe8fc0e0a712faca0dea98396f9143bc5819fe4933a806e9b965133e3c695a45f0fbd6961798c400d7477287df64798b651e0d3009c13f7a2246c28f983509b9e5339919f2cdffcdfc550693cba9491c00334c4a62d878c4d0ca57b1104bc0174968ea8e3730b9e68db49678b23cd508ebe3e12e94b0ad3791023a8ef95473f0b32f906738f34e94e45a4480ad768072e1853adb63996b9ac27a1dade70804b82290a2274c6dcc3ccd40a8b38a56a5eb03f59075de015e8f9096f53549f6374e02da947fb849287a447f757cc340b6bded71d480988b6d2fcd984fba841470519830304667fef0a577b4cf84f76aef9deb84dde36abfbd76673c17113dbea7a3e24bf9b57a8fd17173a1ef91497b732b3fa8889bed58a503a0d3e20bc27ec4dbf5d13a93cbad05495e3df15e1fe34a3a6d6f648ea4aa60b2f114f30944ae593675dac2db188f90a3c483fb82cec0f0d295544d798b62cdcb51c6c036af1a341d78babf87b92609c1d866e311a46abccc8ba8c6a41420359bb061d7e752c0ed25990eef57c9f9e190572203f8c473edf8cfc8c26d34e37240f45ded97":hex:"625aea9122b7b57b9f36446f9053acc42c6435a7f69d91b41547026f833291d488e477c7ccba698c143633a304f463d6af4a3e72c189234fcfc360013e65b07b7f7a36c529d3fdbbdbd6224bf100c14bc5354893b44790f54c739a2b1f5bda82d70fb600ed9b0606dbddea52e508b492b72d8779856274aaaaddc0a3edb6cfc788b603101bedfcc3f44baa62336bd950c2e349d5daf04f2e23ec2628893d214e277569c565e5e6aa8b72ffa14118a3b57f814b4deb179980b5eeefa4fd93f1751850466e929be537801babc2120f3ff1ffe5fea813ec7788eaf43f5ef657e5af48395c3ad11aaf741549090b58670695f7c95c68e00576ca18ef0313f2b4b757219fc8db3dc2db28721d6f912547ebfebcd96935c3100aa4e4df9955acae1b4e2c10df1166d46c4285ab631c6d2ce58ad3ae99c07c019dcd15958694055281ccd6f803af290431f188cc4c429e84a4c30fd9c63968dfd0951c417efb71921c207de172a9546bdd3e2bb35b45e140892c649f88c31a438f864e801a69f8010aa3d77a26601a7a89067c81b0f7e70d8e82f21f88c7d0bb0c8ca0db875d6c3f8c6f6d709bbb31c7da2e31f3571daa2c5ab13bfc16624cf35abd526e84269fb45bbd2fcd8c383d6fbb700bc4b5205b3ef8c4323dc0d9e0370e56a3d1e5e76aa4de082e4c2a0afd092845bd5dab52a45943181461b76e3984b95f48bea80a94944241d04b5634c86274e7"
NIST KW wrap AES-192 CAVS 17.4 PLAINTEXT LENGTH = 128 count 7
depends_on:0
5:exp:0:exp:5:hex:"13df8fa68a6e096b9b5bbaebb64ace2e6a05485b5cb7e43f":hex:"3ee9367f631fb375ba47241966ad4ab8":hex:"d0309b1291a06c595fcaa6dcf97817dbd7b7ad2cf48ddec2"
NIST KW wrap AES-192 CAVS 17.4 PLAINTEXT LENGTH = 256 count 11
depends_on:0
5:exp:0:exp:5:hex:"17c25023ac76a8af777a6f71c0c0f97931554b0a15a79222":hex:"15227ef52412346e83a18c54a75374f69a24de6a07cfba9082596eeb5d758bb0":hex:"0f8e2fe4f3a28c1fcebf20fef2bfd3489deb284e03d057337496285f4ffe62f074bafa0a0a6e44e4"
NIST KW wrap AES-192 CAVS 17.4 PLAINTEXT LENGTH = 192 count 8
depends_on:0
5:exp:0:exp:5:hex:"49d1c4ec51f2695ad7e47554efd24170ab03f628eba7d5fb":hex:"8bf961097a6fa75694cf0ea47cfda23928fc433d5fc762e6":hex:"dc72c58faca0dd662e5fefd05cd714987cc2470219db77baf779fca865f31529"
NIST KW wrap AES-192 CAVS 17.4 PLAINTEXT LENGTH = 320 count 14
depends_on:0
5:exp:0:exp:5:hex:"e06ebf0145b178ea45687abe366fdec559877dbc9300a653":hex:"f0104e9546628d801c4f7e875f1ca4f385e915b0c7bd52ed158b6b42d7301f1df6dd5bfc80d0318a":hex:"5b4b1d4ef349fcf5eb7d720d84b2e79fbabf3db18277ada0752b9883c21f0e24281854420e6751af8fbcc4b98be0c1d7"
NIST KW wrap AES-192 CAVS 17.4 PLAINTEXT LENGTH = 4096 count 0
depends_on:0
5:exp:0:exp:5:hex:"932ed6ee1db1c4cf7fd81efce5609641cb5f3409563089dc":hex:"da8dd9c1dc8cbf95b0fa280747c1007ecb086b7c944b0db4dfa3bdf6ed0c9725901cb838c2e30131250188c22bd92b068aa0871ce58a0c22307671612fc4884a655329851d54afd48a9d3a7f97976850d6fd842034548aee67df1272b06f155eb21966858731c3c35d4bb94a1ea351ef5a8c4779c077d648ec1c4f27cfaa48f47541a8f36831e35a961b076307bea928e1856e448d7695a0f7fbcd8c82800d12f530c2086f3b67bc5081d384010b47d327120def5c92f815aaae31d32893cdd18a71ba4e208445ff3a2f68a0a46689458b0f2d6d9cd3726284e56b4c020b97a82d4463f74098cfd7bd7a5f12157a0bc812266b8f2c215933cb67518f900602f0825538e05765318b6d31150007e410b92d5d957e119c5d94aadba193cf6da230387b1c5e6448515f9789a8867571ea82ad34dc5b912d6cd243bd4fc2f19d132bd8f1f5cef00a141e30ec4d3f7a546a215d5b0c7e70c3b0ec4fc34b66c4170bf403ef910dd3897caef33405827a55f943904c4e1b1aee4cc3ffd0ad27e316c164e2b5bbcf73df60d8859201b6602be01ba638aff468f3136120c117ca848ae161ecafade668e2d04b227437d4b91c6fc40ebd9490f211bcd21fd7005d200ef584f37aa2c4c769174551cec0d7f2936ae78f6c389382212703d0e7c82aef1a736056ed9c45e71439731537a2edb8a63741825c678a11c42e5b2281b43e203b0523":hex:"76b6772984932bb6314d1eab8f625e044920f9494789e9a0ac2affd9a209cabb72ee83331a30472934e02ef28697d541a071eff9eb5c7dd49862f11384d46e8f4c2ddb084e76ef382117a285993e4a9f89e1e0ba6612f63b3c8a54784f940d7e6baf12cb67d27038e91d1ad4feceb5bc44daf7444f76fd140ec7a94869b4f99b9fcf6dd68e78c6a0a4794d55a1c91756ceb9d28b43d9c72b26fafc25c71e63dc175b29282d4a70813b833c35354983f29796909a9ba515cc5c37c58e95aa6f35b850500ea933b27a5922188c2da64680362602d71d169f853af0564b53bc613c15772ed82f89c2f8625670179a83536972332509e7ae4e0726271c5381501d3d88a3cc34a56d80e3e553b9b595e358615e92f361d695837734cdaddd7068c441b310aa511407b53806f1fed984a73862ea2ded1ee67d14feb5d8661ed94a62f5768829d6feea30db392bf24f0ea103fd2a60acf1fcd4bb2465641712113375bc2c8d73650795689f9061608b65e0e608f9948f5efcc0fba62c50b8cd97f67df2b0eec4f5a0cd354e982ae6a62070f4127b6556714bb2267d558112638f10c78be201ba165e57ac9cab6f3e35a762b7fe83b3c7c050b77174a4bf14eb2cac4d6d58a94f0c02727ad020a6a05d9ed145151d4f1ed41d5a6d06c50c0e1d5c24d09100d4f06c50d06a332a95845f4192ef577dc484e7acb91f0b2a57c1f8bef97c23294c59099eea13b3"
NIST KW wrap AES-256 CAVS 17.4 PLAINTEXT LENGTH = 128 count 7
depends_on:0
5:exp:0:exp:5:hex:"e823c6ef53b110eeb3f178871cf436887cca9df061d1f26409ec3b410033d967":hex:"f90c279e9e6423804a6505e8effd924c":hex:"0abb50b222af66058646156d106df7c85c28b708395eb9dd"
NIST KW wrap AES-256 CAVS 17.4 PLAINTEXT LENGTH = 256 count 11
depends_on:0
5:exp:0:exp:5:hex:"e5cca71056548467bc9c2849aba67cfe0fd74c44d514535d2314022a3f3e6ec8":hex:"326b6da4dce95c94226b63c2d38c4e005c566191b00028b59cc788e0af5261cc":hex:"2a4f331f451589fd103d9a9cbbeae5d5f5be7acf15aa6e21c45e09362263cf34b0ccab7c8a28dfed"
NIST KW wrap AES-256 CAVS 17.4 PLAINTEXT LENGTH = 192 count 8
depends_on:0
5:exp:0:exp:5:hex:"6a077f95496aba1bb80831280e7563f3a187e6d014342028349f766b791108ce":hex:"a77b3ddac0e78c9176b7445f9ec349b2d85aa2f57e6cb362":hex:"7c065be0a2173e0f14a3418779e7f3eb6eb7fbb7a3c20fd6c08b37d408bd9423"
NIST KW wrap AES-256 CAVS 17.4 PLAINTEXT LENGTH = 320 count 14
depends_on:0
5:exp:0:exp:5:hex:"752b21422647f1006de116360e88e2f6601eeb5aafd27cba56c20193fc1b941a":hex:"a5948c20bc611187d688cb03caa04fb17774aa4f99ae3da5d821bcccfae950d72ca74b3a870008aa":hex:"d71109224edc4233db8819aaca4db9c61ab5aad2806d0e985f1830acd8adde23ce75046b2057e0a23dec7a053bac6c4c"
NIST KW wrap AES-256 CAVS 17.4 PLAINTEXT LENGTH = 4096 count 0
depends_on:0
5:exp:0:exp:5:hex:"931bf2c55eac657ae56fc0a9505a6ea7cc9af5162d844ccf01f19debfad09cbe":hex:"aa8074a195abd88930825b947cbf3cca9810eb829d2e7a09f9e9cb1f8271986d00c5be478150fbbe990de8c61af879495274a60d83f98cfecb2473a35d86fba6ce839d259ede318a362e7abc1f8a18168606d5e680f456f1ca19942e67e5aee382536df7c28204b7842b99023336b735a861cf28363e7773d7b0bcf32b5fab14cb524249863fd7ce49a7a7882b53728f7ecd020393852494df09d9a69189ea713e730e002252af18864b948a642d7c0fb17b0cd5671f14ae340fb0e83b4bda920445927b8de8a82ac93158edbbd57fddcc1d908688770a07c27d2bdb7151d986e85cdf1606b0c1c959542e75090d8fdce9c2a9c162e6fd988746c9bc916ff3f20f054690173d143212b74c5a8961cd46663958744ca1334f6c1dfc13fa83c0a9cc229a1030c6c84d01751ffef54d0f9edb2a4851a187d02f097a5c716f8fbae29eae76738239516ed08c14f24f9378451e9e696742a4bcdd9e0ecba49fd05eb93698afaa1b0d5558521c7b4e77b15ca2612619bbd78f670a1562a9a0a0215fe64211115e60476525444b351a4f8ff5551dd198655423f3fcfb5967c4f77e25d3911504de1d034176d3ccecaeb31bd29677c7569c858ea24d7017ce0b31f1911f4fa14b2afa429c06115bc285ea8b90bbedbcc63f5f0829dddcb17e8f9d21bd71501679e514147e1957ccf986e7e96a0e63ded70a9d017162658a901f55b1001d":hex:"6b75fa8070291ef7c89f5cc2060c56270f5077a6df65a8095cc76b717167e67af70dcce96de4aa32293c17d0812f666e1f42e7e662cef7a3148486d2be7f314631ed6606f326e9781c3ed6be1735bef8cd5d3ac7d2b45c4419ea61462baccc0ff87b83b9b6cc85278c0b20bc15e6baa0a15eedd9e99df82c8e61476529c98aebbc9d40d417f9af26e6da5d115acdd6007d83206c616a39fbe21c6331cc45af11c578532a7cac50aaba21f3cf317534564c2ee093ef127484aea62c7a90327fe9bbe8e45627974306d8cc7452e96033f0c8c30ba2d7fb644796a49c9b502d3db7d4995f920fe21962fd2b634c15be0d82e9cf0ae3fd2b6d45524e1003ab9788ee56cff3e2e62c5784061a5ff586b5907098b8ab54bb70fbc6cb066b071fedce10e013014d82162e3cc6f9be3b4067555907a4df55012a9b1001888c55dd94b4f8528bb29e7985ecb8a7958fc8559831db05002479b1f39e5de3659f3a6e8289d9b8ff4eaa3f864b1ea101d84b4c6138aa6ffb95dea4f825d23f5d368727ca0a8cacb74f7bfd70fccbc951db99f2f4a580425c31a8552fa27397cf8b7f420f13fdcddca553a5f31d8645615b98a88795fb4472bc7cd6e8e54707d7be1f3dd7d4871725f6bc0e65762f1e42e22c411fee6dfd8139068798c7ae9781c8e5bcf4732a83f9142edce36e1ee6e20142adf46c5abaea0ca78f61e16b6875927d4141f6b215da1f48748bd33c"
NIST KWP wrap AES-128 CAVS 21.4 PLAINTEXT LENGTH = 8 count 3
depends_on:0
5:exp:0:exp:6:hex:"d060e5faa705b6c600ecfcd5252bbfba":hex:"3d":hex:"28ccc6da03cd79b78c7207946fcee402"
NIST KWP wrap AES-128 CAVS 21.4 PLAINTEXT LENGTH = 64 count 5
depends_on:0
5:exp:0:exp:6:hex:"663ee3d40628059fe01a9766d5c1c31f":hex:"1c6ccd67438f20de":hex:"c2717ed6e51bb4314388cd26464f4d18"
NIST KWP wrap AES-128 CAVS 21.4 PLAINTEXT LENGTH = 72 count 0
depends_on:0
5:exp:0:exp:6:hex:"7865e20f3c21659ab4690b629cdf3cc4":hex:"bd6843d420378dc896":hex:"41eca956d4aa047eb5cf4efe659661e74db6f8c564e23500"
NIST KWP wrap AES-128 CAVS 21.4 PLAINTEXT LENGTH = 248 count 2
depends_on:0
5:exp:0:exp:6:hex:"02a92285d0baa874ac94f6648988d44f":hex:"6ac78aff505805e3145fac44eaeb6ac92945ca12d9bc0b6fee8b1e5b983f37":hex:"18b251cf54d2a51ac903af2fd008f6aa2b1bf491fa2e0458dba272866821e98ad037eae4af654811"
NIST KWP wrap AES-128 CAVS 21.4 PLAINTEXT LENGTH = 4096 count 1
depends_on:0
5:exp:0:exp:6:hex:"6b8ba9cc9b31068ba175abfcc60c1338":hex:"8af887c58dfbc38ee0423eefcc0e032dcc79dd116638ca65ad75dca2a2459f13934dbe61a62cb26d8bbddbabf9bf52bbe137ef1d3e30eacf0fe456ec808d6798dc29fe54fa1f784aa3c11cf39405009581d3f1d596843813a6685e503fac8535e0c06ecca8561b6a1f22c578eefb691912be2e1667946101ae8c3501e6c66eb17e14f2608c9ce6fbab4a1597ed49ccb3930b1060f98c97d8dc4ce81e35279c4d30d1bf86c9b919a3ce4f0109e77929e58c4c3aeb5de1ec5e0afa38ae896df9121c72c255141f2f5c9a51be5072547cf8a3b067404e62f9615a02479cf8c202e7feb2e258314e0ebe62878a5c4ecd4e9df7dab2e1fa9a7b532c2169acedb7998d5cd8a7118848ce7ee9fb2f68e28c2b279ddc064db70ad73c6dbe10c5e1c56a709c1407f93a727cce1075103a4009ae2f7731b7d71756eee119b828ef4ed61eff164935532a94fa8fe62dc2e22cf20f168ae65f4b6785286c253f365f29453a479dc2824b8bdabd962da3b76ae9c8a720155e158fe389c8cc7fa6ad522c951b5c236bf964b5b1bfb098a39835759b95404b72b17f7dbcda936177ae059269f41ecdac81a49f5bbfd2e801392a043ef06873550a67fcbc039f0b5d30ce490baa979dbbaf9e53d45d7e2dff26b2f7e6628ded694217a39f454b288e7906b79faf4a407a7d207646f93096a157f0d1dca05a7f92e318fc1ff62ce2de7f129b187053":hex:"aea19443d7f8ad7d4501c1ecadc6b5e3f1c23c29eca608905f9cabdd46e34a55e1f7ac8308e75c903675982bda99173a2ba57d2ccf2e01a02589f89dfd4b3c7fd229ec91c9d0c46ea5dee3c048cd4611bfeadc9bf26daa1e02cb72e222cf3dab120dd1e8c2dd9bd58bbefa5d14526abd1e8d2170a6ba8283c243ec2fd5ef07030b1ef5f69f9620e4b17a3639341005887b9ffc793533594703e5dcae67bd0ce7a3c98ca65815a4d067f27e6e66d6636cebb789732566a52ac3970e14c37310dc2fcee0e739a16291029fd2b4d534e30445474b26711a8b3e1ee3cc88b09e8b1745b6cc0f067624ecb232db750b01fe5457fdea77b251b10fe95d3eeedb083bdf109c41dba26cc9654f787bf95735ff07070b175cea8b62302e6087b91a0415474605691099f1a9e2b626c4b3bb7aeb8ead9922bc3617cb427c669b88be5f98aea7edb8b0063bec80af4c081f89778d7c7242ddae88e8d3aff1f80e575e1aab4a5d115bc27636fd14d19bc59433f697635ecd870d17e7f5b004dee4001cddc34ab6e377eeb3fb08e9476970765105d93e4558fe3d4fc6fe053aab9c6cf032f1116e70c2d65f7c8cdeb6ad63ac4291f93d467ebbb29ead265c05ac684d20a6bef09b71830f717e08bcb4f9d3773bec928f66eeb64dc451e958e357ebbfef5a342df28707ac4b8e3e8c854e8d691cb92e87c0d57558e44cd754424865c229c9e1abb28e003b6819400b"
NIST KWP wrap AES-192 CAVS 21.4 PLAINTEXT LENGTH = 8 count 3
depends_on:0
5:exp:0:exp:6:hex:"959b4595778d7b860e08fcb5e24b11f118fd5d67089f2ea4":hex:"65":hex:"1cf986a0fb2208977c37a4c3830eba72"
NIST KWP wrap AES-192 CAVS 21.4 PLAINTEXT LENGTH = 64 count 5
depends_on:0
5:exp:0:exp:6:hex:"02dfb6662e0c1b95d34aaba7eb6c1fdd41c52b89213d5b18":hex:"27361c34c2601fe6":hex:"089f835f3210734aa1a2282c6ff30ef9"
NIST KWP wrap AES-192 CAVS 21.4 PLAINTEXT LENGTH = 72 count 0
depends_on:0
5:exp:0:exp:6:hex:"9464f1af6aabad076661328bcfd15777da16a288a2660009":hex:"431527c3a644c106bb":hex:"d9b257b400d808a0b0386af3be9154fc7f2fb2d7edc06201"
NIST KWP wrap AES-192 CAVS 21.4 PLAINTEXT LENGTH = 248 count 2
depends_on:0
5:exp:0:exp:6:hex:"df419ca84650ef28a1c5d1cb47917e4480a3aca4bd29dd5e":hex:"3d84df372bc0b854c058441e952738ec79474b673c94e32dc78d23745fb5e7":hex:"497e966414475938204c3b3d606d5160461c54dfdfe903b6624208d7cfc90bb403f384bfd54d1ed2"
NIST KWP wrap AES-192 CAVS 21.4 PLAINTEXT LENGTH = 4096 count 1
depends_on:0
5:exp:0:exp:6:hex:"a85b4359ebd240012ec749459bc928eaa52c84e887ababb9":hex:"9db71e2a2d40f6fcc1b8311167ae13fb101bdf7b5c4e078373c0c3cb3f3a3ca39a91a6985d3fdd48d93f2b5a09b2a69350da2846ce6a37d018dda95ddac93a92fda7b7c3bb6518dd78f367f70e34e0bf19dbba46fd13d3f3e0a1776350f27138c64b177aa39c54dc06184b320016b6305c2dea19fa6da634cd613d5a4f71bc045f555a1ccee39b8f1ab90840b5bae555932e08719bf38f72bc1057875e8c077a70629f46be91281b977ed6f2a71171a7cbaf8e0566e55da6220a85a7655758de3b372144ef76d0337d3133004c0db096b2c41f524f95706247a331d08a6ff72b425395fee8e1ad308ccfe5b0525c40803e529db72063731fe1644891bdc0d5961397006e1f5d6521ad4e5aee3544da101fd3cf6bcf879220a612b7016e5eefe7369f136086e8f5109ae83e8687519f2008406d20992b64ba1d27b436ea5db1fd734340f3b2279e026a96e3f9c5c7b99553e35ada9e1d7d708a73774718f9b7073c0889a298f212d47ff5960e04743070338f99b11687396da2120b8f132535c0911b04505c0e6c32590c82bf59486fadfbdc0f16a224b2f52082eb66201f041d64b34809e5e91cda89d80d78fe1e15862bcf84f65a301ae68d097c9be09f3411c11cf83225733dbc9306ad2630eb7994a0d112ba83dc542966414137fd008fbb7995f649edf844fe5ee86b94acade1a04f42dae21928b9b0cdde8cc66095772d":hex:"72880f9f173f0ef4d99e3ae71f6f3b94f66a08aaa22be1d206faf431718c1a29bd0a574b1a28b69f0e64d56d3e43617dc73506a939b7de9005ef0ee3f02b9265e91a32aaec58b7ab990f39774f6769c9be9ced3339f6bf0159055abe237c4c755613a6c03271abea3bc89527f284a3e1557ae26b3910b779a77a128e773d11d7d641479d02f4888c989cbb8d928da0136b965531730a3c0c32404351f4c2390d996dff58985ed1d4f4021a5d6ccedf4555066a826a04055cdf8c9c44bdae26619390b3e22b064f86b28382094a3e299d55ab335ade601699e85f19d6f6f12407caf84ad47f03d75198691f1a9b2aa9ed95e508d8551b19601418922f3289fc1efc3abb1ebc2f4886dfe325cddfe25dd908e5aef8ad197ce2703e692b9c46a12201fa71ebc2e323ff8926ecc059ffeeacc0446d3f28496f17f1b4ad6504e4e24188862e25f3dfc36adc7f79920d88e6c53269cc4e5dbbebbba1a2347154683c840d178476ae11d6ce574c26b8b895957b8623807e8831b87b5639aeb415adf1bbef394046deb3bbe91a5c17f2f67131ae5f696352a488e3bed40df025e0a0846e0037847350fe8ae3cf73141d0ec550d82b89c05bbff7337bfe846411d3f0bd012e4de2fe5b83c7210214c0404b40e08abdd3f4bc441f9b6e1efdaa4ac13b85d139f670a6060a1ba8d2528bcd19f241d9ee5077d20c120f2b484c67c9c598b1b209824c3b8aec2b7b"
NIST KWP wrap AES-256 CAVS 21.4 PLAINTEXT LENGTH = 8 count 3
depends_on:0
5:exp:0:exp:6:hex:"0070492ff3aaa190496c72bb0affdb6fac7fa9cb32e6e91a46ea34863422f807":hex:"39":hex:"643a9706af6bd06410b70ee38f546bc2"
NIST KWP wrap AES-256 CAVS 21.4 PLAINTEXT LENGTH = 64 count 5
depends_on:0
5:exp:0:exp:6:hex:"c6e882f5b8e361e43bb3e54d5a7b8c690f485bcbec2dd2183c7e623f6b02c5fc":hex:"99ae80eec64630ed":hex:"de0680b34f7374539ad9b75f08f4d8e6"
NIST KWP wrap AES-256 CAVS 21.4 PLAINTEXT LENGTH = 72 count 0
depends_on:0
5:exp:0:exp:6:hex:"70da43aac823c6dd37d1109f5b18feb4503c973288989745e2cc1cc21d9570c6":hex:"edf17d966ed896aee3":hex:"d67b5b2ad15c645450e23b5e7b6d682f8ae20e716d470db7"
NIST KWP wrap AES-256 CAVS 21.4 PLAINTEXT LENGTH = 248 count 2
depends_on:0
5:exp:0:exp:6:hex:"e941febe4b683c02dce56194a86b72d4c569e1fc84bc7a6f24c3ae2b39bf5440":hex:"c168cf12acb6679c24d424baa62ed56559caee163a4efa946478ad43d7dbd6":hex:"4ad9979caa72fddff0876c0295a57fcf74e5980fec2cf622191ec6b5aebb75e0adebb12d0862ffae"
NIST KWP wrap AES-256 CAVS 21.4 PLAINTEXT LENGTH = 4096 count 1
depends_on:0
5:exp:0:exp:6:hex:"20f31cded60b8ed8d9d3fd1e1fa6244e76c7cb7628bfd28a5d63ce8aa2c9494d":hex:"f07225202842c8dede42215301e44b9bb7e625d3812f74f9b6ddbcd024ebd1f33e2cbf280b9004941f3cbf86c880a2357f88f92a6dcf8dad9da7dddcd00f3635efdff0af4382024e93c2af66b991e565eacca6b886f07178c9b4adad6f0d6ada5ff6aa7cd0712519a947a8089cea5e1e3e40ffe1806010b0149f9ffc7c4dd3c31b3d08d5ae1997c52369393d58611dff9bec501c1ab35e6ed3e7f9445a34e211010a8236686f154e0a5ae3433d6a844eb3884961aa6592216d93952b46bb58a4195aa80966ad0ccd4a7e23823912556a90d5ee9c3bb952ecbb9d895dabd3b11ab4f2e3a6c2582de50403289230ef4dc46e7c0d870a3f0cba9d643a0349503c1b162ddb6350e699589eb47bd563999f55a1adb6b78b52f006901b0427ea7d3394bb0adae4637b4f1ad5d5425e2c8ff3083506d7ad7ba4c7405a778b0a3a11760c96900a5256956cc9710091d073a19f46a985d004651fe2b6448ed761bf9bc81619cf273a6783d868d090753bf01318be21afd88d9f3a961a69f93e9d9fb822c80acc7b48cf14a08b5b7ef15c66975721b7cde9761a145b679155472a44dea8fedc0f86ae7ebf6283ecfde5f2444b51569e6723a7a19e28cdf8dec6791ccc14af95abad018f741575b343cb1a20a2a9adf4248f99728069a1e2e78ad8966c41c9918fb7019ef56c153a183a6247d22d9956564bb03075cbfd1b43d96818b28484":hex:"a5b63618fc0c4512960f00a1f226d9837a90480baea75265453b9553b12a58c72153080842d7f8710f317f88fbbbf97caf879ab4bf416ba767ee9aeb34357f4a2d0e8b9571054d98e28804a70bc4d74807f2bfd95ee955bfdbb6f4d6969a0c3c3b541a514647d5cd8c9740ac3496095c3f145c50c97ec98b935158fbdf89705d5330015e48ece89188b8c1bcb2ad6825d865b375a9b9056b743dac720feeac033c9f757f6fe73dd7c4a747661b64cf490a0dd43b547cd791a5d78dac97efcd355f7ebac248fa2a33e4fad640dc34e0d40b0d36588aa32f0864c9446739a6b44ff84666d723bd7d646c5172cda932fec34ddaaba342b02a9604087ef042a2be4774194b5d32cb3fb112438fbf2801050b5424635fa2d3d3fb10332965c73e6669e65195310a3a30602640e9809179cdfc50de585aa1c0072423c626815d281a06eac3b6ffa137716318e288e3f9970e415ef0451bdc557968febf9eb6772c1f77cb8e95701246d9c567048142bb25e340351b87d7391822d9ee7fe51378bc0d08135f9f39cf44b348b87937939dc61f430dfe308cada632722e23aed5a0699e039cf0563ab8025163744b136a13ce3c62c748c89f5e17540f105e7c6ec9ba13515b504342f9e6dc7d65b9a633d8c0b5c9fa858dbb9b3a594406d478a81bb9abfa289730408c1e303c663a61d5caca00f615065312580042862397b9aa8c80ca812887664c439c8c68"
NIST KW unwrap AES-128 CAVS 17.4 PLAINTEXT LENGTH = 128 count 3
depends_on:0
6:exp:0:exp:5:hex:"e63c2cb1a2c1282d473b66753494a591":hex:"084532f86949dfb7be2cdf09d2b7505418e7bca5185661e1":hex:"a26e8ee007ab90f599a1bc31cdabd5fe":int:0
NIST KW unwrap AES-128 CAVS 17.4 PLAINTEXT LENGTH = 256 count 0
depends_on:0
6:exp:0:exp:5:hex:"83da6e02404d5abfd47d15da591840e2":hex:"3f4cbf3a98029243da87a756b3c52553f91366f4ff4b103b2c73e68aa8ca81f01ebda35d718741ac":hex:"67dfd627346ebd217849a5ba5bca6e9ce07a7747bed1ba119ec01503202a075a":int:0
NIST KW unwrap AES-128 CAVS 17.4 PLAINTEXT LENGTH = 192 count 7
depends_on:0
6:exp:0:exp:5:hex:"e5c2fc20f9263da4f15b817874dd987d":hex:"0538fdca42f1fd72afadbe689fa8a396996d734e4f082c8c4ef41ef11dc6246e":hex:"35a261169f240dffe4701ce41f6dff986764afa6e84f63c9":int:0
NIST KW unwrap AES-128 CAVS 17.4 PLAINTEXT LENGTH = 320 count 8
depends_on:0
6:exp:0:exp:5:hex:"3f5501341f617cae30dd0afbfa247c09":hex:"72fcc9e5942344d11c3b23503b170e39cd635da3a83aa9ffb196cfb1d6eeae6dc5f5683238da6e9b49edbf95819bbbdf":hex:"e2a34da9ea2ad66e130251f8a7798b87d7bd7601abc5ae8f7305b024ddb4b3e00351484165e16d25":int:0
NIST KW unwrap AES-128 CAVS 17.4 PLAINTEXT LENGTH = 4096 count 0
depends_on:0
6:exp:0:exp:5:hex:"adf44a10a05e64f2df87db52f3ae18d3":hex:"a940cfea67b90c81b4ccd793f186dd7c6a3c0ff5a6feb5bbef99eaae2b14a979f1acee92b5e4cd750f40571804d380f470e1f5201a389476f97bf29f6699053f468bf102975895f4c1a679a46cf627b22c8d956679ce53775702899afa223c87621f859dccb876d317f2a486d0a4d4ad6ab7e2d9ebf7a956c394ffcff423377e21b274f8ca3a379273dc8de738c97bfd318871330abfe2539a49d4f03d0eef65856c01ebd426f2e76fab90466acbed8c4c9dc09898929d80244eed4fd51e7eff567c2b340e928f298ec00cc8839e1ce9ccdff40a7edd04e01440f2288c384c673de8a758ba50f6f910b8002e0786d2eb633da0ef7eff025f37b45f7c9b918863a56e2da1f3fcd12b990f959051289a1113054c38c135336f19672c86a51200763678cc4ef50ed290d96fec4afaa53af165aa7ebc11d787ab1c535a0abd00b477b914855759477df2afd516a85a66f8b91fb5f5e98232e601e249b3faa856bc6b26f1945f48542601bb4ff1c0dc46f44ae023c0a33ec9faa7467b1cdf1c08df7d00b800ef28e2f77f1e6941db9ce8e71fcf82a14cc8983614e2ce3cb4b3e976a8dec76e4309492ca68486d119cd566b9692d1a513ff30675737d1777a3a1a95b6588685b5a64d890cb8f79578fae8f1d22b83747bf876da582e56e5267ee8e734e0fa9271f5455c40fd599082c0acb442927643aeefffa5bca0a88c38671db14899adbb4819dd1e2d":hex:"a2b43c25c5f530a6a29c5314319bee95e0ad5a630aa8dd614b3751205118e35117c31de7d1ac41f9d782ae8456ef0387cff49eecfbcedf2d9c0b18182f5e043e3202c527be77e6f0404a9746ea1b18978a916cd47d40093813a3b0ba1cb22280fd7f00a7fb4f8def6a0cc1ef848a45106fc389e0ea00652151b1e61dff2cf2be83fccfbccd4fdce86f19859ac927a3dd08645cf072c3525624b3845a532e5a37d99db5cc943a0a9d42be4bc81134f314fd9e22ebd386e7a896bc2d56c933326edb18120c072579989c5bbb1991993a698f2a19387612b25a303e699d12003072fbea6e45569444107ff9a17675f5454440a6c3cc02c1ba513e26502b74a0cb6d397ff6d7d11877100fbfb5370fd882892ba09635fa3fa78d5344fa00008f488395f04a7185ec7819dbf3b165ee52b35bb4ebd10354f2d85514b2fdc1f825a4a2968ba44b3ff2812d1acc13c24ac49c22343b6080f2a7e7efafe86c6435195cb742c35d8178fe20ede0ca08278db49faeca90f95b9b17fc1ffb9d7b1d064f2266d32bbb6f3e28f3b17deeb9faa64f7c127c90241579399294eaf1dac93346943a3cadfd84d7cae1aec66877e892cfa31b5ae35eaf7c35faa6f4cd9212ef7cb2cf9df5748ed8194c380c3298734e1ccb87d0feaf49be1d275142f8421727b5a6c3415fb30ca44ab598597d136bd6d12435ae6ec3db72f6b85462878d833dfe5e6f":int:0
NIST KW unwrap AES-128 CAVS 17.4 PLAINTEXT LENGTH = 128 count 1
depends_on:0
6:exp:0:exp:5:hex:"5d4899ee66beff1bda1fc717a1ad4c50":hex:"bb7fd0bce778bd775e4e88d904d26a7134364c53a6c493a0":hex:"":exp:7
NIST KW unwrap AES-128 CAVS 17.4 PLAINTEXT LENGTH = 256 count 1
depends_on:0
6:exp:0:exp:5:hex:"84bc6ce7ee4fd9db512536669d0686da":hex:"c383db930ffd02c0073ac2cc79ec289e6866bdcc6a135a3b776aa42f14ee04f9cca06ed6c0b22901":hex:"":exp:7
NIST KW unwrap AES-128 CAVS 17.4 PLAINTEXT LENGTH = 192 count 3
depends_on:0
6:exp:0:exp:5:hex:"266b009e911bb55f9aa0661539a6fdd5":hex:"db9c94e7236ec56982d7ddeb9427c24580bc1fb96db98ab19340e03670045b7a":hex:"":exp:7
NIST KW unwrap AES-128 CAVS 17.4 PLAINTEXT LENGTH = 320 count 1
depends_on:0
6:exp:0:exp:5:hex:"51c2e3d090a74bfa10db090b63ae53aa":hex:"598a16c226e6c848a78ca30fa514edc9467f704b529c02c5522d1890b4dc21588ed6c3b070ed952adc733d865eb9d468":hex:"":exp:7
NIST KW unwrap AES-128 CAVS 17.4 PLAINTEXT LENGTH = 4096 count 4
depends_on:0
6:exp:0:exp:5:hex:"6a7814a80acae9d03eda69cad200ffe5":hex:"e1ebfaad7f6d46cd03c50ce4e9543ff01150e9a9a69c4bc8198fc08601ed71203e39375d600f69fd762b196bf50a7dee2be55574196005c8ad53234d789a9fa6f2f0eb7d7b53c7e39a7c70e9ef93c58bcd45c0f592fbcda19b5ea9a118bc2a0d49c8cf367d4c90823eafab86165db3aaa22eee9323de7d23b7729f7f088be9db421fc8256c20e5874bd0c8348c4a6e50436fc94136e568d0aa4c29d7b65136bb378ef010db091085c9c0802466d565eace2c0bd91648fa82f8045c57cc25c46bd8c9e4060ceb00e092f7beeaece1d4f8a2a01b5b1dc9de3c7d2ada7a44d4600085b7e76929198b9823b5ae0f74c652fb8793cae7c16cf062f39136789b213d1d500d560bda89bfc0df0e6bcb07fb4a48914e1af9058b73751aa4d98ef0363e48f9d1ed42230eca1b7b24631cbad80b2d4bfbc00ad1ab797c1c459214be8f64470b4d267ab576fc1d3c86a42610b8282437dc071336c325e606c2d36de1b24595f4888cfb2ddffb46557c964a4ac53ccc1d214d44ac84b8322c93db03bdf2a04b303de4f8482b8e7ee25030aa5ad8a8bfc5dd683726a0286486356f5a965599313a2c39034774ebf646fa7ccbda35316c54d443c6da466d9c95d716016326603c3989bd7545e3506333ab3e2ad7b45b225bc43ecb37e4c301b389e06b95f09b1a10beb5fd5320234fd6d488d5691ae2e078630f9f57dd0870cd617c30bd67ac8dbf4b3a8cf61067f7":hex:"":exp:7
NIST KW unwrap AES-192 CAVS 17.4 PLAINTEXT LENGTH = 128 count 0
depends_on:0
6:exp:0:exp:5:hex:"26045402548ee6196fc0a60208ffde21137ddb1c6c5d2ba0":hex:"fcd55c2c60ff6de19ec3e6b13490c2821f0c565abf10be2d":hex:"94b8276743184d086962ce6c4e63bd53":int:0
NIST KW unwrap AES-192 CAVS 17.4 PLAINTEXT LENGTH = 256 count 0
depends_on:0
6:exp:0:exp:5:hex:"b3a0aa60fb14b658e1eb1c1a5a8e1f60307c9b9faa2f1587":hex:"fdeda2a10e51da1817af2ba4c9f200414aec67545f5e71c608e85d14da8c5567bf51dec4ff2d8c05":hex:"65986b3a6a3658a66cb5beb302540bb032b36c76d040b24fe278a1473ad4c32f":int:0
NIST KW unwrap AES-192 CAVS 17.4 PLAINTEXT LENGTH = 192 count 6
depends_on:0
6:exp:0:exp:5:hex:"f0ee8ab6f804a2629e163b58c1a9e9039b53ac60493df11d":hex:"3593dda0daead2dcf850f8670b7d0692332f57068213a772a8244d058e5634d7":hex:"401df0c06aa4c58a71b9438e11a11a239f577b6037adf350":int:0
NIST KW unwrap AES-192 CAVS 17.4 PLAINTEXT LENGTH = 320 count 8
depends_on:0
6:exp:0:exp:5:hex:"579e58b2bf9c34c31e8c644faef6b698131624063fb2d795":hex:"b39acd09d9bf9daaa89304f76402065cc3d863e12df8a966f037146db9619e7be5ccbf50206773c5eca35e36492ef4b7":hex:"9c1f66267c2083a42f3da4e754a073c1ff151681e2bc070e6e4682065fd109088a096e72024fdcb0":int:0
NIST KW unwrap AES-192 CAVS 17.4 PLAINTEXT LENGTH = 4096 count 0
depends_on:0
6:exp:0:exp:5:hex:"366af2c7a1d7a1ee5a7c239fd526024472f674ab039bba25":hex:"36fb77bd3890aa0a4a4d6f65d671156683c48214a327e5b2b0916c0031f9f4f2c643ca721aa22e84853096bcedd7ef57ab2ae05628099bdbb55111358a06c1e99233b94a568a3f59b06d8a64332acf888cb5bd1fe8ed344937137eff629bee3ad57c73344df80b303994889bbfcd0ec08b13b687ec909cc847f383d3ba91d108c84254af4ab4c22df19897fef44b62d88b0c1b269163de9a2db56a26c4dbd0481026d27e5003153eec761f21c02f4d04898dd3ed961ab158e572aaf3b828a30eedf62a8a7b0911eff27db48ce1b7bb79b14ba43d7ecc1f87c82664c99ea857746c99a993db5807f0fb06114c00428b85ddeb9cfb698d282b1d70eb7c17d4d12575e58103ef1ed37c558d7c312f0fb1d72cbadb84561a41e4745492c8b1eea557efb9f1e9664ee995aa82e7f2a1c86dabed0b2fecd9e938c796dbf2f9b4dc269545ece94e354ca3436e4c6936b51cea7abcd2e49fa263f79757c4b5a8d18c2c6a26435fbbaf3fc759bb323ffb962bdd445dc7e5c84f9d98812e7eae254d19a06ea378b1b262daf22b634dc30aaf9d911cfff0905e5e2cfdd7dde4dbca75729bf33ef6d27d5993f19c9a3e60fccf5fa201963cea0e7caec99d79f83435d11e3a90905103c302851c8d33cef77b39c104ad4d8f45abdb111780c46784e6fd6a78e57862350a671ecbf01dd936b8dae4ce4a91d86efad8b04724d7c17a89b1d43d8abd650f88e17f5df1":hex:"40bc409ed0ba1966e733be4b2ff9d23691e6a9f44b0abebe971a47b4ebd51bb13bcf70bc1359f6b5e670be2e6b008ce9d219abd61ad20edd97aff7458b81e6114ea6d9c85a03400477b1a32f09ac5cd1a963731246011ef4908bacdbfae5e5921cba143b9395d17386e924db6ce40361740c6ae5acfdc979d45c8af70b443878adbb04bad439c9937a30bbecfc50b7005782bd01e3a87538220ca149286855129bd189f9bdb55ed1f7ab786f99c289032123c814e683db2f10970db79d2ef87f5a8a2cbbf7b9e2c447cb22d2a9d0f8c2b093a4d8aee57f0b05c2ac4f4ef780bad406b847d3c9d175f659105795236b072e96738043cbb8499292ad45acf7e576d8decdb635aeda6611da6c00a1badc11962dfa0643a83b865099de79416c86448280aad32f6797ef2fd879ba46abf36c9da45da4d0c936f6e25240cf30ffc79647720bf10ee18743f1ee3397dc0ed967445bb7b0df8eff0887d3f84abf20f0b2036837dd0308ed4a01f9d6447a9eccc9c471e75bd32f7d760216c326901ecd8590afcc2e697311e29f9d704dbeec409cc8c7fecc12fcf70cf9f718c12579fd17cef1e6bb44f89ad418005c2629a96275965f08c54a53e31cabcd4fb17021889bdcd4851ad33bb0d5438e55ba3b759dbf3c50fe20e6f3b8f1989f560818db1f2079b91b1e2d8bb22a7523c3137e9a30ab970f6019eca225e4b42bbe061f3b7b43":int:0
NIST KW unwrap AES-192 CAVS 17.4 PLAINTEXT LENGTH = 128 count 3
depends_on:0
6:exp:0:exp:5:hex:"9200a0f688d86c0b6bfd9abeff66341684a373fe3f9a3057":hex:"5c685c8596e374710fe327bafc45cd09190215fdcc03d010":hex:"":exp:7
NIST KW unwrap AES-192 CAVS 17.4 PLAINTEXT LENGTH = 256 count 1
depends_on:0
6:exp:0:exp:5:hex:"95c9e644559919cace6f93f545dbfe48b130808ed66d0964":hex:"7b8d1307e992221f6ffdcc7909d972d5f02e92187139cfd77f79345cb998bbdbabedb3ac00a6cdc4":hex:"":exp:7
NIST KW unwrap AES-192 CAVS 17.4 PLAINTEXT LENGTH = 192 count 7
depends_on:0
6:exp:0:exp:5:hex:"ffdbcbd0abc94c7f15e5b6e8a7190f1ed4f01be11f4f7ccb":hex:"e9ad95c8e9185a001509c50ae0098d45f7032575c7b8fd90a561716d2e5804fb":hex:"":exp:7
NIST KW unwrap AES-192 CAVS 17.4 PLAINTEXT LENGTH = 320 count 9
depends_on:0
6:exp:0:exp:5:hex:"253a5cbe79a291c0af1a3d7460e7f284bd672cd026753fc4":hex:"f71014ba711602df5cff2b93e86253775ea308bf83fde65fbc9a9a7852f87357330450072aaa3d6ef8dffbee20d2de7c":hex:"":exp:7
NIST KW unwrap AES-192 CAVS 17.4 PLAINTEXT LENGTH = 4096 count 1
depends_on:0
6:exp:0:exp:5:hex:"ff8666e4e538a6cf0a2a002b63716b06ec5f187785c2fc1b":hex:"f5bfda19b535cf39e240d5b42db06f385fb002be273e46d9e5ceed6be4b5f636031bd0622ea0b3abd0087a7280844ce7260594201214e601ada0f686da6e9b45fedbe36c7d13db025746fa6bba2e540a417a29cdde32f9a7ff56325233bf60929bfd49f80e21acc23f3abf572d81e96b556f6f4f20a7e00c1cacd6fad07df30d40de593c99f73dbd61bf9d9d5269a56006ae85d588324f7e140d9775403af631e695f7856b1bcaa377aa7f4f12c68096a974ef703435102d7110f4eeaca787744c942be1186d132bff2b39f160157617bcead75ae59288880fc0e7db9877d854f553e90e1c917a99b8f357082c50bf3b71cd30d016f164ccb85bff50212bab13cca8dcfff0be984daead905ab13054eb12908a73f37ed42c5638a5a410ba182a2bee2caa84e76af2a715ddd24e837988ec475e506faa130f0241e08d92567a69c9645fc2be3945d65a77387cfa307562c9b6c7055f98956c547ccc109da9277292f47cf43e3cbc0d2e91c916e4fbd70df4a980e9430f5c1c8cfbd6c83f0f756c436bc07e86d5c75aec7e4c039349f71fbb959db709427a33869c523c3486be0095c1fd61ac912cafb9065b94916afd9166d73678ffbcc396a037ebe75e44cd824b2196903950b528f537c8baa70530251bfd8a6f37b202453993534c06aada0d1dbf760879d0898026997f1baf63e343e94ae076da7d41ea325dd23ff2a9cbee74baca05a538543d":hex:"":exp:7
NIST KW unwrap AES-256 CAVS 17.4 PLAINTEXT LENGTH = 128 count 3
depends_on:0
6:exp:0:exp:5:hex:"e594f0067cedb74e883e7746d29ba725c884c25375323f367cf49d17ad0f567b":hex:"3b51ae2b0e3ddeed94efd7bfdc22630187e1f7624d15ed78":hex:"587e3f6c75644bb5c3db9c74714f5556":int:0
NIST KW unwrap AES-256 CAVS 17.4 PLAINTEXT LENGTH = 256 count 0
depends_on:0
6:exp:0:exp:5:hex:"049c7bcba03e04395c2a22e6a9215cdae0f762b077b1244b443147f5695799fa":hex:"776b1e91e935d1f80a537902186d6b00dfc6afc12000f1bde913df5d67407061db8227fcd08953d4":hex:"e617831c7db8038fda4c59403775c3d435136a566f3509c273e1da1ef9f50aea":int:0
NIST KW unwrap AES-256 CAVS 17.4 PLAINTEXT LENGTH = 192 count 7
depends_on:0
6:exp:0:exp:5:hex:"e86b9c1f74cc87ab8ca6a2fa1723fef173077e684345b90dacd3d485f587d320":hex:"c97e8c25d498430300982cdcef592e34176e33e45cd59b19f7605f52e3c7b997":hex:"261313cbea4b246e53affe1f84bd4c900c9b1d1842d79337":int:0
NIST KW unwrap AES-256 CAVS 17.4 PLAINTEXT LENGTH = 320 count 8
depends_on:0
6:exp:0:exp:5:hex:"5b7f48b8ce77007481667e9900f3077a0c9407a70082b0de29bbfbd716a07149":hex:"3ed16c7e4fed98d76092936e94fa5696c787ab63cb764e930fd37f917be4e7e60c90f327f0865d279e6c449b96301ed7":hex:"4e0e6c45137efbf858ce896c815268a10d9869ef5668a90739b7eff99617691fe63b911afa53feca":int:0
NIST KW unwrap AES-256 CAVS 17.4 PLAINTEXT LENGTH = 4096 count 0
depends_on:0
6:exp:0:exp:5:hex:"9e92fc974e09541e6cdf1415575511436ac04a56db186bc0e60f0fac9bd58c6a":hex:"201010a2a33fac1d20230bf5254204801de29e66cc44eb391b8e77284b3dbcfa3fabbdd4d9423d96af64ee0dde35786d79b7433021da27d6be753f91d2c1d63b40e9dc265b4a27cb2a61018a60ba5e29813c012b6acbf7d7d101ce227e45b5bc8a16c604c83a99ef35aaaa44fcd2033cddb6122db2dfb944d4b5c16dce911c5f4a1d8db46785534e7a090e31fd2192be64fe5b72efaa8b7965552bab4a20c8eac9a9e7b35e77df0277a90b0b1167e14a8be8d0bc37757354eff920ef93ad65c5a49b04bd553883efe9376811986002d4270d25c5749ee1454270a191084fdca53ae693f5a31b13929fbfd68b331a4fdd2259031f812ecf50d042a55fab302375057cb5b36735bcd2d75f745fd4a92580ecfd0fec44313ba9ca8cb1893f7a329638c17608c170de0ef68123c2233fea878fb1b49ec7478d9cf70591101bfd2d6b0328a27f7c497061b79289b6db4e46199c5db8121e9e1adcc8d64c85c27e329883775073d5f61b0bc470169ce8837b61fc23bbbe7e07d265b32cda5a94acea4bb2e52af17e13818a7ea424ca7fae7677caf405f04e37c2cad0c77eadfb4ead593f79ecbd8292e47b7838d775af9d9e252c6ceb147ccc2aadb01f8541871e5080109f9d94afc9103579bc9dbfcff8791d5eaa68521806590eeea74f411731b920a91c4f4542a60e6ffccb1285dd30e74292d5f37f33d4cb74742ac98c7a0475e069828dcd7d8301fc":hex:"4b6f2257197b0692e6026d531bbe2f222a6764fe1cf277b0320a6bdf9efea0a3f304e94fd22372712f751aa377264b1600f3c1e7e0ada846082ab4885a5c9a51b1b25a593a269a7ca1b62a28f1a11b80fde57f0b9c0fc0e38e8edea8a294e18b4b1e0e24a5ae0e9d9fa0d8cf02378e592b322ff04c5a487332b5f58ad3fe9a0c20a205f6872c9e2d0c52c5b29c5c2f008444a3e8400b4822d39f646f9ed390c352615c4cca8cc0099ac1ec23ad7ef581ed33f9fd4a8a58eb240fc79bfc2df7c1606cc52fb97493fa59a0dc8dc01fdd9fc9fb51a2f1e9fd6a89cba67f001d105c456d99c3b1fd68dc9d01b1b8e0e4c2ed4eed63c0110ea6ee96b54eebcd56c5446dda210a9e143366014e72d5e4bf78bacc230641789ae7caa0e37682190d8007aad0a0983e7c970a6feb1112ee5920f628ba03493cc3b340aa9452e6698f818e6e409cd0a7f660094df05646ea0e6c6aa94e933f4fa4feae6207eb473f9d80e335d6020138f1fcd085a336bdea158823cd47079a89ac18bc8541918ccb6bbbe1aab5ba7d9c6b5fc9ba17cae707a556c2bf7d1f991f9a8ebe0f9aa6e395defecbb508cbbf68db8da443ce8fc40149c3c84314986615ca5685e5e2162ebc617929a7e402a6262a28e646d7f503253c30ff2e37ed6580676a9978aa2f5b4fe82e1c2fb83754fa855ee54a61e64a16b64a680732b14671ff55b3f2a6415233206188":int:0
NIST KW unwrap AES-256 CAVS 17.4 PLAINTEXT LENGTH = 128 count 4
depends_on:0
6:exp:0:exp:5:hex:"08c936b25b567a0aa679c29f201bf8b190327df0c2563e39cee061f149f4d91b":hex:"e227eb8ae9d239ccd8928adec39c28810ca9b3dc1f366444":hex:"":exp:7
NIST KW unwrap AES-256 CAVS 17.4 PLAINTEXT LENGTH = 256 count 3
depends_on:0
6:exp:0:exp:5:hex:"605b22935f1eee56ba884bc7a869febc159ac306b66fb9767a7cc6ab7068dffa":hex:"6607f5a64c8f9fd96dc6f9f735b06a193762cdbacfc367e410926c1bfe6dd715490adbad5b9697a6":hex:"":exp:7
NIST KW unwrap AES-256 CAVS 17.4 PLAINTEXT LENGTH = 192 count 3
depends_on:0
6:exp:0:exp:5:hex:"81c93da5baa5157bf700fd38d7d67662670778b690cfbca9fe11e06268b35605":hex:"875e1ca385586f83d1e23e44ca201006df04e1854e41b933fd607a7383ae1a39":hex:"":exp:7
NIST KW unwrap AES-256 CAVS 17.4 PLAINTEXT LENGTH = 320 count 4
depends_on:0
6:exp:0:exp:5:hex:"c42c53da9bd5393e63818ecc1336ec6dfcf1d633e51ebb51c68fb0997c979e7a":hex:"52f7b481f72bc2d41edade5388d38c2ff75765939576e49bab400040a14ff488848bef57d1502c06a3faad471f5c3178":hex:"":exp:7
NIST KW unwrap AES-256 CAVS 17.4 PLAINTEXT LENGTH = 4096 count 1
depends_on:0
6:exp:0:exp:5:hex:"7b51259246dd7252f6a7215fb11fbeabfabafb0f8856afae525af8feb81d3490":hex:"c625853da9fdb8665264c30539a258ba61da8bbd214f3f493e292f686dce73c003aea5c4070ea94b19e486019b18a2f3f1d836b85414bab14eb99baa283cafffabc8498cf1151489a6a6a0d01e7041633c94f9cc6cc3dfcd661c9c4a0bf77d9be168eec29cb0efef33c74d2dad18ae2ac2b5efb519f4c1f12eaa7a7d7959e7a6dec681e4d1878b20054b7925d2da0b2f8730604445ff3fca3a06285a4a2d86648f10a2bc3cd422646f70224ec9025e7ce701c8b521c0392fd7d2ac883f2a37bb7e4d53a92a620e65e090b91dbcdd616a13b3948eb1b5a6b1bde80f03dad61aba3223fd91ca3df68b0749fd049813a7ab0268445793b16677bc1af00f877097cb14798777ac817d0df82507aec246f755ddf95b19bb56ef9f2e730bcf2863648d8b164656df37977d54eaf05063b0ee8ba61c2a2ba7dda8fae337d5f6ba965d9e643b4534ed9f4eea7b2b26680fff50260e245fa0d63139b40e2f152da3a976589e957be22cb0885cd582aa9468b08f08a22b486767a6b99c1778ecbd763ebfe2bd83c6191f4e8a84972e4920452b2b2dd28be5d7bda05dc3422419793ca8c26defd3b42b2cc99bbad98e7461f034abf137d7b3166c94e20bdba091653c6a17ccc4faf86a7ba6d2abc0ecada9103e73d9ee4659b6e991a1a209d2ebd96c24759c69ad13a03431ddc05abc20dc8581b1e526f4d98f6352ca4c77f5479db234125fa585ba275fbcbdbf":hex:"":exp:7
NIST KWP unwrap AES-128 CAVS 21.4 PLAINTEXT LENGTH = 8 count 2
depends_on:0
6:exp:0:exp:6:hex:"20501013aa1578ab32704a4287029098":hex:"382179a39d75756f57763486d038b50f":hex:"14":int:0
NIST KWP unwrap AES-128 CAVS 21.4 PLAINTEXT LENGTH = 64 count 5
depends_on:0
6:exp:0:exp:6:hex:"a099fff482dbaeb53aad84f81b916da0":hex:"b831c7137facaed059cbf268767e230f":hex:"0d24299443bcc444":int:0
NIST KWP unwrap AES-128 CAVS 21.4 PLAINTEXT LENGTH = 72 count 0
depends_on:0
6:exp:0:exp:6:hex:"4d49e260348172c38a79eb925b189b12":hex:"54755a93ff5173aec60d1eaa8fd7d4090f00f638c2831aa9":hex:"2bbe64479da7c45976":int:0
NIST KWP unwrap AES-128 CAVS 21.4 PLAINTEXT LENGTH = 248 count 3
depends_on:0
6:exp:0:exp:6:hex:"6a5a5ac4ccedf055d7562ac58ee7819c":hex:"46904a5583e8a22f4b2f5aa8d071f5cbfc938130f1b33f2e6401aee7cccdef2159a89c9b682cfaf4":hex:"33ac6837955300e569b29958985cdbd434c18208779a949d20b110b0b719e1":int:0
NIST KWP unwrap AES-128 CAVS 21.4 PLAINTEXT LENGTH = 4096 count 0
depends_on:0
6:exp:0:exp:6:hex:"1dd51f0d3a0a784174ba81b2c9f89005":hex:"e1bde6d2df3b8e48ca127f97b56b5dc2672b3736cc3157c7b80a0316ef1efbdbbce19fea23da831836ccd2e002b2c1dfad206b5cec358446b8434d7f4c39e65b0e0b50897642ffc34bfb3cb3e233aa9c1058ff0d4fd48e98bc8cc3d214c06d514dd97db2278093a308f91f4ae92626d85771fb1447b36a3467fff02ac7e81ddbd0fdbcd02d1acd4f053c989ef3dcc2c01e23bc2f6090f3e8c0ba5f0082341200b1c37b99daa9cb6fec78bce3429aec5badb9fd28fdbdbdc5d53570675a9e39535b4594095658ef950ecd79a162223b60d2eb91765e022dc6e1bbdd86f1bcc280ed9df350da08a801fa16a1bf2701947acfb08f19fdfcaa1d76f466a5de2458a78fb82f6af3e1be68f405a4289f25896f4c9830005c9e895c86e67eceab0ad544856071b8d9585835b5e85a07ab01515f7ab54f98dffb4ca49a15068eefc6a01f7f52fd1adbe3631c59f6f43f79d2b4f2a691e2b30bb1d43a848dc3ee39c7f2e50f0c9deb7ab51e33bf40903ac255bb1510fd61676a6c13c3c776b8aacc6cefb95e24973ebb11192e2692dd0c6a085b58f86e11cc28ee2194988c123e3666da7339c0a4ac6afbacc83f1f100fbb39efff7cc605c9213828224a17c476395aeb9bb0a3150fb8889a8c2a494c8c526203f261642bfa69a94b86de9e6d3d932fe20fffe4bd76d502c0d437a3e1d0d8727b7a8dc0e361967109e93566326b6c517663731c4c9bdd0295d8":hex:"1a4eed4bf5b8d2e2a58f1f1277f164cc32cdadaed848f76fe634034082ff9aa1711870bf3936d01a2aa48de30de5143b9148cf56f4490f9d480dda0b672e8e17a012cd26cec3c68837bd5b2f9beb13e0110f21c6c36343e09e027f39557d1596d4ca406e3e7aa113e9bb8623106bae25f0ea23d46bc29970ba2596f83fe4f73a6f978a4d949fa7c271570a2ae5d2b50792d5ab5c43d455f359fb83c35ca3da37cd73cd66b6adce94d78ecdeabf667daa47ea70799af299e1d898ccf3fca6c42c6fff8cf2ec992f596fed4a0cdb502a00f9b5689302931d15cba691e2f8079a0411332438b714ace5234b91e4aebee8f8dda0e1968c2016fed350430a65d8d206c9436f40b79ce03083b8dc207d6960be1ce97007ed22a388ebb7b3d8f7d2b7d9f8f49731fbcb21e21db0cdd15674c795d5af2b2cd727f83e634e8c47157ed0c6873a5c9419e683f16f4a7827b444967812f9d1adb9201b89a0e66bbcf0591465f5d7036a21cdda0e10099feb819dfc37fdd3105120044dab716882d3971f312e3f4459006fd5a1eab08ff63edf6718f47ddaa37f7f40c9c372995f3aec97bc45e287b64fc8cf5559ab04a4d4d3ed482f5d61d3abd99cc87ee406da3ab9c9cd22ba3b8d191b26754aa94a2412f39e332d77fe72210adb0cbb5c96adebdbde036f1f1aaafad74a7ac2594f81efa734054e2e16dc931d49b970b81756862705fcd4":int:0
NIST KWP unwrap AES-128 CAVS 21.4 PLAINTEXT LENGTH = 8 count 1
depends_on:0
6:exp:0:exp:6:hex:"30be7ff51227f0eef786cb7be2482510":hex:"7f61a0a8b2fe7803f2947d233ec3a255":hex:"":exp:7
NIST KWP unwrap AES-128 CAVS 21.4 PLAINTEXT LENGTH = 64 count 7
depends_on:0
6:exp:0:exp:6:hex:"9ad15907cd05d77b844816b1dd806c92":hex:"7aa0e5d322363afbdd71b531e50d4935":hex:"":exp:7
NIST KWP unwrap AES-128 CAVS 21.4 PLAINTEXT LENGTH = 72 count 5
depends_on:0
6:exp:0:exp:6:hex:"2005cbe9cc66a35cafdff1af119ae6ce":hex:"60f9c736ec3619efdcc7cccc6b90ae5cdb8bb9eceea5dd96":hex:"":exp:7
NIST KWP unwrap AES-128 CAVS 21.4 PLAINTEXT LENGTH = 248 count 5
depends_on:0
6:exp:0:exp:6:hex:"2c3b49efbf60ed01a3ef27ee24ac90b0":hex:"5fa5a87bec09a3e05864656f8966cd38e1c4af48a06b1dab4ec9cca35dd0f92b54015fe5332bdef9":hex:"":exp:7
NIST KWP unwrap AES-128 CAVS 21.4 PLAINTEXT LENGTH = 4096 count 2
depends_on:0
6:exp:0:exp:6:hex:"4b4c43c9de4fb4a2a7a7adafeabe2dbd":hex:"6e4d08b8124f7d3e23303fac1a842014f95e3d71c438f8f1990307842796dc5e404ad81802e35c183fe000390a12c81ee684c5cf26c1d90e414cfffe6931b0f352936fcf0b31429eb5c7612cc359a15371390e518cf5c6a6bff1bb0348d14e2c39b98c9f30672ed2af1d96296df8b5567db25b9510a2083461810e119735490058ed1b46b7fdfa885041d8749f90a072b43ba49f2f51fbcda0dbf3cf99fca1d8f46330e5f6fe079d6679cfa26214c8831b782aaa023a2e0ea91050d277dab876aa6865f2bb3fc1a4a77db52f6179d5e5325993280948b6b7002b572829641d35ed3d735d8423e5b24673c4570ca25064fc2c2ad4840632536bcfaf2a7a814f3eaed92b4d501bc51c1719a0d8d8f420b66db845682bb41c88038cfedf13417143a3a701b521a9bf0bb639875a728c3b5ce6ca7e7a45bc75285c193902e6b5e7a4c6e720493d3937bf485e587bff894f70fd6165a1d0129cc673a992e0a4f5489d228a066b1df60002ec0521924f8d672cd1452fec927e58e75807b2a390256f920743fa4d0fc8f59f2469a595ef65095ca0c80adfc843e9e69b6d4a3f824af47b2bfbf2a7a6c1b650378f096f6f0bfabc752c8f279d4f45d56d09dce97962c119de3a64d83b93ea55066f24d4238a229ae86e6a7857af1d8aba823370a72fe358046049a84a70213ef31d9e77a722def8e21480e79b71299438070946bd459a7251707446c911e381":hex:"":exp:7
NIST KWP unwrap AES-192 CAVS 21.4 PLAINTEXT LENGTH = 8 count 2
depends_on:0
6:exp:0:exp:6:hex:"716da5cce5877d8f305b5478d671f6c73eb1bff4de15df07":hex:"dbd5247ad2445575cafb00ee7707c218":hex:"bf":int:0
NIST KWP unwrap AES-192 CAVS 21.4 PLAINTEXT LENGTH = 64 count 5
depends_on:0
6:exp:0:exp:6:hex:"b94bc10b85a8c2f74a66fa723a25ea1b398a4f627efe1ce0":hex:"18eef64a022b2c7db27648cbb5f1d5e6":hex:"19c0f2f78606fae7":int:0
NIST KWP unwrap AES-192 CAVS 21.4 PLAINTEXT LENGTH = 72 count 0
depends_on:0
6:exp:0:exp:6:hex:"f61cde8e515d59a8ca95efb1a98ed4216c4a9649151babf2":hex:"83fce85e9bfc6ed784b052472e5780fee662f17a91faf1a9":hex:"1c6883862ede37b31b":int:0
NIST KWP unwrap AES-192 CAVS 21.4 PLAINTEXT LENGTH = 248 count 3
depends_on:0
6:exp:0:exp:6:hex:"1c883af75147bae6f34205cd656ad30ec97e617456591ce6":hex:"f24f6747711cf72fab0422026c6d548ccdba786d77ab900ac3fb8f39f116d38e92c82d5fd9a045dd":hex:"bdd793f086d8733f69055bd79bbc448be857286e918fd4c54be4acf4eca5e4":int:0
NIST KWP unwrap AES-192 CAVS 21.4 PLAINTEXT LENGTH = 4096 count 0
depends_on:0
6:exp:0:exp:6:hex:"1b38d4b366f844e71a8db6be2b77a05a9e81720d2d3f31ee":hex:"62ddc158ecb048250bde439dc7aad34dbe7667d330a349026266c24cee9742953b623d1e247e501641b45b60cfbab665e68040ce06ebce478d9d77f5f344943a1edb14f0d9f165ecfe407031707961fedcd016559228bff5761cd6542944a5d86f9acf4e0a4114682c2312b8d4e8285d3efe1a7c1526642c73c332a9e484377a1c86714e3cb687781928c8a5fe28b4aa74e79f53ecd00793e00041b39b172e5fedef3d4164dcc6b2d2e47994e73f2ab048a4adb8cd94fcd7767314ae40f8cdbef2b26d25f74277a2f88f1de56342a0ec97fde4df2d052e6ebc62622f65725d845f670a647808666c7325725a3428e26fefe725c2badb8a8b8f04e30456bd1fd39fd0f7c782b7a2bc9d8c53922a54c5f103551271af6d7243133b96cd1c108811e4beb9a56472c1f9823a1e88832c5505e07cb93b9041f4b8d69cd27403680a18bb3848c269babbc52aaf568ee8245f4f72e177257103dd4bdffeee9b48e0660d6c2f4dfdce52462d0ed5cc5114dc0aa5a35601c9a644a1fdd3c57c3153e65a108eb94eea3bc9979a67a2f569eb7398a4bd24547c15faa361bb2950a379a1cad1737f56e7c210652aaea7581f39f07ee09a101fde8c34c3cfc404f2b8f682735fc4c721eceb4bd2295d8a74ee3cb858329509eba9049e7e791e04d8452b50c6e6225b94a8cc10ec1d262588fd2f05eee08113414e770c83caa84d310559286c393799117c177089a2":hex:"b1c88d3e5648218ee085abcfcaf7f362f33e4d6de363cb84182af9f18a31475f0e14ae8eff76ca67455726392a110ca262b90d040abf49beb036db096be053d493787a67e983b63945277044acf648172c75b38d7f81dcd58e3bbcecb963dc95863877784ac04eba83481152c30b1ca9e9b78fe537deee6c95933e1b5fb414cfaf7ca1dbbae8b114f0538f4cbf433ef214b776faec9ce1d29f680f4c88ff7b9ba0e964898dd253f5f82ec9f25663ece9dbff5e284f63b0e0fd07fb13b41aa8359f1ba1666bcb26e65d28b1f899952beb28b8f902f048e31efb6ab4817cafc6d84c7f4676b50936715667a67df7ca965b3ab2a5fc472375b1446c810242eb1cb78b9ac496ed4715e0f89a4e1ae0e2724edd59c954f54196ab55ac1947528fa14e716b7707aeb023bd0a2242da7ac97f3feb7795d9be05cd5b1cc33095599ab4c4d8d583c9e2a4d4ed12b836722370569737fae2d6fa60c8a5b8a80fd71129fe29395746eb746528a8845c5a9d50e7bc4372e7f3f9c6333feec791529a6ae1bc0f620feb604f56969e4ea3445810c72dd0772856feb58f09796f461f7ab1b454c303c810eec7526aeb397520b6114f57a4d906e974e8d4a910afafbb0f030b18887b951052d18578022cb7e33408578cdca34f32012f62d3dd35cb74e9d0fecac52231c5cf5a34d470d3b5413644c4e2af1f1613093a3b0550f8df26d033a35b9b":int:0
NIST KWP unwrap AES-192 CAVS 21.4 PLAINTEXT LENGTH = 8 count 5
depends_on:0
6:exp:0:exp:6:hex:"df8f5124b1e03228f2b96f0df31924bac1d3b5d094da22e6":hex:"230bb26c1ea9d5c8fcf7c122ea994f41":hex:"":exp:7
NIST KWP unwrap AES-192 CAVS 21.4 PLAINTEXT LENGTH = 64 count 7
depends_on:0
6:exp:0:exp:6:hex:"94c8dae772a43b5e00468e0947699b239dfe30ab5f90e2f6":hex:"239c6bceee3583fe7825011e02f01cc0":hex:"":exp:7
NIST KWP unwrap AES-192 CAVS 21.4 PLAINTEXT LENGTH = 72 count 5
depends_on:0
6:exp:0:exp:6:hex:"d81b7162dc6e9e18bea6e258bddb53a1c9f22a4a7177d9dd":hex:"4f3a2b7b229a665776f9cfa42e0c2a615a81f69cc0f0f465":hex:"":exp:7
NIST KWP unwrap AES-192 CAVS 21.4 PLAINTEXT LENGTH = 248 count 1
depends_on:0
6:exp:0:exp:6:hex:"688833d56cf1a0f492bf1f7e35c2fa6299a2b1b5ca2a2823":hex:"4b7c17d7a7189e7955c03abb0ca95fc0c780953787972097ae596d46fe2a8cd75995e6309780ae5f":hex:"":exp:7
NIST KWP unwrap AES-192 CAVS 21.4 PLAINTEXT LENGTH = 4096 count 2
depends_on:0
6:exp:0:exp:6:hex:"4b0faa630930b0ff8e624aeb4ddfa018a858cfa653132675":hex:"1640db081e87ef7797a9f17509f5bc67d40beaef096131748f413cac3d2500462b61140b31bc3965958af51351903549e4a71db589a6bc67d72ec33b8605a25a539a2043704389e3e0781152dffa9b64d6ec186ed144847434345e6dccefbe26626eebc4c22e3957b2145c46fa11d7819d4195cb43a9db8d2de507c023607548b56a07628ce4c706939fde1bdef8364b2b8fb7db30fc5c8e99f29876130d9f71a8486d99f2c7fc09f646918d4c60e53c7b9f9a8a1e9a023d70448f6b79c3f35cc6b9ace0535147f7f27be66d918895b9106cc83eda1aacdc2bfb7daa75b2867ae63109ecbf9423526511c64c4261e395d9b5a68dd2503ada57cf1b8a18336b8d63d248ec4dedb6e30662336546c86ef83b53504bc3bedd85a027b6b9f0323bd9380d9ba696b77072d98f96b77f9b3ad9e219715122b2dd033529eaf7ecced8be6d1e6467b8e4a61105be9b7a7ce208b6dd6bd34481f80b3bf534fb87904d45986931a088480a8040047c681dc4e8ec1c625a5449d9ab28709d04989c4b1a4ef0f1e379d37fe6f0641b9e705207e9a0652463cd5da71cd50321116d4ff1cbae08063df336482eadc0d117bf119e01f2577afe182e7fa477ec53b754e347a2c742960b9bd355f969e6ae1df2210e75bb44c598b683dd4c8692f4cd1b92125ac9ed10ec4cef6289d3f815cb894e74dff0bb72d51c43cb420d74a31c681c10ad7f9258d77f1f186c926a":hex:"":exp:7
NIST KWP unwrap AES-256 CAVS 21.4 PLAINTEXT LENGTH = 8 count 2
depends_on:0
6:exp:0:exp:6:hex:"da862b25a629d328cf9fac7be0d6ead1cb2404e9bab87a2381a46eb1a81187c5":hex:"5e01a2b9b8413f303a3578d2cc255fda":hex:"d4":int:0
NIST KWP unwrap AES-256 CAVS 21.4 PLAINTEXT LENGTH = 64 count 5
depends_on:0
6:exp:0:exp:6:hex:"362586d516d38e4d58b50a441443e75064cf6d6cdb6420862932ba7b0480b0fd":hex:"ea7ee0f5af3a271a9777838ed13c61af":hex:"f1b92d0db744bfee":int:0
NIST KWP unwrap AES-256 CAVS 21.4 PLAINTEXT LENGTH = 72 count 1
depends_on:0
6:exp:0:exp:6:hex:"0e6d542f960c7e61ca190d7fd719fda157030a0a013164613a8c522b52ae685d":hex:"b5cae8a82095abb3478ab167dbc0201d2f4dfc5f81bbe44e":hex:"a957eb4ea02e68ba8b":int:0
NIST KWP unwrap AES-256 CAVS 21.4 PLAINTEXT LENGTH = 248 count 3
depends_on:0
6:exp:0:exp:6:hex:"0445b86d13b7b76c0089a63dec70c32fded9607af63714b7c3cc724f49c1c6e2":hex:"7f63167976e71e43b7b135c8cd12148f826f56e73f6fb6e7f6cefa23c34302ff374d44dd66b6bb01":hex:"7af8c3b32e61f8b5c027383a273927b8fd09b75692bd0b713ec8ecec0bdd2c":int:0
NIST KWP unwrap AES-256 CAVS 21.4 PLAINTEXT LENGTH = 4096 count 0
depends_on:0
6:exp:0:exp:6:hex:"08f5c088acec18e6cf1f03a8f85d772e327e7fb07f8c2939eb554e84c42ab93d":hex:"dff30fd43647d4be54cf2dfd6187e2ddffb55267313f980fb09c833a9c2bfa558a95861711f0acb2a5c7e731ba22f24a9c4dfdd9e9b0216e9088f817a175b9835b0e17615687a20f68c067205626494cd04fbabc0b3eea7c0a4cd6236bc8b3e52e721dfc357fb8a3722bfcc4c690d8f63dbb864bb6e3a15805aea7270f8eb748deebaa2d066fcda11c2e67221f9a91d2c29a6c79ffae76aa80a2590b4f9e35f623fbf2f8ceb2a205493077556a186e25e5bd52dcff7bcc6909b37a66c1d1431be1b363bb40da25386eaaf5fcabc7be6422a04434a21d1d3105328e7c56770b9f59b03395e4138f5f06fc7e6b80dab87b08caa7bfffc45a095c15263efd3f06c651ded6f58074efc20620d704997fc84721a0a8e9e5b9f5cd330bbb156b31d9d1b1c260e4a24535f30404dc5b2dd6b35d916a1391b25a7d8790be09d85483ed1522074a2785812005bda10dd55acb245b3bd3d9bb777dd23f9b02538ba1a114ba53386d7ca4d9524b2f8a18e0ffb21580b560540bb2146f08f04974b90eb324547d56222df95f44bc6e5f183bef283e4816fb1b2933f9c7c6726a245a495e304d8318d0008c51b0be8090f8f668fbc3f31e073be4b9e97468f4dd8c798e9d682868df493db8a85738b58cfd005190f365849072577772672c6f82555c65046eb34e86fe61103327a063bacbbe33cea7eaa3d1de45471b7269e1b6b38608626e323447a3d5fe0599a6":hex:"8b68f66a3d2f59d419851b94d9a6f2f0e667f8125e11d463a6bc2cea46b12dcc40ce8018b204972c735fdd6d2d05b628f4905c6690f5ac5b1b51e12f3af2dc3ae9b9dab616f0a2a66a1ac197592fd5b15900547f32f54110b58d51a0340aa80e9eeb7b2e0eb97e80aa22ba918f2fe1c678c730ed5c3d8d24774f17d8ab6e01a06243d36e764df1dbb8af1faadbc55281f0242abd7a162c984fd0b05ab8b0bcaedffb2962024f009a8d7c9e71281c09f52ec0707ee3bbeb1ecb918be6ae3e9c1fabbcd3512af928db3ba6c109ff9e9839a616b2a53f092160a48222b84d53cd52490515ef93e1ebb33897263492ab8ec6fad2e633276ae367f76d7f926309478c0205d4f22506a451795dc98f5410d8f5d3e049cbedf381620861e7b4ae08f2d8a71abc1f230248cb636a2d7b4e7717ab2b7b5f2dc6e5b5a18e8043254208b50fd6f8929eaf974c48551233661ad67321b64d69245d536d9a8ca2a6a10966dddb9d2ce36641c9281c460ae524b077867258f638e6ac872cb5f5c6fb216b1ae60a9d0c5ea0dbcd060f255da26111175af4e9935df59ddade6a2a70cddff8cae6a98e4f3843c2dd59d09053b07b648a46f5de0eb21ebb192828279a386ea3eedf2cdc355d73d51111e8c1d522e059752bc56226a4225bcab713bfaaaec78167d7cfd33e913b26fda93ca7524aa8a8b17977c88ff9bc23ea810b4de59eac18d1523b":int:0
NIST KWP unwrap AES-256 CAVS 21.4 PLAINTEXT LENGTH = 8 count 5
depends_on:0
6:exp:0:exp:6:hex:"5fc3ef43eef256993fb00e6ccc90f60319f10a3bc9fe5ca4ec876c165e2a7720":hex:"f3d922a948969acca293bc3daa027e48":hex:"":exp:7
NIST KWP unwrap AES-256 CAVS 21.4 PLAINTEXT LENGTH = 64 count 0
depends_on:0
6:exp:0:exp:6:hex:"398444df32841be9e699c64faa92630c834564b8384876dceb471c4056fc8299":hex:"30032c9a3ed00d29512d8c725fa86a4b":hex:"":exp:7
NIST KWP unwrap AES-256 CAVS 21.4 PLAINTEXT LENGTH = 72 count 0
depends_on:0
6:exp:0:exp:6:hex:"64b69233fe392c0bcda28a931cc3527b1a8f29235c1adf6256556c685cb89b9f":hex:"6b5fd75ad16eda04a8b29f1bc0411ae28befbad9e474f2d8":hex:"":exp:7
NIST KWP unwrap AES-256 CAVS 21.4 PLAINTEXT LENGTH = 248 count 2
depends_on:0
6:exp:0:exp:6:hex:"8c35fb77766d04f48d5b52275c5c5f31f568078419e5c2335918965fbe53cedd":hex:"bacccb1714dbaa4908c2654aa8dbb1ddbddd8ab819429b026619fb1c0fa75a8247372b2feeab1e1d":hex:"":exp:7
NIST KWP unwrap AES-256 CAVS 21.4 PLAINTEXT LENGTH = 4096 count 3
depends_on:0
6:exp:0:exp:6:hex:"1726706350c11e6883955f24ea11ab247ce3b2ab54d05e67ad9770b5564483dd":hex:"b006f26a67d0e1e2cbeb5c23b6b300adc1526d1f17bbe964fe8237ae244878158e6b04cb488786b5258ac973c3a2eafd7fcf3a7ca6c825155659fbc53d112bc78b3a770cf059fdd5e68f2b4bfa36de3721231102e5041c947fba3d906bff39592ec3901a398da23035f1190e99b58659330cc2e856ee87ad4197dcc7d16e1f062275bced1ed5cd82163ae3e58da7368dc2aadac855385bd4fa0b8baadef608d0a5c27172d12b88c70b136eeccf37f36364361a990dc50815743cab1636e661bff04ca8345520c30b935a060b450526b1d6ac09170e5b0a327b88f42327b85c9a621d2ca745963c2815a2bfcf509d50b6058ed6e67f369b5608d2aa885238b67d1b8e0d83f9464aa473bf109350fcc02e360c2619236cbfbf895b607895530d8d3d2e41450750dad05b1c37ef15db7fb4707597ac252e8e58d4c1ab2713b427643d198164c908b5d8ff36e9700157284009c7b283633d8b27b378bb65eff8aa59b5fe5e6437a1d53a99c106c2c4d033d3d23950e313a10eb31d68524ae9f8e4f56437acf66db3e8f77407a15bbff4b393e5559908993146d93c673d2aeb7d4cb8fc8d0169de7ed6e2bbe6ce9958a0f5d201419e7acb17e47da827ba380d6b3ad3b5a8c2101c5fb501110c727169065f23297947f538ab3ec165d61edc1f6a9e1735e9b7fc06d4d3406cf8f9c6a68b196cf262324a986705fbc802cdd2e6b4ebcf68e6bb9e793ae644":hex:"":exp:7
KW AES-128 wrap rfc 3394
depends_on:0
5:exp:0:exp:5:hex:"000102030405060708090A0B0C0D0E0F":hex:"00112233445566778899AABBCCDDEEFF":hex:"1FA68B0A8112B447AEF34BD8FB5A7B829D3E862371D2CFE5"
KW AES-192 wrap rfc 3394
depends_on:0
5:exp:0:exp:5:hex:"000102030405060708090A0B0C0D0E0F1011121314151617":hex:"00112233445566778899AABBCCDDEEFF":hex:"96778B25AE6CA435F92B5B97C050AED2468AB8A17AD84E5D"
KW AES-256 wrap rfc 3394
depends_on:0
5:exp:0:exp:5:hex:"000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F":hex:"00112233445566778899AABBCCDDEEFF":hex:"64E8C3F9CE0F5BA263E9777905818A2A93C8191E7D6E8AE7"
KW AES-128 unwrap rfc 3394
depends_on:0
6:exp:0:exp:5:hex:"000102030405060708090A0B0C0D0E0F":hex:"1FA68B0A8112B447AEF34BD8FB5A7B829D3E862371D2CFE5":hex:"00112233445566778899AABBCCDDEEFF":int:0
KW AES-192 unwrap rfc 3394
depends_on:0
6:exp:0:exp:5:hex:"000102030405060708090A0B0C0D0E0F1011121314151617":hex:"031D33264E15D33268F24EC260743EDCE1C6C7DDEE725A936BA814915C6762D2":hex:"00112233445566778899AABBCCDDEEFF0001020304050607":int:0
KW AES-256 unwrap rfc 3394
depends_on:0
6:exp:0:exp:5:hex:"000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F":hex:"A8F9BC1612C68B3FF6E6F4FBE30E71E4769C8B80A32CB8958CD5D17D6B254DA1":hex:"00112233445566778899AABBCCDDEEFF0001020304050607":int:0
KWP AES-192 wrap rfc 5649 [#1]
depends_on:0
5:exp:0:exp:6:hex:"5840df6e29b02af1ab493b705bf16ea1ae8338f4dcc176a8":hex:"c37b7e6492584340bed12207808941155068f738":hex:"138bdeaa9b8fa7fc61f97742e72248ee5ae6ae5360d1ae6a5f54f373fa543b6a"
KWP AES-192 wrap rfc 5649 [#2]
depends_on:0
5:exp:0:exp:6:hex:"5840df6e29b02af1ab493b705bf16ea1ae8338f4dcc176a8":hex:"466f7250617369":hex:"afbeb0f07dfbf5419200f2ccb50bb24f"
| 56,132 | 485 | jart/cosmopolitan | false |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.