1 2 /* 3 * Licensed Materials - Property of IBM 4 * 5 * trousers - An open source TCG Software Stack 6 * 7 * (C) Copyright International Business Machines Corp. 2006 8 * 9 */ 10 11 /* 12 This file implements Helper functions for converting / creating and freeing 13 internal representation of TSS_DAA structures. 14 An external representation is the one define in tss_structs.h. 15 An internal representation is using bi_t or bi_ptr for representing big numbers. 16 Naming convention: for each structures we can have: 17 init_(<STRUCT>, struct *) : initialize the version field 18 create_<STRUCT> : init all fields 19 free_<STRUCT> : free all fields 20 e_2_i_<STRUCT> : convertor from External representation to internal 21 i_2_e_<STRUCT> : convertor from Internal to External. This call use a given memory 22 allocation function, to allow 23 for example to use calloc_tspi, or a "normal" malloc. 24 */ 25 #include <stdio.h> 26 #include <strings.h> 27 #include <errno.h> 28 #include <strings.h> 29 30 #include "daa_parameter.h" 31 #include "daa_structs.h" 32 #include "tcslog.h" 33 34 #define DUMP_DAA_PK_FIELD( field) \ 35 do { \ 36 printf("%s=", #field); \ 37 dump_field( pk->field##Length, pk->field); \ 38 puts(""); \ 39 } while(0); 40 41 #if 0 42 #define STORE_DAA_PK_BI1( field, bi) \ 43 do { \ 44 store_bi( &pk->field##Length, &pk->field, bi); \ 45 } while(0); 46 47 #define STORE_DAA_PK_BI( field, daa_alloc, param_alloc) \ 48 do { \ 49 store_bi( &pk->field##Length,\ 50 &pk->field,\ 51 pk_internal->field,\ 52 daa_alloc,\ 53 param_alloc); \ 54 } while(0); 55 56 // used only to read a structure from a file, so only as helping function 57 // for TCG application 58 static char buffer[1000]; 59 #endif 60 BYTE *convert_alloc( TCS_CONTEXT_HANDLE tcsContext, UINT32 length, BYTE *source) { 61 BYTE *result = calloc_tspi( tcsContext, length); 62 63 if( result == NULL) return NULL; 64 memcpy( result, source, length); 65 free( source); 66 return result; 67 } 68 69 BYTE *copy_alloc( TCS_CONTEXT_HANDLE tcsContext, UINT32 length, BYTE *source) { 70 BYTE *result = calloc_tspi( tcsContext, length); 71 72 if( result == NULL) return NULL; 73 memcpy( result, source, length); 74 return result; 75 } 76 77 static void *normal_malloc( size_t size, TSS_HOBJECT object) { 78 void *ret = malloc( size); 79 return ret; 80 } 81 82 /* store a bi to a buffer and update the length in big endian format */ 83 void store_bi( UINT32 *length, 84 BYTE **buffer, 85 const bi_ptr i, 86 void * (*daa_alloc)(size_t size, TSS_HOBJECT object), 87 TSS_HOBJECT object 88 ) { 89 int size; 90 91 *buffer = (BYTE *)daa_alloc( bi_length( i), object); 92 bi_2_nbin1( &size, *buffer, i); 93 *length = size; 94 LogDebug( "[store_bi] host_length:%d network_length:%d[address:%d]\n", 95 size, 96 (int)*length, 97 (int)*buffer); 98 } 99 100 bi_ptr get_bi( const unsigned long n_length, const BYTE *buffer) { 101 unsigned long length; 102 103 length = n_length; 104 LogDebug( "[get_bi] %d [address:%d -> |%2x|%2x| ]\n", 105 (int)length, 106 (int)buffer, 107 (int)(buffer[0] &0xFF), 108 (int)(buffer[1]&0xFF)); 109 return bi_set_as_nbin( length, buffer); 110 } 111 112 /* length is in network format: big indian */ 113 void dump_field( int length, BYTE *buffer) { 114 int i; 115 116 for( i=0; i< length; i++) { 117 BYTE byte = (BYTE)(buffer[i] & 0xFF); 118 printf("%02X", byte); 119 } 120 } 121 122 #if 0 123 /* !: do not keep the return buffer */ 124 char *read_str(FILE *file) { 125 int i; 126 char c; 127 128 fgets( buffer, 1000, file); 129 i=0; 130 while( buffer[i] =='\n' || buffer[i]=='\r' || buffer[i]==' ') i++; 131 do { 132 c = buffer[ i++]; 133 } while( c != 0 && c != ' ' && c!='\n' && c!='\r' && c!='#'); 134 buffer[ i -1] = 0; 135 return buffer; 136 } 137 138 /** 139 * 140 * @param file 141 * @return 142 */ 143 int read_int( FILE *file) { 144 int i, ret; 145 char c; 146 147 fgets( buffer, 1000, file); 148 i=0; 149 while( buffer[i] =='\n' || buffer[i]=='\r' || buffer[i]==' ') i++; 150 do { 151 c = buffer[ i++]; 152 } while( c != 0 && c != ' ' && c!='\n' && c!='\r' && c!='#'); 153 buffer[ i -1] = 0; 154 sscanf( buffer, "%d", &ret); 155 return ret; 156 } 157 #endif 158 /******************************************************************************************** 159 * TSS_DAA_SELECTED_ATTRIB 160 * this struct is used internally and externally, only a call to 161 internal_2_DAA_SELECTED_ATTRIB 162 * and DAA_SELECTED_ATTRIB_2_internal will change the struct to be internal or 163 external 164 ********************************************************************************************/ 165 166 void i_2_e_TSS_DAA_SELECTED_ATTRIB( 167 TSS_DAA_SELECTED_ATTRIB *selected_attrib 168 ) { 169 } 170 171 void e_2_i_TSS_DAA_SELECTED_ATTRIB( 172 TSS_DAA_SELECTED_ATTRIB *selected_attrib 173 ) { 174 } 175 176 /* work ONLY with internal format 177 important: TSS_BOOL is of type int_8_t, so a char, if the size is bigger, we 178 will maybe need 179 to transform each part to big indian ? or maybe each part is false if equal to 180 0, true otherwise. 181 */ 182 BYTE *to_bytes_TSS_DAA_SELECTED_ATTRIB_internal( 183 int *result_length, 184 TSS_DAA_SELECTED_ATTRIB *selected_attrib 185 ) { 186 BYTE *result; 187 int index = 0; 188 unsigned int length = selected_attrib->indicesListLength; 189 190 *result_length = sizeof(unsigned int) + 191 (selected_attrib->indicesListLength * sizeof(TSS_BOOL)); 192 result = (BYTE *)malloc( *result_length); 193 memcpy( &result[index], &length, sizeof(UINT32)); 194 index+=sizeof(UINT32); 195 memcpy( &result[index], selected_attrib->indicesList, 196 sizeof(TSS_BOOL) * selected_attrib->indicesListLength); 197 return result; 198 } 199 200 /* 201 create a TSS_DAA_SELECTED_ATTRIB of length <length> with given selected attributes. 202 example of selections of the second and third attributes upon 5: 203 create_TSS_DAA_SELECTED_ATTRIB( &selected_attrib, 5, 0, 1, 1, 0, 0); 204 */ 205 void create_TSS_DAA_SELECTED_ATTRIB( TSS_DAA_SELECTED_ATTRIB *attrib, int length, ...) { 206 va_list ap; 207 int i, select; 208 209 attrib->indicesListLength = length; 210 attrib->indicesList = (TSS_BOOL *)malloc( length * sizeof( TSS_BOOL)); 211 va_start (ap, length); 212 for( i=0; i<length; i++) { 213 select = va_arg( ap, int) != 0; 214 attrib->indicesList[i] = select; 215 } 216 va_end (ap); 217 } 218 219 220 /****************************************************************************************** 221 * TSS_DAA_SIGN_DATA 222 * this struct is used internally and externally, only a call to internal_2_DAA_SIGN_DATA 223 * DAA_SIGN_DATA_2_internal will change the struct to be internal or external 224 *******************************************************************************************/ 225 226 void i_2_e_TSS_DAA_SIGN_DATA( TSS_DAA_SIGN_DATA *sign_data) { 227 } 228 229 void e_2_i_TSS_DAA_SIGN( TSS_DAA_SIGN_DATA *sign_data) { 230 } 231 232 /******************************************************************************************** 233 * TSS_DAA_ATTRIB_COMMIT 234 ********************************************************************************************/ 235 236 TSS_DAA_ATTRIB_COMMIT_internal *create_TSS_DAA_ATTRIB_COMMIT( bi_ptr beta, bi_ptr sMu) { 237 TSS_DAA_ATTRIB_COMMIT_internal *result = 238 (TSS_DAA_ATTRIB_COMMIT_internal *)malloc( sizeof(TSS_DAA_ATTRIB_COMMIT_internal)); 239 240 result->beta = beta; 241 result->sMu = sMu; 242 return result; 243 } 244 245 246 /******************************************************************************************** 247 * TSS_DAA_PSEUDONYM_PLAIN 248 ********************************************************************************************/ 249 250 TSS_DAA_PSEUDONYM_PLAIN_internal * 251 create_TSS_DAA_PSEUDONYM_PLAIN(bi_ptr nV) 252 { 253 TSS_DAA_PSEUDONYM_PLAIN_internal *result = (TSS_DAA_PSEUDONYM_PLAIN_internal *) 254 malloc(sizeof(TSS_DAA_PSEUDONYM_PLAIN_internal)); 255 256 result->nV = nV; 257 return result; 258 } 259 260 /******************************************************************************************** 261 * DAA PRIVATE KEY 262 ********************************************************************************************/ 263 /* 264 * allocate: ret->p_prime 265 * ret->q_prime 266 * ret->productPQprime 267 */ 268 DAA_PRIVATE_KEY_internal * 269 create_TSS_DAA_PRIVATE_KEY(bi_ptr pPrime, bi_ptr qPrime) 270 { 271 DAA_PRIVATE_KEY_internal *private_key = 272 (DAA_PRIVATE_KEY_internal *)malloc( sizeof( DAA_PRIVATE_KEY_internal)); 273 274 private_key->p_prime = bi_new_ptr(); bi_set( private_key->p_prime, pPrime); 275 private_key->q_prime = bi_new_ptr(); bi_set( private_key->q_prime, qPrime); 276 private_key->productPQprime = bi_new_ptr(); 277 bi_mul( private_key->productPQprime, pPrime, qPrime); 278 return private_key; 279 } 280 281 #if 0 282 int 283 save_DAA_PRIVATE_KEY(FILE *file, const DAA_PRIVATE_KEY_internal *private_key) 284 { 285 BI_SAVE( private_key->p_prime , file); 286 BI_SAVE( private_key->q_prime , file); 287 BI_SAVE( private_key->productPQprime, file); 288 return 0; 289 } 290 291 DAA_PRIVATE_KEY_internal * 292 load_DAA_PRIVATE_KEY(FILE *file) 293 { 294 DAA_PRIVATE_KEY_internal *private_key = 295 (DAA_PRIVATE_KEY_internal *)malloc( sizeof(DAA_PRIVATE_KEY_internal)); 296 297 private_key->p_prime = bi_new_ptr(); 298 BI_LOAD( private_key->p_prime, file); 299 private_key->q_prime = bi_new_ptr(); 300 BI_LOAD( private_key->q_prime, file); 301 private_key->productPQprime = bi_new_ptr(); 302 BI_LOAD( private_key->productPQprime, file); 303 return private_key; 304 } 305 #endif 306 DAA_PRIVATE_KEY_internal *e_2_i_TSS_DAA_PRIVATE_KEY(TSS_DAA_PRIVATE_KEY *private_key) { 307 DAA_PRIVATE_KEY_internal *private_key_internal; 308 309 LogDebug("-> e_2_i_TSS_DAA_PRIVATE_KEY"); 310 private_key_internal = 311 (DAA_PRIVATE_KEY_internal *)malloc( sizeof(DAA_PRIVATE_KEY_internal)); 312 private_key_internal->p_prime = get_bi( private_key->p_primeLength, private_key->p_prime); 313 private_key_internal->q_prime = get_bi( private_key->q_primeLength, private_key->q_prime); 314 private_key_internal->productPQprime = 315 get_bi( private_key->productPQprimeLength, private_key->productPQprime); 316 LogDebug("<- e_2_i_TSS_DAA_PRIVATE_KEY"); 317 return private_key_internal; 318 } 319 320 TSS_DAA_PRIVATE_KEY * 321 i_2_e_TSS_DAA_PRIVATE_KEY(DAA_PRIVATE_KEY_internal *private_key_internal, 322 void * (*daa_alloc)(size_t size, TSS_HOBJECT object), 323 TSS_HOBJECT param_alloc) 324 { 325 TSS_DAA_PRIVATE_KEY *result; 326 327 LogDebug("-> i_2_e_TSS_DAA_PRIVATE_KEY"); 328 result = (TSS_DAA_PRIVATE_KEY *)daa_alloc( sizeof(TSS_DAA_PRIVATE_KEY), param_alloc); 329 init_tss_version( result); 330 store_bi( &(result->p_primeLength), 331 &(result->p_prime), 332 private_key_internal->p_prime, 333 daa_alloc, 334 param_alloc); 335 store_bi( &(result->q_primeLength), 336 &(result->q_prime), 337 private_key_internal->q_prime, 338 daa_alloc, 339 param_alloc); 340 store_bi( &(result->productPQprimeLength), 341 &(result->productPQprime), 342 private_key_internal->productPQprime, 343 daa_alloc, 344 param_alloc); 345 LogDebug("<- i_2_e_TSS_DAA_PRIVATE_KEY"); 346 return result; 347 } 348 349 /******************************************************************************************** 350 * KEY PAIR WITH PROOF 351 ********************************************************************************************/ 352 353 #if 0 354 355 /* moved to daa_debug.c */ 356 357 int 358 save_KEY_PAIR_WITH_PROOF(FILE *file, 359 KEY_PAIR_WITH_PROOF_internal *key_pair_with_proof) 360 { 361 save_DAA_PK_internal( file, key_pair_with_proof->pk); 362 save_DAA_PRIVATE_KEY( file, key_pair_with_proof->private_key); 363 save_DAA_PK_PROOF_internal( file, key_pair_with_proof->proof); 364 365 return 0; 366 } 367 368 KEY_PAIR_WITH_PROOF_internal * 369 load_KEY_PAIR_WITH_PROOF(FILE *file) 370 { 371 KEY_PAIR_WITH_PROOF_internal *key_pair_with_proof = 372 (KEY_PAIR_WITH_PROOF_internal *)malloc(sizeof(KEY_PAIR_WITH_PROOF_internal)); 373 374 key_pair_with_proof->pk = load_DAA_PK_internal(file); 375 key_pair_with_proof->private_key = load_DAA_PRIVATE_KEY(file); 376 key_pair_with_proof->proof = load_DAA_PK_PROOF_internal(file); 377 378 return key_pair_with_proof; 379 } 380 381 #endif 382 /* allocated using instrumented daa_alloc */ 383 TSS_DAA_KEY_PAIR *get_TSS_DAA_KEY_PAIR(KEY_PAIR_WITH_PROOF_internal *key_pair_with_proof, 384 void * (*daa_alloc)(size_t size, TSS_HOBJECT object), 385 TSS_HOBJECT param_alloc) 386 { 387 TSS_DAA_KEY_PAIR *result; 388 389 LogDebug("-> i_2_e_KEY_PAIR_WITH_PROOF"); 390 391 result = (TSS_DAA_KEY_PAIR *)daa_alloc(sizeof(TSS_DAA_KEY_PAIR), param_alloc); 392 init_tss_version(result); 393 result->private_key = i_2_e_TSS_DAA_PRIVATE_KEY(key_pair_with_proof->private_key, 394 daa_alloc, param_alloc); 395 result->public_key = i_2_e_TSS_DAA_PK( key_pair_with_proof->pk, daa_alloc, param_alloc); 396 397 LogDebug("<- i_2_e_KEY_PAIR_WITH_PROOF"); 398 399 return result; 400 } 401 402 403 /******************************************************************************************** 404 * TSS_DAA_PK 405 ********************************************************************************************/ 406 407 /* pk_internal->capitalY must be alocated using ALLOC_BI_ARRAY() */ 408 void 409 populate_capitalY(TSS_DAA_PK_internal *pk_internal) 410 { 411 int i; 412 413 bi_new_array(pk_internal->capitalY, 414 pk_internal->capitalRReceiver->length + pk_internal->capitalRIssuer->length); 415 416 // CAPITAL Y ( capitalRReceiver ) 417 for (i = 0; i < pk_internal->capitalRReceiver->length; i++) 418 pk_internal->capitalY->array[i] = pk_internal->capitalRReceiver->array[i]; 419 // CAPITAL Y ( capitalRIssuer) 420 for (i = 0; i < pk_internal->capitalRIssuer->length; i++) 421 pk_internal->capitalY->array[pk_internal->capitalRReceiver->length+i] = 422 pk_internal->capitalRIssuer->array[i]; 423 } 424 425 void 426 compute_capitalSprime(TSS_DAA_PK_internal *pk_internal) 427 { 428 bi_t bi_tmp; 429 430 bi_new(bi_tmp); 431 pk_internal->capitalSprime = bi_new_ptr(); 432 bi_shift_left( bi_tmp, bi_1, DAA_PARAM_SIZE_SPLIT_EXPONENT); 433 bi_mod_exp(pk_internal->capitalSprime, pk_internal->capitalS, bi_tmp, pk_internal->modulus); 434 bi_free( bi_tmp); 435 } 436 437 /* 438 * create anf feel a TSS_DAA_PK_internal structures 439 * ! this function keep pointer on all parameters 440 */ 441 TSS_DAA_PK_internal * 442 create_DAA_PK(const bi_ptr modulus, 443 const bi_ptr capitalS, 444 const bi_ptr capitalZ, 445 const bi_ptr capitalR0, 446 const bi_ptr capitalR1, 447 const bi_ptr gamma, 448 const bi_ptr capitalGamma, 449 const bi_ptr rho, 450 const bi_array_ptr capitalRReceiver, 451 const bi_array_ptr capitalRIssuer, 452 const int issuerBaseNameLength, 453 BYTE * const issuerBaseName) 454 { 455 TSS_DAA_PK_internal *pk_internal; 456 457 LogDebug("-> create_DAA_PK"); 458 pk_internal = (TSS_DAA_PK_internal *)malloc(sizeof(TSS_DAA_PK_internal)); 459 pk_internal->modulus = modulus; 460 pk_internal->capitalS = capitalS; 461 pk_internal->capitalZ = capitalZ; 462 pk_internal->capitalR0 = capitalR0; 463 pk_internal->capitalR1 = capitalR1; 464 pk_internal->gamma = gamma; 465 pk_internal->capitalGamma = capitalGamma; 466 pk_internal->rho = rho; 467 pk_internal->capitalRReceiver = capitalRReceiver; 468 pk_internal->capitalRIssuer = capitalRIssuer; 469 pk_internal->capitalY = ALLOC_BI_ARRAY(); 470 populate_capitalY( pk_internal); 471 pk_internal->issuerBaseNameLength = issuerBaseNameLength; 472 pk_internal->issuerBaseName = issuerBaseName; 473 compute_capitalSprime( pk_internal); 474 475 LogDebug("<- create_DAA_PK"); 476 477 return pk_internal; 478 } 479 480 #if 0 481 482 /* moved to daa_debug.c */ 483 484 int 485 save_DAA_PK_internal(FILE *file, const TSS_DAA_PK_internal *pk_internal) 486 { 487 char *buffer; 488 489 LogDebug("-> save_DAA_PK_internal"); 490 491 BI_SAVE( pk_internal->modulus, file); 492 BI_SAVE( pk_internal->capitalS, file); 493 BI_SAVE( pk_internal->capitalZ, file); 494 BI_SAVE( pk_internal->capitalR0, file); 495 BI_SAVE( pk_internal->capitalR1, file); 496 BI_SAVE( pk_internal->gamma, file); 497 BI_SAVE( pk_internal->capitalGamma, file); 498 BI_SAVE( pk_internal->rho, file); 499 BI_SAVE_ARRAY( pk_internal->capitalRReceiver, file); 500 BI_SAVE_ARRAY( pk_internal->capitalRIssuer, file); 501 fprintf( file, "%d\n", pk_internal->issuerBaseNameLength); 502 buffer = (char *)malloc( pk_internal->issuerBaseNameLength + 1); 503 memcpy( buffer, pk_internal->issuerBaseName, pk_internal->issuerBaseNameLength); 504 buffer[ pk_internal->issuerBaseNameLength] = 0; 505 fprintf( file, "%s\n", buffer); 506 free( buffer); 507 508 LogDebug("<- save_DAA_PK_internal"); 509 510 return 0; 511 } 512 513 TSS_DAA_PK_internal * 514 load_DAA_PK_internal(FILE *file) 515 { 516 TSS_DAA_PK_internal *pk_internal = 517 (TSS_DAA_PK_internal *)malloc(sizeof(TSS_DAA_PK_internal)); 518 char *read_buffer; 519 520 pk_internal->modulus = bi_new_ptr(); 521 BI_LOAD( pk_internal->modulus, file); 522 pk_internal->capitalS = bi_new_ptr(); 523 BI_LOAD( pk_internal->capitalS, file); 524 pk_internal->capitalZ = bi_new_ptr(); 525 BI_LOAD( pk_internal->capitalZ, file); 526 pk_internal->capitalR0 = bi_new_ptr(); 527 BI_LOAD( pk_internal->capitalR0, file); 528 pk_internal->capitalR1 = bi_new_ptr(); 529 BI_LOAD( pk_internal->capitalR1, file); 530 pk_internal->gamma = bi_new_ptr(); 531 BI_LOAD( pk_internal->gamma, file); 532 pk_internal->capitalGamma = bi_new_ptr(); 533 BI_LOAD( pk_internal->capitalGamma, file); 534 pk_internal->rho = bi_new_ptr(); 535 BI_LOAD( pk_internal->rho, file); 536 pk_internal->capitalRReceiver = ALLOC_BI_ARRAY(); 537 BI_LOAD_ARRAY( pk_internal->capitalRReceiver, file); 538 pk_internal->capitalRIssuer = ALLOC_BI_ARRAY(); 539 BI_LOAD_ARRAY( pk_internal->capitalRIssuer, file); 540 pk_internal->capitalY = ALLOC_BI_ARRAY(); 541 populate_capitalY( pk_internal); 542 pk_internal->issuerBaseNameLength = read_int( file); 543 read_buffer = read_str( file); 544 pk_internal->issuerBaseName = malloc( pk_internal->issuerBaseNameLength); 545 memcpy( pk_internal->issuerBaseName, read_buffer, pk_internal->issuerBaseNameLength); 546 compute_capitalSprime( pk_internal); 547 return pk_internal; 548 } 549 550 #endif 551 void 552 dump_DAA_PK_internal(char *name, TSS_DAA_PK_internal *pk_internal) 553 { 554 LogDebug("Dump TSS_DAA_PK_internal:%s\n", name); 555 556 DUMP_BI( pk_internal->modulus); 557 DUMP_BI( pk_internal->capitalS); 558 DUMP_BI( pk_internal->capitalZ); 559 DUMP_BI( pk_internal->capitalR0); 560 DUMP_BI( pk_internal->capitalR1); 561 DUMP_BI( pk_internal->gamma); 562 DUMP_BI( pk_internal->capitalGamma); 563 DUMP_BI( pk_internal->rho); 564 DUMP_BI_ARRAY( pk_internal->capitalRReceiver); 565 DUMP_BI_ARRAY( pk_internal->capitalRIssuer); 566 567 LogDebug("issuerBaseName = %s\n", pk_internal->issuerBaseName); 568 LogDebug("End Dump TSS_DAA_PK_internal:%s\n", name); 569 } 570 571 /* 572 * Encode the DAA_PK like java.security.Key#getEncoded 573 */ 574 BYTE * 575 encoded_DAA_PK_internal(int *result_length, const TSS_DAA_PK_internal *pk) 576 { 577 int length_issuer_base_name = pk->issuerBaseNameLength; 578 int total_length = DAA_PARAM_TSS_VERSION_LENGTH + 579 5 * ((DAA_PARAM_SIZE_RSA_MODULUS / 8)+ sizeof(int)) + 580 2 * ((DAA_PARAM_SIZE_MODULUS_GAMMA / 8)+sizeof(int)) + 581 1 * ((DAA_PARAM_SIZE_RHO / 8)+sizeof(int)) + 582 pk->capitalY->length*(((DAA_PARAM_SIZE_RSA_MODULUS / 8)+sizeof(int))) 583 + length_issuer_base_name; 584 BYTE *result = (BYTE *)malloc(total_length); 585 int i, index = 0, length, big_indian_length; 586 587 if (result == NULL) 588 return NULL; 589 590 LogDebug("total_length=%d", total_length); 591 for (index = 0; index < DAA_PARAM_TSS_VERSION_LENGTH; index++) 592 result[index] = DAA_PARAM_TSS_VERSION[index]; 593 // n, capitalS, capitalZ, capitalR0, capitalR1 594 length = DAA_PARAM_SIZE_RSA_MODULUS / 8; 595 big_indian_length = length; 596 memcpy(&result[index], &big_indian_length, sizeof(int)); 597 index += sizeof(int); 598 bi_2_byte_array( &result[index], length, pk->modulus); 599 index += length; 600 memcpy(&result[index], &big_indian_length, sizeof(int)); 601 index += sizeof(int); 602 bi_2_byte_array( &result[index], length, pk->capitalS); 603 index += length; 604 memcpy(&result[index], &big_indian_length, sizeof(int)); 605 index += sizeof(int); 606 bi_2_byte_array( &result[index], length, pk->capitalZ); 607 index += length; 608 memcpy(&result[index], &big_indian_length, sizeof(int)); 609 index += sizeof(int); 610 bi_2_byte_array( &result[index], length, pk->capitalR0); 611 index += length; 612 memcpy(&result[index], &big_indian_length, sizeof(int)); 613 index += sizeof(int); 614 bi_2_byte_array( &result[index], length, pk->capitalR1); 615 index += length; 616 // gamma, capitalGamma 617 length = DAA_PARAM_SIZE_MODULUS_GAMMA / 8; 618 big_indian_length = length; 619 memcpy(&result[index], &big_indian_length, sizeof(int)); 620 index += sizeof(int); 621 bi_2_byte_array( &result[index], length, pk->gamma); 622 index += length; 623 memcpy(&result[index], &big_indian_length, sizeof(int)); 624 index += sizeof(int); 625 bi_2_byte_array( &result[index], length, pk->capitalGamma); 626 index += length; 627 // rho 628 length = DAA_PARAM_SIZE_RHO / 8; 629 big_indian_length = length; 630 memcpy(&result[index], &big_indian_length, sizeof(int)); 631 index += sizeof(int); 632 bi_2_byte_array( &result[index], length, pk->rho); 633 index += length; 634 // capitalY 635 length = DAA_PARAM_SIZE_RSA_MODULUS / 8; 636 big_indian_length = length; 637 638 for( i=0; i<pk->capitalY->length; i++) { 639 memcpy( &result[index], &big_indian_length, sizeof(int)); 640 index+=sizeof(int); 641 bi_2_byte_array( &result[index], length, pk->capitalY->array[i]); 642 index+=length; 643 } 644 // basename 645 memcpy( &result[index], pk->issuerBaseName, length_issuer_base_name); 646 index+=length_issuer_base_name; 647 *result_length = index; 648 649 LogDebug("return length=%d", index); 650 651 return result; 652 } 653 654 /* create anf feel a TSS_DAA_PK structures */ 655 TSS_DAA_PK * 656 i_2_e_TSS_DAA_PK(TSS_DAA_PK_internal *pk_internal, 657 void *(*daa_alloc)(size_t size, TSS_HOBJECT param_alloc), 658 TSS_HOBJECT param_alloc) 659 { 660 int i; 661 int capitalYLength; 662 int capitalYLength2; 663 TSS_DAA_PK *pk; 664 665 LogDebug("-> i_2_e_TSS_DAA_PK"); 666 pk = (TSS_DAA_PK *)daa_alloc( sizeof(TSS_DAA_PK), param_alloc); 667 init_tss_version( pk); 668 if (pk == NULL) { 669 LogError("Can not allocate the TSS_DAA_PK structure"); 670 return NULL; 671 } 672 STORE_DAA_PK_BI( modulus, daa_alloc, param_alloc); 673 STORE_DAA_PK_BI( capitalS, daa_alloc, param_alloc); 674 STORE_DAA_PK_BI( capitalZ, daa_alloc, param_alloc); 675 STORE_DAA_PK_BI( capitalR0, daa_alloc, param_alloc); 676 STORE_DAA_PK_BI( capitalR1, daa_alloc, param_alloc); 677 STORE_DAA_PK_BI( gamma, daa_alloc, param_alloc); 678 STORE_DAA_PK_BI( capitalGamma, daa_alloc, param_alloc); 679 STORE_DAA_PK_BI( rho, daa_alloc, param_alloc); 680 capitalYLength = pk_internal->capitalY->length; 681 capitalYLength2 = bi_nbin_size( pk_internal->capitalY->array[0]); 682 LogDebug("[capitalYLength=%d capitalYLength2=%d total size=%d]\n", 683 capitalYLength, capitalYLength2, sizeof(BYTE) * capitalYLength * 684 capitalYLength2); 685 pk->capitalY = (BYTE **) daa_alloc( sizeof(BYTE *) * capitalYLength, param_alloc ); 686 for (i = 0; i < capitalYLength; i++) { 687 if( bi_nbin_size( pk_internal->capitalY->array[i]) != capitalYLength2) { 688 // LOG ERROR 689 LogError("Error during feel operation of capitalY (index=%d capitalYLength" 690 "2=%d, currentSize=%d)\n", i, capitalYLength2, 691 (int)bi_nbin_size(pk_internal->capitalY->array[i])); 692 } 693 BYTE *buffer = (BYTE*) daa_alloc( sizeof(BYTE) * capitalYLength2, param_alloc); 694 bi_2_byte_array( buffer, capitalYLength2, pk_internal->capitalY->array[i]); 695 // bi_2_nbin1( &checkSize, buffer, pk_internal->capitalY->array[i]); 696 pk->capitalY[i] = buffer; 697 LogDebug( "[i=%d currentsize=%d buffer[%d]=[%2x|%2x]\n", 698 i, 699 (int)bi_nbin_size( pk_internal->capitalY->array[i]), 700 (int)pk->capitalY[i], 701 (int)pk->capitalY[i][0], 702 (int)pk->capitalY[i][1]); 703 } 704 pk->capitalYLength = capitalYLength; 705 pk->capitalYLength2 = capitalYLength2; 706 pk->capitalYPlatformLength = pk_internal->capitalRReceiver->length; 707 LogDebug("issuer= len=%d", pk_internal->issuerBaseNameLength); 708 pk->issuerBaseNameLength = pk_internal->issuerBaseNameLength; 709 pk->issuerBaseName = (BYTE *)daa_alloc(pk_internal->issuerBaseNameLength, param_alloc); 710 memcpy( pk->issuerBaseName, 711 pk_internal->issuerBaseName, 712 pk_internal->issuerBaseNameLength); 713 LogDebug("i_2_e_TSS_DAA_PK extern_issuer=%s intern_issuer=%s\n", 714 pk->issuerBaseName, 715 pk_internal->issuerBaseName); 716 LogDebug("<- i_2_e_TSS_DAA_PK"); 717 return pk; 718 } 719 720 /**/ 721 TSS_DAA_PK_internal * 722 e_2_i_TSS_DAA_PK( TSS_DAA_PK *pk) 723 { 724 TSS_DAA_PK_internal *pk_internal = 725 (TSS_DAA_PK_internal *)malloc(sizeof(TSS_DAA_PK_internal)); 726 unsigned long capitalYLength, capitalYLength2, capitalYPlatformLength; 727 UINT32 i; 728 int issuer_length; 729 730 // pk_internal->modulus = GET_DAA_PK_BI( modulus); 731 pk_internal->modulus = get_bi(pk->modulusLength, pk->modulus); 732 pk_internal->capitalS = get_bi(pk->capitalSLength, pk->capitalS); 733 pk_internal->capitalZ = get_bi(pk->capitalZLength, pk->capitalZ); 734 pk_internal->capitalR0 = get_bi(pk->capitalR0Length, pk->capitalR0); 735 pk_internal->capitalR1 = get_bi(pk->capitalR1Length, pk->capitalR1); 736 pk_internal->gamma = get_bi(pk->gammaLength, pk->gamma); 737 pk_internal->capitalGamma = get_bi(pk->capitalGammaLength, pk->capitalGamma); 738 pk_internal->rho = get_bi(pk->rhoLength, pk->rho); 739 capitalYLength = pk->capitalYLength; 740 capitalYLength2= pk->capitalYLength2; 741 capitalYPlatformLength = pk->capitalYPlatformLength; 742 LogDebug( "capitalYLength:%ld capitalYLength2:%ld capitalYPlatformLength:%ld\n", 743 capitalYLength, capitalYLength2, capitalYPlatformLength); 744 745 pk_internal->capitalRReceiver = ALLOC_BI_ARRAY(); 746 bi_new_array2(pk_internal->capitalRReceiver, capitalYPlatformLength); 747 for (i = 0; i < capitalYPlatformLength; i++) { 748 LogDebug( "i=%d\n", i); 749 pk_internal->capitalRReceiver->array[i] = 750 get_bi(pk->capitalYLength2, pk->capitalY[i]); 751 } 752 pk_internal->capitalRIssuer = ALLOC_BI_ARRAY(); 753 bi_new_array2( pk_internal->capitalRIssuer, capitalYLength - 754 capitalYPlatformLength); 755 for( ; i<capitalYLength; i++) { 756 pk_internal->capitalRIssuer->array[ i - capitalYPlatformLength] = 757 get_bi( pk->capitalYLength2, pk->capitalY[i]); 758 } 759 pk_internal->capitalY = ALLOC_BI_ARRAY(); 760 populate_capitalY( pk_internal); 761 issuer_length = pk->issuerBaseNameLength; 762 pk_internal->issuerBaseNameLength = issuer_length; 763 LogDebug( "issuer_length=%d\n", issuer_length); 764 pk_internal->issuerBaseName = (BYTE *)malloc( issuer_length); 765 memcpy( pk_internal->issuerBaseName, pk->issuerBaseName, issuer_length); 766 LogDebug("e_2_i_TSS_DAA_PK extern_issuer=%s intern_issuer=%s\n", 767 pk->issuerBaseName, 768 pk_internal->issuerBaseName); 769 compute_capitalSprime( pk_internal); // allocation 770 return pk_internal; 771 } 772 773 void 774 free_TSS_DAA_PK_internal(TSS_DAA_PK_internal *pk_internal) 775 { 776 bi_free_ptr( pk_internal->capitalSprime); 777 free( pk_internal->issuerBaseName); 778 free( pk_internal->capitalY); 779 bi_free_array( pk_internal->capitalRIssuer); 780 bi_free_array( pk_internal->capitalRReceiver); 781 bi_free_ptr( pk_internal->rho); 782 bi_free_ptr( pk_internal->capitalGamma); 783 bi_free_ptr( pk_internal->gamma); 784 bi_free_ptr( pk_internal->capitalR1); 785 bi_free_ptr( pk_internal->capitalR0); 786 bi_free_ptr( pk_internal->capitalZ); 787 bi_free_ptr( pk_internal->capitalS); 788 bi_free_ptr( pk_internal->modulus); 789 free( pk_internal); 790 } 791 792 /* free a TSS_DAA_PK structures */ 793 void 794 free_TSS_DAA_PK(TSS_DAA_PK *pk) 795 { 796 int i; 797 798 LogDebug("-> free_TSS_DAA_PK"); 799 free( pk->modulus); 800 free( pk->capitalS); 801 free( pk->capitalZ); 802 free( pk->capitalR0); 803 free( pk->capitalR1); 804 free( pk->gamma); 805 free( pk->capitalGamma); 806 free( pk->rho); 807 for( i=0; i<(int)pk->capitalYLength; i++) { 808 free( pk->capitalY[i]); 809 } 810 free( pk->capitalY); 811 free( pk->issuerBaseName); 812 free( pk); 813 LogDebug("<- free_TSS_DAA_PK"); 814 815 } 816 817 TPM_DAA_ISSUER * 818 convert2issuer_settings(TSS_DAA_PK_internal *pk_internal) 819 { 820 TPM_DAA_ISSUER *result = (TPM_DAA_ISSUER *)malloc(sizeof(TPM_DAA_ISSUER)); 821 EVP_MD_CTX *mdctx; 822 UINT32 length; 823 BYTE *array = (BYTE*)malloc((DAA_PARAM_SIZE_RSA_MODULUS+7)/8); 824 825 LogDebug("convert2issuer_settings"); 826 EVP_MD_CTX_create(mdctx); 827 // TAG 828 result->tag = htons( TPM_TAG_DAA_ISSUER); 829 // capitalR0 830 EVP_DigestInit(mdctx, DAA_PARAM_get_message_digest()); 831 832 EVP_DigestInit_ex(mdctx, DAA_PARAM_get_message_digest(), NULL); 833 bi_2_byte_array( array, 834 length = (bi_length( pk_internal->capitalR0)+7)/8, 835 pk_internal->capitalR0); 836 LogDebug("capitalR0 length=%d", length); 837 EVP_DigestUpdate(mdctx, array, length); 838 EVP_DigestFinal_ex(mdctx, (BYTE *)&(result->DAA_digest_R0), NULL); 839 // capitalR1 840 EVP_DigestInit_ex(mdctx, DAA_PARAM_get_message_digest(), NULL); 841 bi_2_byte_array( array, 842 length = (bi_length( pk_internal->capitalR1)+7)/8, 843 pk_internal->capitalR1); 844 LogDebug("capitalR1 length=%d", length); 845 EVP_DigestUpdate(mdctx, array, length); 846 EVP_DigestFinal_ex(mdctx, (BYTE *)&(result->DAA_digest_R1), NULL); 847 // capitalS (S0) 848 EVP_DigestInit_ex(mdctx, DAA_PARAM_get_message_digest(), NULL); 849 bi_2_byte_array( array, 850 length = (bi_length( pk_internal->capitalS)+7)/8, 851 pk_internal->capitalS); 852 LogDebug("capitalS length=%d", length); 853 EVP_DigestUpdate(mdctx, array, length); 854 EVP_DigestFinal_ex(mdctx, (BYTE *)&(result->DAA_digest_S0), NULL); 855 // capitalSprime (S1) 856 EVP_DigestInit_ex(mdctx, DAA_PARAM_get_message_digest(), NULL); 857 bi_2_byte_array( array, 858 length = (bi_length( pk_internal->capitalSprime)+7)/8, 859 pk_internal->capitalSprime); 860 LogDebug("capitalSprime length=%d", length); 861 EVP_DigestUpdate(mdctx, array, length); 862 EVP_DigestFinal_ex(mdctx, (BYTE *)&(result->DAA_digest_S1), NULL); 863 // modulus (n) 864 EVP_DigestInit_ex(mdctx, DAA_PARAM_get_message_digest(), NULL); 865 bi_2_byte_array( array, 866 length = (bi_length( pk_internal->modulus)+7)/8, 867 pk_internal->modulus); 868 LogDebug("modulus length=%d", length); 869 EVP_DigestUpdate(mdctx, array, length); 870 EVP_DigestFinal_ex(mdctx, (BYTE *)&(result->DAA_digest_n), NULL); 871 // modulus (n) 872 EVP_DigestInit_ex(mdctx, DAA_PARAM_get_message_digest(), NULL); 873 bi_2_byte_array( array, 874 length = (bi_length( pk_internal->capitalGamma)+7)/8, 875 pk_internal->capitalGamma); 876 LogDebug("capitalGamma length=%d", length); 877 EVP_DigestUpdate(mdctx, array, length); 878 free(array); 879 EVP_DigestFinal_ex(mdctx, (BYTE *)&(result->DAA_digest_gamma), NULL); 880 EVP_MD_CTX_destroy(mdctx); 881 // rho 882 bi_2_byte_array( (BYTE *)&(result->DAA_generic_q), 26, pk_internal->rho); 883 return result; 884 } 885 886 BYTE * 887 issuer_2_byte_array(TPM_DAA_ISSUER *tpm_daa_issuer, int *length) 888 { 889 UINT32 size = sizeof(UINT16) + ( 6 * TPM_SHA1_160_HASH_LEN) + 26; 890 BYTE * result = (BYTE *)malloc( sizeof(BYTE)*size); 891 UINT32 i = 0; 892 893 memcpy( &result[i], &(tpm_daa_issuer->tag), sizeof(UINT16)); 894 i+=sizeof(UINT16); 895 memcpy( &result[i], &(tpm_daa_issuer->DAA_digest_R0), TPM_SHA1_160_HASH_LEN); 896 i+=TPM_SHA1_160_HASH_LEN; 897 memcpy( &result[i], &(tpm_daa_issuer->DAA_digest_R1), TPM_SHA1_160_HASH_LEN); 898 i+=TPM_SHA1_160_HASH_LEN; 899 memcpy( &result[i], &(tpm_daa_issuer->DAA_digest_S0), TPM_SHA1_160_HASH_LEN); 900 i+=TPM_SHA1_160_HASH_LEN; 901 memcpy( &result[i], &(tpm_daa_issuer->DAA_digest_S1), TPM_SHA1_160_HASH_LEN); 902 i+=TPM_SHA1_160_HASH_LEN; 903 memcpy( &result[i], &(tpm_daa_issuer->DAA_digest_n), TPM_SHA1_160_HASH_LEN); 904 i+=TPM_SHA1_160_HASH_LEN; 905 memcpy( &result[i], &(tpm_daa_issuer->DAA_digest_gamma), TPM_SHA1_160_HASH_LEN); 906 i+=TPM_SHA1_160_HASH_LEN; 907 memcpy( &result[i], &(tpm_daa_issuer->DAA_generic_q), 26); 908 *length = size; 909 return result; 910 } 911 912 /******************************************************************************************** 913 * TSS_DAA_PK_PROOF 914 ********************************************************************************************/ 915 916 /* 917 * this function keep references on: 918 * - challenge (BYTE *) 919 * - response (bi_array_ptr *) 920 */ 921 TSS_DAA_PK_PROOF_internal * 922 create_DAA_PK_PROOF(BYTE* const challenge, 923 const int length_challenge, 924 bi_array_ptr *response, 925 const int length_response) 926 { 927 TSS_DAA_PK_PROOF_internal *pk_proof; 928 929 #ifdef DAA_DEBUG 930 printf("create_DAA_PK_PROOF_internal\n"); 931 #endif 932 pk_proof = (TSS_DAA_PK_PROOF_internal *)malloc( sizeof(TSS_DAA_PK_PROOF_internal)); 933 pk_proof->challenge = challenge; 934 pk_proof->length_challenge = length_challenge; 935 pk_proof->response = response; 936 pk_proof->length_response = length_response; 937 return pk_proof; 938 } 939 940 #if 0 941 int 942 save_DAA_PK_PROOF_internal(FILE *file, TSS_DAA_PK_PROOF_internal *proof) 943 { 944 int i; 945 946 #ifdef DAA_DEBUG 947 printf("save_DAA_PK_PROOF_internal"); 948 #endif 949 fprintf(file, "%d # %s.length\n", proof->length_challenge, "challenge"); 950 fprintf(file, "%s\n", dump_byte_array( proof->length_challenge, 951 proof->challenge)); 952 fprintf(file, "%d # %s.length\n", proof->length_response, "response"); 953 for (i = 0; i < proof->length_response; i++) { 954 BI_SAVE_ARRAY( proof->response[i], file); 955 } 956 957 return 0; 958 } 959 960 /* load <proof> using <filename> */ 961 /* allocation of: */ 962 /* proof->challenge (BYTE*) */ 963 /* response (bi_array_ptr) */ 964 TSS_DAA_PK_PROOF_internal * 965 load_DAA_PK_PROOF_internal(FILE *file) 966 { 967 TSS_DAA_PK_PROOF_internal *proof = 968 (TSS_DAA_PK_PROOF_internal *)malloc(sizeof(TSS_DAA_PK_PROOF_internal)); 969 char *read_buffer; 970 int i; 971 972 #ifdef DAA_DEBUG 973 printf("load_DAA_PK_PROOF_internal"); 974 #endif 975 proof->length_challenge = read_int( file); 976 read_buffer = read_str( file); 977 proof->challenge = retrieve_byte_array( &(proof->length_challenge),read_buffer); 978 proof->length_response = read_int( file); 979 proof->response = (bi_array_ptr *)malloc( sizeof(bi_array_ptr) * proof->length_response); 980 for (i = 0; i < proof->length_response; i++) { 981 proof->response[i] = ALLOC_BI_ARRAY(); 982 BI_LOAD_ARRAY( proof->response[i], file); 983 } 984 return proof; 985 } 986 #endif 987 988 TSS_DAA_PK_PROOF * 989 i_2_e_TSS_DAA_PK_PROOF(TSS_DAA_PK_PROOF_internal*pk_internal_proof, 990 void * (*daa_alloc)(size_t size, TSS_HOBJECT param), 991 TSS_HOBJECT param_alloc) 992 { 993 TSS_DAA_PK_PROOF *pk_proof = 994 (TSS_DAA_PK_PROOF *)daa_alloc( sizeof(TSS_DAA_PK_PROOF), param_alloc); 995 int i, j; 996 int length_response2; 997 int length_response3; 998 999 init_tss_version( pk_proof); 1000 // CHALLENGE 1001 pk_proof->challengeLength = pk_internal_proof->length_challenge; 1002 pk_proof->challenge = (BYTE *)daa_alloc( pk_internal_proof->length_challenge, 1003 param_alloc); 1004 memcpy( pk_proof->challenge, pk_internal_proof->challenge, 1005 pk_internal_proof->length_challenge); 1006 // RESPONSES 1007 pk_proof->responseLength = pk_internal_proof->length_response; 1008 length_response2 = pk_internal_proof->response[0]->length; 1009 pk_proof->responseLength2 = length_response2; 1010 length_response3 = bi_nbin_size( 1011 pk_internal_proof->response[0]->array[0]); 1012 if( length_response3 & 1) length_response3++; // length_response3 should be paire 1013 pk_proof->responseLength3 = length_response3; 1014 pk_proof->response = (BYTE ***)daa_alloc( sizeof(BYTE **) * 1015 pk_internal_proof->length_response, param_alloc); 1016 for(i = 0; i < pk_internal_proof->length_response; i++) { 1017 pk_proof->response[i] = (BYTE **)daa_alloc( sizeof(BYTE *) * length_response2, 1018 param_alloc); 1019 for( j = 0; j < length_response2; j++) { 1020 (pk_proof->response[i])[j] = (BYTE *)malloc( 1021 sizeof(BYTE) * length_response3); 1022 bi_2_byte_array( pk_proof->response[i][j], 1023 length_response3, 1024 pk_internal_proof->response[i]->array[j]); 1025 } 1026 } 1027 return pk_proof; 1028 } 1029 1030 TSS_DAA_PK_PROOF_internal * 1031 e_2_i_TSS_DAA_PK_PROOF(TSS_DAA_PK_PROOF *pk_proof) 1032 { 1033 int i, j, response_length2; 1034 TSS_DAA_PK_PROOF_internal *pk_proof_internal = 1035 (TSS_DAA_PK_PROOF_internal *)malloc( sizeof( TSS_DAA_PK_PROOF_internal)); 1036 1037 // CHALLENGE 1038 pk_proof_internal->length_challenge = pk_proof->challengeLength; 1039 #ifdef DAA_DEBUG 1040 fprintf(stderr, "issuer_length=%d\n", pk_proof_internal->length_challenge); 1041 #endif 1042 pk_proof_internal->challenge = (BYTE *)malloc( pk_proof_internal->length_challenge); 1043 memcpy( pk_proof_internal->challenge, 1044 pk_proof->challenge, 1045 pk_proof_internal->length_challenge); 1046 // RESPONSES 1047 pk_proof_internal->length_response = pk_proof->responseLength; 1048 response_length2 = pk_proof->responseLength2; 1049 pk_proof_internal->response = 1050 (bi_array_ptr *)malloc( sizeof(bi_array_ptr) * 1051 pk_proof_internal->length_response); 1052 for(i = 0; i<pk_proof_internal->length_response; i++) { 1053 pk_proof_internal->response[i] = ALLOC_BI_ARRAY(); 1054 bi_new_array2( pk_proof_internal->response[i], response_length2); 1055 for( j = 0; j < response_length2; j++) { 1056 pk_proof_internal->response[i]->array[j] = 1057 get_bi( pk_proof->responseLength3, pk_proof->response[i][j]); 1058 } 1059 } 1060 return pk_proof_internal; 1061 } 1062 1063 1064 /******************************************************************************************** 1065 * TSS_DAA_JOIN_ISSUER_SESSION 1066 ********************************************************************************************/ 1067 1068 TSS_DAA_JOIN_ISSUER_SESSION_internal * 1069 create(TSS_DAA_PK_PROOF_internal *issuerKeyPair, 1070 TPM_DAA_ISSUER *issuerAuthKey, 1071 TSS_DAA_IDENTITY_PROOF *identityProof, 1072 bi_ptr capitalUprime, 1073 int daaCounter, 1074 int nonceIssuerLength, 1075 BYTE *nonceIssuer, 1076 int nonceEncryptedLength, 1077 BYTE *nonceEncrypted) 1078 { 1079 TSS_DAA_JOIN_ISSUER_SESSION_internal *result = 1080 (TSS_DAA_JOIN_ISSUER_SESSION_internal *)malloc( 1081 sizeof(TSS_DAA_JOIN_ISSUER_SESSION_internal)); 1082 1083 result->issuerAuthKey = issuerAuthKey; 1084 result->issuerKeyPair = issuerKeyPair; 1085 result->identityProof = identityProof; 1086 result->capitalUprime = capitalUprime; 1087 result->daaCounter = daaCounter; 1088 result->nonceIssuerLength = nonceIssuerLength; 1089 result->nonceIssuer = nonceIssuer; 1090 result->nonceEncryptedLength = nonceEncryptedLength; 1091 result->nonceEncrypted = nonceEncrypted; 1092 return result; 1093 } 1094 1095 1096 /******************************************************************************************** 1097 * TSS_DAA_SIGNATURE 1098 ********************************************************************************************/ 1099 1100 TSS_DAA_SIGNATURE_internal* 1101 e_2_i_TSS_DAA_SIGNATURE(TSS_DAA_SIGNATURE* signature) 1102 { 1103 TSS_DAA_SIGNATURE_internal *signature_intern = 1104 (TSS_DAA_SIGNATURE_internal *)malloc( sizeof( TSS_DAA_SIGNATURE_internal)); 1105 int i, length; 1106 1107 signature_intern->zeta = bi_set_as_nbin( signature->zetaLength, signature->zeta); 1108 signature_intern->capitalT = bi_set_as_nbin( signature->capitalTLength, 1109 signature->capitalT); 1110 signature_intern->challenge_length = signature->challengeLength; 1111 signature_intern->challenge = (BYTE *)malloc( signature->challengeLength); 1112 memcpy( signature_intern->challenge, 1113 signature->challenge, 1114 signature->challengeLength); 1115 signature_intern->nonce_tpm_length = signature->nonceTpmLength; 1116 signature_intern->nonce_tpm = (BYTE *)malloc( signature->nonceTpmLength); 1117 memcpy( signature_intern->nonce_tpm, signature->nonceTpm, signature->nonceTpmLength); 1118 signature_intern->sV = bi_set_as_nbin( signature->sVLength, signature->sV); 1119 signature_intern->sF0 = bi_set_as_nbin( signature->sF0Length, signature->sF0); 1120 signature_intern->sF1 = bi_set_as_nbin( signature->sF1Length, signature->sF1); 1121 signature_intern->sE = bi_set_as_nbin( signature->sELength, signature->sE); 1122 signature_intern->sA = (bi_array_ptr)malloc( sizeof( bi_array)); 1123 bi_new_array2( signature_intern->sA, signature->sALength); 1124 length = ( DAA_PARAM_SIZE_RANDOMIZED_ATTRIBUTES + 7) / 8; 1125 for (i = 0; i < (int)signature->sALength; i++) { 1126 signature_intern->sA->array[i] = bi_set_as_nbin( length, signature->sA[i]); 1127 } 1128 1129 return signature_intern; 1130 } 1131 1132 void 1133 free_TSS_DAA_SIGNATURE_internal(TSS_DAA_SIGNATURE_internal *signature) 1134 { 1135 bi_free_array( signature->sA); 1136 bi_free_ptr( signature->sE); 1137 bi_free_ptr( signature->sF1); 1138 bi_free_ptr( signature->sF0); 1139 bi_free_ptr( signature->sV); 1140 free( signature->nonce_tpm); 1141 free( signature->challenge); 1142 bi_free_ptr( signature->capitalT); 1143 bi_free_ptr( signature->zeta); 1144 free( signature); 1145 } 1146 1147 #if 0 1148 /******************************************************************************************** 1149 TSS_DAA_CRED_ISSUER 1150 ********************************************************************************************/ 1151 1152 TSS_DAA_CRED_ISSUER * 1153 load_TSS_DAA_CRED_ISSUER(FILE *file) 1154 { 1155 TSS_DAA_CRED_ISSUER *credential = 1156 (TSS_DAA_CRED_ISSUER *)malloc(sizeof(TSS_DAA_CRED_ISSUER)); 1157 char *read_buffer; 1158 int i, len; 1159 1160 init_tss_version( credential); 1161 credential->capitalALength = read_int( file); 1162 read_buffer = read_str( file); 1163 credential->capitalA = retrieve_byte_array( &(credential->capitalALength), 1164 read_buffer); 1165 credential->eLength = read_int( file); 1166 read_buffer = read_str( file); 1167 credential->e = retrieve_byte_array( &(credential->eLength),read_buffer); 1168 credential->vPrimePrimeLength = read_int( file); 1169 read_buffer = read_str( file); 1170 credential->vPrimePrime = retrieve_byte_array(&(credential->vPrimePrimeLength), 1171 read_buffer); 1172 // attributes issuer 1173 credential->attributesIssuerLength = read_int( file); 1174 credential->attributesIssuer = malloc(credential->attributesIssuerLength*sizeof(BYTE*)); 1175 for( i=0; i < (int)credential->attributesIssuerLength; i++) { 1176 credential->attributesIssuer[i] = retrieve_byte_array( &len, read_buffer); 1177 } 1178 credential->cPrimeLength = read_int( file); 1179 read_buffer = read_str( file); 1180 credential->cPrime = retrieve_byte_array( &(credential->cPrimeLength),read_buffer); 1181 credential->sELength = read_int( file); 1182 read_buffer = read_str( file); 1183 credential->sE = retrieve_byte_array( &(credential->sELength),read_buffer); 1184 return credential; 1185 } 1186 1187 int 1188 save_TSS_DAA_CRED_ISSUER(FILE *file, TSS_DAA_CRED_ISSUER *credential) 1189 { 1190 int i; 1191 1192 fprintf(file, "%d # %s.length\n", credential->capitalALength, "capitalA"); 1193 fprintf(file, "%s\n", dump_byte_array( credential->capitalALength, 1194 credential->capitalA)); 1195 fprintf(file, "%d # %s.length\n", credential->eLength, "e"); 1196 fprintf(file, "%s\n", dump_byte_array( credential->eLength, 1197 credential->e)); 1198 fprintf(file, "%d # %s.length\n", credential->vPrimePrimeLength, "vPrimePrime"); 1199 fprintf(file, "%s\n", dump_byte_array( credential->vPrimePrimeLength, 1200 credential->vPrimePrime)); 1201 fprintf(file, "%d # %s\n", credential->attributesIssuerLength, "attributesIssuerLength"); 1202 for( i=0; i < (int)credential->attributesIssuerLength; i++) { 1203 fprintf(file, "%s\n", dump_byte_array( DAA_PARAM_SIZE_F_I / 8, 1204 credential->attributesIssuer[i])); 1205 1206 } 1207 fprintf(file, "%d # %s.length\n", credential->cPrimeLength, "cPrime"); 1208 fprintf(file, "%s\n", dump_byte_array( credential->cPrimeLength, 1209 credential->cPrime)); 1210 fprintf(file, "%d # %s.length\n", credential->sELength, "sE"); 1211 fprintf(file, "%s\n", dump_byte_array( credential->sELength, 1212 credential->sE)); 1213 return 0; 1214 } 1215 1216 1217 /******************************************************************************************** 1218 TSS_DAA_CREDENTIAL 1219 ********************************************************************************************/ 1220 1221 TSS_DAA_CREDENTIAL * 1222 load_TSS_DAA_CREDENTIAL(FILE *file) 1223 { 1224 TSS_DAA_CREDENTIAL *credential = 1225 (TSS_DAA_CREDENTIAL *)malloc(sizeof(TSS_DAA_CREDENTIAL)); 1226 char *read_buffer; 1227 int i, len; 1228 TSS_DAA_PK_internal *pk_internal; 1229 TSS_DAA_PK *pk; 1230 1231 init_tss_version( credential); 1232 credential->capitalALength = read_int( file); 1233 read_buffer = read_str( file); 1234 credential->capitalA = retrieve_byte_array( &(credential->capitalALength), 1235 read_buffer); 1236 credential->exponentLength = read_int( file); 1237 read_buffer = read_str( file); 1238 credential->exponent = retrieve_byte_array( &(credential->exponentLength), 1239 read_buffer); 1240 credential->vBar0Length = read_int( file); 1241 read_buffer = read_str( file); 1242 credential->vBar0 = retrieve_byte_array(&(credential->vBar0Length), 1243 read_buffer); 1244 credential->vBar1Length = read_int( file); 1245 read_buffer = read_str( file); 1246 credential->vBar1 = retrieve_byte_array(&(credential->vBar1Length), 1247 read_buffer); 1248 // attributes issuer 1249 credential->attributesLength = read_int( file); 1250 printf("attributesLength=%d\n", credential->attributesLength); 1251 credential->attributes = malloc(credential->attributesLength * sizeof( BYTE *)); 1252 for( i=0; i < (int)credential->attributesLength; i++) { 1253 read_buffer = read_str( file); 1254 credential->attributes[i] = retrieve_byte_array( &len, read_buffer); 1255 if( len != DAA_PARAM_SIZE_F_I / 8) { 1256 LogError("Error when parsing attributes"); 1257 LogError("\tattribute length:%d", len); 1258 LogError("\texpected length:%d", DAA_PARAM_SIZE_F_I / 8); 1259 return NULL; 1260 } 1261 } 1262 pk_internal = load_DAA_PK_internal( file); 1263 pk = i_2_e_TSS_DAA_PK( pk_internal, &normal_malloc, (TSS_HOBJECT)NULL); 1264 memcpy( &(credential->issuerPK), pk, sizeof(TSS_DAA_PK)); 1265 free( pk); 1266 free_TSS_DAA_PK_internal( pk_internal); 1267 credential->tpmSpecificEncLength = read_int( file); 1268 read_buffer = read_str( file); 1269 credential->tpmSpecificEnc = retrieve_byte_array( &(credential->tpmSpecificEncLength), 1270 read_buffer); 1271 credential->daaCounter = read_int( file); 1272 return credential; 1273 } 1274 1275 int 1276 save_TSS_DAA_CREDENTIAL(FILE *file, 1277 TSS_DAA_CREDENTIAL *credential) 1278 { 1279 int i; 1280 TSS_DAA_PK_internal *pk_internal; 1281 1282 fprintf(file, "%d # %s.length\n", credential->capitalALength, "capitalA"); 1283 fprintf(file, "%s\n", dump_byte_array( credential->capitalALength, 1284 credential->capitalA)); 1285 fprintf(file, "%d # %s.length\n", credential->exponentLength, "exponent"); 1286 fprintf(file, "%s\n", dump_byte_array( credential->exponentLength, 1287 credential->exponent)); 1288 fprintf(file, "%d # %s.length\n", credential->vBar0Length, "vBar0"); 1289 fprintf(file, "%s\n", dump_byte_array( credential->vBar0Length, 1290 credential->vBar0)); 1291 fprintf(file, "%d # %s.length\n", credential->vBar1Length, "vBar1"); 1292 fprintf(file, "%s\n", dump_byte_array( credential->vBar1Length, 1293 credential->vBar1)); 1294 fprintf(file, "%d # %s\n", credential->attributesLength, "attributesLength"); 1295 for( i=0; i < (int)credential->attributesLength; i++) { 1296 fprintf(file, "%s\n", dump_byte_array( DAA_PARAM_SIZE_F_I / 8, 1297 credential->attributes[i])); 1298 } 1299 pk_internal = e_2_i_TSS_DAA_PK( &(credential->issuerPK) ); 1300 save_DAA_PK_internal( file, pk_internal); 1301 free_TSS_DAA_PK_internal( pk_internal); 1302 fprintf(file, "%d # %s.length\n", credential->tpmSpecificEncLength, "tpmSpecificEnc"); 1303 fprintf(file, "%s\n", dump_byte_array( credential->tpmSpecificEncLength, 1304 credential->tpmSpecificEnc)); 1305 fprintf(file, "%d # daaCounter\n", credential->daaCounter); 1306 return 0; 1307 } 1308 #endif 1309 /******************************************************************************************** 1310 TPM_DAA_ISSUER 1311 ********************************************************************************************/ 1312 1313 void 1314 free_TPM_DAA_ISSUER(TPM_DAA_ISSUER *tpm_daa_issuer) 1315 { 1316 free(tpm_daa_issuer); 1317 } 1318
Indexes created Thu Aug 06 00:25:04 UTC 2026