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