ct.c

Go to the documentation of this file.
00001 /***************************************************************************
00002  $RCSfile$
00003                              -------------------
00004     cvs         : $Id: crypttoken.h 1113 2007-01-10 09:14:16Z martin $
00005     begin       : Wed Mar 16 2005
00006     copyright   : (C) 2005 by Martin Preuss
00007     email       : martin@libchipcard.de
00008 
00009  ***************************************************************************
00010  *          Please see toplevel file COPYING for license details           *
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                                   GWEN_UNUSED 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_UNUSED 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, "%s",
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_UNUSED GWEN_CRYPT_PINTYPE pt,
00943                                  GWEN_UNUSED 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     if (dname && *dname) {
01033       snprintf(buffer, sizeof(buffer)-1,
01034                I18N("The wrong chipcard has been inserted.\n"
01035                     "Please insert the chipcard with the number\n"
01036                     "  %s\n"
01037                     "into the card reader.\n"
01038                     "<html>"
01039                     "<p>The wrong card has been inserted.</p>"
01040                     "<p>Please insert the chipcard with the number"
01041                     "<b>%s</b> into the card reader.</p>"
01042                     "</html>"),
01043                dname,
01044                dname);
01045     }
01046     else
01047       snprintf(buffer, sizeof(buffer)-1,
01048                I18N("Please insert the correct chipcard\nfor %s"
01049                     "<html>"
01050                     "Please insert the correct chipcard for <i>%s</i>"
01051                     "</html>"), dname, dname);
01052   }
01053 
01054   rv=GWEN_Gui_MessageBox(GWEN_GUI_MSG_FLAGS_TYPE_WARN |
01055                          GWEN_GUI_MSG_FLAGS_SEVERITY_DANGEROUS |
01056                          GWEN_GUI_MSG_FLAGS_CONFIRM_B1,
01057                          I18N("Insert Medium"),
01058                          buffer,
01059                          I18N("OK"), I18N("Abort"), 0, gid);
01060   if (rv==2) {
01061     DBG_ERROR(GWEN_LOGDOMAIN, "User aborted");
01062     GWEN_Gui_ProgressLog(0, GWEN_LoggerLevel_Notice,
01063                          I18N("Aborted by user."));
01064     return GWEN_ERROR_USER_ABORTED;
01065   }
01066   else if (rv!=1) {
01067     GWEN_Gui_MessageBox(GWEN_GUI_MSG_FLAGS_TYPE_ERROR |
01068                         GWEN_GUI_MSG_FLAGS_SEVERITY_DANGEROUS |
01069                         GWEN_GUI_MSG_FLAGS_CONFIRM_B1,
01070                         I18N("Error"),
01071                         I18N("An internal error occurred."),
01072                         I18N("Dismiss"), 0, 0, gid);
01073     return -1;
01074   }
01075 
01076   return 0;
01077 }
01078 
01079 
01080 
01081 GWEN_CRYPT_TOKEN_DEVICE GWEN_Crypt_Token_Device_fromString(const char *s){
01082   assert(s);
01083   if (strcasecmp(s, "none")==0)
01084     return GWEN_Crypt_Token_Device_None;
01085   else if (strcasecmp(s, "file")==0)
01086     return GWEN_Crypt_Token_Device_File;
01087   else if (strcasecmp(s, "card")==0)
01088     return GWEN_Crypt_Token_Device_Card;
01089   else if (strcasecmp(s, "any")==0)
01090     return GWEN_Crypt_Token_Device_Any;
01091   return GWEN_Crypt_Token_Device_Unknown;
01092 }
01093 
01094 
01095 
01096 const char *GWEN_Crypt_Token_Device_toString(GWEN_CRYPT_TOKEN_DEVICE d){
01097   switch(d) {
01098   case GWEN_Crypt_Token_Device_None:
01099     return "none";
01100   case GWEN_Crypt_Token_Device_File:
01101     return "file";
01102   case GWEN_Crypt_Token_Device_Card:
01103     return "card";
01104   case GWEN_Crypt_Token_Device_Any:
01105     return "any";
01106   default:
01107     return "unknown";
01108   }
01109 }
01110 
01111 
01112 
01113 
01114 
01115 

Generated on Mon Jan 25 12:56:01 2010 for gwenhywfar by  doxygen 1.5.6