int EBC_Provider_MkEuCryptZipDoc_A004(AB_PROVIDER *pro,
AB_USER *u,
const char *requestType,
const uint8_t *pMsg,
uint32_t lMsg,
GWEN_CRYPT_KEY *skey,
GWEN_BUFFER *sbuf) {
GWEN_BUFFER *tbuf;
GWEN_BUFFER *ebuf;
int rv;
uint32_t l;
DBG_INFO(AQEBICS_LOGDOMAIN, "Generating EU A005");
tbuf=GWEN_Buffer_new(0, 512, 0, 1);
rv=EBC_Provider_MkEuZipDoc_A004(pro, u, requestType, pMsg, lMsg, tbuf);
if (rv<0) {
DBG_INFO(AQEBICS_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(tbuf);
return rv;
}
/* padd EU */
rv=GWEN_Padd_PaddWithAnsiX9_23(tbuf);
if (rv<0) {
DBG_INFO(AQEBICS_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(tbuf);
return rv;
}
/* encrypt EU with the DES session key */
ebuf=GWEN_Buffer_new(0, GWEN_Buffer_GetUsedBytes(tbuf)+16, 0, 1);
l=GWEN_Buffer_GetMaxUnsegmentedWrite(ebuf);
/* reset IV !! */
GWEN_Crypt_KeyDes3K_SetIV(skey, NULL, 0);
rv=GWEN_Crypt_Key_Encipher(skey,
(uint8_t*)GWEN_Buffer_GetStart(tbuf),
GWEN_Buffer_GetUsedBytes(tbuf),
(uint8_t*)GWEN_Buffer_GetPosPointer(ebuf),
&l);
if (rv<0) {
DBG_INFO(AQEBICS_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(ebuf);
GWEN_Buffer_free(tbuf);
return rv;
}
GWEN_Buffer_free(tbuf);
GWEN_Buffer_IncrementPos(ebuf, l);
GWEN_Buffer_AdjustUsedBytes(ebuf);
/* base64 encode encrypted EU into given buffer */
rv=GWEN_Base64_Encode((const uint8_t*)GWEN_Buffer_GetStart(ebuf),
GWEN_Buffer_GetUsedBytes(ebuf),
sbuf, 0);
if (rv<0) {
DBG_INFO(AQEBICS_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(ebuf);
return rv;
}
GWEN_Buffer_free(ebuf);
return 0;
}
GWEN_PROCESS_STATE GWEN_Process_Start(GWEN_PROCESS *pr,
const char *prg,
const char *args) {
pid_t pid;
char *argv[32];
int argc;
const char *p, *p2;
GWEN_BUFFER *wbuf;
assert(pr);
if (GWEN_Process_Redirect(pr)) {
DBG_ERROR(GWEN_LOGDOMAIN, "Could not setup redirections");
pr->state=GWEN_ProcessStateNotStarted;
pr->pid=-1;
return GWEN_ProcessStateNotStarted;
}
pid=fork();
if (pid==-1) {
/* error in fork */
pr->state=GWEN_ProcessStateNotStarted;
pr->pid=-1;
/* close all pipes */
if (pr->filesStdin[0]!=-1) {
close(pr->filesStdin[0]);
close(pr->filesStdin[1]);
}
if (pr->filesStdout[0]!=-1) {
close(pr->filesStdout[0]);
close(pr->filesStdout[1]);
}
if (pr->filesStderr[0]!=-1) {
close(pr->filesStderr[0]);
close(pr->filesStderr[1]);
}
return GWEN_ProcessStateNotStarted;
}
else if (pid!=0) {
/* parent */
DBG_INFO(GWEN_LOGDOMAIN, "Process started with id %d", (int)pid);
pr->state=GWEN_ProcessStateRunning;
pr->pid=pid;
/* setup redirections */
if (pr->filesStdin[0]!=-1) {
close(pr->filesStdin[1]);
pr->stdIn=GWEN_SyncIo_File_fromFd(pr->filesStdin[0]);
}
if (pr->filesStdout[0]!=-1) {
close(pr->filesStdout[1]);
pr->stdOut=GWEN_SyncIo_File_fromFd(pr->filesStdout[0]);
}
if (pr->filesStderr[0]!=-1) {
close(pr->filesStderr[1]);
pr->stdErr=GWEN_SyncIo_File_fromFd(pr->filesStdout[0]);
}
return GWEN_ProcessStateRunning;
}
/* child, build arguments */
argc=0;
DBG_DEBUG(GWEN_LOGDOMAIN, "I'm the child process");
/* setup redirections */
if (pr->filesStdin[0]!=-1) {
close(pr->filesStdin[0]);
close(0);
if (dup(pr->filesStdin[1])==-1) {
DBG_ERROR(GWEN_LOGDOMAIN, "Could not setup redirection");
}
}
if (pr->filesStdout[0]!=-1) {
close(pr->filesStdout[0]);
close(1);
if (dup(pr->filesStdout[1])==-1) {
DBG_ERROR(GWEN_LOGDOMAIN, "Could not setup redirection");
}
}
if (pr->filesStderr[0]!=-1) {
close(pr->filesStderr[0]);
close(2);
if (dup(pr->filesStderr[1])==-1) {
DBG_ERROR(GWEN_LOGDOMAIN, "Could not setup redirection");
}
}
argv[0]=strdup(prg);
argc++;
p=args;
wbuf=GWEN_Buffer_new(0, 256, 0, 1);
while(argc<32 && *p) {
while(*p && isspace((int)*p))
p++;
if (!(*p))
break;
if (GWEN_Text_GetWordToBuffer(p, " ",
wbuf,
GWEN_TEXT_FLAGS_NULL_IS_DELIMITER |
GWEN_TEXT_FLAGS_DEL_QUOTES |
GWEN_TEXT_FLAGS_CHECK_BACKSLASH,
&p))
break;
p2=GWEN_Buffer_GetStart(wbuf);
argv[argc]=strdup(p2);
GWEN_Buffer_Reset(wbuf);
argc++;
} /* while */
GWEN_Buffer_free(wbuf);
argv[argc]=0;
/* parameters ready, exec */
execvp(prg, argv);
/* if we reach this point an error occurred */
DBG_ERROR(GWEN_LOGDOMAIN, "Could not start program \"%s\": %s",
prg, strerror(errno));
exit(EXIT_FAILURE);
}
int Gtk2Gui_Dialog_SetupTree(GWEN_WIDGET *w) {
int rv;
switch(GWEN_Widget_GetType(w)) {
case GWEN_Widget_TypeDialog:
rv=Gtk2Gui_WDialog_Setup(w);
break;
case GWEN_Widget_TypeLabel:
rv=Gtk2Gui_WLabel_Setup(w);
break;
case GWEN_Widget_TypeGridLayout:
rv=Gtk2Gui_WGridLayout_Setup(w);
break;
case GWEN_Widget_TypeVLayout:
rv=Gtk2Gui_WVLayout_Setup(w);
break;
case GWEN_Widget_TypeHLayout:
rv=Gtk2Gui_WHLayout_Setup(w);
break;
case GWEN_Widget_TypePushButton:
rv=Gtk2Gui_WPushButton_Setup(w);
break;
case GWEN_Widget_TypeLineEdit:
rv=Gtk2Gui_WLineEdit_Setup(w);
break;
case GWEN_Widget_TypeHLine:
rv=Gtk2Gui_WHLine_Setup(w);
break;
case GWEN_Widget_TypeVLine:
rv=Gtk2Gui_WVLine_Setup(w);
break;
case GWEN_Widget_TypeVSpacer:
rv=Gtk2Gui_WVSpacer_Setup(w);
break;
case GWEN_Widget_TypeHSpacer:
rv=Gtk2Gui_WHSpacer_Setup(w);
break;
case GWEN_Widget_TypeComboBox:
rv=Gtk2Gui_WComboBox_Setup(w);
break;
case GWEN_Widget_TypeTextEdit:
rv=Gtk2Gui_WTextEdit_Setup(w);
break;
case GWEN_Widget_TypeWidgetStack:
rv=Gtk2Gui_WStack_Setup(w);
break;
case GWEN_Widget_TypeTabBook:
rv=Gtk2Gui_WTabBook_Setup(w);
break;
case GWEN_Widget_TypeTabPage:
/* just re-use vbox */
GWEN_Widget_AddFlags(w, GWEN_WIDGET_FLAGS_FILLX | GWEN_WIDGET_FLAGS_FILLY);
rv=Gtk2Gui_WVLayout_Setup(w);
break;
case GWEN_Widget_TypeGroupBox:
rv=Gtk2Gui_WGroupBox_Setup(w);
break;
case GWEN_Widget_TypeTextBrowser:
rv=Gtk2Gui_WTextBrowser_Setup(w);
break;
case GWEN_Widget_TypeProgressBar:
rv=Gtk2Gui_WProgressBar_Setup(w);
break;
case GWEN_Widget_TypeSpinBox:
rv=Gtk2Gui_WSpinBox_Setup(w);
break;
case GWEN_Widget_TypeListBox:
rv=Gtk2Gui_WListBox_Setup(w);
break;
case GWEN_Widget_TypeCheckBox:
rv=Gtk2Gui_WCheckBox_Setup(w);
break;
case GWEN_Widget_TypeScrollArea:
rv=Gtk2Gui_WScrollArea_Setup(w);
break;
case GWEN_Widget_TypeRadioButton:
rv=Gtk2Gui_WRadioButton_Setup(w);
break;
default:
DBG_ERROR(GWEN_LOGDOMAIN, "Unhandled widget type %d", GWEN_Widget_GetType(w));
rv=GWEN_ERROR_INVALID;
break;
}
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
return rv;
}
else {
GWEN_WIDGET *wChild;
/* handle children */
wChild=GWEN_Widget_Tree_GetFirstChild(w);
while(wChild) {
/* recursion */
rv=Gtk2Gui_Dialog_SetupTree(wChild);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
return rv;
}
wChild=GWEN_Widget_Tree_GetNext(wChild);
}
}
return 0;
}
int EBC_Provider_AddJob(AB_PROVIDER *pro, AB_JOB *j) {
EBC_PROVIDER *dp;
AB_ACCOUNT *a;
AB_USER *u;
EBC_USERQUEUE *uq;
int doAdd=1;
GWEN_DB_NODE *dbJob;
assert(pro);
dp=GWEN_INHERIT_GETDATA(AB_PROVIDER, EBC_PROVIDER, pro);
assert(dp);
a=AB_Job_GetAccount(j);
assert(a);
u=AB_Account_GetFirstUser(a);
if (u==NULL) {
DBG_ERROR(AQEBICS_LOGDOMAIN, "No user assigned to account.");
GWEN_Gui_ProgressLog(0,
GWEN_LoggerLevel_Error,
I18N("No user assigned to account."));
GWEN_Gui_ShowError(I18N("Setup Error"),
I18N("No user assigned to this account. Please assign one in the online banking setup dialog "
"for this account.\n"));
return GWEN_ERROR_INTERNAL;
}
dbJob=AB_Job_GetProviderData(j, pro);
assert(dbJob);
switch(AB_Job_GetType(j)) {
case AB_Job_TypeGetTransactions:
case AB_Job_TypeTransfer:
case AB_Job_TypeDebitNote:
break;
case AB_Job_TypeGetBalance:
default:
DBG_INFO(AQEBICS_LOGDOMAIN,
"Job not yet supported (%d)",
AB_Job_GetType(j));
return GWEN_ERROR_NOT_SUPPORTED;
} /* switch */
uq=EBC_Queue_GetUserQueue(dp->queue, u);
assert(uq);
if (AB_Job_GetType(j)==AB_Job_TypeGetTransactions) {
AB_JOB *firstJob;
firstJob=EBC_Queue_FindFirstJobLikeThis(dp->queue, u, j);
if (firstJob) {
GWEN_DB_NODE *dbCurrJob;
/* this job is just a copy of the firstJob, reference it */
dbCurrJob=AB_Job_GetProviderData(j, pro);
assert(dbCurrJob);
GWEN_DB_SetIntValue(dbCurrJob,
GWEN_DB_FLAGS_OVERWRITE_VARS,
"refJob",
AB_Job_GetJobId(firstJob));
/* don't add to queues */
doAdd=0;
}
}
if (doAdd) {
/* only add to queue if needed */
EBC_UserQueue_AddJob(uq, j);
}
/* always add to linear list */
AB_Job_List2_PushBack(dp->bankingJobs, j);
return 0;
}
int EBC_Provider_ExecUserQueue(AB_PROVIDER *pro,
AB_IMEXPORTER_CONTEXT *ctx,
EBC_USERQUEUE *uq){
EBC_PROVIDER *dp;
int errors=0;
int oks=0;
GWEN_HTTP_SESSION *sess;
int rv;
EBC_ACCOUNTQUEUE_LIST *al;
AB_BANKING *ab;
assert(pro);
dp=GWEN_INHERIT_GETDATA(AB_PROVIDER, EBC_PROVIDER, pro);
assert(dp);
ab=AB_Provider_GetBanking(pro);
assert(ab);
/* create and open session */
sess=EBC_Dialog_new(pro,
EBC_UserQueue_GetUser(uq));
rv=GWEN_HttpSession_Init(sess);
if (rv<0) {
DBG_ERROR(AQEBICS_LOGDOMAIN, "Could not open session");
GWEN_HttpSession_free(sess);
return rv;
}
al=EBC_UserQueue_GetAccountQueues(uq);
if (al) {
EBC_ACCOUNTQUEUE *aq;
aq=EBC_AccountQueue_List_First(al);
while(aq) {
AB_ACCOUNT *a;
a=EBC_AccountQueue_GetAccount(aq);
assert(a);
/* lock account */
GWEN_Gui_ProgressLog(0,
GWEN_LoggerLevel_Info,
I18N("Locking account"));
rv=AB_Banking_BeginExclUseAccount(ab, a);
if (rv<0) {
DBG_INFO(AQEBICS_LOGDOMAIN, "here (%d)", rv);
GWEN_Gui_ProgressLog(0,
GWEN_LoggerLevel_Error,
I18N("Could not lock account"));
}
else {
GWEN_Gui_ProgressLog(0,
GWEN_LoggerLevel_Info,
I18N("Executing account queue"));
rv=EBC_Provider_ExecAccountQueue(pro, ctx,
EBC_UserQueue_GetUser(uq),
sess, aq);
if (!rv)
oks++;
else {
errors++;
if (rv==GWEN_ERROR_USER_ABORTED) {
DBG_INFO(AQEBICS_LOGDOMAIN, "User aborted");
AB_Banking_EndExclUseAccount(ab, a, 1); /* abandon */
GWEN_HttpSession_Fini(sess);
GWEN_HttpSession_free(sess);
return rv;
}
else {
DBG_INFO(AQEBICS_LOGDOMAIN, "here (%d)", rv);
}
}
/* unlock account */
GWEN_Gui_ProgressLog(0,
GWEN_LoggerLevel_Info,
I18N("Unlocking account"));
rv=AB_Banking_EndExclUseAccount(ab, a, 0);
if (rv<0) {
DBG_INFO(AQEBICS_LOGDOMAIN, "here (%d)", rv);
GWEN_Gui_ProgressLog(0,
GWEN_LoggerLevel_Error,
I18N("Could not unlock account"));
}
}
aq=EBC_AccountQueue_List_Next(aq);
}
}
/* close and destroy session */
GWEN_HttpSession_Fini(sess);
GWEN_HttpSession_free(sess);
return 0;
}
int EBC_Provider_Init(AB_PROVIDER *pro, GWEN_DB_NODE *dbData) {
EBC_PROVIDER *dp;
const char *logLevelName;
assert(pro);
dp=GWEN_INHERIT_GETDATA(AB_PROVIDER, EBC_PROVIDER, pro);
assert(dp);
if (!GWEN_Logger_IsOpen(AQEBICS_LOGDOMAIN)) {
GWEN_Logger_Open(AQEBICS_LOGDOMAIN,
"aqebics", 0,
GWEN_LoggerType_Console,
GWEN_LoggerFacility_User);
}
logLevelName=getenv("AQEBICS_LOGLEVEL");
if (logLevelName) {
GWEN_LOGGER_LEVEL ll;
ll=GWEN_Logger_Name2Level(logLevelName);
if (ll!=GWEN_LoggerLevel_Unknown) {
GWEN_Logger_SetLevel(AQEBICS_LOGDOMAIN, ll);
DBG_WARN(AQEBICS_LOGDOMAIN,
"Overriding loglevel for AqEBICS with \"%s\"",
logLevelName);
}
else {
DBG_ERROR(AQEBICS_LOGDOMAIN, "Unknown loglevel \"%s\"",
logLevelName);
}
}
DBG_INFO(AQEBICS_LOGDOMAIN, "Please remember to purchase a license if you want to use the EBICS backend.");
if (1) {
GWEN_STRINGLIST *sl=GWEN_PathManager_GetPaths(AB_PM_LIBNAME,
AB_PM_LOCALEDIR);
const char *localedir=GWEN_StringList_FirstString(sl);
int rv;
rv=GWEN_I18N_BindTextDomain_Dir(PACKAGE, localedir);
if (rv) {
DBG_ERROR(AQEBICS_LOGDOMAIN, "Could not bind textdomain (%d)", rv);
}
else {
rv=GWEN_I18N_BindTextDomain_Codeset(PACKAGE, "UTF-8");
if (rv) {
DBG_ERROR(AQEBICS_LOGDOMAIN, "Could not set codeset (%d)", rv);
}
}
GWEN_StringList_free(sl);
}
DBG_NOTICE(AQEBICS_LOGDOMAIN, "Initializing AqEBICS backend");
dp->connectTimeout=GWEN_DB_GetIntValue(dbData, "connectTimeout", 0,
EBC_DEFAULT_CONNECT_TIMEOUT);
dp->transferTimeout=GWEN_DB_GetIntValue(dbData, "transferTimeout", 0,
EBC_DEFAULT_TRANSFER_TIMEOUT);
return 0;
}
int EBC_Provider_FillDataEncryptionInfoNode(AB_PROVIDER *pro, AB_USER *u,
const GWEN_CRYPT_KEY *skey,
xmlNodePtr node) {
EBC_PROVIDER *dp;
int rv;
GWEN_CRYPT_TOKEN *ct;
const GWEN_CRYPT_TOKEN_CONTEXT *ctx;
const GWEN_CRYPT_TOKEN_KEYINFO *ki;
uint32_t keyId;
GWEN_BUFFER *hbuf;
xmlNodePtr nodeX = NULL;
const char *s;
assert(pro);
dp=GWEN_INHERIT_GETDATA(AB_PROVIDER, EBC_PROVIDER, pro);
assert(dp);
/* get crypt token and context */
rv=EBC_Provider_MountToken(pro, u, &ct, &ctx);
if (rv<0) {
DBG_INFO(AQEBICS_LOGDOMAIN, "here (%d)", rv);
return rv;
}
/* get key id for server crypt key */
keyId=GWEN_Crypt_Token_Context_GetEncipherKeyId(ctx);
ki=GWEN_Crypt_Token_GetKeyInfo(ct,
keyId,
0xffffffff,
0);
if (ki==NULL) {
DBG_INFO(AQEBICS_LOGDOMAIN,
"Keyinfo %04x not found on crypt token [%s:%s]",
keyId,
GWEN_Crypt_Token_GetTypeName(ct),
GWEN_Crypt_Token_GetTokenName(ct));
GWEN_Crypt_Token_Close(ct, 0, 0);
return GWEN_ERROR_NOT_FOUND;
}
hbuf=GWEN_Buffer_new(0, 256, 0, 1);
s=EBC_User_GetCryptVersion(u);
if (!(s && *s))
s="E001";
if (strcasecmp(s, "E001")==0) {
rv=EB_Key_Info_BuildHashSha1(ki, hbuf, 1);
if (rv<0) {
DBG_INFO(AQEBICS_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(hbuf);
GWEN_Crypt_Token_Close(ct, 0, 0);
return rv;
}
nodeX=xmlNewTextChild(node, NULL,
BAD_CAST "EncryptionPubKeyDigest",
BAD_CAST GWEN_Buffer_GetStart(hbuf));
GWEN_Buffer_free(hbuf);
assert(nodeX);
xmlNewProp(nodeX,
BAD_CAST "Version",
BAD_CAST "E001");
xmlNewProp(nodeX,
BAD_CAST "Algorithm",
BAD_CAST "http://www.w3.org/2000/09/xmldsig#sha1");
}
else if (strcasecmp(s, "E002")==0) {
rv=EB_Key_Info_BuildHashSha256(ki, hbuf, 1);
if (rv<0) {
DBG_INFO(AQEBICS_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(hbuf);
GWEN_Crypt_Token_Close(ct, 0, 0);
return rv;
}
nodeX=xmlNewTextChild(node, NULL,
BAD_CAST "EncryptionPubKeyDigest",
BAD_CAST GWEN_Buffer_GetStart(hbuf));
GWEN_Buffer_free(hbuf);
assert(nodeX);
xmlNewProp(nodeX,
BAD_CAST "Version",
BAD_CAST "E002");
xmlNewProp(nodeX,
BAD_CAST "Algorithm",
BAD_CAST "http://www.w3.org/2001/04/xmlenc#sha256");
}
/* add encrypted transactio key */
hbuf=GWEN_Buffer_new(0, 256, 0, 1);
rv=EBC_Provider_EncryptKey(pro, u, skey, hbuf);
if (rv<0) {
DBG_INFO(AQEBICS_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(hbuf);
GWEN_Crypt_Token_Close(ct, 0, 0);
return rv;
}
nodeX=xmlNewTextChild(node, NULL,
BAD_CAST "TransactionKey",
BAD_CAST GWEN_Buffer_GetStart(hbuf));
GWEN_Buffer_free(hbuf);
assert(nodeX);
return 0;
}
int AHB_DTAUS__Export(GWEN_DBIO *dbio,
GWEN_SYNCIO *sio,
GWEN_DB_NODE *data,
GWEN_DB_NODE *cfg,
uint32_t flags){
AB_VALUE *sumEUR;
AB_VALUE *sumDEM;
AB_VALUE *sumBankCodes;
AB_VALUE *sumAccountIds;
unsigned int cSets;
GWEN_BUFFER *dst;
GWEN_DB_NODE *gr;
int isDebitNote;
//int isEuro;
const uint8_t *p;
uint32_t size;
int rv;
isDebitNote=(strcasecmp(GWEN_DB_GetCharValue(cfg, "type", 0, "transfer"),
"debitnote")==0);
//isEuro=(strcasecmp(GWEN_DB_GetCharValue(cfg, "currency", 0, "EUR"),
// "EUR")==0);
cSets=0;
sumEUR=AB_Value_new();
sumDEM=AB_Value_new();
sumBankCodes=AB_Value_new();
sumAccountIds=AB_Value_new();
dst=GWEN_Buffer_new(0, 1024, 0, 1);
GWEN_Buffer_SetHardLimit(dst, AHB_DTAUS_HARDLIMIT);
/* create A set */
if (AHB_DTAUS__CreateSetA(dst, cfg)) {
DBG_INFO(AQBANKING_LOGDOMAIN, "Error creating A set");
GWEN_Buffer_free(dst);
AB_Value_free(sumAccountIds);
AB_Value_free(sumBankCodes);
AB_Value_free(sumDEM);
AB_Value_free(sumEUR);
return -1;
}
/* create C sets */
gr=GWEN_DB_GetFirstGroup(data);
while(gr) {
const char *gn;
gn=GWEN_DB_GroupName(gr);
if ((isDebitNote && strcasecmp(gn, "debitnote")==0) ||
(!isDebitNote &&
(strcasecmp(gn, "transfer")==0 ||
strcasecmp(gn, "transaction")==0))){
if (AHB_DTAUS__CreateSetC(dst, cfg, gr,
sumEUR, sumDEM,
sumBankCodes, sumAccountIds)) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error creating C set from this data:");
GWEN_DB_Dump(gr, 2);
GWEN_Buffer_free(dst);
AB_Value_free(sumAccountIds);
AB_Value_free(sumBankCodes);
AB_Value_free(sumDEM);
AB_Value_free(sumEUR);
return -1;
}
cSets++;
} /* if group matches */
else {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Ignoring group [%s]",
GWEN_DB_GroupName(gr));
}
gr=GWEN_DB_GetNextGroup(gr);
} /* while */
/* create E set */
if (AHB_DTAUS__CreateSetE(dst, cfg, cSets,
sumEUR, sumDEM,
sumBankCodes, sumAccountIds)) {
DBG_INFO(AQBANKING_LOGDOMAIN, "Error creating E set");
GWEN_Buffer_free(dst);
AB_Value_free(sumAccountIds);
AB_Value_free(sumBankCodes);
AB_Value_free(sumDEM);
AB_Value_free(sumEUR);
return -1;
}
AB_Value_free(sumAccountIds);
AB_Value_free(sumBankCodes);
AB_Value_free(sumDEM);
AB_Value_free(sumEUR);
/* DTAUS finished, write it */
p=(const uint8_t*)GWEN_Buffer_GetStart(dst);
size=GWEN_Buffer_GetUsedBytes(dst);
rv=GWEN_SyncIo_WriteForced(sio, p, size);
if (rv<0) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Broken pipe");
GWEN_Buffer_free(dst);
return GWEN_ERROR_IO;
}
GWEN_Buffer_free(dst);
return 0;
}
static int EBC_Provider_SignMessage_X001(AB_PROVIDER *pro,
EB_MSG *msg,
AB_USER *u,
xmlNodePtr node) {
EBC_PROVIDER *dp;
int rv;
GWEN_CRYPT_TOKEN *ct;
const GWEN_CRYPT_TOKEN_CONTEXT *ctx;
const GWEN_CRYPT_TOKEN_KEYINFO *ki;
uint32_t keyId;
GWEN_BUFFER *hbuf;
GWEN_BUFFER *bbuf;
xmlNodePtr nodeX = NULL;
xmlNodePtr nodeXX = NULL;
xmlNodePtr nodeXXX = NULL;
xmlNodePtr nodeXXXX = NULL;
xmlNsPtr ns;
assert(pro);
dp=GWEN_INHERIT_GETDATA(AB_PROVIDER, EBC_PROVIDER, pro);
assert(dp);
/* get crypt token and context */
rv=EBC_Provider_MountToken(pro, u, &ct, &ctx);
if (rv<0) {
DBG_INFO(AQEBICS_LOGDOMAIN, "here (%d)", rv);
return rv;
}
/* get key id */
keyId=GWEN_Crypt_Token_Context_GetAuthSignKeyId(ctx);
ki=GWEN_Crypt_Token_GetKeyInfo(ct,
keyId,
0xffffffff,
0);
if (ki==NULL) {
DBG_INFO(AQEBICS_LOGDOMAIN,
"Keyinfo %04x not found on crypt token [%s:%s]",
keyId,
GWEN_Crypt_Token_GetTypeName(ct),
GWEN_Crypt_Token_GetTokenName(ct));
GWEN_Crypt_Token_Close(ct, 0, 0);
return GWEN_ERROR_NOT_FOUND;
}
/* prepare signature nodes */
ns=xmlSearchNs(EB_Msg_GetDoc(msg), node, BAD_CAST "ds");
assert(ns);
/* build hash */
bbuf=GWEN_Buffer_new(0, 256, 0, 1);
rv=EB_Msg_BuildHashSha1(msg, bbuf);
if (rv) {
DBG_ERROR(AQEBICS_LOGDOMAIN, "Could not build hash");
GWEN_Buffer_free(bbuf);
return rv;
}
/* base64 encode */
hbuf=GWEN_Buffer_new(0, 256, 0, 1);
rv=GWEN_Base64_Encode((const uint8_t*)GWEN_Buffer_GetStart(bbuf),
GWEN_Buffer_GetUsedBytes(bbuf),
hbuf, 0);
if (rv<0) {
DBG_INFO(AQEBICS_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(hbuf);
GWEN_Buffer_free(bbuf);
return rv;
}
GWEN_Buffer_free(bbuf);
/* create signature node */
nodeX=xmlNewChild(node, ns, BAD_CAST "SignedInfo", NULL);
nodeXX=xmlNewChild(nodeX, ns, BAD_CAST "CanonicalizationMethod", NULL);
xmlNewProp(nodeXX,
BAD_CAST "Algorithm",
BAD_CAST "http://www.w3.org/TR/2001/REC-xml-c14n-20010315");
nodeXX=xmlNewChild(nodeX, ns, BAD_CAST "SignatureMethod", NULL);
xmlNewProp(nodeXX,
BAD_CAST "Algorithm",
BAD_CAST "http://www.w3.org/2000/09/xmldsig#rsa-sha1");
nodeXX=xmlNewChild(nodeX, ns, BAD_CAST "Reference", NULL);
xmlNewProp(nodeXX,
BAD_CAST "URI",
BAD_CAST "#xpointer(//*[@authenticate='true'])");
nodeXXX=xmlNewChild(nodeXX, ns, BAD_CAST "Transforms", NULL);
nodeXXXX=xmlNewChild(nodeXXX, ns, BAD_CAST "Transform", NULL);
xmlNewProp(nodeXXXX,
BAD_CAST "Algorithm",
BAD_CAST "http://www.w3.org/TR/2001/REC-xml-c14n-20010315");
nodeXXX=xmlNewChild(nodeXX, ns, BAD_CAST "DigestMethod", NULL);
xmlNewProp(nodeXXX,
BAD_CAST "Algorithm",
BAD_CAST "http://www.w3.org/2000/09/xmldsig#sha1");
/* store hash value */
xmlNewTextChild(nodeXX, ns,
BAD_CAST "DigestValue",
BAD_CAST GWEN_Buffer_GetStart(hbuf));
GWEN_Buffer_free(hbuf);
/* build hash over SignedInfo */
bbuf=GWEN_Buffer_new(0, 256, 0, 1);
rv=EB_Xml_BuildNodeHashSha1(nodeX, "#xpointer(//*)", bbuf);
if (rv<0) {
DBG_INFO(AQEBICS_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(bbuf);
return rv;
}
/* sign hash */
if (1) {
GWEN_CRYPT_PADDALGO *algo;
int ksize;
uint32_t l;
const uint8_t prefix[]={
0x30, 0x21, 0x30, 0x09,
0x06, 0x05, 0x2B, 0x0E,
0x03, 0x02, 0x1A, 0x05,
0x00, 0x04, 0x14};
/* add prefix to hash of SignedInfo */
hbuf=GWEN_Buffer_new(0, 256, 0, 1);
ksize=GWEN_Crypt_Token_KeyInfo_GetKeySize(ki);
GWEN_Buffer_AppendBytes(hbuf, (const char*)prefix, sizeof(prefix));
GWEN_Buffer_AppendBuffer(hbuf, bbuf);
GWEN_Buffer_Reset(bbuf);
/* select padd algo */
algo=GWEN_Crypt_PaddAlgo_new(GWEN_Crypt_PaddAlgoId_Pkcs1_1);
GWEN_Crypt_PaddAlgo_SetPaddSize(algo, ksize);
/* actually sign */
GWEN_Buffer_AllocRoom(bbuf, ksize+16);
l=GWEN_Buffer_GetMaxUnsegmentedWrite(bbuf);
rv=GWEN_Crypt_Token_Sign(ct, keyId,
algo,
(const uint8_t*)GWEN_Buffer_GetStart(hbuf),
GWEN_Buffer_GetUsedBytes(hbuf),
(uint8_t*)GWEN_Buffer_GetPosPointer(bbuf),
&l,
NULL, /* ignore seq counter */
0);
GWEN_Crypt_PaddAlgo_free(algo);
if (rv<0) {
DBG_INFO(AQEBICS_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(bbuf);
GWEN_Buffer_free(hbuf);
return rv;
}
GWEN_Buffer_IncrementPos(bbuf, l);
GWEN_Buffer_AdjustUsedBytes(bbuf);
/* base 64 encode signature */
GWEN_Buffer_Reset(hbuf);
rv=GWEN_Base64_Encode((const uint8_t*)GWEN_Buffer_GetStart(bbuf),
GWEN_Buffer_GetUsedBytes(bbuf),
hbuf, 0);
if (rv<0) {
DBG_INFO(AQEBICS_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(hbuf);
GWEN_Buffer_free(bbuf);
return rv;
}
GWEN_Buffer_free(bbuf);
/* store signature */
xmlNewTextChild(node, ns,
BAD_CAST "SignatureValue",
BAD_CAST GWEN_Buffer_GetStart(hbuf));
GWEN_Buffer_free(hbuf);
}
return 0;
}
int extractArchive(GWEN_DB_NODE *dbArgs, int argc, char **argv) {
GWEN_DB_NODE *db;
const char *aname;
GWEN_SAR *sr;
int rv;
int verbosity;
const GWEN_ARGS args[]={
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
GWEN_ArgsType_Char, /* type */
"archive", /* name */
1, /* minnum */
1, /* maxnum */
"a", /* short option */
"archive", /* long option */
"Specify the archive file name", /* short description */
"Specify the archive file name" /* long description */
},
{
0, /* flags */
GWEN_ArgsType_Int, /* type */
"verbosity", /* name */
0, /* minnum */
10, /* maxnum */
"v", /* short option */
NULL, /* long option */
"set verbosity", /* short description */
"set verbosity" /* 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,
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;
}
aname=GWEN_DB_GetCharValue(db, "archive", 0, NULL);
assert(aname);
verbosity=GWEN_DB_GetIntValue(db, "verbosity", 0, 0);
sr=GWEN_Sar_new();
rv=GWEN_Sar_OpenArchive(sr, aname,
GWEN_SyncIo_File_CreationMode_OpenExisting,
GWEN_SYNCIO_FILE_FLAGS_READ);
if (rv<0) {
fprintf(stderr, "ERROR: Error opening archive (%d)\n", rv);
return 2;
}
else {
const GWEN_SAR_FILEHEADER_LIST *fhl;
fhl=GWEN_Sar_GetHeaders(sr);
if (fhl) {
const GWEN_SAR_FILEHEADER *fh;
fh=GWEN_SarFileHeader_List_First(fhl);
while(fh) {
const char *s;
s=GWEN_SarFileHeader_GetPath(fh);
if (s && *s) {
rv=GWEN_Sar_ExtractFile(sr, fh);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Sar_CloseArchive(sr, 1);
GWEN_Sar_free(sr);
return rv;
}
if (verbosity>0) {
fprintf(stdout, "extracted \"%s\"\n", s);
}
}
fh=GWEN_SarFileHeader_List_Next(fh);
}
}
rv=GWEN_Sar_CloseArchive(sr, 0);
if (rv<0) {
fprintf(stderr, "ERROR: Error closing archive (%d)\n", rv);
return 2;
}
return 0;
}
}
GWEN_DIALOG *AH_Provider_GetNewCardUserDialog(AB_PROVIDER *pro)
{
int rv;
GWEN_BUFFER *mtypeName;
GWEN_BUFFER *mediumName;
GWEN_CRYPT_TOKEN *ct;
AB_BANKING *ab;
assert(pro);
ab=AB_Provider_GetBanking(pro);
assert(ab);
mtypeName=GWEN_Buffer_new(0, 64, 0, 1);
mediumName=GWEN_Buffer_new(0, 64, 0, 1);
rv=AB_Banking_CheckCryptToken(ab,
GWEN_Crypt_Token_Device_Card,
mtypeName,
mediumName);
if (rv<0) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "here (%d)", rv);
GWEN_Gui_ShowError(I18N("Chipcard Error"),
I18N("Error checking chip card (%d).\n"
"Maybe libchipcard or its plugins are not installed?"));
GWEN_Buffer_free(mediumName);
GWEN_Buffer_free(mtypeName);
return NULL;
}
rv=AB_Banking_GetCryptToken(AB_Provider_GetBanking(pro),
GWEN_Buffer_GetStart(mtypeName),
GWEN_Buffer_GetStart(mediumName),
&ct);
if (rv<0) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(mediumName);
GWEN_Buffer_free(mtypeName);
return NULL;
}
if (strcasecmp(GWEN_Buffer_GetStart(mtypeName), "ddvcard")==0) {
GWEN_DIALOG *dlg2;
DBG_WARN(0, "DDV card");
dlg2=AH_DdvCardDialog_new(pro, ct);
if (dlg2==NULL) {
DBG_INFO(AQHBCI_LOGDOMAIN, "here (no dialog)");
GWEN_Buffer_free(mediumName);
GWEN_Buffer_free(mtypeName);
return NULL;
}
GWEN_Dialog_SetWidgetText(dlg2, "", I18N("Create HBCI/FinTS DDV User"));
GWEN_Buffer_free(mediumName);
GWEN_Buffer_free(mtypeName);
return dlg2;
}
else if (strcasecmp(GWEN_Buffer_GetStart(mtypeName), "starcoscard")==0) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "STARCOS RSA card currently not supported by this dialog");
// TODO
}
else if (strcasecmp(GWEN_Buffer_GetStart(mtypeName), "zkacard")==0) {
GWEN_DIALOG *dlg2;
DBG_WARN(0, "ZKA RSA card");
dlg2=AH_ZkaCardDialog_new(pro, ct);
if (dlg2==NULL) {
DBG_INFO(AQHBCI_LOGDOMAIN, "here (no dialog)");
GWEN_Buffer_free(mediumName);
GWEN_Buffer_free(mtypeName);
return NULL;
}
GWEN_Dialog_SetWidgetText(dlg2, "", I18N("Create HBCI/FinTS ZKA RSA User"));
GWEN_Buffer_free(mediumName);
GWEN_Buffer_free(mtypeName);
return dlg2;
}
else {
DBG_ERROR(AQHBCI_LOGDOMAIN, "Card type \"%s\" not yet supported",
GWEN_Buffer_GetStart(mtypeName));
}
GWEN_Buffer_free(mediumName);
GWEN_Buffer_free(mtypeName);
AB_Banking_ClearCryptTokenList(AB_Provider_GetBanking(pro));
return NULL;
}
int APY_NewUserDialog_DoIt(GWEN_DIALOG *dlg) {
APY_NEWUSER_DIALOG *xdlg;
AB_USER *u;
int rv;
uint32_t pid;
AB_PROVIDER *pro;
DBG_INFO(0, "Doit");
assert(dlg);
xdlg=GWEN_INHERIT_GETDATA(GWEN_DIALOG, APY_NEWUSER_DIALOG, dlg);
assert(xdlg);
pro=AB_Banking_GetProvider(xdlg->banking, "aqpaypal");
if (pro==NULL) {
DBG_ERROR(AQPAYPAL_LOGDOMAIN, "Could not find backend, maybe some plugins are not installed?");
// TODO: show error message
return GWEN_DialogEvent_ResultHandled;
}
DBG_INFO(0, "Creating user");
u=AB_Banking_CreateUser(xdlg->banking, "aqpaypal");
if (u==NULL) {
DBG_ERROR(AQPAYPAL_LOGDOMAIN, "Could not create user, maybe backend missing?");
// TODO: show error message
return GWEN_DialogEvent_ResultHandled;
}
/* generic setup */
AB_User_SetUserName(u, xdlg->userName);
AB_User_SetUserId(u, xdlg->userId);
AB_User_SetCustomerId(u, xdlg->userId);
AB_User_SetCountry(u, "de");
AB_User_SetBankCode(u, "PAYPAL");
APY_User_SetServerUrl(u, xdlg->url);
APY_User_SetHttpVMajor(u, xdlg->httpVMajor);
APY_User_SetHttpVMinor(u, xdlg->httpVMinor);
DBG_INFO(0, "Adding user");
rv=AB_Banking_AddUser(xdlg->banking, u);
if (rv<0) {
DBG_ERROR(AQPAYPAL_LOGDOMAIN, "Could not add user (%d)", rv);
AB_User_free(u);
return GWEN_DialogEvent_ResultHandled;
}
pid=GWEN_Gui_ProgressStart(GWEN_GUI_PROGRESS_DELAY |
GWEN_GUI_PROGRESS_ALLOW_EMBED |
GWEN_GUI_PROGRESS_SHOW_PROGRESS |
GWEN_GUI_PROGRESS_SHOW_ABORT,
I18N("Setting Up Paypal User"),
I18N("The user will be created."),
3,
0);
/* lock new user */
DBG_INFO(0, "Locking user");
rv=AB_Banking_BeginExclUseUser(xdlg->banking, u);
if (rv<0) {
DBG_ERROR(AQPAYPAL_LOGDOMAIN, "Could not lock user (%d)", rv);
GWEN_Gui_ProgressLog(pid,
GWEN_LoggerLevel_Error,
I18N("Unable to lock users"));
AB_Banking_DeleteUser(xdlg->banking, u);
GWEN_Gui_ProgressEnd(pid);
return GWEN_DialogEvent_ResultHandled;
}
#if 0
DBG_INFO(0, "Getting certs (%08x)", AH_User_GetFlags(u));
GWEN_Gui_ProgressLog(pid,
GWEN_LoggerLevel_Notice,
I18N("Retrieving SSL certificate"));
rv=APY_Provider_GetCert(pro, u, 0, 1, 0);
if (rv<0) {
// TODO: retry with SSLv3 if necessary
AB_Banking_EndExclUseUser(xdlg->banking, u, 1);
DBG_ERROR(AQPAYPAL_LOGDOMAIN, "here (%d)", rv);
AB_Banking_DeleteUser(xdlg->banking, u);
GWEN_Gui_ProgressEnd(pid);
return GWEN_DialogEvent_ResultHandled;
}
rv=GWEN_Gui_ProgressAdvance(pid, GWEN_GUI_PROGRESS_ONE);
if (rv==GWEN_ERROR_USER_ABORTED) {
AB_Banking_EndExclUseUser(xdlg->banking, u, 1);
DBG_INFO(AQPAYPAL_LOGDOMAIN, "here (%d)", rv);
AB_Banking_DeleteUser(xdlg->banking, u);
GWEN_Gui_ProgressLog(pid,
GWEN_LoggerLevel_Error,
I18N("Aborted by user."));
GWEN_Gui_ProgressEnd(pid);
return GWEN_DialogEvent_ResultHandled;
}
#endif
GWEN_Gui_ProgressLog(pid,
GWEN_LoggerLevel_Notice,
I18N("Creating API credentials file"));
rv=APY_User_SetApiSecrets(u, xdlg->apiPassword, xdlg->apiSignature, xdlg->apiUserId);
if (rv<0) {
AB_Banking_EndExclUseUser(xdlg->banking, u, 1);
DBG_INFO(AQPAYPAL_LOGDOMAIN, "here (%d)", rv);
AB_Banking_DeleteUser(xdlg->banking, u);
GWEN_Gui_ProgressLog(pid,
GWEN_LoggerLevel_Error,
I18N("Aborted by user."));
GWEN_Gui_ProgressEnd(pid);
return GWEN_DialogEvent_ResultHandled;
}
/* unlock user */
DBG_INFO(0, "Unlocking user");
rv=AB_Banking_EndExclUseUser(xdlg->banking, u, 0);
if (rv<0) {
DBG_INFO(AQPAYPAL_LOGDOMAIN,
"Could not unlock user [%s] (%d)",
AB_User_GetUserId(u), rv);
GWEN_Gui_ProgressLog2(pid,
GWEN_LoggerLevel_Error,
I18N("Could not unlock user %s (%d)"),
AB_User_GetUserId(u), rv);
AB_Banking_EndExclUseUser(xdlg->banking, u, 1);
AB_Banking_DeleteUser(xdlg->banking, u);
GWEN_Gui_ProgressEnd(pid);
return GWEN_DialogEvent_ResultHandled;
}
if (1) {
AB_ACCOUNT *account;
int rv;
static char accountname[256];
account=AB_Banking_CreateAccount(xdlg->banking, APY_PROVIDER_NAME);
assert(account);
#if 0
AB_User_SetUserName(u, xdlg->userName);
AB_User_SetUserId(u, xdlg->userId);
#endif
AB_Account_SetOwnerName(account, AB_User_GetUserName(u));
AB_Account_SetAccountNumber(account, AB_User_GetUserId(u));
AB_Account_SetBankCode(account, "PAYPAL");
AB_Account_SetBankName(account, "PAYPAL");
strcpy(accountname, "PP ");
strcat(accountname, AB_User_GetUserName(u));
AB_Account_SetAccountName(account, accountname);
AB_Account_SetUser(account, u);
AB_Account_SetSelectedUser(account, u);
rv=AB_Banking_AddAccount(xdlg->banking, account);
if (rv<0) {
DBG_INFO(AQPAYPAL_LOGDOMAIN, "Error adding account (%d)", rv);
AB_Account_free(account);
AB_Banking_DeleteUser(xdlg->banking, u);
GWEN_Gui_ProgressEnd(pid);
return GWEN_DialogEvent_ResultHandled;
}
}
GWEN_Dialog_SetCharProperty(dlg,
"wiz_end_label",
GWEN_DialogProperty_Title,
0,
I18N("The user has been successfully setup."),
0);
GWEN_Gui_ProgressEnd(pid);
APY_NewUserDialog_EnterPage(dlg, PAGE_END, 1);
xdlg->user=u;
return GWEN_DialogEvent_ResultHandled;
}
GWEN_DATE *GWEN_Date_fromStringWithTemplate(const char *s, const char *tmpl) {
int year, month, day;
const char *p;
const char *t;
GWEN_DATE *gwt;
assert(s);
assert(tmpl);
year=month=day=0;
p=s;
t=tmpl;
while(*t && *p) {
int i;
if (*t=='*') {
t++;
if (!*t) {
DBG_ERROR(GWEN_LOGDOMAIN, "Bad pattern: Must not end with \"*\"");
return 0;
}
i=0;
while(*p) {
if (!isdigit((int)*p))
break;
if (*p==*t)
break;
i*=10;
i+=(*p)-'0';
p++;
} /* while */
}
else {
if (isdigit((int)*p))
i=(*p)-'0';
else
i=-1;
p++;
}
if (i==-1 && strchr("YMD", *t)!=NULL) {
DBG_INFO(GWEN_LOGDOMAIN,
"No more digits at [%s], continuing", t);
p--;
}
else {
switch(*t) {
case 'Y':
if (i==-1) {
DBG_INFO(GWEN_LOGDOMAIN, "here");
return 0;
}
year*=10;
year+=i;
break;
case 'M':
if (i==-1) {
DBG_INFO(GWEN_LOGDOMAIN, "here");
return 0;
}
month*=10;
month+=i;
break;
case 'D':
if (i==-1) {
DBG_INFO(GWEN_LOGDOMAIN, "here");
return 0;
}
day*=10;
day+=i;
break;
default:
DBG_VERBOUS(GWEN_LOGDOMAIN,
"Unknown character in template, will skip in both strings");
break;
}
}
t++;
} /* while */
if (year<100)
year+=2000;
DBG_DEBUG(GWEN_LOGDOMAIN,
"Got this date/time: %04d/%02d/%02d",
year, month, day);
/* get time in local time */
gwt=GWEN_Date_fromGregorian(year, month, day);
if (!gwt) {
DBG_INFO(GWEN_LOGDOMAIN, "here");
return 0;
}
return gwt;
}
int GWEN_Gui_CProgress_Advance(GWEN_GUI_CPROGRESS *cp, uint64_t progress)
{
#ifndef OS_WIN32
int fl;
#endif
assert(cp);
if (!cp->shown) {
time_t t1;
t1=time(0);
if (difftime(t1, cp->startTime)>GWEN_GUI_DELAY_SECS) {
if (!(GWEN_Gui_GetFlags(cp->gui) & GWEN_GUI_FLAGS_NONINTERACTIVE))
GWEN_Gui_StdPrintf(cp->gui, stderr, "%s: Started.\n", cp->title);
cp->shown=1;
}
}
if (progress==GWEN_GUI_PROGRESS_ONE)
progress=cp->current+1;
if (progress!=GWEN_GUI_PROGRESS_NONE) {
if (progress!=cp->current) {
if (cp->shown) {
if (!(GWEN_Gui_GetFlags(cp->gui) & GWEN_GUI_FLAGS_NONINTERACTIVE)) {
if (cp->total==GWEN_GUI_PROGRESS_NONE)
GWEN_Gui_StdPrintf(cp->gui, stderr, "%s: %llu\n", cp->title,
(long long unsigned)progress);
else
GWEN_Gui_StdPrintf(cp->gui, stderr, "%s: %llu of %llu\n",
cp->title,
(long long unsigned)progress,
(long long unsigned)cp->total);
}
}
cp->current=progress;
}
}
if (cp->aborted)
return GWEN_ERROR_USER_ABORTED;
#ifndef OS_WIN32
if (!(GWEN_Gui_GetFlags(cp->gui) & GWEN_GUI_FLAGS_NONINTERACTIVE)) {
/* check for abort */
fl=fcntl(fileno(stdin), F_GETFL);
if (fl!=-1) {
int chr;
/* set stdin to nonblocking */
if (fcntl(fileno(stdin), F_SETFL, fl | O_NONBLOCK)) {
DBG_INFO(GWEN_LOGDOMAIN, "fcntl(stdin): %s", strerror(errno));
return 0;
}
/* check whether there is a character */
chr=getchar();
/* set blocking mode to what we found before modification */
fcntl(fileno(stdin), F_SETFL, fl);
if (chr==GWEN_GUI_CPROGRESS_CHAR_ABORT) {
GWEN_Gui_StdPrintf(cp->gui, stderr, "------> ABORTED BY USER\n");
cp->aborted=1;
return GWEN_ERROR_USER_ABORTED;
}
}
}
#endif
return 0;
}
int GWEN_CryptMgr_Decrypt(GWEN_CRYPTMGR *cm, const uint8_t *pData, uint32_t lData, GWEN_BUFFER *dbuf) {
GWEN_TAG16 *tag;
const uint8_t *p;
uint32_t l;
GWEN_CRYPTHEAD *ch=NULL;
const uint8_t *pEncryptedData=NULL;
uint32_t lEncryptedData=0;
int rv;
GWEN_BUFFER *tbuf;
GWEN_CRYPT_KEY *mkey;
assert(cm);
if (lData<3) {
DBG_ERROR(GWEN_LOGDOMAIN, "Too few bytes");
return GWEN_ERROR_BAD_DATA;
}
tag=GWEN_Tag16_fromBuffer2(pData, lData, 0);
if (tag==NULL) {
DBG_ERROR(GWEN_LOGDOMAIN, "Data doesn't contain a valid TLV");
return GWEN_ERROR_BAD_DATA;
}
if (GWEN_Tag16_GetTagType(tag)!=GWEN_CRYPTMGR_TLV_ENCRYPTEDOBJECT) {
DBG_ERROR(GWEN_LOGDOMAIN, "Data does not contain an encrypted object");
GWEN_Tag16_free(tag);
return GWEN_ERROR_BAD_DATA;
}
p=GWEN_Tag16_GetTagData(tag);
l=GWEN_Tag16_GetTagLength(tag);
/* read crypthead */
if (l) {
GWEN_TAG16 *subtag;
subtag=GWEN_Tag16_fromBuffer2(p, l, 0);
if (subtag) {
if (GWEN_Tag16_GetTagType(subtag)==GWEN_CRYPTMGR_TLV_CRYPTHEAD) {
ch=GWEN_CryptHead_fromBuffer(GWEN_Tag16_GetTagData(subtag),
GWEN_Tag16_GetTagLength(subtag));
}
p+=GWEN_Tag16_GetTagSize(subtag);
l-=GWEN_Tag16_GetTagSize(subtag);
GWEN_Tag16_free(subtag);
}
}
/* read encrypted data */
if (l) {
GWEN_TAG16 *subtag;
subtag=GWEN_Tag16_fromBuffer2(p, l, 0);
if (subtag) {
if (GWEN_Tag16_GetTagType(subtag)==GWEN_CRYPTMGR_TLV_CRYPTDATA) {
pEncryptedData=GWEN_Tag16_GetTagData(subtag);
lEncryptedData=GWEN_Tag16_GetTagLength(subtag);
}
p+=GWEN_Tag16_GetTagSize(subtag);
l-=GWEN_Tag16_GetTagSize(subtag);
GWEN_Tag16_free(subtag);
}
}
/* check for all needed components */
if (!(ch && pEncryptedData && lEncryptedData)) {
DBG_ERROR(GWEN_LOGDOMAIN, "Encrypted object is not complete");
GWEN_CryptHead_free(ch);
GWEN_Tag16_free(tag);
return GWEN_ERROR_BAD_DATA;
}
/* store or check peer key info */
if (cm->localKeyName) {
const char *s;
/* compare peer info with expected info */
s=GWEN_CryptHead_GetKeyName(ch);
if (!(cm->localKeyName && s && (strcasecmp(cm->localKeyName, s)==0) &&
(cm->localKeyNumber==GWEN_CryptHead_GetKeyNumber(ch)) &&
(cm->localKeyVersion==GWEN_CryptHead_GetKeyVersion(ch)))) {
DBG_ERROR(GWEN_LOGDOMAIN, "Unexpected local key information in signature");
GWEN_CryptHead_free(ch);
GWEN_Tag16_free(tag);
return GWEN_ERROR_BAD_DATA;
}
}
/* decrypt message key */
tbuf=GWEN_Buffer_new(0, GWEN_CryptHead_GetKeyLen(ch), 0, 1);
rv=GWEN_CryptMgr_DecryptKey(cm,
GWEN_CryptHead_GetKeyPtr(ch),
GWEN_CryptHead_GetKeyLen(ch),
tbuf);
GWEN_CryptHead_free(ch);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(tbuf);
GWEN_Tag16_free(tag);
return rv;
}
/* create message key */
mkey=GWEN_Crypt_KeyBlowFish_fromData(GWEN_Crypt_CryptMode_Cbc,
256/8,
(const uint8_t*) GWEN_Buffer_GetStart(tbuf),
GWEN_Buffer_GetUsedBytes(tbuf));
GWEN_Buffer_free(tbuf);
if (mkey==NULL) {
DBG_ERROR(GWEN_LOGDOMAIN, "Unable to create BLOWFISH key from received data");
GWEN_Tag16_free(tag);
return GWEN_ERROR_BAD_DATA;
}
/* decrypt data with message key */
tbuf=GWEN_Buffer_new(0, lEncryptedData+256, 0, 1);
l=GWEN_Buffer_GetMaxUnsegmentedWrite(tbuf);
rv=GWEN_Crypt_Key_Decipher(mkey,
pEncryptedData, lEncryptedData,
(uint8_t*)GWEN_Buffer_GetStart(tbuf),
&l);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(tbuf);
GWEN_Crypt_Key_free(mkey);
GWEN_Tag16_free(tag);
return rv;
}
GWEN_Buffer_IncrementPos(tbuf, l);
GWEN_Buffer_AdjustUsedBytes(tbuf);
/* unpadd data */
rv=GWEN_Padd_UnpaddWithAnsiX9_23(tbuf);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(tbuf);
GWEN_Crypt_Key_free(mkey);
GWEN_Tag16_free(tag);
return rv;
}
/* store data */
GWEN_Buffer_AppendBuffer(dbuf, tbuf);
GWEN_Buffer_free(tbuf);
GWEN_Crypt_Key_free(mkey);
GWEN_Tag16_free(tag);
return 0;
}
LC_CLIENT_RESULT LC_Client_ConnectCard(LC_CLIENT *cl,
const char *rname,
LC_CARD **pCard) {
LC_CLIENT_RESULT res;
LONG rv;
SCARDHANDLE scardHandle;
DWORD dwActiveProtocol;
LC_CARD *card;
char readerName[256];
DWORD pcchReaderLen;
BYTE pbAtr[MAX_ATR_SIZE];
DWORD dwAtrLen;
DWORD dwState;
GWEN_BUFFER *bDriverType;
GWEN_BUFFER *bReaderType;
uint32_t rflags=0;
assert(cl);
DBG_INFO(LC_LOGDOMAIN, "Trying protocol T1");
rv=SCardConnect(cl->scardContext,
rname,
SCARD_SHARE_EXCLUSIVE,
SCARD_PROTOCOL_T1,
&scardHandle,
&dwActiveProtocol);
if (rv!=SCARD_S_SUCCESS) {
DBG_INFO(LC_LOGDOMAIN, "Trying protocol T0");
rv=SCardConnect(cl->scardContext,
rname,
SCARD_SHARE_EXCLUSIVE,
SCARD_PROTOCOL_T0,
&scardHandle,
&dwActiveProtocol);
}
#ifdef SCARD_PROTOCOL_RAW
if (rv!=SCARD_S_SUCCESS) {
DBG_INFO(LC_LOGDOMAIN, "Trying protocol RAW");
rv=SCardConnect(cl->scardContext,
rname,
SCARD_SHARE_EXCLUSIVE,
SCARD_PROTOCOL_RAW,
&scardHandle,
&dwActiveProtocol);
}
#endif
if (rv!=SCARD_S_SUCCESS) {
DBG_INFO(LC_LOGDOMAIN,
"SCardConnect: %04lx", (long unsigned int) rv);
return LC_Client_ResultIoError;
}
/* get protocol and ATR */
DBG_INFO(LC_LOGDOMAIN, "Reading protocol and ATR");
pcchReaderLen=sizeof(readerName);
dwAtrLen=sizeof(pbAtr);
rv=SCardStatus(scardHandle,
readerName,
&pcchReaderLen,
&dwState,
&dwActiveProtocol,
pbAtr,
&dwAtrLen);
if (rv!=SCARD_S_SUCCESS) {
DBG_ERROR(LC_LOGDOMAIN,
"SCardStatus: %04lx", (long unsigned int) rv);
SCardDisconnect(scardHandle, SCARD_UNPOWER_CARD);
return LC_Client_ResultIoError;
}
/* derive reader and driver type from name */
DBG_INFO(LC_LOGDOMAIN, "Getting reader- and driver type");
bDriverType=GWEN_Buffer_new(0, 32, 0, 1);
bReaderType=GWEN_Buffer_new(0, 32, 0, 1);
res=LC_Client_GetReaderAndDriverType(cl,
readerName,
bDriverType,
bReaderType,
&rflags);
if (res) {
DBG_INFO(LC_LOGDOMAIN,
"Unable to determine type of reader [%s] (%d), assuming generic pcsc",
readerName,
res);
GWEN_Buffer_AppendString(bDriverType, "generic_pcsc");
GWEN_Buffer_AppendString(bReaderType, "generic_pcsc");
}
/* create new card */
card=LC_Card_new(cl,
scardHandle,
readerName,
dwActiveProtocol,
"processor", /* cardType */
rflags,
dwAtrLen?pbAtr:0, /* atrBuf */
dwAtrLen); /* atrLen */
/* complete card data */
LC_Card_SetDriverType(card, GWEN_Buffer_GetStart(bDriverType));
LC_Card_SetReaderType(card, GWEN_Buffer_GetStart(bReaderType));
GWEN_Buffer_free(bReaderType);
GWEN_Buffer_free(bDriverType);
*pCard=card;
return LC_Client_ResultOk;
}
int EBC_Provider_Execute(AB_PROVIDER *pro, AB_IMEXPORTER_CONTEXT *ctx) {
EBC_PROVIDER *dp;
int oks=0;
int errors=0;
AB_JOB_LIST2_ITERATOR *jit;
int rv;
assert(pro);
dp=GWEN_INHERIT_GETDATA(AB_PROVIDER, EBC_PROVIDER, pro);
assert(dp);
rv=EBC_Provider_ExecQueue(pro, ctx);
if (!rv)
oks++;
else {
errors++;
if (rv==GWEN_ERROR_USER_ABORTED) {
EBC_Queue_Clear(dp->queue);
AB_Job_List2_Clear(dp->bankingJobs);
return rv;
}
}
/* set results in referencing jobs, too */
jit=AB_Job_List2_First(dp->bankingJobs);
if (jit) {
AB_JOB *uj;
uj=AB_Job_List2Iterator_Data(jit);
assert(uj);
while(uj) {
if (AB_Job_GetStatus(uj)==AB_Job_StatusSent) {
AB_JOB *rj;
uint32_t rjid;
rj=uj;
/* find referenced job (if any) */
do {
GWEN_DB_NODE *dbT;
dbT=AB_Job_GetProviderData(rj, pro);
assert(dbT);
rjid=GWEN_DB_GetIntValue(dbT, "refJob", 0, 0);
if (rjid) {
rj=EBC_Provider_FindJobById(dp->bankingJobs, rjid);
}
} while(rjid && rj);
if (rj && rj!=uj) {
/* found referenced job, copy status and result text */
DBG_INFO(AQEBICS_LOGDOMAIN,
"Copying status from referenced job");
AB_Job_SetStatus(uj, AB_Job_GetStatus(rj));
AB_Job_SetResultText(uj, AB_Job_GetResultText(rj));
}
if (AB_Job_GetStatus(uj)==AB_Job_StatusSent)
AB_Job_SetStatus(uj, AB_Job_StatusFinished);
}
uj=AB_Job_List2Iterator_Next(jit);
} /* while */
AB_Job_List2Iterator_free(jit);
}
rv=AB_Banking_ExecutionProgress(AB_Provider_GetBanking(pro));
if (rv==GWEN_ERROR_USER_ABORTED) {
DBG_INFO(AQEBICS_LOGDOMAIN,
"User aborted");
return rv;
}
EBC_Queue_Clear(dp->queue);
AB_Job_List2_Clear(dp->bankingJobs);
if (!oks && errors) {
DBG_INFO(AQEBICS_LOGDOMAIN, "Not a single job succeeded");
return GWEN_ERROR_GENERIC;
}
return 0;
}
int LC_Client_UpdateReaderStates(LC_CLIENT *cl) {
LONG rv;
LPSTR mszGroups=0;
LPSTR mszReaders=0;
DWORD dwReaders=0;
const char *p;
int i, j;
assert(cl);
/* allocate buffer for reader list */
rv=SCardListReaders(cl->scardContext, /* context */
NULL, /* mszGroups */
NULL, /* mszReaders */
&dwReaders);
if (rv!=SCARD_S_SUCCESS) {
if (rv==SCARD_E_NO_READERS_AVAILABLE) {
DBG_ERROR(LC_LOGDOMAIN,
"No readers available");
}
else {
DBG_ERROR(LC_LOGDOMAIN,
"SCardListReaders(1): %08lx", (long unsigned int) rv);
}
return LC_Client_ResultIoError;
}
mszReaders=(LPSTR)malloc(sizeof(char)*dwReaders);
if (mszReaders==0) {
return LC_Client_ResultInternal;
}
/* list readers */
rv=SCardListReaders(cl->scardContext, /* context */
mszGroups, /* mszGroups */
mszReaders, /* mszReaders */
&dwReaders);
if (rv!=SCARD_S_SUCCESS) {
DBG_ERROR(LC_LOGDOMAIN,
"SCardListReaders(2): %04lx", (long unsigned int) rv);
return LC_Client_ResultIoError;
}
/* delete removed readers */
for (i=0; i<cl->readerCount; i++) {
int found=0;
/* find reader */
p=(const char*)mszReaders;
while(*p) {
if (strcasecmp(cl->readerStates[i].szReader, p)==0) {
/* re-assign reader name, because we are about to exchange the readerList string */
cl->readerStates[i].szReader=p;
found=1;
break;
}
while(*p)
p++;
p++;
} /* while */
if (!found) {
/* not in the reader list, remove */
for (j=i; j<(cl->readerCount-1); j++)
cl->readerStates[j]=cl->readerStates[j+1];
cl->readerCount--;
}
}
/* add new readers */
p=(const char*)mszReaders;
while(*p) {
i=LC_Client_FindReaderState(cl, p);
if (i!=-1) {
DBG_INFO(LC_LOGDOMAIN, "Reader \"%s\" already listed", p);
}
else {
if (cl->readerCount<MAX_READERS) {
DBG_INFO(LC_LOGDOMAIN, "Creating reader \"%s\"", p);
i=cl->readerCount;
/* preset */
memset((void*) &(cl->readerStates[i]), 0, sizeof(SCARD_READERSTATE));
cl->readerStates[i].szReader=p;
cl->readerStates[i].dwCurrentState=SCARD_STATE_UNAWARE;
/* reader added */
cl->readerCount++;
}
else {
DBG_ERROR(LC_LOGDOMAIN, "Too many readers (%d)",
cl->readerCount);
}
}
/* next reader */
while(*p)
p++;
p++;
} /* while */
if (cl->pnpAvailable) {
if (-1==LC_Client_FindReaderState(cl, "\\\\?PnP?\\Notification")) {
/* add pnp reader */
if (cl->readerCount<MAX_READERS) {
cl->readerStates[cl->readerCount].szReader = "\\\\?PnP?\\Notification";
cl->readerStates[cl->readerCount].dwCurrentState = SCARD_STATE_UNAWARE;
cl->readerCount++;
}
else {
DBG_ERROR(LC_LOGDOMAIN, "Too many readers (%d)",
cl->readerCount);
}
}
}
/* replace reader string */
free(cl->readerList);
cl->readerList=mszReaders;
return 0;
}
void EBC_Provider_LogRequestResults(AB_PROVIDER *pro,
EB_MSG *mRsp,
GWEN_BUFFER *logbuf) {
const char *tcode;
const char *bcode;
const char *s;
GWEN_BUFFER *tbuf;
tcode=EB_Msg_GetCharValue(mRsp, "header/mutable/ReturnCode", NULL);
bcode=EB_Msg_GetCharValue(mRsp, "body/ReturnCode", NULL);
tbuf=GWEN_Buffer_new(0, 256, 0, 1);
if (tcode) {
GWEN_Buffer_AppendString(tbuf, I18N("EBICS (Technical Code):"));
GWEN_Buffer_AppendString(tbuf, " ");
GWEN_Buffer_AppendString(tbuf, tcode);
s=EBC_Provider_TechnicalCodeToString(tcode);
if (s) {
GWEN_Buffer_AppendString(tbuf, " [");
GWEN_Buffer_AppendString(tbuf, s);
GWEN_Buffer_AppendString(tbuf, "]");
}
if (logbuf) {
GWEN_Buffer_AppendString(logbuf, "\t");
GWEN_Buffer_AppendBuffer(logbuf, tbuf);
}
GWEN_Gui_ProgressLog(0,
EBC_Provider_ResultCodeToLogLevel(pro, tcode),
GWEN_Buffer_GetStart(tbuf));
DBG_INFO(AQEBICS_LOGDOMAIN, "%s", GWEN_Buffer_GetStart(tbuf));
GWEN_Buffer_Reset(tbuf);
}
s=EB_Msg_GetCharValue(mRsp, "header/mutable/ReportText", NULL);
if (s) {
GWEN_Buffer_AppendString(tbuf, I18N("EBICS (Technical Report):"));
GWEN_Buffer_AppendString(tbuf, " ");
GWEN_Buffer_AppendString(tbuf, s);
if (logbuf) {
GWEN_Buffer_AppendString(logbuf, "\t");
GWEN_Buffer_AppendBuffer(logbuf, tbuf);
}
GWEN_Gui_ProgressLog(0,
GWEN_LoggerLevel_Notice,
GWEN_Buffer_GetStart(tbuf));
DBG_INFO(AQEBICS_LOGDOMAIN, "%s", GWEN_Buffer_GetStart(tbuf));
GWEN_Buffer_Reset(tbuf);
}
s=EB_Msg_GetCharValue(mRsp, "body/ReturnCode", NULL);
if (bcode) {
GWEN_Buffer_AppendString(tbuf, I18N("EBICS (Bank Code):"));
GWEN_Buffer_AppendString(tbuf, " ");
GWEN_Buffer_AppendString(tbuf, bcode);
s=EBC_Provider_BankCodeToString(bcode);
if (s) {
GWEN_Buffer_AppendString(tbuf, " [");
GWEN_Buffer_AppendString(tbuf, s);
GWEN_Buffer_AppendString(tbuf, "]");
}
if (logbuf) {
GWEN_Buffer_AppendString(logbuf, "\t");
GWEN_Buffer_AppendBuffer(logbuf, tbuf);
}
GWEN_Gui_ProgressLog(0,
EBC_Provider_ResultCodeToLogLevel(pro, bcode),
GWEN_Buffer_GetStart(tbuf));
DBG_INFO(AQEBICS_LOGDOMAIN, "%s", GWEN_Buffer_GetStart(tbuf));
GWEN_Buffer_Reset(tbuf);
}
GWEN_Buffer_free(tbuf);
}
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 EBC_Provider_UpdateJob(AB_PROVIDER *pro, AB_JOB *j) {
EBC_PROVIDER *dp;
AB_ACCOUNT *a;
AB_USER *u;
assert(pro);
dp=GWEN_INHERIT_GETDATA(AB_PROVIDER, EBC_PROVIDER, pro);
assert(dp);
a=AB_Job_GetAccount(j);
assert(a);
u=AB_Account_GetFirstUser(a);
if (u==NULL) {
DBG_ERROR(AQEBICS_LOGDOMAIN, "No user assigned to this account.");
GWEN_Gui_ProgressLog(0,
GWEN_LoggerLevel_Error,
I18N("No user assigned to this account."));
GWEN_Gui_ShowError(I18N("Setup Error"),
I18N("No user assigned to this account. Please assign one in the online banking setup dialog "
"for this account.\n"));
return GWEN_ERROR_INTERNAL;
}
switch(AB_Job_GetType(j)) {
case AB_Job_TypeTransfer: {
AB_TRANSACTION_LIMITS *lim;
lim=AB_TransactionLimits_new();
AB_TransactionLimits_SetMaxLenPurpose(lim, 27);
AB_TransactionLimits_SetMaxLenRemoteName(lim, 27);
AB_TransactionLimits_SetMaxLinesRemoteName(lim, 1);
AB_TransactionLimits_SetMaxLinesPurpose(lim, 2);
AB_TransactionLimits_AddValuesTextKey(lim, "51", 0);
AB_Job_SetFieldLimits(j, lim);
AB_TransactionLimits_free(lim);
break;
}
case AB_Job_TypeDebitNote: {
AB_TRANSACTION_LIMITS *lim;
lim=AB_TransactionLimits_new();
AB_TransactionLimits_SetMaxLenPurpose(lim, 27);
AB_TransactionLimits_SetMaxLenRemoteName(lim, 27);
AB_TransactionLimits_SetMaxLinesRemoteName(lim, 1);
AB_TransactionLimits_SetMaxLinesPurpose(lim, 2);
AB_TransactionLimits_AddValuesTextKey(lim, "05", 0);
AB_Job_SetFieldLimits(j, lim);
AB_TransactionLimits_free(lim);
break;
}
case AB_Job_TypeGetTransactions:
break;
case AB_Job_TypeGetBalance:
default:
DBG_INFO(AQEBICS_LOGDOMAIN,
"Job not yet supported (%d)",
AB_Job_GetType(j));
return GWEN_ERROR_NOT_SUPPORTED;
} /* switch */
return 0;
}
LC_CLIENT_RESULT LC_Client_GetNextCard(LC_CLIENT *cl, LC_CARD **pCard, int timeout) {
LONG rv;
int i;
uint32_t progressId;
time_t startt;
uint64_t to;
int distance;
assert(cl);
startt=time(0);
if (timeout==GWEN_TIMEOUT_NONE ||
timeout==GWEN_TIMEOUT_FOREVER)
to=0;
else
to=timeout;
progressId=GWEN_Gui_ProgressStart(GWEN_GUI_PROGRESS_DELAY |
GWEN_GUI_PROGRESS_ALLOW_EMBED |
GWEN_GUI_PROGRESS_SHOW_PROGRESS |
GWEN_GUI_PROGRESS_SHOW_ABORT,
I18N("Waiting for card to be inserted"),
NULL,
to,
0);
distance=GWEN_GUI_CHECK_PERIOD;
if (distance>timeout)
distance=timeout;
for (;;) {
double d;
int err;
/* continue checking */
for (i=cl->lastUsedReader+1; i<cl->readerCount; i++) {
/* we have a change here */
if (cl->readerStates[i].dwEventState & SCARD_STATE_CHANGED)
cl->readerStates[i].dwCurrentState=cl->readerStates[i].dwEventState;
else
continue;
DBG_DEBUG(LC_LOGDOMAIN, "Status changed on reader [%s] (%08x, %08x)",
cl->readerStates[i].szReader,
(unsigned int)(cl->readerStates[i].dwCurrentState),
(unsigned int)(cl->readerStates[i].dwEventState));
if (cl->pnpAvailable && i==cl->readerCount-1) {
/* pnp pseudo reader: a reader has been added or removed */
DBG_DEBUG(LC_LOGDOMAIN, "Pseudo reader, updating reader list (%08x, %08x)",
(unsigned int)(cl->readerStates[i].dwCurrentState),
(unsigned int)(cl->readerStates[i].dwEventState));
LC_Client_UpdateReaderStates(cl);
cl->lastUsedReader=-1;
break;
}
else {
if ((cl->readerStates[i].dwEventState & SCARD_STATE_PRESENT) &&
!(cl->readerStates[i].dwEventState & SCARD_STATE_EXCLUSIVE) &&
!(cl->readerStates[i].dwEventState & SCARD_STATE_INUSE)) {
LC_CLIENT_RESULT res;
LC_CARD *card=NULL;
/* card inserted and not used by another application */
DBG_DEBUG(LC_LOGDOMAIN, "Found usable card in reader [%s]", cl->readerStates[i].szReader);
res=LC_Client_ConnectCard(cl, cl->readerStates[i].szReader, &card);
if (res==LC_Client_ResultOk) {
/* card csuccessfully connected, return */
*pCard=card;
cl->lastUsedReader=i;
GWEN_Gui_ProgressEnd(progressId);
return LC_Client_ResultOk;
}
else {
DBG_ERROR(LC_LOGDOMAIN,
"Error connecting to card in reader [%s]",
cl->readerStates[i].szReader);
}
}
else {
DBG_INFO(LC_LOGDOMAIN, "Either no card in reader or card unavailable in reader [%s]",
cl->readerStates[i].szReader);
}
}
}
if (i>=cl->readerCount) {
/* there was no relevant change in a reader, wait for status change */
cl->lastUsedReader=-1;
rv=SCardGetStatusChange(cl->scardContext, distance, cl->readerStates, cl->readerCount);
if (rv==SCARD_E_TIMEOUT) {
/* timeout, just repeat next loop */
if (timeout==GWEN_TIMEOUT_NONE) {
GWEN_Gui_ProgressEnd(progressId);
return LC_Client_ResultWait;
}
}
else if (rv!=SCARD_S_SUCCESS) {
DBG_ERROR(LC_LOGDOMAIN, "SCardGetStatusChange: %d", (int) rv);
GWEN_Gui_ProgressEnd(progressId);
return LC_Client_ResultIoError;
}
}
/* check timeout */
d=difftime(time(0), startt);
if (timeout!=GWEN_TIMEOUT_FOREVER) {
if (timeout==GWEN_TIMEOUT_NONE ||
d>timeout) {
DBG_INFO(GWEN_LOGDOMAIN,
"Timeout (%d) while waiting, giving up",
timeout);
GWEN_Gui_ProgressEnd(progressId);
return LC_Client_ResultWait;
}
}
/* check for user abort */
err=GWEN_Gui_ProgressAdvance(progressId, (uint64_t)(d*1000));
if (err==GWEN_ERROR_USER_ABORTED) {
DBG_ERROR(GWEN_LOGDOMAIN, "User aborted");
GWEN_Gui_ProgressEnd(progressId);
return LC_Client_ResultAborted;
}
}
}
int EBC_Provider_ExecContext__IZV(AB_PROVIDER *pro,
AB_IMEXPORTER_CONTEXT *ctx,
AB_USER *u,
AB_ACCOUNT *a,
GWEN_HTTP_SESSION *sess,
EBC_CONTEXT *ectx){
EBC_PROVIDER *dp;
AB_JOB_LIST2_ITERATOR *jit;
AB_JOB_STATUS js;
AB_IMEXPORTER_CONTEXT *exCtx;
AB_IMEXPORTER_ACCOUNTINFO *ai;
GWEN_BUFFER *bufDtaus;
GWEN_TIME *currentTime;
GWEN_BUFFER *logbuf;
int rv;
const char *profileName=NULL;
const char *s;
const char *rqType;
uint32_t groupId=0;
assert(pro);
dp=GWEN_INHERIT_GETDATA(AB_PROVIDER, EBC_PROVIDER, pro);
assert(dp);
/* prepare CTX log */
logbuf=GWEN_Buffer_new(0, 256, 0, 1);
GWEN_Buffer_AppendString(logbuf, "BEGIN");
currentTime=GWEN_CurrentTime();
GWEN_Time_toString(currentTime, I18N("YYYY/MM/DD-hh:mm:ss"), logbuf);
GWEN_Time_free(currentTime);
GWEN_Buffer_AppendString(logbuf, "\t");
GWEN_Buffer_AppendString(logbuf, I18N("National Mass Transfer"));
GWEN_Buffer_AppendString(logbuf, "\n");
GWEN_Buffer_AppendString(logbuf, "\t");
GWEN_Buffer_AppendString(logbuf, I18N("Transfer type: "));
GWEN_Buffer_AppendString(logbuf, "\t");
switch(EBC_Context_GetJobType(ectx)) {
case AB_Job_TypeTransfer:
if (!profileName)
profileName="transfer";
GWEN_Buffer_AppendString(logbuf, I18N("Transfer"));
break;
case AB_Job_TypeDebitNote:
if (!profileName)
profileName="debitnote";
GWEN_Buffer_AppendString(logbuf, I18N("Debit Note"));
break;
default:
GWEN_Buffer_AppendString(logbuf, I18N("unknown"));
break;
}
GWEN_Buffer_AppendString(logbuf, "\n");
GWEN_Buffer_AppendString(logbuf, "\t");
GWEN_Buffer_AppendString(logbuf, I18N("Account: "));
GWEN_Buffer_AppendString(logbuf, "\t");
GWEN_Buffer_AppendString(logbuf, AB_Account_GetBankCode(a));
GWEN_Buffer_AppendString(logbuf, " / ");
GWEN_Buffer_AppendString(logbuf, AB_Account_GetAccountNumber(a));
GWEN_Buffer_AppendString(logbuf, "\n");
/* add a tab-less line to start a new table */
GWEN_Buffer_AppendString(logbuf, "Transactions\n");
DBG_INFO(AQEBICS_LOGDOMAIN, "Sampling transactions from jobs");
exCtx=AB_ImExporterContext_new();
ai=AB_ImExporterAccountInfo_new();
AB_ImExporterAccountInfo_FillFromAccount(ai, a);
jit=AB_Job_List2_First(EBC_Context_GetJobs(ectx));
if (jit) {
AB_JOB *uj;
uj=AB_Job_List2Iterator_Data(jit);
assert(uj);
while(uj) {
AB_TRANSACTION *t;
const GWEN_STRINGLIST *sl;
const char *s;
const AB_VALUE *v;
switch(EBC_Context_GetJobType(ectx)) {
case AB_Job_TypeTransfer:
case AB_Job_TypeDebitNote:
t=AB_Job_GetTransaction(uj);
break;
default:
t=NULL;
}
assert(t);
if (groupId==0)
/* take id from first job of the created DTAUS doc */
groupId=AB_Job_GetJobId(uj);
AB_Transaction_SetGroupId(t, groupId);
AB_ImExporterAccountInfo_AddTransaction(ai, AB_Transaction_dup(t));
sl=AB_Transaction_GetRemoteName(t);
s=NULL;
if (sl)
s=GWEN_StringList_FirstString(sl);
if (!s)
s=I18N("unknown");
GWEN_Buffer_AppendString(logbuf, s);
GWEN_Buffer_AppendString(logbuf, "\t");
s=AB_Transaction_GetRemoteBankCode(t);
if (!s)
s="????????";
GWEN_Buffer_AppendString(logbuf, s);
GWEN_Buffer_AppendString(logbuf, "\t");
s=AB_Transaction_GetRemoteAccountNumber(t);
if (!s)
s="??????????";
GWEN_Buffer_AppendString(logbuf, s);
GWEN_Buffer_AppendString(logbuf, "\t");
sl=AB_Transaction_GetPurpose(t);
s=NULL;
if (sl)
s=GWEN_StringList_FirstString(sl);
if (!s)
s="";
GWEN_Buffer_AppendString(logbuf, s);
GWEN_Buffer_AppendString(logbuf, "\t");
v=AB_Transaction_GetValue(t);
if (v)
AB_Value_toHumanReadableString(v, logbuf, 2);
else
GWEN_Buffer_AppendString(logbuf, "0,00 EUR");
GWEN_Buffer_AppendString(logbuf, "\n");
uj=AB_Job_List2Iterator_Next(jit);
} /* while */
AB_Job_List2Iterator_free(jit);
}
AB_ImExporterContext_AddAccountInfo(exCtx, ai);
GWEN_Buffer_AppendString(logbuf, I18N("Results:\n"));
/* export as DTAUS to bufDtaus */
bufDtaus=GWEN_Buffer_new(0, 1024, 0, 1);
DBG_INFO(AQEBICS_LOGDOMAIN, "Exporting transactions to DTAUS[default]");
rv=AB_Banking_ExportToBuffer(AB_Provider_GetBanking(pro),
exCtx,
"dtaus",
profileName,
bufDtaus);
if (rv<0) {
DBG_INFO(AQEBICS_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(bufDtaus);
EBC_Provider_SetJobListStatus(EBC_Context_GetJobs(ectx),
AB_Job_StatusError);
GWEN_Buffer_AppendString(logbuf, "\t");
GWEN_Buffer_AppendString(logbuf, I18N("Error while exporting to DTAUS\n"));
GWEN_Buffer_AppendString(logbuf, "END\n");
AB_ImExporterContext_AddLog(ctx, GWEN_Buffer_GetStart(logbuf));
GWEN_Buffer_free(logbuf);
return rv;
}
GWEN_Buffer_AppendString(logbuf, "\t");
GWEN_Buffer_AppendString(logbuf, I18N("Exporting to DTAUS: ok\n"));
/* exchange upload request */
DBG_INFO(AQEBICS_LOGDOMAIN, "Uploading.");
AB_HttpSession_ClearLog(sess);
if (EBC_Context_GetJobType(ectx)==AB_Job_TypeDebitNote) {
if (EBC_User_GetFlags(u) & EBC_USER_FLAGS_USE_IZL)
rqType="IZL";
else
rqType="IZV";
}
else
rqType="IZV";
rv=EBC_Provider_XchgUploadRequest(pro, sess, u, rqType,
(const uint8_t*)GWEN_Buffer_GetStart(bufDtaus),
GWEN_Buffer_GetUsedBytes(bufDtaus));
if (rv<0 || rv>=300)
js=AB_Job_StatusError;
else
js=AB_Job_StatusFinished;
s=AB_HttpSession_GetLog(sess);
if (s)
GWEN_Buffer_AppendString(logbuf, s);
GWEN_Buffer_AppendString(logbuf, "END\n");
AB_ImExporterContext_AddLog(ctx, GWEN_Buffer_GetStart(logbuf));
GWEN_Buffer_free(logbuf);
EBC_Provider_SetJobListStatus(EBC_Context_GetJobs(ectx), js);
DBG_INFO(AQEBICS_LOGDOMAIN, "Done");
return 0;
}
int GWEN_CryptMgr_Sign(GWEN_CRYPTMGR *cm, const uint8_t *pData, uint32_t lData, GWEN_BUFFER *dbuf) {
GWEN_SIGHEAD *sh;
GWEN_SIGTAIL *st;
GWEN_TIME *ti;
uint32_t pos;
uint32_t shPos;
uint8_t *p;
uint32_t l;
int rv;
GWEN_BUFFER *sigbuf;
assert(cm);
GWEN_Buffer_AppendByte(dbuf, GWEN_CRYPTMGR_TLV_SIGNEDOBJECT);
pos=GWEN_Buffer_GetPos(dbuf);
GWEN_Buffer_AppendByte(dbuf, 0);
GWEN_Buffer_AppendByte(dbuf, 0);
/* prepare signature head */
sh=GWEN_SigHead_new();
GWEN_SigHead_SetKeyName(sh, cm->localKeyName);
GWEN_SigHead_SetKeyNumber(sh, cm->localKeyNumber);
GWEN_SigHead_SetKeyVersion(sh, cm->localKeyVersion);
ti=GWEN_CurrentTime();
GWEN_SigHead_SetDateTime(sh, ti);
GWEN_Time_free(ti);
GWEN_SigHead_SetSignatureProfile(sh, cm->signatureProfile);
GWEN_SigHead_SetSignatureNumber(sh, 1);
/* write signature head to buffer */
shPos=GWEN_Buffer_GetPos(dbuf);
rv=GWEN_SigHead_toBuffer(sh, dbuf, GWEN_CRYPTMGR_TLV_SIGHEAD);
GWEN_SigHead_free(sh);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
return rv;
}
/* write data to buffer */
if (pData && lData)
GWEN_Tag16_DirectlyToBuffer(GWEN_CRYPTMGR_TLV_SIGDATA,
(const char*)pData,
lData,
dbuf);
/* sign data: signature head TLV + data TLV */
sigbuf=GWEN_Buffer_new(0, 300, 0, 1);
p=((uint8_t*)GWEN_Buffer_GetStart(dbuf))+shPos;
l=GWEN_Buffer_GetPos(dbuf)-shPos;
rv=GWEN_CryptMgr_SignData(cm, p, l, sigbuf);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(sigbuf);
return rv;
}
/* create signature tail */
st=GWEN_SigTail_new();
GWEN_SigTail_SetSignature(st,
(const uint8_t*)GWEN_Buffer_GetStart(sigbuf),
GWEN_Buffer_GetUsedBytes(sigbuf));
GWEN_Buffer_free(sigbuf);
GWEN_SigTail_SetSignatureNumber(st, 1);
/* write signature tail */
rv=GWEN_SigTail_toBuffer(st, dbuf, GWEN_CRYPTMGR_TLV_SIGTAIL);
GWEN_SigTail_free(st);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
return rv;
}
/* write complete size */
l=GWEN_Buffer_GetPos(dbuf)-pos-2;
p=(uint8_t*)GWEN_Buffer_GetStart(dbuf)+pos;
*(p++)=l & 0xff;
*p=(l>>8) & 0xff;
return 0;
}
int EBC_Provider_ExecQueue(AB_PROVIDER *pro,
AB_IMEXPORTER_CONTEXT *ctx) {
EBC_PROVIDER *dp;
EBC_USERQUEUE_LIST *uql;
int errors=0;
int oks=0;
int rv;
AB_BANKING *ab;
assert(pro);
dp=GWEN_INHERIT_GETDATA(AB_PROVIDER, EBC_PROVIDER, pro);
assert(dp);
ab=AB_Provider_GetBanking(pro);
assert(ab);
uql=EBC_Queue_GetUserQueues(dp->queue);
if (uql) {
EBC_USERQUEUE *uq;
uq=EBC_UserQueue_List_First(uql);
while(uq) {
AB_USER *u;
u=EBC_UserQueue_GetUser(uq);
assert(u);
GWEN_Gui_ProgressLog(0,
GWEN_LoggerLevel_Info,
I18N("Locking user"));
rv=AB_Banking_BeginExclUseUser(ab, u);
if (rv) {
DBG_INFO(AQEBICS_LOGDOMAIN, "here (%d)", rv);
errors++;
}
else {
GWEN_Gui_ProgressLog(0,
GWEN_LoggerLevel_Info,
I18N("Executing user queue"));
rv=EBC_Provider_ExecUserQueue(pro, ctx, uq);
if (rv)
errors++;
else
oks++;
if (rv==GWEN_ERROR_USER_ABORTED) {
DBG_INFO(AQEBICS_LOGDOMAIN, "User aborted");
GWEN_Gui_ProgressLog(0,
GWEN_LoggerLevel_Info,
I18N("Unlocking user"));
AB_Banking_EndExclUseUser(ab, u, 1);
return rv;
}
rv=AB_Banking_EndExclUseUser(ab, u, 0);
if (rv<0) {
DBG_INFO(AQEBICS_LOGDOMAIN, "here (%d)", rv);
}
}
uq=EBC_UserQueue_List_Next(uq);
} /* while */
}
return 0;
}
int GWEN_CryptMgr_Encrypt(GWEN_CRYPTMGR *cm, const uint8_t *pData, uint32_t lData, GWEN_BUFFER *dbuf) {
GWEN_CRYPTHEAD *ch;
uint32_t pos;
uint8_t *p;
uint32_t l;
int rv;
GWEN_BUFFER *cryptbuf;
GWEN_BUFFER *tbuf;
GWEN_CRYPT_KEY *mkey;
assert(cm);
/* generate a message key */
mkey=GWEN_Crypt_KeyBlowFish_Generate(GWEN_Crypt_CryptMode_Cbc, 256/8, 2);
if (mkey==NULL) {
DBG_ERROR(GWEN_LOGDOMAIN, "Unable to generate BLOWFISH key");
return GWEN_ERROR_GENERIC;
}
GWEN_Buffer_AppendByte(dbuf, GWEN_CRYPTMGR_TLV_ENCRYPTEDOBJECT);
pos=GWEN_Buffer_GetPos(dbuf);
GWEN_Buffer_AppendByte(dbuf, 0);
GWEN_Buffer_AppendByte(dbuf, 0);
/* prepare signature head */
ch=GWEN_CryptHead_new();
GWEN_CryptHead_SetKeyName(ch, cm->peerKeyName);
GWEN_CryptHead_SetKeyNumber(ch, cm->peerKeyNumber);
GWEN_CryptHead_SetKeyVersion(ch, cm->peerKeyVersion);
GWEN_CryptHead_SetCryptProfile(ch, cm->signatureProfile);
/* encrypt key */
cryptbuf=GWEN_Buffer_new(0, lData+256, 0, 1);
rv=GWEN_CryptMgr_EncryptKey(cm,
GWEN_Crypt_KeyBlowFish_GetKeyDataPtr(mkey),
GWEN_Crypt_KeyBlowFish_GetKeyDataLen(mkey),
cryptbuf);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(cryptbuf);
GWEN_CryptHead_free(ch);
GWEN_Crypt_Key_free(mkey);
return rv;
}
GWEN_CryptHead_SetKey(ch,
(const uint8_t*)GWEN_Buffer_GetStart(cryptbuf),
GWEN_Buffer_GetUsedBytes(cryptbuf));
GWEN_Buffer_free(cryptbuf);
/* write crypt head to buffer */
rv=GWEN_CryptHead_toBuffer(ch, dbuf, GWEN_CRYPTMGR_TLV_CRYPTHEAD);
GWEN_CryptHead_free(ch);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Crypt_Key_free(mkey);
return rv;
}
/* padd plain text data */
tbuf=GWEN_Buffer_new(0, lData+256, 0, 1);
GWEN_Buffer_AppendBytes(tbuf, (const char*)pData, lData);
GWEN_Padd_PaddWithAnsiX9_23(tbuf);
/* encrypt with message key */
cryptbuf=GWEN_Buffer_new(0, lData+256, 0, 1);
l=GWEN_Buffer_GetMaxUnsegmentedWrite(cryptbuf);
rv=GWEN_Crypt_Key_Encipher(mkey,
(const uint8_t*)GWEN_Buffer_GetStart(tbuf),
GWEN_Buffer_GetUsedBytes(tbuf),
(uint8_t*)GWEN_Buffer_GetStart(cryptbuf),
&l);
GWEN_Buffer_free(tbuf);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(cryptbuf);
GWEN_Crypt_Key_free(mkey);
return rv;
}
GWEN_Buffer_IncrementPos(cryptbuf, l);
GWEN_Buffer_AdjustUsedBytes(cryptbuf);
/* write encrypted data */
GWEN_Tag16_DirectlyToBuffer(GWEN_CRYPTMGR_TLV_CRYPTDATA,
GWEN_Buffer_GetStart(cryptbuf),
GWEN_Buffer_GetUsedBytes(cryptbuf),
dbuf);
GWEN_Buffer_free(cryptbuf);
GWEN_Crypt_Key_free(mkey);
/* write complete size */
l=GWEN_Buffer_GetPos(dbuf)-pos-2;
p=(uint8_t*)GWEN_Buffer_GetStart(dbuf)+pos;
*(p++)=l & 0xff;
*p=(l>>8) & 0xff;
return 0;
}
int Gtk2Gui_Dialog_Setup(GWEN_DIALOG *dlg, GtkWidget *parentWindow) {
GTK2_GUI_DIALOG *xdlg;
GWEN_WIDGET_TREE *wtree;
GWEN_WIDGET *w;
GtkWindow *gw;
int rv;
GList *tll;
assert(dlg);
xdlg=GWEN_INHERIT_GETDATA(GWEN_DIALOG, GTK2_GUI_DIALOG, dlg);
assert(xdlg);
wtree=GWEN_Dialog_GetWidgets(dlg);
if (wtree==NULL) {
DBG_ERROR(GWEN_LOGDOMAIN, "No widget tree in dialog");
return GWEN_ERROR_NOT_FOUND;
}
w=GWEN_Widget_Tree_GetFirst(wtree);
if (w==NULL) {
DBG_ERROR(GWEN_LOGDOMAIN, "No widgets in dialog");
return GWEN_ERROR_NOT_FOUND;
}
rv=Gtk2Gui_Dialog_SetupTree(w);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
return rv;
}
gw=GTK_WINDOW(GWEN_Widget_GetImplData(w, GTK2_DIALOG_WIDGET_REAL));
gtk_window_set_type_hint(GTK_WINDOW(gw), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_position (GTK_WINDOW (gw), GTK_WIN_POS_CENTER_ON_PARENT);
/*gtk_window_set_keep_above(GTK_WINDOW(gw), TRUE);*/
xdlg->mainWidget=GTK_WIDGET(gw);
tll=gtk_window_list_toplevels();
if (tll) {
GList* element;
GtkWindow *topLevel=NULL;
for (element = tll; element; element = g_list_next(element)) {
GtkWindow* win = GTK_WINDOW(element->data);
if (gtk_window_is_active(win)) {
topLevel=win;
break;
}
}
g_list_free(tll);
if (topLevel) {
DBG_NOTICE(GWEN_LOGDOMAIN, "Found active window [%s]",
gtk_window_get_title(topLevel));
gtk_window_set_transient_for(gw, topLevel);
}
else {
DBG_ERROR(GWEN_LOGDOMAIN, "No active window found...");
}
}
return 0;
}
int GWEN_CryptMgr_Verify(GWEN_CRYPTMGR *cm, const uint8_t *pData, uint32_t lData, GWEN_BUFFER *dbuf) {
GWEN_TAG16 *tag;
const uint8_t *p;
uint32_t l;
GWEN_SIGHEAD *sh=NULL;
GWEN_SIGTAIL *st=NULL;
const uint8_t *pSignedData=NULL;
uint32_t lSignedData=0;
int rv;
assert(cm);
if (lData<3) {
DBG_ERROR(GWEN_LOGDOMAIN, "Too few bytes");
return GWEN_ERROR_BAD_DATA;
}
tag=GWEN_Tag16_fromBuffer2(pData, lData, 0);
if (tag==NULL) {
DBG_ERROR(GWEN_LOGDOMAIN, "Data doesn't contain a valid TLV");
return GWEN_ERROR_BAD_DATA;
}
if (GWEN_Tag16_GetTagType(tag)!=GWEN_CRYPTMGR_TLV_SIGNEDOBJECT) {
DBG_ERROR(GWEN_LOGDOMAIN, "Data does not contain asigned object");
GWEN_Tag16_free(tag);
return GWEN_ERROR_BAD_DATA;
}
p=GWEN_Tag16_GetTagData(tag);
l=GWEN_Tag16_GetTagLength(tag);
/* read sighead */
if (l) {
GWEN_TAG16 *subtag;
subtag=GWEN_Tag16_fromBuffer2(p, l, 0);
if (subtag) {
if (GWEN_Tag16_GetTagType(subtag)==GWEN_CRYPTMGR_TLV_SIGHEAD) {
sh=GWEN_SigHead_fromBuffer(GWEN_Tag16_GetTagData(subtag),
GWEN_Tag16_GetTagLength(subtag));
if (sh) {
pSignedData=p;
lSignedData=GWEN_Tag16_GetTagSize(subtag);
}
}
p+=GWEN_Tag16_GetTagSize(subtag);
l-=GWEN_Tag16_GetTagSize(subtag);
GWEN_Tag16_free(subtag);
}
}
/* read and store signed data */
if (l) {
GWEN_TAG16 *subtag;
subtag=GWEN_Tag16_fromBuffer2(p, l, 0);
if (subtag) {
if (GWEN_Tag16_GetTagType(subtag)==GWEN_CRYPTMGR_TLV_SIGDATA) {
GWEN_Buffer_AppendBytes(dbuf,
GWEN_Tag16_GetTagData(subtag),
GWEN_Tag16_GetTagLength(subtag));
if ((pSignedData+lSignedData)==p) {
lSignedData+=GWEN_Tag16_GetTagSize(subtag);
}
else {
DBG_ERROR(GWEN_LOGDOMAIN, "data TLV must follow sighead TLV");
GWEN_Tag16_free(subtag);
GWEN_SigHead_free(sh);
GWEN_Tag16_free(tag);
return GWEN_ERROR_BAD_DATA;
}
}
p+=GWEN_Tag16_GetTagSize(subtag);
l-=GWEN_Tag16_GetTagSize(subtag);
GWEN_Tag16_free(subtag);
}
}
/* read sigtail (contains the signature) */
if (l) {
GWEN_TAG16 *subtag;
subtag=GWEN_Tag16_fromBuffer2(p, l, 0);
if (subtag) {
if (GWEN_Tag16_GetTagType(subtag)==GWEN_CRYPTMGR_TLV_SIGTAIL) {
st=GWEN_SigTail_fromBuffer(GWEN_Tag16_GetTagData(subtag),
GWEN_Tag16_GetTagLength(subtag));
}
p+=GWEN_Tag16_GetTagSize(subtag);
l-=GWEN_Tag16_GetTagSize(subtag);
GWEN_Tag16_free(subtag);
}
}
/* check for all needed components */
if (!(sh && st && pSignedData && lSignedData)) {
DBG_ERROR(GWEN_LOGDOMAIN, "Signed object is not complete");
GWEN_SigTail_free(st);
GWEN_SigHead_free(sh);
GWEN_Tag16_free(tag);
return GWEN_ERROR_BAD_DATA;
}
if (GWEN_SigHead_GetSignatureNumber(sh)!=GWEN_SigTail_GetSignatureNumber(st)) {
DBG_ERROR(GWEN_LOGDOMAIN, "Sighead doesn't match sigtail");
GWEN_SigTail_free(st);
GWEN_SigHead_free(sh);
GWEN_Tag16_free(tag);
return GWEN_ERROR_BAD_DATA;
}
/* store or check peer key info */
if (cm->peerKeyName==NULL) {
/* store peer info */
GWEN_CryptMgr_SetPeerKeyName(cm, GWEN_SigHead_GetKeyName(sh));
GWEN_CryptMgr_SetPeerKeyNumber(cm, GWEN_SigHead_GetKeyNumber(sh));
GWEN_CryptMgr_SetPeerKeyVersion(cm, GWEN_SigHead_GetKeyVersion(sh));
}
else {
const char *s;
/* compare peer info with expected info */
s=GWEN_SigHead_GetKeyName(sh);
if (!(cm->peerKeyName && s && (strcasecmp(cm->peerKeyName, s)==0) &&
(cm->peerKeyNumber==GWEN_SigHead_GetKeyNumber(sh)) &&
(cm->peerKeyVersion==GWEN_SigHead_GetKeyVersion(sh)))) {
DBG_ERROR(GWEN_LOGDOMAIN, "Unexpected peer key information in signature");
GWEN_SigTail_free(st);
GWEN_SigHead_free(sh);
GWEN_Tag16_free(tag);
return GWEN_ERROR_BAD_DATA;
}
}
/* verify signature */
rv=GWEN_CryptMgr_VerifyData(cm,
pSignedData, lSignedData,
GWEN_SigTail_GetSignaturePtr(st),
GWEN_SigTail_GetSignatureLen(st));
GWEN_SigTail_free(st);
GWEN_SigHead_free(sh);
GWEN_Tag16_free(tag);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
return rv;
}
return 0;
}
int AH_NewKeyFileDialog_CheckBankIniLetter(GWEN_DIALOG *dlg, AB_USER *u) {
AH_NEWKEYFILE_DIALOG *xdlg;
int rv;
GWEN_BUFFER *tbuf;
assert(dlg);
xdlg=GWEN_INHERIT_GETDATA(GWEN_DIALOG, AH_NEWKEYFILE_DIALOG, dlg);
assert(xdlg);
tbuf=GWEN_Buffer_new(0, 1024, 0, 1);
/* add HTML version of the INI letter */
GWEN_Buffer_AppendString(tbuf, "<html>");
GWEN_Buffer_AppendString(tbuf, I18N("<p>The following is the INI letter describing the keys of your bank. "
"Please look at it carefully and compare the information against that "
"in the letter from your bank.</p>"
"<p><font color=red><b>Important Warning:</b></font> Only proceed if the hash matches! "
"Contact your bank immediately if the hash does not match!</p>"));
rv=AH_Provider_GetIniLetterHtml(AB_User_GetProvider(u),
u,
1,
0,
tbuf,
1);
if (rv<0) {
DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d)", rv);
// TODO: show error message
GWEN_Buffer_free(tbuf);
return GWEN_DialogEvent_ResultHandled;
}
GWEN_Buffer_AppendString(tbuf, "</html>");
/* add ASCII version of the INI letter for frontends which don't support HTML */
GWEN_Buffer_AppendString(tbuf, I18N("The following is the INI letter describing the keys of your bank.\n"
"Please look at it carefully and compare the information against that\n"
"in the letter from your bank.\n"
"\n"
"IMPORTANT WARNING: Only proceed if the hash matches!\n"
"Contact your bank immediately if the hash does not match!\n\n"));
rv=AH_Provider_GetIniLetterTxt(AB_User_GetProvider(u),
u,
1,
0,
tbuf,
0);
if (rv<0) {
DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d)", rv);
// TODO: show error message
GWEN_Buffer_free(tbuf);
return GWEN_DialogEvent_ResultHandled;
}
if (1!=GWEN_Gui_MessageBox(GWEN_GUI_MSG_FLAGS_TYPE_INFO |
GWEN_GUI_MSG_FLAGS_CONFIRM_B1 |
GWEN_GUI_MSG_FLAGS_SEVERITY_DANGEROUS,
I18N("Check Bank Keys"),
GWEN_Buffer_GetStart(tbuf),
I18N("Keys are ok"),
I18N("Keys do not match!"),
NULL,
0)) {
GWEN_Buffer_free(tbuf);
return GWEN_ERROR_VERIFY;
}
GWEN_Buffer_free(tbuf);
return 0;
}
int EBC_Provider_EuSign_A004(AB_PROVIDER *pro,
AB_USER *u,
const char *requestType,
const uint8_t *pMsg,
uint32_t lMsg,
GWEN_BUFFER *sbuf) {
EBC_PROVIDER *dp;
GWEN_MDIGEST *md;
GWEN_BUFFER *hbuf;
GWEN_BUFFER *ebuf;
GWEN_CRYPT_TOKEN *ct;
const GWEN_CRYPT_TOKEN_CONTEXT *ctx;
const GWEN_CRYPT_TOKEN_KEYINFO *ki;
uint32_t keyId;
int ksize;
uint32_t l;
GWEN_CRYPT_PADDALGO *algo;
EB_EU *eu;
GWEN_TIME *ti;
int rv;
const char *userId;
assert(pro);
dp=GWEN_INHERIT_GETDATA(AB_PROVIDER, EBC_PROVIDER, pro);
assert(dp);
userId=AB_User_GetUserId(u);
md=GWEN_MDigest_Rmd160_new();
assert(md);
rv=GWEN_MDigest_Begin(md);
if (rv<0) {
DBG_INFO(AQEBICS_LOGDOMAIN, "here (%d)", rv);
GWEN_MDigest_free(md);
return rv;
}
rv=GWEN_MDigest_Update(md, pMsg, lMsg);
if (rv<0) {
DBG_INFO(AQEBICS_LOGDOMAIN, "here (%d)", rv);
GWEN_MDigest_free(md);
return rv;
}
rv=GWEN_MDigest_End(md);
if (rv<0) {
DBG_INFO(AQEBICS_LOGDOMAIN, "here (%d)", rv);
GWEN_MDigest_free(md);
return rv;
}
hbuf=GWEN_Buffer_new(0, GWEN_MDigest_GetDigestSize(md), 0, 1);
GWEN_Buffer_AppendBytes(hbuf,
(const char*)GWEN_MDigest_GetDigestPtr(md),
GWEN_MDigest_GetDigestSize(md));
GWEN_MDigest_free(md);
/* get crypt token and context */
rv=EBC_Provider_MountToken(pro, u, &ct, &ctx);
if (rv<0) {
DBG_INFO(AQEBICS_LOGDOMAIN, "here (%d)", rv);
return rv;
}
/* get key id */
keyId=GWEN_Crypt_Token_Context_GetSignKeyId(ctx);
ki=GWEN_Crypt_Token_GetKeyInfo(ct,
keyId,
0xffffffff,
0);
if (ki==NULL) {
DBG_INFO(AQEBICS_LOGDOMAIN,
"Keyinfo %04x not found on crypt token [%s:%s]",
keyId,
GWEN_Crypt_Token_GetTypeName(ct),
GWEN_Crypt_Token_GetTokenName(ct));
GWEN_Crypt_Token_Close(ct, 0, 0);
GWEN_Buffer_free(hbuf);
return GWEN_ERROR_NOT_FOUND;
}
ksize=GWEN_Crypt_Token_KeyInfo_GetKeySize(ki);
/* select padd algo */
algo=GWEN_Crypt_PaddAlgo_new(GWEN_Crypt_PaddAlgoId_Iso9796_2);
GWEN_Crypt_PaddAlgo_SetPaddSize(algo, ksize);
/* actually sign */
ebuf=GWEN_Buffer_new(0, ksize+16, 0, 1);
l=GWEN_Buffer_GetMaxUnsegmentedWrite(ebuf);
rv=GWEN_Crypt_Token_Sign(ct, keyId,
algo,
(const uint8_t*)GWEN_Buffer_GetStart(hbuf),
GWEN_Buffer_GetUsedBytes(hbuf),
(uint8_t*)GWEN_Buffer_GetPosPointer(ebuf),
&l,
NULL, /* ignore seq counter */
0);
GWEN_Crypt_PaddAlgo_free(algo);
if (rv<0) {
DBG_INFO(AQEBICS_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(ebuf);
GWEN_Buffer_free(hbuf);
return rv;
}
GWEN_Buffer_IncrementPos(ebuf, l);
GWEN_Buffer_AdjustUsedBytes(ebuf);
GWEN_Buffer_free(hbuf);
/* assemble EU */
eu=EB_Eu_new();
EB_Eu_SetVersion(eu, "A004");
EB_Eu_SetModLen(eu, ksize*8);
EB_Eu_SetJobType(eu, requestType);
EB_Eu_SetSignature(eu,
(const uint8_t*) GWEN_Buffer_GetStart(ebuf),
GWEN_Buffer_GetUsedBytes(ebuf));
GWEN_Buffer_free(ebuf);
ti=GWEN_CurrentTime();
EB_Eu_SetCreationTime(eu, ti);
EB_Eu_SetSignatureTime(eu, ti);
GWEN_Time_free(ti);
EB_Eu_SetUserId(eu, userId);
/* store EU in given buffer */
EB_Eu_toBuffer(eu, sbuf);
EB_Eu_free(eu);
return 0;
}
