1
2
3 LC_CLIENT_RESULT CHIPCARD_CB
LC_Card__IsoReadBinary(LC_CARD * card,uint32_t flags,int offset,int size,GWEN_BUFFER * buf)4 LC_Card__IsoReadBinary(LC_CARD *card,
5 uint32_t flags,
6 int offset,
7 int size,
8 GWEN_BUFFER *buf){
9 GWEN_DB_NODE *dbReq;
10 GWEN_DB_NODE *dbResp;
11 LC_CLIENT_RESULT res;
12 unsigned int bs;
13 const void *p;
14
15 DBG_INFO(LC_LOGDOMAIN, "Reading binary %04x:%04x", offset, size);
16
17 if (flags & LC_CARD_ISO_FLAGS_EFID_MASK) {
18 if (offset>255) {
19 DBG_ERROR(LC_LOGDOMAIN,
20 "Offset too high when implicitly selecting EF "
21 "(%u)", flags);
22 return LC_Client_ResultInvalid;
23 }
24 /* modify offset: highbyte is p1, lowbyte is p2 */
25 offset|=0x8000;
26 offset|=((flags & LC_CARD_ISO_FLAGS_EFID_MASK)<<8);
27 }
28
29 dbReq=GWEN_DB_Group_new("request");
30 dbResp=GWEN_DB_Group_new("response");
31 GWEN_DB_SetIntValue(dbReq, GWEN_DB_FLAGS_DEFAULT,
32 "offset", offset);
33 GWEN_DB_SetIntValue(dbReq, GWEN_DB_FLAGS_DEFAULT,
34 "lr", size);
35
36 res=LC_Card_ExecCommand(card, "IsoReadBinary", dbReq, dbResp);
37 if (res!=LC_Client_ResultOk) {
38 GWEN_DB_Group_free(dbReq);
39 GWEN_DB_Group_free(dbResp);
40 return res;
41 }
42
43 /* successful */
44 if (buf) {
45 p=GWEN_DB_GetBinValue(dbResp,
46 "response/data",
47 0,
48 0, 0,
49 &bs);
50 if (p && bs) {
51 GWEN_Buffer_AppendBytes(buf, p, bs);
52 }
53 else {
54 DBG_WARN(LC_LOGDOMAIN, "No data in response");
55 }
56 }
57
58 GWEN_DB_Group_free(dbResp);
59 GWEN_DB_Group_free(dbReq);
60 return res;
61 }
62
63
64
65 LC_CLIENT_RESULT CHIPCARD_CB
LC_Card__IsoUpdateBinary(LC_CARD * card,uint32_t flags,int offset,const char * ptr,unsigned int size)66 LC_Card__IsoUpdateBinary(LC_CARD *card,
67 uint32_t flags,
68 int offset,
69 const char *ptr,
70 unsigned int size){
71 GWEN_DB_NODE *dbReq;
72 GWEN_DB_NODE *dbResp;
73 LC_CLIENT_RESULT res;
74
75 DBG_DEBUG(LC_LOGDOMAIN, "Writing binary %04x:%04x", offset, size);
76
77 if (flags & LC_CARD_ISO_FLAGS_EFID_MASK) {
78 if (offset>255) {
79 DBG_ERROR(LC_LOGDOMAIN,
80 "Offset too high when implicitly selecting EF "
81 "(%u)", flags);
82 return LC_Client_ResultInvalid;
83 }
84 /* modify offset: highbyte is p1, lowbyte is p2 */
85 offset|=0x8000;
86 offset|=((flags & LC_CARD_ISO_FLAGS_EFID_MASK)<<8);
87 }
88
89 dbReq=GWEN_DB_Group_new("request");
90 dbResp=GWEN_DB_Group_new("response");
91 GWEN_DB_SetIntValue(dbReq, GWEN_DB_FLAGS_DEFAULT,
92 "offset", offset);
93 if (ptr) {
94 if (size) {
95 GWEN_DB_SetBinValue(dbReq, GWEN_DB_FLAGS_DEFAULT,
96 "data", ptr, size);
97 }
98 }
99
100 res=LC_Card_ExecCommand(card, "IsoUpdateBinary", dbReq, dbResp);
101 if (res!=LC_Client_ResultOk) {
102 GWEN_DB_Group_free(dbReq);
103 GWEN_DB_Group_free(dbResp);
104 return res;
105 }
106
107 /* successful */
108 GWEN_DB_Group_free(dbResp);
109 GWEN_DB_Group_free(dbReq);
110 return res;
111 }
112
113
114
115 LC_CLIENT_RESULT CHIPCARD_CB
LC_Card__IsoWriteBinary(LC_CARD * card,uint32_t flags,int offset,const char * ptr,unsigned int size)116 LC_Card__IsoWriteBinary(LC_CARD *card,
117 uint32_t flags,
118 int offset,
119 const char *ptr,
120 unsigned int size){
121 GWEN_DB_NODE *dbReq;
122 GWEN_DB_NODE *dbResp;
123 LC_CLIENT_RESULT res;
124
125 DBG_DEBUG(LC_LOGDOMAIN, "Writing binary %04x:%04x", offset, size);
126
127 if (flags & LC_CARD_ISO_FLAGS_EFID_MASK) {
128 if (offset>255) {
129 DBG_ERROR(LC_LOGDOMAIN,
130 "Offset too high when implicitly selecting EF "
131 "(%u)", flags);
132 return LC_Client_ResultInvalid;
133 }
134 /* modify offset: highbyte is p1, lowbyte is p2 */
135 offset|=0x8000;
136 offset|=((flags & LC_CARD_ISO_FLAGS_EFID_MASK)<<8);
137 }
138
139 dbReq=GWEN_DB_Group_new("request");
140 dbResp=GWEN_DB_Group_new("response");
141 GWEN_DB_SetIntValue(dbReq, GWEN_DB_FLAGS_DEFAULT,
142 "offset", offset);
143 if (ptr) {
144 if (size) {
145 GWEN_DB_SetBinValue(dbReq, GWEN_DB_FLAGS_DEFAULT,
146 "data", ptr, size);
147 }
148 }
149
150 res=LC_Card_ExecCommand(card, "IsoWriteBinary", dbReq, dbResp);
151 if (res!=LC_Client_ResultOk) {
152 GWEN_DB_Group_free(dbReq);
153 GWEN_DB_Group_free(dbResp);
154 return res;
155 }
156
157 /* successful */
158 GWEN_DB_Group_free(dbResp);
159 GWEN_DB_Group_free(dbReq);
160 return res;
161 }
162
163
164
165 LC_CLIENT_RESULT CHIPCARD_CB
LC_Card__IsoEraseBinary(LC_CARD * card,uint32_t flags,int offset,unsigned int size)166 LC_Card__IsoEraseBinary(LC_CARD *card,
167 uint32_t flags,
168 int offset,
169 unsigned int size){
170 GWEN_DB_NODE *dbReq;
171 GWEN_DB_NODE *dbResp;
172 LC_CLIENT_RESULT res;
173
174 DBG_DEBUG(LC_LOGDOMAIN, "Erasing binary %04x:%04x", offset, size);
175
176 if (flags & LC_CARD_ISO_FLAGS_EFID_MASK) {
177 if (offset>255) {
178 DBG_ERROR(LC_LOGDOMAIN,
179 "Offset too high when implicitly selecting EF "
180 "(%u)", flags);
181 return LC_Client_ResultInvalid;
182 }
183 /* modify offset: highbyte is p1, lowbyte is p2 */
184 offset|=0x8000;
185 offset|=((flags & LC_CARD_ISO_FLAGS_EFID_MASK)<<8);
186 }
187
188 dbReq=GWEN_DB_Group_new("request");
189 dbResp=GWEN_DB_Group_new("response");
190 GWEN_DB_SetIntValue(dbReq, GWEN_DB_FLAGS_DEFAULT,
191 "offset", offset);
192 if (size!=0)
193 GWEN_DB_SetIntValue(dbReq, GWEN_DB_FLAGS_DEFAULT,
194 "len", size);
195
196 res=LC_Card_ExecCommand(card, "IsoEraseBinary", dbReq, dbResp);
197 if (res!=LC_Client_ResultOk) {
198 GWEN_DB_Group_free(dbReq);
199 GWEN_DB_Group_free(dbResp);
200 return res;
201 }
202
203 /* successful */
204 GWEN_DB_Group_free(dbResp);
205 GWEN_DB_Group_free(dbReq);
206 return res;
207 }
208
209
210
211 LC_CLIENT_RESULT CHIPCARD_CB
LC_Card__IsoReadRecord(LC_CARD * card,uint32_t flags,int recNum,GWEN_BUFFER * buf)212 LC_Card__IsoReadRecord(LC_CARD *card,
213 uint32_t flags,
214 int recNum,
215 GWEN_BUFFER *buf){
216 GWEN_DB_NODE *dbReq;
217 GWEN_DB_NODE *dbResp;
218 LC_CLIENT_RESULT res;
219 unsigned int bs;
220 const void *p;
221 unsigned char p2;
222
223 p2=(flags & LC_CARD_ISO_FLAGS_EFID_MASK)<<3;
224 if ((flags & LC_CARD_ISO_FLAGS_RECSEL_MASK)!=
225 LC_CARD_ISO_FLAGS_RECSEL_GIVEN) {
226 DBG_ERROR(LC_LOGDOMAIN,
227 "Invalid flags %u"
228 " (only RECSEL_GIVEN is allowed)", flags)
229 return LC_Client_ResultInvalid;
230 }
231 p2|=0x04;
232
233 dbReq=GWEN_DB_Group_new("request");
234 dbResp=GWEN_DB_Group_new("response");
235 GWEN_DB_SetIntValue(dbReq, GWEN_DB_FLAGS_DEFAULT,
236 "recNum", recNum);
237 GWEN_DB_SetIntValue(dbReq, GWEN_DB_FLAGS_DEFAULT,
238 "p2", p2);
239
240 res=LC_Card_ExecCommand(card, "IsoReadRecord", dbReq, dbResp);
241 if (res!=LC_Client_ResultOk) {
242 GWEN_DB_Group_free(dbReq);
243 GWEN_DB_Group_free(dbResp);
244 return res;
245 }
246
247 /* successful */
248 if (buf) {
249 p=GWEN_DB_GetBinValue(dbResp,
250 "response/data",
251 0,
252 0, 0,
253 &bs);
254 if (p && bs) {
255 GWEN_Buffer_AppendBytes(buf, p, bs);
256 }
257 else {
258 DBG_WARN(LC_LOGDOMAIN, "No data in response");
259 }
260 }
261
262 GWEN_DB_Group_free(dbResp);
263 GWEN_DB_Group_free(dbReq);
264 return res;
265 }
266
267
268
269 LC_CLIENT_RESULT CHIPCARD_CB
LC_Card__IsoWriteRecord(LC_CARD * card,uint32_t flags,int recNum,const char * ptr,unsigned int size)270 LC_Card__IsoWriteRecord(LC_CARD *card,
271 uint32_t flags,
272 int recNum,
273 const char *ptr,
274 unsigned int size) {
275 GWEN_DB_NODE *dbReq;
276 GWEN_DB_NODE *dbResp;
277 LC_CLIENT_RESULT res;
278
279 dbReq=GWEN_DB_Group_new("request");
280 dbResp=GWEN_DB_Group_new("response");
281 GWEN_DB_SetIntValue(dbReq, GWEN_DB_FLAGS_DEFAULT,
282 "recNum", recNum);
283 GWEN_DB_SetIntValue(dbReq, GWEN_DB_FLAGS_DEFAULT,
284 "p2",
285 ((flags & LC_CARD_ISO_FLAGS_RECSEL_MASK)>>5) |
286 ((flags & LC_CARD_ISO_FLAGS_EFID_MASK)<<3));
287 if (ptr && size) {
288 GWEN_DB_SetBinValue(dbReq, GWEN_DB_FLAGS_DEFAULT,
289 "data", ptr, size);
290 }
291 res=LC_Card_ExecCommand(card, "IsoWriteRecord", dbReq, dbResp);
292 if (res!=LC_Client_ResultOk) {
293 GWEN_DB_Group_free(dbReq);
294 GWEN_DB_Group_free(dbResp);
295 return res;
296 }
297
298 GWEN_DB_Group_free(dbResp);
299 GWEN_DB_Group_free(dbReq);
300 return res;
301
302 }
303
304
305
306 LC_CLIENT_RESULT CHIPCARD_CB
LC_Card__IsoUpdateRecord(LC_CARD * card,uint32_t flags,int recNum,const char * ptr,unsigned int size)307 LC_Card__IsoUpdateRecord(LC_CARD *card,
308 uint32_t flags,
309 int recNum,
310 const char *ptr,
311 unsigned int size) {
312 GWEN_DB_NODE *dbReq;
313 GWEN_DB_NODE *dbResp;
314 LC_CLIENT_RESULT res;
315
316 dbReq=GWEN_DB_Group_new("request");
317 dbResp=GWEN_DB_Group_new("response");
318 GWEN_DB_SetIntValue(dbReq, GWEN_DB_FLAGS_DEFAULT,
319 "recNum", recNum);
320 GWEN_DB_SetIntValue(dbReq, GWEN_DB_FLAGS_DEFAULT,
321 "p2",
322 ((flags & LC_CARD_ISO_FLAGS_RECSEL_MASK)>>5) |
323 ((flags & LC_CARD_ISO_FLAGS_EFID_MASK)<<3));
324 if (ptr && size) {
325 GWEN_DB_SetBinValue(dbReq, GWEN_DB_FLAGS_DEFAULT,
326 "data", ptr, size);
327 }
328 res=LC_Card_ExecCommand(card, "IsoUpdateRecord", dbReq, dbResp);
329 if (res!=LC_Client_ResultOk) {
330 GWEN_DB_Group_free(dbReq);
331 GWEN_DB_Group_free(dbResp);
332 return res;
333 }
334
335 GWEN_DB_Group_free(dbResp);
336 GWEN_DB_Group_free(dbReq);
337 return res;
338 }
339
340
341
342 LC_CLIENT_RESULT CHIPCARD_CB
LC_Card__IsoAppendRecord(LC_CARD * card,uint32_t flags,const char * ptr,unsigned int size)343 LC_Card__IsoAppendRecord(LC_CARD *card,
344 uint32_t flags,
345 const char *ptr,
346 unsigned int size) {
347 GWEN_DB_NODE *dbReq;
348 GWEN_DB_NODE *dbResp;
349 LC_CLIENT_RESULT res;
350
351 dbReq=GWEN_DB_Group_new("request");
352 dbResp=GWEN_DB_Group_new("response");
353 GWEN_DB_SetIntValue(dbReq, GWEN_DB_FLAGS_DEFAULT,
354 "p2",
355 (flags & LC_CARD_ISO_FLAGS_EFID_MASK)<<3);
356
357 if (ptr && size) {
358 GWEN_DB_SetBinValue(dbReq, GWEN_DB_FLAGS_DEFAULT,
359 "data", ptr, size);
360 }
361 res=LC_Card_ExecCommand(card, "IsoAppendRecord", dbReq, dbResp);
362 if (res!=LC_Client_ResultOk) {
363 GWEN_DB_Group_free(dbReq);
364 GWEN_DB_Group_free(dbResp);
365 return res;
366 }
367
368 GWEN_DB_Group_free(dbResp);
369 GWEN_DB_Group_free(dbReq);
370 return res;
371 }
372
373
374
375 LC_CLIENT_RESULT CHIPCARD_CB
LC_Card__IsoVerifyPin(LC_CARD * card,uint32_t flags,const LC_PININFO * pi,const unsigned char * ptr,unsigned int size,int * triesLeft)376 LC_Card__IsoVerifyPin(LC_CARD *card,
377 uint32_t flags,
378 const LC_PININFO *pi,
379 const unsigned char *ptr,
380 unsigned int size,
381 int *triesLeft) {
382 GWEN_DB_NODE *dbReq;
383 GWEN_DB_NODE *dbResp;
384 GWEN_DB_NODE *dbT;
385 LC_CLIENT_RESULT res;
386 const char *cmd;
387
388 if (triesLeft)
389 *triesLeft=-1;
390
391 switch(LC_PinInfo_GetEncoding(pi)) {
392 case GWEN_Crypt_PinEncoding_Bin:
393 cmd="IsoVerifyPin_Bin";
394 break;
395 case GWEN_Crypt_PinEncoding_Bcd:
396 cmd="IsoVerifyPin_Bcd";
397 break;
398 case GWEN_Crypt_PinEncoding_Ascii:
399 cmd="IsoVerifyPin_Ascii";
400 break;
401 case GWEN_Crypt_PinEncoding_FPin2:
402 cmd="IsoVerifyPin_Fpin2";
403 break;
404 default:
405 DBG_ERROR(LC_LOGDOMAIN, "Unhandled pin encoding \"%s\"",
406 GWEN_Crypt_PinEncoding_toString(LC_PinInfo_GetEncoding(pi)));
407 return LC_Client_ResultInvalid;
408 }
409
410 dbReq=GWEN_DB_Group_new("request");
411 dbResp=GWEN_DB_Group_new("response");
412 dbT=GWEN_DB_GetGroup(dbReq, GWEN_DB_FLAGS_OVERWRITE_GROUPS, "pinInfo");
413 assert(dbT);
414 LC_PinInfo_toDb(pi, dbT);
415 GWEN_DB_SetIntValue(dbReq, GWEN_DB_FLAGS_OVERWRITE_VARS,
416 "pid", LC_PinInfo_GetId(pi));
417
418 if (ptr && size) {
419 GWEN_DB_SetBinValue(dbReq, GWEN_DB_FLAGS_DEFAULT,
420 "pin", ptr, size);
421 }
422 res=LC_Card_ExecCommand(card, cmd, dbReq, dbResp);
423 if (res!=LC_Client_ResultOk) {
424 GWEN_DB_Group_free(dbReq);
425 GWEN_DB_Group_free(dbResp);
426 if (res==LC_Client_ResultCmdError && triesLeft) {
427 if (LC_Card_GetLastSW1(card)==0x63) {
428 int c;
429
430 c=LC_Card_GetLastSW2(card);
431 if (c>=0xc0)
432 *triesLeft=(c & 0xf);
433 }
434 }
435 return res;
436 }
437
438 GWEN_DB_Group_free(dbResp);
439 GWEN_DB_Group_free(dbReq);
440 return res;
441 }
442
443
444
445 LC_CLIENT_RESULT CHIPCARD_CB
LC_Card__IsoModifyPin(LC_CARD * card,uint32_t flags,const LC_PININFO * pi,const unsigned char * oldptr,unsigned int oldsize,const unsigned char * newptr,unsigned int newsize,int * triesLeft)446 LC_Card__IsoModifyPin(LC_CARD *card,
447 uint32_t flags,
448 const LC_PININFO *pi,
449 const unsigned char *oldptr,
450 unsigned int oldsize,
451 const unsigned char *newptr,
452 unsigned int newsize,
453 int *triesLeft) {
454 GWEN_DB_NODE *dbReq;
455 GWEN_DB_NODE *dbResp;
456 GWEN_DB_NODE *dbT;
457 LC_CLIENT_RESULT res;
458 const char *cmd;
459
460 if (triesLeft)
461 *triesLeft=-1;
462
463 switch(LC_PinInfo_GetEncoding(pi)) {
464 case GWEN_Crypt_PinEncoding_Bin:
465 cmd="IsoModifyPin_Bin";
466 break;
467 case GWEN_Crypt_PinEncoding_Bcd:
468 cmd="IsoModifyPin_Bcd";
469 break;
470 case GWEN_Crypt_PinEncoding_Ascii:
471 cmd="IsoModifyPin_Ascii";
472 break;
473 case GWEN_Crypt_PinEncoding_FPin2:
474 cmd="IsoModifyPin_Fpin2";
475 break;
476 default:
477 DBG_ERROR(LC_LOGDOMAIN, "Unhandled pin encoding \"%s\"",
478 GWEN_Crypt_PinEncoding_toString(LC_PinInfo_GetEncoding(pi)));
479 return LC_Client_ResultInvalid;
480 }
481
482 dbReq=GWEN_DB_Group_new("request");
483 dbResp=GWEN_DB_Group_new("response");
484 dbT=GWEN_DB_GetGroup(dbReq, GWEN_DB_FLAGS_OVERWRITE_GROUPS, "pinInfo");
485 assert(dbT);
486 LC_PinInfo_toDb(pi, dbT);
487 GWEN_DB_SetIntValue(dbReq, GWEN_DB_FLAGS_OVERWRITE_VARS,
488 "pid", LC_PinInfo_GetId(pi));
489
490 if (oldptr && oldsize) {
491 GWEN_DB_SetBinValue(dbReq, GWEN_DB_FLAGS_DEFAULT,
492 "oldpin", oldptr, oldsize);
493 }
494 if (newptr && newsize) {
495 GWEN_DB_SetBinValue(dbReq, GWEN_DB_FLAGS_DEFAULT,
496 "newpin", newptr, newsize);
497 }
498 res=LC_Card_ExecCommand(card, cmd, dbReq, dbResp);
499 if (res!=LC_Client_ResultOk) {
500 GWEN_DB_Group_free(dbReq);
501 GWEN_DB_Group_free(dbResp);
502 if (res==LC_Client_ResultCmdError && triesLeft) {
503 if (LC_Card_GetLastSW1(card)==0x63) {
504 int c;
505
506 c=LC_Card_GetLastSW2(card);
507 if (c>=0xc0)
508 *triesLeft=(c & 0xf);
509 }
510 }
511 return res;
512 }
513
514 GWEN_DB_Group_free(dbResp);
515 GWEN_DB_Group_free(dbReq);
516 return res;
517 }
518
519
520
521 LC_CLIENT_RESULT CHIPCARD_CB
LC_Card__IsoPerformVerification(LC_CARD * card,uint32_t flags,const LC_PININFO * pi,int * triesLeft)522 LC_Card__IsoPerformVerification(LC_CARD *card,
523 uint32_t flags,
524 const LC_PININFO *pi,
525 int *triesLeft) {
526 GWEN_DB_NODE *dbReq=0;
527 GWEN_DB_NODE *dbResp;
528 GWEN_DB_NODE *dbT;
529 LC_CLIENT_RESULT res;
530 const char *cmd;
531
532 if (triesLeft)
533 *triesLeft=-1;
534
535 switch(LC_PinInfo_GetEncoding(pi)) {
536 case GWEN_Crypt_PinEncoding_Bin:
537 cmd="IsoPerformVerification_Bin";
538 break;
539 case GWEN_Crypt_PinEncoding_Bcd:
540 cmd="IsoPerformVerification_Bcd";
541 break;
542 case GWEN_Crypt_PinEncoding_Ascii:
543 cmd="IsoPerformVerification_Ascii";
544 break;
545 case GWEN_Crypt_PinEncoding_FPin2:
546 cmd="IsoPerformVerification_Fpin2";
547 break;
548 default:
549 DBG_ERROR(LC_LOGDOMAIN, "Unhandled pin encoding \"%s\"",
550 GWEN_Crypt_PinEncoding_toString(LC_PinInfo_GetEncoding(pi)));
551 return LC_Client_ResultInvalid;
552 }
553
554 dbReq=GWEN_DB_Group_new("request");
555 dbResp=GWEN_DB_Group_new("response");
556 dbT=GWEN_DB_GetGroup(dbReq, GWEN_DB_FLAGS_OVERWRITE_GROUPS, "pinInfo");
557 assert(dbT);
558 LC_PinInfo_toDb(pi, dbT);
559 GWEN_DB_SetIntValue(dbReq, GWEN_DB_FLAGS_OVERWRITE_VARS,
560 "pid", LC_PinInfo_GetId(pi));
561
562 res=LC_Card_ExecCommand(card, cmd, dbReq, dbResp);
563 DBG_DEBUG(LC_LOGDOMAIN, "ExecCommand returned %d", res);
564 if (res!=LC_Client_ResultOk) {
565 DBG_INFO(LC_LOGDOMAIN, "here (%d)", res);
566 GWEN_DB_Group_free(dbReq);
567 GWEN_DB_Group_free(dbResp);
568 if (res==LC_Client_ResultCmdError && triesLeft) {
569 if (LC_Card_GetLastSW1(card)==0x63) {
570 int c;
571
572 c=LC_Card_GetLastSW2(card);
573 if (c>=0xc0)
574 *triesLeft=(c & 0xf);
575 }
576 }
577 return res;
578 }
579
580 GWEN_DB_Group_free(dbResp);
581 GWEN_DB_Group_free(dbReq);
582 return res;
583 }
584
585
586
587 LC_CLIENT_RESULT CHIPCARD_CB
LC_Card__IsoPerformModification(LC_CARD * card,uint32_t flags,const LC_PININFO * pi,int * triesLeft)588 LC_Card__IsoPerformModification(LC_CARD *card,
589 uint32_t flags,
590 const LC_PININFO *pi,
591 int *triesLeft) {
592 GWEN_DB_NODE *dbReq=0;
593 GWEN_DB_NODE *dbResp;
594 GWEN_DB_NODE *dbT;
595 LC_CLIENT_RESULT res;
596 const char *cmd;
597
598 if (triesLeft)
599 *triesLeft=-1;
600
601 switch(LC_PinInfo_GetEncoding(pi)) {
602 case GWEN_Crypt_PinEncoding_Bin:
603 cmd="IsoPerformModification_Bin";
604 break;
605 case GWEN_Crypt_PinEncoding_Bcd:
606 cmd="IsoPerformModification_Bcd";
607 break;
608 case GWEN_Crypt_PinEncoding_Ascii:
609 cmd="IsoPerformModification_Ascii";
610 break;
611 case GWEN_Crypt_PinEncoding_FPin2:
612 cmd="IsoPerformModification_Fpin2";
613 break;
614 default:
615 DBG_ERROR(LC_LOGDOMAIN, "Unhandled pin encoding \"%s\"",
616 GWEN_Crypt_PinEncoding_toString(LC_PinInfo_GetEncoding(pi)));
617 return LC_Client_ResultInvalid;
618 }
619
620 dbReq=GWEN_DB_Group_new("request");
621 dbResp=GWEN_DB_Group_new("response");
622 dbT=GWEN_DB_GetGroup(dbReq, GWEN_DB_FLAGS_OVERWRITE_GROUPS, "pinInfo");
623 assert(dbT);
624 LC_PinInfo_toDb(pi, dbT);
625 GWEN_DB_SetIntValue(dbReq, GWEN_DB_FLAGS_OVERWRITE_VARS,
626 "pid", LC_PinInfo_GetId(pi));
627
628 res=LC_Card_ExecCommand(card, cmd, dbReq, dbResp);
629 if (res!=LC_Client_ResultOk) {
630 GWEN_DB_Group_free(dbReq);
631 GWEN_DB_Group_free(dbResp);
632 if (res==LC_Client_ResultCmdError && triesLeft) {
633 if (LC_Card_GetLastSW1(card)==0x63) {
634 int c;
635
636 c=LC_Card_GetLastSW2(card);
637 if (c>=0xc0)
638 *triesLeft=(c & 0xf);
639 }
640 }
641 return res;
642 }
643
644 GWEN_DB_Group_free(dbResp);
645 GWEN_DB_Group_free(dbReq);
646 return res;
647 }
648
649
650
651 LC_CLIENT_RESULT CHIPCARD_CB
LC_Card__IsoManageSe(LC_CARD * card,int tmpl,int kids,int kidp,int ar)652 LC_Card__IsoManageSe(LC_CARD *card,
653 int tmpl, int kids, int kidp, int ar) {
654 GWEN_DB_NODE *dbReq;
655 GWEN_DB_NODE *dbResp;
656 LC_CLIENT_RESULT res;
657 GWEN_BUFFER *dbuf;
658
659 assert(card);
660
661 LC_Card_SetLastResult(card, 0, 0, 0, 0);
662
663 dbuf=GWEN_Buffer_new(0, 32, 0, 1);
664 if (kids) {
665 GWEN_Buffer_AppendByte(dbuf, 0x84);
666 GWEN_Buffer_AppendByte(dbuf, 1);
667 GWEN_Buffer_AppendByte(dbuf, kids);
668 }
669
670 if (kidp) {
671 GWEN_Buffer_AppendByte(dbuf, 0x83);
672 GWEN_Buffer_AppendByte(dbuf, 1);
673 GWEN_Buffer_AppendByte(dbuf, kidp);
674 }
675
676 if (ar!=-1) {
677 GWEN_Buffer_AppendByte(dbuf, 0x80);
678 GWEN_Buffer_AppendByte(dbuf, 1);
679 GWEN_Buffer_AppendByte(dbuf, ar);
680 }
681
682 dbReq=GWEN_DB_Group_new("request");
683 GWEN_DB_SetIntValue(dbReq, GWEN_DB_FLAGS_DEFAULT,
684 "template", tmpl);
685 GWEN_DB_SetBinValue(dbReq, GWEN_DB_FLAGS_DEFAULT,
686 "data",
687 GWEN_Buffer_GetStart(dbuf),
688 GWEN_Buffer_GetUsedBytes(dbuf));
689 GWEN_Buffer_free(dbuf);
690
691 dbResp=GWEN_DB_Group_new("response");
692 res=LC_Card_ExecCommand(card, "IsoManageSE", dbReq, dbResp);
693 if (res!=LC_Client_ResultOk) {
694 DBG_INFO(LC_LOGDOMAIN, "here");
695 GWEN_DB_Group_free(dbReq);
696 GWEN_DB_Group_free(dbResp);
697 return res;
698 }
699 GWEN_DB_Group_free(dbReq);
700 GWEN_DB_Group_free(dbResp);
701 return LC_Client_ResultOk;
702 }
703
704
705
706 LC_CLIENT_RESULT CHIPCARD_CB
LC_Card__IsoInternalAuth(LC_CARD * card,int kid,const unsigned char * ptr,unsigned int size,GWEN_BUFFER * rBuf)707 LC_Card__IsoInternalAuth(LC_CARD *card,
708 int kid,
709 const unsigned char *ptr,
710 unsigned int size,
711 GWEN_BUFFER *rBuf) {
712 GWEN_DB_NODE *dbReq;
713 GWEN_DB_NODE *dbResp;
714 LC_CLIENT_RESULT res;
715
716 dbReq=GWEN_DB_Group_new("request");
717 dbResp=GWEN_DB_Group_new("response");
718 GWEN_DB_SetIntValue(dbReq, GWEN_DB_FLAGS_OVERWRITE_VARS, "kid", kid);
719
720 if (ptr && size) {
721 GWEN_DB_SetBinValue(dbReq, GWEN_DB_FLAGS_DEFAULT,
722 "data", ptr, size);
723 }
724 res=LC_Card_ExecCommand(card, "IsoInternalAuth", dbReq, dbResp);
725 if (res!=LC_Client_ResultOk) {
726 GWEN_DB_Group_free(dbReq);
727 GWEN_DB_Group_free(dbResp);
728 return res;
729 }
730
731
732 if (rBuf) {
733 unsigned int bs;
734 const void *p;
735
736 p=GWEN_DB_GetBinValue(dbResp,
737 "response/data",
738 0,
739 0, 0,
740 &bs);
741 if (p && bs) {
742 GWEN_Buffer_AppendBytes(rBuf, p, bs);
743 }
744 else {
745 DBG_WARN(LC_LOGDOMAIN, "No data in response");
746 }
747 }
748
749 GWEN_DB_Group_free(dbResp);
750 GWEN_DB_Group_free(dbReq);
751 return res;
752 }
753
754
755
756
757 LC_CLIENT_RESULT CHIPCARD_CB
LC_Card__IsoEncipher(LC_CARD * card,const char * ptr,unsigned int size,GWEN_BUFFER * codeBuf)758 LC_Card__IsoEncipher(LC_CARD *card,
759 const char *ptr,
760 unsigned int size,
761 GWEN_BUFFER *codeBuf) {
762 GWEN_DB_NODE *dbReq;
763 GWEN_DB_NODE *dbRsp;
764 LC_CLIENT_RESULT res;
765 const void *p;
766 unsigned int bs;
767
768 assert(card);
769
770 /* put data */
771 dbReq=GWEN_DB_Group_new("request");
772 dbRsp=GWEN_DB_Group_new("response");
773 GWEN_DB_SetBinValue(dbReq, GWEN_DB_FLAGS_DEFAULT,
774 "data", ptr, size);
775 LC_Card_SetLastResult(card, 0, 0, 0, 0);
776 res=LC_Card_ExecCommand(card, "IsoEncipher", dbReq, dbRsp);
777 if (res!=LC_Client_ResultOk) {
778 DBG_INFO(LC_LOGDOMAIN, "here");
779 GWEN_DB_Group_free(dbReq);
780 GWEN_DB_Group_free(dbRsp);
781 return res;
782 }
783
784 /* extract the encoded data */
785 p=GWEN_DB_GetBinValue(dbRsp, "response/data", 0, 0, 0, &bs);
786 if (!p || !bs) {
787 DBG_ERROR(LC_LOGDOMAIN, "No data returned by card");
788 GWEN_DB_Dump(dbRsp, 2);
789 GWEN_DB_Group_free(dbReq);
790 GWEN_DB_Group_free(dbRsp);
791 return res;
792 }
793 GWEN_Buffer_AppendBytes(codeBuf, p, bs);
794 GWEN_DB_Group_free(dbReq);
795 GWEN_DB_Group_free(dbRsp);
796
797 return LC_Client_ResultOk;
798 }
799
800
801
802 LC_CLIENT_RESULT CHIPCARD_CB
LC_Card__IsoDecipher(LC_CARD * card,const char * ptr,unsigned int size,GWEN_BUFFER * plainBuf)803 LC_Card__IsoDecipher(LC_CARD *card,
804 const char *ptr,
805 unsigned int size,
806 GWEN_BUFFER *plainBuf) {
807 GWEN_DB_NODE *dbReq;
808 GWEN_DB_NODE *dbRsp;
809 LC_CLIENT_RESULT res;
810 const void *p;
811 unsigned int bs;
812
813 assert(card);
814
815 /* put hash */
816 dbReq=GWEN_DB_Group_new("request");
817 dbRsp=GWEN_DB_Group_new("response");
818 GWEN_DB_SetBinValue(dbReq, GWEN_DB_FLAGS_DEFAULT,
819 "data", ptr, size);
820 LC_Card_SetLastResult(card, 0, 0, 0, 0);
821 res=LC_Card_ExecCommand(card, "IsoDecipher", dbReq, dbRsp);
822 if (res!=LC_Client_ResultOk) {
823 DBG_INFO(LC_LOGDOMAIN, "here");
824 GWEN_DB_Group_free(dbReq);
825 GWEN_DB_Group_free(dbRsp);
826 return res;
827 }
828
829 /* extract the decoded data */
830 p=GWEN_DB_GetBinValue(dbRsp, "response/data", 0, 0, 0, &bs);
831 if (!p || !bs) {
832 DBG_ERROR(LC_LOGDOMAIN, "No data returned by card");
833 GWEN_DB_Group_free(dbReq);
834 GWEN_DB_Group_free(dbRsp);
835 return res;
836 }
837 GWEN_Buffer_AppendBytes(plainBuf, p, bs);
838 GWEN_DB_Group_free(dbReq);
839 GWEN_DB_Group_free(dbRsp);
840
841 return LC_Client_ResultOk;
842 }
843
844
845
846
847
848
849
LC_Card_IsoReadBinary(LC_CARD * card,uint32_t flags,int offset,int size,GWEN_BUFFER * buf)850 LC_CLIENT_RESULT LC_Card_IsoReadBinary(LC_CARD *card,
851 uint32_t flags,
852 int offset,
853 int size,
854 GWEN_BUFFER *buf) {
855 assert(card);
856 if (card->readBinaryFn)
857 return card->readBinaryFn(card, flags, offset, size, buf);
858 else
859 return LC_Card__IsoReadBinary(card, flags, offset, size, buf);
860 }
861
862
863
LC_Card_IsoWriteBinary(LC_CARD * card,uint32_t flags,int offset,const char * ptr,unsigned int size)864 LC_CLIENT_RESULT LC_Card_IsoWriteBinary(LC_CARD *card,
865 uint32_t flags,
866 int offset,
867 const char *ptr,
868 unsigned int size) {
869 assert(card);
870 if (card->writeBinaryFn)
871 return card->writeBinaryFn(card, flags, offset, ptr, size);
872 else
873 return LC_Card__IsoWriteBinary(card, flags, offset, ptr, size);
874 }
875
876
877
LC_Card_IsoUpdateBinary(LC_CARD * card,uint32_t flags,int offset,const char * ptr,unsigned int size)878 LC_CLIENT_RESULT LC_Card_IsoUpdateBinary(LC_CARD *card,
879 uint32_t flags,
880 int offset,
881 const char *ptr,
882 unsigned int size) {
883 assert(card);
884 if (card->updateBinaryFn)
885 return card->updateBinaryFn(card, flags, offset, ptr, size);
886 else
887 return LC_Card__IsoUpdateBinary(card, flags, offset, ptr, size);
888 }
889
890
891
892
LC_Card_IsoEraseBinary(LC_CARD * card,uint32_t flags,int offset,unsigned int size)893 LC_CLIENT_RESULT LC_Card_IsoEraseBinary(LC_CARD *card,
894 uint32_t flags,
895 int offset,
896 unsigned int size) {
897 assert(card);
898 if (card->eraseBinaryFn)
899 return card->eraseBinaryFn(card, flags, offset, size);
900 else
901 return LC_Card__IsoEraseBinary(card, flags, offset, size);
902 }
903
904
905
LC_Card_IsoReadRecord(LC_CARD * card,uint32_t flags,int recNum,GWEN_BUFFER * buf)906 LC_CLIENT_RESULT LC_Card_IsoReadRecord(LC_CARD *card,
907 uint32_t flags,
908 int recNum,
909 GWEN_BUFFER *buf) {
910 assert(card);
911 if (card->readRecordFn)
912 return card->readRecordFn(card, flags, recNum, buf);
913 else
914 return LC_Card__IsoReadRecord(card, flags, recNum, buf);
915 }
916
917
918
LC_Card_IsoWriteRecord(LC_CARD * card,uint32_t flags,int recNum,const char * ptr,unsigned int size)919 LC_CLIENT_RESULT LC_Card_IsoWriteRecord(LC_CARD *card,
920 uint32_t flags,
921 int recNum,
922 const char *ptr,
923 unsigned int size) {
924 assert(card);
925 if (card->writeRecordFn)
926 return card->writeRecordFn(card, flags, recNum, ptr, size);
927 else
928 return LC_Card__IsoWriteRecord(card, flags, recNum, ptr, size);
929 }
930
931
932
LC_Card_IsoAppendRecord(LC_CARD * card,uint32_t flags,const char * ptr,unsigned int size)933 LC_CLIENT_RESULT LC_Card_IsoAppendRecord(LC_CARD *card,
934 uint32_t flags,
935 const char *ptr,
936 unsigned int size) {
937 assert(card);
938 if (card->appendRecordFn)
939 return card->appendRecordFn(card, flags, ptr, size);
940 else
941 return LC_Card__IsoAppendRecord(card, flags, ptr, size);
942 }
943
944
945
946
LC_Card_IsoUpdateRecord(LC_CARD * card,uint32_t flags,int recNum,const char * ptr,unsigned int size)947 LC_CLIENT_RESULT LC_Card_IsoUpdateRecord(LC_CARD *card,
948 uint32_t flags,
949 int recNum,
950 const char *ptr,
951 unsigned int size) {
952 assert(card);
953 if (card->updateRecordFn)
954 return card->updateRecordFn(card, flags, recNum, ptr, size);
955 else
956 return LC_Card__IsoUpdateRecord(card, flags, recNum, ptr, size);
957 }
958
959
960
LC_Card_IsoVerifyPin(LC_CARD * card,uint32_t flags,const LC_PININFO * pi,const unsigned char * ptr,unsigned int size,int * triesLeft)961 LC_CLIENT_RESULT LC_Card_IsoVerifyPin(LC_CARD *card,
962 uint32_t flags,
963 const LC_PININFO *pi,
964 const unsigned char *ptr,
965 unsigned int size,
966 int *triesLeft) {
967 assert(card);
968 if (card->verifyPinFn)
969 return card->verifyPinFn(card, flags, pi, ptr, size,
970 triesLeft);
971 else
972 return LC_Card__IsoVerifyPin(card, flags, pi, ptr, size,
973 triesLeft);
974 }
975
976
977
LC_Card_IsoModifyPin(LC_CARD * card,uint32_t flags,const LC_PININFO * pi,const unsigned char * oldptr,unsigned int oldsize,const unsigned char * newptr,unsigned int newsize,int * triesLeft)978 LC_CLIENT_RESULT LC_Card_IsoModifyPin(LC_CARD *card,
979 uint32_t flags,
980 const LC_PININFO *pi,
981 const unsigned char *oldptr,
982 unsigned int oldsize,
983 const unsigned char *newptr,
984 unsigned int newsize,
985 int *triesLeft) {
986 assert(card);
987 if (card->modifyPinFn)
988 return card->modifyPinFn(card, flags, pi,
989 oldptr, oldsize,
990 newptr, newsize,
991 triesLeft);
992 else
993 return LC_Card__IsoModifyPin(card, flags, pi,
994 oldptr, oldsize,
995 newptr, newsize,
996 triesLeft);
997 }
998
999
1000
LC_Card_IsoPerformVerification(LC_CARD * card,uint32_t flags,const LC_PININFO * pi,int * triesLeft)1001 LC_CLIENT_RESULT LC_Card_IsoPerformVerification(LC_CARD *card,
1002 uint32_t flags,
1003 const LC_PININFO *pi,
1004 int *triesLeft) {
1005 assert(card);
1006 if (card->performVerificationFn)
1007 return card->performVerificationFn(card, flags, pi,
1008 triesLeft);
1009 else
1010 return LC_Card__IsoPerformVerification(card, flags, pi,
1011 triesLeft);
1012 }
1013
1014
1015
LC_Card_IsoPerformModification(LC_CARD * card,uint32_t flags,const LC_PININFO * pi,int * triesLeft)1016 LC_CLIENT_RESULT LC_Card_IsoPerformModification(LC_CARD *card,
1017 uint32_t flags,
1018 const LC_PININFO *pi,
1019 int *triesLeft) {
1020 assert(card);
1021 if (card->performModificationFn)
1022 return card->performModificationFn(card, flags, pi,
1023 triesLeft);
1024 else
1025 return LC_Card__IsoPerformModification(card, flags, pi,
1026 triesLeft);
1027 }
1028
1029
1030
LC_Card_IsoManageSe(LC_CARD * card,int tmpl,int kids,int kidp,int ar)1031 LC_CLIENT_RESULT LC_Card_IsoManageSe(LC_CARD *card,
1032 int tmpl, int kids, int kidp, int ar) {
1033 assert(card);
1034 if (card->manageSeFn)
1035 return card->manageSeFn(card, tmpl, kids, kidp, ar);
1036 else
1037 return LC_Card__IsoManageSe(card, tmpl, kids, kidp, ar);
1038 }
1039
1040
1041
LC_Card_IsoEncipher(LC_CARD * card,const char * ptr,unsigned int size,GWEN_BUFFER * codeBuf)1042 LC_CLIENT_RESULT LC_Card_IsoEncipher(LC_CARD *card,
1043 const char *ptr,
1044 unsigned int size,
1045 GWEN_BUFFER *codeBuf) {
1046 assert(card);
1047 if (card->encipherFn)
1048 return card->encipherFn(card, ptr, size, codeBuf);
1049 else
1050 return LC_Card__IsoEncipher(card, ptr, size, codeBuf);
1051 }
1052
1053
1054
LC_Card_IsoDecipher(LC_CARD * card,const char * ptr,unsigned int size,GWEN_BUFFER * plainBuf)1055 LC_CLIENT_RESULT LC_Card_IsoDecipher(LC_CARD *card,
1056 const char *ptr,
1057 unsigned int size,
1058 GWEN_BUFFER *plainBuf) {
1059 assert(card);
1060 if (card->decipherFn)
1061 return card->decipherFn(card, ptr, size, plainBuf);
1062 else
1063 return LC_Card__IsoDecipher(card, ptr, size, plainBuf);
1064 }
1065
1066
1067
LC_Card_IsoSign(LC_CARD * card,const char * ptr,unsigned int size,GWEN_BUFFER * sigBuf)1068 LC_CLIENT_RESULT LC_Card_IsoSign(LC_CARD *card,
1069 const char *ptr,
1070 unsigned int size,
1071 GWEN_BUFFER *sigBuf) {
1072 assert(card);
1073 if (card->signFn)
1074 return card->signFn(card, ptr, size, sigBuf);
1075 else
1076 return LC_Client_ResultNotSupported;
1077 }
1078
1079
1080
LC_Card_IsoVerify(LC_CARD * card,const char * dptr,unsigned int dsize,const char * sigptr,unsigned int sigsize)1081 LC_CLIENT_RESULT LC_Card_IsoVerify(LC_CARD *card,
1082 const char *dptr,
1083 unsigned int dsize,
1084 const char *sigptr,
1085 unsigned int sigsize) {
1086 assert(card);
1087 if (card->verifyFn)
1088 return card->verifyFn(card, dptr, dsize, sigptr, sigsize);
1089 else
1090 return LC_Client_ResultNotSupported;
1091 }
1092
1093
1094
LC_Card_IsoInternalAuth(LC_CARD * card,int kid,const unsigned char * ptr,unsigned int size,GWEN_BUFFER * rBuf)1095 LC_CLIENT_RESULT LC_Card_IsoInternalAuth(LC_CARD *card,
1096 int kid,
1097 const unsigned char *ptr,
1098 unsigned int size,
1099 GWEN_BUFFER *rBuf) {
1100 assert(card);
1101 if (card->internalAuthFn)
1102 return card->internalAuthFn(card, kid, ptr, size, rBuf);
1103 else
1104 return LC_Client_ResultNotSupported;
1105 }
1106
1107
1108
1109
1110
1111
1112
LC_Card_SetIsoReadBinaryFn(LC_CARD * card,LC_CARD_ISOREADBINARY_FN f)1113 void LC_Card_SetIsoReadBinaryFn(LC_CARD *card, LC_CARD_ISOREADBINARY_FN f) {
1114 assert(card);
1115 card->readBinaryFn=f;
1116 }
1117
1118
1119
LC_Card_SetIsoWriteBinaryFn(LC_CARD * card,LC_CARD_ISOWRITEBINARY_FN f)1120 void LC_Card_SetIsoWriteBinaryFn(LC_CARD *card, LC_CARD_ISOWRITEBINARY_FN f){
1121 assert(card);
1122 card->writeBinaryFn=f;
1123 }
1124
1125
1126
LC_Card_SetIsoUpdateBinaryFn(LC_CARD * card,LC_CARD_ISOUPDATEBINARY_FN f)1127 void LC_Card_SetIsoUpdateBinaryFn(LC_CARD *card,
1128 LC_CARD_ISOUPDATEBINARY_FN f){
1129 assert(card);
1130 card->updateBinaryFn=f;
1131 }
1132
1133
1134
LC_Card_SetIsoEraseBinaryFn(LC_CARD * card,LC_CARD_ISOERASEBINARY_FN f)1135 void LC_Card_SetIsoEraseBinaryFn(LC_CARD *card, LC_CARD_ISOERASEBINARY_FN f) {
1136 assert(card);
1137 card->eraseBinaryFn=f;
1138 }
1139
1140
1141
LC_Card_SetIsoReadRecordFn(LC_CARD * card,LC_CARD_ISOREADRECORD_FN f)1142 void LC_Card_SetIsoReadRecordFn(LC_CARD *card, LC_CARD_ISOREADRECORD_FN f){
1143 assert(card);
1144 card->readRecordFn=f;
1145 }
1146
1147
1148
LC_Card_SetIsoWriteRecordFn(LC_CARD * card,LC_CARD_ISOWRITERECORD_FN f)1149 void LC_Card_SetIsoWriteRecordFn(LC_CARD *card, LC_CARD_ISOWRITERECORD_FN f){
1150 assert(card);
1151 card->writeRecordFn=f;
1152 }
1153
1154
1155
LC_Card_SetIsoUpdateRecordFn(LC_CARD * card,LC_CARD_ISOUPDATERECORD_FN f)1156 void LC_Card_SetIsoUpdateRecordFn(LC_CARD *card,
1157 LC_CARD_ISOUPDATERECORD_FN f) {
1158 assert(card);
1159 card->updateRecordFn=f;
1160 }
1161
1162
1163
LC_Card_SetIsoAppendRecordFn(LC_CARD * card,LC_CARD_ISOAPPENDRECORD_FN f)1164 void LC_Card_SetIsoAppendRecordFn(LC_CARD *card,
1165 LC_CARD_ISOAPPENDRECORD_FN f){
1166 assert(card);
1167 card->appendRecordFn=f;
1168 }
1169
1170
1171
LC_Card_SetIsoVerifyPinFn(LC_CARD * card,LC_CARD_ISOVERIFYPIN_FN f)1172 void LC_Card_SetIsoVerifyPinFn(LC_CARD *card, LC_CARD_ISOVERIFYPIN_FN f) {
1173 assert(card);
1174 card->verifyPinFn=f;
1175 }
1176
1177
1178
LC_Card_SetIsoModifyPinFn(LC_CARD * card,LC_CARD_ISOMODIFYPIN_FN f)1179 void LC_Card_SetIsoModifyPinFn(LC_CARD *card, LC_CARD_ISOMODIFYPIN_FN f) {
1180 assert(card);
1181 card->modifyPinFn=f;
1182 }
1183
1184
1185
LC_Card_SetIsoPerformVerificationFn(LC_CARD * card,LC_CARD_ISOPERFORMVERIFICATION_FN f)1186 void LC_Card_SetIsoPerformVerificationFn(LC_CARD *card,
1187 LC_CARD_ISOPERFORMVERIFICATION_FN f){
1188 assert(card);
1189 card->performVerificationFn=f;
1190 }
1191
1192
1193
LC_Card_SetIsoPerformModificationFn(LC_CARD * card,LC_CARD_ISOPERFORMMODIFICATION_FN f)1194 void LC_Card_SetIsoPerformModificationFn(LC_CARD *card,
1195 LC_CARD_ISOPERFORMMODIFICATION_FN f){
1196 assert(card);
1197 card->performModificationFn=f;
1198 }
1199
1200
1201
LC_Card_SetIsoManageSeFn(LC_CARD * card,LC_CARD_ISOMANAGESE_FN f)1202 void LC_Card_SetIsoManageSeFn(LC_CARD *card, LC_CARD_ISOMANAGESE_FN f) {
1203 assert(card);
1204 card->manageSeFn=f;
1205 }
1206
1207
1208
LC_Card_SetIsoSignFn(LC_CARD * card,LC_CARD_ISOSIGN_FN f)1209 void LC_Card_SetIsoSignFn(LC_CARD *card, LC_CARD_ISOSIGN_FN f) {
1210 assert(card);
1211 card->signFn=f;
1212 }
1213
1214
1215
LC_Card_SetIsoVerifyFn(LC_CARD * card,LC_CARD_ISOVERIFY_FN f)1216 void LC_Card_SetIsoVerifyFn(LC_CARD *card, LC_CARD_ISOVERIFY_FN f) {
1217 assert(card);
1218 card->verifyFn=f;
1219 }
1220
1221
1222
LC_Card_SetIsoEncipherFn(LC_CARD * card,LC_CARD_ISOENCIPHER_FN f)1223 void LC_Card_SetIsoEncipherFn(LC_CARD *card, LC_CARD_ISOENCIPHER_FN f) {
1224 assert(card);
1225 card->encipherFn=f;
1226 }
1227
1228
1229
LC_Card_SetIsoDecipherFn(LC_CARD * card,LC_CARD_ISODECIPHER_FN f)1230 void LC_Card_SetIsoDecipherFn(LC_CARD *card, LC_CARD_ISODECIPHER_FN f) {
1231 assert(card);
1232 card->decipherFn=f;
1233 }
1234
1235
1236
LC_Card_SetIsoInternalAuthFn(LC_CARD * card,LC_CARD_ISOINTERNALAUTH_FN f)1237 void LC_Card_SetIsoInternalAuthFn(LC_CARD *card, LC_CARD_ISOINTERNALAUTH_FN f) {
1238 assert(card);
1239 card->internalAuthFn=f;
1240 }
1241
1242
1243
1244