00001
00002
00003
00004
00005
00006
00007
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