Verschüsselungs-DLL mit Fehlern

[RebellX]

Hallo,

ich habe folgendes Problem:
Ich will einen String in einen String aus Zahlen verschlüsseln, aber je nach länge des eingegebenen Strings kommt entweder:
-Ungültige Zeigeroperation
-Zugriffsverletzung bei Adresse 00321F95 im Modul 'Crypt.dll' Lesen der Adresse 0000018
-Das Fenster schließt sich einfach

Hier der Code:

Delphi-Quellcode:

showmessage(crypt(edit2.Text));

Die DLL wird so eingebunden:

Delphi-Quellcode:

  function crypt(s: string): string; stdcall;
  external {$IFDEF __GPC__}name 'crypt'{$ELSE} 'PCrypt.dll'{$ENDIF __GPC__};

und so sieht sie aus:

Delphi-Quellcode:

library PCrypt;

uses
  FastShareMem,
  SysUtils,
  Classes;

  const
   list: array [1..62] of string =
   ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
   'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
   'W', 'X', 'Y', 'Z', '1', '2', '3', '4', '5', '6', '7',
   '8', '9', '0', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
   'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
   't', 'u', 'v', 'w', 'x', 'y', 'z');
   list2: array [1..62] of string =
   ('1', '2', '3', '4', '5', '6', '7',
   '8', '9', '0', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
   'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
   't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D',
   'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
   'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z');

function crypt1(s: string): string; stdcall;
var wert: array of byte;
    i, j: integer;
    ende: string;
begin
s := s + 'A';
randseed := 4546464;
setlength(wert, length(s));
ende := '';        
for i := 0 to length(s)-1 do
begin
for j := 1 to 62 do
begin
if copy(s, i, 1) = list[j] then wert[i] := j;
end;
ende := ende+inttostr(wert[i])+inttostr(random(wert[i]));
end;
for i := 0 to length(s)-1 do
begin
for j := 1 to 62 do
begin
if copy(s, i, 1) = list2[j] then wert[i] := j;
end;
ende := ende+inttostr(wert[i])+inttostr(random(wert[i]));
end;
result := ende;
end;

function crypt(s: string): string; stdcall; export; 
var s1, s2: string;
begin
s1 := crypt1(s);
s2 := crypt1(s1);
result := s2;
end;

{$R *.res}

exports
  Crypt;
begin
end.

[nuclearping]

1.) Mit Strings in DLLs arbeiten -> Pfui
2.) Code-Einrückung faktisch nicht vorhanden. Wer soll da durchblicken? -> Pfui
3.) Strings gehen von 1-Length. Nicht von 0-Length (-1)

[Luckie]

Deine for-Schleifen für die Strings sind falsch. Der ertse Buchstabe eines Strings steht an der Position 1 und nicht null. Ob das allerdings für den Fehler verantwortlich ist, kann ich aber nicht sagen. Ist mir nur aufgefallen.

Ach so und man kann nicht so einfach Strings an DLLs übergeben und wieder zurückgeben. Siehe dazu meinen Artikel: http://www.michael-puff.de/Artikel/StringDLL.shtml

[RebellX]

Ob ich jetzt
for i := 1 to length(s) do
oder
for i := 0 to length(s)-1 do
schreibe macht bei dem Problem irgendwie aber keinen unterschied.
Was die DLL angeht: ich wollte das ganze mal so ausprobieren... Ohne DLL komm ich zu den gleichen Fehlern...
Statt ShareMem verwende ich halt FastShareMem, die braucht kein e weitere DLL.

RebellX

[nuclearping]

"0 to ..." ist aber 100% falsch.

Wenn's daran nicht lag, liegts woanders.

Breakpoints setzen, F7 und F8 bemühen.

... Aber vorher würde ich erstmal ordentlich einrücken.

[RebellX]

Also ich hab mir das jetzt nochmal angeschaut in der DLL. Aber haltepunkte waren da nicht möglich,
also hab ichs kurz in ne Unit gepackt.

Zitat:

"0 to ..." ist aber 100% falsch.

Dazu hab ich gefunden, dass ohne -1 jetzt noch ein Fehler kommt, mit aber nocht (15 Testläufe).

Laufen tut das ganze jetzt ohne (sichtbare) Fehler.
Ums Einrücken werd ich mich in Zukunft bemühen, auch wenn mir selbst der Code dann unübersichtlich vorkommt^^.

RebellX

[Sir Rufo]

:wiejetzt:
was ist denn an einem formatierten Code unübersichtlich? das man sieht wie die Blöcke zusammenhängen?
Nun ja, jeder hat da ja eine andere Wahrnehmung ...

Delphi-Quellcode:

library PCrypt;

uses
  FastShareMem,
  SysUtils,
  Classes;

const
  list: array [1..62] of string =
    ( 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
      'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
      'W', 'X', 'Y', 'Z', '1', '2', '3', '4', '5', '6', '7',
      '8', '9', '0', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
      'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
      't', 'u', 'v', 'w', 'x', 'y', 'z' );
  list2: array [1..62] of string =
    ( '1', '2', '3', '4', '5', '6', '7',
      '8', '9', '0', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
      'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
      't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D',
      'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
      'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z' );

function crypt1(s: string): string; stdcall;
var 
  wert: array of byte;
  i, j: integer;
  ende: string;
begin
  s := s + 'A';
  randseed := 4546464;
  SetLength( wert, Length( s ) );
  ende := '';       
  for i := 0 to Length( s ) - 1 do
    begin
      for j := 1 to 62 do
        if 
          ( Copy( s, i, 1 ) = list[ j ] )
        then 
          wert[ i ] := j;
      ende := ende + IntToStr( wert[ i ] ) + IntToStr( Random( wert[ i ] ) );
    end;
  for i := 0 to Length( s ) - 1 do
    begin
      for j := 1 to 62 do
        if 
          ( Copy( s, i, 1 ) = list2[ j ] )
        then 
          wert[ i ] := j;
      ende := ende + IntToStr( wert[ i ] ) + IntToStr( Random( wert[ i ] ) );
  end;
  result := ende;
end;

function crypt(s: string): string; stdcall; export;
var 
  s1, s2: string;
begin
  s1 := crypt1( s );
  s2 := crypt1( s1 );
  result := s2;
end;

{$R *.res}

exports
  Crypt;
begin
end.

[Luckie]

@Rufo: Deine if-Schreibweise in drei Zeilen ist aber auch gewöhnungsbedürftig und, wie ich finde, unübersichtlich.

[mr_emre_d]

Zitat:

Zitat von nuclearping

"0 to ..." ist aber 100% falsch.

Ich würd mir das nochmal überlegen !

Es ist eigentlich ziemlich wurscht, wie die Schleife ausschaut. Im Endeffekt ist es wichtig, wie er indiziert (nennt man das - zugreifen auf einzelne Werte eines Strings - so ?)

Delphi-Quellcode:

  str := ';)';
  for i := -3 to Length(Str)-4 do
    Str[i+4] := Chr( Ord(str[i+4]) + 3 );

PS: OK ich habe nochmal nachgesehen und bemerkt, dass er falsch *indiziert

Aber deine Aussagen ist zu 100% falsch.

MfG

[nuclearping]

Wenn er eine Schleife hat "i := 0 to ..." und dort auch auf String[i] zugreift, ist das 100% falsch.

[himitsu]

Auch wenn ich die Art der Verschlüsselung "komisch" find ...

- Ramdom zur Verschüsselung: ließ mal in der OH nach, was dort diesbezüglich bei RandSeed steht.
- das mit dem StartIndex 1 bei Strings wurde schon gesagt
- die Codeformatierung ... naja

zur "Verschlüsselung":
- du weißt, daß die Datenmänge vermutlich so durchschnittlich um das 8- bis 12-fache ansteiget?
pro crypt1, also insgesammt 8*8- bis 12*12-fach
- Daten innerhalb des verschlüsselten Strings sind vierfach vorhanden und da crypt1 auch noch doppelt ausgeführt wird, sind die Daten sogar alle 8 mal vorhanden
- du solltest lieber noch eine Fehlerprüfung integrieren, falls mal unzulässige Zeichen im String s vorkommen, also welche die nicht in list/list2 vorkommen
- warum array of string, wo da doch nur Chars drin sind?

Delphi-Quellcode:

  list: array [1..62] of char = ...
  list2: array [1..62] of char = ...

- wieso wert: array of byte;, wo du die Daten sofort verwendest

aber hier zumindestens mal deine Funktion, wie sie erstmal funktionieren sollte

Delphi-Quellcode:

function crypt1(s: string): string; stdcall;
var wert: array of byte;
    i, j: integer;
begin
  s := s + 'A';
  RandSeed := 4546464;
  SetLength(wert, Length(s));
  Result := '';
  for i := 0 to Length(s) - 1 do
  begin
    for j := 1 to 62 do
    begin
      if s[i + 1] = list[j] then wert[i] := j;
    end;
    Result := Result + Format('%d%d', [wert[i], Random(wert[i])]);
  end;
  for i := 0 to Length(s) - 1 do
  begin
    for j := 1 to 62 do
    begin
      if s[i + 1] = list2[j] then wert[i] := j;
    end;
    Result := Result + Format('%d%d', [wert[i], Random(wert[i])]);
  end;
end;

Delphi-Quellcode:

function crypt1(s: string): string; stdcall;
var wert: byte;
    i, j: integer;
begin
  s := s + 'A';
  RandSeed := 4546464;
  Result := '';
  for i := 0 to Length(s) - 1 do
  begin
    for j := 1 to 62 do
    begin
      if s[i + 1] = list[j] then wert := j;
    end;
    Result := Result + Format('%d%d', [wert, Random(wert)]);
  end;
  for i := 0 to Length(s) - 1 do
  begin
    for j := 1 to 62 do
    begin
      if s[i + 1] = list2[j] then wert := j;
    end;
    Result := Result + Format('%d%d', [wert, Random(wert)]);
  end;
end;

wie gesagt, eine Prüfung ob der Variable wert innerhalb der Schleife überhaupt etwas zugewiesen wurde, wäre nicht schlecht

Delphi-Quellcode:

wert := 0;
for j := 1 to 62 do
begin
  if s[i + 1] = list2[j] then wert := j;
end; 
if wert = 0 then EineFehlermeldung;

so wie es jetzt ist, hätte "wert" einen zufälligen Inhalt, wenn es keinem Zeichen in list bzw. list2 entspricht.

mit einem Array[Char] of könntest du die ganze J-For-Schleife weglassen, da man damit das Zeichen direkt als Array-Index nutzen kann:

Delphi-Quellcode:

const list: array [AnsiChar] of Byte = (
  {    x0  x1  x2  x3  x4  x5  x6  x7  x8  x9  xa  xb  xc  xd  xe  xf}
  {0x}  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  {1x}  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  {2x}  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  {3x} 36, 27, 28, 29, 30, 31, 32, 33, 34, 35,  0,  0,  0,  0,  0,  0,
  {4x}  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
  {5x} 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,  0,  0,  0,  0,  0,
  {6x}  0, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
  {7x} 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62,  0,  0,  0,  0,  0,
  {8x}  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  {9x}  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  {ax}  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  {bx}  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  {cx}  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  {dx}  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  {ex}  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  {fx}  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0);
// List2 hab ich jetzt nicht übersetzt, aber mit 'ner 
// ASCII-Tabelle kannst das ganz einfach selber machen.
// Im Grunde ist das Ganze nur andersrum zu deinem Array:
// - bei dir wurde eine fortlaufende Zahl je mit einem Zeichen verknüpft
// - hier ist den entsprechenden Zeichen die passende fortlaufende Zahl zugeordnet

function crypt1(s: string): string; stdcall;
var wert: byte;
    i: integer;
begin
  s := s + 'A';
  RandSeed := 4546464;
  Result := '';
  for i := 0 to Length(s) - 1 do
  begin
    wert := list[s[i + 1]];
    if wert = 0 then HierEineFehlermeldungAusgeben;
    Result := Result + Format('%d%d', [wert, Random(wert)]);
  end;
  for i := 0 to Length(s) - 1 do
  begin
    wert := list2[s[i + 1]];
    if wert = 0 then HierEineFehlermeldungAusgeben;
    Result := Result + Format('%d%d', [wert, Random(wert)]);
  end;
end;

Aber wenn du wirklich was "ordentlich" verschlüsseln willst, dann schau dich mal nach DEC/DEC (von Hagen) um