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
convert_alloc(TCS_CONTEXT_HANDLE tcsContext,UINT32 length,BYTE * source)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
copy_alloc(TCS_CONTEXT_HANDLE tcsContext,UINT32 length,BYTE * source)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
normal_malloc(size_t size,TSS_HOBJECT object)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 */
store_bi(UINT32 * length,BYTE ** buffer,const bi_ptr i,void * (* daa_alloc)(size_t size,TSS_HOBJECT object),TSS_HOBJECT object)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
get_bi(const unsigned long n_length,const BYTE * buffer)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 */
dump_field(int length,BYTE * buffer)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
i_2_e_TSS_DAA_SELECTED_ATTRIB(TSS_DAA_SELECTED_ATTRIB * selected_attrib)166 void i_2_e_TSS_DAA_SELECTED_ATTRIB(
167 TSS_DAA_SELECTED_ATTRIB *selected_attrib
168 ) {
169 }
170
e_2_i_TSS_DAA_SELECTED_ATTRIB(TSS_DAA_SELECTED_ATTRIB * selected_attrib)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 */
to_bytes_TSS_DAA_SELECTED_ATTRIB_internal(int * result_length,TSS_DAA_SELECTED_ATTRIB * selected_attrib)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 */
create_TSS_DAA_SELECTED_ATTRIB(TSS_DAA_SELECTED_ATTRIB * attrib,int length,...)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
i_2_e_TSS_DAA_SIGN_DATA(TSS_DAA_SIGN_DATA * sign_data)226 void i_2_e_TSS_DAA_SIGN_DATA( TSS_DAA_SIGN_DATA *sign_data) {
227 }
228
e_2_i_TSS_DAA_SIGN(TSS_DAA_SIGN_DATA * sign_data)229 void e_2_i_TSS_DAA_SIGN( TSS_DAA_SIGN_DATA *sign_data) {
230 }
231
232 /********************************************************************************************
233 * TSS_DAA_ATTRIB_COMMIT
234 ********************************************************************************************/
235
create_TSS_DAA_ATTRIB_COMMIT(bi_ptr beta,bi_ptr sMu)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 *
create_TSS_DAA_PSEUDONYM_PLAIN(bi_ptr nV)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 *
create_TSS_DAA_PRIVATE_KEY(bi_ptr pPrime,bi_ptr qPrime)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
e_2_i_TSS_DAA_PRIVATE_KEY(TSS_DAA_PRIVATE_KEY * private_key)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 *
i_2_e_TSS_DAA_PRIVATE_KEY(DAA_PRIVATE_KEY_internal * private_key_internal,void * (* daa_alloc)(size_t size,TSS_HOBJECT object),TSS_HOBJECT param_alloc)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 */
get_TSS_DAA_KEY_PAIR(KEY_PAIR_WITH_PROOF_internal * key_pair_with_proof,void * (* daa_alloc)(size_t size,TSS_HOBJECT object),TSS_HOBJECT param_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
populate_capitalY(TSS_DAA_PK_internal * pk_internal)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
compute_capitalSprime(TSS_DAA_PK_internal * pk_internal)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 *
create_DAA_PK(const bi_ptr modulus,const bi_ptr capitalS,const bi_ptr capitalZ,const bi_ptr capitalR0,const bi_ptr capitalR1,const bi_ptr gamma,const bi_ptr capitalGamma,const bi_ptr rho,const bi_array_ptr capitalRReceiver,const bi_array_ptr capitalRIssuer,const int issuerBaseNameLength,BYTE * const issuerBaseName)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
dump_DAA_PK_internal(char * name,TSS_DAA_PK_internal * pk_internal)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 *
encoded_DAA_PK_internal(int * result_length,const TSS_DAA_PK_internal * pk)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 *
i_2_e_TSS_DAA_PK(TSS_DAA_PK_internal * pk_internal,void * (* daa_alloc)(size_t size,TSS_HOBJECT param_alloc),TSS_HOBJECT param_alloc)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 *
e_2_i_TSS_DAA_PK(TSS_DAA_PK * pk)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
free_TSS_DAA_PK_internal(TSS_DAA_PK_internal * pk_internal)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
free_TSS_DAA_PK(TSS_DAA_PK * pk)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 *
convert2issuer_settings(TSS_DAA_PK_internal * pk_internal)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 *
issuer_2_byte_array(TPM_DAA_ISSUER * tpm_daa_issuer,int * length)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 *
create_DAA_PK_PROOF(BYTE * const challenge,const int length_challenge,bi_array_ptr * response,const int length_response)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 *
i_2_e_TSS_DAA_PK_PROOF(TSS_DAA_PK_PROOF_internal * pk_internal_proof,void * (* daa_alloc)(size_t size,TSS_HOBJECT param),TSS_HOBJECT param_alloc)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 *
e_2_i_TSS_DAA_PK_PROOF(TSS_DAA_PK_PROOF * pk_proof)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 *
create(TSS_DAA_PK_PROOF_internal * issuerKeyPair,TPM_DAA_ISSUER * issuerAuthKey,TSS_DAA_IDENTITY_PROOF * identityProof,bi_ptr capitalUprime,int daaCounter,int nonceIssuerLength,BYTE * nonceIssuer,int nonceEncryptedLength,BYTE * nonceEncrypted)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*
e_2_i_TSS_DAA_SIGNATURE(TSS_DAA_SIGNATURE * signature)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
free_TSS_DAA_SIGNATURE_internal(TSS_DAA_SIGNATURE_internal * signature)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
free_TPM_DAA_ISSUER(TPM_DAA_ISSUER * tpm_daa_issuer)1314 free_TPM_DAA_ISSUER(TPM_DAA_ISSUER *tpm_daa_issuer)
1315 {
1316 free(tpm_daa_issuer);
1317 }
1318