gwenhywfar  4.3.3
ct.c
Go to the documentation of this file.
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