Heap overflow [Pascal]

Neue Frage »

tigerbine Auf diesen Beitrag antworten »
Heap overflow [Pascal]
Das Programm läuft jetzt bis zu einem Wert von n=2500. (Und auch alles "schnell". nicht wieder ein Tag Wartezeit) Ab dann tritt im letzten Arbeitsschritt, der Lexikografischen Sortierung der Matrix S(n² x 3) die Fehlermeldung "Exitcode 203" auf. Soll für einen Heap overflow stehen.

Was ist das? http://www.my-smileys.de/smileys3/hideing_behind_computer.gif

Zitat:
wikipedia
Heap-Überlauf

Ein Heap-Überlauf ist ein Pufferüberlauf, der auf dem Heap stattfindet. Speicher auf dem Heap wird zugewiesen, wenn Programme dynamischen Speicher anfordern, etwa über malloc() oder den new-Operator in C++. Werden in einen Puffer auf dem Heap Daten ohne Überprüfung der Länge geschrieben und ist die Datenmenge größer als die Größe des Puffers, so wird über das Ende des Puffers hinausgeschrieben und es kommt zu einem Speicherüberlauf.

Durch Heap-Überläufe kann meist beliebiger Code auf dem Rechner ausgeführt werden, insbesondere wenn der Heap ausführbar ist. FreeBSD hat beispielsweise einen Heap-Schutz, hier ist dies nicht möglich. Sie können nur in Programmiersprachen auftreten, in denen bei Pufferzugriffen keine Längenüberprüfung stattfindet. C, C++ oder Assembler sind anfällig, Java oder Perl sind es nicht.

Siehe auch: Shellcode, Exploit


?? http://www.my-smileys.de/smileys3/chinese_2.gif??
sqrt(2) Auf diesen Beitrag antworten »

Was an dem Text verstehst du nicht? Raten ist übrigens sehr mühselig, du könntest schon die relevanten Codeteile posten...
tigerbine Auf diesen Beitrag antworten »

Hallo sqrt(2),

Es wäre nun müßig jedes Wort des Textes farbig zu unterlegen. Geh einfach mal davon aus, dass ich von dem "wie ein Computer arbeitet" keine Ahnung habe.

Hier der Code.

code:
1:
2:
3:
4:
5:
6:
7:
8:
9:
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:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
program ...

Var S2: ARRAY OF [0..2] OD DOUBLE;

function Le(k1, k2: LONGINT): BOOLEAN;
begin
   if      (S2[k1,0] < S2[k2,0]) then Le:=true
   else if (S2[k1,0] > S2[k2,0]) then Le:=false
   else if (S2[k1,0] = S2[k2,0]) then
        begin
        if      (S2[k1,1] < S2[k2,1]) then Le:=true
        else if (S2[k1,1] > S2[k2,1]) then Le:=false
        else if (S2[k1,1] = S2[k2,1]) then
             begin
             if      (S2[k1,2] < S2[k2,2]) then Le:=true
             else                               Le:=false;
             end;
        end;
end;


function Gr(k1, k2: LONGINT): BOOLEAN;

begin
   if      (S2[k1,0] > S2[k2,0]) then Gr:=true
   else if (S2[k1,0] < S2[k2,0]) then Gr:=false
   else if (S2[k1,0] = S2[k2,0]) then
      begin
      if      (S2[k1,1] > S2[k2,1]) then Gr:=true
      else if (S2[k1,1] < S2[k2,1]) then Gr:=false
      else if (S2[k1,1] = S2[k2,1]) then
         begin
         if     (S2[k1,2] > S2[k2,2]) then Gr:=true
         else                              Gr:=false;
         end;
      end;
end;


procedure swap(i,j: LONGINT);
begin
sx:=S2[i,0]; sy:=S2[i,1]; sz:=S2[i,2];
S2[i,0]:=S2[j,0]; S2[i,1]:=S2[j,1]; S2[i,2]:=S2[j,2];
S2[j,0]:=sx; S2[j,1]:=sy; S2[j,2]:=sz;
end;


procedure LEXIQS(Links, Rechts: LongInt);

var i,j, pivot: Longint;

begin

   Pivot:=Links; i:=Links; j:=Rechts;

   repeat
     { while S2[i,0] < S2[Pivot,0] do Inc(i);}
     { while S2[j,0] > S2[Pivot,0] do Dec(j);}

      while Le(i,Pivot)=true do Inc(i);
      while Gr(j,Pivot)=true do Dec(j);

      if i <=j then
      begin
        swap(j,i);
        Inc(i);
        Dec(j);
      end;
    until i > j;

    if Links < j then LEXIQS(Links, j);

    if i < Rechts then LEXIQS(i, Rechts);

end;

begin
....

{Teil 9: Zeilen Lexikografisch sortieren mit Quicksort}

writeLn('Zeilen Lexikografisch sortieren mit Quicksort');

...
end.
LEXIQS(0,sqr(n)-1);
sqrt(2) Auf diesen Beitrag antworten »

Zitat:
Original von tigerbine
Es wäre nun müßig jedes Wort des Textes farbig zu unterlegen.

Außerdem wäre es übertrieben.

Zitat:
Original von tigerbine
Geh einfach mal davon aus, dass ich von dem "wie ein Computer arbeitet" keine Ahnung habe.

Du weißt, aber, dass das Ding irgendwie Arbeitsspeicher hat. Wir lassen jetzt mal das Betriebssystem beiseite, das soll die ganze Adressierung für uns erledigen. Dann kannst du einfach davon ausgehen, dass es zwei Typen von Speicher gibt, in dem du Daten ablegen kannst: Heap und Stack.

Der Stack ist -- wie der Name schon sagt -- sowas wie ein Stapel (korrekt heißt er auf deutsch "Kellerspeicher", warum auch immer): Du kannst oben was drauflegen, aber auch nur von oben wieder was herunternehmen. Der Stack wird dazu verwendet, die Parameter und lokalen Variablen von Funktionen zu speichern: Beim Funktionsaufruf werden sie einfach oben auf den Stack draufgepackt. Ruft deine Funktion noch eine Funktion auf, packt die wiederum ihre Variablen oben drauf: Die der aufrufenden Funktion braucht man ja jetzt erstmal nicht. Wenn eine Funktion zu Ende ist, nimmt sie ihre Variablen einfach vom Stack wieder herunter und die aufrufende Funktion hat wieder ihre eigenen Variablen oben.

Im Heap kannst du auf Speicher zugreifen und ihn wieder freigeben, wie du willst. Globale Variablen und dynamisch allokierter Variablen liegen im Heap. Der Witz an der Sache ist jetzt: Erstens verwendest du den Heap kaum und zweitens bietet Freepascal einen dynamisch wachsenden Heap, d.h. um dessen Größe musst du dich eigentlich gar nicht kümmern.

Meine Theorie ist folgende: Auf vielen Plattformen wächst der Stack abwärts (von hohen zu niedrigen Speicheradressen), der Heap aufwärts. (Wenn du dir deinen Speicher als Hochhaus vorstellst, werden für den Stack die obersten Stockwerke abwärts vollgeräumt und für den Heap die unteren aufwärts.) Den Stack verwendest du durch die Rekursion aber schon (obwohl du jetzt auch keine wahnsinnig großen Rekursionstiefen hast). Heap und Stack können sich irgendwo in der Mitte treffen (deswegen sind die Stackgrößen eigentlich vorher festgelegt), vielleicht hast du in der Richtung ein Problem. Du könnest einfach mal probieren, größere Stackgrößen einzustellen (dafür gibt es Compilerswitches, schau im Handbuch nach).
tigerbine Auf diesen Beitrag antworten »

Das war jetzt mal eine Erklärung, die ich Dummy auch verstanden habe. Mit Zunge Bis auf den Letzen Satz.

Zitat:
sqrt(2)
Du könnest einfach mal probieren, größere Stackgrößen einzustellen (dafür gibt es Compilerswitches, schau im Handbuch nach).


Handbuch von wem?
sqrt(2) Auf diesen Beitrag antworten »

Zitat:
Original von tigerbine
Handbuch von wem?

http://www.freepascal.org/docs-html/
 
 
tigerbine Auf diesen Beitrag antworten »

Danke Augenzwinkern
Neue Frage »
Antworten »



Verwandte Themen

Die Beliebtesten »
Die Größten »
Die Neuesten »