AES_BLOCK_SIZE - syntax, references, description

References

Code

Location

#define AES_BLOCK_SIZE 16

aes.h:12

u8 aad_buf[2 * AES_BLOCK_SIZE];

aes-ccm.c:33

u8 b[AES_BLOCK_SIZE];

aes-ccm.c:34

WPA_PUT_BE16(&b[AES_BLOCK_SIZE - L], plain_len);

aes-ccm.c:42

if (aad_len > AES_BLOCK_SIZE - 2) {

aes-ccm.c:57

xor_aes_block(&aad_buf[AES_BLOCK_SIZE], x);

aes-ccm.c:58

aes_encrypt(aes, &aad_buf[AES_BLOCK_SIZE], x);

aes-ccm.c:60

size_t last = len % AES_BLOCK_SIZE;

aes-ccm.c:67

for (i = 0; i < len / AES_BLOCK_SIZE; i++) {

aes-ccm.c:70

data += AES_BLOCK_SIZE;

aes-ccm.c:73

size_t last = len % AES_BLOCK_SIZE;

aes-ccm.c:96

for (i = 1; i <= len / AES_BLOCK_SIZE; i++) {

aes-ccm.c:100

WPA_PUT_BE16(&a[AES_BLOCK_SIZE - 2], i);

aes-ccm.c:101

out += AES_BLOCK_SIZE;

aes-ccm.c:105

in += AES_BLOCK_SIZE;

aes-ccm.c:106

WPA_PUT_BE16(&a[AES_BLOCK_SIZE - 2], i);

aes-ccm.c:109

u8 tmp[AES_BLOCK_SIZE];

aes-ccm.c:121

WPA_PUT_BE16(&a[AES_BLOCK_SIZE - 2], 0);

aes-ccm.c:125

u8 tmp[AES_BLOCK_SIZE];

aes-ccm.c:136

WPA_PUT_BE16(&a[AES_BLOCK_SIZE - 2], 0);

aes-ccm.c:140

u8 x[AES_BLOCK_SIZE], a[AES_BLOCK_SIZE];

aes-ccm.c:155

if (aad_len > 30 || M > AES_BLOCK_SIZE)

aes-ccm.c:157

u8 x[AES_BLOCK_SIZE], a[AES_BLOCK_SIZE];

aes-ccm.c:185

u8 t[AES_BLOCK_SIZE];

aes-ccm.c:186

if (aad_len > 30 || M > AES_BLOCK_SIZE)

aes-ccm.c:188

val = WPA_GET_BE32(block + AES_BLOCK_SIZE - 4);

aes-gcm.c:19

WPA_PUT_BE32(block + AES_BLOCK_SIZE - 4, val);

aes-gcm.c:21

u8 cb[AES_BLOCK_SIZE], tmp[AES_BLOCK_SIZE];

aes-gcm.c:146

os_memcpy(cb, icb, AES_BLOCK_SIZE);

aes-gcm.c:155

xpos += AES_BLOCK_SIZE;

aes-gcm.c:160

ypos += AES_BLOCK_SIZE;

aes-gcm.c:161

os_memset(H, 0, AES_BLOCK_SIZE);

aes-gcm.c:184

os_memset(J0 + iv_len, 0, AES_BLOCK_SIZE - iv_len);

aes-gcm.c:199

J0[AES_BLOCK_SIZE - 1] = 0x01;

aes-gcm.c:200

u8 J0inc[AES_BLOCK_SIZE];

aes-gcm.c:218

os_memcpy(J0inc, J0, AES_BLOCK_SIZE);

aes-gcm.c:223

u8 H[AES_BLOCK_SIZE];

aes-gcm.c:258

u8 J0[AES_BLOCK_SIZE];

aes-gcm.c:259

u8 H[AES_BLOCK_SIZE];

aes-gcm.c:292

u8 J0[AES_BLOCK_SIZE];

aes-gcm.c:293

static const u8 zero[AES_BLOCK_SIZE];

aes-siv.c:17

for (i = 0; i < AES_BLOCK_SIZE - 1; i++)

aes-siv.c:25

pad[AES_BLOCK_SIZE - 1] <<= 1;

aes-siv.c:27

pad[AES_BLOCK_SIZE - 1] ^= 0x87;

aes-siv.c:29

for (i = 0; i < AES_BLOCK_SIZE; i++)

aes-siv.c:37

os_memset(pad, 0, AES_BLOCK_SIZE);

aes-siv.c:56

if (len < AES_BLOCK_SIZE)

aes-siv.c:59

u8 tmp[AES_BLOCK_SIZE], tmp2[AES_BLOCK_SIZE];

aes-siv.c:67

tmp[AES_BLOCK_SIZE - 1] = 1;

aes-siv.c:76

if (len[i] >= AES_BLOCK_SIZE) {

aes-siv.c:97

xorend(buf, len[i], tmp, AES_BLOCK_SIZE);

aes-siv.c:102

u8 v[AES_BLOCK_SIZE];

aes-siv.c:127

crypt_pw = out + AES_BLOCK_SIZE;

aes-siv.c:150

os_memcpy(iv, v, AES_BLOCK_SIZE);

aes-siv.c:152

u8 iv[AES_BLOCK_SIZE];

aes-siv.c:173

u8 check[AES_BLOCK_SIZE];

aes-siv.c:174

if (iv_c_len < AES_BLOCK_SIZE || num_elem > ARRAY_SIZE(_addr) - 1 ||

aes-siv.c:176

crypt_len = iv_c_len - AES_BLOCK_SIZE;

aes-siv.c:179

os_memcpy(iv, iv_crypt, AES_BLOCK_SIZE);

aes-siv.c:191

os_memcpy(out, iv_crypt + AES_BLOCK_SIZE, crypt_len);

aes-siv.c:192

if (os_memcmp(check, iv_crypt, AES_BLOCK_SIZE) == 0)

aes-siv.c:204

u8 a[8], *r, b[AES_BLOCK_SIZE];

aes-unwrap.c:29

u8 *a, *r, b[AES_BLOCK_SIZE];

aes-wrap.c:28

plain = os_malloc(data_len + AES_BLOCK_SIZE);

ccmp.c:151

crypt = os_malloc(hdrlen + 8 + plen + 8 + AES_BLOCK_SIZE);

ccmp.c:203

crypt = os_malloc(hdrlen + plen + 8 + AES_BLOCK_SIZE);

ccmp.c:254

plain = os_malloc(data_len + AES_BLOCK_SIZE);

ccmp.c:293

crypt = os_malloc(hdrlen + 8 + plen + 16 + AES_BLOCK_SIZE);

ccmp.c:329

u8 wrapped_data[4 + DPP_MAX_NONCE_LEN + 4 + 1 + AES_BLOCK_SIZE];

dpp.c:461

siv_len += AES_BLOCK_SIZE;

dpp.c:583

4 + 4 + DPP_MAX_HASH_LEN + AES_BLOCK_SIZE

dpp.c:618

u8 wrapped_data[DPP_AUTH_RESP_CLEAR_LEN + AES_BLOCK_SIZE];

dpp.c:620

siv_len += AES_BLOCK_SIZE;

dpp.c:756

attr_len = 4 + clear_len + AES_BLOCK_SIZE;

dpp.c:1237

wpabuf_put_le16(msg, wpabuf_len(clear) + AES_BLOCK_SIZE);

dpp.c:1287

wrapped = wpabuf_put(msg, wpabuf_len(clear) + AES_BLOCK_SIZE);

dpp.c:1288

u8 wrapped_r_auth[4 + DPP_MAX_HASH_LEN + AES_BLOCK_SIZE], *w_r_auth;

dpp.c:1445

wrapped_r_auth_len = 4 + auth->curve->hash_len + AES_BLOCK_SIZE;

dpp.c:1540

if (!wrapped_data || wrapped_data_len < AES_BLOCK_SIZE) {

dpp.c:1721

unwrapped_len = wrapped_data_len - AES_BLOCK_SIZE;

dpp.c:1811

4 + i_auth_len + r_nonce_len + AES_BLOCK_SIZE;

dpp.c:1984

wpabuf_put_le16(msg, i_auth_len + AES_BLOCK_SIZE);

dpp.c:2070

wrapped_i_auth = wpabuf_put(msg, i_auth_len + AES_BLOCK_SIZE);

dpp.c:2071

wpabuf_put_le16(msg, r_nonce_len + AES_BLOCK_SIZE);

dpp.c:2101

wrapped_r_nonce = wpabuf_put(msg, r_nonce_len + AES_BLOCK_SIZE);

dpp.c:2102

unwrapped_len = wrapped_data_len - AES_BLOCK_SIZE;

dpp.c:2172

if (!wrapped_data || wrapped_data_len < AES_BLOCK_SIZE) {

dpp.c:2269

unwrapped_len = wrapped_data_len - AES_BLOCK_SIZE;

dpp.c:2394

if (!wrapped2 || wrapped2_len < AES_BLOCK_SIZE) {

dpp.c:2473

unwrapped2_len = wrapped2_len - AES_BLOCK_SIZE;

dpp.c:2485

unwrapped_len = wrapped_data_len - AES_BLOCK_SIZE;

dpp.c:2573

if (!wrapped_data || wrapped_data_len < AES_BLOCK_SIZE) {

dpp.c:2647

unwrapped_len = wrapped_data_len - AES_BLOCK_SIZE;

dpp.c:2731

attr_len = 4 + 1 + 4 + clear_len + AES_BLOCK_SIZE;

dpp.c:3558

wpabuf_put_le16(msg, wpabuf_len(clear) + AES_BLOCK_SIZE);

dpp.c:3644

wrapped = wpabuf_put(msg, wpabuf_len(clear) + AES_BLOCK_SIZE);

dpp.c:3645

if (!wrapped_data || wrapped_data_len < AES_BLOCK_SIZE) {

dpp.c:3704

unwrapped_len = wrapped_data_len - AES_BLOCK_SIZE;

dpp.c:3712

if (!wrapped_data || wrapped_data_len < AES_BLOCK_SIZE) {

dpp.c:4458

unwrapped_len = wrapped_data_len - AES_BLOCK_SIZE;

dpp.c:4466

if (elems.sae_pk_len < SAE_PK_M_LEN + AES_BLOCK_SIZE) {

sae_pk.c:660

elems.sae_pk, SAE_PK_M_LEN + AES_BLOCK_SIZE,

sae_pk.c:671

AES_BLOCK_SIZE macro

Syntax

Examples

References

Call Tree

Data Use

Class Tree

Override Tree

Implementations

Instances

Lifecycle