int LC_DDVCard_GetKeyVersion1(LC_CARD *card, int keyNumber){ LC_DDVCARD *ddv; GWEN_DB_NODE *dbReq; GWEN_DB_NODE *dbResp; LC_CLIENT_RESULT res; int keyVersion; assert(card); ddv=GWEN_INHERIT_GETDATA(LC_CARD, LC_DDVCARD, card); assert(ddv); dbReq=GWEN_DB_Group_new("GetKeyInfo"); dbResp=GWEN_DB_Group_new("response"); GWEN_DB_SetIntValue(dbReq, GWEN_DB_FLAGS_DEFAULT, "keyNumber", keyNumber); res=LC_Card_ExecCommand(card, "GetKeyInfo", dbReq, dbResp); if (res!=LC_Client_ResultOk) { GWEN_DB_Group_free(dbReq); GWEN_DB_Group_free(dbResp); return -1; } keyVersion=GWEN_DB_GetIntValue(dbResp, "response/keyVersion", 0, -1); if (keyVersion==-1) { DBG_ERROR(LC_LOGDOMAIN, "No keyversion returned by command"); } GWEN_DB_Group_free(dbReq); GWEN_DB_Group_free(dbResp); return keyVersion; }
LC_CLIENT_RESULT LC_DDVCard_CryptCharBlock(LC_CARD *card, const char *data, unsigned int dlen, GWEN_BUFFER *obuf){ LC_DDVCARD *ddv; GWEN_DB_NODE *dbReq; GWEN_DB_NODE *dbResp; LC_CLIENT_RESULT res; const void *p; unsigned int bs; assert(card); ddv=GWEN_INHERIT_GETDATA(LC_CARD, LC_DDVCARD, card); assert(ddv); if (dlen!=8) { DBG_ERROR(LC_LOGDOMAIN, "In-block must exactly be 8 bytes in length (is %d)", dlen); return LC_Client_ResultDataError; } dbReq=GWEN_DB_Group_new("CryptBlock"); dbResp=GWEN_DB_Group_new("response"); GWEN_DB_SetBinValue(dbReq, GWEN_DB_FLAGS_DEFAULT, "in", data, dlen); res=LC_Card_ExecCommand(card, "CryptBlock", dbReq, dbResp); if (res!=LC_Client_ResultOk) { GWEN_DB_Group_free(dbReq); GWEN_DB_Group_free(dbResp); return res; } p=GWEN_DB_GetBinValue(dbResp, "response/out", 0, 0, 0, &bs); if ( p && bs==8) GWEN_Buffer_AppendBytes(obuf, p, bs); else { DBG_ERROR(LC_LOGDOMAIN, "Expected 8 bytes response, got %d bytes", bs); GWEN_DB_Group_free(dbReq); GWEN_DB_Group_free(dbResp); return LC_Client_ResultDataError; } GWEN_DB_Group_free(dbReq); GWEN_DB_Group_free(dbResp); return LC_Client_ResultOk; }
int AB_Banking_SaveUser(AB_BANKING *ab, AB_USER *u) { GWEN_DB_NODE *db; GWEN_DB_NODE *dbP; int rv; db=GWEN_DB_Group_new("user"); AB_User_toDb(u, db); dbP=GWEN_DB_GetGroup(db, GWEN_DB_FLAGS_DEFAULT, "data/backend"); rv=AB_Provider_ExtendUser(AB_User_GetProvider(u), u, AB_ProviderExtendMode_Save, dbP); if (rv) { DBG_INFO(AQBANKING_LOGDOMAIN, "here (%d)", rv); GWEN_DB_Group_free(db); return rv; } /* save group (still locked) */ rv=GWEN_ConfigMgr_SetGroup(ab->configMgr, AB_CFG_GROUP_USERS, AB_User_GetDbId(u), db); if (rv<0) { DBG_ERROR(AQBANKING_LOGDOMAIN, "Could not save user group (%d)", rv); GWEN_DB_Group_free(db); return rv; } GWEN_DB_Group_free(db); return 0; }
int AB_CSV_EditProfileDialog_HandleActivated(GWEN_DIALOG *dlg, const char *sender) { AB_CSV_EDIT_PROFILE_DIALOG *xdlg; assert(dlg); xdlg=GWEN_INHERIT_GETDATA(GWEN_DIALOG, AB_CSV_EDIT_PROFILE_DIALOG, dlg); assert(xdlg); if (strcasecmp(sender, "okButton")==0) { GWEN_DB_NODE *db; int rv; db=GWEN_DB_Group_new("profile"); rv=AB_CSV_EditProfileDialog_fromGui(dlg, db); if (rv<0) { DBG_INFO(AQBANKING_LOGDOMAIN, "here (%d)", rv); GWEN_DB_Group_free(db); return GWEN_DialogEvent_ResultHandled; } GWEN_DB_ClearGroup(xdlg->dbProfile, NULL); GWEN_DB_AddGroupChildren(xdlg->dbProfile, db); GWEN_DB_Group_free(db); return GWEN_DialogEvent_ResultAccept; } else if (strcasecmp(sender, "abortButton")==0) return GWEN_DialogEvent_ResultReject; else if (strcasecmp(sender, "helpButton")==0) { } else if (strcasecmp(sender, "headerCheck")==0) { if (xdlg->testFileName) readTestData(dlg); return GWEN_DialogEvent_ResultHandled; } return GWEN_DialogEvent_ResultHandled; }
void AH_User_LoadSepaDescriptors(AB_USER *u) { AH_USER *ue; GWEN_DB_NODE *db; int rv; assert(u); ue=GWEN_INHERIT_GETDATA(AB_USER, AH_USER, u); assert(ue); /* read directly from BPD */ GWEN_StringList_Clear(ue->sepaDescriptors); db=GWEN_DB_Group_new("bpd"); rv=AH_Job_SampleBpdVersions("JobGetAccountSepaInfo", u, db); if (rv<0) { DBG_INFO(AQHBCI_LOGDOMAIN, "No BPD for TAN job"); } else { GWEN_DB_NODE *dbV; dbV=GWEN_DB_GetFirstGroup(db); while(dbV) { int version; version=atoi(GWEN_DB_GroupName(dbV)); if (version>0) { GWEN_DB_NODE *dbT; /* always overwrite with latest version received */ GWEN_StringList_Clear(ue->sepaDescriptors); dbT=GWEN_DB_FindFirstGroup(dbV, "SupportedSepaFormats"); if (!dbT) { DBG_INFO(AQHBCI_LOGDOMAIN, "No SEPA descriptor found"); } while(dbT) { int i; for (i=0; i<100; i++) { const char *s; s=GWEN_DB_GetCharValue(dbT, "format", i, NULL); if (! (s && *s)) break; GWEN_StringList_AppendString(ue->sepaDescriptors, s, 0, 1); DBG_INFO(AQHBCI_LOGDOMAIN, "Adding SEPA descriptor [%s] for GV version %d", s, version); } dbT=GWEN_DB_FindNextGroup(dbT, "SupportedSepaFormats"); } } dbV=GWEN_DB_GetNextGroup(dbV); } } GWEN_DB_Group_free(db); }
GWEN_URL *GWEN_Url_new(void) { GWEN_URL *st; GWEN_NEW_OBJECT(GWEN_URL, st) st->_usage=1; GWEN_LIST_INIT(GWEN_URL, st) st->vars=GWEN_DB_Group_new("vars"); return st; }
int readContext(const char *ctxFile, AB_IMEXPORTER_CONTEXT **pCtx, int mustExist) { AB_IMEXPORTER_CONTEXT *ctx; GWEN_SYNCIO *sio; GWEN_DB_NODE *dbCtx; int rv; if (ctxFile==NULL) { sio=GWEN_SyncIo_File_fromStdin(); GWEN_SyncIo_AddFlags(sio, GWEN_SYNCIO_FLAGS_DONTCLOSE | GWEN_SYNCIO_FILE_FLAGS_READ); } else { sio=GWEN_SyncIo_File_new(ctxFile, GWEN_SyncIo_File_CreationMode_OpenExisting); GWEN_SyncIo_AddFlags(sio, GWEN_SYNCIO_FILE_FLAGS_READ); rv=GWEN_SyncIo_Connect(sio); if (rv<0) { if (!mustExist) { ctx=AB_ImExporterContext_new(); *pCtx=ctx; GWEN_SyncIo_free(sio); return 0; } GWEN_SyncIo_free(sio); return 4; } } /* actually read */ dbCtx=GWEN_DB_Group_new("context"); rv=GWEN_DB_ReadFromIo(dbCtx, sio, GWEN_DB_FLAGS_DEFAULT | GWEN_PATH_FLAGS_CREATE_GROUP); if (rv<0) { DBG_ERROR(0, "Error reading context file (%d)", rv); GWEN_DB_Group_free(dbCtx); GWEN_SyncIo_Disconnect(sio); GWEN_SyncIo_free(sio); return rv; } GWEN_SyncIo_Disconnect(sio); GWEN_SyncIo_free(sio); ctx=AB_ImExporterContext_fromDb(dbCtx); if (!ctx) { DBG_ERROR(0, "No context in input data"); GWEN_DB_Group_free(dbCtx); return GWEN_ERROR_BAD_DATA; } GWEN_DB_Group_free(dbCtx); *pCtx=ctx; return 0; }
LC_CLIENT_RESULT LC_DDVCard_GetChallenge(LC_CARD *card, GWEN_BUFFER *mbuf){ LC_DDVCARD *ddv; GWEN_DB_NODE *dbReq; GWEN_DB_NODE *dbResp; LC_CLIENT_RESULT res; const void *p; unsigned int bs; assert(card); ddv=GWEN_INHERIT_GETDATA(LC_CARD, LC_DDVCARD, card); assert(ddv); dbReq=GWEN_DB_Group_new("GetChallenge"); dbResp=GWEN_DB_Group_new("response"); res=LC_Card_ExecCommand(card, "GetChallenge", dbReq, dbResp); if (res!=LC_Client_ResultOk) { GWEN_DB_Group_free(dbReq); GWEN_DB_Group_free(dbResp); return res; } p=GWEN_DB_GetBinValue(dbResp, "response/challenge", 0, 0, 0, &bs); if (p && bs==8) { GWEN_Buffer_AppendBytes(mbuf, p, bs); } else { DBG_ERROR(LC_LOGDOMAIN, "Expected 8 bytes response, got %d bytes", bs); GWEN_DB_Group_free(dbReq); GWEN_DB_Group_free(dbResp); return LC_Client_ResultDataError; } GWEN_DB_Group_free(dbReq); GWEN_DB_Group_free(dbResp); return res; }
int writeContext(const char *ctxFile, const AB_IMEXPORTER_CONTEXT *ctx) { GWEN_DB_NODE *dbCtx; GWEN_SYNCIO *sio; int rv; if (ctxFile==NULL) { sio=GWEN_SyncIo_File_fromStdout(); GWEN_SyncIo_AddFlags(sio, GWEN_SYNCIO_FLAGS_DONTCLOSE | GWEN_SYNCIO_FILE_FLAGS_WRITE); } else { sio=GWEN_SyncIo_File_new(ctxFile, GWEN_SyncIo_File_CreationMode_CreateAlways); GWEN_SyncIo_AddFlags(sio, GWEN_SYNCIO_FILE_FLAGS_READ | GWEN_SYNCIO_FILE_FLAGS_WRITE | GWEN_SYNCIO_FILE_FLAGS_UREAD | GWEN_SYNCIO_FILE_FLAGS_UWRITE | GWEN_SYNCIO_FILE_FLAGS_GREAD | GWEN_SYNCIO_FILE_FLAGS_GWRITE); rv=GWEN_SyncIo_Connect(sio); if (rv<0) { DBG_ERROR(0, "Error selecting output file: %s", strerror(errno)); GWEN_SyncIo_free(sio); return 4; } } dbCtx=GWEN_DB_Group_new("context"); rv=AB_ImExporterContext_toDb(ctx, dbCtx); if (rv<0) { DBG_ERROR(0, "Error writing context to db (%d)", rv); GWEN_DB_Group_free(dbCtx); GWEN_SyncIo_Disconnect(sio); GWEN_SyncIo_free(sio); return rv; } rv=GWEN_DB_WriteToIo(dbCtx, sio, GWEN_DB_FLAGS_DEFAULT); if (rv<0) { DBG_ERROR(0, "Error writing context (%d)", rv); } else rv=0; GWEN_DB_Group_free(dbCtx); GWEN_SyncIo_Disconnect(sio); GWEN_SyncIo_free(sio); return rv; }
int AH_ImExporterCtxFile_Import(AB_IMEXPORTER *ie, AB_IMEXPORTER_CONTEXT *ctx, GWEN_SYNCIO *sio, GWEN_DB_NODE *params){ AH_IMEXPORTER_CTXFILE *ieh; GWEN_DB_NODE *dbData; int rv; assert(ie); ieh=GWEN_INHERIT_GETDATA(AB_IMEXPORTER, AH_IMEXPORTER_CTXFILE, ie); assert(ieh); dbData=GWEN_DB_Group_new("context"); rv=GWEN_DB_ReadFromIo(dbData, sio, GWEN_DB_FLAGS_DEFAULT | GWEN_PATH_FLAGS_CREATE_GROUP); if (rv) { DBG_ERROR(AQBANKING_LOGDOMAIN, "Error importing data (%d)", rv); GWEN_Gui_ProgressLog(0, GWEN_LoggerLevel_Error, "Error importing data"); GWEN_DB_Group_free(dbData); return GWEN_ERROR_GENERIC; } /* transform DB to transactions */ GWEN_Gui_ProgressLog(0, GWEN_LoggerLevel_Notice, I18N("Data imported, transforming to UTF-8")); rv=AB_ImExporter_DbFromIso8859_1ToUtf8(dbData); if (rv) { GWEN_Gui_ProgressLog(0, GWEN_LoggerLevel_Error, "Error converting data"); GWEN_DB_Group_free(dbData); return rv; } GWEN_Gui_ProgressLog(0, GWEN_LoggerLevel_Notice, "Transforming data to transactions"); rv=AB_ImExporterContext_ReadDb(ctx, dbData); if (rv) { GWEN_Gui_ProgressLog(0, GWEN_LoggerLevel_Error, "Error importing data"); GWEN_DB_Group_free(dbData); return rv; } GWEN_DB_Group_free(dbData); return 0; }
void AH_User_SetUpd(AB_USER *u, GWEN_DB_NODE *n){ AH_USER *ue; assert(u); ue=GWEN_INHERIT_GETDATA(AB_USER, AH_USER, u); assert(ue); if (ue->dbUpd) GWEN_DB_Group_free(ue->dbUpd); if (n) { ue->dbUpd=GWEN_DB_Group_dup(n); } else ue->dbUpd=GWEN_DB_Group_new("upd"); }
int LC_DDVCard_GetSignKeyVersion0(LC_CARD *card){ LC_DDVCARD *ddv; LC_CLIENT_RESULT res; GWEN_DB_NODE *dbRecord; GWEN_BUFFER *mbuf; int keyVer; assert(card); ddv=GWEN_INHERIT_GETDATA(LC_CARD, LC_DDVCARD, card); assert(ddv); res=LC_Card_SelectEf(card, "EF_KEYD"); if (res!=LC_Client_ResultOk) { DBG_INFO(LC_LOGDOMAIN, "here"); return -1; } mbuf=GWEN_Buffer_new(0, 4, 0, 1); res=LC_Card_IsoReadRecord(card, LC_CARD_ISO_FLAGS_RECSEL_GIVEN, 1 /* should be 2 */, mbuf); if (res!=LC_Client_ResultOk) { DBG_INFO(LC_LOGDOMAIN, "here"); GWEN_Buffer_free(mbuf); return -1; } GWEN_Buffer_Rewind(mbuf); dbRecord=GWEN_DB_Group_new("autd"); if (LC_Card_ParseRecord(card, 1 /* should be 2, but that doesn't work */, mbuf, dbRecord)) { DBG_ERROR(LC_LOGDOMAIN, "Error parsing record"); GWEN_DB_Group_free(dbRecord); GWEN_Buffer_free(mbuf); return -1; } GWEN_Buffer_free(mbuf); keyVer=GWEN_DB_GetIntValue(dbRecord, "keyVersion", 0, -1); GWEN_DB_Group_free(dbRecord); if (keyVer==-1) { DBG_ERROR(LC_LOGDOMAIN, "No keyVersion in record 2 of EF_KEYD"); } return keyVer; }
int AB_Banking_EndExclUseAccount(AB_BANKING *ab, AB_ACCOUNT *a, int abandon) { int rv; if (!abandon) { GWEN_DB_NODE *db=GWEN_DB_Group_new("account"); GWEN_DB_NODE *dbP; AB_Account_toDb(a, db); dbP=GWEN_DB_GetGroup(db, GWEN_DB_FLAGS_DEFAULT, "data/backend"); rv=AB_Provider_ExtendAccount(AB_Account_GetProvider(a), a, AB_ProviderExtendMode_Save, dbP); if (rv) { DBG_INFO(AQBANKING_LOGDOMAIN, "here (%d)", rv); GWEN_DB_Group_free(db); return rv; } /* save group (still locked) */ rv=GWEN_ConfigMgr_SetGroup(ab->configMgr, AB_CFG_GROUP_ACCOUNTS, AB_Account_GetDbId(a), db); if (rv<0) { DBG_ERROR(AQBANKING_LOGDOMAIN, "Could not save account group (%d)", rv); GWEN_ConfigMgr_UnlockGroup(ab->configMgr, AB_CFG_GROUP_ACCOUNTS, AB_Account_GetDbId(a)); GWEN_DB_Group_free(db); return rv; } GWEN_DB_Group_free(db); } /* unlock group */ rv=GWEN_ConfigMgr_UnlockGroup(ab->configMgr, AB_CFG_GROUP_ACCOUNTS, AB_Account_GetDbId(a)); if (rv<0) { DBG_ERROR(AQBANKING_LOGDOMAIN, "Could not unlock account group (%d)", rv); return rv; } return 0; }
int AB_Banking_WriteAccountSpec(AB_BANKING *ab, const AB_ACCOUNT_SPEC *accountSpec) { GWEN_DB_NODE *db=NULL; int rv; uint32_t uniqueId; assert(ab); uniqueId=AB_AccountSpec_GetUniqueId(accountSpec); /* write account spec to DB */ db=GWEN_DB_Group_new("accountSpec"); AB_AccountSpec_toDb(accountSpec, db); rv=AB_Banking_WriteConfigGroup(ab, AB_CFG_GROUP_ACCOUNTSPECS, uniqueId, 1, 1, db); if (rv<0) { DBG_INFO(AQBANKING_LOGDOMAIN, "here (%d)", rv); GWEN_DB_Group_free(db); return rv; } GWEN_DB_Group_free(db); return 0; }
int AH_ImExporterCtxFile_Export(AB_IMEXPORTER *ie, AB_IMEXPORTER_CONTEXT *ctx, GWEN_SYNCIO *sio, GWEN_DB_NODE *params){ AH_IMEXPORTER_CTXFILE *ieh; GWEN_DB_NODE *dbData; int rv; assert(ie); ieh=GWEN_INHERIT_GETDATA(AB_IMEXPORTER, AH_IMEXPORTER_CTXFILE, ie); assert(ieh); /* create db, store context in it */ dbData=GWEN_DB_Group_new("context"); rv=AB_ImExporterContext_toDb(ctx, dbData); if (rv) { DBG_ERROR(AQBANKING_LOGDOMAIN, "Error exporting data (%d)", rv); GWEN_Gui_ProgressLog(0, GWEN_LoggerLevel_Error, "Error exporting data"); GWEN_DB_Group_free(dbData); return GWEN_ERROR_GENERIC; } rv=GWEN_DB_WriteToIo(dbData, sio, GWEN_DB_FLAGS_DEFAULT); if (rv) { DBG_ERROR(AQBANKING_LOGDOMAIN, "Error exporting data (%d)", rv); GWEN_Gui_ProgressLog(0, GWEN_LoggerLevel_Error, "Error exporting data"); GWEN_DB_Group_free(dbData); return GWEN_ERROR_GENERIC; } GWEN_DB_Group_free(dbData); return 0; }
int listBal(AB_BANKING *ab, GWEN_DB_NODE *dbArgs, int argc, char **argv) { GWEN_DB_NODE *db; int rv; const char *ctxFile; AB_IMEXPORTER_CONTEXT *ctx=0; AB_IMEXPORTER_ACCOUNTINFO *iea=0; uint32_t aid; const char *bankId; const char *accountId; const char *subAccountId; const char *iban; const char *tmplString; const char *s; AB_BALANCE_TYPE bt=AB_Balance_TypeBooked; /* parse command line arguments */ db=_readCommandLine(dbArgs, argc, argv); if (db==NULL) { /* error in command line */ return 1; } /* read command line arguments */ aid=(uint32_t)GWEN_DB_GetIntValue(db, "uniqueAccountId", 0, 0); bankId=GWEN_DB_GetCharValue(db, "bankId", 0, 0); accountId=GWEN_DB_GetCharValue(db, "accountId", 0, 0); subAccountId=GWEN_DB_GetCharValue(db, "subAccountId", 0, 0); iban=GWEN_DB_GetCharValue(db, "iban", 0, 0); tmplString=GWEN_DB_GetCharValue(db, "template", 0, "$(dateAsString)\t" "$(valueAsString)\t" "$(iban)"); /* determine balance type */ s=GWEN_DB_GetCharValue(db, "balanceType", 0, "noted"); if (s && *s) { AB_BALANCE_TYPE tempBalanceType; tempBalanceType=AB_Balance_Type_fromString(s); if (tempBalanceType==AB_Balance_TypeUnknown) { DBG_ERROR(0, "Invalid balance type given (%s)", s); return 1; } bt=tempBalanceType; } /* init AqBanking */ rv=AB_Banking_Init(ab); if (rv) { DBG_ERROR(0, "Error on init (%d)", rv); return 2; } /* load ctx file */ ctxFile=GWEN_DB_GetCharValue(db, "ctxfile", 0, 0); rv=readContext(ctxFile, &ctx, 1); if (rv<0) { DBG_ERROR(0, "Error reading context (%d)", rv); AB_ImExporterContext_free(ctx); return 4; } /* copy context, but only keep wanted accounts and transactions */ iea=AB_ImExporterContext_GetFirstAccountInfo(ctx); while (iea) { if (AB_ImExporterAccountInfo_Matches(iea, aid, /* unique account id */ "*", bankId, accountId, subAccountId, iban, "*", /* currency */ AB_AccountType_Unknown)) { AB_BALANCE *bal; GWEN_DB_NODE *dbAccount; const char *s; dbAccount=GWEN_DB_Group_new("dbAccount"); s=AB_ImExporterAccountInfo_GetBankCode(iea); if (s && *s) GWEN_DB_SetCharValue(dbAccount, GWEN_DB_FLAGS_OVERWRITE_VARS, "bankCode", s); s=AB_ImExporterAccountInfo_GetAccountNumber(iea); if (s && *s) GWEN_DB_SetCharValue(dbAccount, GWEN_DB_FLAGS_OVERWRITE_VARS, "accountNumber", s); s=AB_ImExporterAccountInfo_GetBic(iea); if (s && *s) GWEN_DB_SetCharValue(dbAccount, GWEN_DB_FLAGS_OVERWRITE_VARS, "bic", s); s=AB_ImExporterAccountInfo_GetIban(iea); if (s && *s) GWEN_DB_SetCharValue(dbAccount, GWEN_DB_FLAGS_OVERWRITE_VARS, "iban", s); bal=AB_Balance_List_GetLatestByType(AB_ImExporterAccountInfo_GetBalanceList(iea), bt); if (bal) { GWEN_DB_NODE *dbElement; const AB_VALUE *v; const GWEN_DATE *dt; GWEN_BUFFER *dbuf; dbElement=GWEN_DB_Group_dup(dbAccount); AB_Balance_toDb(bal, dbElement); /* translate value */ dbuf=GWEN_Buffer_new(0, 256, 0, 1); v=AB_Balance_GetValue(bal); if (v) { AB_Value_toHumanReadableString(v, dbuf, 2, 0); GWEN_DB_SetCharValue(dbElement, GWEN_DB_FLAGS_OVERWRITE_VARS, "valueAsString", GWEN_Buffer_GetStart(dbuf)); GWEN_Buffer_Reset(dbuf); } /* translate date */ dt=AB_Balance_GetDate(bal); if (dt) { rv=GWEN_Date_toStringWithTemplate(dt, I18N("DD.MM.YYYY"), dbuf); if (rv>=0) { GWEN_DB_SetCharValue(dbElement, GWEN_DB_FLAGS_OVERWRITE_VARS, "dateAsString", GWEN_Buffer_GetStart(dbuf)); } GWEN_Buffer_Reset(dbuf); } GWEN_DB_ReplaceVars(dbElement, tmplString, dbuf); fprintf(stdout, "%s\n", GWEN_Buffer_GetStart(dbuf)); GWEN_Buffer_free(dbuf); GWEN_DB_Group_free(dbElement); } /* if bal */ GWEN_DB_Group_free(dbAccount); } /* if account matches */ iea=AB_ImExporterAccountInfo_List_Next(iea); } /* while */ AB_ImExporterContext_free(ctx); /* deinit */ rv=AB_Banking_Fini(ab); if (rv) { fprintf(stderr, "ERROR: Error on deinit (%d)\n", rv); return 5; } return 0; }
int LC_Client_InitCommon() { if (lc_client__initcounter==0) { int rv; GWEN_STRINGLIST *paths; rv=GWEN_Init(); if (rv) { DBG_ERROR_ERR(LC_LOGDOMAIN, rv); return rv; } if (!GWEN_Logger_IsOpen(LC_LOGDOMAIN)) { const char *s; /* only set our logger if it not already has been */ GWEN_Logger_Open(LC_LOGDOMAIN, "chipcard3-client", 0, GWEN_LoggerType_Console, GWEN_LoggerFacility_User); GWEN_Logger_SetLevel(LC_LOGDOMAIN, GWEN_LoggerLevel_Warning); s=getenv("LC_LOGLEVEL"); if (s) { GWEN_LOGGER_LEVEL ll; ll=GWEN_Logger_Name2Level(s); if (ll!=GWEN_LoggerLevel_Unknown) { GWEN_Logger_SetLevel(LC_LOGDOMAIN, ll); DBG_WARN(LC_LOGDOMAIN, "Overriding loglevel for Libchipcard-Client with \"%s\"", s); } else { DBG_ERROR(0, "Unknown loglevel \"%s\"", s); } } else { GWEN_Logger_SetLevel(LC_LOGDOMAIN, GWEN_LoggerLevel_Warning); } } /* define sysconf path */ GWEN_PathManager_DefinePath(LCC_PM_LIBNAME, LCC_PM_SYSCONFDIR); #if defined(OS_WIN32) || defined(ENABLE_LOCAL_INSTALL) /* add folder relative to EXE */ GWEN_PathManager_AddRelPath(LCC_PM_LIBNAME, LCC_PM_LIBNAME, LCC_PM_SYSCONFDIR, LC_CLIENT_CONFIG_DIR, GWEN_PathManager_RelModeExe); #else /* add absolute folder */ GWEN_PathManager_AddPath(LCC_PM_LIBNAME, LCC_PM_LIBNAME, LCC_PM_SYSCONFDIR, LC_CLIENT_CONFIG_DIR); #endif /* define data path */ GWEN_PathManager_DefinePath(LCC_PM_LIBNAME, LCC_PM_DATADIR); #if defined(OS_WIN32) || defined(ENABLE_LOCAL_INSTALL) /* add folder relative to EXE */ GWEN_PathManager_AddRelPath(LCC_PM_LIBNAME, LCC_PM_LIBNAME, LCC_PM_DATADIR, LC_CLIENT_XML_DIR, GWEN_PathManager_RelModeExe); #else /* add absolute folder */ GWEN_PathManager_AddPath(LCC_PM_LIBNAME, LCC_PM_LIBNAME, LCC_PM_DATADIR, LC_CLIENT_XML_DIR); #endif /* load configuration file */ #if 0 paths=GWEN_PathManager_GetPaths(LCC_PM_LIBNAME, LCC_PM_SYSCONFDIR); if (paths) { GWEN_DB_NODE *db; GWEN_BUFFER *fbuf; db=GWEN_DB_Group_new("config"); fbuf=GWEN_Buffer_new(0, 256, 0, 1); rv=GWEN_Directory_FindFileInPaths(paths, LC_CLIENT_CONFIG_FILE, fbuf); if (rv) { DBG_INFO(LC_LOGDOMAIN, "Trying config file with suffix \".default\""); rv=GWEN_Directory_FindFileInPaths(paths, LC_CLIENT_CONFIG_FILE".default", fbuf); } GWEN_StringList_free(paths); if (rv) { DBG_WARN(LC_LOGDOMAIN, "No configuration file found, using defaults"); } else { DBG_INFO(LC_LOGDOMAIN, "Reading configuration file \"%s\"", GWEN_Buffer_GetStart(fbuf)); rv=GWEN_DB_ReadFile(db, GWEN_Buffer_GetStart(fbuf), GWEN_DB_FLAGS_DEFAULT | GWEN_PATH_FLAGS_CREATE_GROUP); if (rv<0) { DBG_ERROR(LC_LOGDOMAIN, "Error in configuration file \"%s\" (%d)", GWEN_Buffer_GetStart(fbuf), rv); GWEN_Buffer_free(fbuf); /* undo all init stuff so far */ GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_DATADIR); GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_SYSCONFDIR); return rv; } } GWEN_Buffer_free(fbuf); lc_client__config=db; } else { DBG_ERROR(LC_LOGDOMAIN, "Internal error: Paths not found"); return GWEN_ERROR_INTERNAL; } #else lc_client__config=GWEN_DB_Group_new("config"); #endif /* load XML files */ paths=GWEN_PathManager_GetPaths(LCC_PM_LIBNAME, LCC_PM_DATADIR); if (paths) { GWEN_XMLNODE *n; GWEN_DB_NODE *db; GWEN_BUFFER *fbuf; uint32_t bpos; fbuf=GWEN_Buffer_new(0, 256, 0, 1); rv=GWEN_Directory_FindPathForFile(paths, "cards/README", fbuf); GWEN_StringList_free(paths); if (rv) { DBG_ERROR(LC_LOGDOMAIN, "Data files not found (%d)", rv); /* undo all init stuff so far */ GWEN_Buffer_free(fbuf); GWEN_DB_Group_free(lc_client__config); lc_client__config=NULL; GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_DATADIR); GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_SYSCONFDIR); return rv; } /* load card files */ n=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, "cards"); if (LC_Client_ReadXmlFiles(n, GWEN_Buffer_GetStart(fbuf), "cards", "card")) { DBG_ERROR(LC_LOGDOMAIN, "Could not read card files"); GWEN_XMLNode_free(n); /* undo all init stuff so far */ GWEN_Buffer_free(fbuf); GWEN_DB_Group_free(lc_client__config); lc_client__config=NULL; GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_DATADIR); GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_SYSCONFDIR); return GWEN_ERROR_GENERIC; } lc_client__card_nodes=n; /* load app files */ n=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, "apps"); if (LC_Client_ReadXmlFiles(n, GWEN_Buffer_GetStart(fbuf), "apps", "app")) { DBG_ERROR(LC_LOGDOMAIN, "Could not read app files"); GWEN_XMLNode_free(n); /* undo all init stuff so far */ GWEN_XMLNode_free(lc_client__card_nodes); lc_client__card_nodes=NULL; GWEN_Buffer_free(fbuf); GWEN_DB_Group_free(lc_client__config); lc_client__config=NULL; GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_DATADIR); GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_SYSCONFDIR); return GWEN_ERROR_GENERIC; } lc_client__app_nodes=n; /*GWEN_XMLNode_WriteFile(n, "/tmp/apps", GWEN_XML_FLAGS_DEFAULT);*/ /* load driver files (if any) */ bpos=GWEN_Buffer_GetPos(fbuf); GWEN_Buffer_AppendString(fbuf, DIRSEP "drivers"); db=GWEN_DB_Group_new("drivers"); rv=LC_DriverInfo_ReadDrivers(GWEN_Buffer_GetStart(fbuf), db, 0, 1); if (rv) { DBG_INFO(LC_LOGDOMAIN, "here (%d)", rv); GWEN_DB_Group_free(db); /* undo all init stuff so far */ GWEN_XMLNode_free(lc_client__app_nodes); lc_client__app_nodes=NULL; GWEN_XMLNode_free(lc_client__card_nodes); lc_client__card_nodes=NULL; GWEN_Buffer_free(fbuf); GWEN_DB_Group_free(lc_client__config); lc_client__config=NULL; GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_DATADIR); GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_SYSCONFDIR); return rv; } lc_client__driver_db=db; GWEN_Buffer_Crop(fbuf, 0, bpos); /* insert more loading here */ GWEN_Buffer_free(fbuf); } else { DBG_ERROR(LC_LOGDOMAIN, "No data files found."); /* undo all init stuff so far */ GWEN_DB_Group_free(lc_client__config); lc_client__config=NULL; GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_DATADIR); GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_SYSCONFDIR); return GWEN_ERROR_GENERIC; } } lc_client__initcounter++; return 0; }
int main(int argc, char **argv) { GWEN_DB_NODE *db; const char *cmd; const char *pinFile; int nonInteractive=0; const char *s; int rv; AB_BANKING *ab; GWEN_GUI *gui; const GWEN_ARGS args[]={ { GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */ GWEN_ArgsType_Char, /* type */ "cfgfile", /* name */ 0, /* minnum */ 1, /* maxnum */ "C", /* short option */ "cfgfile", /* long option */ "Specify the configuration file", /* short description */ "Specify the configuration file" /* long description */ }, { GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */ GWEN_ArgsType_Char, /* type */ "pinfile", /* name */ 0, /* minnum */ 1, /* maxnum */ "P", /* short option */ "pinfile", /* long option */ "Specify the PIN file", /* short description */ "Specify the PIN file" /* long description */ }, { 0, /* flags */ GWEN_ArgsType_Int, /* type */ "nonInteractive", /* name */ 0, /* minnum */ 1, /* maxnum */ "n", /* short option */ "noninteractive", /* long option */ "Select non-interactive mode",/* short description */ "Select non-interactive mode.\n" /* long description */ "This automatically returns a confirmative answer to any non-critical\n" "message." }, { 0, GWEN_ArgsType_Int, "verbosity", 0, 10, "v", 0, "Increase the verbosity level", "Increase the verbosity level" }, { GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */ GWEN_ArgsType_Char, /* type */ "charset", /* name */ 0, /* minnum */ 1, /* maxnum */ 0, /* short option */ "charset", /* long option */ "Specify the output character set", /* short description */ "Specify the output character set" /* long description */ }, { GWEN_ARGS_FLAGS_HELP | GWEN_ARGS_FLAGS_LAST, /* flags */ GWEN_ArgsType_Int, /* type */ "help", /* name */ 0, /* minnum */ 0, /* maxnum */ "h", /* short option */ "help", /* long option */ "Show this help screen", /* short description */ "Show this help screen" /* long description */ } }; rv=GWEN_Init(); if (rv<0) { fprintf(stderr, "ERROR: Unable to init GWEN (%d).\n", rv); return 2; } GWEN_Logger_Open("aqpaypal-tool", "aqpaypal-tool", 0, GWEN_LoggerType_Console, GWEN_LoggerFacility_User); GWEN_Logger_SetLevel("aqpaypal-tool", GWEN_LoggerLevel_Warning); GWEN_Logger_SetLevel(0, GWEN_LoggerLevel_Warning); db=GWEN_DB_Group_new("arguments"); rv=GWEN_Args_Check(argc, argv, 1, GWEN_ARGS_MODE_ALLOW_FREEPARAM | GWEN_ARGS_MODE_STOP_AT_FREEPARAM, args, db); if (rv==GWEN_ARGS_RESULT_ERROR) { fprintf(stderr, "ERROR: Could not parse arguments main\n"); return -1; } else if (rv==GWEN_ARGS_RESULT_HELP) { GWEN_BUFFER *ubuf; ubuf=GWEN_Buffer_new(0, 1024, 0, 1); GWEN_Buffer_AppendString(ubuf, I18N("Usage: ")); GWEN_Buffer_AppendString(ubuf, argv[0]); GWEN_Buffer_AppendString(ubuf, I18N(" [GLOBAL OPTIONS] COMMAND " "[LOCAL OPTIONS]\n")); GWEN_Buffer_AppendString(ubuf, I18N("\nGlobal Options:\n")); if (GWEN_Args_Usage(args, ubuf, GWEN_ArgsOutType_Txt)) { fprintf(stderr, "ERROR: Could not create help string\n"); return 1; } GWEN_Buffer_AppendString(ubuf, I18N("\nCommands:\n\n")); GWEN_Buffer_AppendString(ubuf, I18N(" listusers:\n" " blurb " "file\n\n")); GWEN_Buffer_AppendString(ubuf, I18N(" listaccounts:\n" " blurb " "file\n\n")); GWEN_Buffer_AppendString(ubuf, I18N(" adduser:\n" " blurb " "file\n\n")); GWEN_Buffer_AppendString(ubuf, I18N(" addaccount:\n" " blurb " "file\n\n")); GWEN_Buffer_AppendString(ubuf, I18N(" setsecret:\n" " blurb " "file\n\n")); fprintf(stdout, "%s\n", GWEN_Buffer_GetStart(ubuf)); GWEN_Buffer_free(ubuf); return 0; } if (rv) { argc-=rv-1; argv+=rv-1; } cmd=GWEN_DB_GetCharValue(db, "params", 0, 0); if (!cmd) { fprintf(stderr, "ERROR: Command needed.\n"); return 1; } gui=GWEN_Gui_CGui_new(); s=GWEN_DB_GetCharValue(db, "charset", 0, "ISO-8859-15"); GWEN_Gui_SetCharSet(gui, s); nonInteractive=GWEN_DB_GetIntValue(db, "nonInteractive", 0, 0); if (nonInteractive) GWEN_Gui_AddFlags(gui, GWEN_GUI_FLAGS_NONINTERACTIVE); else GWEN_Gui_SubFlags(gui, GWEN_GUI_FLAGS_NONINTERACTIVE); pinFile=GWEN_DB_GetCharValue(db, "pinFile", 0, NULL); if (pinFile) { GWEN_DB_NODE *dbPins; dbPins=GWEN_DB_Group_new("pins"); if (GWEN_DB_ReadFile(dbPins, pinFile, GWEN_DB_FLAGS_DEFAULT | GWEN_PATH_FLAGS_CREATE_GROUP)) { fprintf(stderr, "Error reading pinfile \"%s\"\n", pinFile); return 2; } /* set argument "persistent" to one in non-interactive mode */ GWEN_Gui_CGui_SetPasswordDb(gui, dbPins, nonInteractive); } GWEN_Gui_SetGui(gui); ab=AB_Banking_new("aqpaypal-tool", GWEN_DB_GetCharValue(db, "cfgfile", 0, 0), 0); AB_Gui_Extend(gui, ab); if (strcasecmp(cmd, "listusers")==0) { rv=listUsers(ab, db, argc, argv); } else if (strcasecmp(cmd, "listaccounts")==0) { rv=listAccounts(ab, db, argc, argv); } else if (strcasecmp(cmd, "adduser")==0) { rv=addUser(ab, db, argc, argv); } else if (strcasecmp(cmd, "addaccount")==0) { rv=addAccount(ab, db, argc, argv); } else if (strcasecmp(cmd, "setsecrets")==0) { rv=setSecrets(ab, db, argc, argv); } else { fprintf(stderr, "ERROR: Unknown command \"%s\".\n", cmd); rv=1; } return rv; }
int AB_Banking_SaveUserConfig(AB_BANKING *ab, AB_USER *u, int doLock) { GWEN_DB_NODE *db; GWEN_DB_NODE *dbP; int rv; assert(ab); /* check for config manager (created by AB_Banking_Init) */ if (ab->configMgr==NULL) { DBG_ERROR(AQBANKING_LOGDOMAIN, "No config manager (maybe the gwenhywfar plugins are not installed?"); return GWEN_ERROR_GENERIC; } if (doLock) { /* lock group */ rv=GWEN_ConfigMgr_LockGroup(ab->configMgr, AB_CFG_GROUP_USERS, AB_User_GetDbId(u)); if (rv<0) { DBG_ERROR(AQBANKING_LOGDOMAIN, "Unable to lock user config group (%d)", rv); return rv; } } db=GWEN_DB_Group_new("user"); AB_User_toDb(u, db); /* let the backend save its data */ dbP=GWEN_DB_GetGroup(db, GWEN_DB_FLAGS_DEFAULT, "data/backend"); rv=AB_Provider_ExtendUser(AB_User_GetProvider(u), u, AB_ProviderExtendMode_Save, dbP); if (rv) { DBG_INFO(AQBANKING_LOGDOMAIN, "here (%d)", rv); GWEN_DB_Group_free(db); if (doLock) { GWEN_ConfigMgr_UnlockGroup(ab->configMgr, AB_CFG_GROUP_USERS, AB_User_GetDbId(u)); } return rv; } /* save group (still locked) */ rv=GWEN_ConfigMgr_SetGroup(ab->configMgr, AB_CFG_GROUP_USERS, AB_User_GetDbId(u), db); if (rv<0) { DBG_ERROR(AQBANKING_LOGDOMAIN, "Could not save user group (%d)", rv); if (doLock) { GWEN_ConfigMgr_UnlockGroup(ab->configMgr, AB_CFG_GROUP_USERS, AB_User_GetDbId(u)); } GWEN_DB_Group_free(db); return rv; } GWEN_DB_Group_free(db); if (doLock) { /* unlock group */ rv=GWEN_ConfigMgr_UnlockGroup(ab->configMgr, AB_CFG_GROUP_USERS, AB_User_GetDbId(u)); if (rv<0) { DBG_ERROR(AQBANKING_LOGDOMAIN, "Could not unlock user group (%d)", rv); return rv; } } return 0; }
int AH_Msg_SignRdh2(AH_MSG *hmsg, AB_USER *su, GWEN_BUFFER *rawBuf, const char *signer) { AH_HBCI *h; GWEN_XMLNODE *node; GWEN_DB_NODE *cfg; GWEN_BUFFER *sigbuf; GWEN_BUFFER *hbuf; unsigned int l; int rv; char ctrlref[15]; const char *p; GWEN_MSGENGINE *e; uint32_t uFlags; GWEN_CRYPT_TOKEN *ct; const GWEN_CRYPT_TOKEN_CONTEXT *ctx; const GWEN_CRYPT_TOKEN_KEYINFO *ki; uint32_t keyId; uint32_t gid; assert(hmsg); h=AH_Dialog_GetHbci(hmsg->dialog); assert(h); e=AH_Dialog_GetMsgEngine(hmsg->dialog); assert(e); GWEN_MsgEngine_SetMode(e, "rdh"); gid=0; uFlags=AH_User_GetFlags(su); /* get crypt token of signer */ rv=AB_Banking_GetCryptToken(AH_HBCI_GetBankingApi(h), AH_User_GetTokenType(su), AH_User_GetTokenName(su), &ct); if (rv) { DBG_INFO(AQHBCI_LOGDOMAIN, "Could not get crypt token for user \"%s\" (%d)", AB_User_GetUserId(su), rv); return rv; } /* open CryptToken if necessary */ if (!GWEN_Crypt_Token_IsOpen(ct)) { GWEN_Crypt_Token_AddModes(ct, GWEN_CRYPT_TOKEN_MODE_DIRECT_SIGN); rv=GWEN_Crypt_Token_Open(ct, 0, gid); if (rv) { DBG_INFO(AQHBCI_LOGDOMAIN, "Could not open crypt token for user \"%s\" (%d)", AB_User_GetUserId(su), rv); return rv; } } /* get context and key info */ ctx=GWEN_Crypt_Token_GetContext(ct, AH_User_GetTokenContextId(su), gid); if (ctx==NULL) { DBG_INFO(AQHBCI_LOGDOMAIN, "Context %d not found on crypt token [%s:%s]", AH_User_GetTokenContextId(su), GWEN_Crypt_Token_GetTypeName(ct), GWEN_Crypt_Token_GetTokenName(ct)); return GWEN_ERROR_NOT_FOUND; } keyId=GWEN_Crypt_Token_Context_GetSignKeyId(ctx); ki=GWEN_Crypt_Token_GetKeyInfo(ct, keyId, 0xffffffff, gid); if (ki==NULL) { DBG_INFO(AQHBCI_LOGDOMAIN, "Keyinfo %04x not found on crypt token [%s:%s]", keyId, GWEN_Crypt_Token_GetTypeName(ct), GWEN_Crypt_Token_GetTokenName(ct)); return GWEN_ERROR_NOT_FOUND; } node=GWEN_MsgEngine_FindNodeByPropertyStrictProto(e, "SEG", "id", 0, "SigHead"); if (!node) { DBG_INFO(AQHBCI_LOGDOMAIN, "Segment \"SigHead\" not found"); return GWEN_ERROR_INTERNAL; } /* prepare config for segment */ cfg=GWEN_DB_Group_new("sighead"); rv=AH_MsgRdh_PrepareCryptoSeg2(hmsg, su, ki, cfg, 0, 1); if (rv) { DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d)", rv); GWEN_DB_Group_free(cfg); return rv; } /* set expected signer */ if (!(uFlags & AH_USER_FLAGS_BANK_DOESNT_SIGN)) { const char *remoteId; remoteId=AH_User_GetPeerId(su); if (!remoteId || *remoteId==0) remoteId=AB_User_GetUserId(su); assert(remoteId); assert(*remoteId); DBG_DEBUG(AQHBCI_LOGDOMAIN, "Expecting \"%s\" to sign the response", remoteId); AH_Msg_SetExpectedSigner(hmsg, remoteId); } /* store system id */ if (hmsg->noSysId) { GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT, "SecDetails/SecId", "0"); } else { p=AH_User_GetSystemId(su); if (p==NULL) p=GWEN_Crypt_Token_Context_GetSystemId(ctx); if (p) GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT, "SecDetails/SecId", p); else { GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT, "SecDetails/SecId", "0"); } } /* retrieve control reference for sigtail (to be used later) */ p=GWEN_DB_GetCharValue(cfg, "ctrlref", 0, ""); if (strlen(p)>=sizeof(ctrlref)) { DBG_INFO(AQHBCI_LOGDOMAIN, "Control reference too long (14 bytes maximum)"); GWEN_DB_Group_free(cfg); return -1; } strcpy(ctrlref, p); /* create SigHead */ hbuf=GWEN_Buffer_new(0, 128+GWEN_Buffer_GetUsedBytes(rawBuf), 0, 1); GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT, "head/seq", hmsg->firstSegment-1); GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT, "signseq", GWEN_Crypt_Token_KeyInfo_GetSignCounter(ki)); /* create signature head segment */ rv=GWEN_MsgEngine_CreateMessageFromNode(e, node, hbuf, cfg); GWEN_DB_Group_free(cfg); cfg=0; if (rv) { DBG_INFO(AQHBCI_LOGDOMAIN, "Could not create SigHead"); GWEN_Buffer_free(hbuf); return rv; } /* remember size of sighead for now */ l=GWEN_Buffer_GetUsedBytes(hbuf); /* add raw data to to-sign data buffer */ GWEN_Buffer_AppendBuffer(hbuf, rawBuf); /* sign message */ sigbuf=GWEN_Buffer_new(0, 512, 0, 1); if (1) { uint32_t signLen; GWEN_CRYPT_PADDALGO *algo; GWEN_MDIGEST *md; uint32_t seq; /* hash sighead + data */ md=GWEN_MDigest_Rmd160_new(); rv=GWEN_MDigest_Begin(md); if (rv==0) rv=GWEN_MDigest_Update(md, (uint8_t*)GWEN_Buffer_GetStart(hbuf), GWEN_Buffer_GetUsedBytes(hbuf)); if (rv==0) rv=GWEN_MDigest_End(md); if (rv<0) { DBG_ERROR(AQHBCI_LOGDOMAIN, "Hash error (%d)", rv); GWEN_MDigest_free(md); GWEN_Buffer_free(sigbuf); GWEN_Buffer_free(hbuf); return rv; } /* sign hash */ algo=GWEN_Crypt_PaddAlgo_new(GWEN_Crypt_PaddAlgoId_Iso9796_2); GWEN_Crypt_PaddAlgo_SetPaddSize(algo, GWEN_Crypt_Token_KeyInfo_GetKeySize(ki)); signLen=GWEN_Buffer_GetMaxUnsegmentedWrite(sigbuf); rv=GWEN_Crypt_Token_Sign(ct, keyId, algo, GWEN_MDigest_GetDigestPtr(md), GWEN_MDigest_GetDigestSize(md), (uint8_t*)GWEN_Buffer_GetPosPointer(sigbuf), &signLen, &seq, gid); GWEN_Crypt_PaddAlgo_free(algo); GWEN_MDigest_free(md); if (rv) { DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not sign data with medium of user \"%s\" (%d)", AB_User_GetUserId(su), rv); GWEN_Buffer_free(sigbuf); GWEN_Buffer_free(hbuf); return rv; } GWEN_Buffer_IncrementPos(sigbuf, signLen); GWEN_Buffer_AdjustUsedBytes(sigbuf); } DBG_DEBUG(AQHBCI_LOGDOMAIN, "Signing done"); /* insert new SigHead at beginning of message buffer */ DBG_DEBUG(AQHBCI_LOGDOMAIN, "Inserting signature head"); GWEN_Buffer_Rewind(hmsg->buffer); GWEN_Buffer_InsertBytes(hmsg->buffer, GWEN_Buffer_GetStart(hbuf), l); /* create sigtail */ DBG_DEBUG(AQHBCI_LOGDOMAIN, "Completing signature tail"); cfg=GWEN_DB_Group_new("sigtail"); GWEN_Buffer_Reset(hbuf); GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT, "head/seq", hmsg->lastSegment+1); /* store to DB */ GWEN_DB_SetBinValue(cfg, GWEN_DB_FLAGS_DEFAULT, "signature", GWEN_Buffer_GetStart(sigbuf), GWEN_Buffer_GetUsedBytes(sigbuf)); GWEN_Buffer_free(sigbuf); GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT, "ctrlref", ctrlref); /* get node */ node=GWEN_MsgEngine_FindNodeByPropertyStrictProto(e, "SEG", "id", 0, "SigTail"); if (!node) { DBG_INFO(AQHBCI_LOGDOMAIN, "Segment \"SigTail\"not found"); GWEN_Buffer_free(hbuf); GWEN_DB_Group_free(cfg); return -1; } rv=GWEN_MsgEngine_CreateMessageFromNode(e, node, hbuf, cfg); if (rv) { DBG_INFO(AQHBCI_LOGDOMAIN, "Could not create SigTail"); GWEN_Buffer_free(hbuf); GWEN_DB_Group_free(cfg); return -1; } /* append sigtail */ DBG_DEBUG(AQHBCI_LOGDOMAIN, "Appending signature tail"); if (GWEN_Buffer_AppendBuffer(hmsg->buffer, hbuf)) { DBG_INFO(AQHBCI_LOGDOMAIN, "here"); GWEN_Buffer_free(hbuf); GWEN_DB_Group_free(cfg); return -1; } DBG_DEBUG(AQHBCI_LOGDOMAIN, "Appending signature tail: done"); GWEN_Buffer_free(hbuf); GWEN_DB_Group_free(cfg); /* adjust segment numbers (for next signature and message tail */ hmsg->firstSegment--; hmsg->lastSegment++; return 0; }
int AH_Msg_EncryptRdh2(AH_MSG *hmsg) { AH_HBCI *h; GWEN_XMLNODE *node; GWEN_DB_NODE *cfg; GWEN_BUFFER *mbuf; GWEN_BUFFER *hbuf; uint32_t l; int rv; const char *p; GWEN_MSGENGINE *e; AB_USER *u; const char *peerId; // uint32_t uFlags; GWEN_CRYPT_TOKEN *ct; const GWEN_CRYPT_TOKEN_CONTEXT *ctx; const GWEN_CRYPT_TOKEN_KEYINFO *ki; uint32_t keyId; GWEN_CRYPT_KEY *sk; uint8_t encKey[300]; int encKeyLen; uint32_t gid; assert(hmsg); h=AH_Dialog_GetHbci(hmsg->dialog); assert(h); e=AH_Dialog_GetMsgEngine(hmsg->dialog); assert(e); GWEN_MsgEngine_SetMode(e, "rdh"); gid=0; u=AH_Dialog_GetDialogOwner(hmsg->dialog); // uFlags=AH_User_GetFlags(u); peerId=AH_User_GetPeerId(u); if (!peerId || *peerId==0) peerId=AB_User_GetUserId(u); /* get crypt token of signer */ rv=AB_Banking_GetCryptToken(AH_HBCI_GetBankingApi(h), AH_User_GetTokenType(u), AH_User_GetTokenName(u), &ct); if (rv) { DBG_INFO(AQHBCI_LOGDOMAIN, "Could not get crypt token for user \"%s\" (%d)", AB_User_GetUserId(u), rv); return rv; } /* open CryptToken if necessary */ if (!GWEN_Crypt_Token_IsOpen(ct)) { GWEN_Crypt_Token_AddModes(ct, GWEN_CRYPT_TOKEN_MODE_DIRECT_SIGN); rv=GWEN_Crypt_Token_Open(ct, 0, gid); if (rv) { DBG_INFO(AQHBCI_LOGDOMAIN, "Could not open crypt token for user \"%s\" (%d)", AB_User_GetUserId(u), rv); return rv; } } /* get context and key info */ ctx=GWEN_Crypt_Token_GetContext(ct, AH_User_GetTokenContextId(u), gid); if (ctx==NULL) { DBG_INFO(AQHBCI_LOGDOMAIN, "Context %d not found on crypt token [%s:%s]", AH_User_GetTokenContextId(u), GWEN_Crypt_Token_GetTypeName(ct), GWEN_Crypt_Token_GetTokenName(ct)); return GWEN_ERROR_NOT_FOUND; } keyId=GWEN_Crypt_Token_Context_GetEncipherKeyId(ctx); ki=GWEN_Crypt_Token_GetKeyInfo(ct, keyId, 0xffffffff, gid); if (ki==NULL) { DBG_INFO(AQHBCI_LOGDOMAIN, "Keyinfo %04x not found on crypt token [%s:%s]", keyId, GWEN_Crypt_Token_GetTypeName(ct), GWEN_Crypt_Token_GetTokenName(ct)); return GWEN_ERROR_NOT_FOUND; } rv=GWEN_Padd_PaddWithAnsiX9_23(hmsg->buffer); if (rv) { DBG_INFO(AQHBCI_LOGDOMAIN, "Error padding message with ANSI X9.23 (%d)", rv); return rv; } /* create session key */ sk=GWEN_Crypt_KeyDes3K_Generate(GWEN_Crypt_CryptMode_Cbc, 24, 2); if (sk==NULL) { DBG_INFO(AQHBCI_LOGDOMAIN, "Could not generate DES key"); return GWEN_ERROR_INTERNAL; } /* encrypt message with that session key */ mbuf=GWEN_Buffer_new(0, GWEN_Buffer_GetUsedBytes(hmsg->buffer), 0, 1); l=GWEN_Buffer_GetUsedBytes(hmsg->buffer); rv=GWEN_Crypt_Key_Encipher(sk, (uint8_t*)GWEN_Buffer_GetStart(hmsg->buffer), GWEN_Buffer_GetUsedBytes(hmsg->buffer), (uint8_t*)GWEN_Buffer_GetPosPointer(mbuf), &l); if (rv<0) { DBG_INFO(AQHBCI_LOGDOMAIN, "Could not encipher with DES session key (%d)", rv); GWEN_Buffer_free(mbuf); GWEN_Crypt_Key_free(sk); return rv; } GWEN_Buffer_IncrementPos(mbuf, l); GWEN_Buffer_AdjustUsedBytes(mbuf); /* encrypt session key */ if (1) { uint32_t elen; GWEN_CRYPT_PADDALGO *algo; algo=GWEN_Crypt_PaddAlgo_new(GWEN_Crypt_PaddAlgoId_LeftZero); GWEN_Crypt_PaddAlgo_SetPaddSize(algo, GWEN_Crypt_Token_KeyInfo_GetKeySize(ki)); elen=sizeof(encKey); rv=GWEN_Crypt_Token_Encipher(ct, keyId, algo, GWEN_Crypt_KeyDes3K_GetKeyDataPtr(sk), 16, encKey, &elen, gid); GWEN_Crypt_PaddAlgo_free(algo); if (rv<0) { DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d)", rv); GWEN_Buffer_free(mbuf); GWEN_Crypt_Key_free(sk); return rv; } encKeyLen=elen; } GWEN_Crypt_Key_free(sk); /* create crypt head */ node=GWEN_MsgEngine_FindNodeByPropertyStrictProto(e, "SEG", "id", 0, "CryptHead"); if (!node) { DBG_INFO(AQHBCI_LOGDOMAIN, "Segment \"CryptHead\" not found"); GWEN_Buffer_free(mbuf); GWEN_Crypt_Key_free(sk); return GWEN_ERROR_INTERNAL; } /* create CryptHead */ cfg=GWEN_DB_Group_new("crypthead"); GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT, "head/seq", 998); rv=AH_MsgRdh_PrepareCryptoSeg2(hmsg, u, ki, cfg, 1, 0); if (rv) { DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d)", rv); GWEN_DB_Group_free(cfg); GWEN_Buffer_free(mbuf); return rv; } /* store system id */ if (hmsg->noSysId) { GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT, "SecDetails/SecId", "0"); } else { p=AH_User_GetSystemId(u); if (p==NULL) p=GWEN_Crypt_Token_Context_GetSystemId(ctx); if (p) GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT, "SecDetails/SecId", p); else { DBG_INFO(AQHBCI_LOGDOMAIN, "No System id on RDH medium, using default"); GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT, "SecDetails/SecId", "0"); } } /* store encrypted message key */ GWEN_DB_SetBinValue(cfg, GWEN_DB_FLAGS_DEFAULT, "CryptAlgo/MsgKey", encKey, encKeyLen); hbuf=GWEN_Buffer_new(0, 256+GWEN_Buffer_GetUsedBytes(mbuf), 0, 1); rv=GWEN_MsgEngine_CreateMessageFromNode(e, node, hbuf, cfg); if (rv) { DBG_INFO(AQHBCI_LOGDOMAIN, "Could not create CryptHead (%d)", rv); GWEN_Buffer_free(hbuf); GWEN_DB_Group_free(cfg); GWEN_Buffer_free(mbuf); return rv; } GWEN_DB_Group_free(cfg); /* create cryptdata */ cfg=GWEN_DB_Group_new("cryptdata"); GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT, "head/seq", 999); GWEN_DB_SetBinValue(cfg, GWEN_DB_FLAGS_DEFAULT, "cryptdata", GWEN_Buffer_GetStart(mbuf), GWEN_Buffer_GetUsedBytes(mbuf)); GWEN_Buffer_free(mbuf); node=GWEN_MsgEngine_FindNodeByPropertyStrictProto(e, "SEG", "id", 0, "CryptData"); if (!node) { DBG_INFO(AQHBCI_LOGDOMAIN, "Segment \"CryptData\"not found"); GWEN_Buffer_free(hbuf); GWEN_DB_Group_free(cfg); return -1; } rv=GWEN_MsgEngine_CreateMessageFromNode(e, node, hbuf, cfg); if (rv) { DBG_INFO(AQHBCI_LOGDOMAIN, "Could not create CryptData (%d)", rv); GWEN_Buffer_free(hbuf); GWEN_DB_Group_free(cfg); return rv; } /* replace existing buffer by encrypted one */ GWEN_Buffer_free(hmsg->buffer); hmsg->buffer=hbuf; GWEN_DB_Group_free(cfg); return 0; }
/* --------------------------------------------------------------- FUNCTION */ int AH_Job_GetTransactions_Process(AH_JOB *j, AB_IMEXPORTER_CONTEXT *ctx) { AH_JOB_GETTRANSACTIONS *aj; AB_ACCOUNT *a; AB_IMEXPORTER_ACCOUNTINFO *ai; GWEN_DB_NODE *dbResponses; GWEN_DB_NODE *dbCurr; GWEN_BUFFER *tbooked; GWEN_BUFFER *tnoted; int rv; DBG_INFO(AQHBCI_LOGDOMAIN, "Processing JobGetTransactions"); assert(j); aj=GWEN_INHERIT_GETDATA(AH_JOB, AH_JOB_GETTRANSACTIONS, j); assert(aj); tbooked=GWEN_Buffer_new(0, 1024, 0, 1); tnoted=GWEN_Buffer_new(0, 1024, 0, 1); dbResponses=AH_Job_GetResponses(j); assert(dbResponses); /* search for "Transactions" */ dbCurr=GWEN_DB_GetFirstGroup(dbResponses); while (dbCurr) { GWEN_DB_NODE *dbXA; rv=AH_Job_CheckEncryption(j, dbCurr); if (rv) { DBG_INFO(AQHBCI_LOGDOMAIN, "Compromised security (encryption)"); GWEN_Buffer_free(tbooked); GWEN_Buffer_free(tnoted); AH_Job_SetStatus(j, AH_JobStatusError); return rv; } rv=AH_Job_CheckSignature(j, dbCurr); if (rv) { DBG_INFO(AQHBCI_LOGDOMAIN, "Compromised security (signature)"); GWEN_Buffer_free(tbooked); GWEN_Buffer_free(tnoted); AH_Job_SetStatus(j, AH_JobStatusError); return rv; } dbXA=GWEN_DB_GetGroup(dbCurr, GWEN_PATH_FLAGS_NAMEMUSTEXIST, "data/transactions"); if (dbXA) { const void *p; unsigned int bs; if (GWEN_Logger_GetLevel(0)>=GWEN_LoggerLevel_Debug) GWEN_DB_Dump(dbXA, 2); p=GWEN_DB_GetBinValue(dbXA, "booked", 0, 0, 0, &bs); if (p && bs) GWEN_Buffer_AppendBytes(tbooked, p, bs); p=GWEN_DB_GetBinValue(dbXA, "noted", 0, 0, 0, &bs); if (p && bs) GWEN_Buffer_AppendBytes(tnoted, p, bs); } /* if "Transactions" */ dbCurr=GWEN_DB_GetNextGroup(dbCurr); } GWEN_Buffer_Rewind(tbooked); GWEN_Buffer_Rewind(tnoted); /* now the buffers contain data to be parsed by DBIOs */ a=AH_AccountJob_GetAccount(j); assert(a); ai=AB_ImExporterContext_GetOrAddAccountInfo(ctx, AB_Account_GetUniqueId(a), AB_Account_GetIban(a), AB_Account_GetBankCode(a), AB_Account_GetAccountNumber(a), AB_Account_GetAccountType(a)); assert(ai); /* read booked transactions */ if (GWEN_Buffer_GetUsedBytes(tbooked)) { if (getenv("AQHBCI_LOGBOOKED")) { FILE *f; f=fopen("/tmp/booked.mt", "w+"); if (f) { if (fwrite(GWEN_Buffer_GetStart(tbooked), GWEN_Buffer_GetUsedBytes(tbooked), 1, f)!=1) { DBG_ERROR(AQHBCI_LOGDOMAIN, "fwrite: %s", strerror(errno)); } if (fclose(f)) { DBG_ERROR(AQHBCI_LOGDOMAIN, "fclose: %s", strerror(errno)); } } } if (AH_Job_GetTransactions__ReadTransactions(j, ai, "SWIFT-MT940", AB_Transaction_TypeStatement, (const uint8_t *) GWEN_Buffer_GetStart(tbooked), GWEN_Buffer_GetUsedBytes(tbooked))) { GWEN_Buffer_free(tbooked); GWEN_Buffer_free(tnoted); DBG_INFO(AQHBCI_LOGDOMAIN, "Error parsing booked transactions"); AH_Job_SetStatus(j, AH_JobStatusError); return -1; } } /* read noted transactions */ if (GWEN_Buffer_GetUsedBytes(tnoted)) { if (getenv("AQHBCI_LOGNOTED")) { FILE *f; f=fopen("/tmp/noted.mt", "w+"); if (f) { if (fwrite(GWEN_Buffer_GetStart(tnoted), GWEN_Buffer_GetUsedBytes(tnoted), 1, f)!=1) { DBG_ERROR(AQHBCI_LOGDOMAIN, "fwrite: %s", strerror(errno)); } if (fclose(f)) { DBG_ERROR(AQHBCI_LOGDOMAIN, "fclose: %s", strerror(errno)); } } } if (AH_Job_GetTransactions__ReadTransactions(j, ai, "SWIFT-MT942", AB_Transaction_TypeNotedStatement, (const uint8_t *) GWEN_Buffer_GetStart(tnoted), GWEN_Buffer_GetUsedBytes(tnoted))) { GWEN_Buffer_free(tbooked); GWEN_Buffer_free(tnoted); DBG_INFO(AQHBCI_LOGDOMAIN, "Error parsing noted transactions"); AH_Job_SetStatus(j, AH_JobStatusError); return -1; } } if (GWEN_Logger_GetLevel(AQHBCI_LOGDOMAIN)>=GWEN_LoggerLevel_Debug) { GWEN_DB_NODE *gn; AB_TRANSACTION *ttmp; DBG_INFO(AQHBCI_LOGDOMAIN, "*** Dumping transactions *******************"); ttmp=AB_ImExporterAccountInfo_GetFirstTransaction(ai, 0, 0); while (ttmp) { DBG_INFO(AQHBCI_LOGDOMAIN, "*** --------------------------------------"); gn=GWEN_DB_Group_new("transaction"); AB_Transaction_toDb(ttmp, gn); GWEN_DB_Dump(gn, 2); GWEN_DB_Group_free(gn); ttmp=AB_Transaction_List_Next(ttmp); } DBG_INFO(AQHBCI_LOGDOMAIN, "*** End dumping transactions ***************"); } GWEN_Buffer_free(tbooked); GWEN_Buffer_free(tnoted); return 0; }
int main(int argc, char **argv) { GWEN_DB_NODE *db; const char *cmd; int rv; int err; GWEN_GUI *gui; const GWEN_ARGS args[]={ { GWEN_ARGS_FLAGS_HELP | GWEN_ARGS_FLAGS_LAST, /* flags */ GWEN_ArgsType_Int, /* type */ "help", /* name */ 0, /* minnum */ 0, /* maxnum */ "h", /* short option */ "help", /* long option */ "Show this help screen", /* short description */ "Show this help screen" /* long description */ } }; err=GWEN_Init(); if (err) { fprintf(stderr, "Could not initialize Gwenhywfar.\n"); return 2; } gui=GWEN_Gui_CGui_new(); GWEN_Gui_SetGui(gui); GWEN_Logger_Open(GSA_LOGDOMAIN, "gsa", 0, GWEN_LoggerType_Console, GWEN_LoggerFacility_User); GWEN_Logger_SetLevel(GSA_LOGDOMAIN, GWEN_LoggerLevel_Warning); GWEN_Logger_SetLevel(0, GWEN_LoggerLevel_Warning); #ifdef GSA_IS_EXPERIMENTAL fprintf(stderr, "\n"); fprintf(stderr, "\n"); fprintf(stderr, "=================== WARNING ===================\n"); fprintf(stderr, "This tool is still EXPERIMENTAL !!!\n"); fprintf(stderr, "Please DON'T USE it with your data files !\n"); fprintf(stderr, "===============================================\n"); fprintf(stderr, "\n"); fprintf(stderr, "\n"); #endif db=GWEN_DB_Group_new("arguments"); rv=GWEN_Args_Check(argc, argv, 1, GWEN_ARGS_MODE_ALLOW_FREEPARAM | GWEN_ARGS_MODE_STOP_AT_FREEPARAM, args, db); if (rv==GWEN_ARGS_RESULT_ERROR) { fprintf(stderr, "ERROR: Could not parse arguments main\n"); return -1; } else if (rv==GWEN_ARGS_RESULT_HELP) { GWEN_BUFFER *ubuf; ubuf=GWEN_Buffer_new(0, 1024, 0, 1); GWEN_Buffer_AppendString(ubuf, I18N("GWEN's Simple Archiver")); GWEN_Buffer_AppendString(ubuf, " (Gwenhywfar v" GWENHYWFAR_VERSION_FULL_STRING ")\n"); GWEN_Buffer_AppendString(ubuf, I18N("Usage: ")); GWEN_Buffer_AppendString(ubuf, argv[0]); GWEN_Buffer_AppendString(ubuf, I18N(" [GLOBAL OPTIONS] COMMAND " "[LOCAL OPTIONS]\n")); GWEN_Buffer_AppendString(ubuf, I18N("\nGlobal Options:\n")); if (GWEN_Args_Usage(args, ubuf, GWEN_ArgsOutType_Txt)) { fprintf(stderr, "ERROR: Could not create help string\n"); return 1; } GWEN_Buffer_AppendString(ubuf, I18N("\nCommands:\n\n")); GWEN_Buffer_AppendString(ubuf, I18N(" create:\n" " This command creates an archive file" "\n\n")); GWEN_Buffer_AppendString(ubuf, I18N(" add:\n" " Add files and folders to an archive file\n\n")); GWEN_Buffer_AppendString(ubuf, I18N(" list:\n" " List files and folders in an archive file\n\n")); GWEN_Buffer_AppendString(ubuf, I18N(" check:\n" " Check integrity of files and folders in an archive file\n\n")); fprintf(stderr, "%s\n", GWEN_Buffer_GetStart(ubuf)); GWEN_Buffer_free(ubuf); return 0; } if (rv) { argc-=rv-1; argv+=rv-1; } cmd=GWEN_DB_GetCharValue(db, "params", 0, 0); if (!cmd) { fprintf(stderr, "ERROR: Command needed.\n"); return 1; } if (strcasecmp(cmd, "create")==0) { rv=createArchive(db, argc, argv); } else if (strcasecmp(cmd, "add")==0) { rv=add2Archive(db, argc, argv); } else if (strcasecmp(cmd, "list")==0) { rv=listArchive(db, argc, argv); } else if (strcasecmp(cmd, "check")==0) { rv=checkArchive(db, argc, argv); } else if (strcasecmp(cmd, "extract")==0) { rv=extractArchive(db, argc, argv); } else if (strcasecmp(cmd, "sign")==0) { rv=signArchive(db, argc, argv); } else if (strcasecmp(cmd, "verify")==0) { rv=verifyArchive(db, argc, argv); } else if (strcasecmp(cmd, "mkkey")==0) { rv=mkArchiveKey(db, argc, argv); } else if (strcasecmp(cmd, "rfi")==0) { rv=releaseFillIn(db, argc, argv); } else { fprintf(stderr, "ERROR: Unknown command \"%s\".\n", cmd); rv=1; } err=GWEN_Fini(); if (err) { fprintf(stderr, "WARNING: Could not deinitialize Gwenhywfar.\n"); } return rv; }
static int _readLogFile(const char *fname, GWEN_DB_NODE *db) { GWEN_SYNCIO *sio; GWEN_FAST_BUFFER *fb; int rv; GWEN_BUFFER *tbuf = NULL; sio=GWEN_SyncIo_File_new(fname, GWEN_SyncIo_File_CreationMode_OpenExisting); GWEN_SyncIo_AddFlags(sio, GWEN_SYNCIO_FILE_FLAGS_READ); rv=GWEN_SyncIo_Connect(sio); if (rv<0) { DBG_ERROR(0, "Error opening file [%s] (%d)", fname, rv); return rv; } /* create fast buffer around io layer */ fb=GWEN_FastBuffer_new(1024, sio); for (;;) { GWEN_DB_NODE *dbMsg; GWEN_DB_NODE *dbHeader; unsigned int size; /* read header */ dbMsg=GWEN_DB_Group_new("Message"); dbHeader=GWEN_DB_GetGroup(dbMsg, GWEN_DB_FLAGS_DEFAULT, "header"); rv=GWEN_DB_ReadFromFastBuffer(dbHeader, fb, GWEN_DB_FLAGS_HTTP | GWEN_DB_FLAGS_UNTIL_EMPTY_LINE); if (rv<0) { if (rv==GWEN_ERROR_EOF) break; else { GWEN_DB_Group_free(dbMsg); GWEN_FastBuffer_free(fb); GWEN_SyncIo_Disconnect(sio); GWEN_SyncIo_free(sio); DBG_ERROR(0, "Error reading header from file [%s] (%d)", fname, rv); GWEN_DB_Dump(db, 2); return rv; } } /* read body */ size=GWEN_DB_GetIntValue(dbHeader, "size", 0, 0); tbuf=GWEN_Buffer_new(0, 2048, 0, 1); while(size) { unsigned int lsize; uint8_t buffer[1024]; lsize=size; if (lsize>sizeof(buffer)) lsize=sizeof(buffer); GWEN_FASTBUFFER_READFORCED(fb, rv, buffer, lsize); if (rv<0) { GWEN_DB_Group_free(dbMsg); GWEN_FastBuffer_free(fb); GWEN_SyncIo_Disconnect(sio); GWEN_SyncIo_free(sio); DBG_ERROR(0, "Error reading body from file [%s] (%d)", fname, rv); return rv; } GWEN_Buffer_AppendBytes(tbuf, (const char*)buffer, lsize); size-=lsize; } // while GWEN_DB_SetBinValue(dbMsg, GWEN_DB_FLAGS_OVERWRITE_VARS, "body", GWEN_Buffer_GetStart(tbuf), GWEN_Buffer_GetUsedBytes(tbuf)); GWEN_Buffer_Reset(tbuf); GWEN_DB_AddGroup(db, dbMsg); } GWEN_Buffer_free(tbuf); GWEN_FastBuffer_free(fb); GWEN_SyncIo_Disconnect(sio); GWEN_SyncIo_free(sio); return 0; }
int AH_Msg_SignPinTan(AH_MSG *hmsg, GWEN_BUFFER *rawBuf, const char *signer) { AH_HBCI *h; GWEN_XMLNODE *node; GWEN_DB_NODE *cfg; GWEN_BUFFER *hbuf; int rv; char ctrlref[15]; const char *p; GWEN_MSGENGINE *e; AB_USER *su; uint32_t uFlags; char pin[64]; uint32_t tm; assert(hmsg); h=AH_Dialog_GetHbci(hmsg->dialog); assert(h); e=AH_Dialog_GetMsgEngine(hmsg->dialog); assert(e); GWEN_MsgEngine_SetMode(e, "pintan"); su=AB_Banking_FindUser(AH_HBCI_GetBankingApi(h), AH_PROVIDER_NAME, "de", "*", signer, "*"); if (!su) { DBG_ERROR(AQHBCI_LOGDOMAIN, "Unknown user \"%s\"", signer); return GWEN_ERROR_NOT_FOUND; } uFlags=AH_User_GetFlags(su); node=GWEN_MsgEngine_FindNodeByPropertyStrictProto(e, "SEG", "id", 0, "SigHead"); if (!node) { DBG_INFO(AQHBCI_LOGDOMAIN, "Segment \"SigHead\" not found"); return GWEN_ERROR_INTERNAL; } /* for iTAN mode: set selected mode (Sicherheitsfunktion, kodiert) */ tm=AH_Msg_GetItanMethod(hmsg); if (tm==0) { tm=AH_Dialog_GetItanMethod(hmsg->dialog); if (tm) /* this is needed by AH_MsgPinTan_PrepareCryptoSeg */ AH_Msg_SetItanMethod(hmsg, tm); } /* prepare config for segment */ cfg=GWEN_DB_Group_new("sighead"); rv=AH_MsgPinTan_PrepareCryptoSeg(hmsg, su, cfg, 0, 1); if (rv) { DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d)", rv); GWEN_DB_Group_free(cfg); return rv; } /* set expected signer */ if (!(uFlags & AH_USER_FLAGS_BANK_DOESNT_SIGN)) { const char *remoteId; remoteId=AH_User_GetPeerId(su); if (!remoteId || *remoteId==0) remoteId=AB_User_GetUserId(su); assert(remoteId); assert(*remoteId); DBG_DEBUG(AQHBCI_LOGDOMAIN, "Expecting \"%s\" to sign the response", remoteId); AH_Msg_SetExpectedSigner(hmsg, remoteId); } /* store system id */ p=NULL; if (!hmsg->noSysId) p=AH_User_GetSystemId(su); if (!p) p="0"; GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT, "SecDetails/SecId", p); if (tm) { GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT, "function", tm); } /* retrieve control reference for sigtail (to be used later) */ p=GWEN_DB_GetCharValue(cfg, "ctrlref", 0, ""); if (strlen(p)>=sizeof(ctrlref)) { DBG_INFO(AQHBCI_LOGDOMAIN, "Control reference too long (14 bytes maximum)"); GWEN_DB_Group_free(cfg); return -1; } strcpy(ctrlref, p); /* create SigHead */ hbuf=GWEN_Buffer_new(0, 128+GWEN_Buffer_GetUsedBytes(rawBuf), 0, 1); GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT, "head/seq", hmsg->firstSegment-1); GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT, "signseq", 1); /* create signature head segment */ rv=GWEN_MsgEngine_CreateMessageFromNode(e, node, hbuf, cfg); GWEN_DB_Group_free(cfg); cfg=0; if (rv) { DBG_INFO(AQHBCI_LOGDOMAIN, "Could not create SigHead"); GWEN_Buffer_free(hbuf); return rv; } /* insert new SigHead at beginning of message buffer */ DBG_DEBUG(AQHBCI_LOGDOMAIN, "Inserting signature head"); GWEN_Buffer_Rewind(hmsg->buffer); GWEN_Buffer_InsertBytes(hmsg->buffer, GWEN_Buffer_GetStart(hbuf), GWEN_Buffer_GetUsedBytes(hbuf)); /* create sigtail */ DBG_DEBUG(AQHBCI_LOGDOMAIN, "Completing signature tail"); cfg=GWEN_DB_Group_new("sigtail"); GWEN_Buffer_Reset(hbuf); GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT, "head/seq", hmsg->lastSegment+1); /* store to DB */ GWEN_DB_SetBinValue(cfg, GWEN_DB_FLAGS_DEFAULT, "signature", "NOSIGNATURE", 11); GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT, "ctrlref", ctrlref); /* handle pin */ memset(pin, 0, sizeof(pin)); rv=AH_User_InputPin(su, pin, 4, sizeof(pin), 0); if (rv<0) { DBG_ERROR(AQHBCI_LOGDOMAIN, "Error getting pin from medium (%d)", rv); GWEN_DB_Group_free(cfg); GWEN_Buffer_free(hbuf); memset(pin, 0, sizeof(pin)); return rv; } GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT, "pin", pin); AH_Msg_SetPin(hmsg, pin); memset(pin, 0, sizeof(pin)); /* handle tan */ if (hmsg->needTan) { DBG_NOTICE(AQHBCI_LOGDOMAIN, "This queue needs a TAN"); if (hmsg->usedTan) { DBG_NOTICE(AQHBCI_LOGDOMAIN, "Using existing TAN"); GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT, "tan", hmsg->usedTan); } else { char tan[16]; memset(tan, 0, sizeof(tan)); DBG_NOTICE(AQHBCI_LOGDOMAIN, "Asking for TAN"); rv=AH_User_InputTan(su, tan, 4, sizeof(tan)); if (rv<0) { DBG_ERROR(AQHBCI_LOGDOMAIN, "Error getting TAN from medium"); GWEN_DB_Group_free(cfg); GWEN_Buffer_free(hbuf); return rv; } GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT, "tan", tan); AH_Msg_SetTan(hmsg, tan); } } else { DBG_NOTICE(AQHBCI_LOGDOMAIN, "This queue doesn't need a TAN"); } /* get node */ node=GWEN_MsgEngine_FindNodeByPropertyStrictProto(e, "SEG", "id", 0, "SigTail"); if (!node) { DBG_INFO(AQHBCI_LOGDOMAIN, "Segment \"SigTail\"not found"); GWEN_Buffer_free(hbuf); GWEN_DB_Group_free(cfg); return GWEN_ERROR_INTERNAL; } rv=GWEN_MsgEngine_CreateMessageFromNode(e, node, hbuf, cfg); if (rv) { DBG_INFO(AQHBCI_LOGDOMAIN, "Could not create SigTail (%d)", rv); GWEN_Buffer_free(hbuf); GWEN_DB_Group_free(cfg); return rv; } /* append sigtail */ DBG_DEBUG(AQHBCI_LOGDOMAIN, "Appending signature tail"); if (GWEN_Buffer_AppendBuffer(hmsg->buffer, hbuf)) { DBG_INFO(AQHBCI_LOGDOMAIN, "here"); GWEN_Buffer_free(hbuf); GWEN_DB_Group_free(cfg); return GWEN_ERROR_MEMORY_FULL; } DBG_DEBUG(AQHBCI_LOGDOMAIN, "Appending signature tail: done"); GWEN_Buffer_free(hbuf); GWEN_DB_Group_free(cfg); /* adjust segment numbers (for next signature and message tail */ hmsg->firstSegment--; hmsg->lastSegment++; return 0; }
int main(int argc, char **argv) { int rv; GWEN_DB_NODE *db; const char *s; LC_CLIENT *cl; LC_CLIENT_RESULT res; GWEN_GUI *gui; int v; gui=GWEN_Gui_CGui_new(); GWEN_Gui_SetGui(gui); db=GWEN_DB_Group_new("arguments"); rv=GWEN_Args_Check(argc, argv, 1, GWEN_ARGS_MODE_ALLOW_FREEPARAM, prg_args, db); if (rv==GWEN_ARGS_RESULT_HELP) { GWEN_BUFFER *ubuf; ubuf=GWEN_Buffer_new(0, 256, 0, 1); if (GWEN_Args_Usage(prg_args, ubuf, GWEN_ArgsOutType_Txt)) { fprintf(stderr, "Could not generate usage string.\n"); GWEN_Buffer_free(ubuf); return RETURNVALUE_PARAM; } usage(argv[0], GWEN_Buffer_GetStart(ubuf)); GWEN_Buffer_free(ubuf); return 0; } if (rv<1) { fprintf(stderr, "ERROR: Error in argument list (%d)\n", rv); return RETURNVALUE_PARAM; } v=GWEN_DB_GetIntValue(db, "verbosity", 0, 0); if (v<2) GWEN_Gui_AddFlags(gui, GWEN_GUI_FLAGS_NONINTERACTIVE); /* get command */ s=GWEN_DB_GetCharValue(db, "params", 0, 0); if (!s) { fprintf(stderr, "No command given.\n"); GWEN_DB_Group_free(db); return RETURNVALUE_PARAM; } cl=LC_Client_new("kvkcard", PROGRAM_VERSION); res=LC_Client_Init(cl); if (res!=LC_Client_ResultOk) { showError(0, res, "Init"); return RETURNVALUE_SETUP; } /* handle command */ if (strcasecmp(s, "read")==0) { rv=kvkRead(cl, db); } else if (strcasecmp(s, "daemon")==0) { fprintf(stderr, "KVK daemon no longer supported.\n"); return RETURNVALUE_SETUP; } else if (strcasecmp(s, "rdvd")==0) { rv=rdvd(cl, db); } else if (strcasecmp(s, "rdpd")==0) { rv=rdpd(cl, db); } else if (strcasecmp(s, "psvd")==0) { rv=psvd(cl, db); } else { fprintf(stderr, "Unknown command \"%s\"", s); rv=RETURNVALUE_PARAM; } LC_Client_free(cl); GWEN_DB_Group_free(db); return 0; }
int AH_Msg_EncryptPinTan(AH_MSG *hmsg) { AH_HBCI *h; GWEN_XMLNODE *node; GWEN_DB_NODE *cfg; GWEN_BUFFER *hbuf; int rv; const char *p; GWEN_MSGENGINE *e; AB_USER *u; const char *peerId; // uint32_t uFlags; assert(hmsg); h=AH_Dialog_GetHbci(hmsg->dialog); assert(h); e=AH_Dialog_GetMsgEngine(hmsg->dialog); assert(e); GWEN_MsgEngine_SetMode(e, "pintan"); u=AH_Dialog_GetDialogOwner(hmsg->dialog); // uFlags=AH_User_GetFlags(u); peerId=AH_User_GetPeerId(u); if (!peerId || *peerId==0) peerId=AB_User_GetUserId(u); /* create crypt head */ node=GWEN_MsgEngine_FindNodeByPropertyStrictProto(e, "SEG", "id", 0, "CryptHead"); if (!node) { DBG_INFO(AQHBCI_LOGDOMAIN, "Segment \"CryptHead\" not found"); return GWEN_ERROR_INTERNAL; } /* create CryptHead */ cfg=GWEN_DB_Group_new("crypthead"); GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT, "head/seq", 998); rv=AH_MsgPinTan_PrepareCryptoSeg(hmsg, u, cfg, 1, 0); if (rv) { DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d)", rv); GWEN_DB_Group_free(cfg); return rv; } /* store system id */ p=NULL; if (!hmsg->noSysId) p=AH_User_GetSystemId(u); if (!p) p="0"; GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT, "SecDetails/SecId", p); /* store encrypted message key */ GWEN_DB_SetBinValue(cfg, GWEN_DB_FLAGS_DEFAULT, "CryptAlgo/MsgKey", "NOKEY", 5); hbuf=GWEN_Buffer_new(0, 256+GWEN_Buffer_GetUsedBytes(hmsg->buffer), 0, 1); rv=GWEN_MsgEngine_CreateMessageFromNode(e, node, hbuf, cfg); if (rv) { DBG_INFO(AQHBCI_LOGDOMAIN, "Could not create CryptHead (%d)", rv); GWEN_Buffer_free(hbuf); GWEN_DB_Group_free(cfg); return rv; } GWEN_DB_Group_free(cfg); /* create cryptdata */ cfg=GWEN_DB_Group_new("cryptdata"); GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT, "head/seq", 999); GWEN_DB_SetBinValue(cfg, GWEN_DB_FLAGS_DEFAULT, "cryptdata", GWEN_Buffer_GetStart(hmsg->buffer), GWEN_Buffer_GetUsedBytes(hmsg->buffer)); node=GWEN_MsgEngine_FindNodeByPropertyStrictProto(e, "SEG", "id", 0, "CryptData"); if (!node) { DBG_INFO(AQHBCI_LOGDOMAIN, "Segment \"CryptData\"not found"); GWEN_Buffer_free(hbuf); GWEN_DB_Group_free(cfg); return -1; } rv=GWEN_MsgEngine_CreateMessageFromNode(e, node, hbuf, cfg); if (rv) { DBG_INFO(AQHBCI_LOGDOMAIN, "Could not create CryptData (%d)", rv); GWEN_Buffer_free(hbuf); GWEN_DB_Group_free(cfg); return rv; } /* replace existing buffer by encrypted one */ GWEN_Buffer_free(hmsg->buffer); hmsg->buffer=hbuf; GWEN_DB_Group_free(cfg); return 0; }
int main(int argc, char **argv) { GWEN_DB_NODE *db; const char *cmd; int rv; int err; GWEN_GUI *gui; const char *localedir; GWEN_STRINGLIST *slist; const GWEN_ARGS args[]={ { GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */ GWEN_ArgsType_Char, /* type */ "cfgfile", /* name */ 0, /* minnum */ 1, /* maxnum */ "C", /* short option */ "cfgfile", /* long option */ "Specify the configuration file", /* short description */ "Specify the configuration file" /* long description */ }, { 0, /* flags */ GWEN_ArgsType_Int, /* type */ "forcePin", /* name */ 0, /* minnum */ 1, /* maxnum */ 0, /* short option */ "forcepin", /* long option */ "force pin entry", /* short description */ "force pin entry even if the error counter is not zero" }, { GWEN_ARGS_FLAGS_HELP | GWEN_ARGS_FLAGS_LAST, /* flags */ GWEN_ArgsType_Int, /* type */ "help", /* name */ 0, /* minnum */ 0, /* maxnum */ "h", /* short option */ "help", /* long option */ "Show this help screen", /* short description */ "Show this help screen" /* long description */ } }; err=GWEN_Init(); if (err) { fprintf(stderr, "Could not initialize Gwenhywfar.\n"); return 2; } gui=GWEN_Gui_CGui_new(); GWEN_Gui_SetGui(gui); slist = GWEN_PathManager_GetPaths(GWEN_PM_LIBNAME, GWEN_PM_LOCALEDIR); assert(GWEN_StringList_Count(slist) > 0); localedir = GWEN_StringList_FirstString(slist); #ifdef HAVE_I18N setlocale(LC_ALL,""); if (bindtextdomain(PACKAGE, localedir)==0) fprintf(stderr, "Error binding locale\n"); #endif GWEN_StringList_free(slist); GWEN_Logger_Open(GCT_LOGDOMAIN, "gct-tool", 0, GWEN_LoggerType_Console, GWEN_LoggerFacility_User); #ifdef DEBUG_GCT_TOOL GWEN_Logger_SetLevel(GCT_LOGDOMAIN, GWEN_LoggerLevel_Info); GWEN_Logger_SetLevel(GWEN_LOGDOMAIN, GWEN_LoggerLevel_Debug); GWEN_Logger_SetLevel(0, GWEN_LoggerLevel_Info); #else GWEN_Logger_SetLevel(GCT_LOGDOMAIN, GWEN_LoggerLevel_Warning); GWEN_Logger_SetLevel(GWEN_LOGDOMAIN, GWEN_LoggerLevel_Warning); GWEN_Logger_SetLevel(0, GWEN_LoggerLevel_Warning); #endif #ifdef GCT_IS_EXPERIMENTAL fprintf(stderr, "\n"); fprintf(stderr, "\n"); fprintf(stderr, "=================== WARNING ===================\n"); fprintf(stderr, "This tool is still EXPERIMENTAL !!!\n"); fprintf(stderr, "Please DON'T USE it with your daily key files !\n"); fprintf(stderr, "===============================================\n"); fprintf(stderr, "\n"); fprintf(stderr, "\n"); #endif db=GWEN_DB_Group_new("arguments"); rv=GWEN_Args_Check(argc, argv, 1, GWEN_ARGS_MODE_ALLOW_FREEPARAM | GWEN_ARGS_MODE_STOP_AT_FREEPARAM, args, db); if (rv==GWEN_ARGS_RESULT_ERROR) { fprintf(stderr, "ERROR: Could not parse arguments main\n"); return -1; } else if (rv==GWEN_ARGS_RESULT_HELP) { GWEN_BUFFER *ubuf; ubuf=GWEN_Buffer_new(0, 1024, 0, 1); GWEN_Buffer_AppendString(ubuf, I18N("Usage: ")); GWEN_Buffer_AppendString(ubuf, argv[0]); GWEN_Buffer_AppendString(ubuf, I18N(" [GLOBAL OPTIONS] COMMAND " "[LOCAL OPTIONS]\n")); GWEN_Buffer_AppendString(ubuf, I18N("\nGlobal Options:\n")); if (GWEN_Args_Usage(args, ubuf, GWEN_ArgsOutType_Txt)) { fprintf(stderr, "ERROR: Could not create help string\n"); return 1; } GWEN_Buffer_AppendString(ubuf, I18N("\nCommands:\n\n")); GWEN_Buffer_AppendString(ubuf, I18N(" create:\n" " This command creates a crypt token" "\n\n")); GWEN_Buffer_AppendString(ubuf, I18N(" showuser:\n" " Display user data stored on the " "token\n\n")); fprintf(stderr, "%s\n", GWEN_Buffer_GetStart(ubuf)); GWEN_Buffer_free(ubuf); return 0; } if (rv) { argc-=rv-1; argv+=rv-1; } cmd=GWEN_DB_GetCharValue(db, "params", 0, 0); if (!cmd) { fprintf(stderr, "ERROR: Command needed.\n"); return 1; } if (strcasecmp(cmd, "sign1")==0) { rv=signWithOld(db, argc, argv); } else if (strcasecmp(cmd, "sign2")==0) { rv=signWithNew(db, argc, argv); } else if (strcasecmp(cmd, "crypt1")==0) { rv=cryptWithOld(db, argc, argv); } else if (strcasecmp(cmd, "crypt2")==0) { rv=cryptWithNew(db, argc, argv); } else if (strcasecmp(cmd, "crypt3")==0) { rv=cryptWithNew2(db, argc, argv); } else { fprintf(stderr, "ERROR: Unknown command \"%s\".\n", cmd); rv=1; } err=GWEN_Fini(); if (err) { fprintf(stderr, "WARNING: Could not deinitialize Gwenhywfar.\n"); } return rv; }
int GWEN_PathManager_ModuleInit(void) { gwen__paths=GWEN_DB_Group_new("paths"); return 0; }
int logFile(AB_BANKING *ab, GWEN_DB_NODE *dbArgs, int argc, char **argv) { int rv; GWEN_DB_NODE *db; GWEN_DB_NODE *dbMessages; const char *s; GWEN_MSGENGINE *e; GWEN_SYNCIO *sioOut=NULL; GWEN_SYNCIO *sioDb=NULL; const char *inFile; const char *outFile; const char *dbOutFile; int i; GWEN_DB_NODE *dbT; int trustLevel; const GWEN_ARGS args[]={ { GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */ GWEN_ArgsType_Char, /* type */ "xmlfile", /* name */ 0, /* minnum */ 99, /* maxnum */ "x", /* short option */ "xmlfile", /* long option */ "Specify XML files to load", /* short description */ "Specify XML files to load" /* long description */ }, { GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */ GWEN_ArgsType_Char, /* type */ "infile", /* name */ 1, /* minnum */ 1, /* maxnum */ "i", /* short option */ "infile", /* long option */ "Specify input file", /* short description */ "Specify input file" /* long description */ }, { GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */ GWEN_ArgsType_Char, /* type */ "outfile", /* name */ 0, /* minnum */ 1, /* maxnum */ "o", /* short option */ "outfile", /* long option */ "Specify output file", /* short description */ "Specify output file" /* long description */ }, { GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */ GWEN_ArgsType_Char, /* type */ "dboutfile", /* name */ 0, /* minnum */ 1, /* maxnum */ "d", /* short option */ "dbfile", /* long option */ "Specify DB output file", /* short description */ "Specify DB output file" /* long description */ }, { GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */ GWEN_ArgsType_Int, /* type */ "trustLevel", /* name */ 0, /* minnum */ 1, /* maxnum */ "L", /* short option */ "trustlevel", /* long option */ "Specify the trust level", /* short description */ "Specify the trust level" /* long description */ }, { GWEN_ARGS_FLAGS_HELP | GWEN_ARGS_FLAGS_LAST, /* flags */ GWEN_ArgsType_Int, /* type */ "help", /* name */ 0, /* minnum */ 0, /* maxnum */ "h", /* short option */ "help", /* long option */ "Show this help screen", /* short description */ "Show this help screen" /* long description */ } }; db=GWEN_DB_GetGroup(dbArgs, GWEN_DB_FLAGS_DEFAULT, "local"); rv=GWEN_Args_Check(argc, argv, 1, 0 /*GWEN_ARGS_MODE_ALLOW_FREEPARAM*/, args, db); if (rv==GWEN_ARGS_RESULT_ERROR) { fprintf(stderr, "ERROR: Could not parse arguments\n"); return 1; } else if (rv==GWEN_ARGS_RESULT_HELP) { GWEN_BUFFER *ubuf; ubuf=GWEN_Buffer_new(0, 1024, 0, 1); if (GWEN_Args_Usage(args, ubuf, GWEN_ArgsOutType_Txt)) { fprintf(stderr, "ERROR: Could not create help string\n"); return 1; } fprintf(stderr, "%s\n", GWEN_Buffer_GetStart(ubuf)); GWEN_Buffer_free(ubuf); return 0; } trustLevel=GWEN_DB_GetIntValue(db, "trustLevel", 0, 0); outFile=GWEN_DB_GetCharValue(db, "outFile", 0, NULL); dbOutFile=GWEN_DB_GetCharValue(db, "dbOutFile", 0, NULL); inFile=GWEN_DB_GetCharValue(db, "inFile", 0, NULL); assert(inFile); /* do it */ dbMessages=GWEN_DB_Group_new("Messages"); rv=_readLogFile(inFile, dbMessages); if (rv<0) { DBG_ERROR(0, "Error reading message (%d)", rv); return 2; } /* create message engine, read XML definitions */ e=AH_MsgEngine_new(); for (i=0; i<99; i++) { s=GWEN_DB_GetCharValue(dbArgs, "xmlfile", i, NULL); if (s && *s) { GWEN_XMLNODE *defs; defs=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, "defs"); if (GWEN_XML_ReadFile(defs, s, GWEN_XML_FLAGS_DEFAULT)){ fprintf(stderr, "Error parsing.\n"); GWEN_MsgEngine_free(e); return 2; } GWEN_MsgEngine_AddDefinitions(e, defs); GWEN_XMLNode_free(defs); } else { if (i==0) { GWEN_XMLNODE *defs; defs=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, "defs"); if (GWEN_XML_ReadFile(defs, XMLDATA_DIR "/hbci.xml", GWEN_XML_FLAGS_DEFAULT)){ fprintf(stderr, "Error parsing.\n"); GWEN_MsgEngine_free(e); return 2; } GWEN_MsgEngine_AddDefinitions(e, defs); GWEN_XMLNode_free(defs); } break; } } if (outFile) { sioOut=GWEN_SyncIo_File_new(outFile, GWEN_SyncIo_File_CreationMode_CreateAlways); GWEN_SyncIo_AddFlags(sioOut, GWEN_SYNCIO_FILE_FLAGS_READ | GWEN_SYNCIO_FILE_FLAGS_WRITE | GWEN_SYNCIO_FILE_FLAGS_UREAD | GWEN_SYNCIO_FILE_FLAGS_UWRITE | GWEN_SYNCIO_FILE_FLAGS_APPEND); rv=GWEN_SyncIo_Connect(sioOut); if (rv<0) { DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv); GWEN_SyncIo_free(sioOut); return 2; } } if (dbOutFile) { sioDb=GWEN_SyncIo_File_new(dbOutFile, GWEN_SyncIo_File_CreationMode_CreateAlways); GWEN_SyncIo_AddFlags(sioDb, GWEN_SYNCIO_FILE_FLAGS_READ | GWEN_SYNCIO_FILE_FLAGS_WRITE | GWEN_SYNCIO_FILE_FLAGS_UREAD | GWEN_SYNCIO_FILE_FLAGS_UWRITE | GWEN_SYNCIO_FILE_FLAGS_APPEND); rv=GWEN_SyncIo_Connect(sioDb); if (rv<0) { DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv); GWEN_SyncIo_free(sioDb); return 2; } } dbT=GWEN_DB_GetFirstGroup(dbMessages); while(dbT) { const uint8_t *p; uint32_t len; GWEN_DB_NODE *dbHeader; dbHeader=GWEN_DB_GetGroup(dbT, GWEN_PATH_FLAGS_NAMEMUSTEXIST, "header"); assert(dbHeader); s=GWEN_DB_GetCharValue(dbHeader, "mode", 0, "PINTAN"); GWEN_MsgEngine_SetMode(e, s); i=GWEN_DB_GetIntValue(dbHeader, "hbciVersion", 0, 220); GWEN_MsgEngine_SetProtocolVersion(e, i); p=GWEN_DB_GetBinValue(dbT, "body", 0, NULL, 0, &len); if (p && len) { GWEN_BUFFER *tbuf; GWEN_DB_NODE *gr; GWEN_MSGENGINE_TRUSTEDDATA *trustedData; GWEN_MSGENGINE_TRUSTEDDATA *ntd; GWEN_DB_NODE *repl; gr=GWEN_DB_Group_new("message"); tbuf=GWEN_Buffer_new((char*) p, len, len, 0); rv=GWEN_MsgEngine_ReadMessage(e, "SEG", tbuf, gr, GWEN_MSGENGINE_READ_FLAGS_TRUSTINFO); if (rv) { fprintf(stderr, "ERROR.\n"); GWEN_Buffer_Dump(tbuf, 2); return 2; } /* work on trust data */ trustedData=GWEN_MsgEngine_TakeTrustInfo(e); if (trustedData) { if (GWEN_MsgEngine_TrustedData_CreateReplacements(trustedData)) { fprintf(stderr, "Could not anonymize log (createReplacements)\n"); GWEN_MsgEngine_TrustedData_free(trustedData); GWEN_MsgEngine_free(e); return 2; } } /* anonymize file */ ntd=trustedData; repl=GWEN_DB_GetGroup(dbHeader, GWEN_DB_FLAGS_OVERWRITE_GROUPS, "replacements"); assert(repl); while(ntd) { if (GWEN_MsgEngine_TrustedData_GetTrustLevel(ntd)>trustLevel) { int pos; unsigned int size; char rbuffer[3]; const char *rpstr; rpstr=GWEN_MsgEngine_TrustedData_GetReplacement(ntd); assert(rpstr); assert(*rpstr); size=strlen(rpstr); if (size==1) { rbuffer[0]=rpstr[0]; rbuffer[1]=0; } else { rbuffer[0]=rpstr[0]; rbuffer[1]=rpstr[1]; rbuffer[2]=0; } GWEN_DB_SetCharValue(repl, GWEN_DB_FLAGS_DEFAULT | GWEN_PATH_FLAGS_CREATE_VAR, rbuffer, GWEN_MsgEngine_TrustedData_GetDescription(ntd)); size=GWEN_MsgEngine_TrustedData_GetSize(ntd); pos=GWEN_MsgEngine_TrustedData_GetFirstPos(ntd); while(pos>=0) { DBG_INFO(0, "Replacing %d bytes at %d", size, pos); GWEN_Buffer_SetPos(tbuf, pos); GWEN_Buffer_ReplaceBytes(tbuf, size, GWEN_MsgEngine_TrustedData_GetReplacement(ntd), size); pos=GWEN_MsgEngine_TrustedData_GetNextPos(ntd); } // while pos } ntd=GWEN_MsgEngine_TrustedData_GetNext(ntd); } // while ntd GWEN_DB_SetIntValue(dbHeader, GWEN_DB_FLAGS_OVERWRITE_VARS, "size", GWEN_Buffer_GetUsedBytes(tbuf)); if (outFile) { rv=dumpMsg(sioOut, dbHeader, (const uint8_t*)GWEN_Buffer_GetStart(tbuf), GWEN_Buffer_GetUsedBytes(tbuf)); if (rv<0) { fprintf(stderr, "Could not anonymize log (dumpMsg)\n"); GWEN_MsgEngine_TrustedData_free(trustedData); GWEN_MsgEngine_free(e); return 2; } } if (dbOutFile) { GWEN_BUFFER *xbuf; GWEN_DB_NODE *dbOut; xbuf=GWEN_Buffer_new(0, 256, 0, 1); GWEN_Buffer_AppendString(xbuf, "# ========== Message ( "); s=GWEN_DB_GetCharValue(dbHeader, "sender", 0, "UNK"); if (s && *s) { GWEN_Buffer_AppendString(xbuf, "sender="); GWEN_Buffer_AppendString(xbuf, s); GWEN_Buffer_AppendString(xbuf, " "); } s=GWEN_DB_GetCharValue(dbHeader, "crypt", 0, "UNK"); if (s && *s) { GWEN_Buffer_AppendString(xbuf, "crypt="); GWEN_Buffer_AppendString(xbuf, s); GWEN_Buffer_AppendString(xbuf, " "); } GWEN_Buffer_AppendString(xbuf, ") ==========\n"); dbOut=GWEN_DB_Group_new("Message"); GWEN_Buffer_Rewind(tbuf); rv=GWEN_MsgEngine_ReadMessage(e, "SEG", tbuf, dbOut, 0); if (rv) { fprintf(stderr, "ERROR.\n"); GWEN_Buffer_Dump(tbuf, 2); return 2; } rv=GWEN_SyncIo_WriteForced(sioDb, (const uint8_t*) GWEN_Buffer_GetStart(xbuf), GWEN_Buffer_GetUsedBytes(xbuf)); GWEN_Buffer_free(xbuf); if (rv<0) { DBG_INFO(0, "here (%d)", rv); return rv; } rv=GWEN_DB_WriteToIo(dbOut, sioDb, GWEN_DB_FLAGS_DEFAULT); if (rv<0) { DBG_INFO(0, "here (%d)", rv); return 2; } /* append empty line to separate header from data */ rv=GWEN_SyncIo_WriteForced(sioDb, (const uint8_t*) "\n", 1); if (rv<0) { DBG_INFO(0, "here (%d)", rv); return rv; } } GWEN_Buffer_free(tbuf); } dbT=GWEN_DB_GetNextGroup(dbT); } /* close output layer */ if (outFile) { rv=GWEN_SyncIo_Disconnect(sioOut); if (rv<0) { DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d)", rv); GWEN_SyncIo_free(sioOut); return 2; } GWEN_SyncIo_free(sioOut); } if (dbOutFile) { rv=GWEN_SyncIo_Disconnect(sioDb); if (rv<0) { DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d)", rv); GWEN_SyncIo_free(sioDb); return 2; } GWEN_SyncIo_free(sioDb); } return 0; }