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 *tname;
00745 const char *dname;
00746
00747 tname=GWEN_Crypt_Token_GetTypeName(ct);
00748 assert(tname);
00749 dname=GWEN_Crypt_Token_GetTokenName(ct);
00750 if (!dname) {
00751 DBG_ERROR(GWEN_LOGDOMAIN, "Token has no name");
00752 return GWEN_ERROR_INVALID;
00753 }
00754
00755 GWEN_Buffer_AppendString(nbuf, "PASSWORD_");
00756 GWEN_Buffer_AppendString(nbuf, tname);
00757 GWEN_Buffer_AppendString(nbuf, "_");
00758 GWEN_Buffer_AppendString(nbuf, dname);
00759 if (pt==GWEN_Crypt_PinType_Manage)
00760 GWEN_Buffer_AppendString(nbuf, ":MANAGE");
00761
00762 return 0;
00763 }
00764
00765
00766
00767 int GWEN_Crypt_Token_GetPin(GWEN_CRYPT_TOKEN *ct,
00768 GWEN_CRYPT_PINTYPE pt,
00769 GWEN_CRYPT_PINENCODING pe,
00770 uint32_t flags,
00771 unsigned char *pwbuffer,
00772 unsigned int minLength,
00773 unsigned int maxLength,
00774 unsigned int *pinLength,
00775 uint32_t gid) {
00776 int rv;
00777 const char *dname;
00778 const char *mode;
00779 const char *numeric_warning = "";
00780 char buffer[512];
00781 GWEN_BUFFER *nameBuffer;
00782
00783 assert(ct);
00784 assert(ct->refCount);
00785
00786 dname=GWEN_Crypt_Token_GetFriendlyName(ct);
00787 if (!dname || !*dname)
00788 dname=GWEN_Crypt_Token_GetTokenName(ct);
00789
00790 if (pt==GWEN_Crypt_PinType_Access)
00791 mode=I18N("access password");
00792 else if (pt==GWEN_Crypt_PinType_Manage)
00793 mode=I18N("manager password");
00794 else
00795 mode=I18N("password");
00796
00797 buffer[0]=0;
00798 buffer[sizeof(buffer)-1]=0;
00799 if (flags & GWEN_GUI_INPUT_FLAGS_NUMERIC) {
00800 numeric_warning = I18N("\nYou must only enter numbers, not letters.");
00801 }
00802
00803 if (flags & GWEN_GUI_INPUT_FLAGS_CONFIRM) {
00804 snprintf(buffer, sizeof(buffer)-1,
00805 I18N("Please enter a new %s for \n"
00806 "%s\n"
00807 "The password must be at least %d characters long.%s"
00808 "<html>"
00809 "Please enter a new %s for <i>%s</i>. "
00810 "The password must be at least %d characters long.%s"
00811 "</html>"),
00812 mode,
00813 dname,
00814 minLength,
00815 numeric_warning,
00816 mode,
00817 dname,
00818 minLength,
00819 numeric_warning);
00820 }
00821 else {
00822 snprintf(buffer, sizeof(buffer)-1,
00823 I18N("Please enter the %s for \n"
00824 "%s\n"
00825 "%s<html>"
00826 "Please enter the %s for <i>%s</i>.%s"
00827 "</html>"),
00828 mode,
00829 dname,
00830 numeric_warning,
00831 mode,
00832 dname,
00833 numeric_warning);
00834 }
00835
00836 nameBuffer=GWEN_Buffer_new(0, 256, 0, 1);
00837 GWEN_Crypt_Token__CreatePasswordName(ct, pt, nameBuffer);
00838 rv=GWEN_Gui_GetPassword(flags,
00839 GWEN_Buffer_GetStart(nameBuffer),
00840 I18N("Enter Password"),
00841 buffer,
00842 (char*)pwbuffer,
00843 minLength,
00844 maxLength, gid);
00845 GWEN_Buffer_free(nameBuffer);
00846 if (rv) {
00847 DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
00848 return rv;
00849 }
00850
00851 *pinLength=strlen((char*)pwbuffer);
00852
00853 if (pe!=GWEN_Crypt_PinEncoding_Ascii) {
00854 rv=GWEN_Crypt_TransformPin(GWEN_Crypt_PinEncoding_Ascii,
00855 pe,
00856 pwbuffer,
00857 maxLength,
00858 pinLength);
00859 if (rv) {
00860 DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
00861 return rv;
00862 }
00863 }
00864
00865 return 0;
00866 }
00867
00868
00869
00870 int GWEN_Crypt_Token_SetPinStatus(GWEN_CRYPT_TOKEN *ct,
00871 GWEN_CRYPT_PINTYPE pt,
00872 GWEN_CRYPT_PINENCODING pe,
00873 uint32_t flags,
00874 const unsigned char *buffer,
00875 unsigned int pinLength,
00876 int isOk,
00877 uint32_t gid) {
00878 GWEN_BUFFER *nameBuffer;
00879 int rv;
00880 unsigned char ibuffer[256];
00881
00882 assert(ct);
00883 assert(ct->refCount);
00884
00885 if (pe!=GWEN_Crypt_PinEncoding_Ascii) {
00886 if (pinLength>=sizeof(ibuffer)) {
00887 DBG_ERROR(GWEN_LOGDOMAIN, "Pin too long");
00888 return GWEN_ERROR_BUFFER_OVERFLOW;
00889 }
00890 memset(ibuffer, 0, sizeof(ibuffer));
00891 memmove(ibuffer, buffer, pinLength);
00892 rv=GWEN_Crypt_TransformPin(pe,
00893 GWEN_Crypt_PinEncoding_Ascii,
00894 ibuffer,
00895 sizeof(ibuffer)-1,
00896 &pinLength);
00897 if (rv) {
00898 DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
00899 return rv;
00900 }
00901 buffer=ibuffer;
00902 }
00903
00904 nameBuffer=GWEN_Buffer_new(0, 256, 0, 1);
00905 GWEN_Crypt_Token__CreatePasswordName(ct, pt, nameBuffer);
00906 rv=GWEN_Gui_SetPasswordStatus(GWEN_Buffer_GetStart(nameBuffer),
00907 (const char*)buffer,
00908 isOk?GWEN_Gui_PasswordStatus_Ok:
00909 GWEN_Gui_PasswordStatus_Bad, gid);
00910 memset(ibuffer, 0, sizeof(ibuffer));
00911 GWEN_Buffer_free(nameBuffer);
00912 return rv;
00913
00914 }
00915
00916
00917
00918 uint32_t GWEN_Crypt_Token_BeginEnterPin(GWEN_CRYPT_TOKEN *ct,
00919 GWEN_CRYPT_PINTYPE pt,
00920 uint32_t gid) {
00921 char buffer[512];
00922
00923 assert(ct);
00924 assert(ct->refCount);
00925
00926 buffer[0]=0;
00927 buffer[sizeof(buffer)-1]=0;
00928
00929 snprintf(buffer, sizeof(buffer)-1,
00930 I18N("Please enter your PIN into the card reader."
00931 "<html>"
00932 "Please enter your PIN into the card reader."
00933 "</html>"));
00934 return GWEN_Gui_ShowBox(GWEN_GUI_SHOWBOX_FLAGS_BEEP,
00935 I18N("Secure PIN Input"),
00936 buffer, gid);
00937 }
00938
00939
00940
00941 int GWEN_Crypt_Token_EndEnterPin(GWEN_CRYPT_TOKEN *ct,
00942 GWEN_CRYPT_PINTYPE pt,
00943 int ok,
00944 uint32_t id) {
00945 assert(ct);
00946 assert(ct->refCount);
00947
00948 GWEN_Gui_HideBox(id);
00949
00950 return 0;
00951 }
00952
00953
00954
00955 int GWEN_Crypt_Token_InsertToken(GWEN_CRYPT_TOKEN *ct, uint32_t gid) {
00956 int rv;
00957 char buffer[512];
00958 const char *dname;
00959
00960 assert(ct);
00961 assert(ct->refCount);
00962
00963 buffer[0]=0;
00964 buffer[sizeof(buffer)-1]=0;
00965
00966 dname=GWEN_Crypt_Token_GetFriendlyName(ct);
00967 if (!dname || !*dname)
00968 dname=GWEN_Crypt_Token_GetTokenName(ct);
00969
00970 if (GWEN_Crypt_Token_GetDevice(ct)==GWEN_Crypt_Token_Device_File)
00971 snprintf(buffer, sizeof(buffer)-1,
00972 I18N("Please insert the security disc\nfor %s"
00973 "<html>"
00974 "Please insert the security disc for <i>%s</i>"
00975 "</html>"), dname, dname);
00976 else
00977 snprintf(buffer, sizeof(buffer)-1,
00978 I18N("Please insert the chip card\nfor %s"
00979 "<html>"
00980 "Please insert the chip card for <i>%s</i>"
00981 "</html>"), dname, dname);
00982
00983 rv=GWEN_Gui_MessageBox(GWEN_GUI_MSG_FLAGS_TYPE_WARN |
00984 GWEN_GUI_MSG_FLAGS_SEVERITY_NORMAL |
00985 GWEN_GUI_MSG_FLAGS_CONFIRM_B1,
00986 I18N("Insert Medium"),
00987 buffer,
00988 I18N("OK"), I18N("Abort"), 0, gid);
00989 if (rv==2) {
00990 DBG_ERROR(GWEN_LOGDOMAIN, "User aborted");
00991 GWEN_Gui_ProgressLog(0, GWEN_LoggerLevel_Notice,
00992 I18N("Aborted by user."));
00993 return GWEN_ERROR_USER_ABORTED;
00994 }
00995 else if (rv!=1) {
00996 GWEN_Gui_MessageBox(GWEN_GUI_MSG_FLAGS_TYPE_ERROR |
00997 GWEN_GUI_MSG_FLAGS_SEVERITY_DANGEROUS |
00998 GWEN_GUI_MSG_FLAGS_CONFIRM_B1,
00999 I18N("Error"),
01000 I18N("An internal error occurred."),
01001 I18N("Dismiss"), 0, 0, gid);
01002 return -1;
01003 }
01004
01005 return 0;
01006 }
01007
01008
01009
01010 int GWEN_Crypt_Token_InsertCorrectToken(GWEN_CRYPT_TOKEN *ct, uint32_t gid) {
01011 int rv;
01012 char buffer[512];
01013 const char *dname;
01014
01015 assert(ct);
01016 assert(ct->refCount);
01017
01018 buffer[0]=0;
01019 buffer[sizeof(buffer)-1]=0;
01020
01021 dname=GWEN_Crypt_Token_GetFriendlyName(ct);
01022 if (!dname || !*dname)
01023 dname=GWEN_Crypt_Token_GetTokenName(ct);
01024
01025 if (GWEN_Crypt_Token_GetDevice(ct)==GWEN_Crypt_Token_Device_File)
01026 snprintf(buffer, sizeof(buffer)-1,
01027 I18N("Please insert the correct security disc\nfor %s"
01028 "<html>"
01029 "Please insert the correct security disc for <i>%s</i>"
01030 "</html>"), dname, dname);
01031 else
01032 snprintf(buffer, sizeof(buffer)-1,
01033 I18N("Please insert the correct chip card\nfor %s"
01034 "<html>"
01035 "Please insert the correct chip card for <i>%s</i>"
01036 "</html>"), dname, dname);
01037
01038 rv=GWEN_Gui_MessageBox(GWEN_GUI_MSG_FLAGS_TYPE_WARN |
01039 GWEN_GUI_MSG_FLAGS_SEVERITY_DANGEROUS |
01040 GWEN_GUI_MSG_FLAGS_CONFIRM_B1,
01041 I18N("Insert Medium"),
01042 buffer,
01043 I18N("OK"), I18N("Abort"), 0, gid);
01044 if (rv==2) {
01045 DBG_ERROR(GWEN_LOGDOMAIN, "User aborted");
01046 GWEN_Gui_ProgressLog(0, GWEN_LoggerLevel_Notice,
01047 I18N("Aborted by user."));
01048 return GWEN_ERROR_USER_ABORTED;
01049 }
01050 else if (rv!=1) {
01051 GWEN_Gui_MessageBox(GWEN_GUI_MSG_FLAGS_TYPE_ERROR |
01052 GWEN_GUI_MSG_FLAGS_SEVERITY_DANGEROUS |
01053 GWEN_GUI_MSG_FLAGS_CONFIRM_B1,
01054 I18N("Error"),
01055 I18N("An internal error occurred."),
01056 I18N("Dismiss"), 0, 0, gid);
01057 return -1;
01058 }
01059
01060 return 0;
01061 }
01062
01063
01064
01065 GWEN_CRYPT_TOKEN_DEVICE GWEN_Crypt_Token_Device_fromString(const char *s){
01066 assert(s);
01067 if (strcasecmp(s, "none")==0)
01068 return GWEN_Crypt_Token_Device_None;
01069 else if (strcasecmp(s, "file")==0)
01070 return GWEN_Crypt_Token_Device_File;
01071 else if (strcasecmp(s, "card")==0)
01072 return GWEN_Crypt_Token_Device_Card;
01073 else if (strcasecmp(s, "any")==0)
01074 return GWEN_Crypt_Token_Device_Any;
01075 return GWEN_Crypt_Token_Device_Unknown;
01076 }
01077
01078
01079
01080 const char *GWEN_Crypt_Token_Device_toString(GWEN_CRYPT_TOKEN_DEVICE d){
01081 switch(d) {
01082 case GWEN_Crypt_Token_Device_None:
01083 return "none";
01084 case GWEN_Crypt_Token_Device_File:
01085 return "file";
01086 case GWEN_Crypt_Token_Device_Card:
01087 return "card";
01088 case GWEN_Crypt_Token_Device_Any:
01089 return "any";
01090 default:
01091 return "unknown";
01092 }
01093 }
01094
01095
01096
01097
01098
01099