1 /***************************************************************************
2     begin       : Tue Jun 03 2018
3     copyright   : (C) 2018 by Martin Preuss
4     email       : martin@libchipcard.de
5 
6  ***************************************************************************
7  *          Please see toplevel file COPYING for license details           *
8  ***************************************************************************/
9 
10 
11 #ifdef HAVE_CONFIG_H
12 # include <config.h>
13 #endif
14 
15 #include "provider_online.h"
16 
17 #include "aqhbci/banking/provider_l.h"
18 #include "aqhbci/applayer/adminjobs_l.h"
19 #include "aqhbci/msglayer/dialog_l.h"
20 
21 #include "aqhbci/admjobs/jobgetkeys_l.h"
22 #include "aqhbci/admjobs/jobsendkeys_l.h"
23 #include "aqhbci/admjobs/jobchangekeys_l.h"
24 #include "aqhbci/admjobs/jobgetsepainfo_l.h"
25 #include "aqhbci/admjobs/jobgetsysid_l.h"
26 #include "aqhbci/admjobs/jobgetbankinfo_l.h"
27 #include "aqhbci/admjobs/jobunblockpin_l.h"
28 
29 #include <gwenhywfar/gui.h>
30 
31 
32 
33 
AH_Provider_GetAccounts(AB_PROVIDER * pro,AB_USER * u,AB_IMEXPORTER_CONTEXT * ctx,int withProgress,int nounmount,int doLock)34 int AH_Provider_GetAccounts(AB_PROVIDER *pro, AB_USER *u,
35                             AB_IMEXPORTER_CONTEXT *ctx,
36                             int withProgress, int nounmount, int doLock)
37 {
38   AB_BANKING *ab;
39   AH_HBCI *h;
40   AH_JOB *job;
41   AH_OUTBOX *ob;
42   int rv;
43 
44   assert(pro);
45   assert(u);
46 
47   ab=AB_Provider_GetBanking(pro);
48   assert(ab);
49 
50   h=AH_Provider_GetHbci(pro);
51   assert(h);
52 
53   job=AH_Job_UpdateBank_new(pro, u);
54   if (!job) {
55     DBG_ERROR(AQHBCI_LOGDOMAIN, "Job not supported, should not happen");
56     return GWEN_ERROR_GENERIC;
57   }
58   AH_Job_AddSigner(job, AB_User_GetUserId(u));
59 
60   ob=AH_Outbox_new(pro);
61   AH_Outbox_AddJob(ob, job);
62 
63   rv=AH_Outbox_Execute(ob, ctx, withProgress, 1, doLock);
64   AH_Outbox_free(ob);
65   if (rv) {
66     DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not execute outbox.\n");
67     AH_Job_free(job);
68     if (!nounmount)
69       AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
70     return rv;
71   }
72 
73   /* always try to commit, even when there are errors */
74   rv=AH_Job_Commit(job, doLock);
75   if (rv) {
76     DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not commit result.\n");
77     AH_Job_free(job);
78     if (!nounmount)
79       AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
80     return rv;
81   }
82 
83   if (AH_Job_HasErrors(job)) {
84     DBG_ERROR(AQHBCI_LOGDOMAIN, "Job has errors, but accounts may have been received.");
85     AH_Job_free(job);
86     if (!nounmount)
87       AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
88     return GWEN_ERROR_GENERIC;
89   }
90 
91   AH_Job_free(job);
92   if (!nounmount)
93     AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
94   return 0;
95 }
96 
97 
98 
AH_Provider_GetBankInfo(AB_PROVIDER * pro,AB_USER * u,AB_IMEXPORTER_CONTEXT * ctx,int withTanSeg,int withProgress,int nounmount,int doLock)99 int AH_Provider_GetBankInfo(AB_PROVIDER *pro, AB_USER *u,
100                             AB_IMEXPORTER_CONTEXT *ctx,
101                             int withTanSeg,
102                             int withProgress, int nounmount, int doLock)
103 {
104   AB_BANKING *ab;
105   AH_HBCI *h;
106   AH_JOB *job;
107   AH_OUTBOX *ob;
108   int rv;
109 
110   assert(pro);
111   assert(u);
112 
113   ab=AB_Provider_GetBanking(pro);
114   assert(ab);
115 
116   h=AH_Provider_GetHbci(pro);
117   assert(h);
118 
119   job=AH_Job_GetBankInfo_new(pro, u, withTanSeg);
120   if (!job) {
121     DBG_ERROR(AQHBCI_LOGDOMAIN, "Job not supported, should not happen");
122     return GWEN_ERROR_GENERIC;
123   }
124 
125   ob=AH_Outbox_new(pro);
126   AH_Outbox_AddJob(ob, job);
127 
128   rv=AH_Outbox_Execute(ob, ctx, withProgress, 1, doLock);
129   AH_Outbox_free(ob);
130   if (rv) {
131     DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not execute outbox.\n");
132     AH_Job_free(job);
133     if (!nounmount)
134       AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
135     return rv;
136   }
137 
138   if (AH_Job_HasErrors(job)) {
139     DBG_ERROR(AQHBCI_LOGDOMAIN, "Job has errors");
140     // TODO: show errors
141     AH_Job_free(job);
142     if (!nounmount)
143       AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
144     return GWEN_ERROR_GENERIC;
145   }
146   else {
147     rv=AH_Job_Commit(job, doLock);
148     if (rv) {
149       DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not commit result.\n");
150       AH_Job_free(job);
151       if (!nounmount)
152         AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
153       return rv;
154     }
155   }
156 
157   AH_Job_free(job);
158   if (!nounmount)
159     AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
160   return 0;
161 }
162 
163 
164 
AH_Provider_GetSysId(AB_PROVIDER * pro,AB_USER * u,AB_IMEXPORTER_CONTEXT * ctx,int withProgress,int nounmount,int doLock)165 int AH_Provider_GetSysId(AB_PROVIDER *pro, AB_USER *u,
166                          AB_IMEXPORTER_CONTEXT *ctx,
167                          int withProgress, int nounmount, int doLock)
168 {
169   AB_BANKING *ab;
170   AH_HBCI *h;
171   AH_JOB *job;
172   int rv;
173   const char *s;
174   int i;
175   char tbuf[256];
176 
177   assert(pro);
178   assert(u);
179 
180   ab=AB_Provider_GetBanking(pro);
181   assert(ab);
182 
183   h=AH_Provider_GetHbci(pro);
184   assert(h);
185 
186   job=0;
187   rv=0;
188   for (i=0; ; i++) {
189     AH_OUTBOX *ob;
190 
191     job=AH_Job_GetSysId_new(pro, u);
192     if (!job) {
193       DBG_ERROR(AQHBCI_LOGDOMAIN, "Job not supported, should not happen");
194       return GWEN_ERROR_GENERIC;
195     }
196     AH_Job_AddSigner(job, AB_User_GetUserId(u));
197 
198     ob=AH_Outbox_new(pro);
199     AH_Outbox_AddJob(ob, job);
200 
201     rv=AH_Outbox_Execute(ob, ctx, withProgress, 1, doLock);
202     AH_Outbox_free(ob);
203     if (rv) {
204       DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not execute outbox.\n");
205       AH_Job_free(job);
206       if (!nounmount)
207         AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
208       return rv;
209     }
210 
211     /* check whether we received a sysid */
212     s=AH_Job_GetSysId_GetSysId(job);
213     if (s && *s) {
214       /* we did, commit the job and break loop */
215       rv=AH_Job_Commit(job, doLock);
216       if (rv<0) {
217         DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not commit result.\n");
218         AH_Job_free(job);
219         if (!nounmount)
220           AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
221         return rv;
222       }
223       break;
224     }
225 
226     if (AH_Job_HasItanResult(job)) {
227       GWEN_Gui_ProgressLog(0,
228                            GWEN_LoggerLevel_Notice,
229                            I18N("Adjusting to iTAN modes of the server"));
230       rv=AH_Job_Commit(job, doLock);
231       if (rv) {
232         DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not commit result.\n");
233         AH_Job_free(job);
234         if (!nounmount)
235           AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
236         return rv;
237       }
238 
239 #if 0
240       /* save user in order to get the info written to config database for
241        * inspection while debugging
242        */
243       rv=AB_Banking_SaveUser(ab, u);
244       if (rv<0) {
245         DBG_ERROR(AQHBCI_LOGDOMAIN, "Error saving user (%d)", rv);
246         AH_Outbox_free(ob);
247         if (!nounmount)
248           AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
249         return rv;
250       }
251 #endif
252 
253       rv=GWEN_Gui_ProgressLog(0,
254                               GWEN_LoggerLevel_Notice,
255                               I18N("Retrying to get system id."));
256       if (rv) {
257         DBG_ERROR(AQHBCI_LOGDOMAIN, "Error in progress log, maybe user aborted?");
258         AH_Job_free(job);
259         if (!nounmount)
260           AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
261         return rv;
262       }
263     }
264     else {
265       DBG_ERROR(AQHBCI_LOGDOMAIN, "Job has no system id and no iTAN results");
266       // TODO: show errors
267       AH_Job_free(job);
268       if (!nounmount)
269         AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
270       return GWEN_ERROR_GENERIC;
271     }
272 
273     AH_Job_free(job);
274     if (i>1) {
275       DBG_ERROR(AQHBCI_LOGDOMAIN, "Tried too often, giving up");
276       GWEN_Gui_ProgressLog(0,
277                            GWEN_LoggerLevel_Error,
278                            I18N("Could not get system id after multiple trials"));
279       if (!nounmount)
280         AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
281       return GWEN_ERROR_GENERIC;
282     }
283   } /* for */
284 
285   /* lock user */
286   if (doLock) {
287     rv=AB_Provider_BeginExclUseUser(pro, u);
288     if (rv) {
289       DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not lock user (%d)\n", rv);
290       AH_Job_free(job);
291       if (!nounmount)
292         AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
293       return rv;
294     }
295   }
296 
297   s=AH_Job_GetSysId_GetSysId(job);
298   if (!s) {
299     DBG_ERROR(AQHBCI_LOGDOMAIN, "No system id");
300     if (doLock)
301       AB_Provider_EndExclUseUser(pro, u, 1);
302     AH_Job_free(job);
303     if (!nounmount)
304       AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
305     return GWEN_ERROR_NO_DATA;
306   }
307 
308   AH_User_SetSystemId(u, s);
309   AH_Job_free(job);
310 
311   /* unlock user */
312   if (doLock) {
313     rv=AB_Provider_EndExclUseUser(pro, u, 0);
314     if (rv<0) {
315       DBG_INFO(AQHBCI_LOGDOMAIN,
316                "Could not unlock customer [%s] (%d)",
317                AB_User_GetCustomerId(u), rv);
318       snprintf(tbuf, sizeof(tbuf)-1,
319                I18N("Could not unlock user %s (%d)"),
320                AB_User_GetUserId(u), rv);
321       tbuf[sizeof(tbuf)-1]=0;
322       GWEN_Gui_ProgressLog(0,
323                            GWEN_LoggerLevel_Error,
324                            tbuf);
325       AB_Provider_EndExclUseUser(pro, u, 1);
326       if (!nounmount)
327         AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
328       return rv;
329     }
330   }
331 
332   if (!nounmount)
333     AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
334 
335   return 0;
336 }
337 
338 
339 
AH_Provider_GetServerKeys(AB_PROVIDER * pro,AB_USER * u,AB_IMEXPORTER_CONTEXT * ctx,int withProgress,int nounmount,int doLock)340 int AH_Provider_GetServerKeys(AB_PROVIDER *pro, AB_USER *u,
341                               AB_IMEXPORTER_CONTEXT *ctx,
342                               int withProgress, int nounmount, int doLock)
343 {
344   AB_BANKING *ab;
345   AH_HBCI *h;
346   AH_JOB *job;
347   AH_OUTBOX *ob;
348   int rv;
349   GWEN_CRYPT_TOKEN *ct;
350   const GWEN_CRYPT_TOKEN_CONTEXT *cctx;
351   const char *s;
352 
353   assert(pro);
354   assert(u);
355 
356   ab=AB_Provider_GetBanking(pro);
357   assert(ab);
358 
359   h=AH_Provider_GetHbci(pro);
360   assert(h);
361 
362   job=AH_Job_GetKeys_new(pro, u);
363   if (!job) {
364     DBG_ERROR(AQHBCI_LOGDOMAIN, "Job not supported, should not happen");
365     return GWEN_ERROR_GENERIC;
366   }
367 
368   ob=AH_Outbox_new(pro);
369   AH_Outbox_AddJob(ob, job);
370 
371   rv=AH_Outbox_Execute(ob, ctx, withProgress, 1, doLock);
372 
373   AH_Outbox_free(ob);
374   if (rv) {
375     GWEN_Gui_ProgressLog(0,
376                          GWEN_LoggerLevel_Error,
377                          I18N("Could not execute outbox."));
378     AH_Job_free(job);
379     if (!nounmount)
380       AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
381     return rv;
382   }
383 
384   /* Store crypt and sign keys in database */
385   if (AH_Job_GetKeys_GetCryptKeyInfo(job)==NULL && AH_Job_GetKeys_GetSignKeyInfo(job)==NULL) {
386     DBG_ERROR(AQHBCI_LOGDOMAIN, "No crypt key and no sign key received");
387     GWEN_Gui_ProgressLog(0,
388                          GWEN_LoggerLevel_Error,
389                          I18N("No crypt key and no sign key received."));
390     AH_Job_free(job);
391     if (!nounmount)
392       AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
393     return GWEN_ERROR_GENERIC;
394   }
395   else {
396     rv=AH_Job_Commit(job, doLock);
397     if (rv) {
398       DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not commit result.\n");
399       GWEN_Gui_ProgressLog(0,
400                            GWEN_LoggerLevel_Error,
401                            I18N("Could not commit result"));
402       AH_Job_free(job);
403       if (!nounmount)
404         AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
405       return rv;
406     }
407   }
408 
409   /* lock user */
410   if (doLock) {
411     rv=AB_Provider_BeginExclUseUser(pro, u);
412     if (rv) {
413       DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not lock user (%d)\n", rv);
414       AH_Job_free(job);
415       if (!nounmount)
416         AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
417       return rv;
418     }
419   }
420 
421   s=AH_User_GetPeerId(u);
422   if (!s || !*s) {
423     s=AH_Job_GetKeys_GetPeerId(job);
424     if (s && *s) {
425       char tbuf[256];
426 
427       snprintf(tbuf, sizeof(tbuf)-1, I18N("Setting peer ID to \"%s\")"), s);
428       tbuf[sizeof(tbuf)-1]=0;
429       GWEN_Gui_ProgressLog(0,
430                            GWEN_LoggerLevel_Notice,
431                            tbuf);
432       AH_User_SetPeerId(u, s);
433     }
434   }
435 
436   /* get crypt token */
437   rv=AB_Banking_GetCryptToken(AH_HBCI_GetBankingApi(h),
438                               AH_User_GetTokenType(u),
439                               AH_User_GetTokenName(u),
440                               &ct);
441   if (rv) {
442     DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not get crypt token (%d)", rv);
443     GWEN_Gui_ProgressLog(0,
444                          GWEN_LoggerLevel_Error,
445                          I18N("Error getting crypt token"));
446     if (doLock)
447       AB_Provider_EndExclUseUser(pro, u, 0);
448     AH_Job_free(job);
449     if (!nounmount)
450       AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
451     return rv;
452   }
453 
454   /* open crypt token */
455   rv=GWEN_Crypt_Token_Open(ct, 1, 0);
456   if (rv) {
457     DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not open crypt token (%d)", rv);
458     GWEN_Gui_ProgressLog(0,
459                          GWEN_LoggerLevel_Error,
460                          I18N("Error opening crypt token"));
461     if (doLock)
462       AB_Provider_EndExclUseUser(pro, u, 0);
463     AH_Job_free(job);
464     if (!nounmount)
465       AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
466     return rv;
467   }
468 
469   /* get context */
470   cctx=GWEN_Crypt_Token_GetContext(ct, AH_User_GetTokenContextId(u), 0);
471   if (!cctx) {
472     DBG_ERROR(AQHBCI_LOGDOMAIN, "User context not found on crypt token");
473     GWEN_Gui_ProgressLog(0,
474                          GWEN_LoggerLevel_Error,
475                          I18N("User context not found on crypt token"));
476     if (doLock)
477       AB_Provider_EndExclUseUser(pro, u, 0);
478     AH_Job_free(job);
479     if (!nounmount)
480       AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
481     return GWEN_ERROR_NOT_FOUND;
482   }
483   else {
484     GWEN_CRYPT_TOKEN_KEYINFO *ki;
485     uint32_t kid;
486 
487     /* store sign key on token (if any) */
488     kid=GWEN_Crypt_Token_Context_GetVerifyKeyId(cctx);
489     ki=AH_Job_GetKeys_GetSignKeyInfo(job);
490     if (kid && ki) {
491       rv=GWEN_Crypt_Token_SetKeyInfo(ct,
492                                      kid,
493                                      ki,
494                                      0);
495       if (rv) {
496         DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not save key info (%d)", rv);
497         GWEN_Gui_ProgressLog(0, GWEN_LoggerLevel_Error,
498                              I18N("Error saving sign key"));
499         if (doLock)
500           AB_Provider_EndExclUseUser(pro, u, 0);
501         AH_Job_free(job);
502         if (!nounmount)
503           AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
504         return rv;
505       }
506       DBG_INFO(AQHBCI_LOGDOMAIN, "Sign key saved");
507     }
508 
509     /* store crypt key on token */
510     kid=GWEN_Crypt_Token_Context_GetEncipherKeyId(cctx);
511     ki=AH_Job_GetKeys_GetCryptKeyInfo(job);
512     if (kid && ki) {
513       rv=GWEN_Crypt_Token_SetKeyInfo(ct,
514                                      kid,
515                                      ki,
516                                      0);
517       if (rv) {
518         DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not save key info (%d)", rv);
519         GWEN_Gui_ProgressLog(0, GWEN_LoggerLevel_Error,
520                              I18N("Error saving crypt key"));
521         if (doLock)
522           AB_Provider_EndExclUseUser(pro, u, 0);
523         AH_Job_free(job);
524         if (!nounmount)
525           AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
526         return rv;
527       }
528       DBG_INFO(AQHBCI_LOGDOMAIN, "Crypt key saved");
529     }
530 
531     /* store auth key on token (if any) */
532     kid=GWEN_Crypt_Token_Context_GetAuthVerifyKeyId(cctx);
533     ki=AH_Job_GetKeys_GetAuthKeyInfo(job);
534     if (kid && ki) {
535       rv=GWEN_Crypt_Token_SetKeyInfo(ct,
536                                      kid,
537                                      ki,
538                                      0);
539       if (rv) {
540         DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not save key info (%d)", rv);
541         GWEN_Gui_ProgressLog(0, GWEN_LoggerLevel_Error,
542                              I18N("Error saving auth key"));
543         if (doLock)
544           AB_Provider_EndExclUseUser(pro, u, 0);
545         AH_Job_free(job);
546         if (!nounmount)
547           AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
548         return rv;
549       }
550       DBG_INFO(AQHBCI_LOGDOMAIN, "Auth key saved");
551     }
552   }
553 
554   AH_Job_free(job);
555   GWEN_Gui_ProgressLog(0,
556                        GWEN_LoggerLevel_Notice,
557                        I18N("Keys saved."));
558 
559   /* unlock user */
560   if (doLock) {
561     rv=AB_Provider_EndExclUseUser(pro, u, 0);
562     if (rv) {
563       DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not unlock user (%d)\n", rv);
564       if (!nounmount)
565         AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
566       return rv;
567     }
568   }
569 
570   if (!nounmount)
571     AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
572 
573   return 0;
574 }
575 
576 
577 
AH_Provider_SendUserKeys2(AB_PROVIDER * pro,AB_USER * u,AB_IMEXPORTER_CONTEXT * ctx,int withAuthKey,int withProgress,int nounmount,int doLock)578 int AH_Provider_SendUserKeys2(AB_PROVIDER *pro, AB_USER *u,
579                               AB_IMEXPORTER_CONTEXT *ctx,
580                               int withAuthKey,
581                               int withProgress, int nounmount, int doLock)
582 {
583   AB_BANKING *ab;
584   AH_HBCI *h;
585   AH_JOB *job;
586   AH_OUTBOX *ob;
587   int rv;
588   GWEN_CRYPT_TOKEN *ct;
589   uint32_t kid;
590   const GWEN_CRYPT_TOKEN_CONTEXT *cctx;
591   GWEN_CRYPT_TOKEN_KEYINFO *signKeyInfo=NULL;
592   GWEN_CRYPT_TOKEN_KEYINFO *cryptKeyInfo=NULL;
593   GWEN_CRYPT_TOKEN_KEYINFO *authKeyInfo=NULL;
594   int mounted=0;
595 
596   assert(pro);
597   assert(u);
598 
599   ab=AB_Provider_GetBanking(pro);
600   assert(ab);
601 
602   h=AH_Provider_GetHbci(pro);
603   assert(h);
604 
605   /* get crypt token */
606   rv=AB_Banking_GetCryptToken(AH_HBCI_GetBankingApi(h),
607                               AH_User_GetTokenType(u),
608                               AH_User_GetTokenName(u),
609                               &ct);
610   if (rv) {
611     DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not get crypt token (%d)", rv);
612     GWEN_Gui_ProgressLog(0,
613                          GWEN_LoggerLevel_Error,
614                          I18N("Error getting crypt token"));
615     if (!nounmount)
616       AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
617     return rv;
618   }
619 
620   /* open crypt token */
621   rv=GWEN_Crypt_Token_Open(ct, 1, 0);
622   if (rv) {
623     DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not open crypt token (%d)", rv);
624     GWEN_Gui_ProgressLog(0,
625                          GWEN_LoggerLevel_Error,
626                          I18N("Error opening crypt token"));
627     if (!nounmount)
628       AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
629     return rv;
630   }
631 
632   /* get context */
633   cctx=GWEN_Crypt_Token_GetContext(ct, AH_User_GetTokenContextId(u), 0);
634   if (!cctx) {
635     DBG_ERROR(AQHBCI_LOGDOMAIN, "User context not found on crypt token");
636     GWEN_Gui_ProgressLog(0,
637                          GWEN_LoggerLevel_Error,
638                          I18N("User context not found on crypt token"));
639     if (!nounmount)
640       AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
641     return GWEN_ERROR_NOT_FOUND;
642   }
643 
644   /* get sign key info */
645   kid=GWEN_Crypt_Token_Context_GetSignKeyId(cctx);
646   if (kid) {
647     uint32_t ctxSignKeyNum=GWEN_Crypt_Token_Context_GetSignKeyNum(cctx);
648     const GWEN_CRYPT_TOKEN_KEYINFO *signKeyInfoCT=GWEN_Crypt_Token_GetKeyInfo(ct, kid,
649                                                                               GWEN_CRYPT_TOKEN_KEYFLAGS_HASMODULUS |
650                                                                               GWEN_CRYPT_TOKEN_KEYFLAGS_HASEXPONENT |
651                                                                               GWEN_CRYPT_TOKEN_KEYFLAGS_HASKEYVERSION |
652                                                                               GWEN_CRYPT_TOKEN_KEYFLAGS_HASKEYNUMBER,
653                                                                               0);
654     if (signKeyInfoCT==NULL) {
655       DBG_ERROR(AQHBCI_LOGDOMAIN, "Sign key info not found on crypt token");
656       GWEN_Gui_ProgressLog(0,
657                            GWEN_LoggerLevel_Error,
658                            I18N("Sign key info not found on crypt token"));
659       if (!nounmount)
660         AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
661       return GWEN_ERROR_NOT_FOUND;
662     }
663     signKeyInfo=GWEN_Crypt_Token_KeyInfo_dup(signKeyInfoCT);
664     if (ctxSignKeyNum) {
665       GWEN_Crypt_Token_KeyInfo_SetKeyNumber(signKeyInfo, ctxSignKeyNum);
666       GWEN_Crypt_Token_KeyInfo_SetKeyVersion(signKeyInfo, GWEN_Crypt_Token_Context_GetSignKeyVer(cctx));
667     }
668 
669   }
670   else {
671     DBG_INFO(AQHBCI_LOGDOMAIN, "No sign key id");
672   }
673 
674   /* get crypt key info */
675   kid=GWEN_Crypt_Token_Context_GetDecipherKeyId(cctx);
676   if (kid) {
677     uint32_t ctxCryptKeyNum=GWEN_Crypt_Token_Context_GetDecipherKeyNum(cctx);
678     const GWEN_CRYPT_TOKEN_KEYINFO *cryptKeyInfoCT=GWEN_Crypt_Token_GetKeyInfo(ct, kid,
679                                                                                GWEN_CRYPT_TOKEN_KEYFLAGS_HASMODULUS |
680                                                                                GWEN_CRYPT_TOKEN_KEYFLAGS_HASEXPONENT |
681                                                                                GWEN_CRYPT_TOKEN_KEYFLAGS_HASKEYVERSION |
682                                                                                GWEN_CRYPT_TOKEN_KEYFLAGS_HASKEYNUMBER,
683                                                                                0);
684     if (cryptKeyInfoCT==NULL) {
685       DBG_ERROR(AQHBCI_LOGDOMAIN, "Crypt key info not found on crypt token");
686       GWEN_Gui_ProgressLog(0,
687                            GWEN_LoggerLevel_Error,
688                            I18N("Crypt key info not found on crypt token"));
689       if (!nounmount)
690         AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
691       return GWEN_ERROR_NOT_FOUND;
692     }
693     cryptKeyInfo=GWEN_Crypt_Token_KeyInfo_dup(cryptKeyInfoCT);
694     if (ctxCryptKeyNum) {
695       GWEN_Crypt_Token_KeyInfo_SetKeyNumber(cryptKeyInfo, ctxCryptKeyNum);
696       GWEN_Crypt_Token_KeyInfo_SetKeyVersion(cryptKeyInfo, GWEN_Crypt_Token_Context_GetDecipherKeyVer(cctx));
697     }
698   }
699   else {
700     DBG_INFO(AQHBCI_LOGDOMAIN, "No decipher key id");
701   }
702 
703   /* get auth sign key info */
704   if (withAuthKey) {
705     kid=GWEN_Crypt_Token_Context_GetAuthSignKeyId(cctx);
706     if (kid) {
707       uint32_t ctxAuthKeyNum=GWEN_Crypt_Token_Context_GetAuthSignKeyNum(cctx);
708       const GWEN_CRYPT_TOKEN_KEYINFO *authKeyInfoCT=GWEN_Crypt_Token_GetKeyInfo(ct, kid,
709                                                                                 GWEN_CRYPT_TOKEN_KEYFLAGS_HASMODULUS |
710                                                                                 GWEN_CRYPT_TOKEN_KEYFLAGS_HASEXPONENT |
711                                                                                 GWEN_CRYPT_TOKEN_KEYFLAGS_HASKEYVERSION |
712                                                                                 GWEN_CRYPT_TOKEN_KEYFLAGS_HASKEYNUMBER,
713                                                                                 0);
714       if (authKeyInfoCT==NULL) {
715         DBG_ERROR(AQHBCI_LOGDOMAIN, "Auth key info not found on crypt token");
716         GWEN_Gui_ProgressLog(0,
717                              GWEN_LoggerLevel_Error,
718                              I18N("Auth key info not found on crypt token"));
719         if (!nounmount)
720           AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
721         return GWEN_ERROR_NOT_FOUND;
722       }
723       authKeyInfo=GWEN_Crypt_Token_KeyInfo_dup(authKeyInfoCT);
724       if (ctxAuthKeyNum) {
725         GWEN_Crypt_Token_KeyInfo_SetKeyNumber(authKeyInfo, ctxAuthKeyNum);
726         GWEN_Crypt_Token_KeyInfo_SetKeyVersion(authKeyInfo, GWEN_Crypt_Token_Context_GetAuthSignKeyVer(cctx));
727       }
728     }
729     else {
730       DBG_INFO(AQHBCI_LOGDOMAIN, "No auth key id");
731     }
732   }
733 
734   /* create job */
735   job=AH_Job_SendKeys_new(pro, u, cryptKeyInfo, signKeyInfo, authKeyInfo);
736 
737   /* free keyinfos */
738   if (signKeyInfo) {
739     GWEN_Crypt_Token_KeyInfo_free(signKeyInfo);
740   }
741   if (cryptKeyInfo) {
742     GWEN_Crypt_Token_KeyInfo_free(cryptKeyInfo);
743   }
744   if (authKeyInfo) {
745     GWEN_Crypt_Token_KeyInfo_free(authKeyInfo);
746   }
747 
748   if (!job) {
749     DBG_ERROR(AQHBCI_LOGDOMAIN, "Job not supported, should not happen");
750     GWEN_Gui_ProgressLog(0,
751                          GWEN_LoggerLevel_Error,
752                          I18N("Job not supported, should not happen"));
753     if (!nounmount && mounted)
754       AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
755     return GWEN_ERROR_GENERIC;
756   }
757   AH_Job_AddSigner(job, AB_User_GetUserId(u));
758 
759   /* enqueue job */
760   ob=AH_Outbox_new(pro);
761   AH_Outbox_AddJob(ob, job);
762 
763   /* execute queue */
764   rv=AH_Outbox_Execute(ob, ctx, withProgress, 0, doLock);
765   AH_Outbox_free(ob);
766   if (rv) {
767     GWEN_Gui_ProgressLog(0,
768                          GWEN_LoggerLevel_Error,
769                          I18N("Could not execute outbox."));
770     AH_Job_free(job);
771     if (!nounmount && mounted)
772       AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
773     return rv;
774   }
775 
776   /* check result */
777   if (AH_Job_HasErrors(job)) {
778     DBG_ERROR(AQHBCI_LOGDOMAIN, "Job has errors");
779     GWEN_Gui_ProgressLog(0,
780                          GWEN_LoggerLevel_Error,
781                          I18N("Job contains errors."));
782     AH_Job_free(job);
783     if (!nounmount && mounted)
784       AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
785     return GWEN_ERROR_GENERIC;
786   }
787   else {
788     rv=AH_Job_Commit(job, doLock);
789     if (rv) {
790       DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not commit result.\n");
791       GWEN_Gui_ProgressLog(0,
792                            GWEN_LoggerLevel_Error,
793                            I18N("Could not commit result"));
794       AH_Job_free(job);
795       if (!nounmount && mounted)
796         AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
797       return rv;
798     }
799   }
800 
801   GWEN_Gui_ProgressLog(0,
802                        GWEN_LoggerLevel_Notice,
803                        I18N("Keys sent"));
804 
805   AH_Job_free(job);
806   if (!nounmount && mounted)
807     AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
808 
809   return 0;
810 }
811 
812 
813 
AH_Provider_SendUserKeys(AB_PROVIDER * pro,AB_USER * u,AB_IMEXPORTER_CONTEXT * ctx,int withProgress,int nounmount,int doLock)814 int AH_Provider_SendUserKeys(AB_PROVIDER *pro, AB_USER *u,
815                              AB_IMEXPORTER_CONTEXT *ctx,
816                              int withProgress, int nounmount, int doLock)
817 {
818   return AH_Provider_SendUserKeys2(pro, u, ctx, 0, withProgress, nounmount, doLock);
819 }
820 
821 
822 
AH_Provider_ChangeUserKeys(AB_PROVIDER * pro,AB_USER * u,GWEN_DB_NODE * args,int withProgress,int nounmount,int doLock)823 int AH_Provider_ChangeUserKeys(AB_PROVIDER *pro, AB_USER *u, GWEN_DB_NODE *args, int withProgress, int nounmount,
824                                int doLock)
825 {
826   int res=0;
827   uint8_t canceled=0;
828   AH_JOB *job=NULL;
829   AB_IMEXPORTER_CONTEXT *ctx=NULL;
830 
831   assert(u);
832 
833   job=AH_Job_ChangeKeys_new(pro, u, args, &canceled);
834   if (!job) {
835     res = -2;
836     if (!canceled) {
837       DBG_ERROR(AQHBCI_LOGDOMAIN, "Unexplainable, 'AH_Job_ChangeKeys_new' not supported.");
838       GWEN_Gui_ProgressLog(0, GWEN_LoggerLevel_Error, I18N("Unexplainable, 'AH_Job_ChangeKeys_new' not supported."));
839       res = -1;
840     }
841     if (canceled == 2)
842       res = -1;
843   }
844 
845   if (!res) {
846     ctx = AB_ImExporterContext_new();
847     if (!ctx) {
848       DBG_ERROR(AQHBCI_LOGDOMAIN, "Error getting ctx.");
849       res = -1;
850     }
851   }
852   if (ctx) {
853     AH_OUTBOX *ob = AH_Outbox_new(pro);
854     if (!ob)
855       GWEN_Gui_ProgressLog(0, GWEN_LoggerLevel_Error, I18N("Allocate outbox failed."));
856     else {
857       AH_Job_AddSigner(job, AB_User_GetUserId(u));
858       AH_Outbox_AddJob(ob, job);
859 
860       GWEN_Gui_ProgressLog(0, GWEN_LoggerLevel_Info, I18N("Fetching serverkeys."));
861       res = AH_Outbox_Execute(ob, ctx, withProgress, 0, doLock);
862       AH_Outbox_free(ob);
863       if (res)
864         GWEN_Gui_ProgressLog(0, GWEN_LoggerLevel_Error, I18N("Could not execute outbox."));
865       DBG_INFO(AQHBCI_LOGDOMAIN, "res %d, status %d.", res, AH_Job_GetStatus(job));
866       if (res || (AH_Job_GetStatus(job) == AH_JobStatusError))
867         res = -1;
868     }
869     AB_ImExporterContext_free(ctx);
870   }
871 
872   res = AH_Job_ChangeKeys_finish(pro, job, res);
873 
874   if (job)
875     AH_Job_free(job);
876 
877   AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(AH_Provider_GetHbci(pro)));
878 
879   return (res == -2) ? 0 : res;
880 }
881 
882 
883 
AH_Provider_GetCert(AB_PROVIDER * pro,AB_USER * u,int withProgress,int nounmount,int doLock)884 int AH_Provider_GetCert(AB_PROVIDER *pro,
885                         AB_USER *u,
886                         int withProgress, int nounmount, int doLock)
887 {
888   AB_BANKING *ab;
889   AH_HBCI *h;
890   int rv;
891   AH_DIALOG *dialog;
892   uint32_t pid;
893 
894   assert(pro);
895   assert(u);
896 
897   ab=AB_Provider_GetBanking(pro);
898   assert(ab);
899 
900   h=AH_Provider_GetHbci(pro);
901   assert(h);
902 
903   pid=GWEN_Gui_ProgressStart(GWEN_GUI_PROGRESS_ALLOW_EMBED |
904                              GWEN_GUI_PROGRESS_SHOW_PROGRESS |
905                              GWEN_GUI_PROGRESS_SHOW_ABORT,
906                              I18N("Getting Certificate"),
907                              I18N("We are now asking the server for its "
908                                   "SSL certificate"),
909                              GWEN_GUI_PROGRESS_NONE,
910                              0);
911   /* first try */
912   dialog=AH_Dialog_new(u, pro);
913   assert(dialog);
914   rv=AH_Dialog_TestServer_Https(dialog);
915   AH_Dialog_Disconnect(dialog);
916   AH_Dialog_free(dialog);
917 
918   if (rv) {
919     DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not connect to server (%d)", rv);
920     GWEN_Gui_ProgressLog(pid,
921                          GWEN_LoggerLevel_Error,
922                          I18N("Could not connect to server"));
923     GWEN_Gui_ProgressEnd(pid);
924     return rv;
925   }
926 
927   GWEN_Gui_ProgressLog(pid,
928                        GWEN_LoggerLevel_Error,
929                        I18N("Got certificate"));
930   GWEN_Gui_ProgressEnd(pid);
931 
932   return 0;
933 }
934 
935 
936 
AH_Provider_GetItanModes(AB_PROVIDER * pro,AB_USER * u,AB_IMEXPORTER_CONTEXT * ctx,int withProgress,int nounmount,int doLock)937 int AH_Provider_GetItanModes(AB_PROVIDER *pro, AB_USER *u,
938                              AB_IMEXPORTER_CONTEXT *ctx,
939                              int withProgress, int nounmount, int doLock)
940 {
941   AB_BANKING *ab;
942   AH_HBCI *h;
943   AH_JOB *job;
944   AH_OUTBOX *ob;
945   int rv;
946   const int *tm;
947   char tbuf[256];
948 
949   assert(pro);
950   assert(u);
951 
952   ab=AB_Provider_GetBanking(pro);
953   assert(ab);
954 
955   h=AH_Provider_GetHbci(pro);
956   assert(h);
957 
958   if (doLock) {
959     rv=AB_Provider_BeginExclUseUser(pro, u);
960     if (rv<0) {
961       DBG_INFO(AQHBCI_LOGDOMAIN,
962                "Could not lock customer [%s] (%d)",
963                AB_User_GetCustomerId(u), rv);
964       snprintf(tbuf, sizeof(tbuf)-1,
965                I18N("Could not lock user %s (%d)"),
966                AB_User_GetUserId(u), rv);
967       tbuf[sizeof(tbuf)-1]=0;
968       GWEN_Gui_ProgressLog(0,
969                            GWEN_LoggerLevel_Error,
970                            tbuf);
971       return rv;
972     }
973   }
974 
975   job=AH_Job_GetItanModes_new(pro, u);
976   if (!job) {
977     DBG_ERROR(AQHBCI_LOGDOMAIN, "Job not supported, should not happen");
978     if (doLock)
979       AB_Provider_EndExclUseUser(pro, u, 1);
980     return GWEN_ERROR_GENERIC;
981   }
982   AH_Job_AddSigner(job, AB_User_GetUserId(u));
983 
984   ob=AH_Outbox_new(pro);
985   AH_Outbox_AddJob(ob, job);
986   rv=AH_Outbox_Execute(ob, ctx, withProgress, 1, 0);
987   AH_Outbox_free(ob);
988   if (rv) {
989     DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not execute outbox.");
990     if (doLock)
991       AB_Provider_EndExclUseUser(pro, u, 1);
992     AH_Job_free(job);
993     if (!nounmount)
994       AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
995     return rv;
996   }
997 
998   tm=AH_Job_GetItanModes_GetModes(job);
999   if (tm[0]==-1) {
1000     DBG_ERROR(AQHBCI_LOGDOMAIN, "No iTAN modes reported");
1001     GWEN_Gui_ProgressLog(0,
1002                          GWEN_LoggerLevel_Error,
1003                          I18N("No iTAN modes reported."));
1004     if (doLock)
1005       AB_Provider_EndExclUseUser(pro, u, 1);
1006     AH_Job_free(job);
1007     if (!nounmount)
1008       AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
1009     return GWEN_ERROR_NO_DATA;
1010   }
1011 
1012   /* we have received tan methods, so there was a 3920 response. In this
1013    * special case we need to apply the job data, because otherwise we couldn't
1014    * fully connect to the server next time.
1015    */
1016   rv=AH_Job_Commit(job, 0);
1017   if (rv) {
1018     DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not commit result.\n");
1019     GWEN_Gui_ProgressLog(0,
1020                          GWEN_LoggerLevel_Error,
1021                          I18N("Could not commit result to the system"));
1022     if (doLock)
1023       AB_Provider_EndExclUseUser(pro, u, 1);
1024     AH_Job_free(job);
1025     if (!nounmount)
1026       AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
1027     return rv;
1028   }
1029 
1030   if (doLock) {
1031     rv=AB_Provider_EndExclUseUser(pro, u, 0);
1032     if (rv<0) {
1033       DBG_INFO(AQHBCI_LOGDOMAIN,
1034                "Could not unlock customer [%s] (%d)",
1035                AB_User_GetCustomerId(u), rv);
1036       snprintf(tbuf, sizeof(tbuf)-1,
1037                I18N("Could not unlock user %s (%d)"),
1038                AB_User_GetUserId(u), rv);
1039       tbuf[sizeof(tbuf)-1]=0;
1040       GWEN_Gui_ProgressLog(0,
1041                            GWEN_LoggerLevel_Error,
1042                            tbuf);
1043       AB_Provider_EndExclUseUser(pro, u, 1);
1044       AH_Job_free(job);
1045       if (!nounmount)
1046         AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
1047       return rv;
1048     }
1049   }
1050 
1051   AH_Job_free(job);
1052 
1053   if (!nounmount)
1054     AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
1055 
1056   return 0;
1057 }
1058 
1059 
1060 
AH_Provider_ChangePin(AB_PROVIDER * pro,AB_USER * u,AB_IMEXPORTER_CONTEXT * ctx,int withProgress,int nounmount,int doLock)1061 int AH_Provider_ChangePin(AB_PROVIDER *pro, AB_USER *u,
1062                           AB_IMEXPORTER_CONTEXT *ctx,
1063                           int withProgress, int nounmount, int doLock)
1064 {
1065   AB_BANKING *ab;
1066   AH_HBCI *h;
1067   AH_JOB *job;
1068   AH_OUTBOX *ob;
1069   int rv;
1070   char pwbuf[32];
1071 
1072   assert(pro);
1073   assert(u);
1074 
1075   ab=AB_Provider_GetBanking(pro);
1076   assert(ab);
1077 
1078   h=AH_Provider_GetHbci(pro);
1079   assert(h);
1080 
1081   memset(pwbuf, 0, sizeof(pwbuf));
1082   rv=GWEN_Gui_InputBox(GWEN_GUI_INPUT_FLAGS_NUMERIC |
1083                        GWEN_GUI_INPUT_FLAGS_CONFIRM,
1084                        I18N("Enter New Banking PIN"),
1085                        I18N("Please enter a new banking PIN.\n"
1086                             "You must only enter numbers, not letters.\n"
1087                             "<html>"
1088                             "<p>"
1089                             "Please enter a new banking PIN."
1090                             "</p>"
1091                             "<p>"
1092                             "You must only enter numbers, not letters."
1093                             "</p>"
1094                             "</html>"),
1095                        pwbuf,
1096                        0, 8, 0);
1097   if (rv<0) {
1098     DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d)", rv);
1099     return rv;
1100   }
1101   job=AH_Job_ChangePin_new(pro, u, pwbuf);
1102   if (!job) {
1103     DBG_ERROR(AQHBCI_LOGDOMAIN, "Job not supported, should not happen");
1104     return GWEN_ERROR_GENERIC;
1105   }
1106   AH_Job_AddSigner(job, AB_User_GetUserId(u));
1107 
1108   ob=AH_Outbox_new(pro);
1109   AH_Outbox_AddJob(ob, job);
1110 
1111   rv=AH_Outbox_Execute(ob, ctx, withProgress, nounmount, doLock);
1112   AH_Outbox_free(ob);
1113   if (rv) {
1114     DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not execute outbox.\n");
1115     AH_Job_free(job);
1116     if (!nounmount)
1117       AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
1118     return rv;
1119   }
1120 
1121   if (AH_Job_HasErrors(job)) {
1122     DBG_ERROR(AQHBCI_LOGDOMAIN, "Job has errors");
1123     // TODO: show errors
1124     AH_Job_free(job);
1125     if (!nounmount)
1126       AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
1127     return GWEN_ERROR_GENERIC;
1128   }
1129   else {
1130     rv=AH_Job_Commit(job, doLock);
1131     if (rv) {
1132       DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not commit result.\n");
1133       AH_Job_free(job);
1134       if (!nounmount)
1135         AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
1136       return rv;
1137     }
1138   }
1139 
1140   AH_Job_free(job);
1141 
1142   if (!nounmount)
1143     AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
1144 
1145   return 0;
1146 }
1147 
1148 
1149 
AH_Provider_UnblockPin(AB_PROVIDER * pro,AB_USER * u,AB_IMEXPORTER_CONTEXT * ctx,int withProgress,int nounmount,int doLock)1150 int AH_Provider_UnblockPin(AB_PROVIDER *pro,
1151                            AB_USER *u,
1152                            AB_IMEXPORTER_CONTEXT *ctx,
1153                            int withProgress, int nounmount, int doLock)
1154 {
1155   AB_BANKING *ab;
1156   AH_HBCI *h;
1157   AH_OUTBOX *ob;
1158   int rv;
1159   AH_JOB *job;
1160 
1161   assert(pro);
1162 
1163   ab=AB_Provider_GetBanking(pro);
1164   assert(ab);
1165 
1166   h=AH_Provider_GetHbci(pro);
1167   assert(h);
1168 
1169   ob=AH_Outbox_new(pro);
1170 
1171   /* TODO: store user to free it later */
1172   job=AH_Job_UnblockPin_new(pro, u);
1173   if (!job) {
1174     DBG_WARN(AQHBCI_LOGDOMAIN, "Job not supported with this account");
1175     AH_Outbox_free(ob);
1176     return GWEN_ERROR_GENERIC;
1177   }
1178   AH_Job_AddSigner(job, AB_User_GetUserId(u));
1179 
1180   AH_Outbox_AddJob(ob, job);
1181   AH_Job_free(job);
1182 
1183   rv=AH_Outbox_Execute(ob, ctx, withProgress, nounmount, doLock);
1184   if (rv) {
1185     DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not execute outbox.\n");
1186     AH_Outbox_free(ob);
1187     if (!nounmount)
1188       AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
1189     return rv;
1190   }
1191 
1192   AH_Outbox_free(ob);
1193 
1194   if (!nounmount)
1195     AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
1196 
1197   return 0;
1198 }
1199 
1200 
1201 
AH_Provider_GetAccountSepaInfo(AB_PROVIDER * pro,AB_ACCOUNT * a,AB_IMEXPORTER_CONTEXT * ctx,int withProgress,int nounmount,int doLock)1202 int AH_Provider_GetAccountSepaInfo(AB_PROVIDER *pro,
1203                                    AB_ACCOUNT *a,
1204                                    AB_IMEXPORTER_CONTEXT *ctx,
1205                                    int withProgress, int nounmount, int doLock)
1206 {
1207   AB_BANKING *ab;
1208   AH_HBCI *h;
1209   AH_OUTBOX *ob;
1210   uint32_t uid;
1211   int rv;
1212 
1213   assert(pro);
1214 
1215   ab=AB_Provider_GetBanking(pro);
1216   assert(ab);
1217 
1218   h=AH_Provider_GetHbci(pro);
1219   assert(h);
1220 
1221 
1222   ob=AH_Outbox_new(pro);
1223 
1224   uid=AB_Account_GetUserId(a);
1225   if (uid==0) {
1226     DBG_ERROR(AQHBCI_LOGDOMAIN, "No user for this account");
1227   }
1228   else {
1229     AB_USER *u;
1230 
1231     rv=AB_Provider_GetUser(pro, uid, 1, 1, &u);
1232     if (rv<0) {
1233       DBG_ERROR(AQHBCI_LOGDOMAIN, "Unknown user for this account");
1234     }
1235     else {
1236       AH_JOB *job;
1237 
1238       /* TODO: store user to free it later */
1239       job=AH_Job_GetAccountSepaInfo_new(pro, u, a);
1240       if (!job) {
1241         DBG_WARN(AQHBCI_LOGDOMAIN, "Job not supported with this account");
1242         AH_Outbox_free(ob);
1243         return GWEN_ERROR_GENERIC;
1244       }
1245       AH_Job_AddSigner(job, AB_User_GetUserId(u));
1246       AH_Outbox_AddJob(ob, job);
1247       AH_Job_free(job);
1248     }
1249   }
1250 
1251   rv=AH_Outbox_Execute(ob, ctx, withProgress, nounmount, doLock);
1252   if (rv) {
1253     DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not execute outbox.\n");
1254     AH_Outbox_free(ob);
1255     if (!nounmount)
1256       AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
1257     return rv;
1258   }
1259 
1260   AH_Outbox_free(ob);
1261 
1262   if (!nounmount)
1263     AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
1264 
1265   return 0;
1266 }
1267 
1268 
1269 
1270 
1271 
1272