IBAN Rechner in C
Umfassender Leitfaden: IBAN-Berechnung in C implementieren
Die Implementierung eines IBAN-Rechners in C erfordert ein tiefes Verständnis der internationalen Bankkontonummer-Standards (ISO 13616) und der mathematischen Validierungsverfahren. Dieser Leitfaden führt Sie durch die technischen Details der IBAN-Generierung, Validierung und Optimierung in der Programmiersprache C.
1. Grundlagen der IBAN-Struktur
Eine IBAN (International Bank Account Number) besteht aus:
- Ländercode (2 Buchstaben, ISO 3166-1 alpha-2)
- Prüfziffer (2 Ziffern, berechnet nach ISO 7064)
- BBAN (Basic Bank Account Number, länderspezifisch)
Für Deutschland hat die BBAN folgende Struktur: Bankleitzahl (8 Stellen) + Kontonummer (10 Stellen).
2. Mathematische Grundlagen der IBAN-Prüfziffer
Die Prüfziffer wird nach dem Modulo-97-Algorithmus (ISO 7064) berechnet:
- Ländercode wird an das Ende der BBAN verschoben
- Buchstaben werden in Zahlen umgewandelt (A=10, B=11,…, Z=35)
- Die Zahl wird durch 97 dividiert
- Der Rest wird von 98 subtrahiert (ergibt die Prüfziffer)
pre {
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
long long mod97(char* iban) {
long long num = 0;
for (int i = 0; iban[i] != ‘\0’; i++) {
int c = toupper(iban[i]);
if (isdigit(c)) {
num = (num * 10 + (c – ‘0’)) % 97;
} else if (isalpha(c)) {
num = (num * 100 + (c – ‘A’ + 10)) % 97;
}
}
return num;
}
int calculate_checksum(char* country, char* bban) {
char temp[50];
strcpy(temp, bban);
strcat(temp, country);
strcat(temp, “00”);
long long remainder = mod97(temp);
return (98 – remainder) % 97;
}
}
3. Komplette C-Implementierung eines IBAN-Rechners
Das folgende Beispiel zeigt eine vollständige Implementierung mit Eingabevalidierung und Fehlerbehandlung:
pre {
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
int is_valid_country_code(const char* code) {
if (strlen(code) != 2) return 0;
for (int i = 0; i < 2; i++) {
if (!isalpha(code[i])) return 0;
}
return 1;
}
int is_valid_bban(const char* bban) {
if (strlen(bban) < 8) return 0;
for (int i = 0; bban[i] != '\0'; i++) {
if (!isdigit(bban[i])) return 0;
}
return 1;
}
void generate_iban(const char* country, const char* bban, char* iban) {
int checksum = calculate_checksum(country, bban);
sprintf(iban, "%s%02d%s", country, checksum, bban);
}
int validate_iban(const char* iban) {
if (strlen(iban) < 4) return 0;
char country[3] = {iban[0], iban[1], '\0'};
if (!is_valid_country_code(country)) return 0;
char bban[50];
strncpy(bban, iban + 4, sizeof(bban) - 1);
bban[sizeof(bban) - 1] = '\0';
if (!is_valid_bban(bban)) return 0;
char temp[50];
strcpy(temp, bban);
strcat(temp, country);
strcat(temp, "00");
return mod97(temp) == 1;
}
int main() {
char country[3];
char bban[50];
char iban[50];
printf("IBAN Rechner in C\n");
printf("-----------------\n");
printf("Ländercode (2 Buchstaben): ");
scanf("%2s", country);
printf("BBAN (Bankleitzahl + Kontonummer): ");
scanf("%49s", bban);
if (!is_valid_country_code(country) || !is_valid_bban(bban)) {
printf("Ungültige Eingabe!\n");
return 1;
}
generate_iban(country, bban, iban);
printf("Generierte IBAN: %s\n", iban);
if (validate_iban(iban)) {
printf("IBAN ist gültig.\n");
} else {
printf("IBAN ist ungültig!\n");
}
return 0;
}
}
4. Performance-Optimierung für große Datenmengen
Bei der Verarbeitung von Massen IBAN-Daten (z.B. in Bankensystemen) sind folgende Optimierungen entscheidend:
| Optimierungstechnik | Performance-Gewinn | Implementierungsaufwand |
|---|---|---|
| Lookup-Tabellen für Buchstaben | ~30% schneller | Niedrig |
| SIMD-Instruktionen (SSE/AVX) | ~400% schneller | Hoch |
| Parallelverarbeitung (OpenMP) | ~300% (4 Kerne) | Mittel |
| Caching häufiger Ländercodes | ~15% schneller | Niedrig |
Für kritische Anwendungen empfiehlt sich die folgende optimierte Modulo-97-Implementierung:
pre {
// Optimierte Modulo-97 Berechnung mit Lookup-Tabelle
const int letter_values[26] = {
10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
30, 31, 32, 33, 34, 35
};
long long fast_mod97(const char* iban) {
long long num = 0;
for (int i = 0; iban[i] != ‘\0’; i++) {
if (isdigit(iban[i])) {
num = (num * 10 + (iban[i] – ‘0’)) % 97;
} else if (isalpha(iban[i])) {
int val = letter_values[toupper(iban[i]) – ‘A’];
num = (num * 100 + val) % 97;
}
}
return num;
}
}
5. Integration mit Bankensystemen
Bei der Integration in bestehende Bankensysteme sind folgende Aspekte zu beachten:
- Datenbankanbindung: Verwendung von Prepared Statements zur Vermeidung von SQL-Injection
- Fehlerbehandlung: Umfassende Logging-Mechanismen für Audit-Zwecke
- Sicherheit: Verschlüsselung sensibler Daten (AES-256 empfohlen)
- Compliance: Einhaltung von PSD2 und GDPR-Vorgaben
Ein Beispiel für eine sichere Datenbankintegration mit SQLite:
pre {
#include <sqlite3.h>
int save_iban_to_db(const char* iban, const char* customer_id) {
sqlite3 *db;
char *err_msg = 0;
int rc;
rc = sqlite3_open(“bank.db”, &db);
if (rc != SQLITE_OK) {
fprintf(stderr, “Cannot open database: %s\n”, sqlite3_errmsg(db));
return 0;
}
char sql[256];
sprintf(sql, “INSERT INTO accounts (customer_id, iban, created_at) ”
“VALUES (‘%s’, ‘%s’, datetime(‘now’))”, customer_id, iban);
rc = sqlite3_exec(db, sql, 0, 0, &err_msg);
if (rc != SQLITE_OK) {
fprintf(stderr, “SQL error: %s\n”, err_msg);
sqlite3_free(err_msg);
sqlite3_close(db);
return 0;
}
sqlite3_close(db);
return 1;
}
}
6. Vergleich internationaler IBAN-Formate
| Land | IBAN-Länge | BBAN-Struktur | Beispiel |
|---|---|---|---|
| Deutschland (DE) | 22 | BLZ (8) + Kontonummer (10) | DE89 3704 0044 0532 0130 00 |
| Österreich (AT) | 20 | Bankcode (5) + Kontonummer (11) | AT61 1904 3002 3457 3201 |
| Schweiz (CH) | 21 | Bankcode (5) + Kontonummer (12) | CH93 0076 2011 6238 5295 7 |
| Frankreich (FR) | 27 | Bankcode (5) + Branch (5) + Kontonummer (11) + Schlüssel (2) | FR14 2004 1010 0505 0001 3M02 606 |
| Großbritannien (GB) | 22 | Sort Code (6) + Kontonummer (8) | GB29 NWBK 6016 1331 9268 19 |
7. Rechtliche Aspekte und Compliance
Bei der Implementierung eines IBAN-Rechners müssen folgende rechtliche Anforderungen beachtet werden:
- PSD2 (Payment Services Directive 2): Verpflichtende starke Kundenauthentifizierung für Zahlungsdienste
- GDPR (DSGVO): Schutz personbezogener Daten in Kontonummern
- ISO 13616: Einhaltung des internationalen IBAN-Standards
- Länderspezifische Vorschriften: Z.B. BaFin-Richtlinien in Deutschland
Offizielle Quellen für weitere Informationen:
- Europäische Zentralbank – IBAN-Spezifikationen
- ISO 13616 Standard (IBAN)
- Deutsche Bundesbank – Zahlungsverkehrssysteme
8. Testverfahren und Qualitätsicherung
Um die Korrektheit der Implementierung zu gewährleisten, sollten folgende Testfälle abgedeckt werden:
pre {
void run_tests() {
struct {
const char* country;
const char* bban;
const char* expected_iban;
int valid;
} test_cases[] = {
{“DE”, “100100101234567890”, “DE89100100101234567890”, 1},
{“AT”, “1904300234573201”, “AT611904300234573201”, 1},
{“CH”, “00762011623852957”, “CH9300762011623852957”, 1},
{“FR”, “20041010050500013M02606”, “FR1420041010050500013M02606”, 1},
{“GB”, “NWBK60161331926819”, “GB29NWBK60161331926819”, 1},
{“XX”, “1234567890”, “”, 0}, // Ungültiger Ländercode
{“DE”, “123”, “”, 0} // Ungültige BBAN
};
for (int i = 0; i < sizeof(test_cases)/sizeof(test_cases[0]); i++) {
char iban[50];
generate_iban(test_cases[i].country, test_cases[i].bban, iban);
int valid = validate_iban(iban);
printf("Test %d: %s\n", i+1, valid == test_cases[i].valid ?
"PASSED" : "FAILED");
printf(" Input: %s/%s\n", test_cases[i].country, test_cases[i].bban);
printf(" Generated: %s\n", iban);
printf(" Expected: %s\n", test_cases[i].expected_iban);
printf(" Valid: %d (expected %d)\n\n",
valid, test_cases[i].valid);
}
}
}
9. Zukunftsperspektiven und Erweiterungen
Moderne Anforderungen an IBAN-Systeme umfassen:
- KI-basierte Betrugserkennung: Analyse von IBAN-Mustern zur Erkennung verdächtiger Transaktionen
- Blockchain-Integration: Verwendung von IBANs in Smart Contracts für automatisierte Zahlungen
- Echtzeit-Validierung: API-basierte Dienste zur sofortigen IBAN-Prüfung während der Eingabe
- Quantum-Resistenz: Vorbereitung auf post-quantum Kryptographie für zukünftige Sicherheitsanforderungen
Eine mögliche Erweiterung wäre die Implementierung einer REST-API für die IBAN-Validierung:
pre {
// Beispiel für eine einfache HTTP-API mit libmicrohttpd
#include <microhttpd.h>
static int answer_to_connection(void *cls, struct MHD_Connection *connection,
const char *url, const char *method,
const char *version, const char *upload_data,
size_t *upload_data_size, void **con_cls) {
const char *country = MHD_lookup_get_value(connection, MHD_GET_ARGUMENT_KIND, “country”);
const char *bban = MHD_lookup_get_value(connection, MHD_GET_ARGUMENT_KIND, “bban”);
if (!country || !bban) {
const char *response = “{\”error\”: \”Missing parameters\”}”;
struct MHD_Response *res = MHD_create_response_from_buffer(strlen(response),
(void*)response,
MHD_RESPMEM_PERSISTENT);
MHD_queue_response(connection, MHD_HTTP_BAD_REQUEST, res);
MHD_destroy_response(res);
return MHD_YES;
}
char iban[50];
generate_iban(country, bban, iban);
int valid = validate_iban(iban);
char response[256];
snprintf(response, sizeof(response),
“{\”iban\”: \”%s\”, \”valid\”: %d}”, iban, valid);
struct MHD_Response *res = MHD_create_response_from_buffer(strlen(response),
(void*)response,
MHD_RESPMEM_PERSISTENT);
MHD_queue_response(connection, MHD_HTTP_OK, res);
MHD_destroy_response(res);
return MHD_YES;
}
int main() {
struct MHD_Daemon *daemon;
daemon = MHD_start_daemon(MHD_USE_SELECT_INTERNAL_POLLING_THREAD, 8080,
NULL, NULL, &answer_to_connection, NULL,
MHD_OPTION_END);
if (NULL == daemon) return 1;
getchar();
MHD_stop_daemon(daemon);
return 0;
}
}
Zusammenfassung und Empfehlungen
Die Implementierung eines IBAN-Rechners in C erfordert:
- Exaktes Verständnis des ISO 13616 Standards
- Korrekte Implementierung des Modulo-97-Algorithmus
- Umfassende Eingabevalidierung
- Performance-Optimierungen für Produktionsumgebungen
- Berücksichtigung rechtlicher Anforderungen
Für produktive Einsatzzwecke empfiehlt sich:
- Verwendung etablierter Bibliotheken wie iban.c
- Implementierung umfassender Unit-Tests
- Regelmäßige Updates gemäß neuer ISO-Standards
- Sicherheitsaudits durch Dritte