1 /* 2 * EAP-TNC - TNCC (IF-IMC and IF-TNCCS) 3 * Copyright (c) 2007, Jouni Malinen <j@w1.fi> 4 * 5 * This software may be distributed under the terms of the BSD license. 6 * See README for more details. 7 */ 8 9 #include "includes.h" 10 #ifndef CONFIG_NATIVE_WINDOWS 11 #include <dlfcn.h> 12 #endif /* CONFIG_NATIVE_WINDOWS */ 13 14 #include "common.h" 15 #include "base64.h" 16 #include "tncc.h" 17 #include "eap_common/eap_tlv_common.h" 18 #include "eap_common/eap_defs.h" 19 20 21 #ifdef UNICODE 22 #define TSTR "%S" 23 #else /* UNICODE */ 24 #define TSTR "%s" 25 #endif /* UNICODE */ 26 27 28 #define TNC_CONFIG_FILE "/etc/tnc_config" 29 #define TNC_WINREG_PATH TEXT("SOFTWARE\\Trusted Computing Group\\TNC\\IMCs") 30 #define IF_TNCCS_START \ 31 "<?xml version=\"1.0\"?>\n" \ 32 "<TNCCS-Batch BatchId=\"%d\" Recipient=\"TNCS\" " \ 33 "xmlns=\"http://www.trustedcomputinggroup.org/IWG/TNC/1_0/IF_TNCCS#\" " \ 34 "xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" " \ 35 "xsi:schemaLocation=\"http://www.trustedcomputinggroup.org/IWG/TNC/1_0/" \ 36 "IF_TNCCS# https://www.trustedcomputinggroup.org/XML/SCHEMA/TNCCS_1.0.xsd\">\n" 37 #define IF_TNCCS_END "\n</TNCCS-Batch>" 38 39 /* TNC IF-IMC */ 40 41 typedef unsigned long TNC_UInt32; 42 typedef unsigned char *TNC_BufferReference; 43 44 typedef TNC_UInt32 TNC_IMCID; 45 typedef TNC_UInt32 TNC_ConnectionID; 46 typedef TNC_UInt32 TNC_ConnectionState; 47 typedef TNC_UInt32 TNC_RetryReason; 48 typedef TNC_UInt32 TNC_MessageType; 49 typedef TNC_MessageType *TNC_MessageTypeList; 50 typedef TNC_UInt32 TNC_VendorID; 51 typedef TNC_UInt32 TNC_MessageSubtype; 52 typedef TNC_UInt32 TNC_Version; 53 typedef TNC_UInt32 TNC_Result; 54 55 typedef TNC_Result (*TNC_TNCC_BindFunctionPointer)( 56 TNC_IMCID imcID, 57 char *functionName, 58 void **pOutfunctionPointer); 59 60 #define TNC_RESULT_SUCCESS 0 61 #define TNC_RESULT_NOT_INITIALIZED 1 62 #define TNC_RESULT_ALREADY_INITIALIZED 2 63 #define TNC_RESULT_NO_COMMON_VERSION 3 64 #define TNC_RESULT_CANT_RETRY 4 65 #define TNC_RESULT_WONT_RETRY 5 66 #define TNC_RESULT_INVALID_PARAMETER 6 67 #define TNC_RESULT_CANT_RESPOND 7 68 #define TNC_RESULT_ILLEGAL_OPERATION 8 69 #define TNC_RESULT_OTHER 9 70 #define TNC_RESULT_FATAL 10 71 72 #define TNC_CONNECTION_STATE_CREATE 0 73 #define TNC_CONNECTION_STATE_HANDSHAKE 1 74 #define TNC_CONNECTION_STATE_ACCESS_ALLOWED 2 75 #define TNC_CONNECTION_STATE_ACCESS_ISOLATED 3 76 #define TNC_CONNECTION_STATE_ACCESS_NONE 4 77 #define TNC_CONNECTION_STATE_DELETE 5 78 79 #define TNC_IFIMC_VERSION_1 1 80 81 #define TNC_VENDORID_ANY ((TNC_VendorID) 0xffffff) 82 #define TNC_SUBTYPE_ANY ((TNC_MessageSubtype) 0xff) 83 84 /* TNCC-TNCS Message Types */ 85 #define TNC_TNCCS_RECOMMENDATION 0x00000001 86 #define TNC_TNCCS_ERROR 0x00000002 87 #define TNC_TNCCS_PREFERREDLANGUAGE 0x00000003 88 #define TNC_TNCCS_REASONSTRINGS 0x00000004 89 90 91 /* IF-TNCCS-SOH - SSoH and SSoHR Attributes */ 92 enum { 93 SSOH_MS_MACHINE_INVENTORY = 1, 94 SSOH_MS_QUARANTINE_STATE = 2, 95 SSOH_MS_PACKET_INFO = 3, 96 SSOH_MS_SYSTEMGENERATED_IDS = 4, 97 SSOH_MS_MACHINENAME = 5, 98 SSOH_MS_CORRELATIONID = 6, 99 SSOH_MS_INSTALLED_SHVS = 7, 100 SSOH_MS_MACHINE_INVENTORY_EX = 8 101 }; 102 103 struct tnc_if_imc { 104 struct tnc_if_imc *next; 105 char *name; 106 char *path; 107 void *dlhandle; /* from dlopen() */ 108 TNC_IMCID imcID; 109 TNC_ConnectionID connectionID; 110 TNC_MessageTypeList supported_types; 111 size_t num_supported_types; 112 u8 *imc_send; 113 size_t imc_send_len; 114 115 /* Functions implemented by IMCs (with TNC_IMC_ prefix) */ 116 TNC_Result (*Initialize)( 117 TNC_IMCID imcID, 118 TNC_Version minVersion, 119 TNC_Version maxVersion, 120 TNC_Version *pOutActualVersion); 121 TNC_Result (*NotifyConnectionChange)( 122 TNC_IMCID imcID, 123 TNC_ConnectionID connectionID, 124 TNC_ConnectionState newState); 125 TNC_Result (*BeginHandshake)( 126 TNC_IMCID imcID, 127 TNC_ConnectionID connectionID); 128 TNC_Result (*ReceiveMessage)( 129 TNC_IMCID imcID, 130 TNC_ConnectionID connectionID, 131 TNC_BufferReference messageBuffer, 132 TNC_UInt32 messageLength, 133 TNC_MessageType messageType); 134 TNC_Result (*BatchEnding)( 135 TNC_IMCID imcID, 136 TNC_ConnectionID connectionID); 137 TNC_Result (*Terminate)(TNC_IMCID imcID); 138 TNC_Result (*ProvideBindFunction)( 139 TNC_IMCID imcID, 140 TNC_TNCC_BindFunctionPointer bindFunction); 141 }; 142 143 struct tncc_data { 144 struct tnc_if_imc *imc; 145 unsigned int last_batchid; 146 }; 147 148 #define TNC_MAX_IMC_ID 10 149 static struct tnc_if_imc *tnc_imc[TNC_MAX_IMC_ID] = { NULL }; 150 151 152 /* TNCC functions that IMCs can call */ 153 154 TNC_Result TNC_TNCC_ReportMessageTypes( 155 TNC_IMCID imcID, 156 TNC_MessageTypeList supportedTypes, 157 TNC_UInt32 typeCount) 158 { 159 TNC_UInt32 i; 160 struct tnc_if_imc *imc; 161 162 wpa_printf(MSG_DEBUG, "TNC: TNC_TNCC_ReportMessageTypes(imcID=%lu " 163 "typeCount=%lu)", 164 (unsigned long) imcID, (unsigned long) typeCount); 165 166 for (i = 0; i < typeCount; i++) { 167 wpa_printf(MSG_DEBUG, "TNC: supportedTypes[%lu] = %lu", 168 i, supportedTypes[i]); 169 } 170 171 if (imcID >= TNC_MAX_IMC_ID || tnc_imc[imcID] == NULL) 172 return TNC_RESULT_INVALID_PARAMETER; 173 174 imc = tnc_imc[imcID]; 175 os_free(imc->supported_types); 176 imc->supported_types = 177 os_malloc(typeCount * sizeof(TNC_MessageType)); 178 if (imc->supported_types == NULL) 179 return TNC_RESULT_FATAL; 180 os_memcpy(imc->supported_types, supportedTypes, 181 typeCount * sizeof(TNC_MessageType)); 182 imc->num_supported_types = typeCount; 183 184 return TNC_RESULT_SUCCESS; 185 } 186 187 188 TNC_Result TNC_TNCC_SendMessage( 189 TNC_IMCID imcID, 190 TNC_ConnectionID connectionID, 191 TNC_BufferReference message, 192 TNC_UInt32 messageLength, 193 TNC_MessageType messageType) 194 { 195 struct tnc_if_imc *imc; 196 unsigned char *b64; 197 size_t b64len; 198 199 wpa_printf(MSG_DEBUG, "TNC: TNC_TNCC_SendMessage(imcID=%lu " 200 "connectionID=%lu messageType=%lu)", 201 imcID, connectionID, messageType); 202 wpa_hexdump_ascii(MSG_DEBUG, "TNC: TNC_TNCC_SendMessage", 203 message, messageLength); 204 205 if (imcID >= TNC_MAX_IMC_ID || tnc_imc[imcID] == NULL) 206 return TNC_RESULT_INVALID_PARAMETER; 207 208 b64 = base64_encode(message, messageLength, &b64len); 209 if (b64 == NULL) 210 return TNC_RESULT_FATAL; 211 212 imc = tnc_imc[imcID]; 213 os_free(imc->imc_send); 214 imc->imc_send_len = 0; 215 imc->imc_send = os_zalloc(b64len + 100); 216 if (imc->imc_send == NULL) { 217 os_free(b64); 218 return TNC_RESULT_OTHER; 219 } 220 221 imc->imc_send_len = 222 os_snprintf((char *) imc->imc_send, b64len + 100, 223 "<IMC-IMV-Message><Type>%08X</Type>" 224 "<Base64>%s</Base64></IMC-IMV-Message>", 225 (unsigned int) messageType, b64); 226 227 os_free(b64); 228 229 return TNC_RESULT_SUCCESS; 230 } 231 232 233 TNC_Result TNC_TNCC_RequestHandshakeRetry( 234 TNC_IMCID imcID, 235 TNC_ConnectionID connectionID, 236 TNC_RetryReason reason) 237 { 238 wpa_printf(MSG_DEBUG, "TNC: TNC_TNCC_RequestHandshakeRetry"); 239 240 if (imcID >= TNC_MAX_IMC_ID || tnc_imc[imcID] == NULL) 241 return TNC_RESULT_INVALID_PARAMETER; 242 243 /* 244 * TODO: trigger a call to eapol_sm_request_reauth(). This would 245 * require that the IMC continues to be loaded in memory afer 246 * authentication.. 247 */ 248 249 return TNC_RESULT_SUCCESS; 250 } 251 252 253 TNC_Result TNC_9048_LogMessage(TNC_IMCID imcID, TNC_UInt32 severity, 254 const char *message) 255 { 256 wpa_printf(MSG_DEBUG, "TNC: TNC_9048_LogMessage(imcID=%lu " 257 "severity==%lu message='%s')", 258 imcID, severity, message); 259 return TNC_RESULT_SUCCESS; 260 } 261 262 263 TNC_Result TNC_9048_UserMessage(TNC_IMCID imcID, TNC_ConnectionID connectionID, 264 const char *message) 265 { 266 wpa_printf(MSG_DEBUG, "TNC: TNC_9048_UserMessage(imcID=%lu " 267 "connectionID==%lu message='%s')", 268 imcID, connectionID, message); 269 return TNC_RESULT_SUCCESS; 270 } 271 272 273 TNC_Result TNC_TNCC_BindFunction( 274 TNC_IMCID imcID, 275 char *functionName, 276 void **pOutfunctionPointer) 277 { 278 wpa_printf(MSG_DEBUG, "TNC: TNC_TNCC_BindFunction(imcID=%lu, " 279 "functionName='%s')", (unsigned long) imcID, functionName); 280 281 if (imcID >= TNC_MAX_IMC_ID || tnc_imc[imcID] == NULL) 282 return TNC_RESULT_INVALID_PARAMETER; 283 284 if (pOutfunctionPointer == NULL) 285 return TNC_RESULT_INVALID_PARAMETER; 286 287 if (os_strcmp(functionName, "TNC_TNCC_ReportMessageTypes") == 0) 288 *pOutfunctionPointer = TNC_TNCC_ReportMessageTypes; 289 else if (os_strcmp(functionName, "TNC_TNCC_SendMessage") == 0) 290 *pOutfunctionPointer = TNC_TNCC_SendMessage; 291 else if (os_strcmp(functionName, "TNC_TNCC_RequestHandshakeRetry") == 292 0) 293 *pOutfunctionPointer = TNC_TNCC_RequestHandshakeRetry; 294 else if (os_strcmp(functionName, "TNC_9048_LogMessage") == 0) 295 *pOutfunctionPointer = TNC_9048_LogMessage; 296 else if (os_strcmp(functionName, "TNC_9048_UserMessage") == 0) 297 *pOutfunctionPointer = TNC_9048_UserMessage; 298 else 299 *pOutfunctionPointer = NULL; 300 301 return TNC_RESULT_SUCCESS; 302 } 303 304 305 static void * tncc_get_sym(void *handle, char *func) 306 { 307 void *fptr; 308 309 #ifdef CONFIG_NATIVE_WINDOWS 310 #ifdef _WIN32_WCE 311 fptr = GetProcAddressA(handle, func); 312 #else /* _WIN32_WCE */ 313 fptr = GetProcAddress(handle, func); 314 #endif /* _WIN32_WCE */ 315 #else /* CONFIG_NATIVE_WINDOWS */ 316 fptr = dlsym(handle, func); 317 #endif /* CONFIG_NATIVE_WINDOWS */ 318 319 return fptr; 320 } 321 322 323 static int tncc_imc_resolve_funcs(struct tnc_if_imc *imc) 324 { 325 void *handle = imc->dlhandle; 326 327 /* Mandatory IMC functions */ 328 imc->Initialize = tncc_get_sym(handle, "TNC_IMC_Initialize"); 329 if (imc->Initialize == NULL) { 330 wpa_printf(MSG_ERROR, "TNC: IMC does not export " 331 "TNC_IMC_Initialize"); 332 return -1; 333 } 334 335 imc->BeginHandshake = tncc_get_sym(handle, "TNC_IMC_BeginHandshake"); 336 if (imc->BeginHandshake == NULL) { 337 wpa_printf(MSG_ERROR, "TNC: IMC does not export " 338 "TNC_IMC_BeginHandshake"); 339 return -1; 340 } 341 342 imc->ProvideBindFunction = 343 tncc_get_sym(handle, "TNC_IMC_ProvideBindFunction"); 344 if (imc->ProvideBindFunction == NULL) { 345 wpa_printf(MSG_ERROR, "TNC: IMC does not export " 346 "TNC_IMC_ProvideBindFunction"); 347 return -1; 348 } 349 350 /* Optional IMC functions */ 351 imc->NotifyConnectionChange = 352 tncc_get_sym(handle, "TNC_IMC_NotifyConnectionChange"); 353 imc->ReceiveMessage = tncc_get_sym(handle, "TNC_IMC_ReceiveMessage"); 354 imc->BatchEnding = tncc_get_sym(handle, "TNC_IMC_BatchEnding"); 355 imc->Terminate = tncc_get_sym(handle, "TNC_IMC_Terminate"); 356 357 return 0; 358 } 359 360 361 static int tncc_imc_initialize(struct tnc_if_imc *imc) 362 { 363 TNC_Result res; 364 TNC_Version imc_ver; 365 366 wpa_printf(MSG_DEBUG, "TNC: Calling TNC_IMC_Initialize for IMC '%s'", 367 imc->name); 368 res = imc->Initialize(imc->imcID, TNC_IFIMC_VERSION_1, 369 TNC_IFIMC_VERSION_1, &imc_ver); 370 wpa_printf(MSG_DEBUG, "TNC: TNC_IMC_Initialize: res=%lu imc_ver=%lu", 371 (unsigned long) res, (unsigned long) imc_ver); 372 373 return res == TNC_RESULT_SUCCESS ? 0 : -1; 374 } 375 376 377 static int tncc_imc_terminate(struct tnc_if_imc *imc) 378 { 379 TNC_Result res; 380 381 if (imc->Terminate == NULL) 382 return 0; 383 384 wpa_printf(MSG_DEBUG, "TNC: Calling TNC_IMC_Terminate for IMC '%s'", 385 imc->name); 386 res = imc->Terminate(imc->imcID); 387 wpa_printf(MSG_DEBUG, "TNC: TNC_IMC_Terminate: %lu", 388 (unsigned long) res); 389 390 return res == TNC_RESULT_SUCCESS ? 0 : -1; 391 } 392 393 394 static int tncc_imc_provide_bind_function(struct tnc_if_imc *imc) 395 { 396 TNC_Result res; 397 398 wpa_printf(MSG_DEBUG, "TNC: Calling TNC_IMC_ProvideBindFunction for " 399 "IMC '%s'", imc->name); 400 res = imc->ProvideBindFunction(imc->imcID, TNC_TNCC_BindFunction); 401 wpa_printf(MSG_DEBUG, "TNC: TNC_IMC_ProvideBindFunction: res=%lu", 402 (unsigned long) res); 403 404 return res == TNC_RESULT_SUCCESS ? 0 : -1; 405 } 406 407 408 static int tncc_imc_notify_connection_change(struct tnc_if_imc *imc, 409 TNC_ConnectionState state) 410 { 411 TNC_Result res; 412 413 if (imc->NotifyConnectionChange == NULL) 414 return 0; 415 416 wpa_printf(MSG_DEBUG, "TNC: Calling TNC_IMC_NotifyConnectionChange(%d)" 417 " for IMC '%s'", (int) state, imc->name); 418 res = imc->NotifyConnectionChange(imc->imcID, imc->connectionID, 419 state); 420 wpa_printf(MSG_DEBUG, "TNC: TNC_IMC_NotifyConnectionChange: %lu", 421 (unsigned long) res); 422 423 return res == TNC_RESULT_SUCCESS ? 0 : -1; 424 } 425 426 427 static int tncc_imc_begin_handshake(struct tnc_if_imc *imc) 428 { 429 TNC_Result res; 430 431 wpa_printf(MSG_DEBUG, "TNC: Calling TNC_IMC_BeginHandshake for IMC " 432 "'%s'", imc->name); 433 res = imc->BeginHandshake(imc->imcID, imc->connectionID); 434 wpa_printf(MSG_DEBUG, "TNC: TNC_IMC_BeginHandshake: %lu", 435 (unsigned long) res); 436 437 return res == TNC_RESULT_SUCCESS ? 0 : -1; 438 } 439 440 441 static int tncc_load_imc(struct tnc_if_imc *imc) 442 { 443 if (imc->path == NULL) { 444 wpa_printf(MSG_DEBUG, "TNC: No IMC configured"); 445 return -1; 446 } 447 448 wpa_printf(MSG_DEBUG, "TNC: Opening IMC: %s (%s)", 449 imc->name, imc->path); 450 #ifdef CONFIG_NATIVE_WINDOWS 451 #ifdef UNICODE 452 { 453 TCHAR *lib = wpa_strdup_tchar(imc->path); 454 if (lib == NULL) 455 return -1; 456 imc->dlhandle = LoadLibrary(lib); 457 os_free(lib); 458 } 459 #else /* UNICODE */ 460 imc->dlhandle = LoadLibrary(imc->path); 461 #endif /* UNICODE */ 462 if (imc->dlhandle == NULL) { 463 wpa_printf(MSG_ERROR, "TNC: Failed to open IMC '%s' (%s): %d", 464 imc->name, imc->path, (int) GetLastError()); 465 return -1; 466 } 467 #else /* CONFIG_NATIVE_WINDOWS */ 468 imc->dlhandle = dlopen(imc->path, RTLD_LAZY); 469 if (imc->dlhandle == NULL) { 470 wpa_printf(MSG_ERROR, "TNC: Failed to open IMC '%s' (%s): %s", 471 imc->name, imc->path, dlerror()); 472 return -1; 473 } 474 #endif /* CONFIG_NATIVE_WINDOWS */ 475 476 if (tncc_imc_resolve_funcs(imc) < 0) { 477 wpa_printf(MSG_ERROR, "TNC: Failed to resolve IMC functions"); 478 return -1; 479 } 480 481 if (tncc_imc_initialize(imc) < 0 || 482 tncc_imc_provide_bind_function(imc) < 0) { 483 wpa_printf(MSG_ERROR, "TNC: Failed to initialize IMC"); 484 return -1; 485 } 486 487 return 0; 488 } 489 490 491 static void tncc_unload_imc(struct tnc_if_imc *imc) 492 { 493 tncc_imc_terminate(imc); 494 tnc_imc[imc->imcID] = NULL; 495 496 if (imc->dlhandle) { 497 #ifdef CONFIG_NATIVE_WINDOWS 498 FreeLibrary(imc->dlhandle); 499 #else /* CONFIG_NATIVE_WINDOWS */ 500 dlclose(imc->dlhandle); 501 #endif /* CONFIG_NATIVE_WINDOWS */ 502 } 503 os_free(imc->name); 504 os_free(imc->path); 505 os_free(imc->supported_types); 506 os_free(imc->imc_send); 507 } 508 509 510 static int tncc_supported_type(struct tnc_if_imc *imc, unsigned int type) 511 { 512 size_t i; 513 unsigned int vendor, subtype; 514 515 if (imc == NULL || imc->supported_types == NULL) 516 return 0; 517 518 vendor = type >> 8; 519 subtype = type & 0xff; 520 521 for (i = 0; i < imc->num_supported_types; i++) { 522 unsigned int svendor, ssubtype; 523 svendor = imc->supported_types[i] >> 8; 524 ssubtype = imc->supported_types[i] & 0xff; 525 if ((vendor == svendor || svendor == TNC_VENDORID_ANY) && 526 (subtype == ssubtype || ssubtype == TNC_SUBTYPE_ANY)) 527 return 1; 528 } 529 530 return 0; 531 } 532 533 534 static void tncc_send_to_imcs(struct tncc_data *tncc, unsigned int type, 535 const u8 *msg, size_t len) 536 { 537 struct tnc_if_imc *imc; 538 TNC_Result res; 539 540 wpa_hexdump_ascii(MSG_MSGDUMP, "TNC: Message to IMC(s)", msg, len); 541 542 for (imc = tncc->imc; imc; imc = imc->next) { 543 if (imc->ReceiveMessage == NULL || 544 !tncc_supported_type(imc, type)) 545 continue; 546 547 wpa_printf(MSG_DEBUG, "TNC: Call ReceiveMessage for IMC '%s'", 548 imc->name); 549 res = imc->ReceiveMessage(imc->imcID, imc->connectionID, 550 (TNC_BufferReference) msg, len, 551 type); 552 wpa_printf(MSG_DEBUG, "TNC: ReceiveMessage: %lu", 553 (unsigned long) res); 554 } 555 } 556 557 558 void tncc_init_connection(struct tncc_data *tncc) 559 { 560 struct tnc_if_imc *imc; 561 562 for (imc = tncc->imc; imc; imc = imc->next) { 563 tncc_imc_notify_connection_change( 564 imc, TNC_CONNECTION_STATE_CREATE); 565 tncc_imc_notify_connection_change( 566 imc, TNC_CONNECTION_STATE_HANDSHAKE); 567 568 os_free(imc->imc_send); 569 imc->imc_send = NULL; 570 imc->imc_send_len = 0; 571 572 tncc_imc_begin_handshake(imc); 573 } 574 } 575 576 577 size_t tncc_total_send_len(struct tncc_data *tncc) 578 { 579 struct tnc_if_imc *imc; 580 581 size_t len = 0; 582 for (imc = tncc->imc; imc; imc = imc->next) 583 len += imc->imc_send_len; 584 return len; 585 } 586 587 588 u8 * tncc_copy_send_buf(struct tncc_data *tncc, u8 *pos) 589 { 590 struct tnc_if_imc *imc; 591 592 for (imc = tncc->imc; imc; imc = imc->next) { 593 if (imc->imc_send == NULL) 594 continue; 595 596 os_memcpy(pos, imc->imc_send, imc->imc_send_len); 597 pos += imc->imc_send_len; 598 os_free(imc->imc_send); 599 imc->imc_send = NULL; 600 imc->imc_send_len = 0; 601 } 602 603 return pos; 604 } 605 606 607 char * tncc_if_tnccs_start(struct tncc_data *tncc) 608 { 609 char *buf = os_malloc(1000); 610 if (buf == NULL) 611 return NULL; 612 tncc->last_batchid++; 613 os_snprintf(buf, 1000, IF_TNCCS_START, tncc->last_batchid); 614 return buf; 615 } 616 617 618 char * tncc_if_tnccs_end(void) 619 { 620 char *buf = os_malloc(100); 621 if (buf == NULL) 622 return NULL; 623 os_snprintf(buf, 100, IF_TNCCS_END); 624 return buf; 625 } 626 627 628 static void tncc_notify_recommendation(struct tncc_data *tncc, 629 enum tncc_process_res res) 630 { 631 TNC_ConnectionState state; 632 struct tnc_if_imc *imc; 633 634 switch (res) { 635 case TNCCS_RECOMMENDATION_ALLOW: 636 state = TNC_CONNECTION_STATE_ACCESS_ALLOWED; 637 break; 638 case TNCCS_RECOMMENDATION_NONE: 639 state = TNC_CONNECTION_STATE_ACCESS_NONE; 640 break; 641 case TNCCS_RECOMMENDATION_ISOLATE: 642 state = TNC_CONNECTION_STATE_ACCESS_ISOLATED; 643 break; 644 default: 645 state = TNC_CONNECTION_STATE_ACCESS_NONE; 646 break; 647 } 648 649 for (imc = tncc->imc; imc; imc = imc->next) 650 tncc_imc_notify_connection_change(imc, state); 651 } 652 653 654 static int tncc_get_type(char *start, unsigned int *type) 655 { 656 char *pos = os_strstr(start, "<Type>"); 657 if (pos == NULL) 658 return -1; 659 pos += 6; 660 *type = strtoul(pos, NULL, 16); 661 return 0; 662 } 663 664 665 static unsigned char * tncc_get_base64(char *start, size_t *decoded_len) 666 { 667 char *pos, *pos2; 668 unsigned char *decoded; 669 670 pos = os_strstr(start, "<Base64>"); 671 if (pos == NULL) 672 return NULL; 673 674 pos += 8; 675 pos2 = os_strstr(pos, "</Base64>"); 676 if (pos2 == NULL) 677 return NULL; 678 *pos2 = '\0'; 679 680 decoded = base64_decode((unsigned char *) pos, os_strlen(pos), 681 decoded_len); 682 *pos2 = '<'; 683 if (decoded == NULL) { 684 wpa_printf(MSG_DEBUG, "TNC: Failed to decode Base64 data"); 685 } 686 687 return decoded; 688 } 689 690 691 static enum tncc_process_res tncc_get_recommendation(char *start) 692 { 693 char *pos, *pos2, saved; 694 int recom; 695 696 pos = os_strstr(start, "<TNCCS-Recommendation "); 697 if (pos == NULL) 698 return TNCCS_RECOMMENDATION_ERROR; 699 700 pos += 21; 701 pos = os_strstr(pos, " type="); 702 if (pos == NULL) 703 return TNCCS_RECOMMENDATION_ERROR; 704 pos += 6; 705 706 if (*pos == '"') 707 pos++; 708 709 pos2 = pos; 710 while (*pos2 != '\0' && *pos2 != '"' && *pos2 != '>') 711 pos2++; 712 713 if (*pos2 == '\0') 714 return TNCCS_RECOMMENDATION_ERROR; 715 716 saved = *pos2; 717 *pos2 = '\0'; 718 wpa_printf(MSG_DEBUG, "TNC: TNCCS-Recommendation: '%s'", pos); 719 720 recom = TNCCS_RECOMMENDATION_ERROR; 721 if (os_strcmp(pos, "allow") == 0) 722 recom = TNCCS_RECOMMENDATION_ALLOW; 723 else if (os_strcmp(pos, "none") == 0) 724 recom = TNCCS_RECOMMENDATION_NONE; 725 else if (os_strcmp(pos, "isolate") == 0) 726 recom = TNCCS_RECOMMENDATION_ISOLATE; 727 728 *pos2 = saved; 729 730 return recom; 731 } 732 733 734 enum tncc_process_res tncc_process_if_tnccs(struct tncc_data *tncc, 735 const u8 *msg, size_t len) 736 { 737 char *buf, *start, *end, *pos, *pos2, *payload; 738 unsigned int batch_id; 739 unsigned char *decoded; 740 size_t decoded_len; 741 enum tncc_process_res res = TNCCS_PROCESS_OK_NO_RECOMMENDATION; 742 int recommendation_msg = 0; 743 744 buf = dup_binstr(msg, len); 745 if (buf == NULL) 746 return TNCCS_PROCESS_ERROR; 747 748 start = os_strstr(buf, "<TNCCS-Batch "); 749 end = os_strstr(buf, "</TNCCS-Batch>"); 750 if (start == NULL || end == NULL || start > end) { 751 os_free(buf); 752 return TNCCS_PROCESS_ERROR; 753 } 754 755 start += 13; 756 while (*start == ' ') 757 start++; 758 *end = '\0'; 759 760 pos = os_strstr(start, "BatchId="); 761 if (pos == NULL) { 762 os_free(buf); 763 return TNCCS_PROCESS_ERROR; 764 } 765 766 pos += 8; 767 if (*pos == '"') 768 pos++; 769 batch_id = atoi(pos); 770 wpa_printf(MSG_DEBUG, "TNC: Received IF-TNCCS BatchId=%u", 771 batch_id); 772 if (batch_id != tncc->last_batchid + 1) { 773 wpa_printf(MSG_DEBUG, "TNC: Unexpected IF-TNCCS BatchId " 774 "%u (expected %u)", 775 batch_id, tncc->last_batchid + 1); 776 os_free(buf); 777 return TNCCS_PROCESS_ERROR; 778 } 779 tncc->last_batchid = batch_id; 780 781 while (*pos != '\0' && *pos != '>') 782 pos++; 783 if (*pos == '\0') { 784 os_free(buf); 785 return TNCCS_PROCESS_ERROR; 786 } 787 pos++; 788 payload = start; 789 790 /* 791 * <IMC-IMV-Message> 792 * <Type>01234567</Type> 793 * <Base64>foo==</Base64> 794 * </IMC-IMV-Message> 795 */ 796 797 while (*start) { 798 char *endpos; 799 unsigned int type; 800 801 pos = os_strstr(start, "<IMC-IMV-Message>"); 802 if (pos == NULL) 803 break; 804 start = pos + 17; 805 end = os_strstr(start, "</IMC-IMV-Message>"); 806 if (end == NULL) 807 break; 808 *end = '\0'; 809 endpos = end; 810 end += 18; 811 812 if (tncc_get_type(start, &type) < 0) { 813 *endpos = '<'; 814 start = end; 815 continue; 816 } 817 wpa_printf(MSG_DEBUG, "TNC: IMC-IMV-Message Type 0x%x", type); 818 819 decoded = tncc_get_base64(start, &decoded_len); 820 if (decoded == NULL) { 821 *endpos = '<'; 822 start = end; 823 continue; 824 } 825 826 tncc_send_to_imcs(tncc, type, decoded, decoded_len); 827 828 os_free(decoded); 829 830 start = end; 831 } 832 833 /* 834 * <TNCC-TNCS-Message> 835 * <Type>01234567</Type> 836 * <XML><TNCCS-Foo type="foo"></TNCCS-Foo></XML> 837 * <Base64>foo==</Base64> 838 * </TNCC-TNCS-Message> 839 */ 840 841 start = payload; 842 while (*start) { 843 unsigned int type; 844 char *xml, *xmlend, *endpos; 845 846 pos = os_strstr(start, "<TNCC-TNCS-Message>"); 847 if (pos == NULL) 848 break; 849 start = pos + 19; 850 end = os_strstr(start, "</TNCC-TNCS-Message>"); 851 if (end == NULL) 852 break; 853 *end = '\0'; 854 endpos = end; 855 end += 20; 856 857 if (tncc_get_type(start, &type) < 0) { 858 *endpos = '<'; 859 start = end; 860 continue; 861 } 862 wpa_printf(MSG_DEBUG, "TNC: TNCC-TNCS-Message Type 0x%x", 863 type); 864 865 /* Base64 OR XML */ 866 decoded = NULL; 867 xml = NULL; 868 xmlend = NULL; 869 pos = os_strstr(start, "<XML>"); 870 if (pos) { 871 pos += 5; 872 pos2 = os_strstr(pos, "</XML>"); 873 if (pos2 == NULL) { 874 *endpos = '<'; 875 start = end; 876 continue; 877 } 878 xmlend = pos2; 879 xml = pos; 880 } else { 881 decoded = tncc_get_base64(start, &decoded_len); 882 if (decoded == NULL) { 883 *endpos = '<'; 884 start = end; 885 continue; 886 } 887 } 888 889 if (decoded) { 890 wpa_hexdump_ascii(MSG_MSGDUMP, 891 "TNC: TNCC-TNCS-Message Base64", 892 decoded, decoded_len); 893 os_free(decoded); 894 } 895 896 if (xml) { 897 wpa_hexdump_ascii(MSG_MSGDUMP, 898 "TNC: TNCC-TNCS-Message XML", 899 (unsigned char *) xml, 900 xmlend - xml); 901 } 902 903 if (type == TNC_TNCCS_RECOMMENDATION && xml) { 904 /* 905 * <TNCCS-Recommendation type="allow"> 906 * </TNCCS-Recommendation> 907 */ 908 *xmlend = '\0'; 909 res = tncc_get_recommendation(xml); 910 *xmlend = '<'; 911 recommendation_msg = 1; 912 } 913 914 start = end; 915 } 916 917 os_free(buf); 918 919 if (recommendation_msg) 920 tncc_notify_recommendation(tncc, res); 921 922 return res; 923 } 924 925 926 #ifdef CONFIG_NATIVE_WINDOWS 927 static int tncc_read_config_reg(struct tncc_data *tncc, HKEY hive) 928 { 929 HKEY hk, hk2; 930 LONG ret; 931 DWORD i; 932 struct tnc_if_imc *imc, *last; 933 int j; 934 935 last = tncc->imc; 936 while (last && last->next) 937 last = last->next; 938 939 ret = RegOpenKeyEx(hive, TNC_WINREG_PATH, 0, KEY_ENUMERATE_SUB_KEYS, 940 &hk); 941 if (ret != ERROR_SUCCESS) 942 return 0; 943 944 for (i = 0; ; i++) { 945 TCHAR name[255], *val; 946 DWORD namelen, buflen; 947 948 namelen = 255; 949 ret = RegEnumKeyEx(hk, i, name, &namelen, NULL, NULL, NULL, 950 NULL); 951 952 if (ret == ERROR_NO_MORE_ITEMS) 953 break; 954 955 if (ret != ERROR_SUCCESS) { 956 wpa_printf(MSG_DEBUG, "TNC: RegEnumKeyEx failed: 0x%x", 957 (unsigned int) ret); 958 break; 959 } 960 961 if (namelen >= 255) 962 namelen = 255 - 1; 963 name[namelen] = '\0'; 964 965 wpa_printf(MSG_DEBUG, "TNC: IMC '" TSTR "'", name); 966 967 ret = RegOpenKeyEx(hk, name, 0, KEY_QUERY_VALUE, &hk2); 968 if (ret != ERROR_SUCCESS) { 969 wpa_printf(MSG_DEBUG, "Could not open IMC key '" TSTR 970 "'", name); 971 continue; 972 } 973 974 ret = RegQueryValueEx(hk2, TEXT("Path"), NULL, NULL, NULL, 975 &buflen); 976 if (ret != ERROR_SUCCESS) { 977 wpa_printf(MSG_DEBUG, "TNC: Could not read Path from " 978 "IMC key '" TSTR "'", name); 979 RegCloseKey(hk2); 980 continue; 981 } 982 983 val = os_malloc(buflen); 984 if (val == NULL) { 985 RegCloseKey(hk2); 986 continue; 987 } 988 989 ret = RegQueryValueEx(hk2, TEXT("Path"), NULL, NULL, 990 (LPBYTE) val, &buflen); 991 if (ret != ERROR_SUCCESS) { 992 os_free(val); 993 RegCloseKey(hk2); 994 continue; 995 } 996 997 RegCloseKey(hk2); 998 999 wpa_unicode2ascii_inplace(val); 1000 wpa_printf(MSG_DEBUG, "TNC: IMC Path '%s'", (char *) val); 1001 1002 for (j = 0; j < TNC_MAX_IMC_ID; j++) { 1003 if (tnc_imc[j] == NULL) 1004 break; 1005 } 1006 if (j >= TNC_MAX_IMC_ID) { 1007 wpa_printf(MSG_DEBUG, "TNC: Too many IMCs"); 1008 os_free(val); 1009 continue; 1010 } 1011 1012 imc = os_zalloc(sizeof(*imc)); 1013 if (imc == NULL) { 1014 os_free(val); 1015 break; 1016 } 1017 1018 imc->imcID = j; 1019 1020 wpa_unicode2ascii_inplace(name); 1021 imc->name = os_strdup((char *) name); 1022 imc->path = os_strdup((char *) val); 1023 1024 os_free(val); 1025 1026 if (last == NULL) 1027 tncc->imc = imc; 1028 else 1029 last->next = imc; 1030 last = imc; 1031 1032 tnc_imc[imc->imcID] = imc; 1033 } 1034 1035 RegCloseKey(hk); 1036 1037 return 0; 1038 } 1039 1040 1041 static int tncc_read_config(struct tncc_data *tncc) 1042 { 1043 if (tncc_read_config_reg(tncc, HKEY_LOCAL_MACHINE) < 0 || 1044 tncc_read_config_reg(tncc, HKEY_CURRENT_USER) < 0) 1045 return -1; 1046 return 0; 1047 } 1048 1049 #else /* CONFIG_NATIVE_WINDOWS */ 1050 1051 static struct tnc_if_imc * tncc_parse_imc(char *start, char *end, int *error) 1052 { 1053 struct tnc_if_imc *imc; 1054 char *pos, *pos2; 1055 int i; 1056 1057 for (i = 0; i < TNC_MAX_IMC_ID; i++) { 1058 if (tnc_imc[i] == NULL) 1059 break; 1060 } 1061 if (i >= TNC_MAX_IMC_ID) { 1062 wpa_printf(MSG_DEBUG, "TNC: Too many IMCs"); 1063 return NULL; 1064 } 1065 1066 imc = os_zalloc(sizeof(*imc)); 1067 if (imc == NULL) { 1068 *error = 1; 1069 return NULL; 1070 } 1071 1072 imc->imcID = i; 1073 1074 pos = start; 1075 wpa_printf(MSG_DEBUG, "TNC: Configured IMC: %s", pos); 1076 if (pos + 1 >= end || *pos != '"') { 1077 wpa_printf(MSG_ERROR, "TNC: Ignoring invalid IMC line '%s' " 1078 "(no starting quotation mark)", start); 1079 os_free(imc); 1080 return NULL; 1081 } 1082 1083 pos++; 1084 pos2 = pos; 1085 while (pos2 < end && *pos2 != '"') 1086 pos2++; 1087 if (pos2 >= end) { 1088 wpa_printf(MSG_ERROR, "TNC: Ignoring invalid IMC line '%s' " 1089 "(no ending quotation mark)", start); 1090 os_free(imc); 1091 return NULL; 1092 } 1093 *pos2 = '\0'; 1094 wpa_printf(MSG_DEBUG, "TNC: Name: '%s'", pos); 1095 imc->name = os_strdup(pos); 1096 1097 pos = pos2 + 1; 1098 if (pos >= end || *pos != ' ') { 1099 wpa_printf(MSG_ERROR, "TNC: Ignoring invalid IMC line '%s' " 1100 "(no space after name)", start); 1101 os_free(imc->name); 1102 os_free(imc); 1103 return NULL; 1104 } 1105 1106 pos++; 1107 wpa_printf(MSG_DEBUG, "TNC: IMC file: '%s'", pos); 1108 imc->path = os_strdup(pos); 1109 tnc_imc[imc->imcID] = imc; 1110 1111 return imc; 1112 } 1113 1114 1115 static int tncc_read_config(struct tncc_data *tncc) 1116 { 1117 char *config, *end, *pos, *line_end; 1118 size_t config_len; 1119 struct tnc_if_imc *imc, *last; 1120 1121 last = NULL; 1122 1123 config = os_readfile(TNC_CONFIG_FILE, &config_len); 1124 if (config == NULL) { 1125 wpa_printf(MSG_ERROR, "TNC: Could not open TNC configuration " 1126 "file '%s'", TNC_CONFIG_FILE); 1127 return -1; 1128 } 1129 1130 end = config + config_len; 1131 for (pos = config; pos < end; pos = line_end + 1) { 1132 line_end = pos; 1133 while (*line_end != '\n' && *line_end != '\r' && 1134 line_end < end) 1135 line_end++; 1136 *line_end = '\0'; 1137 1138 if (os_strncmp(pos, "IMC ", 4) == 0) { 1139 int error = 0; 1140 1141 imc = tncc_parse_imc(pos + 4, line_end, &error); 1142 if (error) 1143 return -1; 1144 if (imc) { 1145 if (last == NULL) 1146 tncc->imc = imc; 1147 else 1148 last->next = imc; 1149 last = imc; 1150 } 1151 } 1152 } 1153 1154 os_free(config); 1155 1156 return 0; 1157 } 1158 1159 #endif /* CONFIG_NATIVE_WINDOWS */ 1160 1161 1162 struct tncc_data * tncc_init(void) 1163 { 1164 struct tncc_data *tncc; 1165 struct tnc_if_imc *imc; 1166 1167 tncc = os_zalloc(sizeof(*tncc)); 1168 if (tncc == NULL) 1169 return NULL; 1170 1171 /* TODO: 1172 * move loading and Initialize() to a location that is not 1173 * re-initialized for every EAP-TNC session (?) 1174 */ 1175 1176 if (tncc_read_config(tncc) < 0) { 1177 wpa_printf(MSG_ERROR, "TNC: Failed to read TNC configuration"); 1178 goto failed; 1179 } 1180 1181 for (imc = tncc->imc; imc; imc = imc->next) { 1182 if (tncc_load_imc(imc)) { 1183 wpa_printf(MSG_ERROR, "TNC: Failed to load IMC '%s'", 1184 imc->name); 1185 goto failed; 1186 } 1187 } 1188 1189 return tncc; 1190 1191 failed: 1192 tncc_deinit(tncc); 1193 return NULL; 1194 } 1195 1196 1197 void tncc_deinit(struct tncc_data *tncc) 1198 { 1199 struct tnc_if_imc *imc, *prev; 1200 1201 imc = tncc->imc; 1202 while (imc) { 1203 tncc_unload_imc(imc); 1204 1205 prev = imc; 1206 imc = imc->next; 1207 os_free(prev); 1208 } 1209 1210 os_free(tncc); 1211 } 1212 1213 1214 static struct wpabuf * tncc_build_soh(int ver) 1215 { 1216 struct wpabuf *buf; 1217 u8 *tlv_len, *tlv_len2, *outer_len, *inner_len, *ssoh_len, *end; 1218 u8 correlation_id[24]; 1219 /* TODO: get correct name */ 1220 char *machinename = "wpa_supplicant@w1.fi"; 1221 1222 if (os_get_random(correlation_id, sizeof(correlation_id))) 1223 return NULL; 1224 wpa_hexdump(MSG_DEBUG, "TNC: SoH Correlation ID", 1225 correlation_id, sizeof(correlation_id)); 1226 1227 buf = wpabuf_alloc(200); 1228 if (buf == NULL) 1229 return NULL; 1230 1231 /* Vendor-Specific TLV (Microsoft) - SoH */ 1232 wpabuf_put_be16(buf, EAP_TLV_VENDOR_SPECIFIC_TLV); /* TLV Type */ 1233 tlv_len = wpabuf_put(buf, 2); /* Length */ 1234 wpabuf_put_be32(buf, EAP_VENDOR_MICROSOFT); /* Vendor_Id */ 1235 wpabuf_put_be16(buf, 0x01); /* TLV Type - SoH TLV */ 1236 tlv_len2 = wpabuf_put(buf, 2); /* Length */ 1237 1238 /* SoH Header */ 1239 wpabuf_put_be16(buf, EAP_TLV_VENDOR_SPECIFIC_TLV); /* Outer Type */ 1240 outer_len = wpabuf_put(buf, 2); 1241 wpabuf_put_be32(buf, EAP_VENDOR_MICROSOFT); /* IANA SMI Code */ 1242 wpabuf_put_be16(buf, ver); /* Inner Type */ 1243 inner_len = wpabuf_put(buf, 2); 1244 1245 if (ver == 2) { 1246 /* SoH Mode Sub-Header */ 1247 /* Outer Type */ 1248 wpabuf_put_be16(buf, EAP_TLV_VENDOR_SPECIFIC_TLV); 1249 wpabuf_put_be16(buf, 4 + 24 + 1 + 1); /* Length */ 1250 wpabuf_put_be32(buf, EAP_VENDOR_MICROSOFT); /* IANA SMI Code */ 1251 /* Value: */ 1252 wpabuf_put_data(buf, correlation_id, sizeof(correlation_id)); 1253 wpabuf_put_u8(buf, 0x01); /* Intent Flag - Request */ 1254 wpabuf_put_u8(buf, 0x00); /* Content-Type Flag */ 1255 } 1256 1257 /* SSoH TLV */ 1258 /* System-Health-Id */ 1259 wpabuf_put_be16(buf, 0x0002); /* Type */ 1260 wpabuf_put_be16(buf, 4); /* Length */ 1261 wpabuf_put_be32(buf, 79616); 1262 /* Vendor-Specific Attribute */ 1263 wpabuf_put_be16(buf, EAP_TLV_VENDOR_SPECIFIC_TLV); 1264 ssoh_len = wpabuf_put(buf, 2); 1265 wpabuf_put_be32(buf, EAP_VENDOR_MICROSOFT); /* IANA SMI Code */ 1266 1267 /* MS-Packet-Info */ 1268 wpabuf_put_u8(buf, SSOH_MS_PACKET_INFO); 1269 /* Note: IF-TNCCS-SOH v1.0 r8 claims this field to be: 1270 * Reserved(4 bits) r(1 bit) Vers(3 bits), but Windows XP 1271 * SP3 seems to be sending 0x11 for SSoH, i.e., r(request/response) bit 1272 * would not be in the specified location. 1273 * [MS-SOH] 4.0.2: Reserved(3 bits) r(1 bit) Vers(4 bits) 1274 */ 1275 wpabuf_put_u8(buf, 0x11); /* r=request, vers=1 */ 1276 1277 /* MS-Machine-Inventory */ 1278 /* TODO: get correct values; 0 = not applicable for OS */ 1279 wpabuf_put_u8(buf, SSOH_MS_MACHINE_INVENTORY); 1280 wpabuf_put_be32(buf, 0); /* osVersionMajor */ 1281 wpabuf_put_be32(buf, 0); /* osVersionMinor */ 1282 wpabuf_put_be32(buf, 0); /* osVersionBuild */ 1283 wpabuf_put_be16(buf, 0); /* spVersionMajor */ 1284 wpabuf_put_be16(buf, 0); /* spVersionMinor */ 1285 wpabuf_put_be16(buf, 0); /* procArch */ 1286 1287 /* MS-MachineName */ 1288 wpabuf_put_u8(buf, SSOH_MS_MACHINENAME); 1289 wpabuf_put_be16(buf, os_strlen(machinename) + 1); 1290 wpabuf_put_data(buf, machinename, os_strlen(machinename) + 1); 1291 1292 /* MS-CorrelationId */ 1293 wpabuf_put_u8(buf, SSOH_MS_CORRELATIONID); 1294 wpabuf_put_data(buf, correlation_id, sizeof(correlation_id)); 1295 1296 /* MS-Quarantine-State */ 1297 wpabuf_put_u8(buf, SSOH_MS_QUARANTINE_STATE); 1298 wpabuf_put_be16(buf, 1); /* Flags: ExtState=0, f=0, qState=1 */ 1299 wpabuf_put_be32(buf, 0xffffffff); /* ProbTime (hi) */ 1300 wpabuf_put_be32(buf, 0xffffffff); /* ProbTime (lo) */ 1301 wpabuf_put_be16(buf, 1); /* urlLenInBytes */ 1302 wpabuf_put_u8(buf, 0); /* null termination for the url */ 1303 1304 /* MS-Machine-Inventory-Ex */ 1305 wpabuf_put_u8(buf, SSOH_MS_MACHINE_INVENTORY_EX); 1306 wpabuf_put_be32(buf, 0); /* Reserved 1307 * (note: Windows XP SP3 uses 0xdecafbad) */ 1308 wpabuf_put_u8(buf, 1); /* ProductType: Client */ 1309 1310 /* Update SSoH Length */ 1311 end = wpabuf_put(buf, 0); 1312 WPA_PUT_BE16(ssoh_len, end - ssoh_len - 2); 1313 1314 /* TODO: SoHReportEntry TLV (zero or more) */ 1315 1316 /* Update length fields */ 1317 end = wpabuf_put(buf, 0); 1318 WPA_PUT_BE16(tlv_len, end - tlv_len - 2); 1319 WPA_PUT_BE16(tlv_len2, end - tlv_len2 - 2); 1320 WPA_PUT_BE16(outer_len, end - outer_len - 2); 1321 WPA_PUT_BE16(inner_len, end - inner_len - 2); 1322 1323 return buf; 1324 } 1325 1326 1327 struct wpabuf * tncc_process_soh_request(int ver, const u8 *data, size_t len) 1328 { 1329 const u8 *pos; 1330 1331 wpa_hexdump(MSG_DEBUG, "TNC: SoH Request", data, len); 1332 1333 if (len < 12) 1334 return NULL; 1335 1336 /* SoH Request */ 1337 pos = data; 1338 1339 /* TLV Type */ 1340 if (WPA_GET_BE16(pos) != EAP_TLV_VENDOR_SPECIFIC_TLV) 1341 return NULL; 1342 pos += 2; 1343 1344 /* Length */ 1345 if (WPA_GET_BE16(pos) < 8) 1346 return NULL; 1347 pos += 2; 1348 1349 /* Vendor_Id */ 1350 if (WPA_GET_BE32(pos) != EAP_VENDOR_MICROSOFT) 1351 return NULL; 1352 pos += 4; 1353 1354 /* TLV Type */ 1355 if (WPA_GET_BE16(pos) != 0x02 /* SoH request TLV */) 1356 return NULL; 1357 1358 wpa_printf(MSG_DEBUG, "TNC: SoH Request TLV received"); 1359 1360 return tncc_build_soh(2); 1361 } 1362