Grundlegendes zu Überlauf- und Unterlaufangriffen auf intelligente Verträge

Leitfaden für Überlauf- und Unterlaufangriffe auf Smart Contracts.

Betrachten Sie das folgende Diagramm:

Grundlegendes zu Überlauf- und Unterlaufangriffen auf intelligente Verträge

Dies ist ein normaler Kilometerzähler, der die zurückgelegte Entfernung Ihres Autos berechnet. Dieser Kilometerzähler reicht von 000000 – 999999. Aus diesem Grund wird Ihr Kilometerzähler in dem Moment, in dem Sie 1.000.000 km überqueren, auf 000000 zurückgesetzt.

Dies kann schwerwiegende schwerwiegende Auswirkungen haben.

Grundlegendes zu Überlauf- und Unterlaufangriffen auf intelligente Verträge

Denken Sie an die Jahrtausendwende und das Y2K-Problem. Y2K war eine Klasse von Computerfehlern, die um die Jahrtausendwende zu Chaos drohten. Um es so einfach wie möglich zu halten, repräsentierten viele Programme vierstellige Jahre mit nur den letzten beiden Ziffern. 1998 wurde also als 98 und 1999 als 99 gespeichert. Dies wäre jedoch problematisch, wenn sich das Jahr auf 2000 ändert, da das System es als 00 speichert und auf 1900 zurücksetzt.

Beide Beispiele, die wir Ihnen oben gegeben haben, sind eine Fehlerklasse, die als “ganzzahliger Überlauf” bezeichnet wird. In diesem Handbuch werden wir die nachteiligen Auswirkungen der Überlauf- und Unterlaufangriffe auf intelligente Verträge untersuchen.

Der Überlauffehler

Ein Überlauf tritt auf, wenn eine Zahl über ihren Maximalwert erhöht wird. Angenommen, wir deklarieren eine uint8-Variable, die eine vorzeichenlose Variable ist und bis zu 8 Bit aufnehmen kann. Dies bedeutet, dass es Dezimalzahlen zwischen 0 und 2 ^ 8-1 = 255 haben kann.

Beachten Sie vor diesem Hintergrund das folgende Beispiel.

uint a = 255;

a ++;

Dies führt zu einem Überlauf, da der Maximalwert von a 255 beträgt.

Solidity kann bis zu 256-Bit-Zahlen verarbeiten. Eine Erhöhung um 1 würde zu einer Überlaufsituation führen:

Dies führt zu einem Überlauf, da der Maximalwert von a 255 beträgt.

Solidity kann bis zu 256-Bit-Zahlen verarbeiten. Eine Erhöhung um 1 würde zu einer Überlaufsituation führen:

0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

+ 0x00000000000000000000000000000000000001

——————————————-

= 0x00000000000000000000000000000000000000

Überprüfen wir den Überlauffehler mit einem einfachen Token-Übertragungsvertrag (Code aus GitHub):

Zuordnung (Adresse => uint256) public balanceOf;

// INSECURE

Funktionsübertragung (Adresse _to, uint256 _Wert) {

/ * Überprüfen Sie, ob der Absender ein Guthaben hat * /

erfordern (balanceOf [msg.sender] >= _Wert);

/ * Neue Salden addieren und subtrahieren * /

balanceOf [msg.sender] – = _value;

balanceOf [_to] + = _value;

}}

// SICHER

Funktionsübertragung (Adresse _to, uint256 _Wert) {

/ * Überprüfen Sie, ob der Absender ein Guthaben hat und ob es zu Überläufen kommt * /

erfordern (balanceOf [msg.sender] >= _Wert && balanceOf [_to] + _value >= balanceOf [_to]);

/ * Neue Salden addieren und subtrahieren * /

balanceOf [msg.sender] – = _value;

balanceOf [_to] + = _value;

}}

Also, was haben wir hier?

Es gibt zwei Übertragungsfunktionen, die im obigen Programm verwendet werden. Einer sucht nach einem Überlauf, der andere nicht nach einem Überlauf. Die sichere Übertragungsfunktion prüft, ob der Kontostand den Maximalwert erreicht.

Jetzt müssen Sie eines im Auge behalten. Diese Funktion ist möglicherweise nicht immer relevant, insbesondere in dem oben angegebenen Szenario. Als Entwickler muss man sich überlegen, ob der Wert jemals ein so hohes Niveau erreichen wird oder ob sie nur unnötig Benzin ausgeben.

Der Unterlauffehler

Jetzt erreichen wir das andere Ende des Spektrums, den Unterlauffehler. Dies funktioniert genau in die entgegengesetzte Richtung. Denken Sie daran, wie uint8 nur Werte zwischen 0 und 255 annehmen kann? Betrachten Sie den folgenden Code.

unint8 a = 0;

ein-;

Wir haben gerade einen Unterlauf verursacht, der dazu führt, dass a den maximal möglichen Wert von 255 hat.

Anwendung der gleichen Logik bei Solidity Smart Contracts:

0x00000000000000000000000000000000000000

– 0x00000000000000000000000000000000000001

——————————————-

= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

Wie Sie sehen, kann dies zu schwerwiegenden Falschdarstellungen von Daten führen.

Schauen wir uns einen Code an und sehen, wie ein einfacher Unterlauf in einem intelligenten Vertrag (Code aus GitHub) zu Chaos führen kann:

Zuordnung (Adresse => uint256) public balanceOf;

// INSECURE

Funktionsübertragung (Adresse _to, uint256 _Wert) {

/ * Überprüfen Sie, ob der Absender ein Guthaben hat * /

erfordern (balanceOf [msg.sender] >= _Wert);

/ * Neue Salden addieren und subtrahieren * /

balanceOf [msg.sender] – = _value;

balanceOf [_to] + = _value;

}}

// SICHER

Funktionsübertragung (Adresse _to, uint256 _Wert) {

/ * Überprüfen Sie, ob der Absender ein Guthaben hat und ob es zu Überläufen kommt * /

erfordern (balanceOf [msg.sender] >= _Wert && balanceOf [_to] + _value >= balanceOf [_to]);

/ * Neue Salden addieren und subtrahieren * /

balanceOf [msg.sender] – = _value;

balanceOf [_to] + = _value;

}}

In dem oben angegebenen Codebeispiel kann ein Hacker manipulateMe nutzen, da die dynamischen Arrays sequentiell gespeichert werden. Alles, was ein Hacker tun muss, ist:

Rufen Sie popBonusCode zum Unterlauf auf

Berechnen Sie den Speicherort von manipulateMe

Ändern und aktualisieren Sie den Wert von manipulateMe mithilfe von modifyBonusCode

Natürlich ist es einfach, auf alle Fehler in isolierten Funktionen hinzuweisen. Stellen Sie sich jedoch einen langen und komplizierten intelligenten Vertrag mit Tausenden von Codezeilen vor. Es kann sehr leicht sein, einen solchen Fehler bei der Codeüberprüfung aus den Augen zu verlieren.

Gefahren von Überlauf- und Unterlaufangriffen

Es ist wahrscheinlicher, dass der Unterlauffehler auftritt als der Überlauffehler, da es für jemanden nicht möglich ist, die erforderliche Anzahl von Token zu erhalten, um einen Überlauf zu verursachen.

Stellen Sie sich eine Situation vor, in der ein Token-Inhaber nur X Token hat. Angenommen, er versucht, X + 1 Token auszugeben. Wenn das Programm dies nicht einmal überprüft, besteht die Möglichkeit, dass ein Angreifer mehr Token als tatsächlich erhält und ein maximales Gleichgewicht erhält.

Betrachten Sie das folgende Beispiel (aus Nethemba):

Pragma-Solidität ^ 0,4,22;

Vertragstoken {

Zuordnung (Adresse => uint) Guthaben;

Funktionsübertragung (Adresse _to, uint _Wert) public {

require (balances [msg.sender] – _value >= 0);

Salden [msg.sender] – = _value;

Salden [_to] + = _Wert;

}}

}}

In dem oben angegebenen Code sieht die Erforderungsbedingung in der Übertragungsfunktion auf den ersten Blick möglicherweise korrekt aus, jedoch nur, bis Sie feststellen, dass Operationen zwischen zwei Einheiten einen Einheitswert erzeugen.

Was dies letztendlich bedeutet, ist, dass der Wert von Salden [msg.sender] – _Wert >= 0 wird immer wahr sein, unabhängig von der Bedingung.

Aufgrund dieser Bedingung kann ein Hacker tatsächlich mehr Geld besitzen als er tatsächlich besitzt, und sein Guthaben maximal ausschöpfen. Z.B. Wenn der Hacker 100 Token besitzt und versucht, 101 Token zu besitzen, erhält er 100-101 Token, was ihm aufgrund des Unterlaufs 2 ^ 256-1 Token gibt!

Dies kann einfach das gesamte System beschädigen.

Probleme in der realen Welt durch Unterlaufangriffe

4chans / biz / gruppierte zusammen “Proof of Weak Hands Coin” oder “POWH”. Es war ein legitimes Ponzi-Programm, aber die Leute kauften es immer noch und es wuchs auf über eine Million Dollar.

Es stellt sich jedoch heraus, dass die Entwickler der POWH-Münze nicht alle Vorgänge gesichert haben und nicht in der Lage waren, die richtigen Abwehrmaßnahmen gegen Überlauf- und Unterlaufangriffe zu ergreifen. Aus genau diesem Grund konnte ein unbekannter Hacker die 2000 ETH mit einem Wert von ~ 2,3 Millionen US-Dollar abschöpfen.

Wie Sie sehen, ist es für Entwickler wichtig, ihre Abwehrkräfte gegen Überlauf- und Unterlaufangriffe zu stärken. Als Kopfgeldjäger sollten Sie nach Überlauf- / Unterlaufangriffen Ausschau halten.

Mike Owergreen Administrator
Sorry! The Author has not filled his profile.
follow me
Like this post? Please share to your friends:
map