IBAN überprüfen

[HeikoAdams]

Hallo,
mit dem folgenden Code kann man eine deutsche IBAN auf Korrektheit prüfen. Den Code für die Funktion Modulo97PruefZiffer habe ich von http://www.delphipraxis.net/1061658-post6.html übernommen. Der Algorithmus zum Prüfen der IBAN ist unter http://www.europebanks.info/ibanguide.htm#6 beschrieben.

Delphi-Quellcode:

function Modulo97PruefZiffer(const aIBAN:string):Integer;
const
   m36:string = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';
var
   nCounter, nPruef : Integer;
begin
   Result := 0;

   for nCounter := 1 to Length(aIBAN) do
   begin
      nPruef := Pos(aIBAN[nCounter], m36) ;

      if (nPruef = 0) then
         raise Exception.CreateFmt('Modulo97PruefZiffer(%s): invalid data', [aIBAN]);

      Dec(nPruef);

      if (nPruef > 9) then
      begin
         Result := Result * 10 + (nPruef div 10);
         nPruef := nPruef mod 10;
      end;

      Result := Result * 10 + nPruef;
      Result := Result mod 97;
   end;
end;

function CodiereLand(const aLand: string): string;
var
  sLetter: Char;
begin
  for sLetter in aLand do
    case sLetter of
      'A': Result := Result + '10';
      'B': Result := Result + '11';
      'C': Result := Result + '12';
      'D': Result := Result + '13';
      'E': Result := Result + '14';
      'F': Result := Result + '15';
      'G': Result := Result + '16';
      'H': Result := Result + '17';
      'I': Result := Result + '18';
      'J': Result := Result + '19';
      'K': Result := Result + '20';
      'L': Result := Result + '21';
      'M': Result := Result + '22';
      'N': Result := Result + '23';
      'O': Result := Result + '24';
      'P': Result := Result + '25';
      'Q': Result := Result + '26';
      'R': Result := Result + '27';
      'S': Result := Result + '28';
      'T': Result := Result + '29';
      'U': Result := Result + '30';
      'V': Result := Result + '31';
      'W': Result := Result + '32';
      'X': Result := Result + '33';
      'Y': Result := Result + '34';
      'Z': Result := Result + '35';
    else
      Result := Result + EmptyStr;
    end;
end;

function PruefeIBAN(const aIBAN: string): boolean;
var
  sBLZ: string;
  sKTO: string;
  sIBAN: string;
  sLand: string;
  sLand2: string;
  sControl: string;
begin
    sLand := Copy(aIBAN, 1, 2);

    if (sLand <> 'DE') then
    begin
      Result := true;
      Exit;
    end;

    sControl := Copy(aIBAN, 3, 2);
    sBLZ := Copy(aIBAN, 5, 8);
    sKTO := Copy(aIBAN, 13, 10);
    sLand2 := CodiereLand(sLand);
    sIBAN := sBLZ + sKTO + sLand2 + sControl;

    Result := (Modulo97PruefZiffer(sIBAN) = 1);
end;

[Sharky]

Zitat von HeikoAdams:

...

Delphi-Quellcode:

    nControl := StrToInt(Copy(aIBAN, 3, 2));
...
    sIBAN := sBLZ + sKTO + sLand2 + IntToStr(nControl);
end;

Hai Heiko,

warum wandelst Du das "Copy-Ergebniss" in eine Zahl nur um sie dann später wieder ein einen String zu wandeln?

[HeikoAdams]

Zitat von Sharky:

Hai Heiko,
warum wandelst Du das "Copy-Ergebniss" in eine Zahl nur um sie dann später wieder ein einen String zu wandeln?

Das war noch ein Überbleibsel aus einer früheren Version des Codes, das ich übersehen hatte. Habs geändert

[ms61]

Hallo,
bin auf der Suche nach einer schnellen IBAN-Validierung (für Massenverarbeitung) auf diesen Thread gestoßen. Da die bisherige Lösung nicht auf Schnelligkeit getrimmt war, habe ich dann doch selbst etwas programmiert. Für alle, die es interessiert:

Code:

// Prüfung einer IBAN auf formale Korrektheit (ohne Prüfung der Gültigkeit des Länderkürzels)
// Autor: Dr. Michael Schramm, Bordesholm
function checkIban(const sIban: String): boolean;
var k,i,n,len: integer; c: char;
    buff: array[0..67] of char;
begin
  result:= false;
  n:= length(sIban);
  if (n < 5) or (n > 34) then exit;
  len:= 0; k:= 5;
  repeat // IBAN als Ziffernfolge in geänderter Reihenfolge in buff schreiben
    c:= sIban[k];
    if (c >= '0') and (c <= '9') then begin
      buff[len]:= c; inc(len)
    end
    else if (c >= 'A') and (c <= 'Z') then begin
      i:= ord(c)-55;
      buff[len]:= char(i div 10 + 48); inc(len);
      buff[len]:= char(i mod 10 + 48); inc(len)
    end
    else exit;
    inc(k);
    if k > n then k:= 1
  until k = 5;
  i:= 0; // aktueller Rest für Modulo-Berechnung
  for k:= 0 to len-1 do begin // modulo 97 berechnen
    i:= (i * 10 + ord(buff[k]) - 48) mod 97;
  end;
  result:= (i = 1)
end;

Die Funktion erwartet die IBAN in kurzer Form, so wie sie z. B. in SEPA-XML-Dateien auftritt. Falls die IBAN Leerzeichen enthält, müssen diese vor der Prüfung entfernt werden.

Grüße
Michael

[HeikoAdams]

Ich habe Deinen Code in meine Klasse übernommen.

[Amateurprofi]

@ms61:
Hier eine um 15-20 % schnellere Version:

Delphi-Quellcode:

FUNCTION IsIBAN(const s:string):boolean;
var len,cs:integer;
FUNCTION GetCheckSum(first,last:integer):boolean;
var i:integer; c:integer;
begin
   for i:=first to last do begin
      c:=Ord(s[i])-48;
      case c of
         0..9     :  cs:=(cs*10+c) mod 97;
         17..42   :  cs:=(((cs*10+(c-7) Div 10) mod 97)*10+(c-7) Mod 10) Mod 97;
         else Exit(False);
      end;
   end;
   result:=true;
end;
begin
   len:=Length(s);
   if (len<5) or (len>34) then Exit(false);
   cs:=0;
   if not GetCheckSum(5,len) then Exit(false);
   if not GetCheckSum(1,4) then Exit(false);
   result:=cs=1;
end;

Noch deutlich schneller geht es, wenn man eine Tabelle benutzt um die "teuren" Mod-Operationen zu vermeiden.
Nachteil : Die Tabelle muß entweder als Konstante hinterlegt oder bei Programmstart einmalig gefüllt werden,
was für die Massenverarbeitung aber sicherlich kein Hindernis ist.

Zum Beispiel so :

Delphi-Quellcode:

var
   m97tab:array[0..96,0..9] of byte;

PROCEDURE FillM97Tab;
var i,j:Integer;
begin
   for i:=0 to 96 do
      for j:=0 to 9 do
         m97tab[i,j]:=(i*10+j) Mod 97;
end;

FUNCTION IsIBAN2(const s:string):boolean;
var len:integer; cs:byte;
FUNCTION GetCheckSum(first,last:integer):boolean;
var i:integer; c:integer;
begin
   for i:=first to last do begin
      c:=Ord(s[i])-48;
      case c of
         0..9     :  cs:=m97tab[cs,c];
         17..42   :  cs:=m97tab[m97tab[cs,(c-7) Div 10],(c-7) Mod 10];
         else Exit(False);
      end;
   end;
   result:=true;
end;
begin
   len:=Length(s);
   if (len<5) or (len>34) then Exit(false);
   cs:=0;
   if not GetCheckSum(5,len) then Exit(false);
   if not GetCheckSum(1,4) then Exit(false);
   result:=cs=1;
end;

Gemessene Zeiten für 1 Mio Durchläufe:
CheckIban : 249 ms
IsIBAN : 203 ms
IsIBAN2 : 94 ms

[HeikoAdams]

So, nachdem hier einiges an Feedback aufgeschlagen ist, das ich dankenderweise übernommen habe, anbei mal eine aktuelle Version der TIBan Klasse.

[ms61]

Oh, hier hat sich ja einiges getan (ich war zwei Tage weg). Inzwischen (eine Nacht darüber schlafen...) war mir schon aufgegangen, dass die Zwischenspeicherung in einem Array nicht erforderlich ist und eine einzige Programmschleife zur Verarbeitung genügt. Auch die DIV- und MOD-Operationen zur Basis 10 braucht man gar nicht - man kann ja zwei Ziffern auf einmal verarbeiten. Die Lösung schaut dann so aus:

Delphi-Quellcode:

function checkIban(const sIban: String): boolean;
var k,n,rest: integer; c: char;
begin
  result:= false;
  n:= length(sIban);
  if (n < 5) or (n > 34) then exit;
  rest:= 0; k:= 5;
  repeat // Zeichen der IBAN in geänderter Reihenfolge per Modulo-97 prüfen
    c:= sIban[k];
    case c of
      '0'..'9': // Ziffer als solche berücksichtigen
        rest:= (rest * 10 + ord(c) - 48) mod 97;
      'A'..'Z': // 'A' wie '10, 'B' wie '11' usw.
        rest:= (rest * 100 + ord(c) - 55) mod 97
      else exit
    end;
    inc(k);
    if k > n then k:= 1
  until k = 5;
  result:= (rest = 1)
end;

Die Modulo-97-Reste nur einmal zu berechnen und in einer Tabelle zu speichern, ist eine gute Idee, Amateurprofi! Für meine Zwecke lohnt das aber nicht wirklich. Massenverabeitung heißt in meinem Fall, dass es um einige 10.000 Datensätze geht, und jede Verarbeitung unter einer Sekunde ist gut - den Bereich haben wir ja locker erreicht...

Viele Grüße
Michael

[Amateurprofi]

@ms61:
Ja, das ist ja 'ne super Idee, die Buchstaben in "einem Rutsch" zu verarbeiten.
Aber zu Ende gedacht heißt das ja, daß man auch mehrere Ziffern in einem Rutsch verarbeiten kann.
Ich habe das mal umgesetzt in IsIBAN3 und weils so schön ist auch in der Asm-Funktion IsIBAN4, die allerdings
nur auf 64 Bit Systemen läuft.

Für jeweils 1 Mio Durchläufe hab ich folgende Zeiten gemessen
CheckIban (von ms61 aus #4) : 249 ms
CheckIban (von ms61 aus #8) : 156 ms
IsIBAN (aus #6) : 203 ms
IsIBAN2 (aus #6 mit Tabelle) : 94 ms
IsIBAN3 : 124 ms
IsIBAN4 (64 Bit Asm) : 78 ms

Überraschend für mich ist, daß die Asm-Version noch deutlich schneller ist, als die Version, die eine Tabelle benutzt.
Vielleicht hat jemand, der einen gewissen Bestand an IBANs hat, Lust, zu prüfen, ob die Funktionen korrekte Ergebnisse bringen.
Ich habe es nur an einer einzigen IBAN getestet (meiner eigenenen).

Geändert :
Prüfung ob Puffer voll ist korrigiert. Bei der bisherigen Version hätte ev. ein Zahlenüberlauf auftreten können.

Delphi-Quellcode:

FUNCTION IsIBAN3(const s:string): boolean;
var n:Integer; cs,ci:UInt64;
PROCEDURE GetMod;
begin
   cs:=(cs+ci) mod 97;
   ci:=0;
   n:=0;
end;
FUNCTION GetCheckSum(first,last:integer):boolean;
var i,c:integer;
begin
   for i:=first to last do begin
      if n>=15 then GetMod;
      c:=Ord(s[i])-48;
      case c of
         0..9     :  begin
                        cs:=cs*10;
                        ci:=ci*10+c;
                        inc(n);
                     end;
         17..42   :  begin
                        cs:=cs*100;
                        ci:=ci*100+c-7;
                        inc(n,2);
                     end;
         else Exit(False);
      end;
   end;
   result:=true;
end;
var len:integer;
begin
   len:=length(s);
   if (len<5) or (len>34) then Exit(false);
   cs:=0;
   ci:=0;
   n:=0;
   if not GetCheckSum(5,len) then Exit(false);
   if not GetCheckSum(1,4) then Exit(false);
   if n>0 then GetMod;
   result:=cs=1;
end;

Geändert :
1) Zugriff auf die Zeichen in s optimiert.
2) Prüfung ob Puffer voll ist korrigiert. Bei der bisherigen Version hätte ev. ein Zahlenüberlauf auftreten können.
3) Prüfung ob s ungültige Zeichen enthält, korrigiert.

Delphi-Quellcode:

FUNCTION IsIBAN4(const s:string):boolean;
asm
               test  rcx,rcx
               je    @Fail
               xor   r9,r9
               mov   r9d,[rcx-4]
               cmp   r9,5
               jb    @Fail
               cmp   r9,34
               ja    @Fail
               jmp   @Work
@PopFail:      pop   rcx
@Fail:         xor   al,al
               ret

@GetMod:       lea   rax,[rax+r10]        // = Rest + Ziffernpuffer
               xor   rdx,rdx
               mov   r11,97
               div   r11
               mov   rax,rdx              // = (Rest + Ziffernpuffer) Mod 97
               xor   r10,r10              // Ziffernpuffer löschen
               xor   r11,r11              // Ziffernzähler löschen
               ret

@GetCS:        cmp   r11,15
               jb    @ReadChar
               call  @GetMod
@ReadChar:     movzx rdx,word [r8+r9*2]   // Zeichen aus s
               sub   dx,'0'
               cmp   dx,9
               ja    @CheckLetter         // keine Ziffer
               lea   rax,[rax+rax*4]      // = Rest * 5
               lea   rax,[rax+rax]        // = Rest * 10
               lea   r10,[r10+r10*4]      // = Ziffernpuffer * 5
               lea   r10,[r10*2+rdx]      // = Ziffernpuffer * 10 + Ziffer
               add   r11,1                // Zifferzähler + 1
               jmp   @Next
@CheckLetter:  sub   dx,'A'-'0'
               cmp   dx,25
               ja    @PopFail             // weder Ziffer noch Buchstabe
               lea   rax,[rax+rax*4]      // = Rest * 5
               lea   rax,[rax+rax*4]      // = Rest * 25
               lea   rax,[rax*4]          // = Rest * 100
               lea   r10,[r10+r10*4]      // = Ziffernpuffer * 5
               lea   r10,[r10+r10*4]      // = Ziffernpuffer * 25
               lea   r10,[r10*4+rdx+10]   // = Ziffernpuffer * 100 + BuchstabenIndex
               add   r11,2                // Zifferzähler + 2
@Next:         add   r9,1
               jne   @GetCS
               ret

@Work:         xor   rax,rax              // Rest
               xor   r10,r10              // Ziffernpuffer
               xor   r11,r11              // Ziffernzähler
               lea   r8,[rcx+r9*2]        // Hinter s[Length(s)]
               sub   r9,4                 // Length(s)-4 Zeichen lesen
               neg   r9
               call  @GetCS
               lea   r8,[rcx+8]           // Hinter s[4]
               mov   r9,-4                // 4 Zeichen lesen
               call  @GetCS
               test  r11,r11
               je    @End
               call  @GetMod
@End:          cmp   rax,1
               sete  al
end;