1 /* 2 * SAE-PK 3 * Copyright (c) 2020, The Linux Foundation 4 * 5 * This software may be distributed under the terms of the BSD license. 6 * See README for more details. 7 */ 8 9 #include "utils/includes.h" 10 #include <stdint.h> 11 12 #include "utils/common.h" 13 #include "utils/base64.h" 14 #include "common/ieee802_11_defs.h" 15 #include "common/ieee802_11_common.h" 16 #include "crypto/crypto.h" 17 #include "crypto/aes.h" 18 #include "crypto/aes_siv.h" 19 #include "sae.h" 20 21 22 /* RFC 4648 base 32 alphabet with lowercase characters */ 23 static const char *sae_pk_base32_table = "abcdefghijklmnopqrstuvwxyz234567"; 24 25 26 static const u8 d_mult_table[] = { 27 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 28 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 29 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 30 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 16, 31 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 32 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 16, 17, 33 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 34 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 16, 17, 18, 35 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 36 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 16, 17, 18, 19, 37 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 38 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 16, 17, 18, 19, 20, 39 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 40 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 16, 17, 18, 19, 20, 21, 41 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 42 23, 24, 25, 26, 27, 28, 29, 30, 31, 16, 17, 18, 19, 20, 21, 22, 43 8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7, 44 24, 25, 26, 27, 28, 29, 30, 31, 16, 17, 18, 19, 20, 21, 22, 23, 45 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7, 8, 46 25, 26, 27, 28, 29, 30, 31, 16, 17, 18, 19, 20, 21, 22, 23, 24, 47 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 48 26, 27, 28, 29, 30, 31, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 49 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 50 27, 28, 29, 30, 31, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 51 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 52 28, 29, 30, 31, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 53 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 54 29, 30, 31, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 55 14, 15, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 56 30, 31, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 57 15, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 58 31, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 59 16, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 60 0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 61 17, 16, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 62 1, 0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 63 18, 17, 16, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 64 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 65 19, 18, 17, 16, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 66 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 67 20, 19, 18, 17, 16, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 68 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 69 21, 20, 19, 18, 17, 16, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 70 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 71 22, 21, 20, 19, 18, 17, 16, 31, 30, 29, 28, 27, 26, 25, 24, 23, 72 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 73 23, 22, 21, 20, 19, 18, 17, 16, 31, 30, 29, 28, 27, 26, 25, 24, 74 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8, 75 24, 23, 22, 21, 20, 19, 18, 17, 16, 31, 30, 29, 28, 27, 26, 25, 76 8, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 77 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 31, 30, 29, 28, 27, 26, 78 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 79 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 31, 30, 29, 28, 27, 80 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 81 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 31, 30, 29, 28, 82 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 83 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 31, 30, 29, 84 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 85 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 31, 30, 86 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 87 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 31, 88 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 15, 89 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 90 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 91 }; 92 93 static const u8 d_perm_table[] = { 94 7, 2, 1, 30, 16, 20, 27, 11, 31, 6, 8, 13, 29, 5, 10, 21, 95 22, 3, 24, 0, 23, 25, 12, 9, 28, 14, 4, 15, 17, 18, 19, 26 96 }; 97 98 99 static u8 d_permute(u8 val, unsigned int iter) 100 { 101 if (iter == 0) 102 return val; 103 return d_permute(d_perm_table[val], iter - 1); 104 } 105 106 107 static u8 d_invert(u8 val) 108 { 109 if (val > 0 && val < 16) 110 return 16 - val; 111 return val; 112 } 113 114 115 static char d_check_char(const char *str, size_t len) 116 { 117 size_t i; 118 u8 val = 0; 119 u8 dtable[256]; 120 unsigned int iter = 1; 121 int j; 122 123 os_memset(dtable, 0x80, 256); 124 for (i = 0; sae_pk_base32_table[i]; i++) 125 dtable[(u8) sae_pk_base32_table[i]] = i; 126 127 for (j = len - 1; j >= 0; j--) { 128 u8 c, p; 129 130 c = dtable[(u8) str[j]]; 131 if (c == 0x80) 132 continue; 133 p = d_permute(c, iter); 134 iter++; 135 val = d_mult_table[val * 32 + p]; 136 } 137 138 return sae_pk_base32_table[d_invert(val)]; 139 } 140 141 142 bool sae_pk_valid_password(const char *pw) 143 { 144 int pos; 145 size_t i, pw_len = os_strlen(pw); 146 u8 sec_1b; 147 u8 dtable[256]; 148 149 os_memset(dtable, 0x80, 256); 150 for (i = 0; sae_pk_base32_table[i]; i++) 151 dtable[(u8) sae_pk_base32_table[i]] = i; 152 153 /* SAE-PK password has at least three four character components 154 * separated by hyphens. */ 155 if (pw_len < 14 || pw_len % 5 != 4) { 156 wpa_printf(MSG_DEBUG, "SAE-PK: Not a valid password (length)"); 157 return false; 158 } 159 160 for (pos = 0; pw[pos]; pos++) { 161 if (pos && pos % 5 == 4) { 162 if (pw[pos] != '-') { 163 wpa_printf(MSG_DEBUG, 164 "SAE-PK: Not a valid password (separator)"); 165 return false; 166 } 167 continue; 168 } 169 if (dtable[(u8) pw[pos]] == 0x80) { 170 wpa_printf(MSG_DEBUG, 171 "SAE-PK: Not a valid password (character)"); 172 return false; 173 } 174 } 175 176 /* Verify that the checksum character is valid */ 177 if (pw[pw_len - 1] != d_check_char(pw, pw_len - 1)) { 178 wpa_printf(MSG_DEBUG, 179 "SAE-PK: Not a valid password (checksum)"); 180 return false; 181 } 182 183 /* Verify that Sec_1b bits match */ 184 sec_1b = dtable[(u8) pw[0]] & BIT(4); 185 for (i = 5; i < pw_len; i += 5) { 186 if (sec_1b != (dtable[(u8) pw[i]] & BIT(4))) { 187 wpa_printf(MSG_DEBUG, 188 "SAE-PK: Not a valid password (Sec_1b)"); 189 return false; 190 } 191 } 192 return true; 193 } 194 195 196 static char * add_char(const char *start, char *pos, u8 idx, size_t *bits) 197 { 198 if (*bits == 0) 199 return pos; 200 if (*bits > 5) 201 *bits -= 5; 202 else 203 *bits = 0; 204 205 if ((pos - start) % 5 == 4) 206 *pos++ = '-'; 207 *pos++ = sae_pk_base32_table[idx]; 208 return pos; 209 } 210 211 212 /* Base32 encode a password and add hyper separators and checksum */ 213 char * sae_pk_base32_encode(const u8 *src, size_t len_bits) 214 { 215 char *out, *pos; 216 size_t olen, extra_pad, i; 217 u64 block = 0; 218 u8 val; 219 size_t len = (len_bits + 7) / 8; 220 size_t left = len_bits; 221 int j; 222 223 if (len == 0 || len >= SIZE_MAX / 8) 224 return NULL; 225 olen = len * 8 / 5 + 1; 226 olen += olen / 4; /* hyphen separators */ 227 pos = out = os_zalloc(olen + 2); /* include room for ChkSum and nul */ 228 if (!out) 229 return NULL; 230 231 extra_pad = (5 - len % 5) % 5; 232 for (i = 0; i < len + extra_pad; i++) { 233 val = i < len ? src[i] : 0; 234 block <<= 8; 235 block |= val; 236 if (i % 5 == 4) { 237 for (j = 7; j >= 0; j--) 238 pos = add_char(out, pos, 239 (block >> j * 5) & 0x1f, &left); 240 block = 0; 241 } 242 } 243 244 *pos = d_check_char(out, os_strlen(out)); 245 246 return out; 247 } 248 249 250 u8 * sae_pk_base32_decode(const char *src, size_t len, size_t *out_len) 251 { 252 u8 dtable[256], *out, *pos, tmp; 253 u64 block = 0; 254 size_t i, count, olen; 255 int pad = 0; 256 size_t extra_pad; 257 258 os_memset(dtable, 0x80, 256); 259 for (i = 0; sae_pk_base32_table[i]; i++) 260 dtable[(u8) sae_pk_base32_table[i]] = i; 261 dtable['='] = 0; 262 263 count = 0; 264 for (i = 0; i < len; i++) { 265 if (dtable[(u8) src[i]] != 0x80) 266 count++; 267 } 268 269 if (count == 0) 270 return NULL; 271 extra_pad = (8 - count % 8) % 8; 272 273 olen = (count + extra_pad) / 8 * 5; 274 pos = out = os_malloc(olen); 275 if (!out) 276 return NULL; 277 278 count = 0; 279 for (i = 0; i < len + extra_pad; i++) { 280 u8 val; 281 282 if (i >= len) 283 val = '='; 284 else 285 val = src[i]; 286 tmp = dtable[val]; 287 if (tmp == 0x80) 288 continue; 289 290 if (val == '=') 291 pad++; 292 block <<= 5; 293 block |= tmp; 294 count++; 295 if (count == 8) { 296 *pos++ = (block >> 32) & 0xff; 297 *pos++ = (block >> 24) & 0xff; 298 *pos++ = (block >> 16) & 0xff; 299 *pos++ = (block >> 8) & 0xff; 300 *pos++ = block & 0xff; 301 count = 0; 302 block = 0; 303 if (pad) { 304 /* Leave in all the available bits with zero 305 * padding to full octets from right. */ 306 pos -= pad * 5 / 8; 307 break; 308 } 309 } 310 } 311 312 *out_len = pos - out; 313 return out; 314 } 315 316 317 u32 sae_pk_get_be19(const u8 *buf) 318 { 319 return (buf[0] << 11) | (buf[1] << 3) | (buf[2] >> 5); 320 } 321 322 323 /* shift left by two octets and three bits; fill in zeros from right; 324 * len must be at least three */ 325 void sae_pk_buf_shift_left_19(u8 *buf, size_t len) 326 { 327 u8 *dst, *src, *end; 328 329 dst = buf; 330 src = buf + 2; 331 end = buf + len; 332 333 while (src + 1 < end) { 334 *dst++ = (src[0] << 3) | (src[1] >> 5); 335 src++; 336 } 337 *dst++ = *src << 3; 338 *dst++ = 0; 339 *dst++ = 0; 340 } 341 342 343 static void sae_pk_buf_shift_left_1(u8 *buf, size_t len) 344 { 345 u8 *dst, *src, *end; 346 347 dst = buf; 348 src = buf; 349 end = buf + len; 350 351 while (src + 1 < end) { 352 *dst++ = (src[0] << 1) | (src[1] >> 7); 353 src++; 354 } 355 *dst++ = *src << 1; 356 } 357 358 359 int sae_pk_set_password(struct sae_data *sae, const char *password) 360 { 361 struct sae_temporary_data *tmp = sae->tmp; 362 size_t len, pw_len; 363 u8 *pw, *pos; 364 int bits; 365 u32 val = 0, val19; 366 unsigned int val_bits = 0; 367 368 if (!tmp) 369 return -1; 370 371 os_memset(tmp->fingerprint, 0, sizeof(tmp->fingerprint)); 372 tmp->fingerprint_bytes = tmp->fingerprint_bits = 0; 373 374 len = os_strlen(password); 375 if (len < 1 || !sae_pk_valid_password(password)) 376 return -1; 377 378 pw = sae_pk_base32_decode(password, len, &pw_len); 379 if (!pw) 380 return -1; 381 382 tmp->sec = (pw[0] & BIT(7)) ? 3 : 5; 383 tmp->lambda = len - len / 5; 384 tmp->fingerprint_bits = 8 * tmp->sec + 19 * tmp->lambda / 4 - 5; 385 wpa_printf(MSG_DEBUG, "SAE-PK: Sec=%u Lambda=%zu fingerprint_bits=%zu", 386 tmp->sec, tmp->lambda, tmp->fingerprint_bits); 387 388 /* Construct Fingerprint from PasswordBase by prefixing with Sec zero 389 * octets and skipping the Sec_1b bits */ 390 pos = &tmp->fingerprint[tmp->sec]; 391 bits = tmp->fingerprint_bits - 8 * tmp->sec; 392 wpa_hexdump_key(MSG_DEBUG, "SAE-PK: PasswordBase", pw, pw_len); 393 while (bits > 0) { 394 if (val_bits < 8) { 395 sae_pk_buf_shift_left_1(pw, pw_len); /* Sec_1b */ 396 val19 = sae_pk_get_be19(pw); 397 sae_pk_buf_shift_left_19(pw, pw_len); 398 val = (val << 19) | val19; 399 val_bits += 19; 400 } 401 if (val_bits >= 8) { 402 if (bits < 8) 403 break; 404 *pos++ = (val >> (val_bits - 8)) & 0xff; 405 val_bits -= 8; 406 bits -= 8; 407 } 408 } 409 if (bits > 0) { 410 val >>= val_bits - bits; 411 *pos++ = val << (8 - bits); 412 } 413 tmp->fingerprint_bytes = pos - tmp->fingerprint; 414 wpa_hexdump_key(MSG_DEBUG, "SAE-PK: Fingerprint", 415 tmp->fingerprint, tmp->fingerprint_bytes); 416 bin_clear_free(pw, pw_len); 417 return 0; 418 } 419 420 421 static size_t sae_group_2_hash_len(int group) 422 { 423 switch (group) { 424 case 19: 425 return 32; 426 case 20: 427 return 48; 428 case 21: 429 return 64; 430 } 431 432 return 0; 433 } 434 435 436 void sae_deinit_pk(struct sae_pk *pk) 437 { 438 if (pk) { 439 wpabuf_free(pk->m); 440 crypto_ec_key_deinit(pk->key); 441 #ifdef CONFIG_TESTING_OPTIONS 442 crypto_ec_key_deinit(pk->sign_key_override); 443 #endif /* CONFIG_TESTING_OPTIONS */ 444 wpabuf_free(pk->pubkey); 445 os_free(pk); 446 } 447 } 448 449 450 struct sae_pk * sae_parse_pk(const char *val) 451 { 452 struct sae_pk *pk; 453 const char *pos; 454 #ifdef CONFIG_TESTING_OPTIONS 455 const char *pos2; 456 #endif /* CONFIG_TESTING_OPTIONS */ 457 size_t len; 458 unsigned char *der; 459 size_t der_len, b_len; 460 461 /* <m-as-hexdump>:<base64-encoded-DER-encoded-key> */ 462 463 pos = os_strchr(val, ':'); 464 if (!pos || (pos - val) & 0x01) 465 return NULL; 466 len = (pos - val) / 2; 467 if (len != SAE_PK_M_LEN) { 468 wpa_printf(MSG_INFO, "SAE: Unexpected Modifier M length %zu", 469 len); 470 return NULL; 471 } 472 473 pk = os_zalloc(sizeof(*pk)); 474 if (!pk) 475 return NULL; 476 pk->m = wpabuf_alloc(len); 477 if (!pk->m || hexstr2bin(val, wpabuf_put(pk->m, len), len)) { 478 wpa_printf(MSG_INFO, "SAE: Failed to parse m"); 479 goto fail; 480 } 481 482 pos++; 483 b_len = os_strlen(pos); 484 #ifdef CONFIG_TESTING_OPTIONS 485 pos2 = os_strchr(pos, ':'); 486 if (pos2) { 487 b_len = pos2 - pos; 488 pos2++; 489 } 490 #endif /* CONFIG_TESTING_OPTIONS */ 491 der = base64_decode(pos, b_len, &der_len); 492 if (!der) { 493 wpa_printf(MSG_INFO, "SAE: Failed to base64 decode PK key"); 494 goto fail; 495 } 496 497 pk->key = crypto_ec_key_parse_priv(der, der_len); 498 bin_clear_free(der, der_len); 499 if (!pk->key) 500 goto fail; 501 pk->group = crypto_ec_key_group(pk->key); 502 pk->pubkey = crypto_ec_key_get_subject_public_key(pk->key); 503 if (!pk->pubkey) 504 goto fail; 505 506 #ifdef CONFIG_TESTING_OPTIONS 507 if (pos2) { 508 der = base64_decode(pos2, os_strlen(pos2), &der_len); 509 if (!der) { 510 wpa_printf(MSG_INFO, 511 "SAE: Failed to base64 decode PK key"); 512 goto fail; 513 } 514 515 pk->sign_key_override = crypto_ec_key_parse_priv(der, der_len); 516 bin_clear_free(der, der_len); 517 if (!pk->sign_key_override) 518 goto fail; 519 } 520 #endif /* CONFIG_TESTING_OPTIONS */ 521 522 return pk; 523 fail: 524 sae_deinit_pk(pk); 525 return NULL; 526 } 527 528 529 int sae_hash(size_t hash_len, const u8 *data, size_t len, u8 *hash) 530 { 531 if (hash_len == 32) 532 return sha256_vector(1, &data, &len, hash); 533 #ifdef CONFIG_SHA384 534 if (hash_len == 48) 535 return sha384_vector(1, &data, &len, hash); 536 #endif /* CONFIG_SHA384 */ 537 #ifdef CONFIG_SHA512 538 if (hash_len == 64) 539 return sha512_vector(1, &data, &len, hash); 540 #endif /* CONFIG_SHA512 */ 541 return -1; 542 } 543 544 545 static int sae_pk_hash_sig_data(struct sae_data *sae, size_t hash_len, 546 bool ap, const u8 *m, size_t m_len, 547 const u8 *pubkey, size_t pubkey_len, u8 *hash) 548 { 549 struct sae_temporary_data *tmp = sae->tmp; 550 struct wpabuf *sig_data; 551 u8 *pos; 552 int ret = -1; 553 554 /* Signed data for KeyAuth: eleAP || eleSTA || scaAP || scaSTA || 555 * M || K_AP || AP-BSSID || STA-MAC */ 556 sig_data = wpabuf_alloc(tmp->prime_len * 6 + m_len + pubkey_len + 557 2 * ETH_ALEN); 558 if (!sig_data) 559 goto fail; 560 pos = wpabuf_put(sig_data, 2 * tmp->prime_len); 561 if (crypto_ec_point_to_bin(tmp->ec, ap ? tmp->own_commit_element_ecc : 562 tmp->peer_commit_element_ecc, 563 pos, pos + tmp->prime_len) < 0) 564 goto fail; 565 pos = wpabuf_put(sig_data, 2 * tmp->prime_len); 566 if (crypto_ec_point_to_bin(tmp->ec, ap ? tmp->peer_commit_element_ecc : 567 tmp->own_commit_element_ecc, 568 pos, pos + tmp->prime_len) < 0) 569 goto fail; 570 if (crypto_bignum_to_bin(ap ? tmp->own_commit_scalar : 571 sae->peer_commit_scalar, 572 wpabuf_put(sig_data, tmp->prime_len), 573 tmp->prime_len, tmp->prime_len) < 0 || 574 crypto_bignum_to_bin(ap ? sae->peer_commit_scalar : 575 tmp->own_commit_scalar, 576 wpabuf_put(sig_data, tmp->prime_len), 577 tmp->prime_len, tmp->prime_len) < 0) 578 goto fail; 579 wpabuf_put_data(sig_data, m, m_len); 580 wpabuf_put_data(sig_data, pubkey, pubkey_len); 581 wpabuf_put_data(sig_data, ap ? tmp->own_addr : tmp->peer_addr, 582 ETH_ALEN); 583 wpabuf_put_data(sig_data, ap ? tmp->peer_addr : tmp->own_addr, 584 ETH_ALEN); 585 wpa_hexdump_buf_key(MSG_DEBUG, "SAE-PK: Data to be signed for KeyAuth", 586 sig_data); 587 if (sae_hash(hash_len, wpabuf_head(sig_data), wpabuf_len(sig_data), 588 hash) < 0) 589 goto fail; 590 wpa_hexdump(MSG_DEBUG, "SAE-PK: hash(data to be signed)", 591 hash, hash_len); 592 ret = 0; 593 fail: 594 wpabuf_free(sig_data); 595 return ret; 596 } 597 598 599 int sae_write_confirm_pk(struct sae_data *sae, struct wpabuf *buf) 600 { 601 struct sae_temporary_data *tmp = sae->tmp; 602 struct wpabuf *sig = NULL; 603 size_t need; 604 int ret = -1; 605 u8 *encr_mod; 606 size_t encr_mod_len; 607 const struct sae_pk *pk; 608 u8 hash[SAE_MAX_HASH_LEN]; 609 size_t hash_len; 610 struct crypto_ec_key *key; 611 612 if (!tmp) 613 return -1; 614 615 pk = tmp->ap_pk; 616 if (!sae->pk || !pk) 617 return 0; 618 619 key = pk->key; 620 #ifdef CONFIG_TESTING_OPTIONS 621 if (tmp->omit_pk_elem) 622 return 0; 623 if (pk->sign_key_override) { 624 wpa_printf(MSG_INFO, "TESTING: Override SAE-PK signing key"); 625 key = pk->sign_key_override; 626 } 627 #endif /* CONFIG_TESTING_OPTIONS */ 628 629 if (tmp->kek_len != 32 && tmp->kek_len != 48 && tmp->kek_len != 64) { 630 wpa_printf(MSG_INFO, 631 "SAE-PK: No KEK available for writing confirm"); 632 return -1; 633 } 634 635 if (!tmp->ec) { 636 /* Only ECC groups are supported for SAE-PK in the current 637 * implementation. */ 638 wpa_printf(MSG_INFO, 639 "SAE-PK: SAE commit did not use an ECC group"); 640 return -1; 641 } 642 643 hash_len = sae_group_2_hash_len(pk->group); 644 if (sae_pk_hash_sig_data(sae, hash_len, true, wpabuf_head(pk->m), 645 wpabuf_len(pk->m), wpabuf_head(pk->pubkey), 646 wpabuf_len(pk->pubkey), hash) < 0) 647 goto fail; 648 sig = crypto_ec_key_sign(key, hash, hash_len); 649 if (!sig) 650 goto fail; 651 wpa_hexdump_buf(MSG_DEBUG, "SAE-PK: KeyAuth = Sig_AP()", sig); 652 653 /* TODO: fragmentation if any of the elements needs it for a group 654 * using sufficiently large primes (none of the currently supported 655 * ones do) */ 656 657 encr_mod_len = wpabuf_len(pk->m) + AES_BLOCK_SIZE; 658 need = 4 + wpabuf_len(pk->pubkey) + 3 + wpabuf_len(sig) + 659 6 + encr_mod_len; 660 if (wpabuf_tailroom(buf) < need) { 661 wpa_printf(MSG_INFO, 662 "SAE-PK: No room in message buffer for SAE-PK elements (%zu < %zu)", 663 wpabuf_tailroom(buf), need); 664 goto fail; 665 } 666 667 /* FILS Public Key element */ 668 wpabuf_put_u8(buf, WLAN_EID_EXTENSION); 669 wpabuf_put_u8(buf, 2 + wpabuf_len(pk->pubkey)); 670 wpabuf_put_u8(buf, WLAN_EID_EXT_FILS_PUBLIC_KEY); 671 wpabuf_put_u8(buf, 2); /* Key Type: ECDSA public key */ 672 wpabuf_put_buf(buf, pk->pubkey); 673 674 /* FILS Key Confirmation element (KeyAuth) */ 675 wpabuf_put_u8(buf, WLAN_EID_EXTENSION); 676 wpabuf_put_u8(buf, 1 + wpabuf_len(sig)); 677 wpabuf_put_u8(buf, WLAN_EID_EXT_FILS_KEY_CONFIRM); 678 /* KeyAuth = Sig_AP(eleAP || eleSTA || scaAP || scaSTA || M || K_AP || 679 * AP-BSSID || STA-MAC) */ 680 wpabuf_put_buf(buf, sig); 681 682 /* SAE-PK element */ 683 wpabuf_put_u8(buf, WLAN_EID_VENDOR_SPECIFIC); 684 wpabuf_put_u8(buf, 4 + encr_mod_len); 685 wpabuf_put_be32(buf, SAE_PK_IE_VENDOR_TYPE); 686 /* EncryptedModifier = AES-SIV-Q(M); no AAD */ 687 encr_mod = wpabuf_put(buf, encr_mod_len); 688 if (aes_siv_encrypt(tmp->kek, tmp->kek_len, 689 wpabuf_head(pk->m), wpabuf_len(pk->m), 690 0, NULL, NULL, encr_mod) < 0) 691 goto fail; 692 wpa_hexdump(MSG_DEBUG, "SAE-PK: EncryptedModifier", 693 encr_mod, encr_mod_len); 694 695 ret = 0; 696 fail: 697 wpabuf_free(sig); 698 return ret; 699 700 } 701 702 703 static bool sae_pk_valid_fingerprint(struct sae_data *sae, 704 const u8 *m, size_t m_len, 705 const u8 *k_ap, size_t k_ap_len, int group) 706 { 707 struct sae_temporary_data *tmp = sae->tmp; 708 u8 *hash_data, *pos; 709 size_t hash_len, hash_data_len; 710 u8 hash[SAE_MAX_HASH_LEN]; 711 int res; 712 713 if (!tmp->fingerprint_bytes) { 714 wpa_printf(MSG_DEBUG, 715 "SAE-PK: No PW available for K_AP fingerprint check"); 716 return false; 717 } 718 719 /* Fingerprint = L(Hash(SSID || M || K_AP), 0, 8*Sec + 19*Lambda/4 - 5) 720 */ 721 722 hash_len = sae_group_2_hash_len(group); 723 hash_data_len = tmp->ssid_len + m_len + k_ap_len; 724 hash_data = os_malloc(hash_data_len); 725 if (!hash_data) 726 return false; 727 pos = hash_data; 728 os_memcpy(pos, tmp->ssid, tmp->ssid_len); 729 pos += tmp->ssid_len; 730 os_memcpy(pos, m, m_len); 731 pos += m_len; 732 os_memcpy(pos, k_ap, k_ap_len); 733 734 wpa_hexdump_key(MSG_DEBUG, "SAE-PK: SSID || M || K_AP", 735 hash_data, hash_data_len); 736 res = sae_hash(hash_len, hash_data, hash_data_len, hash); 737 bin_clear_free(hash_data, hash_data_len); 738 if (res < 0) 739 return false; 740 wpa_hexdump(MSG_DEBUG, "SAE-PK: Hash(SSID || M || K_AP)", 741 hash, hash_len); 742 743 if (tmp->fingerprint_bits > hash_len * 8) { 744 wpa_printf(MSG_INFO, 745 "SAE-PK: Not enough hash output bits for the fingerprint"); 746 return false; 747 } 748 if (tmp->fingerprint_bits % 8) { 749 size_t extra; 750 751 /* Zero out the extra bits in the last octet */ 752 extra = 8 - tmp->fingerprint_bits % 8; 753 pos = &hash[tmp->fingerprint_bits / 8]; 754 *pos = (*pos >> extra) << extra; 755 } 756 wpa_hexdump(MSG_DEBUG, "SAE-PK: Fingerprint", hash, 757 tmp->fingerprint_bytes); 758 res = os_memcmp_const(hash, tmp->fingerprint, tmp->fingerprint_bytes); 759 if (res) { 760 wpa_printf(MSG_DEBUG, "SAE-PK: K_AP fingerprint mismatch"); 761 wpa_hexdump(MSG_DEBUG, "SAE-PK: Expected fingerprint", 762 tmp->fingerprint, tmp->fingerprint_bytes); 763 return false; 764 } 765 766 wpa_printf(MSG_DEBUG, "SAE-PK: Valid K_AP fingerprint"); 767 return true; 768 } 769 770 771 int sae_check_confirm_pk(struct sae_data *sae, const u8 *ies, size_t ies_len) 772 { 773 struct sae_temporary_data *tmp = sae->tmp; 774 const u8 *k_ap; 775 u8 m[SAE_PK_M_LEN]; 776 size_t k_ap_len; 777 struct crypto_ec_key *key; 778 int res; 779 u8 hash[SAE_MAX_HASH_LEN]; 780 size_t hash_len; 781 int group; 782 struct ieee802_11_elems elems; 783 784 if (!tmp) 785 return -1; 786 if (!sae->pk || tmp->ap_pk) 787 return 0; 788 789 if (tmp->kek_len != 32 && tmp->kek_len != 48 && tmp->kek_len != 64) { 790 wpa_printf(MSG_INFO, 791 "SAE-PK: No KEK available for checking confirm"); 792 return -1; 793 } 794 795 if (!tmp->ec) { 796 /* Only ECC groups are supported for SAE-PK in the current 797 * implementation. */ 798 wpa_printf(MSG_INFO, 799 "SAE-PK: SAE commit did not use an ECC group"); 800 return -1; 801 } 802 803 wpa_hexdump(MSG_DEBUG, "SAE-PK: Received confirm IEs", ies, ies_len); 804 if (ieee802_11_parse_elems(ies, ies_len, &elems, 1) == ParseFailed) { 805 wpa_printf(MSG_INFO, "SAE-PK: Failed to parse confirm IEs"); 806 return -1; 807 } 808 if (!elems.fils_pk || !elems.fils_key_confirm || !elems.sae_pk) { 809 wpa_printf(MSG_INFO, 810 "SAE-PK: Not all mandatory IEs included in confirm"); 811 return -1; 812 } 813 814 /* TODO: Fragment reassembly */ 815 816 if (elems.sae_pk_len < SAE_PK_M_LEN + AES_BLOCK_SIZE) { 817 wpa_printf(MSG_INFO, 818 "SAE-PK: No room for EncryptedModifier in SAE-PK element"); 819 return -1; 820 } 821 822 wpa_hexdump(MSG_DEBUG, "SAE-PK: EncryptedModifier", 823 elems.sae_pk, SAE_PK_M_LEN + AES_BLOCK_SIZE); 824 825 if (aes_siv_decrypt(tmp->kek, tmp->kek_len, 826 elems.sae_pk, SAE_PK_M_LEN + AES_BLOCK_SIZE, 827 0, NULL, NULL, m) < 0) { 828 wpa_printf(MSG_INFO, 829 "SAE-PK: Failed to decrypt EncryptedModifier"); 830 return -1; 831 } 832 wpa_hexdump_key(MSG_DEBUG, "SAE-PK: Modifier M", m, SAE_PK_M_LEN); 833 834 if (elems.fils_pk[0] != 2) { 835 wpa_printf(MSG_INFO, "SAE-PK: Unsupported public key type %u", 836 elems.fils_pk[0]); 837 return -1; 838 } 839 k_ap_len = elems.fils_pk_len - 1; 840 k_ap = elems.fils_pk + 1; 841 wpa_hexdump(MSG_DEBUG, "SAE-PK: Received K_AP", k_ap, k_ap_len); 842 /* TODO: Check against the public key, if one is stored in the network 843 * profile */ 844 845 key = crypto_ec_key_parse_pub(k_ap, k_ap_len); 846 if (!key) { 847 wpa_printf(MSG_INFO, "SAE-PK: Failed to parse K_AP"); 848 return -1; 849 } 850 851 group = crypto_ec_key_group(key); 852 if (!sae_pk_valid_fingerprint(sae, m, SAE_PK_M_LEN, k_ap, k_ap_len, 853 group)) { 854 crypto_ec_key_deinit(key); 855 return -1; 856 } 857 858 wpa_hexdump(MSG_DEBUG, "SAE-PK: Received KeyAuth", 859 elems.fils_key_confirm, elems.fils_key_confirm_len); 860 861 hash_len = sae_group_2_hash_len(group); 862 if (sae_pk_hash_sig_data(sae, hash_len, false, m, SAE_PK_M_LEN, 863 k_ap, k_ap_len, hash) < 0) { 864 crypto_ec_key_deinit(key); 865 return -1; 866 } 867 868 res = crypto_ec_key_verify_signature(key, hash, hash_len, 869 elems.fils_key_confirm, 870 elems.fils_key_confirm_len); 871 crypto_ec_key_deinit(key); 872 873 if (res != 1) { 874 wpa_printf(MSG_INFO, 875 "SAE-PK: Invalid or incorrect signature in KeyAuth"); 876 return -1; 877 } 878 879 wpa_printf(MSG_DEBUG, "SAE-PK: Valid KeyAuth signature received"); 880 881 /* TODO: Store validated public key into network profile */ 882 883 return 0; 884 } 885
Indexes created Fri Jun 19 00:25:02 UTC 2026