gwenhywfar
4.3.1
|
00001 /*************************************************************************** 00002 begin : Wed Mar 16 2005 00003 copyright : (C) 2005-2010 by Martin Preuss 00004 email : martin@libchipcard.de 00005 00006 *************************************************************************** 00007 * Please see toplevel file COPYING for license details * 00008 ***************************************************************************/ 00009 00010 #ifdef HAVE_CONFIG_H 00011 # include <config.h> 00012 #endif 00013 00014 #define DISABLE_DEBUGLOG 00015 00016 00017 #include "ct_p.h" 00018 #include "i18n_l.h" 00019 #include <gwenhywfar/misc.h> 00020 #include <gwenhywfar/debug.h> 00021 #include <gwenhywfar/gui.h> 00022 00023 00024 00025 GWEN_INHERIT_FUNCTIONS(GWEN_CRYPT_TOKEN) 00026 GWEN_LIST_FUNCTIONS(GWEN_CRYPT_TOKEN, GWEN_Crypt_Token) 00027 GWEN_LIST2_FUNCTIONS(GWEN_CRYPT_TOKEN, GWEN_Crypt_Token) 00028 00029 00030 00031 00032 00033 GWEN_CRYPT_TOKEN *GWEN_Crypt_Token_new(GWEN_CRYPT_TOKEN_DEVICE dev, 00034 const char *typeName, 00035 const char *tokenName) { 00036 GWEN_CRYPT_TOKEN *ct; 00037 00038 assert(typeName); 00039 00040 GWEN_NEW_OBJECT(GWEN_CRYPT_TOKEN, ct); 00041 ct->refCount=1; 00042 GWEN_INHERIT_INIT(GWEN_CRYPT_TOKEN, ct); 00043 GWEN_LIST_INIT(GWEN_CRYPT_TOKEN, ct); 00044 00045 ct->device=dev; 00046 ct->typeName=strdup(typeName); 00047 if (tokenName) 00048 ct->tokenName=strdup(tokenName); 00049 00050 return ct; 00051 } 00052 00053 00054 00055 void GWEN_Crypt_Token_free(GWEN_CRYPT_TOKEN *ct) { 00056 if (ct) { 00057 assert(ct->refCount); 00058 if (ct->refCount==1) { 00059 GWEN_LIST_FINI(GWEN_CRYPT_TOKEN, ct); 00060 GWEN_INHERIT_FINI(GWEN_CRYPT_TOKEN, ct); 00061 free(ct->tokenName); 00062 free(ct->typeName); 00063 ct->refCount=0; 00064 GWEN_FREE_OBJECT(ct); 00065 } 00066 else { 00067 ct->refCount--; 00068 } 00069 } 00070 } 00071 00072 00073 00074 GWEN_CRYPT_TOKEN_DEVICE GWEN_Crypt_Token_GetDevice(const GWEN_CRYPT_TOKEN *ct) { 00075 assert(ct); 00076 assert(ct->refCount); 00077 00078 return ct->device; 00079 } 00080 00081 00082 00083 const char *GWEN_Crypt_Token_GetTypeName(const GWEN_CRYPT_TOKEN *ct) { 00084 assert(ct); 00085 assert(ct->refCount); 00086 00087 return ct->typeName; 00088 } 00089 00090 00091 00092 const char *GWEN_Crypt_Token_GetTokenName(const GWEN_CRYPT_TOKEN *ct) { 00093 assert(ct); 00094 assert(ct->refCount); 00095 00096 return ct->tokenName; 00097 } 00098 00099 00100 00101 void GWEN_Crypt_Token_SetTokenName(GWEN_CRYPT_TOKEN *ct, const char *s) { 00102 assert(ct); 00103 assert(ct->refCount); 00104 00105 assert(s); 00106 00107 free(ct->tokenName); 00108 ct->tokenName=strdup(s); 00109 } 00110 00111 00112 00113 const char *GWEN_Crypt_Token_GetFriendlyName(const GWEN_CRYPT_TOKEN *ct) { 00114 assert(ct); 00115 assert(ct->refCount); 00116 00117 return ct->friendlyName; 00118 } 00119 00120 00121 00122 void GWEN_Crypt_Token_SetFriendlyName(GWEN_CRYPT_TOKEN *ct, const char *s) { 00123 assert(ct); 00124 assert(ct->refCount); 00125 00126 assert(s); 00127 00128 free(ct->friendlyName); 00129 ct->friendlyName=strdup(s); 00130 } 00131 00132 00133 00134 uint32_t GWEN_Crypt_Token_GetFlags(const GWEN_CRYPT_TOKEN *ct) { 00135 assert(ct); 00136 assert(ct->refCount); 00137 00138 return ct->flags; 00139 } 00140 00141 00142 00143 void GWEN_Crypt_Token_SetFlags(GWEN_CRYPT_TOKEN *ct, uint32_t f) { 00144 assert(ct); 00145 assert(ct->refCount); 00146 00147 ct->flags=f; 00148 } 00149 00150 00151 00152 void GWEN_Crypt_Token_AddFlags(GWEN_CRYPT_TOKEN *ct, uint32_t f) { 00153 assert(ct); 00154 assert(ct->refCount); 00155 00156 ct->flags|=f; 00157 } 00158 00159 00160 00161 void GWEN_Crypt_Token_SubFlags(GWEN_CRYPT_TOKEN *ct, uint32_t f) { 00162 assert(ct); 00163 assert(ct->refCount); 00164 00165 ct->flags&=~f; 00166 } 00167 00168 00169 00170 uint32_t GWEN_Crypt_Token_GetModes(const GWEN_CRYPT_TOKEN *ct) { 00171 assert(ct); 00172 assert(ct->refCount); 00173 00174 return ct->modes; 00175 } 00176 00177 00178 00179 void GWEN_Crypt_Token_SetModes(GWEN_CRYPT_TOKEN *ct, uint32_t f) { 00180 assert(ct); 00181 assert(ct->refCount); 00182 00183 ct->modes=f; 00184 } 00185 00186 00187 00188 void GWEN_Crypt_Token_AddModes(GWEN_CRYPT_TOKEN *ct, uint32_t f) { 00189 assert(ct); 00190 assert(ct->refCount); 00191 00192 ct->modes|=f; 00193 } 00194 00195 00196 00197 void GWEN_Crypt_Token_SubModes(GWEN_CRYPT_TOKEN *ct, uint32_t f) { 00198 assert(ct); 00199 assert(ct->refCount); 00200 00201 ct->modes&=~f; 00202 } 00203 00204 00205 00206 int GWEN_Crypt_Token_Open(GWEN_CRYPT_TOKEN *ct, int admin, uint32_t gid) { 00207 int rv; 00208 00209 assert(ct); 00210 assert(ct->refCount); 00211 00212 if (ct->openCount) { 00213 ct->openCount++; 00214 return 0; 00215 } 00216 00217 if (ct->openFn) 00218 rv=ct->openFn(ct, admin, gid); 00219 else 00220 rv=GWEN_ERROR_NOT_IMPLEMENTED; 00221 00222 if (rv==0) 00223 ct->openCount++; 00224 return rv; 00225 } 00226 00227 00228 00229 int GWEN_Crypt_Token_Create(GWEN_CRYPT_TOKEN *ct, uint32_t gid) { 00230 int rv; 00231 00232 assert(ct); 00233 assert(ct->refCount); 00234 00235 if (ct->createFn) 00236 rv=ct->createFn(ct, gid); 00237 else 00238 rv=GWEN_ERROR_NOT_IMPLEMENTED; 00239 00240 if (rv==0) 00241 ct->openCount++; 00242 return rv; 00243 } 00244 00245 00246 00247 int GWEN_Crypt_Token_Close(GWEN_CRYPT_TOKEN *ct, int abandon, uint32_t gid) { 00248 assert(ct); 00249 assert(ct->refCount); 00250 00251 if (ct->openCount>1 && !abandon) { 00252 ct->openCount--; 00253 return 0; 00254 } 00255 00256 if (ct->closeFn) { 00257 int rv; 00258 00259 rv=ct->closeFn(ct, abandon, gid); 00260 if (abandon) 00261 ct->openCount=0; 00262 else if (rv==0) 00263 ct->openCount--; 00264 return rv; 00265 } 00266 else 00267 return GWEN_ERROR_NOT_IMPLEMENTED; 00268 } 00269 00270 00271 00272 int GWEN_Crypt_Token_IsOpen(const GWEN_CRYPT_TOKEN *ct) { 00273 assert(ct); 00274 assert(ct->refCount); 00275 00276 return (ct->openCount!=0); 00277 } 00278 00279 00280 00281 int GWEN_Crypt_Token_GetKeyIdList(GWEN_CRYPT_TOKEN *ct, 00282 uint32_t *pIdList, 00283 uint32_t *pCount, 00284 uint32_t gid) { 00285 assert(ct); 00286 assert(ct->refCount); 00287 00288 if (ct->openCount<1) 00289 return GWEN_ERROR_NOT_OPEN; 00290 00291 if (ct->getKeyIdListFn) 00292 return ct->getKeyIdListFn(ct, pIdList, pCount, gid); 00293 else 00294 return GWEN_ERROR_NOT_IMPLEMENTED; 00295 } 00296 00297 00298 00299 const GWEN_CRYPT_TOKEN_KEYINFO* GWEN_Crypt_Token_GetKeyInfo(GWEN_CRYPT_TOKEN *ct, 00300 uint32_t id, 00301 uint32_t flags, 00302 uint32_t gid) { 00303 assert(ct); 00304 assert(ct->refCount); 00305 00306 if (ct->openCount<1) { 00307 DBG_INFO(GWEN_LOGDOMAIN, "Token not open"); 00308 return NULL; 00309 } 00310 00311 if (ct->getKeyInfoFn) 00312 return ct->getKeyInfoFn(ct, id, flags, gid); 00313 else 00314 return NULL; 00315 } 00316 00317 00318 00319 int GWEN_Crypt_Token_SetKeyInfo(GWEN_CRYPT_TOKEN *ct, 00320 uint32_t id, 00321 const GWEN_CRYPT_TOKEN_KEYINFO *ki, 00322 uint32_t gid) { 00323 assert(ct); 00324 assert(ct->refCount); 00325 00326 if (ct->openCount<1) 00327 return GWEN_ERROR_NOT_OPEN; 00328 00329 if (ct->setKeyInfoFn) 00330 return ct->setKeyInfoFn(ct, id, ki, gid); 00331 else 00332 return GWEN_ERROR_NOT_IMPLEMENTED; 00333 } 00334 00335 00336 00337 int GWEN_Crypt_Token_GetContextIdList(GWEN_CRYPT_TOKEN *ct, 00338 uint32_t *pIdList, 00339 uint32_t *pCount, 00340 uint32_t gid) { 00341 assert(ct); 00342 assert(ct->refCount); 00343 00344 if (ct->openCount<1) 00345 return GWEN_ERROR_NOT_OPEN; 00346 00347 if (ct->getContextIdListFn) 00348 return ct->getContextIdListFn(ct, pIdList, pCount, gid); 00349 else 00350 return GWEN_ERROR_NOT_IMPLEMENTED; 00351 } 00352 00353 00354 00355 const GWEN_CRYPT_TOKEN_CONTEXT* GWEN_Crypt_Token_GetContext(GWEN_CRYPT_TOKEN *ct, 00356 uint32_t id, 00357 uint32_t gid) { 00358 assert(ct); 00359 assert(ct->refCount); 00360 00361 if (ct->openCount<1) { 00362 DBG_INFO(GWEN_LOGDOMAIN, "Token not open"); 00363 return NULL; 00364 } 00365 00366 if (ct->getContextFn) 00367 return ct->getContextFn(ct, id, gid); 00368 else 00369 return NULL; 00370 } 00371 00372 00373 00374 int GWEN_Crypt_Token_SetContext(GWEN_CRYPT_TOKEN *ct, 00375 uint32_t id, 00376 const GWEN_CRYPT_TOKEN_CONTEXT *ctx, 00377 uint32_t gid) { 00378 assert(ct); 00379 assert(ct->refCount); 00380 00381 if (ct->openCount<1) 00382 return GWEN_ERROR_NOT_OPEN; 00383 00384 if (ct->setContextFn) 00385 return ct->setContextFn(ct, id, ctx, gid); 00386 else 00387 return GWEN_ERROR_NOT_IMPLEMENTED; 00388 } 00389 00390 00391 00392 int GWEN_Crypt_Token_Sign(GWEN_CRYPT_TOKEN *ct, 00393 uint32_t keyId, 00394 GWEN_CRYPT_PADDALGO *a, 00395 const uint8_t *pInData, 00396 uint32_t inLen, 00397 uint8_t *pSignatureData, 00398 uint32_t *pSignatureLen, 00399 uint32_t *pSeqCounter, 00400 uint32_t gid) { 00401 assert(ct); 00402 assert(ct->refCount); 00403 00404 if (ct->openCount<1) 00405 return GWEN_ERROR_NOT_OPEN; 00406 00407 if (ct->signFn) 00408 return ct->signFn(ct, keyId, a, pInData, inLen, pSignatureData, pSignatureLen, 00409 pSeqCounter, gid); 00410 else 00411 return GWEN_ERROR_NOT_IMPLEMENTED; 00412 } 00413 00414 00415 00416 int GWEN_Crypt_Token_Verify(GWEN_CRYPT_TOKEN *ct, 00417 uint32_t keyId, 00418 GWEN_CRYPT_PADDALGO *a, 00419 const uint8_t *pInData, 00420 uint32_t inLen, 00421 const uint8_t *pSignatureData, 00422 uint32_t signatureLen, 00423 uint32_t seqCounter, 00424 uint32_t gid) { 00425 assert(ct); 00426 assert(ct->refCount); 00427 00428 if (ct->openCount<1) 00429 return GWEN_ERROR_NOT_OPEN; 00430 00431 if (ct->verifyFn) 00432 return ct->verifyFn(ct, keyId, a, pInData, inLen, pSignatureData, signatureLen, 00433 seqCounter, gid); 00434 else 00435 return GWEN_ERROR_NOT_IMPLEMENTED; 00436 } 00437 00438 00439 00440 int GWEN_Crypt_Token_Encipher(GWEN_CRYPT_TOKEN *ct, 00441 uint32_t keyId, 00442 GWEN_CRYPT_PADDALGO *a, 00443 const uint8_t *pInData, 00444 uint32_t inLen, 00445 uint8_t *pOutData, 00446 uint32_t *pOutLen, 00447 uint32_t gid) { 00448 assert(ct); 00449 assert(ct->refCount); 00450 00451 if (ct->openCount<1) 00452 return GWEN_ERROR_NOT_OPEN; 00453 00454 if (ct->encipherFn) 00455 return ct->encipherFn(ct, keyId, a, pInData, inLen, pOutData, pOutLen, gid); 00456 else 00457 return GWEN_ERROR_NOT_IMPLEMENTED; 00458 } 00459 00460 00461 00462 int GWEN_Crypt_Token_Decipher(GWEN_CRYPT_TOKEN *ct, 00463 uint32_t keyId, 00464 GWEN_CRYPT_PADDALGO *a, 00465 const uint8_t *pInData, 00466 uint32_t inLen, 00467 uint8_t *pOutData, 00468 uint32_t *pOutLen, 00469 uint32_t gid) { 00470 assert(ct); 00471 assert(ct->refCount); 00472 00473 if (ct->openCount<1) 00474 return GWEN_ERROR_NOT_OPEN; 00475 00476 if (ct->decipherFn) 00477 return ct->decipherFn(ct, keyId, a, pInData, inLen, pOutData, pOutLen, gid); 00478 else 00479 return GWEN_ERROR_NOT_IMPLEMENTED; 00480 } 00481 00482 00483 00484 00485 int GWEN_Crypt_Token_GenerateKey(GWEN_CRYPT_TOKEN *ct, 00486 uint32_t keyId, 00487 const GWEN_CRYPT_CRYPTALGO *a, 00488 uint32_t gid) { 00489 assert(ct); 00490 assert(ct->refCount); 00491 00492 if (ct->openCount<1) 00493 return GWEN_ERROR_NOT_OPEN; 00494 00495 if (ct->generateKeyFn) 00496 return ct->generateKeyFn(ct, keyId, a, gid); 00497 else 00498 return GWEN_ERROR_NOT_IMPLEMENTED; 00499 } 00500 00501 00502 00503 int GWEN_Crypt_Token_ChangePin(GWEN_CRYPT_TOKEN *ct, int admin, uint32_t gid) { 00504 assert(ct); 00505 assert(ct->refCount); 00506 00507 if (ct->openCount<1) 00508 return GWEN_ERROR_NOT_OPEN; 00509 00510 if (ct->changePinFn) 00511 return ct->changePinFn(ct, admin, gid); 00512 else 00513 return GWEN_ERROR_NOT_IMPLEMENTED; 00514 } 00515 00516 00517 00518 int GWEN_Crypt_Token_ActivateKey(GWEN_CRYPT_TOKEN *ct, uint32_t id, uint32_t gid) { 00519 assert(ct); 00520 assert(ct->refCount); 00521 00522 if (ct->openCount<1) 00523 return GWEN_ERROR_NOT_OPEN; 00524 00525 if (ct->activateKeyFn) 00526 return ct->activateKeyFn(ct, id ,gid); 00527 else 00528 return GWEN_ERROR_NOT_IMPLEMENTED; 00529 } 00530 00531 00532 00533 00534 00535 00536 GWEN_CRYPT_TOKEN_OPEN_FN GWEN_Crypt_Token_SetOpenFn(GWEN_CRYPT_TOKEN *ct, 00537 GWEN_CRYPT_TOKEN_OPEN_FN f) { 00538 GWEN_CRYPT_TOKEN_OPEN_FN of; 00539 00540 assert(ct); 00541 assert(ct->refCount); 00542 of=ct->openFn; 00543 ct->openFn=f; 00544 00545 return of; 00546 } 00547 00548 00549 00550 GWEN_CRYPT_TOKEN_CREATE_FN GWEN_Crypt_Token_SetCreateFn(GWEN_CRYPT_TOKEN *ct, 00551 GWEN_CRYPT_TOKEN_CREATE_FN f) { 00552 GWEN_CRYPT_TOKEN_CREATE_FN of; 00553 00554 assert(ct); 00555 assert(ct->refCount); 00556 of=ct->createFn; 00557 ct->createFn=f; 00558 00559 return of; 00560 00561 } 00562 00563 00564 00565 GWEN_CRYPT_TOKEN_CLOSE_FN GWEN_Crypt_Token_SetCloseFn(GWEN_CRYPT_TOKEN *ct, 00566 GWEN_CRYPT_TOKEN_CLOSE_FN f) { 00567 GWEN_CRYPT_TOKEN_CLOSE_FN of; 00568 00569 assert(ct); 00570 assert(ct->refCount); 00571 of=ct->closeFn; 00572 ct->closeFn=f; 00573 00574 return of; 00575 } 00576 00577 00578 00579 GWEN_CRYPT_TOKEN_GETKEYIDLIST_FN 00580 GWEN_Crypt_Token_SetGetKeyIdListFn(GWEN_CRYPT_TOKEN *ct, 00581 GWEN_CRYPT_TOKEN_GETKEYIDLIST_FN f) { 00582 GWEN_CRYPT_TOKEN_GETKEYIDLIST_FN of; 00583 00584 assert(ct); 00585 assert(ct->refCount); 00586 of=ct->getKeyIdListFn; 00587 ct->getKeyIdListFn=f; 00588 00589 return of; 00590 } 00591 00592 00593 00594 GWEN_CRYPT_TOKEN_GETKEYINFO_FN 00595 GWEN_Crypt_Token_SetGetKeyInfoFn(GWEN_CRYPT_TOKEN *ct, 00596 GWEN_CRYPT_TOKEN_GETKEYINFO_FN f) { 00597 GWEN_CRYPT_TOKEN_GETKEYINFO_FN of; 00598 00599 assert(ct); 00600 assert(ct->refCount); 00601 of=ct->getKeyInfoFn; 00602 ct->getKeyInfoFn=f; 00603 00604 return of; 00605 } 00606 00607 00608 00609 GWEN_CRYPT_TOKEN_SETKEYINFO_FN GWEN_Crypt_Token_SetSetKeyInfoFn(GWEN_CRYPT_TOKEN *ct, 00610 GWEN_CRYPT_TOKEN_SETKEYINFO_FN f) { 00611 GWEN_CRYPT_TOKEN_SETKEYINFO_FN of; 00612 00613 assert(ct); 00614 assert(ct->refCount); 00615 of=ct->setKeyInfoFn; 00616 ct->setKeyInfoFn=f; 00617 00618 return of; 00619 } 00620 00621 00622 00623 GWEN_CRYPT_TOKEN_GETCONTEXTIDLIST_FN 00624 GWEN_Crypt_Token_SetGetContextIdListFn(GWEN_CRYPT_TOKEN *ct, 00625 GWEN_CRYPT_TOKEN_GETCONTEXTIDLIST_FN f) { 00626 GWEN_CRYPT_TOKEN_GETCONTEXTIDLIST_FN of; 00627 00628 assert(ct); 00629 assert(ct->refCount); 00630 of=ct->getContextIdListFn; 00631 ct->getContextIdListFn=f; 00632 00633 return of; 00634 } 00635 00636 00637 00638 GWEN_CRYPT_TOKEN_GETCONTEXT_FN 00639 GWEN_Crypt_Token_SetGetContextFn(GWEN_CRYPT_TOKEN *ct, 00640 GWEN_CRYPT_TOKEN_GETCONTEXT_FN f) { 00641 GWEN_CRYPT_TOKEN_GETCONTEXT_FN of; 00642 00643 assert(ct); 00644 assert(ct->refCount); 00645 of=ct->getContextFn; 00646 ct->getContextFn=f; 00647 00648 return of; 00649 } 00650 00651 00652 00653 GWEN_CRYPT_TOKEN_SETCONTEXT_FN 00654 GWEN_Crypt_Token_SetSetContextFn(GWEN_CRYPT_TOKEN *ct, 00655 GWEN_CRYPT_TOKEN_SETCONTEXT_FN f) { 00656 GWEN_CRYPT_TOKEN_SETCONTEXT_FN of; 00657 00658 assert(ct); 00659 assert(ct->refCount); 00660 of=ct->setContextFn; 00661 ct->setContextFn=f; 00662 00663 return of; 00664 } 00665 00666 00667 00668 GWEN_CRYPT_TOKEN_SIGN_FN GWEN_Crypt_Token_SetSignFn(GWEN_CRYPT_TOKEN *ct, 00669 GWEN_CRYPT_TOKEN_SIGN_FN f) { 00670 GWEN_CRYPT_TOKEN_SIGN_FN of; 00671 00672 assert(ct); 00673 assert(ct->refCount); 00674 of=ct->signFn; 00675 ct->signFn=f; 00676 00677 return of; 00678 } 00679 00680 00681 00682 GWEN_CRYPT_TOKEN_VERIFY_FN GWEN_Crypt_Token_SetVerifyFn(GWEN_CRYPT_TOKEN *ct, 00683 GWEN_CRYPT_TOKEN_VERIFY_FN f) { 00684 GWEN_CRYPT_TOKEN_VERIFY_FN of; 00685 00686 assert(ct); 00687 assert(ct->refCount); 00688 of=ct->verifyFn; 00689 ct->verifyFn=f; 00690 00691 return of; 00692 } 00693 00694 00695 00696 GWEN_CRYPT_TOKEN_ENCIPHER_FN GWEN_Crypt_Token_SetEncipherFn(GWEN_CRYPT_TOKEN *ct, 00697 GWEN_CRYPT_TOKEN_ENCIPHER_FN f) { 00698 GWEN_CRYPT_TOKEN_ENCIPHER_FN of; 00699 00700 assert(ct); 00701 assert(ct->refCount); 00702 of=ct->encipherFn; 00703 ct->encipherFn=f; 00704 00705 return of; 00706 } 00707 00708 00709 00710 GWEN_CRYPT_TOKEN_DECIPHER_FN GWEN_Crypt_Token_SetDecipherFn(GWEN_CRYPT_TOKEN *ct, 00711 GWEN_CRYPT_TOKEN_DECIPHER_FN f) { 00712 GWEN_CRYPT_TOKEN_DECIPHER_FN of; 00713 00714 assert(ct); 00715 assert(ct->refCount); 00716 of=ct->decipherFn; 00717 ct->decipherFn=f; 00718 00719 return of; 00720 } 00721 00722 00723 00724 GWEN_CRYPT_TOKEN_GENERATEKEY_FN 00725 GWEN_Crypt_Token_SetGenerateKeyFn(GWEN_CRYPT_TOKEN *ct, 00726 GWEN_CRYPT_TOKEN_GENERATEKEY_FN f) { 00727 GWEN_CRYPT_TOKEN_GENERATEKEY_FN of; 00728 00729 assert(ct); 00730 assert(ct->refCount); 00731 of=ct->generateKeyFn; 00732 ct->generateKeyFn=f; 00733 00734 return of; 00735 } 00736 00737 00738 00739 GWEN_CRYPT_TOKEN_CHANGEPIN_FN GWEN_Crypt_Token_SetChangePinFn(GWEN_CRYPT_TOKEN *ct, 00740 GWEN_CRYPT_TOKEN_CHANGEPIN_FN f) { 00741 GWEN_CRYPT_TOKEN_CHANGEPIN_FN of; 00742 00743 assert(ct); 00744 assert(ct->refCount); 00745 of=ct->changePinFn; 00746 ct->changePinFn=f; 00747 00748 return of; 00749 } 00750 00751 00752 00753 GWEN_CRYPT_TOKEN_ACTIVATEKEY_FN GWEN_Crypt_Token_SetActivateKeyFn(GWEN_CRYPT_TOKEN *ct, 00754 GWEN_CRYPT_TOKEN_ACTIVATEKEY_FN f) { 00755 GWEN_CRYPT_TOKEN_ACTIVATEKEY_FN of; 00756 00757 assert(ct); 00758 assert(ct->refCount); 00759 of=ct->activateKeyFn; 00760 ct->activateKeyFn=f; 00761 00762 return of; 00763 } 00764 00765 00766 00767 00768 00769 int GWEN_Crypt_Token__CreatePasswordName(GWEN_CRYPT_TOKEN *ct, 00770 GWEN_CRYPT_PINTYPE pt, 00771 GWEN_BUFFER *nbuf) { 00772 const char *tname; 00773 const char *dname; 00774 00775 tname=GWEN_Crypt_Token_GetTypeName(ct); 00776 assert(tname); 00777 dname=GWEN_Crypt_Token_GetTokenName(ct); 00778 if (!dname) { 00779 DBG_ERROR(GWEN_LOGDOMAIN, "Token has no name"); 00780 return GWEN_ERROR_INVALID; 00781 } 00782 00783 GWEN_Buffer_AppendString(nbuf, "PASSWORD_"); 00784 GWEN_Buffer_AppendString(nbuf, tname); 00785 GWEN_Buffer_AppendString(nbuf, "_"); 00786 GWEN_Buffer_AppendString(nbuf, dname); 00787 if (pt==GWEN_Crypt_PinType_Manage) 00788 GWEN_Buffer_AppendString(nbuf, ":MANAGE"); 00789 00790 return 0; 00791 } 00792 00793 00794 00795 int GWEN_Crypt_Token_GetPin(GWEN_CRYPT_TOKEN *ct, 00796 GWEN_CRYPT_PINTYPE pt, 00797 GWEN_CRYPT_PINENCODING pe, 00798 uint32_t flags, 00799 unsigned char *pwbuffer, 00800 unsigned int minLength, 00801 unsigned int maxLength, 00802 unsigned int *pinLength, 00803 uint32_t gid) { 00804 int rv; 00805 const char *dname; 00806 const char *mode; 00807 const char *numeric_warning = ""; 00808 char buffer[512]; 00809 GWEN_BUFFER *nameBuffer; 00810 00811 assert(ct); 00812 assert(ct->refCount); 00813 00814 dname=GWEN_Crypt_Token_GetFriendlyName(ct); 00815 if (!dname || !*dname) 00816 dname=GWEN_Crypt_Token_GetTokenName(ct); 00817 00818 if (pt==GWEN_Crypt_PinType_Access) 00819 mode=I18N("access password"); 00820 else if (pt==GWEN_Crypt_PinType_Manage) 00821 mode=I18N("manager password"); 00822 else 00823 mode=I18N("password"); 00824 00825 buffer[0]=0; 00826 buffer[sizeof(buffer)-1]=0; 00827 if (flags & GWEN_GUI_INPUT_FLAGS_NUMERIC) { 00828 numeric_warning = I18N("\nYou must only enter numbers, not letters."); 00829 } 00830 00831 if (flags & GWEN_GUI_INPUT_FLAGS_CONFIRM) { 00832 snprintf(buffer, sizeof(buffer)-1, 00833 I18N("Please enter a new %s for \n" 00834 "%s\n" 00835 "The password must be at least %d characters long.%s" 00836 "<html>" 00837 "Please enter a new %s for <i>%s</i>. " 00838 "The password must be at least %d characters long.%s" 00839 "</html>"), 00840 mode, 00841 dname, 00842 minLength, 00843 numeric_warning, 00844 mode, 00845 dname, 00846 minLength, 00847 numeric_warning); 00848 } 00849 else { 00850 snprintf(buffer, sizeof(buffer)-1, 00851 I18N("Please enter the %s for \n" 00852 "%s\n" 00853 "%s<html>" 00854 "Please enter the %s for <i>%s</i>.%s" 00855 "</html>"), 00856 mode, 00857 dname, 00858 numeric_warning, 00859 mode, 00860 dname, 00861 numeric_warning); 00862 } 00863 00864 nameBuffer=GWEN_Buffer_new(0, 256, 0, 1); 00865 GWEN_Crypt_Token__CreatePasswordName(ct, pt, nameBuffer); 00866 rv=GWEN_Gui_GetPassword(flags, 00867 GWEN_Buffer_GetStart(nameBuffer), 00868 I18N("Enter Password"), 00869 buffer, 00870 (char*)pwbuffer, 00871 minLength, 00872 maxLength, gid); 00873 GWEN_Buffer_free(nameBuffer); 00874 if (rv) { 00875 DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv); 00876 return rv; 00877 } 00878 00879 *pinLength=strlen((char*)pwbuffer); 00880 00881 if (pe!=GWEN_Crypt_PinEncoding_Ascii) { 00882 rv=GWEN_Crypt_TransformPin(GWEN_Crypt_PinEncoding_Ascii, 00883 pe, 00884 pwbuffer, 00885 maxLength, 00886 pinLength); 00887 if (rv) { 00888 DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv); 00889 return rv; 00890 } 00891 } 00892 00893 return 0; 00894 } 00895 00896 00897 00898 int GWEN_Crypt_Token_SetPinStatus(GWEN_CRYPT_TOKEN *ct, 00899 GWEN_CRYPT_PINTYPE pt, 00900 GWEN_CRYPT_PINENCODING pe, 00901 GWEN_UNUSED uint32_t flags, 00902 const unsigned char *buffer, 00903 unsigned int pinLength, 00904 int isOk, 00905 uint32_t gid) { 00906 GWEN_BUFFER *nameBuffer; 00907 int rv; 00908 unsigned char ibuffer[256]; 00909 00910 assert(ct); 00911 assert(ct->refCount); 00912 00913 if (pe!=GWEN_Crypt_PinEncoding_Ascii) { 00914 if (pinLength>=sizeof(ibuffer)) { 00915 DBG_ERROR(GWEN_LOGDOMAIN, "Pin too long"); 00916 return GWEN_ERROR_BUFFER_OVERFLOW; 00917 } 00918 memset(ibuffer, 0, sizeof(ibuffer)); 00919 memmove(ibuffer, buffer, pinLength); 00920 rv=GWEN_Crypt_TransformPin(pe, 00921 GWEN_Crypt_PinEncoding_Ascii, 00922 ibuffer, 00923 sizeof(ibuffer)-1, 00924 &pinLength); 00925 if (rv) { 00926 DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv); 00927 return rv; 00928 } 00929 buffer=ibuffer; 00930 } 00931 00932 nameBuffer=GWEN_Buffer_new(0, 256, 0, 1); 00933 GWEN_Crypt_Token__CreatePasswordName(ct, pt, nameBuffer); 00934 rv=GWEN_Gui_SetPasswordStatus(GWEN_Buffer_GetStart(nameBuffer), 00935 (const char*)buffer, 00936 isOk?GWEN_Gui_PasswordStatus_Ok: 00937 GWEN_Gui_PasswordStatus_Bad, gid); 00938 memset(ibuffer, 0, sizeof(ibuffer)); 00939 GWEN_Buffer_free(nameBuffer); 00940 return rv; 00941 00942 } 00943 00944 00945 00946 uint32_t GWEN_Crypt_Token_BeginEnterPin(GWEN_CRYPT_TOKEN *ct, 00947 GWEN_UNUSED GWEN_CRYPT_PINTYPE pt, 00948 uint32_t gid) { 00949 char buffer[512]; 00950 00951 assert(ct); 00952 assert(ct->refCount); 00953 00954 buffer[0]=0; 00955 buffer[sizeof(buffer)-1]=0; 00956 00957 snprintf(buffer, sizeof(buffer)-1, "%s", 00958 I18N("Please enter your PIN into the card reader." 00959 "<html>" 00960 "Please enter your PIN into the card reader." 00961 "</html>")); 00962 return GWEN_Gui_ShowBox(GWEN_GUI_SHOWBOX_FLAGS_BEEP, 00963 I18N("Secure PIN Input"), 00964 buffer, gid); 00965 } 00966 00967 00968 00969 int GWEN_Crypt_Token_EndEnterPin(GWEN_CRYPT_TOKEN *ct, 00970 GWEN_UNUSED GWEN_CRYPT_PINTYPE pt, 00971 GWEN_UNUSED int ok, 00972 uint32_t id) { 00973 assert(ct); 00974 assert(ct->refCount); 00975 00976 GWEN_Gui_HideBox(id); 00977 00978 return 0; 00979 } 00980 00981 00982 00983 int GWEN_Crypt_Token_InsertToken(GWEN_CRYPT_TOKEN *ct, uint32_t gid) { 00984 int rv; 00985 char buffer[512]; 00986 const char *dname; 00987 00988 assert(ct); 00989 assert(ct->refCount); 00990 00991 buffer[0]=0; 00992 buffer[sizeof(buffer)-1]=0; 00993 00994 dname=GWEN_Crypt_Token_GetFriendlyName(ct); 00995 if (!dname || !*dname) 00996 dname=GWEN_Crypt_Token_GetTokenName(ct); 00997 00998 if (GWEN_Crypt_Token_GetDevice(ct)==GWEN_Crypt_Token_Device_File) 00999 snprintf(buffer, sizeof(buffer)-1, 01000 I18N("Please insert the security disc\nfor %s" 01001 "<html>" 01002 "Please insert the security disc for <i>%s</i>" 01003 "</html>"), dname, dname); 01004 else 01005 snprintf(buffer, sizeof(buffer)-1, 01006 I18N("Please insert the chip card\nfor %s" 01007 "<html>" 01008 "Please insert the chip card for <i>%s</i>" 01009 "</html>"), dname, dname); 01010 01011 rv=GWEN_Gui_MessageBox(GWEN_GUI_MSG_FLAGS_TYPE_WARN | 01012 GWEN_GUI_MSG_FLAGS_SEVERITY_NORMAL | 01013 GWEN_GUI_MSG_FLAGS_CONFIRM_B1, 01014 I18N("Insert Medium"), 01015 buffer, 01016 I18N("OK"), I18N("Abort"), 0, gid); 01017 if (rv==2) { 01018 DBG_ERROR(GWEN_LOGDOMAIN, "User aborted"); 01019 GWEN_Gui_ProgressLog(0, GWEN_LoggerLevel_Notice, 01020 I18N("Aborted by user.")); 01021 return GWEN_ERROR_USER_ABORTED; 01022 } 01023 else if (rv!=1) { 01024 GWEN_Gui_MessageBox(GWEN_GUI_MSG_FLAGS_TYPE_ERROR | 01025 GWEN_GUI_MSG_FLAGS_SEVERITY_DANGEROUS | 01026 GWEN_GUI_MSG_FLAGS_CONFIRM_B1, 01027 I18N("Error"), 01028 I18N("An internal error occurred."), 01029 I18N("Dismiss"), 0, 0, gid); 01030 return -1; 01031 } 01032 01033 return 0; 01034 } 01035 01036 01037 01038 int GWEN_Crypt_Token_InsertCorrectToken(GWEN_CRYPT_TOKEN *ct, uint32_t gid) { 01039 int rv; 01040 char buffer[512]; 01041 const char *dname; 01042 01043 assert(ct); 01044 assert(ct->refCount); 01045 01046 buffer[0]=0; 01047 buffer[sizeof(buffer)-1]=0; 01048 01049 dname=GWEN_Crypt_Token_GetFriendlyName(ct); 01050 if (!dname || !*dname) 01051 dname=GWEN_Crypt_Token_GetTokenName(ct); 01052 01053 if (GWEN_Crypt_Token_GetDevice(ct)==GWEN_Crypt_Token_Device_File) 01054 snprintf(buffer, sizeof(buffer)-1, 01055 I18N("Please insert the correct security disc\nfor %s" 01056 "<html>" 01057 "Please insert the correct security disc for <i>%s</i>" 01058 "</html>"), dname, dname); 01059 else { 01060 if (dname && *dname) { 01061 snprintf(buffer, sizeof(buffer)-1, 01062 I18N("The wrong chipcard has been inserted.\n" 01063 "Please insert the chipcard with the number\n" 01064 " %s\n" 01065 "into the card reader.\n" 01066 "<html>" 01067 "<p>The wrong card has been inserted.</p>" 01068 "<p>Please insert the chipcard with the number" 01069 "<b>%s</b> into the card reader.</p>" 01070 "</html>"), 01071 dname, 01072 dname); 01073 } 01074 else 01075 snprintf(buffer, sizeof(buffer)-1, 01076 I18N("Please insert the correct chipcard\nfor %s" 01077 "<html>" 01078 "Please insert the correct chipcard for <i>%s</i>" 01079 "</html>"), dname, dname); 01080 } 01081 01082 rv=GWEN_Gui_MessageBox(GWEN_GUI_MSG_FLAGS_TYPE_WARN | 01083 GWEN_GUI_MSG_FLAGS_SEVERITY_DANGEROUS | 01084 GWEN_GUI_MSG_FLAGS_CONFIRM_B1, 01085 I18N("Insert Medium"), 01086 buffer, 01087 I18N("OK"), I18N("Abort"), 0, gid); 01088 if (rv==2) { 01089 DBG_ERROR(GWEN_LOGDOMAIN, "User aborted"); 01090 GWEN_Gui_ProgressLog(0, GWEN_LoggerLevel_Notice, 01091 I18N("Aborted by user.")); 01092 return GWEN_ERROR_USER_ABORTED; 01093 } 01094 else if (rv!=1) { 01095 GWEN_Gui_MessageBox(GWEN_GUI_MSG_FLAGS_TYPE_ERROR | 01096 GWEN_GUI_MSG_FLAGS_SEVERITY_DANGEROUS | 01097 GWEN_GUI_MSG_FLAGS_CONFIRM_B1, 01098 I18N("Error"), 01099 I18N("An internal error occurred."), 01100 I18N("Dismiss"), 0, 0, gid); 01101 return -1; 01102 } 01103 01104 return 0; 01105 } 01106 01107 01108 01109 GWEN_CRYPT_TOKEN_DEVICE GWEN_Crypt_Token_Device_fromString(const char *s){ 01110 assert(s); 01111 if (strcasecmp(s, "none")==0) 01112 return GWEN_Crypt_Token_Device_None; 01113 else if (strcasecmp(s, "file")==0) 01114 return GWEN_Crypt_Token_Device_File; 01115 else if (strcasecmp(s, "card")==0) 01116 return GWEN_Crypt_Token_Device_Card; 01117 else if (strcasecmp(s, "any")==0) 01118 return GWEN_Crypt_Token_Device_Any; 01119 return GWEN_Crypt_Token_Device_Unknown; 01120 } 01121 01122 01123 01124 const char *GWEN_Crypt_Token_Device_toString(GWEN_CRYPT_TOKEN_DEVICE d){ 01125 switch(d) { 01126 case GWEN_Crypt_Token_Device_None: 01127 return "none"; 01128 case GWEN_Crypt_Token_Device_File: 01129 return "file"; 01130 case GWEN_Crypt_Token_Device_Card: 01131 return "card"; 01132 case GWEN_Crypt_Token_Device_Any: 01133 return "any"; 01134 default: 01135 return "unknown"; 01136 } 01137 } 01138 01139 01140 01141 01142 01143