mbedTLS
+
0
/1 examples
SourceVu will show references to
MBEDTLS_PRIVATE
from the following samples and libraries:
ESP-IDF
Symbol previews are coming soon...
Symbols
loading...
Files
loading...
Summary
Syntax
Arguments
Examples
References
Call Tree
Data Use
Class Tree
Override Tree
Implementations
Instances
Lifecycle
SourceVu
ESP-IDF Framework and Examples
mbedTLS
MBEDTLS_PRIVATE
MBEDTLS_PRIVATE macro
Syntax
Show:
Summary
Declaration
from
private_access.h:15
#define
MBEDTLS_PRIVATE
(
member
)
private_
##
member
Arguments
Argument
member
Examples
MBEDTLS_PRIVATE
is referenced by 1 libraries and example projects:
ESP-IDF
References
from
0/1
examples
Code
Location
#define
MBEDTLS_PRIVATE
(
member
)
private_
##
member
private_access.h:15
#define
MBEDTLS_PRIVATE
(
member
)
member
private_access.h:17
int
MBEDTLS_PRIVATE
(
nr
)
;
/*!< The number of rounds. */
aes.h:64
size_t
MBEDTLS_PRIVATE
(
rk_offset
)
;
/*!< The offset in array elements to AES
aes.h:65
uint32_t
MBEDTLS_PRIVATE
(
buf
)
[
68
]
;
/*!< Unaligned data buffer. This buffer can
aes.h:71
mbedtls_aes_context
MBEDTLS_PRIVATE
(
crypt
)
;
/*!< The AES context to use for AES block
aes.h:88
mbedtls_aes_context
MBEDTLS_PRIVATE
(
tweak
)
;
/*!< The AES context used for tweak
aes.h:90
unsigned
char
MBEDTLS_PRIVATE
(
nr
)
;
/*!< The number of rounds (12, 14 or 16) */
aria.h:53
uint32_t
MBEDTLS_PRIVATE
(
rk
)
[
MBEDTLS_ARIA_MAX_ROUNDS
+
1
]
[
MBEDTLS_ARIA_BLOCKSIZE
/
4
]
;
aria.h:55
unsigned
char
MBEDTLS_PRIVATE
(
next_merged
)
;
asn1.h:196
mbedtls_mpi_uint
*
MBEDTLS_PRIVATE
(
p
)
;
bignum.h:214
signed
short
MBEDTLS_PRIVATE
(
s
)
;
bignum.h:227
unsigned
short
MBEDTLS_PRIVATE
(
n
)
;
bignum.h:230
mpi_hal_write_to_mem_block
(
MPI_PARAM_M
,
0
,
M
->
MBEDTLS_PRIVATE
(
p
)
,
M
->
MBEDTLS_PRIVATE
(
n
)
,
num_words
)
;
bignum_alt.c:69
mpi_hal_write_to_mem_block
(
MPI_PARAM_X
,
0
,
X
->
MBEDTLS_PRIVATE
(
p
)
,
X
->
MBEDTLS_PRIVATE
(
n
)
,
num_words
)
;
bignum_alt.c:70
mpi_hal_write_to_mem_block
(
MPI_PARAM_Z
,
0
,
Rinv
->
MBEDTLS_PRIVATE
(
p
)
,
Rinv
->
MBEDTLS_PRIVATE
(
n
)
,
num_words
)
;
bignum_alt.c:76
mpi_hal_write_to_mem_block
(
MPI_PARAM_X
,
0
,
Y
->
MBEDTLS_PRIVATE
(
p
)
,
Y
->
MBEDTLS_PRIVATE
(
n
)
,
num_words
)
;
bignum_alt.c:84
mpi_hal_write_to_mem_block
(
MPI_PARAM_X
,
0
,
X
->
MBEDTLS_PRIVATE
(
p
)
,
X
->
MBEDTLS_PRIVATE
(
n
)
,
num_words
)
;
bignum_alt.c:97
mpi_hal_write_to_mem_block
(
MPI_PARAM_Z
,
num_words
*
4
,
Y
->
MBEDTLS_PRIVATE
(
p
)
,
Y
->
MBEDTLS_PRIVATE
(
n
)
,
num_words
)
;
bignum_alt.c:98
mpi_hal_write_to_mem_block
(
MPI_PARAM_X
,
0
,
X
->
MBEDTLS_PRIVATE
(
p
)
,
X
->
MBEDTLS_PRIVATE
(
n
)
,
num_words
)
;
bignum_alt.c:152
mpi_hal_write_to_mem_block
(
MPI_PARAM_X
,
0
,
Y
->
MBEDTLS_PRIVATE
(
p
)
,
Y
->
MBEDTLS_PRIVATE
(
n
)
,
num_words
)
;
bignum_alt.c:167
mpi_hal_write_to_mem_block
(
MPI_PARAM_M
,
0
,
M
->
MBEDTLS_PRIVATE
(
p
)
,
M
->
MBEDTLS_PRIVATE
(
n
)
,
hw_words
)
;
bignum_alt.c:182
mpi_hal_write_to_mem_block
(
MPI_PARAM_X
,
0
,
X
->
MBEDTLS_PRIVATE
(
p
)
,
X
->
MBEDTLS_PRIVATE
(
n
)
,
hw_words
)
;
bignum_alt.c:187
mpi_hal_write_to_mem_block
(
MPI_PARAM_Z
,
0
,
Y
->
MBEDTLS_PRIVATE
(
p
)
,
Y
->
MBEDTLS_PRIVATE
(
n
)
,
hw_words
)
;
bignum_alt.c:188
Z
->
MBEDTLS_PRIVATE
(
s
)
=
1
;
// The sign of Z will be = M->s (but M->s is always 1)
bignum_alt.c:192
mpi_hal_read_result_hw_op
(
Z
->
MBEDTLS_PRIVATE
(
p
)
,
Z
->
MBEDTLS_PRIVATE
(
n
)
,
hw_words
)
;
bignum_alt.c:196
mbedtls_block_cipher_id_t
MBEDTLS_PRIVATE
(
id
)
;
block_cipher.h:53
mbedtls_aes_context
MBEDTLS_PRIVATE
(
aes
)
;
block_cipher.h:61
mbedtls_aria_context
MBEDTLS_PRIVATE
(
aria
)
;
block_cipher.h:64
}
MBEDTLS_PRIVATE
(
ctx
)
;
block_cipher.h:69
int
MBEDTLS_PRIVATE
(
nr
)
;
/*!< number of rounds */
camellia.h:42
uint32_t
MBEDTLS_PRIVATE
(
rk
)
[
68
]
;
/*!< CAMELLIA round keys */
camellia.h:43
unsigned
char
MBEDTLS_PRIVATE
(
y
)
[
16
]
;
/*!< The Y working buffer */
ccm.h:70
unsigned
char
MBEDTLS_PRIVATE
(
ctr
)
[
16
]
;
/*!< The counter buffer */
ccm.h:71
size_t
MBEDTLS_PRIVATE
(
plaintext_len
)
;
/*!< Total plaintext length */
ccm.h:72
size_t
MBEDTLS_PRIVATE
(
add_len
)
;
/*!< Total authentication data length */
ccm.h:73
size_t
MBEDTLS_PRIVATE
(
tag_len
)
;
/*!< Total tag length */
ccm.h:74
size_t
MBEDTLS_PRIVATE
(
processed
)
;
/*!< Track how many bytes of input data
ccm.h:75
unsigned
int
MBEDTLS_PRIVATE
(
q
)
;
/*!< The Q working value */
ccm.h:81
unsigned
int
MBEDTLS_PRIVATE
(
mode
)
;
/*!< The operation to perform:
ccm.h:82
mbedtls_cipher_context_t
MBEDTLS_PRIVATE
(
cipher_ctx
)
;
/*!< The cipher context used. */
ccm.h:90
int
MBEDTLS_PRIVATE
(
state
)
;
/*!< Working value holding context's
ccm.h:92
uint32_t
MBEDTLS_PRIVATE
(
state
)
[
16
]
;
/*! The state (before round operations). */
chacha20.h:39
uint8_t
MBEDTLS_PRIVATE
(
keystream8
)
[
64
]
;
/*! Leftover keystream bytes. */
chacha20.h:40
size_t
MBEDTLS_PRIVATE
(
keystream_bytes_used
)
;
/*! Number of keystream bytes already used. */
chacha20.h:41
mbedtls_chacha20_context
MBEDTLS_PRIVATE
(
chacha20_ctx
)
;
/**< The ChaCha20 context. */
chachapoly.h:49
mbedtls_poly1305_context
MBEDTLS_PRIVATE
(
poly1305_ctx
)
;
/**< The Poly1305 context. */
chachapoly.h:50
uint64_t
MBEDTLS_PRIVATE
(
aad_len
)
;
/**< The length (bytes) of the Additional Authenticated Data. */
chachapoly.h:51
uint64_t
MBEDTLS_PRIVATE
(
ciphertext_len
)
;
/**< The length (bytes) of the ciphertext. */
chachapoly.h:52
int
MBEDTLS_PRIVATE
(
state
)
;
/**< The current state of the context. */
chachapoly.h:53
mbedtls_chachapoly_mode_t
MBEDTLS_PRIVATE
(
mode
)
;
/**< Cipher mode (encrypt or decrypt). */
chachapoly.h:54
const
char
*
MBEDTLS_PRIVATE
(
name
)
;
cipher.h:268
unsigned
int
MBEDTLS_PRIVATE
(
block_size
)
:
5
;
cipher.h:271
unsigned
int
MBEDTLS_PRIVATE
(
iv_size
)
:
3
;
cipher.h:277
unsigned
int
MBEDTLS_PRIVATE
(
key_bitlen
)
:
4
;
cipher.h:283
unsigned
int
MBEDTLS_PRIVATE
(
mode
)
:
4
;
cipher.h:288
unsigned
int
MBEDTLS_PRIVATE
(
type
)
:
8
;
cipher.h:296
unsigned
int
MBEDTLS_PRIVATE
(
flags
)
:
2
;
cipher.h:302
unsigned
int
MBEDTLS_PRIVATE
(
base_idx
)
:
5
;
cipher.h:305
const
mbedtls_cipher_info_t
*
MBEDTLS_PRIVATE
(
cipher_info
)
;
cipher.h:318
int
MBEDTLS_PRIVATE
(
key_bitlen
)
;
cipher.h:321
mbedtls_operation_t
MBEDTLS_PRIVATE
(
operation
)
;
cipher.h:326
void
(
*
MBEDTLS_PRIVATE
(
add_padding
)
)
(
unsigned
char
*
output
,
size_t
olen
,
size_t
data_len
)
;
cipher.h:332
int
(
*
MBEDTLS_PRIVATE
(
get_padding
)
)
(
unsigned
char
*
input
,
size_t
ilen
,
size_t
*
data_len
)
;
cipher.h:333
unsigned
char
MBEDTLS_PRIVATE
(
unprocessed_data
)
[
MBEDTLS_MAX_BLOCK_LENGTH
]
;
cipher.h:337
size_t
MBEDTLS_PRIVATE
(
unprocessed_len
)
;
cipher.h:340
unsigned
char
MBEDTLS_PRIVATE
(
iv
)
[
MBEDTLS_MAX_IV_LENGTH
]
;
cipher.h:344
size_t
MBEDTLS_PRIVATE
(
iv_size
)
;
cipher.h:347
void
*
MBEDTLS_PRIVATE
(
cipher_ctx
)
;
cipher.h:350
mbedtls_cmac_context_t
*
MBEDTLS_PRIVATE
(
cmac_ctx
)
;
cipher.h:354
return
(
mbedtls_cipher_type_t
)
info
->
MBEDTLS_PRIVATE
(
type
)
;
cipher.h:443
return
(
mbedtls_cipher_mode_t
)
info
->
MBEDTLS_PRIVATE
(
mode
)
;
cipher.h:462
return
(
(
size_t
)
info
->
MBEDTLS_PRIVATE
(
key_bitlen
)
)
<
<
MBEDTLS_KEY_BITLEN_SHIFT
;
cipher.h:483
return
info
->
MBEDTLS_PRIVATE
(
name
)
;
cipher.h:504
return
(
(
size_t
)
info
->
MBEDTLS_PRIVATE
(
iv_size
)
)
<
<
MBEDTLS_IV_SIZE_SHIFT
;
cipher.h:525
return
(
size_t
)
(
info
->
MBEDTLS_PRIVATE
(
block_size
)
)
;
cipher.h:545
return
info
->
MBEDTLS_PRIVATE
(
flags
)
&
MBEDTLS_CIPHER_VARIABLE_KEY_LEN
;
cipher.h:564
return
info
->
MBEDTLS_PRIVATE
(
flags
)
&
MBEDTLS_CIPHER_VARIABLE_IV_LEN
;
cipher.h:583
if
(
ctx
->
MBEDTLS_PRIVATE
(
cipher_info
)
==
NULL
)
{
cipher.h:681
return
(
unsigned
int
)
ctx
->
MBEDTLS_PRIVATE
(
cipher_info
)
->
MBEDTLS_PRIVATE
(
block_size
)
;
cipher.h:685
if
(
ctx
->
MBEDTLS_PRIVATE
(
cipher_info
)
==
NULL
)
{
cipher.h:700
return
(
mbedtls_cipher_mode_t
)
ctx
->
MBEDTLS_PRIVATE
(
cipher_info
)
->
MBEDTLS_PRIVATE
(
mode
)
;
cipher.h:704
if
(
ctx
->
MBEDTLS_PRIVATE
(
cipher_info
)
==
NULL
)
{
cipher.h:720
if
(
ctx
->
MBEDTLS_PRIVATE
(
iv_size
)
!=
0
)
{
cipher.h:724
return
(
int
)
ctx
->
MBEDTLS_PRIVATE
(
iv_size
)
;
cipher.h:725
return
(
int
)
(
(
(
int
)
ctx
->
MBEDTLS_PRIVATE
(
cipher_info
)
->
MBEDTLS_PRIVATE
(
iv_size
)
)
<
<
cipher.h:728
if
(
ctx
->
MBEDTLS_PRIVATE
(
cipher_info
)
==
NULL
)
{
cipher.h:743
return
(
mbedtls_cipher_type_t
)
ctx
->
MBEDTLS_PRIVATE
(
cipher_info
)
->
MBEDTLS_PRIVATE
(
type
)
;
cipher.h:747
if
(
ctx
->
MBEDTLS_PRIVATE
(
cipher_info
)
==
NULL
)
{
cipher.h:762
return
ctx
->
MBEDTLS_PRIVATE
(
cipher_info
)
->
MBEDTLS_PRIVATE
(
name
)
;
cipher.h:766
if
(
ctx
->
MBEDTLS_PRIVATE
(
cipher_info
)
==
NULL
)
{
cipher.h:781
return
(
int
)
ctx
->
MBEDTLS_PRIVATE
(
cipher_info
)
->
MBEDTLS_PRIVATE
(
key_bitlen
)
<
<
cipher.h:785
if
(
ctx
->
MBEDTLS_PRIVATE
(
cipher_info
)
==
NULL
)
{
cipher.h:800
return
ctx
->
MBEDTLS_PRIVATE
(
operation
)
;
cipher.h:804
unsigned
char
MBEDTLS_PRIVATE
(
state
)
[
MBEDTLS_CMAC_MAX_BLOCK_SIZE
]
;
cmac.h:61
unsigned
char
MBEDTLS_PRIVATE
(
unprocessed_block
)
[
MBEDTLS_CMAC_MAX_BLOCK_SIZE
]
;
cmac.h:65
size_t
MBEDTLS_PRIVATE
(
unprocessed_len
)
;
cmac.h:68
psa_algorithm_t
MBEDTLS_PRIVATE
(
alg
)
;
crypto_builtin_composites.h:47
uint8_t
MBEDTLS_PRIVATE
(
opad
)
[
PSA_HMAC_MAX_HASH_BLOCK_SIZE
]
;
crypto_builtin_composites.h:51
psa_algorithm_t
MBEDTLS_PRIVATE
(
alg
)
;
crypto_builtin_composites.h:58
unsigned
MBEDTLS_PRIVATE
(
dummy
)
;
/* Make the union non-empty even with no supported algorithms. */
crypto_builtin_composites.h:60
mbedtls_psa_hmac_operation_t
MBEDTLS_PRIVATE
(
hmac
)
;
crypto_builtin_composites.h:62
mbedtls_cipher_context_t
MBEDTLS_PRIVATE
(
cmac
)
;
crypto_builtin_composites.h:65
}
MBEDTLS_PRIVATE
(
ctx
)
;
crypto_builtin_composites.h:67
psa_algorithm_t
MBEDTLS_PRIVATE
(
alg
)
;
crypto_builtin_composites.h:80
psa_key_type_t
MBEDTLS_PRIVATE
(
key_type
)
;
crypto_builtin_composites.h:81
unsigned
int
MBEDTLS_PRIVATE
(
is_encrypt
)
:
1
;
crypto_builtin_composites.h:83
uint8_t
MBEDTLS_PRIVATE
(
tag_length
)
;
crypto_builtin_composites.h:85
mbedtls_ccm_context
MBEDTLS_PRIVATE
(
ccm
)
;
crypto_builtin_composites.h:90
mbedtls_gcm_context
MBEDTLS_PRIVATE
(
gcm
)
;
crypto_builtin_composites.h:93
unsigned
MBEDTLS_PRIVATE
(
dummy
)
;
crypto_builtin_composites.h:125
unsigned
MBEDTLS_PRIVATE
(
dummy
)
;
crypto_builtin_composites.h:160
psa_algorithm_t
MBEDTLS_PRIVATE
(
alg
)
;
crypto_builtin_composites.h:192
uint8_t
*
MBEDTLS_PRIVATE
(
password
)
;
crypto_builtin_composites.h:194
size_t
MBEDTLS_PRIVATE
(
password_len
)
;
crypto_builtin_composites.h:195
mbedtls_ecjpake_role
MBEDTLS_PRIVATE
(
role
)
;
crypto_builtin_composites.h:197
uint8_t
MBEDTLS_PRIVATE
(
buffer
[
MBEDTLS_PSA_JPAKE_BUFFER_SIZE
]
)
;
crypto_builtin_composites.h:198
size_t
MBEDTLS_PRIVATE
(
buffer_length
)
;
crypto_builtin_composites.h:199
size_t
MBEDTLS_PRIVATE
(
buffer_offset
)
;
crypto_builtin_composites.h:200
unsigned
int
MBEDTLS_PRIVATE
(
dummy
)
;
crypto_builtin_composites.h:204
mbedtls_ecjpake_context
MBEDTLS_PRIVATE
(
jpake
)
;
crypto_builtin_composites.h:206
}
MBEDTLS_PRIVATE
(
ctx
)
;
crypto_builtin_composites.h:208
uint8_t
MBEDTLS_PRIVATE
(
data
)
[
PSA_TLS12_ECJPAKE_TO_PMS_DATA_SIZE
]
;
crypto_builtin_key_derivation.h:49
uint8_t
MBEDTLS_PRIVATE
(
left_in_block
)
;
crypto_builtin_key_derivation.h:71
uint8_t
MBEDTLS_PRIVATE
(
block_number
)
;
crypto_builtin_key_derivation.h:74
psa_tls12_prf_key_derivation_state_t
MBEDTLS_PRIVATE
(
state
)
;
crypto_builtin_key_derivation.h:76
uint8_t
*
MBEDTLS_PRIVATE
(
secret
)
;
crypto_builtin_key_derivation.h:78
size_t
MBEDTLS_PRIVATE
(
secret_length
)
;
crypto_builtin_key_derivation.h:79
uint8_t
*
MBEDTLS_PRIVATE
(
seed
)
;
crypto_builtin_key_derivation.h:80
size_t
MBEDTLS_PRIVATE
(
seed_length
)
;
crypto_builtin_key_derivation.h:81
uint8_t
*
MBEDTLS_PRIVATE
(
label
)
;
crypto_builtin_key_derivation.h:82
size_t
MBEDTLS_PRIVATE
(
label_length
)
;
crypto_builtin_key_derivation.h:83
uint8_t
*
MBEDTLS_PRIVATE
(
other_secret
)
;
crypto_builtin_key_derivation.h:85
size_t
MBEDTLS_PRIVATE
(
other_secret_length
)
;
crypto_builtin_key_derivation.h:86
uint8_t
MBEDTLS_PRIVATE
(
Ai
)
[
PSA_HASH_MAX_SIZE
]
;
crypto_builtin_key_derivation.h:89
uint8_t
MBEDTLS_PRIVATE
(
output_block
)
[
PSA_HASH_MAX_SIZE
]
;
crypto_builtin_key_derivation.h:92
psa_algorithm_t
MBEDTLS_PRIVATE
(
alg
)
;
crypto_builtin_primitives.h:53
}
MBEDTLS_PRIVATE
(
ctx
)
;
crypto_builtin_primitives.h:79
psa_algorithm_t
MBEDTLS_PRIVATE
(
alg
)
;
crypto_builtin_primitives.h:103
uint8_t
MBEDTLS_PRIVATE
(
iv_length
)
;
crypto_builtin_primitives.h:104
uint8_t
MBEDTLS_PRIVATE
(
block_length
)
;
crypto_builtin_primitives.h:105
unsigned
int
MBEDTLS_PRIVATE
(
dummy
)
;
crypto_builtin_primitives.h:107
mbedtls_cipher_context_t
MBEDTLS_PRIVATE
(
cipher
)
;
crypto_builtin_primitives.h:108
}
MBEDTLS_PRIVATE
(
ctx
)
;
crypto_builtin_primitives.h:109
psa_tls12_prf_key_derivation_t
MBEDTLS_PRIVATE
(
tls12_prf
)
;
crypto_driver_contexts_key_derivation.h:41
psa_tls12_ecjpake_to_pms_t
MBEDTLS_PRIVATE
(
tls12_ecjpake_to_pms
)
;
crypto_driver_contexts_key_derivation.h:44
attributes
->
MBEDTLS_PRIVATE
(
policy
)
.
MBEDTLS_PRIVATE
(
alg2
)
=
alg2
;
crypto_extra.h:62
return
attributes
->
MBEDTLS_PRIVATE
(
policy
)
.
MBEDTLS_PRIVATE
(
alg2
)
;
crypto_extra.h:74
size_t
MBEDTLS_PRIVATE
(
volatile_slots
)
;
crypto_extra.h:223
size_t
MBEDTLS_PRIVATE
(
persistent_slots
)
;
crypto_extra.h:226
size_t
MBEDTLS_PRIVATE
(
external_slots
)
;
crypto_extra.h:229
size_t
MBEDTLS_PRIVATE
(
half_filled_slots
)
;
crypto_extra.h:232
size_t
MBEDTLS_PRIVATE
(
cache_slots
)
;
crypto_extra.h:234
size_t
MBEDTLS_PRIVATE
(
empty_slots
)
;
crypto_extra.h:236
size_t
MBEDTLS_PRIVATE
(
locked_slots
)
;
crypto_extra.h:238
psa_key_id_t
MBEDTLS_PRIVATE
(
max_open_internal_key_id
)
;
crypto_extra.h:240
psa_key_id_t
MBEDTLS_PRIVATE
(
max_open_external_key_id
)
;
crypto_extra.h:242
uint8_t
*
MBEDTLS_PRIVATE
(
password
)
;
crypto_extra.h:1788
size_t
MBEDTLS_PRIVATE
(
password_len
)
;
crypto_extra.h:1789
uint8_t
*
MBEDTLS_PRIVATE
(
user
)
;
crypto_extra.h:1790
size_t
MBEDTLS_PRIVATE
(
user_len
)
;
crypto_extra.h:1791
uint8_t
*
MBEDTLS_PRIVATE
(
peer
)
;
crypto_extra.h:1792
size_t
MBEDTLS_PRIVATE
(
peer_len
)
;
crypto_extra.h:1793
psa_key_attributes_t
MBEDTLS_PRIVATE
(
attributes
)
;
crypto_extra.h:1794
psa_pake_cipher_suite_t
MBEDTLS_PRIVATE
(
cipher_suite
)
;
crypto_extra.h:1795
psa_jpake_round_t
MBEDTLS_PRIVATE
(
round
)
;
crypto_extra.h:1827
psa_jpake_io_mode_t
MBEDTLS_PRIVATE
(
io_mode
)
;
crypto_extra.h:1829
uint8_t
MBEDTLS_PRIVATE
(
inputs
)
;
crypto_extra.h:1831
uint8_t
MBEDTLS_PRIVATE
(
outputs
)
;
crypto_extra.h:1833
psa_pake_step_t
MBEDTLS_PRIVATE
(
step
)
;
crypto_extra.h:1835
unsigned
int
MBEDTLS_PRIVATE
(
id
)
;
crypto_extra.h:1853
psa_algorithm_t
MBEDTLS_PRIVATE
(
alg
)
;
crypto_extra.h:1855
psa_pake_primitive_t
MBEDTLS_PRIVATE
(
primitive
)
;
crypto_extra.h:1857
uint8_t
MBEDTLS_PRIVATE
(
stage
)
;
crypto_extra.h:1860
uint8_t
MBEDTLS_PRIVATE
(
dummy
)
;
crypto_extra.h:1863
psa_jpake_computation_stage_t
MBEDTLS_PRIVATE
(
jpake
)
;
crypto_extra.h:1865
}
MBEDTLS_PRIVATE
(
computation_stage
)
;
crypto_extra.h:1867
psa_driver_pake_context_t
MBEDTLS_PRIVATE
(
ctx
)
;
crypto_extra.h:1869
psa_crypto_driver_pake_inputs_t
MBEDTLS_PRIVATE
(
inputs
)
;
crypto_extra.h:1870
}
MBEDTLS_PRIVATE
(
data
)
;
crypto_extra.h:1871
const
void
*
const
MBEDTLS_PRIVATE
(
persistent_data
)
;
crypto_se_driver.h:89
const
size_t
MBEDTLS_PRIVATE
(
persistent_data_size
)
;
crypto_se_driver.h:96
uintptr_t
MBEDTLS_PRIVATE
(
transient_data
)
;
crypto_se_driver.h:103
size_t
MBEDTLS_PRIVATE
(
context_size
)
;
crypto_se_driver.h:315
psa_drv_se_mac_setup_t
MBEDTLS_PRIVATE
(
p_setup
)
;
crypto_se_driver.h:318
psa_drv_se_mac_update_t
MBEDTLS_PRIVATE
(
p_update
)
;
crypto_se_driver.h:321
psa_drv_se_mac_finish_t
MBEDTLS_PRIVATE
(
p_finish
)
;
crypto_se_driver.h:324
psa_drv_se_mac_finish_verify_t
MBEDTLS_PRIVATE
(
p_finish_verify
)
;
crypto_se_driver.h:327
psa_drv_se_mac_abort_t
MBEDTLS_PRIVATE
(
p_abort
)
;
crypto_se_driver.h:330
psa_drv_se_mac_generate_t
MBEDTLS_PRIVATE
(
p_mac
)
;
crypto_se_driver.h:333
psa_drv_se_mac_verify_t
MBEDTLS_PRIVATE
(
p_mac_verify
)
;
crypto_se_driver.h:336
size_t
MBEDTLS_PRIVATE
(
context_size
)
;
crypto_se_driver.h:502
psa_drv_se_cipher_setup_t
MBEDTLS_PRIVATE
(
p_setup
)
;
crypto_se_driver.h:504
psa_drv_se_cipher_set_iv_t
MBEDTLS_PRIVATE
(
p_set_iv
)
;
crypto_se_driver.h:506
psa_drv_se_cipher_update_t
MBEDTLS_PRIVATE
(
p_update
)
;
crypto_se_driver.h:508
psa_drv_se_cipher_finish_t
MBEDTLS_PRIVATE
(
p_finish
)
;
crypto_se_driver.h:510
psa_drv_se_cipher_abort_t
MBEDTLS_PRIVATE
(
p_abort
)
;
crypto_se_driver.h:512
psa_drv_se_cipher_ecb_t
MBEDTLS_PRIVATE
(
p_ecb
)
;
crypto_se_driver.h:517
psa_drv_se_asymmetric_sign_t
MBEDTLS_PRIVATE
(
p_sign
)
;
crypto_se_driver.h:673
psa_drv_se_asymmetric_verify_t
MBEDTLS_PRIVATE
(
p_verify
)
;
crypto_se_driver.h:675
psa_drv_se_asymmetric_encrypt_t
MBEDTLS_PRIVATE
(
p_encrypt
)
;
crypto_se_driver.h:677
psa_drv_se_asymmetric_decrypt_t
MBEDTLS_PRIVATE
(
p_decrypt
)
;
crypto_se_driver.h:679
psa_drv_se_aead_encrypt_t
MBEDTLS_PRIVATE
(
p_encrypt
)
;
crypto_se_driver.h:790
psa_drv_se_aead_decrypt_t
MBEDTLS_PRIVATE
(
p_decrypt
)
;
crypto_se_driver.h:792
psa_drv_se_allocate_key_t
MBEDTLS_PRIVATE
(
p_allocate
)
;
crypto_se_driver.h:1111
psa_drv_se_validate_slot_number_t
MBEDTLS_PRIVATE
(
p_validate_slot_number
)
;
crypto_se_driver.h:1113
psa_drv_se_import_key_t
MBEDTLS_PRIVATE
(
p_import
)
;
crypto_se_driver.h:1115
psa_drv_se_generate_key_t
MBEDTLS_PRIVATE
(
p_generate
)
;
crypto_se_driver.h:1117
psa_drv_se_destroy_key_t
MBEDTLS_PRIVATE
(
p_destroy
)
;
crypto_se_driver.h:1119
psa_drv_se_export_key_t
MBEDTLS_PRIVATE
(
p_export
)
;
crypto_se_driver.h:1121
psa_drv_se_export_key_t
MBEDTLS_PRIVATE
(
p_export_public
)
;
crypto_se_driver.h:1123
size_t
MBEDTLS_PRIVATE
(
context_size
)
;
crypto_se_driver.h:1254
psa_drv_se_key_derivation_setup_t
MBEDTLS_PRIVATE
(
p_setup
)
;
crypto_se_driver.h:1256
psa_drv_se_key_derivation_collateral_t
MBEDTLS_PRIVATE
(
p_collateral
)
;
crypto_se_driver.h:1258
psa_drv_se_key_derivation_derive_t
MBEDTLS_PRIVATE
(
p_derive
)
;
crypto_se_driver.h:1260
psa_drv_se_key_derivation_export_t
MBEDTLS_PRIVATE
(
p_export
)
;
crypto_se_driver.h:1263
uint32_t
MBEDTLS_PRIVATE
(
hal_version
)
;
crypto_se_driver.h:1284
size_t
MBEDTLS_PRIVATE
(
persistent_data_size
)
;
crypto_se_driver.h:1294
psa_drv_se_init_t
MBEDTLS_PRIVATE
(
p_init
)
;
crypto_se_driver.h:1306
const
psa_drv_se_key_management_t
*
MBEDTLS_PRIVATE
(
key_management
)
;
crypto_se_driver.h:1308
const
psa_drv_se_mac_t
*
MBEDTLS_PRIVATE
(
mac
)
;
crypto_se_driver.h:1309
const
psa_drv_se_cipher_t
*
MBEDTLS_PRIVATE
(
cipher
)
;
crypto_se_driver.h:1310
const
psa_drv_se_aead_t
*
MBEDTLS_PRIVATE
(
aead
)
;
crypto_se_driver.h:1311
const
psa_drv_se_asymmetric_t
*
MBEDTLS_PRIVATE
(
asymmetric
)
;
crypto_se_driver.h:1312
const
psa_drv_se_key_derivation_t
*
MBEDTLS_PRIVATE
(
derivation
)
;
crypto_se_driver.h:1313
unsigned
int
MBEDTLS_PRIVATE
(
id
)
;
crypto_struct.h:80
psa_driver_hash_context_t
MBEDTLS_PRIVATE
(
ctx
)
;
crypto_struct.h:81
unsigned
int
MBEDTLS_PRIVATE
(
id
)
;
crypto_struct.h:105
unsigned
int
MBEDTLS_PRIVATE
(
iv_required
)
:
1
;
crypto_struct.h:107
unsigned
int
MBEDTLS_PRIVATE
(
iv_set
)
:
1
;
crypto_struct.h:108
uint8_t
MBEDTLS_PRIVATE
(
default_iv_length
)
;
crypto_struct.h:110
psa_driver_cipher_context_t
MBEDTLS_PRIVATE
(
ctx
)
;
crypto_struct.h:112
unsigned
int
MBEDTLS_PRIVATE
(
id
)
;
crypto_struct.h:141
uint8_t
MBEDTLS_PRIVATE
(
mac_size
)
;
crypto_struct.h:142
unsigned
int
MBEDTLS_PRIVATE
(
is_sign
)
:
1
;
crypto_struct.h:143
psa_driver_mac_context_t
MBEDTLS_PRIVATE
(
ctx
)
;
crypto_struct.h:144
unsigned
int
MBEDTLS_PRIVATE
(
id
)
;
crypto_struct.h:169
psa_algorithm_t
MBEDTLS_PRIVATE
(
alg
)
;
crypto_struct.h:171
psa_key_type_t
MBEDTLS_PRIVATE
(
key_type
)
;
crypto_struct.h:172
size_t
MBEDTLS_PRIVATE
(
ad_remaining
)
;
crypto_struct.h:174
size_t
MBEDTLS_PRIVATE
(
body_remaining
)
;
crypto_struct.h:175
unsigned
int
MBEDTLS_PRIVATE
(
nonce_set
)
:
1
;
crypto_struct.h:177
unsigned
int
MBEDTLS_PRIVATE
(
lengths_set
)
:
1
;
crypto_struct.h:178
unsigned
int
MBEDTLS_PRIVATE
(
ad_started
)
:
1
;
crypto_struct.h:179
unsigned
int
MBEDTLS_PRIVATE
(
body_started
)
:
1
;
crypto_struct.h:180
unsigned
int
MBEDTLS_PRIVATE
(
is_encrypt
)
:
1
;
crypto_struct.h:181
psa_driver_aead_context_t
MBEDTLS_PRIVATE
(
ctx
)
;
crypto_struct.h:183
psa_algorithm_t
MBEDTLS_PRIVATE
(
alg
)
;
crypto_struct.h:206
unsigned
int
MBEDTLS_PRIVATE
(
can_output_key
)
:
1
;
crypto_struct.h:207
size_t
MBEDTLS_PRIVATE
(
capacity
)
;
crypto_struct.h:208
psa_driver_key_derivation_context_t
MBEDTLS_PRIVATE
(
ctx
)
;
crypto_struct.h:209
psa_key_usage_t
MBEDTLS_PRIVATE
(
usage
)
;
crypto_struct.h:269
psa_algorithm_t
MBEDTLS_PRIVATE
(
alg
)
;
crypto_struct.h:270
psa_algorithm_t
MBEDTLS_PRIVATE
(
alg2
)
;
crypto_struct.h:271
psa_key_type_t
MBEDTLS_PRIVATE
(
type
)
;
crypto_struct.h:300
psa_key_bits_t
MBEDTLS_PRIVATE
(
bits
)
;
crypto_struct.h:301
psa_key_lifetime_t
MBEDTLS_PRIVATE
(
lifetime
)
;
crypto_struct.h:302
psa_key_policy_t
MBEDTLS_PRIVATE
(
policy
)
;
crypto_struct.h:303
mbedtls_svc_key_id_t
MBEDTLS_PRIVATE
(
id
)
;
crypto_struct.h:315
psa_key_lifetime_t
lifetime
=
attributes
->
MBEDTLS_PRIVATE
(
lifetime
)
;
crypto_struct.h:338
attributes
->
MBEDTLS_PRIVATE
(
id
)
=
key
;
crypto_struct.h:340
attributes
->
MBEDTLS_PRIVATE
(
lifetime
)
=
crypto_struct.h:343
return
attributes
->
MBEDTLS_PRIVATE
(
id
)
;
crypto_struct.h:353
attributes
->
MBEDTLS_PRIVATE
(
lifetime
)
=
lifetime
;
crypto_struct.h:367
attributes
->
MBEDTLS_PRIVATE
(
id
)
=
0
;
crypto_struct.h:372
return
attributes
->
MBEDTLS_PRIVATE
(
lifetime
)
;
crypto_struct.h:380
attributes
->
MBEDTLS_PRIVATE
(
policy
)
.
MBEDTLS_PRIVATE
(
usage
)
=
usage_flags
;
crypto_struct.h:398
return
attributes
->
MBEDTLS_PRIVATE
(
policy
)
.
MBEDTLS_PRIVATE
(
usage
)
;
crypto_struct.h:404
attributes
->
MBEDTLS_PRIVATE
(
policy
)
.
MBEDTLS_PRIVATE
(
alg
)
=
alg
;
crypto_struct.h:410
return
attributes
->
MBEDTLS_PRIVATE
(
policy
)
.
MBEDTLS_PRIVATE
(
alg
)
;
crypto_struct.h:416
attributes
->
MBEDTLS_PRIVATE
(
type
)
=
type
;
crypto_struct.h:422
return
attributes
->
MBEDTLS_PRIVATE
(
type
)
;
crypto_struct.h:428
attributes
->
MBEDTLS_PRIVATE
(
bits
)
=
PSA_KEY_BITS_TOO_LARGE
;
crypto_struct.h:435
attributes
->
MBEDTLS_PRIVATE
(
bits
)
=
(
psa_key_bits_t
)
bits
;
crypto_struct.h:437
return
attributes
->
MBEDTLS_PRIVATE
(
bits
)
;
crypto_struct.h:444
unsigned
int
MBEDTLS_PRIVATE
(
id
)
;
crypto_struct.h:460
psa_driver_sign_hash_interruptible_context_t
MBEDTLS_PRIVATE
(
ctx
)
;
crypto_struct.h:462
unsigned
int
MBEDTLS_PRIVATE
(
error_occurred
)
:
1
;
crypto_struct.h:464
uint32_t
MBEDTLS_PRIVATE
(
num_ops
)
;
crypto_struct.h:466
unsigned
int
MBEDTLS_PRIVATE
(
id
)
;
crypto_struct.h:498
psa_driver_verify_hash_interruptible_context_t
MBEDTLS_PRIVATE
(
ctx
)
;
crypto_struct.h:500
unsigned
int
MBEDTLS_PRIVATE
(
error_occurred
)
:
1
;
crypto_struct.h:502
uint32_t
MBEDTLS_PRIVATE
(
num_ops
)
;
crypto_struct.h:504
unsigned
char
MBEDTLS_PRIVATE
(
counter
)
[
16
]
;
/*!< The counter (V). */
ctr_drbg.h:186
int
MBEDTLS_PRIVATE
(
reseed_counter
)
;
/*!< The reseed counter.
ctr_drbg.h:187
int
MBEDTLS_PRIVATE
(
prediction_resistance
)
;
/*!< This determines whether prediction
ctr_drbg.h:197
size_t
MBEDTLS_PRIVATE
(
entropy_len
)
;
/*!< The amount of entropy grabbed on each
ctr_drbg.h:201
int
MBEDTLS_PRIVATE
(
reseed_interval
)
;
/*!< The reseed interval.
ctr_drbg.h:203
mbedtls_aes_context
MBEDTLS_PRIVATE
(
aes_ctx
)
;
/*!< The AES context. */
ctr_drbg.h:210
int
(
*
MBEDTLS_PRIVATE
(
f_entropy
)
)
(
void
*
,
unsigned
char
*
,
size_t
)
;
ctr_drbg.h:216
void
*
MBEDTLS_PRIVATE
(
p_entropy
)
;
/*!< The context for the entropy function. */
ctr_drbg.h:219
uint32_t
MBEDTLS_PRIVATE
(
sk
)
[
32
]
;
/*!< DES subkeys */
des.h:49
uint32_t
MBEDTLS_PRIVATE
(
sk
)
[
96
]
;
/*!< 3DES subkeys */
des.h:61
mbedtls_mpi
MBEDTLS_PRIVATE
(
P
)
;
/*!< The prime modulus. */
dhm.h:102
mbedtls_mpi
MBEDTLS_PRIVATE
(
G
)
;
/*!< The generator. */
dhm.h:103
mbedtls_mpi
MBEDTLS_PRIVATE
(
X
)
;
/*!< Our secret value. */
dhm.h:104
mbedtls_mpi
MBEDTLS_PRIVATE
(
GX
)
;
/*!< Our public key = \c G^X mod \c P. */
dhm.h:105
mbedtls_mpi
MBEDTLS_PRIVATE
(
GY
)
;
/*!< The public key of the peer = \c G^Y mod \c P. */
dhm.h:106
mbedtls_mpi
MBEDTLS_PRIVATE
(
K
)
;
/*!< The shared secret = \c G^(XY) mod \c P. */
dhm.h:107
mbedtls_mpi
MBEDTLS_PRIVATE
(
RP
)
;
/*!< The cached value = \c R^2 mod \c P. */
dhm.h:108
mbedtls_mpi
MBEDTLS_PRIVATE
(
Vi
)
;
/*!< The blinding value. */
dhm.h:109
mbedtls_mpi
MBEDTLS_PRIVATE
(
Vf
)
;
/*!< The unblinding value. */
dhm.h:110
mbedtls_mpi
MBEDTLS_PRIVATE
(
pX
)
;
/*!< The previous \c X. */
dhm.h:111
return
ctx
->
MBEDTLS_PRIVATE
(
grp_id
)
;
ecdh.c:152
mbedtls_ecp_group
MBEDTLS_PRIVATE
(
grp
)
;
/*!< The elliptic curve used. */
ecdh.h:87
mbedtls_mpi
MBEDTLS_PRIVATE
(
d
)
;
/*!< The private key. */
ecdh.h:88
mbedtls_ecp_point
MBEDTLS_PRIVATE
(
Q
)
;
/*!< The public key. */
ecdh.h:89
mbedtls_ecp_point
MBEDTLS_PRIVATE
(
Qp
)
;
/*!< The value of the public key of the peer. */
ecdh.h:90
mbedtls_mpi
MBEDTLS_PRIVATE
(
z
)
;
/*!< The shared secret. */
ecdh.h:91
uint8_t
MBEDTLS_PRIVATE
(
point_format
)
;
/*!< The format of point export in TLS messages
ecdh.h:121
mbedtls_ecp_group_id
MBEDTLS_PRIVATE
(
grp_id
)
;
/*!< The elliptic curve used. */
ecdh.h:123
mbedtls_ecdh_variant
MBEDTLS_PRIVATE
(
var
)
;
/*!< The ECDH implementation/structure used. */
ecdh.h:124
mbedtls_ecdh_context_mbed
MBEDTLS_PRIVATE
(
mbed_ecdh
)
;
ecdh.h:126
}
MBEDTLS_PRIVATE
(
ctx
)
;
/*!< Implementation-specific context. The
ecdh.h:130
mbedtls_md_type_t
MBEDTLS_PRIVATE
(
md_type
)
;
/**< Hash to use */
ecjpake.h:61
mbedtls_ecp_group
MBEDTLS_PRIVATE
(
grp
)
;
/**< Elliptic curve */
ecjpake.h:62
mbedtls_ecjpake_role
MBEDTLS_PRIVATE
(
role
)
;
/**< Are we client or server? */
ecjpake.h:63
int
MBEDTLS_PRIVATE
(
point_format
)
;
/**< Format for point export */
ecjpake.h:64
mbedtls_ecp_point
MBEDTLS_PRIVATE
(
Xm1
)
;
/**< My public key 1 C: X1, S: X3 */
ecjpake.h:66
mbedtls_ecp_point
MBEDTLS_PRIVATE
(
Xm2
)
;
/**< My public key 2 C: X2, S: X4 */
ecjpake.h:67
mbedtls_ecp_point
MBEDTLS_PRIVATE
(
Xp1
)
;
/**< Peer public key 1 C: X3, S: X1 */
ecjpake.h:68
mbedtls_ecp_point
MBEDTLS_PRIVATE
(
Xp2
)
;
/**< Peer public key 2 C: X4, S: X2 */
ecjpake.h:69
mbedtls_ecp_point
MBEDTLS_PRIVATE
(
Xp
)
;
/**< Peer public key C: Xs, S: Xc */
ecjpake.h:70
mbedtls_mpi
MBEDTLS_PRIVATE
(
xm1
)
;
/**< My private key 1 C: x1, S: x3 */
ecjpake.h:72
mbedtls_mpi
MBEDTLS_PRIVATE
(
xm2
)
;
/**< My private key 2 C: x2, S: x4 */
ecjpake.h:73
mbedtls_mpi
MBEDTLS_PRIVATE
(
s
)
;
/**< Pre-shared secret (passphrase) */
ecjpake.h:75
mbedtls_mpi
MBEDTLS_PRIVATE
(
X
)
;
/*!< The X coordinate of the ECP point. */
ecp.h:159
mbedtls_mpi
MBEDTLS_PRIVATE
(
Y
)
;
/*!< The Y coordinate of the ECP point. */
ecp.h:160
mbedtls_mpi
MBEDTLS_PRIVATE
(
Z
)
;
/*!< The Z coordinate of the ECP point. */
ecp.h:161
unsigned
int
MBEDTLS_PRIVATE
(
h
)
;
/*!< \internal 1 if the constants are static. */
ecp.h:251
int
(
*
MBEDTLS_PRIVATE
(
modp
)
)
(
mbedtls_mpi
*
)
;
/*!< The function for fast pseudo-reduction
ecp.h:252
int
(
*
MBEDTLS_PRIVATE
(
t_pre
)
)
(
mbedtls_ecp_point
*
,
void
*
)
;
/*!< Unused. */
ecp.h:254
int
(
*
MBEDTLS_PRIVATE
(
t_post
)
)
(
mbedtls_ecp_point
*
,
void
*
)
;
/*!< Unused. */
ecp.h:255
void
*
MBEDTLS_PRIVATE
(
t_data
)
;
/*!< Unused. */
ecp.h:256
mbedtls_ecp_point
*
MBEDTLS_PRIVATE
(
T
)
;
/*!< Pre-computed points for ecp_mul_comb(). */
ecp.h:257
size_t
MBEDTLS_PRIVATE
(
T_size
)
;
/*!< The number of dynamic allocated pre-computed points. */
ecp.h:258
mbedtls_ecp_group
MBEDTLS_PRIVATE
(
grp
)
;
/*!< Elliptic curve and base point */
ecp.h:429
mbedtls_mpi
MBEDTLS_PRIVATE
(
d
)
;
/*!< our secret value */
ecp.h:430
mbedtls_ecp_point
MBEDTLS_PRIVATE
(
Q
)
;
/*!< our public value */
ecp.h:431
return
grp
->
A
.
MBEDTLS_PRIVATE
(
p
)
==
NULL
;
ecp.h:1024
mbedtls_entropy_f_source_ptr
MBEDTLS_PRIVATE
(
f_source
)
;
/**< The entropy source callback */
entropy.h:94
void
*
MBEDTLS_PRIVATE
(
p_source
)
;
/**< The callback data pointer */
entropy.h:95
size_t
MBEDTLS_PRIVATE
(
size
)
;
/**< Amount received in bytes */
entropy.h:96
size_t
MBEDTLS_PRIVATE
(
threshold
)
;
/**< Minimum bytes required before release */
entropy.h:97
int
MBEDTLS_PRIVATE
(
strong
)
;
/**< Is the source strong? */
entropy.h:98
mbedtls_md_context_t
MBEDTLS_PRIVATE
(
accumulator
)
;
entropy.h:106
int
MBEDTLS_PRIVATE
(
accumulator_started
)
;
/* 0 after init.
entropy.h:107
int
MBEDTLS_PRIVATE
(
source_count
)
;
/* Number of entries used in source. */
entropy.h:110
mbedtls_entropy_source_state
MBEDTLS_PRIVATE
(
source
)
[
MBEDTLS_ENTROPY_MAX_SOURCES
]
;
entropy.h:111
for
(
size_t
i
=
mpi
->
MBEDTLS_PRIVATE
(
n
)
;
i
>
0
;
i
--
)
{
esp_bignum.c:153
if
(
mpi
->
MBEDTLS_PRIVATE
(
p
[
i
-
1
]
)
!=
0
)
{
esp_bignum.c:154
uint64_t
N
=
M
->
MBEDTLS_PRIVATE
(
p
[
0
]
)
;
esp_bignum.c:177
mpi_hal_read_result_hw_op
(
Z
->
MBEDTLS_PRIVATE
(
p
)
,
Z
->
MBEDTLS_PRIVATE
(
n
)
,
z_words
)
;
esp_bignum.c:253
Z
->
MBEDTLS_PRIVATE
(
s
)
=
X
->
MBEDTLS_PRIVATE
(
s
)
*
Y
->
MBEDTLS_PRIVATE
(
s
)
;
esp_bignum.c:254
if
(
X
!=
NULL
&&
X
->
MBEDTLS_PRIVATE
(
n
)
!=
0
)
{
esp_bignum.c:272
for
(
i
=
X
->
MBEDTLS_PRIVATE
(
n
)
-
1
;
i
>=
0
;
i
--
)
{
esp_bignum.c:273
if
(
X
->
MBEDTLS_PRIVATE
(
p
[
i
]
)
!=
0
)
{
esp_bignum.c:274
if
(
(
X
->
MBEDTLS_PRIVATE
(
p
[
i
]
)
&
(
1
<
<
j
)
)
!=
0
)
{
esp_bignum.c:276
if
(
mbedtls_mpi_cmp_int
(
M
,
0
)
<=
0
||
(
M
->
MBEDTLS_PRIVATE
(
p
[
0
]
)
&
1
)
==
0
)
{
esp_bignum.c:378
if
(
Rinv
->
MBEDTLS_PRIVATE
(
p
)
==
NULL
)
{
esp_bignum.c:398
if
(
X
->
MBEDTLS_PRIVATE
(
s
)
==
-
1
&&
(
Y
->
MBEDTLS_PRIVATE
(
p
[
0
]
)
&
1
)
!=
0
)
{
esp_bignum.c:441
Z
->
MBEDTLS_PRIVATE
(
s
)
=
-
1
;
esp_bignum.c:442
Z
->
MBEDTLS_PRIVATE
(
s
)
=
1
;
esp_bignum.c:445
Z
->
MBEDTLS_PRIVATE
(
s
)
*=
X
->
MBEDTLS_PRIVATE
(
s
)
;
esp_bignum.c:510
Z
->
MBEDTLS_PRIVATE
(
s
)
*=
Y
->
MBEDTLS_PRIVATE
(
s
)
;
esp_bignum.c:515
mpi_hal_read_result_hw_op
(
Z
->
MBEDTLS_PRIVATE
(
p
)
,
Z
->
MBEDTLS_PRIVATE
(
n
)
,
z_words
)
;
esp_bignum.c:552
Z
->
MBEDTLS_PRIVATE
(
s
)
=
X
->
MBEDTLS_PRIVATE
(
s
)
*
Y
->
MBEDTLS_PRIVATE
(
s
)
;
esp_bignum.c:556
_B
.
MBEDTLS_PRIVATE
(
s
)
=
1
;
esp_bignum.c:567
_B
.
MBEDTLS_PRIVATE
(
n
)
=
1
;
esp_bignum.c:568
_B
.
MBEDTLS_PRIVATE
(
p
)
=
p
;
esp_bignum.c:569
.
MBEDTLS_PRIVATE
(
p
)
=
Y
->
MBEDTLS_PRIVATE
(
p
)
,
esp_bignum.c:600
.
MBEDTLS_PRIVATE
(
n
)
=
words_slice
,
esp_bignum.c:601
.
MBEDTLS_PRIVATE
(
s
)
=
Y
->
MBEDTLS_PRIVATE
(
s
)
esp_bignum.c:602
.
MBEDTLS_PRIVATE
(
p
)
=
Y
->
MBEDTLS_PRIVATE
(
p
)
+
words_slice
,
esp_bignum.c:606
.
MBEDTLS_PRIVATE
(
n
)
=
y_words
-
words_slice
,
esp_bignum.c:607
.
MBEDTLS_PRIVATE
(
s
)
=
Y
->
MBEDTLS_PRIVATE
(
s
)
esp_bignum.c:608
mpi_hal_read_result_hw_op
(
Z
->
MBEDTLS_PRIVATE
(
p
)
,
Z
->
MBEDTLS_PRIVATE
(
n
)
,
hw_words
)
;
esp_bignum.c:642
Z
->
MBEDTLS_PRIVATE
(
s
)
=
X
->
MBEDTLS_PRIVATE
(
s
)
*
Y
->
MBEDTLS_PRIVATE
(
s
)
;
esp_bignum.c:644
if
(
unlikely
(
!
mbedtls_pk_can_do
(
&
pubkey
,
child
->
MBEDTLS_PRIVATE
(
sig_pk
)
)
)
)
{
esp_crt_bundle.c:139
md_info
=
mbedtls_md_info_from_type
(
child
->
MBEDTLS_PRIVATE
(
sig_md
)
)
;
esp_crt_bundle.c:145
if
(
unlikely
(
(
ret
=
mbedtls_pk_verify_ext
(
child
->
MBEDTLS_PRIVATE
(
sig_pk
)
,
child
->
MBEDTLS_PRIVATE
(
sig_opts
)
,
&
pubkey
,
esp_crt_bundle.c:161
child
->
MBEDTLS_PRIVATE
(
sig_md
)
,
hash
,
md_size
,
esp_crt_bundle.c:162
child
->
MBEDTLS_PRIVATE
(
sig
)
.
p
,
child
->
MBEDTLS_PRIVATE
(
sig
)
.
len
)
)
!=
0
)
)
{
esp_crt_bundle.c:163
ctx
->
MBEDTLS_PRIVATE
(
int_ms
)
=
int_ms
;
esp_timing.c:57
ctx
->
MBEDTLS_PRIVATE
(
fin_ms
)
=
fin_ms
;
esp_timing.c:58
(
void
)
mbedtls_timing_get_timer
(
&
ctx
->
MBEDTLS_PRIVATE
(
timer
)
,
1
)
;
esp_timing.c:61
if
(
ctx
->
MBEDTLS_PRIVATE
(
fin_ms
)
==
0
)
esp_timing.c:72
elapsed_ms
=
mbedtls_timing_get_timer
(
&
ctx
->
MBEDTLS_PRIVATE
(
timer
)
,
0
)
;
esp_timing.c:75
if
(
elapsed_ms
>=
ctx
->
MBEDTLS_PRIVATE
(
fin_ms
)
)
esp_timing.c:77
if
(
elapsed_ms
>=
ctx
->
MBEDTLS_PRIVATE
(
int_ms
)
)
esp_timing.c:80
return
(
data
->
MBEDTLS_PRIVATE
(
fin_ms
)
)
;
esp_timing.c:91
mbedtls_cipher_context_t
MBEDTLS_PRIVATE
(
cipher_ctx
)
;
/*!< The cipher context used. */
gcm.h:73
uint64_t
MBEDTLS_PRIVATE
(
H
)
[
MBEDTLS_GCM_HTABLE_SIZE
]
[
2
]
;
/*!< Precalculated HTable. */
gcm.h:75
uint64_t
MBEDTLS_PRIVATE
(
len
)
;
/*!< The total length of the encrypted data. */
gcm.h:76
uint64_t
MBEDTLS_PRIVATE
(
add_len
)
;
/*!< The total length of the additional data. */
gcm.h:77
unsigned
char
MBEDTLS_PRIVATE
(
base_ectr
)
[
16
]
;
/*!< The first ECTR for tag. */
gcm.h:78
unsigned
char
MBEDTLS_PRIVATE
(
y
)
[
16
]
;
/*!< The Y working value. */
gcm.h:79
unsigned
char
MBEDTLS_PRIVATE
(
buf
)
[
16
]
;
/*!< The buf working value. */
gcm.h:80
unsigned
char
MBEDTLS_PRIVATE
(
mode
)
;
/*!< The operation to perform:
gcm.h:81
unsigned
char
MBEDTLS_PRIVATE
(
acceleration
)
;
/*!< The acceleration to use. */
gcm.h:84
mbedtls_md_context_t
MBEDTLS_PRIVATE
(
md_ctx
)
;
/*!< HMAC context (inc. K) */
hmac_drbg.h:77
unsigned
char
MBEDTLS_PRIVATE
(
V
)
[
MBEDTLS_MD_MAX_SIZE
]
;
/*!< V in the spec */
hmac_drbg.h:78
int
MBEDTLS_PRIVATE
(
reseed_counter
)
;
/*!< reseed counter */
hmac_drbg.h:79
size_t
MBEDTLS_PRIVATE
(
entropy_len
)
;
/*!< entropy bytes grabbed on each (re)seed */
hmac_drbg.h:82
int
MBEDTLS_PRIVATE
(
prediction_resistance
)
;
/*!< enable prediction resistance (Automatic
hmac_drbg.h:83
int
MBEDTLS_PRIVATE
(
reseed_interval
)
;
/*!< reseed interval */
hmac_drbg.h:85
int
(
*
MBEDTLS_PRIVATE
(
f_entropy
)
)
(
void
*
,
unsigned
char
*
,
size_t
)
;
/*!< entropy function */
hmac_drbg.h:88
void
*
MBEDTLS_PRIVATE
(
p_entropy
)
;
/*!< context for the entropy function */
hmac_drbg.h:89
unsigned
char
MBEDTLS_PRIVATE
(
I_key_identifier
[
MBEDTLS_LMOTS_I_KEY_ID_LEN
]
)
;
/*!< The key
lms.h:94
unsigned
char
MBEDTLS_PRIVATE
(
q_leaf_identifier
[
MBEDTLS_LMOTS_Q_LEAF_ID_LEN
]
)
;
/*!< Which
lms.h:96
mbedtls_lmots_algorithm_type_t
MBEDTLS_PRIVATE
(
type
)
;
/*!< The LM-OTS key type identifier as
lms.h:99
mbedtls_lmots_parameters_t
MBEDTLS_PRIVATE
(
params
)
;
lms.h:122
unsigned
char
MBEDTLS_PRIVATE
(
public_key
)
[
MBEDTLS_LMOTS_N_HASH_LEN_MAX
]
;
lms.h:123
unsigned
char
MBEDTLS_PRIVATE
(
have_public_key
)
;
/*!< Whether the context contains a public key.
lms.h:124
unsigned
char
MBEDTLS_PRIVATE
(
I_key_identifier
[
MBEDTLS_LMOTS_I_KEY_ID_LEN
]
)
;
/*!< The key
lms.h:162
mbedtls_lmots_algorithm_type_t
MBEDTLS_PRIVATE
(
otstype
)
;
/*!< The LM-OTS key type identifier as
lms.h:164
mbedtls_lms_algorithm_type_t
MBEDTLS_PRIVATE
(
type
)
;
/*!< The LMS key type identifier as per
lms.h:167
mbedtls_lms_parameters_t
MBEDTLS_PRIVATE
(
params
)
;
lms.h:191
unsigned
char
MBEDTLS_PRIVATE
(
T_1_pub_key
)
[
MBEDTLS_LMS_M_NODE_BYTES_MAX
]
;
/*!< The public key, in
lms.h:192
unsigned
char
MBEDTLS_PRIVATE
(
have_public_key
)
;
/*!< Whether the context contains a public key.
lms.h:194
return
ctx
->
MBEDTLS_PRIVATE
(
md_info
)
;
md.c:915
const
mbedtls_md_info_t
*
MBEDTLS_PRIVATE
(
md_info
)
;
md.h:124
void
*
MBEDTLS_PRIVATE
(
md_ctx
)
;
md.h:132
void
*
MBEDTLS_PRIVATE
(
hmac_ctx
)
;
md.h:136
mbedtls_cipher_context_t
MBEDTLS_PRIVATE
(
cipher_ctx
)
;
/*!< The cipher context used. */
nist_kw.h:52
const
char
*
MBEDTLS_PRIVATE
(
asn1
)
;
/*!< OID ASN.1 representation */
oid.h:477
size_t
MBEDTLS_PRIVATE
(
asn1_len
)
;
/*!< length of asn1 */
oid.h:478
const
char
*
MBEDTLS_PRIVATE
(
name
)
;
/*!< official name (e.g. from RFC) */
oid.h:480
const
char
*
MBEDTLS_PRIVATE
(
description
)
;
/*!< human friendly description */
oid.h:481
unsigned
char
*
MBEDTLS_PRIVATE
(
buf
)
;
/*!< buffer for decoded data */
pem.h:53
size_t
MBEDTLS_PRIVATE
(
buflen
)
;
/*!< length of the buffer */
pem.h:54
unsigned
char
*
MBEDTLS_PRIVATE
(
info
)
;
/*!< buffer for extra header information */
pem.h:55
*
buflen
=
ctx
->
MBEDTLS_PRIVATE
(
buflen
)
;
pem.h:111
return
ctx
->
MBEDTLS_PRIVATE
(
buf
)
;
pem.h:112
mbedtls_pk_debug_type
MBEDTLS_PRIVATE
(
type
)
;
pk.h:198
const
char
*
MBEDTLS_PRIVATE
(
name
)
;
pk.h:199
void
*
MBEDTLS_PRIVATE
(
value
)
;
pk.h:200
const
mbedtls_pk_info_t
*
MBEDTLS_PRIVATE
(
pk_info
)
;
/**< Public key information */
pk.h:221
void
*
MBEDTLS_PRIVATE
(
pk_ctx
)
;
/**< Underlying public key context */
pk.h:222
return
(
mbedtls_rsa_context
*
)
(
pk
)
.
MBEDTLS_PRIVATE
(
pk_ctx
)
;
pk.h:1041
return
(
mbedtls_ecp_keypair
*
)
(
pk
)
.
MBEDTLS_PRIVATE
(
pk_ctx
)
;
pk.h:1066
return
(
const
mbedtls_ecp_keypair
*
)
(
pk
)
.
MBEDTLS_PRIVATE
(
pk_ctx
)
;
pk_internal.h:66
return
(
mbedtls_ecp_keypair
*
)
(
pk
)
.
MBEDTLS_PRIVATE
(
pk_ctx
)
;
pk_internal.h:78
int
MBEDTLS_PRIVATE
(
version
)
;
pkcs7.h:109
mbedtls_x509_buf
MBEDTLS_PRIVATE
(
serial
)
;
pkcs7.h:110
mbedtls_x509_name
MBEDTLS_PRIVATE
(
issuer
)
;
pkcs7.h:111
mbedtls_x509_buf
MBEDTLS_PRIVATE
(
issuer_raw
)
;
pkcs7.h:112
mbedtls_x509_buf
MBEDTLS_PRIVATE
(
alg_identifier
)
;
pkcs7.h:113
mbedtls_x509_buf
MBEDTLS_PRIVATE
(
sig_alg_identifier
)
;
pkcs7.h:114
mbedtls_x509_buf
MBEDTLS_PRIVATE
(
sig
)
;
pkcs7.h:115
struct
mbedtls_pkcs7_signer_info
*
MBEDTLS_PRIVATE
(
next
)
;
pkcs7.h:116
int
MBEDTLS_PRIVATE
(
version
)
;
pkcs7.h:124
mbedtls_pkcs7_buf
MBEDTLS_PRIVATE
(
digest_alg_identifiers
)
;
pkcs7.h:125
int
MBEDTLS_PRIVATE
(
no_of_certs
)
;
pkcs7.h:126
mbedtls_x509_crt
MBEDTLS_PRIVATE
(
certs
)
;
pkcs7.h:127
int
MBEDTLS_PRIVATE
(
no_of_crls
)
;
pkcs7.h:128
mbedtls_x509_crl
MBEDTLS_PRIVATE
(
crl
)
;
pkcs7.h:129
int
MBEDTLS_PRIVATE
(
no_of_signers
)
;
pkcs7.h:130
mbedtls_pkcs7_signer_info
MBEDTLS_PRIVATE
(
signers
)
;
pkcs7.h:131
mbedtls_pkcs7_buf
MBEDTLS_PRIVATE
(
raw
)
;
pkcs7.h:139
mbedtls_pkcs7_signed_data
MBEDTLS_PRIVATE
(
signed_data
)
;
pkcs7.h:140
char
MBEDTLS_PRIVATE
(
dummy
)
;
/**< A placeholder member, as empty structs are not portable. */
platform.h:441
uint32_t
MBEDTLS_PRIVATE
(
r
)
[
4
]
;
/** The value for 'r' (low 128 bits of the key). */
poly1305.h:39
uint32_t
MBEDTLS_PRIVATE
(
s
)
[
4
]
;
/** The value for 's' (high 128 bits of the key). */
poly1305.h:40
uint32_t
MBEDTLS_PRIVATE
(
acc
)
[
5
]
;
/** The accumulator number. */
poly1305.h:41
uint8_t
MBEDTLS_PRIVATE
(
queue
)
[
16
]
;
/** The current partial block of data. */
poly1305.h:42
size_t
MBEDTLS_PRIVATE
(
queue_len
)
;
/** The number of bytes stored in 'queue'. */
poly1305.h:43
uint32_t
MBEDTLS_PRIVATE
(
total
)
[
2
]
;
/*!< number of bytes processed */
ripemd160.h:31
uint32_t
MBEDTLS_PRIVATE
(
state
)
[
5
]
;
/*!< intermediate digest state */
ripemd160.h:32
unsigned
char
MBEDTLS_PRIVATE
(
buffer
)
[
64
]
;
/*!< data block being processed */
ripemd160.h:33
int
MBEDTLS_PRIVATE
(
ver
)
;
/*!< Reserved for internal purposes.
rsa.h:86
size_t
MBEDTLS_PRIVATE
(
len
)
;
/*!< The size of \p N in Bytes. */
rsa.h:90
mbedtls_mpi
MBEDTLS_PRIVATE
(
N
)
;
/*!< The public modulus. */
rsa.h:92
mbedtls_mpi
MBEDTLS_PRIVATE
(
E
)
;
/*!< The public exponent. */
rsa.h:93
mbedtls_mpi
MBEDTLS_PRIVATE
(
D
)
;
/*!< The private exponent. */
rsa.h:95
mbedtls_mpi
MBEDTLS_PRIVATE
(
P
)
;
/*!< The first prime factor. */
rsa.h:96
mbedtls_mpi
MBEDTLS_PRIVATE
(
Q
)
;
/*!< The second prime factor. */
rsa.h:97
mbedtls_mpi
MBEDTLS_PRIVATE
(
DP
)
;
/*!< <code>D % (P - 1)</code>. */
rsa.h:99
mbedtls_mpi
MBEDTLS_PRIVATE
(
DQ
)
;
/*!< <code>D % (Q - 1)</code>. */
rsa.h:100
mbedtls_mpi
MBEDTLS_PRIVATE
(
QP
)
;
/*!< <code>1 / (Q % P)</code>. */
rsa.h:101
mbedtls_mpi
MBEDTLS_PRIVATE
(
RN
)
;
/*!< cached <code>R^2 mod N</code>. */
rsa.h:103
mbedtls_mpi
MBEDTLS_PRIVATE
(
RP
)
;
/*!< cached <code>R^2 mod P</code>. */
rsa.h:105
mbedtls_mpi
MBEDTLS_PRIVATE
(
RQ
)
;
/*!< cached <code>R^2 mod Q</code>. */
rsa.h:106
mbedtls_mpi
MBEDTLS_PRIVATE
(
Vi
)
;
/*!< The cached blinding value. */
rsa.h:108
mbedtls_mpi
MBEDTLS_PRIVATE
(
Vf
)
;
/*!< The cached un-blinding value. */
rsa.h:109
int
MBEDTLS_PRIVATE
(
padding
)
;
/*!< Selects padding mode:
rsa.h:111
int
MBEDTLS_PRIVATE
(
hash_id
)
;
/*!< Hash identifier of mbedtls_md_type_t type,
rsa.h:114
uint32_t
MBEDTLS_PRIVATE
(
total
)
[
2
]
;
/*!< The number of Bytes processed. */
sha1.h:46
uint32_t
MBEDTLS_PRIVATE
(
state
)
[
5
]
;
/*!< The intermediate digest state. */
sha1.h:47
unsigned
char
MBEDTLS_PRIVATE
(
buffer
)
[
64
]
;
/*!< The data block being processed. */
sha1.h:48
unsigned
char
MBEDTLS_PRIVATE
(
buffer
)
[
64
]
;
/*!< The data block being processed. */
sha256.h:41
uint32_t
MBEDTLS_PRIVATE
(
total
)
[
2
]
;
/*!< The number of Bytes processed. */
sha256.h:42
uint32_t
MBEDTLS_PRIVATE
(
state
)
[
8
]
;
/*!< The intermediate digest state. */
sha256.h:43
int
MBEDTLS_PRIVATE
(
is224
)
;
/*!< Determines which function to use:
sha256.h:45
uint64_t
MBEDTLS_PRIVATE
(
state
[
25
]
)
;
sha3.h:51
uint32_t
MBEDTLS_PRIVATE
(
index
)
;
sha3.h:52
uint16_t
MBEDTLS_PRIVATE
(
olen
)
;
sha3.h:53
uint16_t
MBEDTLS_PRIVATE
(
max_block_size
)
;
sha3.h:54
uint64_t
MBEDTLS_PRIVATE
(
total
)
[
2
]
;
/*!< The number of Bytes processed. */
sha512.h:40
uint64_t
MBEDTLS_PRIVATE
(
state
)
[
8
]
;
/*!< The intermediate digest state. */
sha512.h:41
unsigned
char
MBEDTLS_PRIVATE
(
buffer
)
[
128
]
;
/*!< The data block being processed. */
sha512.h:42
int
MBEDTLS_PRIVATE
(
is384
)
;
/*!< Determines which function to use:
sha512.h:44
mbedtls_ssl_srtp_profile
MBEDTLS_PRIVATE
(
chosen_dtls_srtp_profile
)
;
ssl.h:1203
uint16_t
MBEDTLS_PRIVATE
(
mki_len
)
;
ssl.h:1205
unsigned
char
MBEDTLS_PRIVATE
(
mki_value
)
[
MBEDTLS_TLS_SRTP_MAX_MKI_LENGTH
]
;
ssl.h:1207
unsigned
char
MBEDTLS_PRIVATE
(
mfl_code
)
;
/*!< MaxFragmentLength negotiated by peer */
ssl.h:1233
unsigned
char
MBEDTLS_PRIVATE
(
exported
)
;
ssl.h:1241
uint8_t
MBEDTLS_PRIVATE
(
endpoint
)
;
/*!< 0: client, 1: server */
ssl.h:1242
mbedtls_ssl_protocol_version
MBEDTLS_PRIVATE
(
tls_version
)
;
ssl.h:1247
mbedtls_time_t
MBEDTLS_PRIVATE
(
start
)
;
/*!< start time of current session */
ssl.h:1250
int
MBEDTLS_PRIVATE
(
ciphersuite
)
;
/*!< chosen ciphersuite */
ssl.h:1252
size_t
MBEDTLS_PRIVATE
(
id_len
)
;
/*!< session id length */
ssl.h:1253
unsigned
char
MBEDTLS_PRIVATE
(
id
)
[
32
]
;
/*!< session identifier */
ssl.h:1254
unsigned
char
MBEDTLS_PRIVATE
(
master
)
[
48
]
;
/*!< the master secret */
ssl.h:1255
mbedtls_x509_crt
*
MBEDTLS_PRIVATE
(
peer_cert
)
;
/*!< peer X.509 cert chain */
ssl.h:1259
uint32_t
MBEDTLS_PRIVATE
(
verify_result
)
;
/*!< verification result */
ssl.h:1268
unsigned
char
*
MBEDTLS_PRIVATE
(
ticket
)
;
/*!< RFC 5077 session ticket */
ssl.h:1271
size_t
MBEDTLS_PRIVATE
(
ticket_len
)
;
/*!< session ticket length */
ssl.h:1272
uint32_t
MBEDTLS_PRIVATE
(
ticket_lifetime
)
;
/*!< ticket lifetime hint */
ssl.h:1273
mbedtls_ms_time_t
MBEDTLS_PRIVATE
(
ticket_creation_time
)
;
ssl.h:1294
int
MBEDTLS_PRIVATE
(
encrypt_then_mac
)
;
/*!< flag for EtM activation */
ssl.h:1323
mbedtls_ssl_protocol_version
MBEDTLS_PRIVATE
(
max_tls_version
)
;
/*!< max. TLS version used */
ssl.h:1417
mbedtls_ssl_protocol_version
MBEDTLS_PRIVATE
(
min_tls_version
)
;
/*!< min. TLS version used */
ssl.h:1418
uint8_t
MBEDTLS_PRIVATE
(
endpoint
)
;
/*!< 0: client, 1: server */
ssl.h:1426
uint8_t
MBEDTLS_PRIVATE
(
transport
)
;
/*!< 0: stream (TLS), 1: datagram (DTLS) */
ssl.h:1427
uint8_t
MBEDTLS_PRIVATE
(
authmode
)
;
/*!< MBEDTLS_SSL_VERIFY_XXX */
ssl.h:1428
uint8_t
MBEDTLS_PRIVATE
(
allow_legacy_renegotiation
)
;
/*!< MBEDTLS_LEGACY_XXX */
ssl.h:1430
uint8_t
MBEDTLS_PRIVATE
(
mfl_code
)
;
/*!< desired fragment length indicator
ssl.h:1432
uint8_t
MBEDTLS_PRIVATE
(
encrypt_then_mac
)
;
/*!< negotiate encrypt-then-mac? */
ssl.h:1436
uint8_t
MBEDTLS_PRIVATE
(
extended_ms
)
;
/*!< negotiate extended master secret? */
ssl.h:1439
uint8_t
MBEDTLS_PRIVATE
(
anti_replay
)
;
/*!< detect and prevent replay? */
ssl.h:1442
uint8_t
MBEDTLS_PRIVATE
(
disable_renegotiation
)
;
/*!< disable renegotiation? */
ssl.h:1445
uint8_t
MBEDTLS_PRIVATE
(
session_tickets
)
;
/*!< use session tickets? */
ssl.h:1455
uint8_t
MBEDTLS_PRIVATE
(
cert_req_ca_list
)
;
/*!< enable sending CA list in
ssl.h:1465
uint8_t
MBEDTLS_PRIVATE
(
respect_cli_pref
)
;
/*!< pick the ciphersuite according to
ssl.h:1467
uint8_t
MBEDTLS_PRIVATE
(
dtls_srtp_mki_support
)
;
/* support having mki_value
ssl.h:1477
const
int
*
MBEDTLS_PRIVATE
(
ciphersuite_list
)
;
ssl.h:1486
void
(
*
MBEDTLS_PRIVATE
(
f_dbg
)
)
(
void
*
,
int
,
const
char
*
,
int
,
const
char
*
)
;
ssl.h:1494
void
*
MBEDTLS_PRIVATE
(
p_dbg
)
;
/*!< context for the debug function */
ssl.h:1495
int
(
*
MBEDTLS_PRIVATE
(
f_rng
)
)
(
void
*
,
unsigned
char
*
,
size_t
)
;
ssl.h:1498
void
*
MBEDTLS_PRIVATE
(
p_rng
)
;
/*!< context for the RNG function */
ssl.h:1499
mbedtls_ssl_cache_get_t
*
MBEDTLS_PRIVATE
(
f_get_cache
)
;
ssl.h:1502
mbedtls_ssl_cache_set_t
*
MBEDTLS_PRIVATE
(
f_set_cache
)
;
ssl.h:1504
void
*
MBEDTLS_PRIVATE
(
p_cache
)
;
/*!< context for cache callbacks */
ssl.h:1505
int
(
*
MBEDTLS_PRIVATE
(
f_sni
)
)
(
void
*
,
mbedtls_ssl_context
*
,
const
unsigned
char
*
,
size_t
)
;
ssl.h:1509
void
*
MBEDTLS_PRIVATE
(
p_sni
)
;
/*!< context for SNI callback */
ssl.h:1510
int
(
*
MBEDTLS_PRIVATE
(
f_vrfy
)
)
(
void
*
,
mbedtls_x509_crt
*
,
int
,
uint32_t
*
)
;
ssl.h:1515
void
*
MBEDTLS_PRIVATE
(
p_vrfy
)
;
/*!< context for X.509 verify calllback */
ssl.h:1516
int
(
*
MBEDTLS_PRIVATE
(
f_psk
)
)
(
void
*
,
mbedtls_ssl_context
*
,
const
unsigned
char
*
,
size_t
)
;
ssl.h:1522
void
*
MBEDTLS_PRIVATE
(
p_psk
)
;
/*!< context for PSK callback */
ssl.h:1523
int
(
*
MBEDTLS_PRIVATE
(
f_cookie_write
)
)
(
void
*
,
unsigned
char
*
*
,
unsigned
char
*
,
ssl.h:1529
int
(
*
MBEDTLS_PRIVATE
(
f_cookie_check
)
)
(
void
*
,
const
unsigned
char
*
,
size_t
,
ssl.h:1532
void
*
MBEDTLS_PRIVATE
(
p_cookie
)
;
/*!< context for the cookie callbacks */
ssl.h:1534
int
(
*
MBEDTLS_PRIVATE
(
f_ticket_write
)
)
(
void
*
,
const
mbedtls_ssl_session
*
,
ssl.h:1539
int
(
*
MBEDTLS_PRIVATE
(
f_ticket_parse
)
)
(
void
*
,
mbedtls_ssl_session
*
,
unsigned
char
*
,
size_t
)
;
ssl.h:1543
void
*
MBEDTLS_PRIVATE
(
p_ticket
)
;
/*!< context for the ticket callbacks */
ssl.h:1544
const
mbedtls_x509_crt_profile
*
MBEDTLS_PRIVATE
(
cert_profile
)
;
/*!< verification profile */
ssl.h:1551
mbedtls_ssl_key_cert
*
MBEDTLS_PRIVATE
(
key_cert
)
;
/*!< own certificate/key pair(s) */
ssl.h:1552
mbedtls_x509_crt
*
MBEDTLS_PRIVATE
(
ca_chain
)
;
/*!< trusted CAs */
ssl.h:1553
mbedtls_x509_crl
*
MBEDTLS_PRIVATE
(
ca_crl
)
;
/*!< trusted CAs CRLs */
ssl.h:1554
const
uint16_t
*
MBEDTLS_PRIVATE
(
sig_algs
)
;
/*!< allowed signature algorithms */
ssl.h:1576
const
uint16_t
*
MBEDTLS_PRIVATE
(
group_list
)
;
/*!< allowed IANA NamedGroups */
ssl.h:1583
mbedtls_mpi
MBEDTLS_PRIVATE
(
dhm_P
)
;
/*!< prime modulus for DHM */
ssl.h:1586
mbedtls_mpi
MBEDTLS_PRIVATE
(
dhm_G
)
;
/*!< generator for DHM */
ssl.h:1587
unsigned
char
*
MBEDTLS_PRIVATE
(
psk
)
;
/*!< The raw pre-shared key. This field should
ssl.h:1600
size_t
MBEDTLS_PRIVATE
(
psk_len
)
;
/*!< The length of the raw pre-shared key.
ssl.h:1604
unsigned
char
*
MBEDTLS_PRIVATE
(
psk_identity
)
;
/*!< The PSK identity for PSK negotiation.
ssl.h:1610
size_t
MBEDTLS_PRIVATE
(
psk_identity_len
)
;
/*!< The length of PSK identity.
ssl.h:1615
const
char
*
*
MBEDTLS_PRIVATE
(
alpn_list
)
;
/*!< ordered list of protocols */
ssl.h:1636
const
mbedtls_ssl_srtp_profile
*
MBEDTLS_PRIVATE
(
dtls_srtp_profile_list
)
;
ssl.h:1641
size_t
MBEDTLS_PRIVATE
(
dtls_srtp_profile_list_len
)
;
ssl.h:1643
uint32_t
MBEDTLS_PRIVATE
(
read_timeout
)
;
/*!< timeout for mbedtls_ssl_read (ms) */
ssl.h:1650
uint32_t
MBEDTLS_PRIVATE
(
hs_timeout_min
)
;
/*!< initial value of the handshake
ssl.h:1653
uint32_t
MBEDTLS_PRIVATE
(
hs_timeout_max
)
;
/*!< maximum value of the handshake
ssl.h:1655
int
MBEDTLS_PRIVATE
(
renego_max_records
)
;
/*!< grace period for renegotiation */
ssl.h:1660
unsigned
char
MBEDTLS_PRIVATE
(
renego_period
)
[
8
]
;
/*!< value of the record counters
ssl.h:1661
unsigned
int
MBEDTLS_PRIVATE
(
badmac_limit
)
;
/*!< limit of records with a bad MAC */
ssl.h:1665
unsigned
int
MBEDTLS_PRIVATE
(
dhm_min_bitlen
)
;
/*!< min. bit length of the DHM prime */
ssl.h:1668
mbedtls_ssl_user_data_t
MBEDTLS_PRIVATE
(
user_data
)
;
ssl.h:1676
mbedtls_ssl_hs_cb_t
MBEDTLS_PRIVATE
(
f_cert_cb
)
;
/*!< certificate selection callback */
ssl.h:1679
const
mbedtls_x509_crt
*
MBEDTLS_PRIVATE
(
dn_hints
)
;
/*!< acceptable client cert issuers */
ssl.h:1683
const
mbedtls_ssl_config
*
MBEDTLS_PRIVATE
(
conf
)
;
/*!< configuration information */
ssl.h:1688
int
MBEDTLS_PRIVATE
(
state
)
;
/*!< SSL handshake: current state */
ssl.h:1693
int
MBEDTLS_PRIVATE
(
renego_status
)
;
/*!< Initial, in progress, pending? */
ssl.h:1695
int
MBEDTLS_PRIVATE
(
renego_records_seen
)
;
/*!< Records since renego request, or with DTLS,
ssl.h:1696
mbedtls_ssl_protocol_version
MBEDTLS_PRIVATE
(
tls_version
)
;
ssl.h:1717
unsigned
MBEDTLS_PRIVATE
(
badmac_seen
)
;
/*!< records with a bad MAC received */
ssl.h:1727
int
(
*
MBEDTLS_PRIVATE
(
f_vrfy
)
)
(
void
*
,
mbedtls_x509_crt
*
,
int
,
uint32_t
*
)
;
ssl.h:1731
void
*
MBEDTLS_PRIVATE
(
p_vrfy
)
;
/*!< context for X.509 verify callback */
ssl.h:1732
mbedtls_ssl_send_t
*
MBEDTLS_PRIVATE
(
f_send
)
;
/*!< Callback for network send */
ssl.h:1735
mbedtls_ssl_recv_t
*
MBEDTLS_PRIVATE
(
f_recv
)
;
/*!< Callback for network receive */
ssl.h:1736
mbedtls_ssl_recv_timeout_t
*
MBEDTLS_PRIVATE
(
f_recv_timeout
)
;
ssl.h:1737
void
*
MBEDTLS_PRIVATE
(
p_bio
)
;
/*!< context for I/O operations */
ssl.h:1740
mbedtls_ssl_session
*
MBEDTLS_PRIVATE
(
session_in
)
;
/*!< current session data (in) */
ssl.h:1745
mbedtls_ssl_session
*
MBEDTLS_PRIVATE
(
session_out
)
;
/*!< current session data (out) */
ssl.h:1746
mbedtls_ssl_session
*
MBEDTLS_PRIVATE
(
session
)
;
/*!< negotiated session data */
ssl.h:1747
mbedtls_ssl_session
*
MBEDTLS_PRIVATE
(
session_negotiate
)
;
/*!< session data in negotiation */
ssl.h:1748
mbedtls_ssl_handshake_params
*
MBEDTLS_PRIVATE
(
handshake
)
;
/*!< params required only during
ssl.h:1750
mbedtls_ssl_transform
*
MBEDTLS_PRIVATE
(
transform_in
)
;
/*!< current transform params (in)
ssl.h:1756
mbedtls_ssl_transform
*
MBEDTLS_PRIVATE
(
transform_out
)
;
/*!< current transform params (out)
ssl.h:1759
mbedtls_ssl_transform
*
MBEDTLS_PRIVATE
(
transform
)
;
/*!< negotiated transform params
ssl.h:1762
mbedtls_ssl_transform
*
MBEDTLS_PRIVATE
(
transform_negotiate
)
;
/*!< transform params in negotiation
ssl.h:1766
void
*
MBEDTLS_PRIVATE
(
p_timer
)
;
/*!< context for the timer callbacks */
ssl.h:1780
mbedtls_ssl_set_timer_t
*
MBEDTLS_PRIVATE
(
f_set_timer
)
;
/*!< set timer callback */
ssl.h:1782
mbedtls_ssl_get_timer_t
*
MBEDTLS_PRIVATE
(
f_get_timer
)
;
/*!< get timer callback */
ssl.h:1783
unsigned
char
*
MBEDTLS_PRIVATE
(
in_buf
)
;
/*!< input buffer */
ssl.h:1788
unsigned
char
*
MBEDTLS_PRIVATE
(
in_ctr
)
;
/*!< 64-bit incoming message counter
ssl.h:1789
unsigned
char
*
MBEDTLS_PRIVATE
(
in_hdr
)
;
/*!< start of record header */
ssl.h:1792
unsigned
char
*
MBEDTLS_PRIVATE
(
in_len
)
;
/*!< two-bytes message length field */
ssl.h:1797
unsigned
char
*
MBEDTLS_PRIVATE
(
in_iv
)
;
/*!< ivlen-byte IV */
ssl.h:1798
unsigned
char
*
MBEDTLS_PRIVATE
(
in_msg
)
;
/*!< message contents (in_iv+ivlen) */
ssl.h:1799
unsigned
char
*
MBEDTLS_PRIVATE
(
in_offt
)
;
/*!< read offset in application data */
ssl.h:1800
int
MBEDTLS_PRIVATE
(
in_msgtype
)
;
/*!< record header: message type */
ssl.h:1802
size_t
MBEDTLS_PRIVATE
(
in_msglen
)
;
/*!< record header: message length */
ssl.h:1803
size_t
MBEDTLS_PRIVATE
(
in_left
)
;
/*!< amount of data read so far */
ssl.h:1804
uint16_t
MBEDTLS_PRIVATE
(
in_epoch
)
;
/*!< DTLS epoch for incoming records */
ssl.h:1809
size_t
MBEDTLS_PRIVATE
(
next_record_offset
)
;
/*!< offset of the next record in datagram
ssl.h:1810
uint64_t
MBEDTLS_PRIVATE
(
in_window_top
)
;
/*!< last validated record seq_num */
ssl.h:1814
uint64_t
MBEDTLS_PRIVATE
(
in_window
)
;
/*!< bitmask for replay detection */
ssl.h:1815
size_t
MBEDTLS_PRIVATE
(
in_hslen
)
;
/*!< current handshake message length,
ssl.h:1818
int
MBEDTLS_PRIVATE
(
nb_zero
)
;
/*!< # of 0-length encrypted messages */
ssl.h:1820
int
MBEDTLS_PRIVATE
(
keep_current_message
)
;
/*!< drop or reuse current message
ssl.h:1822
unsigned
char
MBEDTLS_PRIVATE
(
send_alert
)
;
/*!< Determines if a fatal alert
ssl.h:1828
unsigned
char
MBEDTLS_PRIVATE
(
alert_type
)
;
/*!< Type of alert if send_alert
ssl.h:1832
int
MBEDTLS_PRIVATE
(
alert_reason
)
;
/*!< The error code to be returned
ssl.h:1834
uint8_t
MBEDTLS_PRIVATE
(
disable_datagram_packing
)
;
/*!< Disable packing multiple records
ssl.h:1839
unsigned
char
*
MBEDTLS_PRIVATE
(
out_buf
)
;
/*!< output buffer */
ssl.h:1859
unsigned
char
*
MBEDTLS_PRIVATE
(
out_ctr
)
;
/*!< 64-bit outgoing message counter */
ssl.h:1860
unsigned
char
*
MBEDTLS_PRIVATE
(
out_hdr
)
;
/*!< start of record header */
ssl.h:1861
unsigned
char
*
MBEDTLS_PRIVATE
(
out_len
)
;
/*!< two-bytes message length field */
ssl.h:1866
unsigned
char
*
MBEDTLS_PRIVATE
(
out_iv
)
;
/*!< ivlen-byte IV */
ssl.h:1867
unsigned
char
*
MBEDTLS_PRIVATE
(
out_msg
)
;
/*!< message contents (out_iv+ivlen) */
ssl.h:1868
int
MBEDTLS_PRIVATE
(
out_msgtype
)
;
/*!< record header: message type */
ssl.h:1870
size_t
MBEDTLS_PRIVATE
(
out_msglen
)
;
/*!< record header: message length */
ssl.h:1871
size_t
MBEDTLS_PRIVATE
(
out_left
)
;
/*!< amount of data not yet written */
ssl.h:1872
unsigned
char
MBEDTLS_PRIVATE
(
cur_out_ctr
)
[
MBEDTLS_SSL_SEQUENCE_NUMBER_LEN
]
;
/*!< Outgoing record sequence number. */
ssl.h:1877
uint16_t
MBEDTLS_PRIVATE
(
mtu
)
;
/*!< path mtu, used to fragment outgoing messages */
ssl.h:1880
char
*
MBEDTLS_PRIVATE
(
hostname
)
;
/*!< expected peer CN for verification
ssl.h:1887
const
char
*
MBEDTLS_PRIVATE
(
alpn_chosen
)
;
/*!< negotiated protocol */
ssl.h:1892
mbedtls_dtls_srtp_info
MBEDTLS_PRIVATE
(
dtls_srtp_info
)
;
ssl.h:1899
unsigned
char
*
MBEDTLS_PRIVATE
(
cli_id
)
;
/*!< transport-level ID of the client */
ssl.h:1906
size_t
MBEDTLS_PRIVATE
(
cli_id_len
)
;
/*!< length of cli_id */
ssl.h:1907
int
MBEDTLS_PRIVATE
(
secure_renegotiation
)
;
/*!< does peer support legacy or
ssl.h:1914
size_t
MBEDTLS_PRIVATE
(
verify_data_len
)
;
/*!< length of verify data stored */
ssl.h:1917
char
MBEDTLS_PRIVATE
(
own_verify_data
)
[
MBEDTLS_SSL_VERIFY_DATA_MAX_LEN
]
;
/*!< previous handshake verify data */
ssl.h:1918
char
MBEDTLS_PRIVATE
(
peer_verify_data
)
[
MBEDTLS_SSL_VERIFY_DATA_MAX_LEN
]
;
/*!< previous handshake verify data */
ssl.h:1919
mbedtls_ssl_export_keys_t
*
MBEDTLS_PRIVATE
(
f_export_keys
)
;
ssl.h:1938
void
*
MBEDTLS_PRIVATE
(
p_export_keys
)
;
/*!< context for key export callback */
ssl.h:1939
mbedtls_ssl_user_data_t
MBEDTLS_PRIVATE
(
user_data
)
;
ssl.h:1950
return
conf
->
MBEDTLS_PRIVATE
(
endpoint
)
;
ssl.h:2038
return
ssl
->
MBEDTLS_PRIVATE
(
conf
)
;
ssl.h:2209
conf
->
MBEDTLS_PRIVATE
(
f_cert_cb
)
=
f_cert_cb
;
ssl.h:2591
session
->
MBEDTLS_PRIVATE
(
endpoint
)
!=
MBEDTLS_SSL_IS_SERVER
)
{
ssl.h:2687
*
ticket_creation_time
=
session
->
MBEDTLS_PRIVATE
(
ticket_creation_time
)
;
ssl.h:2691
return
&
session
->
MBEDTLS_PRIVATE
(
id
)
;
ssl.h:2708
return
session
->
MBEDTLS_PRIVATE
(
id_len
)
;
ssl.h:2720
return
session
->
MBEDTLS_PRIVATE
(
ciphersuite
)
;
ssl.h:2732
conf
->
MBEDTLS_PRIVATE
(
user_data
)
.
p
=
p
;
ssl.h:2771
conf
->
MBEDTLS_PRIVATE
(
user_data
)
.
n
=
n
;
ssl.h:2785
return
conf
->
MBEDTLS_PRIVATE
(
user_data
)
.
p
;
ssl.h:2801
return
conf
->
MBEDTLS_PRIVATE
(
user_data
)
.
n
;
ssl.h:2817
ssl
->
MBEDTLS_PRIVATE
(
user_data
)
.
p
=
p
;
ssl.h:2834
ssl
->
MBEDTLS_PRIVATE
(
user_data
)
.
n
=
n
;
ssl.h:2848
return
ssl
->
MBEDTLS_PRIVATE
(
user_data
)
.
p
;
ssl.h:2864
return
ssl
->
MBEDTLS_PRIVATE
(
user_data
)
.
n
;
ssl.h:2880
conf
->
MBEDTLS_PRIVATE
(
dn_hints
)
=
crt
;
ssl.h:3510
return
ssl
->
MBEDTLS_PRIVATE
(
hostname
)
;
ssl.h:4000
conf
->
MBEDTLS_PRIVATE
(
max_tls_version
)
=
tls_version
;
ssl.h:4319
conf
->
MBEDTLS_PRIVATE
(
min_tls_version
)
=
tls_version
;
ssl.h:4376
return
ssl
->
MBEDTLS_PRIVATE
(
tls_version
)
;
ssl.h:4768
return
ssl
->
MBEDTLS_PRIVATE
(
state
)
>=
MBEDTLS_SSL_HANDSHAKE_OVER
;
ssl.h:4989
mbedtls_time_t
MBEDTLS_PRIVATE
(
timestamp
)
;
/*!< entry timestamp */
ssl_cache.h:52
unsigned
char
MBEDTLS_PRIVATE
(
session_id
)
[
32
]
;
/*!< session ID */
ssl_cache.h:55
size_t
MBEDTLS_PRIVATE
(
session_id_len
)
;
ssl_cache.h:56
unsigned
char
*
MBEDTLS_PRIVATE
(
session
)
;
/*!< serialized session */
ssl_cache.h:58
size_t
MBEDTLS_PRIVATE
(
session_len
)
;
ssl_cache.h:59
mbedtls_ssl_cache_entry
*
MBEDTLS_PRIVATE
(
next
)
;
/*!< chain pointer */
ssl_cache.h:61
mbedtls_ssl_cache_entry
*
MBEDTLS_PRIVATE
(
chain
)
;
/*!< start of the chain */
ssl_cache.h:68
int
MBEDTLS_PRIVATE
(
timeout
)
;
/*!< cache entry timeout */
ssl_cache.h:69
int
MBEDTLS_PRIVATE
(
max_entries
)
;
/*!< maximum entries */
ssl_cache.h:70
return
cache
->
MBEDTLS_PRIVATE
(
timeout
)
;
ssl_cache.h:163
int
MBEDTLS_PRIVATE
(
id
)
;
ssl_ciphersuites.h:449
const
char
*
MBEDTLS_PRIVATE
(
name
)
;
ssl_ciphersuites.h:450
uint8_t
MBEDTLS_PRIVATE
(
cipher
)
;
/* mbedtls_cipher_type_t */
ssl_ciphersuites.h:452
uint8_t
MBEDTLS_PRIVATE
(
mac
)
;
/* mbedtls_md_type_t */
ssl_ciphersuites.h:453
uint8_t
MBEDTLS_PRIVATE
(
key_exchange
)
;
/* mbedtls_key_exchange_type_t */
ssl_ciphersuites.h:454
uint8_t
MBEDTLS_PRIVATE
(
flags
)
;
ssl_ciphersuites.h:455
uint16_t
MBEDTLS_PRIVATE
(
min_tls_version
)
;
/* mbedtls_ssl_protocol_version */
ssl_ciphersuites.h:457
uint16_t
MBEDTLS_PRIVATE
(
max_tls_version
)
;
/* mbedtls_ssl_protocol_version */
ssl_ciphersuites.h:458
return
info
->
MBEDTLS_PRIVATE
(
name
)
;
ssl_ciphersuites.h:468
return
info
->
MBEDTLS_PRIVATE
(
id
)
;
ssl_ciphersuites.h:473
switch
(
info
->
MBEDTLS_PRIVATE
(
key_exchange
)
)
{
ssl_ciphersuites_internal.h:30
switch
(
info
->
MBEDTLS_PRIVATE
(
key_exchange
)
)
{
ssl_ciphersuites_internal.h:48
switch
(
info
->
MBEDTLS_PRIVATE
(
key_exchange
)
)
{
ssl_ciphersuites_internal.h:65
switch
(
info
->
MBEDTLS_PRIVATE
(
key_exchange
)
)
{
ssl_ciphersuites_internal.h:78
switch
(
info
->
MBEDTLS_PRIVATE
(
key_exchange
)
)
{
ssl_ciphersuites_internal.h:94
switch
(
info
->
MBEDTLS_PRIVATE
(
key_exchange
)
)
{
ssl_ciphersuites_internal.h:112
switch
(
info
->
MBEDTLS_PRIVATE
(
key_exchange
)
)
{
ssl_ciphersuites_internal.h:126
switch
(
info
->
MBEDTLS_PRIVATE
(
key_exchange
)
)
{
ssl_ciphersuites_internal.h:142
mbedtls_md_context_t
MBEDTLS_PRIVATE
(
hmac_ctx
)
;
/*!< context for the HMAC portion */
ssl_cookie.h:49
unsigned
long
MBEDTLS_PRIVATE
(
timeout
)
;
/*!< timeout delay, in seconds if HAVE_TIME,
ssl_cookie.h:54
unsigned
char
MBEDTLS_PRIVATE
(
name
)
[
MBEDTLS_SSL_TICKET_KEY_NAME_BYTES
]
;
ssl_ticket.h:48
mbedtls_time_t
MBEDTLS_PRIVATE
(
generation_time
)
;
/*!< key generation timestamp (seconds) */
ssl_ticket.h:51
uint32_t
MBEDTLS_PRIVATE
(
lifetime
)
;
ssl_ticket.h:56
mbedtls_cipher_context_t
MBEDTLS_PRIVATE
(
ctx
)
;
/*!< context for auth enc/decryption */
ssl_ticket.h:58
mbedtls_ssl_ticket_key
MBEDTLS_PRIVATE
(
keys
)
[
2
]
;
/*!< ticket protection keys */
ssl_ticket.h:72
unsigned
char
MBEDTLS_PRIVATE
(
active
)
;
/*!< index of the currently active key */
ssl_ticket.h:73
uint32_t
MBEDTLS_PRIVATE
(
ticket_lifetime
)
;
/*!< lifetime of tickets in seconds */
ssl_ticket.h:75
int
(
*
MBEDTLS_PRIVATE
(
f_rng
)
)
(
void
*
,
unsigned
char
*
,
size_t
)
;
ssl_ticket.h:78
void
*
MBEDTLS_PRIVATE
(
p_rng
)
;
/*!< context for the RNG function */
ssl_ticket.h:79
uint64_t
MBEDTLS_PRIVATE
(
opaque
)
[
4
]
;
timing.h:30
struct
mbedtls_timing_hr_time
MBEDTLS_PRIVATE
(
timer
)
;
timing.h:37
uint32_t
MBEDTLS_PRIVATE
(
int_ms
)
;
timing.h:38
uint32_t
MBEDTLS_PRIVATE
(
fin_ms
)
;
timing.h:39
while
(
dn
->
MBEDTLS_PRIVATE
(
next_merged
)
&&
dn
->
next
!=
NULL
)
{
x509.h:356
mbedtls_x509_buf
MBEDTLS_PRIVATE
(
sig_oid2
)
;
x509_crl.h:82
mbedtls_x509_buf
MBEDTLS_PRIVATE
(
sig
)
;
x509_crl.h:83
mbedtls_md_type_t
MBEDTLS_PRIVATE
(
sig_md
)
;
/**< Internal representation of the MD algorithm of the signature algorithm, e.g. MBEDTLS_MD_SHA256 */
x509_crl.h:84
mbedtls_pk_type_t
MBEDTLS_PRIVATE
(
sig_pk
)
;
/**< Internal representation of the Public Key algorithm of the signature algorithm, e.g. MBEDTLS_PK_RSA */
x509_crl.h:85
void
*
MBEDTLS_PRIVATE
(
sig_opts
)
;
/**< Signature options to be passed to mbedtls_pk_verify_ext(), e.g. for RSASSA-PSS */
x509_crl.h:86
return
crt
->
MBEDTLS_PRIVATE
(
ca_istrue
)
;
x509_crt.c:3298
int
MBEDTLS_PRIVATE
(
own_buffer
)
;
/**< Indicates if \c raw is owned
x509_crt.h:42
int
MBEDTLS_PRIVATE
(
ext_types
)
;
/**< Bit string containing detected and parsed extensions */
x509_crt.h:72
int
MBEDTLS_PRIVATE
(
ca_istrue
)
;
/**< Optional Basic Constraint extension value: 1 if this certificate belongs to a CA, 0 otherwise. */
x509_crt.h:73
int
MBEDTLS_PRIVATE
(
max_pathlen
)
;
/**< Optional Basic Constraint extension value: The maximum path length to the root certificate. Path length is 1 higher than RFC 5280 'meaning', so 1+ */
x509_crt.h:74
unsigned
int
MBEDTLS_PRIVATE
(
key_usage
)
;
/**< Optional key usage extension value: See the values in x509.h */
x509_crt.h:76
unsigned
char
MBEDTLS_PRIVATE
(
ns_cert_type
)
;
/**< Optional Netscape certificate type extension value: See the values in x509.h */
x509_crt.h:80
mbedtls_x509_buf
MBEDTLS_PRIVATE
(
sig
)
;
/**< Signature: hash of the tbs part signed with the private key. */
x509_crt.h:82
mbedtls_md_type_t
MBEDTLS_PRIVATE
(
sig_md
)
;
/**< Internal representation of the MD algorithm of the signature algorithm, e.g. MBEDTLS_MD_SHA256 */
x509_crt.h:83
mbedtls_pk_type_t
MBEDTLS_PRIVATE
(
sig_pk
)
;
/**< Internal representation of the Public Key algorithm of the signature algorithm, e.g. MBEDTLS_PK_RSA */
x509_crt.h:84
void
*
MBEDTLS_PRIVATE
(
sig_opts
)
;
/**< Signature options to be passed to mbedtls_pk_verify_ext(), e.g. for RSASSA-PSS */
x509_crt.h:85
int
MBEDTLS_PRIVATE
(
version
)
;
x509_crt.h:218
unsigned
char
MBEDTLS_PRIVATE
(
serial
)
[
MBEDTLS_X509_RFC5280_MAX_SERIAL_LEN
]
;
x509_crt.h:219
size_t
MBEDTLS_PRIVATE
(
serial_len
)
;
x509_crt.h:220
mbedtls_pk_context
*
MBEDTLS_PRIVATE
(
subject_key
)
;
x509_crt.h:221
mbedtls_pk_context
*
MBEDTLS_PRIVATE
(
issuer_key
)
;
x509_crt.h:222
mbedtls_asn1_named_data
*
MBEDTLS_PRIVATE
(
subject
)
;
x509_crt.h:223
mbedtls_asn1_named_data
*
MBEDTLS_PRIVATE
(
issuer
)
;
x509_crt.h:224
mbedtls_md_type_t
MBEDTLS_PRIVATE
(
md_alg
)
;
x509_crt.h:225
char
MBEDTLS_PRIVATE
(
not_before
)
[
MBEDTLS_X509_RFC5280_UTC_TIME_LEN
+
1
]
;
x509_crt.h:226
char
MBEDTLS_PRIVATE
(
not_after
)
[
MBEDTLS_X509_RFC5280_UTC_TIME_LEN
+
1
]
;
x509_crt.h:227
mbedtls_asn1_named_data
*
MBEDTLS_PRIVATE
(
extensions
)
;
x509_crt.h:228
mbedtls_x509_crt
*
MBEDTLS_PRIVATE
(
crt
)
;
x509_crt.h:251
uint32_t
MBEDTLS_PRIVATE
(
flags
)
;
x509_crt.h:252
mbedtls_x509_crt_verify_chain_item
MBEDTLS_PRIVATE
(
items
)
[
MBEDTLS_X509_MAX_VERIFY_CHAIN_SIZE
]
;
x509_crt.h:264
unsigned
MBEDTLS_PRIVATE
(
len
)
;
x509_crt.h:265
return
ctx
->
MBEDTLS_PRIVATE
(
ext_types
)
&
ext_type
;
x509_crt.h:916
int
MBEDTLS_PRIVATE
(
ext_types
)
;
/**< Bit string containing detected and parsed extensions */
x509_csr.h:53
mbedtls_x509_buf
MBEDTLS_PRIVATE
(
sig
)
;
x509_csr.h:56
mbedtls_md_type_t
MBEDTLS_PRIVATE
(
sig_md
)
;
/**< Internal representation of the MD algorithm of the signature algorithm, e.g. MBEDTLS_MD_SHA256 */
x509_csr.h:57
mbedtls_pk_type_t
MBEDTLS_PRIVATE
(
sig_pk
)
;
/**< Internal representation of the Public Key algorithm of the signature algorithm, e.g. MBEDTLS_PK_RSA */
x509_csr.h:58
void
*
MBEDTLS_PRIVATE
(
sig_opts
)
;
/**< Signature options to be passed to mbedtls_pk_verify_ext(), e.g. for RSASSA-PSS */
x509_csr.h:59
mbedtls_pk_context
*
MBEDTLS_PRIVATE
(
key
)
;
x509_csr.h:67
mbedtls_asn1_named_data
*
MBEDTLS_PRIVATE
(
subject
)
;
x509_csr.h:68
mbedtls_md_type_t
MBEDTLS_PRIVATE
(
md_alg
)
;
x509_csr.h:69
mbedtls_asn1_named_data
*
MBEDTLS_PRIVATE
(
extensions
)
;
x509_csr.h:70
Call Tree
from
0/1
examples
All items filtered out
All items filtered out
Data Use
from
0/1
examples
All items filtered out
All items filtered out
Class Tree
from
0/1
examples
All items filtered out
All items filtered out
Override Tree
from
0/1
examples
All items filtered out
All items filtered out
Implementations
from
0/1
examples
All items filtered out
All items filtered out
Instances
from
0/1
examples
Lifecycle
from
0/1
examples
All items filtered out
All items filtered out