gwenhywfar  4.6.0beta
ct.c
Go to the documentation of this file.
1 /***************************************************************************
2  begin : Wed Mar 16 2005
3  copyright : (C) 2005-2010 by Martin Preuss
4  email : martin@libchipcard.de
5 
6  ***************************************************************************
7  * Please see toplevel file COPYING for license details *
8  ***************************************************************************/
9 
10 #ifdef HAVE_CONFIG_H
11 # include <config.h>
12 #endif
13 
14 #define DISABLE_DEBUGLOG
15 
16 
17 #include "ct_p.h"
18 #include "i18n_l.h"
19 #include <gwenhywfar/misc.h>
20 #include <gwenhywfar/debug.h>
21 #include <gwenhywfar/gui.h>
22 
23 
24 
26 GWEN_LIST_FUNCTIONS(GWEN_CRYPT_TOKEN, GWEN_Crypt_Token)
27 GWEN_LIST2_FUNCTIONS(GWEN_CRYPT_TOKEN, GWEN_Crypt_Token)
28 
29 
30 
31 
32 
34  const char *typeName,
35  const char *tokenName) {
36  GWEN_CRYPT_TOKEN *ct;
37 
38  assert(typeName);
39 
40  GWEN_NEW_OBJECT(GWEN_CRYPT_TOKEN, ct);
41  ct->refCount=1;
42  GWEN_INHERIT_INIT(GWEN_CRYPT_TOKEN, ct);
43  GWEN_LIST_INIT(GWEN_CRYPT_TOKEN, ct);
44 
45  ct->device=dev;
46  ct->typeName=strdup(typeName);
47  if (tokenName)
48  ct->tokenName=strdup(tokenName);
49 
50  return ct;
51 }
52 
53 
54 
56  if (ct) {
57  assert(ct->refCount);
58  if (ct->refCount==1) {
61  free(ct->tokenName);
62  free(ct->typeName);
63  ct->refCount=0;
64  GWEN_FREE_OBJECT(ct);
65  }
66  else {
67  ct->refCount--;
68  }
69  }
70 }
71 
72 
73 
75  assert(ct);
76  assert(ct->refCount);
77 
78  return ct->device;
79 }
80 
81 
82 
84  assert(ct);
85  assert(ct->refCount);
86 
87  return ct->typeName;
88 }
89 
90 
91 
93  assert(ct);
94  assert(ct->refCount);
95 
96  return ct->tokenName;
97 }
98 
99 
100 
102  assert(ct);
103  assert(ct->refCount);
104 
105  assert(s);
106 
107  free(ct->tokenName);
108  ct->tokenName=strdup(s);
109 }
110 
111 
112 
114  assert(ct);
115  assert(ct->refCount);
116 
117  return ct->friendlyName;
118 }
119 
120 
121 
123  assert(ct);
124  assert(ct->refCount);
125 
126  assert(s);
127 
128  free(ct->friendlyName);
129  ct->friendlyName=strdup(s);
130 }
131 
132 
133 
135  assert(ct);
136  assert(ct->refCount);
137 
138  return ct->flags;
139 }
140 
141 
142 
144  assert(ct);
145  assert(ct->refCount);
146 
147  ct->flags=f;
148 }
149 
150 
151 
153  assert(ct);
154  assert(ct->refCount);
155 
156  ct->flags|=f;
157 }
158 
159 
160 
162  assert(ct);
163  assert(ct->refCount);
164 
165  ct->flags&=~f;
166 }
167 
168 
169 
171  assert(ct);
172  assert(ct->refCount);
173 
174  return ct->modes;
175 }
176 
177 
178 
180  assert(ct);
181  assert(ct->refCount);
182 
183  ct->modes=f;
184 }
185 
186 
187 
189  assert(ct);
190  assert(ct->refCount);
191 
192  ct->modes|=f;
193 }
194 
195 
196 
198  assert(ct);
199  assert(ct->refCount);
200 
201  ct->modes&=~f;
202 }
203 
204 
205 
206 int GWEN_Crypt_Token_Open(GWEN_CRYPT_TOKEN *ct, int admin, uint32_t gid) {
207  int rv;
208 
209  assert(ct);
210  assert(ct->refCount);
211 
212  if (ct->openCount) {
213  ct->openCount++;
214  return 0;
215  }
216 
217  if (ct->openFn)
218  rv=ct->openFn(ct, admin, gid);
219  else
221 
222  if (rv==0)
223  ct->openCount++;
224  return rv;
225 }
226 
227 
228 
230  int rv;
231 
232  assert(ct);
233  assert(ct->refCount);
234 
235  if (ct->createFn)
236  rv=ct->createFn(ct, gid);
237  else
239 
240  if (rv==0)
241  ct->openCount++;
242  return rv;
243 }
244 
245 
246 
247 int GWEN_Crypt_Token_Close(GWEN_CRYPT_TOKEN *ct, int abandon, uint32_t gid) {
248  assert(ct);
249  assert(ct->refCount);
250 
251  if (ct->openCount>1 && !abandon) {
252  ct->openCount--;
253  return 0;
254  }
255 
256  if (ct->closeFn) {
257  int rv;
258 
259  rv=ct->closeFn(ct, abandon, gid);
260  if (abandon)
261  ct->openCount=0;
262  else if (rv==0)
263  ct->openCount--;
264  return rv;
265  }
266  else
268 }
269 
270 
271 
273  assert(ct);
274  assert(ct->refCount);
275 
276  return (ct->openCount!=0);
277 }
278 
279 
280 
282  uint32_t *pIdList,
283  uint32_t *pCount,
284  uint32_t gid) {
285  assert(ct);
286  assert(ct->refCount);
287 
288  if (ct->openCount<1)
289  return GWEN_ERROR_NOT_OPEN;
290 
291  if (ct->getKeyIdListFn)
292  return ct->getKeyIdListFn(ct, pIdList, pCount, gid);
293  else
295 }
296 
297 
298 
300  uint32_t id,
301  uint32_t flags,
302  uint32_t gid) {
303  assert(ct);
304  assert(ct->refCount);
305 
306  if (ct->openCount<1) {
307  DBG_INFO(GWEN_LOGDOMAIN, "Token not open");
308  return NULL;
309  }
310 
311  if (ct->getKeyInfoFn)
312  return ct->getKeyInfoFn(ct, id, flags, gid);
313  else
314  return NULL;
315 }
316 
317 
318 
320  uint32_t id,
321  const GWEN_CRYPT_TOKEN_KEYINFO *ki,
322  uint32_t gid) {
323  assert(ct);
324  assert(ct->refCount);
325 
326  if (ct->openCount<1)
327  return GWEN_ERROR_NOT_OPEN;
328 
329  if (ct->setKeyInfoFn)
330  return ct->setKeyInfoFn(ct, id, ki, gid);
331  else
333 }
334 
335 
336 
338  uint32_t *pIdList,
339  uint32_t *pCount,
340  uint32_t gid) {
341  assert(ct);
342  assert(ct->refCount);
343 
344  if (ct->openCount<1)
345  return GWEN_ERROR_NOT_OPEN;
346 
347  if (ct->getContextIdListFn)
348  return ct->getContextIdListFn(ct, pIdList, pCount, gid);
349  else
351 }
352 
353 
354 
356  uint32_t id,
357  uint32_t gid) {
358  assert(ct);
359  assert(ct->refCount);
360 
361  if (ct->openCount<1) {
362  DBG_INFO(GWEN_LOGDOMAIN, "Token not open");
363  return NULL;
364  }
365 
366  if (ct->getContextFn)
367  return ct->getContextFn(ct, id, gid);
368  else
369  return NULL;
370 }
371 
372 
373 
375  uint32_t id,
376  const GWEN_CRYPT_TOKEN_CONTEXT *ctx,
377  uint32_t gid) {
378  assert(ct);
379  assert(ct->refCount);
380 
381  if (ct->openCount<1)
382  return GWEN_ERROR_NOT_OPEN;
383 
384  if (ct->setContextFn)
385  return ct->setContextFn(ct, id, ctx, gid);
386  else
388 }
389 
390 
391 
393  uint32_t keyId,
395  const uint8_t *pInData,
396  uint32_t inLen,
397  uint8_t *pSignatureData,
398  uint32_t *pSignatureLen,
399  uint32_t *pSeqCounter,
400  uint32_t gid) {
401  assert(ct);
402  assert(ct->refCount);
403 
404  if (ct->openCount<1)
405  return GWEN_ERROR_NOT_OPEN;
406 
407  if (ct->signFn)
408  return ct->signFn(ct, keyId, a, pInData, inLen, pSignatureData, pSignatureLen,
409  pSeqCounter, gid);
410  else
412 }
413 
414 
415 
417  uint32_t keyId,
419  const uint8_t *pInData,
420  uint32_t inLen,
421  const uint8_t *pSignatureData,
422  uint32_t signatureLen,
423  uint32_t seqCounter,
424  uint32_t gid) {
425  assert(ct);
426  assert(ct->refCount);
427 
428  if (ct->openCount<1)
429  return GWEN_ERROR_NOT_OPEN;
430 
431  if (ct->verifyFn)
432  return ct->verifyFn(ct, keyId, a, pInData, inLen, pSignatureData, signatureLen,
433  seqCounter, gid);
434  else
436 }
437 
438 
439 
441  uint32_t keyId,
443  const uint8_t *pInData,
444  uint32_t inLen,
445  uint8_t *pOutData,
446  uint32_t *pOutLen,
447  uint32_t gid) {
448  assert(ct);
449  assert(ct->refCount);
450 
451  if (ct->openCount<1)
452  return GWEN_ERROR_NOT_OPEN;
453 
454  if (ct->encipherFn)
455  return ct->encipherFn(ct, keyId, a, pInData, inLen, pOutData, pOutLen, gid);
456  else
458 }
459 
460 
461 
463  uint32_t keyId,
465  const uint8_t *pInData,
466  uint32_t inLen,
467  uint8_t *pOutData,
468  uint32_t *pOutLen,
469  uint32_t gid) {
470  assert(ct);
471  assert(ct->refCount);
472 
473  if (ct->openCount<1)
474  return GWEN_ERROR_NOT_OPEN;
475 
476  if (ct->decipherFn)
477  return ct->decipherFn(ct, keyId, a, pInData, inLen, pOutData, pOutLen, gid);
478  else
480 }
481 
482 
483 
484 
486  uint32_t keyId,
487  const GWEN_CRYPT_CRYPTALGO *a,
488  uint32_t gid) {
489  assert(ct);
490  assert(ct->refCount);
491 
492  if (ct->openCount<1)
493  return GWEN_ERROR_NOT_OPEN;
494 
495  if (ct->generateKeyFn)
496  return ct->generateKeyFn(ct, keyId, a, gid);
497  else
499 }
500 
501 
502 
503 int GWEN_Crypt_Token_ChangePin(GWEN_CRYPT_TOKEN *ct, int admin, uint32_t gid) {
504  assert(ct);
505  assert(ct->refCount);
506 
507  if (ct->openCount<1)
508  return GWEN_ERROR_NOT_OPEN;
509 
510  if (ct->changePinFn)
511  return ct->changePinFn(ct, admin, gid);
512  else
514 }
515 
516 
517 
518 int GWEN_Crypt_Token_ActivateKey(GWEN_CRYPT_TOKEN *ct, uint32_t id, uint32_t gid) {
519  assert(ct);
520  assert(ct->refCount);
521 
522  if (ct->openCount<1)
523  return GWEN_ERROR_NOT_OPEN;
524 
525  if (ct->activateKeyFn)
526  return ct->activateKeyFn(ct, id ,gid);
527  else
529 }
530 
531 
532 
533 
534 
535 
539 
540  assert(ct);
541  assert(ct->refCount);
542  of=ct->openFn;
543  ct->openFn=f;
544 
545  return of;
546 }
547 
548 
549 
553 
554  assert(ct);
555  assert(ct->refCount);
556  of=ct->createFn;
557  ct->createFn=f;
558 
559  return of;
560 
561 }
562 
563 
564 
568 
569  assert(ct);
570  assert(ct->refCount);
571  of=ct->closeFn;
572  ct->closeFn=f;
573 
574  return of;
575 }
576 
577 
578 
583 
584  assert(ct);
585  assert(ct->refCount);
586  of=ct->getKeyIdListFn;
587  ct->getKeyIdListFn=f;
588 
589  return of;
590 }
591 
592 
593 
598 
599  assert(ct);
600  assert(ct->refCount);
601  of=ct->getKeyInfoFn;
602  ct->getKeyInfoFn=f;
603 
604  return of;
605 }
606 
607 
608 
612 
613  assert(ct);
614  assert(ct->refCount);
615  of=ct->setKeyInfoFn;
616  ct->setKeyInfoFn=f;
617 
618  return of;
619 }
620 
621 
622 
627 
628  assert(ct);
629  assert(ct->refCount);
630  of=ct->getContextIdListFn;
631  ct->getContextIdListFn=f;
632 
633  return of;
634 }
635 
636 
637 
642 
643  assert(ct);
644  assert(ct->refCount);
645  of=ct->getContextFn;
646  ct->getContextFn=f;
647 
648  return of;
649 }
650 
651 
652 
657 
658  assert(ct);
659  assert(ct->refCount);
660  of=ct->setContextFn;
661  ct->setContextFn=f;
662 
663  return of;
664 }
665 
666 
667 
671 
672  assert(ct);
673  assert(ct->refCount);
674  of=ct->signFn;
675  ct->signFn=f;
676 
677  return of;
678 }
679 
680 
681 
685 
686  assert(ct);
687  assert(ct->refCount);
688  of=ct->verifyFn;
689  ct->verifyFn=f;
690 
691  return of;
692 }
693 
694 
695 
699 
700  assert(ct);
701  assert(ct->refCount);
702  of=ct->encipherFn;
703  ct->encipherFn=f;
704 
705  return of;
706 }
707 
708 
709 
713 
714  assert(ct);
715  assert(ct->refCount);
716  of=ct->decipherFn;
717  ct->decipherFn=f;
718 
719  return of;
720 }
721 
722 
723 
728 
729  assert(ct);
730  assert(ct->refCount);
731  of=ct->generateKeyFn;
732  ct->generateKeyFn=f;
733 
734  return of;
735 }
736 
737 
738 
742 
743  assert(ct);
744  assert(ct->refCount);
745  of=ct->changePinFn;
746  ct->changePinFn=f;
747 
748  return of;
749 }
750 
751 
752 
756 
757  assert(ct);
758  assert(ct->refCount);
759  of=ct->activateKeyFn;
760  ct->activateKeyFn=f;
761 
762  return of;
763 }
764 
765 
766 
767 
768 
771  GWEN_BUFFER *nbuf) {
772  const char *tname;
773  const char *dname;
774 
776  assert(tname);
778  if (!dname) {
779  DBG_ERROR(GWEN_LOGDOMAIN, "Token has no name");
780  return GWEN_ERROR_INVALID;
781  }
782 
783  GWEN_Buffer_AppendString(nbuf, "PASSWORD_");
784  GWEN_Buffer_AppendString(nbuf, tname);
785  GWEN_Buffer_AppendString(nbuf, "_");
786  GWEN_Buffer_AppendString(nbuf, dname);
788  GWEN_Buffer_AppendString(nbuf, ":MANAGE");
789 
790  return 0;
791 }
792 
793 
794 
798  uint32_t flags,
799  unsigned char *pwbuffer,
800  unsigned int minLength,
801  unsigned int maxLength,
802  unsigned int *pinLength,
803  uint32_t gid) {
804  int rv;
805  const char *dname;
806  const char *mode;
807  const char *numeric_warning = "";
808  char buffer[512];
809  GWEN_BUFFER *nameBuffer;
810 
811  assert(ct);
812  assert(ct->refCount);
813 
815  if (!dname || !*dname)
817 
819  mode=I18N("access password");
820  else if (pt==GWEN_Crypt_PinType_Manage)
821  mode=I18N("manager password");
822  else
823  mode=I18N("password");
824 
825  buffer[0]=0;
826  buffer[sizeof(buffer)-1]=0;
827  if (flags & GWEN_GUI_INPUT_FLAGS_NUMERIC) {
828  numeric_warning = I18N("\nYou must only enter numbers, not letters.");
829  }
830 
831  if (flags & GWEN_GUI_INPUT_FLAGS_CONFIRM) {
832  snprintf(buffer, sizeof(buffer)-1,
833  I18N("Please enter a new %s for \n"
834  "%s\n"
835  "The password must be at least %d characters long.%s"
836  "<html>"
837  "Please enter a new %s for <i>%s</i>. "
838  "The password must be at least %d characters long.%s"
839  "</html>"),
840  mode,
841  dname,
842  minLength,
843  numeric_warning,
844  mode,
845  dname,
846  minLength,
847  numeric_warning);
848  }
849  else {
850  snprintf(buffer, sizeof(buffer)-1,
851  I18N("Please enter the %s for \n"
852  "%s\n"
853  "%s<html>"
854  "Please enter the %s for <i>%s</i>.%s"
855  "</html>"),
856  mode,
857  dname,
858  numeric_warning,
859  mode,
860  dname,
861  numeric_warning);
862  }
863 
864  nameBuffer=GWEN_Buffer_new(0, 256, 0, 1);
865  GWEN_Crypt_Token__CreatePasswordName(ct, pt, nameBuffer);
866  rv=GWEN_Gui_GetPassword(flags,
867  GWEN_Buffer_GetStart(nameBuffer),
868  I18N("Enter Password"),
869  buffer,
870  (char*)pwbuffer,
871  minLength,
872  maxLength, gid);
873  GWEN_Buffer_free(nameBuffer);
874  if (rv) {
875  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
876  return rv;
877  }
878 
879  *pinLength=strlen((char*)pwbuffer);
880 
883  pe,
884  pwbuffer,
885  maxLength,
886  pinLength);
887  if (rv) {
888  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
889  return rv;
890  }
891  }
892 
893  return 0;
894 }
895 
896 
897 
901  GWEN_UNUSED uint32_t flags,
902  const unsigned char *buffer,
903  unsigned int pinLength,
904  int isOk,
905  uint32_t gid) {
906  GWEN_BUFFER *nameBuffer;
907  int rv;
908  unsigned char ibuffer[256];
909 
910  assert(ct);
911  assert(ct->refCount);
912 
914  if (pinLength>=sizeof(ibuffer)) {
915  DBG_ERROR(GWEN_LOGDOMAIN, "Pin too long");
917  }
918  memset(ibuffer, 0, sizeof(ibuffer));
919  memmove(ibuffer, buffer, pinLength);
922  ibuffer,
923  sizeof(ibuffer)-1,
924  &pinLength);
925  if (rv) {
926  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
927  return rv;
928  }
929  buffer=ibuffer;
930  }
931 
932  nameBuffer=GWEN_Buffer_new(0, 256, 0, 1);
933  GWEN_Crypt_Token__CreatePasswordName(ct, pt, nameBuffer);
935  (const char*)buffer,
938  memset(ibuffer, 0, sizeof(ibuffer));
939  GWEN_Buffer_free(nameBuffer);
940  return rv;
941 
942 }
943 
944 
945 
948  uint32_t gid) {
949  char buffer[512];
950 
951  assert(ct);
952  assert(ct->refCount);
953 
954  buffer[0]=0;
955  buffer[sizeof(buffer)-1]=0;
956 
957  snprintf(buffer, sizeof(buffer)-1, "%s",
958  I18N("Please enter your PIN into the card reader."
959  "<html>"
960  "Please enter your PIN into the card reader."
961  "</html>"));
963  I18N("Secure PIN Input"),
964  buffer, gid);
965 }
966 
967 
968 
971  GWEN_UNUSED int ok,
972  uint32_t id) {
973  assert(ct);
974  assert(ct->refCount);
975 
976  GWEN_Gui_HideBox(id);
977 
978  return 0;
979 }
980 
981 
982 
984  int rv;
985  char buffer[512];
986  const char *dname;
987 
988  assert(ct);
989  assert(ct->refCount);
990 
991  buffer[0]=0;
992  buffer[sizeof(buffer)-1]=0;
993 
995  if (!dname || !*dname)
997 
999  snprintf(buffer, sizeof(buffer)-1,
1000  I18N("Please insert the security disc\nfor %s"
1001  "<html>"
1002  "Please insert the security disc for <i>%s</i>"
1003  "</html>"), dname, dname);
1004  else
1005  snprintf(buffer, sizeof(buffer)-1,
1006  I18N("Please insert the chip card\nfor %s"
1007  "<html>"
1008  "Please insert the chip card for <i>%s</i>"
1009  "</html>"), dname, dname);
1010 
1014  I18N("Insert Medium"),
1015  buffer,
1016  I18N("OK"), I18N("Abort"), 0, gid);
1017  if (rv==2) {
1018  DBG_ERROR(GWEN_LOGDOMAIN, "User aborted");
1020  I18N("Aborted by user."));
1021  return GWEN_ERROR_USER_ABORTED;
1022  }
1023  else if (rv!=1) {
1027  I18N("Error"),
1028  I18N("An internal error occurred."),
1029  I18N("Dismiss"), 0, 0, gid);
1030  return -1;
1031  }
1032 
1033  return 0;
1034 }
1035 
1036 
1037 
1039  int rv;
1040  char buffer[512];
1041  const char *dname;
1042 
1043  assert(ct);
1044  assert(ct->refCount);
1045 
1046  buffer[0]=0;
1047  buffer[sizeof(buffer)-1]=0;
1048 
1050  if (!dname || !*dname)
1052 
1054  snprintf(buffer, sizeof(buffer)-1,
1055  I18N("Please insert the correct security disc\nfor %s"
1056  "<html>"
1057  "Please insert the correct security disc for <i>%s</i>"
1058  "</html>"), dname, dname);
1059  else {
1060  if (dname && *dname) {
1061  snprintf(buffer, sizeof(buffer)-1,
1062  I18N("The wrong chipcard has been inserted.\n"
1063  "Please insert the chipcard with the number\n"
1064  " %s\n"
1065  "into the card reader.\n"
1066  "<html>"
1067  "<p>The wrong card has been inserted.</p>"
1068  "<p>Please insert the chipcard with the number"
1069  "<b>%s</b> into the card reader.</p>"
1070  "</html>"),
1071  dname,
1072  dname);
1073  }
1074  else
1075  snprintf(buffer, sizeof(buffer)-1,
1076  I18N("Please insert the correct chipcard\nfor %s"
1077  "<html>"
1078  "Please insert the correct chipcard for <i>%s</i>"
1079  "</html>"), dname, dname);
1080  }
1081 
1085  I18N("Insert Medium"),
1086  buffer,
1087  I18N("OK"), I18N("Abort"), 0, gid);
1088  if (rv==2) {
1089  DBG_ERROR(GWEN_LOGDOMAIN, "User aborted");
1091  I18N("Aborted by user."));
1092  return GWEN_ERROR_USER_ABORTED;
1093  }
1094  else if (rv!=1) {
1098  I18N("Error"),
1099  I18N("An internal error occurred."),
1100  I18N("Dismiss"), 0, 0, gid);
1101  return -1;
1102  }
1103 
1104  return 0;
1105 }
1106 
1107 
1108 
1110  assert(s);
1111  if (strcasecmp(s, "none")==0)
1113  else if (strcasecmp(s, "file")==0)
1115  else if (strcasecmp(s, "card")==0)
1117  else if (strcasecmp(s, "any")==0)
1120 }
1121 
1122 
1123 
1125  switch(d) {
1127  return "none";
1129  return "file";
1131  return "card";
1133  return "any";
1134  default:
1135  return "unknown";
1136  }
1137 }
1138 
1139 
1140 
1141 
1142 
1143