ProHoster > Blog > Administratioun > Glanz an Aarmut Atomaustausch

Glanz an Aarmut Atomaustausch

Firwat atomarer Swaps sinn schlecht a wéi Channels hinnen hëllefen, wat wichteg Saache geschitt an der Konstantinopel schwéier Gabel a wat ze maachen wann Dir näischt fir Gas ze bezuelen hunn.

D'Haaptmotivatioun vun all Sécherheetsspezialist ass de Wonsch Verantwortung ze vermeiden.

D'Providence war barmhäerzlech, ech hunn d'ICO verlooss ouni op déi éischt irreversibel Transaktioun ze waarden, awer geschwënn hu mech selwer e Krypto-Austausch entwéckelt.

Ech sinn definitiv net Malchish Kibalchish, an ee strenge Bléck ass genuch fir mech all d'Schlësselen a Passwierder ze iwwerginn. Dofir war mäin Haaptziel als Architekt den rout-waarme Steng vun der Kryptoanalyse sou wäit wéi méiglech vun den Infrastrukturelementer déi mir gär hunn.

Net Är Schlësselen, net Är Probleemer

Mir bauen e Verméigenaustauschsystem a wëllen d'Zwëschenlagerung vun dësen Verméigen eliminéieren, awer mir mussen d'Sécherheet vun der Transaktioun garantéieren.

Dir kënnt als Riichter an enger kontroverser Situatioun handelen an Transaktioune mat Portemonnaie maachen, déi zwee vun dräi Ënnerschrëften erfuerderen: Keefer, Verkeefer an Escrow.

Wéi och ëmmer, wann de Participant den Escrow erfollegräich attackéiert, kritt hien déi néideg zwou Ënnerschrëften.

Atom Swap ass en Austauschschema wou de Garant e Smart Kontrakt ass deen nëmmen éierlech Verhalen erlaabt.

Wéi wann an engem Rätsel iwwer e Wollef, eng Geess an e Kabes, kënnt Dir nëmmen nom eenzege richtege Szenario handelen a Verloschter leiden, wann Dir dovun ofwäich.

Nëmmen amplaz vu grujeleg Déieren gëtt Uerdnung vun enger Hashfunktioun geliwwert, an där et sou schwéier ass eng Kollisioun ze fannen, datt et net derwäert ass unzefänken.

Schrëtt eent: Rätsel

Ugeholl datt d'Alice e schéine Moien dem Bob e Bitcoin fir eng Handvoll "Krypto-Yuan" wëll ginn.

  • Si mécht e grousst Geheimnis
  • Kritt en Hash dovun
  • Transfert Bitcoins op e Smart Kontrakt, aus deem de Bob Sue kann zréckzéien andeems e Geheimnis presentéiert (den Hash dovun muss gläich sinn wéi déi am Kontrakt spezifizéiert)
  • Wann de Bob owes net fir seng Bitcoins opdaucht, kann d'Alice se zréck op sech selwer huelen.

Schrëtt zwee: Köder

De Bob kënnt an d'Spill an iwwerweist "Krypto-Euro" op säi Kontrakt, deen esou geschriwwen ass:

  • D'Alice kann "Krypto-Yens" ewechhuelen andeems se eng geheim Nummer presentéieren
  • Net méi fréi wéi Mëttegiessen, Bob kann den Depot zréckginn wann d'Alice net opdaucht.

Schrëtt dräi: d'Äntwert ass am Köder

D'Alice kënnt fir hir Suen an hëlt d'Suen aus dem Bob säi Kontrakt, verroden hiert Geheimnis am Prozess.

Finale Schrëtt: d'Rätsel ass geléist

De Bob gesäit d'Transaktioun, a mat sengem Adler-Ae hëlt hien d'Geheimnis doraus eraus, dat d'Alice dem Kontrakt virgestallt huet. Hie benotzt dëst Geheimnis fir seng Bitcoins zréck ze huelen.

Wann Saachen falsch goen

Wann d'Alice op eemol stierflech ass, hëlt de Bob säi Yuan am Mëttegiessen.

Am Géigesaz, bréngt d'Alice de Bitcoin am Owend zréck, wann de verréide Bob decidéiert d'Sue bis besser Zäiten ze halen.

Wann Dir léiwer e Bild op Text wëllt, huet den Habré eng méi detailléiert a visuell fir Iech. Erklärung wéi Atomswaps funktionnéieren.

Den Ënnerscheed tëscht den Timeouts ass entwéckelt fir eis géint déi béiswëlleg Alice ze versécheren, déi dem Bob seng Suen am leschte Moment hëlt, an den Timeout leeft aus, während hien mat zidderen Fanger an d'Hex an d'Transaktioun erakënnt.

D'Participanten kënnen hir Sue maximal net verléieren, si mussen op e Remboursement waarden.

Blockchain ËnnerstëtzungDëst ass en einfache Schema dat guer näischt erfuerdert vu Blockchainen ze interagéieren:

  • Ënnerstëtzung fir Smart Kontrakter mat mindestens enger Branche
  • Béid Blockchaine mussen déiselwecht Hashing Algorithmen ënnerstëtzen (erënnert Iech un déi geheim Längt ze kontrolléieren)
  • Timelocks.

Op den éischte Bléck kann een der Bourse scho soen "Äddi, eis Versammlung war e Feeler", awer dat war net de Fall.

Fir all hir Virdeeler, atomarer Swap-Léisungen beandrocken net mat hirer Liquiditéit. Haaptsächlech well am populäersten BTC-USD Pair de Fiat Deel net voll tokeniséiert gouf.
Den Erfolleg vun USDT huet zu enger ganzer Welle vu stabile Mënzen am ERC20-Format fir all Goût entstanen, vun der am meeschte gespaarten USDC bis zum algorithmesche DAI.

Dofir, fir Simplicitéit, plädéieren mir weider datt Alice Bob Bitcoins fir e puer ERC20 Tokens verkeeft, a mir hoffen op d'Gléck vun de Stabilisatoren, well mir nach vill méi technesch Problemer hunn.

Speed

Bitcoin an Ethereum sinn net ganz séier individuell, awer hei musse mir als éischt op eng Depot mat all Bestätegungen waarden, dann op déi zweet.

Dëst ass alles well de Participant deen d'Geheimnis kennt fir d'éischt d'Suen deposéiert, an de Géigner waart op d'Finale an iwwerdréit nëmmen säin Deel.

Ausserdeem hu mir mat engem ganz liichtflüchtege Verméigen ze dinn, sou datt während dëser Zäit den Taux zimlech däitlech änneren kann, an d'Konditioune änneren ass net méi einfach.

Vertraulechkeet

All Austausch léisst Artefakte op béide Blockchainen. En opmierksam Beobachter kann déiselwecht Hashes an intelligente Kontrakter bemierken an eng logesch Conclusioun maachen datt eng Transaktioun ofgeschloss ass, aus deem vill Conclusiounen aus der Tax op Steier gezunn kënne ginn.

Wann d'Bourse iwwer Är Affären weess, ass et extrem désagréabel, wann jiddereen doriwwer weess, et ass duebel désagréabel.

Benotzerfrëndlechkeet

De staarke Punkt vu Blockchain am Allgemengen an Ether besonnesch. Loosst eis kucken wéi eng Gesten de Verkeefer a Keefer musse maachen.

Aus der Siicht vum Verkeefer ass alles relativ einfach: Dir musst just Bitcoin op eng p2sh Adress transferéieren. Mat Ether ass alles vill méi komplizéiert.

De KontraktLoosst eis de Kontrakt duerchschnëttlech iwwer Github kucken fir en Austausch:

contract iERC20 {
    function totalSupply() public view returns (uint256);
    function transfer(address receiver, uint numTokens) public returns (bool);
    function balanceOf(address tokenOwner) public view returns (uint);
    function approve(address delegate, uint numTokens) public returns (bool);
    function allowance(address owner, address delegate) public view returns (uint);
    function transferFrom(address owner, address buyer, uint numTokens) public returns (bool);
}

contract Swapper {

    struct Swap {
        iERC20 token;
        bytes32 hash;
        uint amount;
        uint refundTime;
        bytes32 secret;
    }

    mapping (address => mapping(address => Swap)) swaps;

    function create(iERC20 token, bytes32 hash, address receiver, uint amount, uint refundTime) public {
        require(swaps[msg.sender][receiver].amount == 0); // check is swap with given hash already exists
        require(token.transferFrom(msg.sender, address(this), amount)); // transfer locked tokens to swap contract
        swaps[msg.sender][receiver] = Swap(token, hash, amount, refundTime, 0x00); //create swap
    }
    
    function hashOf(bytes32 secret) public pure returns(bytes32) {
        return sha256(abi.encodePacked(secret));
    }


    function withdraw(address owner, bytes32 secret) public {
        Swap memory swap = swaps[owner][msg.sender];
        require(swap.secret == bytes32(0));
        require(swap.hash == sha256(abi.encodePacked(secret))); // swap exists
        swaps[owner][msg.sender].secret = secret;
        swap.token.transfer(msg.sender, swap.amount);
    }

    function refund(address receiver) public {
        Swap memory swap = swaps[msg.sender][receiver];
        require(now > swap.refundTime);
        delete swaps[msg.sender][receiver];
        swap.token.transfer(msg.sender, swap.amount);
    }
}

Opgepasst weg! Benotzt dës an aner Kontrakter net aus dem Artikel an der Produktioun, si sinn nëmme fir Demonstratiounszwecker geschriwwe. Besonnesch dësen.

  • De Bob muss d'Methode vum Tokenkontrakt nennen approve, gëtt dem Swap-Kontrakt Zougang zu sengen Tokens
  • De Bob erstellt den Austausch a Kontrakt mat der Method transferFrom hëlt dem Sender seng Tokens op Är Adress
  • Alice an withdraw verréid d'Geheimnis an de Kontrakt rifft transfer

Déi meescht Portemonnaie a Krypto-Austausch ënnerstëtzen net approve Tokens, a fir gudde Grond.

D'Benotzer selwer maachen dacks Feeler an iwwerdroen einfach Tokens op de Kontrakt, duerno ginn d'Tokens einfach verluer. D'Kommentaren op Etherscan sinn voller Lamenter vum Onglécklechen.

A fir e Kontrakt ze ruffen, musst Dir eng Kommissioun an der ETH bezuelen, dat heescht datt béid Participanten et musse stockéieren ier Dir d'Transaktioun starten, a wéineg Leit wëllen dat maachen.

Gashalter

Eng gutt Plaz fir unzefänken ass de Sendercheck iwwerall méiglech ze läschen an unzehuelen datt mir een hunn deen ënner iwwerschësseg Gas rifft Kontrakter fir all Komern.

Upgrade Kontrakt

contract Swapper {

    struct Swap {
        iERC20 token;
        address receiver;
        uint amount;
        address refundAddress;
        uint refundTime;
    }

    mapping (bytes32 =>  Swap) swaps;

    function create(iERC20 token, bytes32 hash, address receiver, uint amount, address refundAddress, uint refundTime) public {
        require(swaps[hash].amount == 0); // use hash once
        require(token.transferFrom(msg.sender, address(this), amount));
        swaps[hash] = Swap(token, receiver, amount, refundAddress, refundTime);
    }


    function withdraw(bytes memory secret) public {
        bytes32 hash = sha256(secret);
        Swap memory swap = swaps[hash];
        require(swap.amount > 0);
        delete swaps[hash];
        swap.token.transfer(swap.receiver, swap.amount);
    }

    function refund(bytes32 hash) public {
        Swap memory swap = swaps[hash];
        require(now > swap.refundTime);
        delete swaps[hash];
        swap.token.transfer(swap.refundAddress, swap.amount);
    }
}

Kontrakt-Schlëssel Dualismus an EIP 712

Wéi mir wëssen, kann eng Adress op der Loft e Kontrakt sinn, oder et kann e Sujet sinn, dat ass e Schlëssel.
D'Haaptaufgab vum Schlëssel ass e puer Messagen z'ënnerschreiwen.

Mir kënnen de Bob-Kontrakt als Sender benotzen, deen all néideg Passë mécht, nodeems Dir d'Ënnerschrëft vum Bob-Key fir d'éischt iwwerpréift huet.

Elo kann jidderee eng Participantkommissioun sponseren, awer nëmmen deen, deen de Schlëssel kennt, mécht d'Entscheedung.

Bob-Kontrakt

library EIP712ProxyLibrary {
    function hashCommand(address sender, iERC20 token, Swapper swapper, bytes32 hash, address receiver, uint amount, address refundAddress, uint refundTime) public view returns(bytes32);
}

contract ProxyBob {
    address owner;

    constructor(address _owner) public {
        owner = _owner;
    }

    function createSwap(Swapper swapper, iERC20 token, bytes32 hash, address receiver, uint amount, address refundAddress, uint refundTime, uint8 v, bytes32 r, bytes32 s) public {
        require(owner == ecrecover(EIP712ProxyLibrary.hashCommand(address(this), token, swapper, hash, receiver, amount, refundAddress, refundTime), v, r, s));
        token.approve(address(swapper), amount);
        swapper.create(token, hash, receiver, amount, refundAddress, refundTime);
    }
}

Ethereum huet e Standard fir mat Ënnerschrëfte vu komplexen Datestrukturen ze schaffen EIP 712 eng, Dir kënnt méi doriwwer liesen an Metamask Portemonnaie Blog

Deelen a conquéieren

Oft gesäit de Szenario fir en Ethereum Kontrakt ze hacken esou aus:

  • De Participant deposéiert Fongen an de Kontrakt
  • Da hëlt hien d'Fongen
  • Et geet eppes falsch
  • Den Ugräifer hëlt d'Suen ëmmer erëm

Wa mir zréck op eist éischt Beispill goen, geet eppes falsch wann d'Rätsel eng eidel Set vu Bytes ass.

Wéi eng Millioun ze klauenErstellt e Swap mat engem Hash 0x66687aadf862bd776c8fc18b8e9f8e20089714856ee233b3902a591d0d5f2925
Dëst ass sha256 aus 0x0000000000000000000000000000000000000000000000000000000000000000
Mir transferéieren d'Geheimnis an huelen eis Tokens
Mir iwwerdroen nach eng Kéier an huelen een aneren, alles well 0 = 0

Andeems Dir e separaten Kontrakt fir all Handel erstellt, kënne mir Kontrakter um EVM Niveau isoléieren.

Awer dat ass net alles: elo huet all Transaktioun seng eegen Adress, op déi Dir Tokens vun all Portemonnaie oder Austausch transferéiere kënnt.

Opginn Kontrakter a schafen2

Awer elo fir all Transaktioun musse mir e Kontrakt erstellen a waarden op de Keefer fir d'Aarbecht "Krypto-Find" do ze transferéieren. Am Schema "Kontrakter am Mueren, Geld am Owend" ass et ëmmer eng Gefor datt de Keefer falen, an d'Äther ass scho fir de Kontrakt ze kreéieren.

Ass et méiglech et sou ze maachen, datt Dir Moies Geld hutt an owes Bytes?

Entwéckler am Konstantinopel schwéier Gabel EIP 1014 eng huet d'create2 Instruktioun bäigefüügt, déi en neie Kontrakt op enger deterministescher Adress erstellt

keccak256( 0xff ++ address ++ salt ++ keccak256(init_code))[12:]

Wou

  • Adress - Fabréck Kontrakt Adress
  • Salz - eng Zuel, d'Bedeitung vun deem mir an der nächster Serie léieren
  • init_code - Kontrakt Bytecode a Konstruktor Parameteren.

FabréckD'Instruktioun funktionnéiert nëmmen duerch d'Versammlung, sou datt d'Fabréck e bëssen grujeleg ausgesäit:

contract Factory {
  event Deployed(address addr, uint256 salt);

  function create2(bytes memory code, uint256 salt) public {
    address addr;
    assembly {

      addr := create2(0, add(code, 0x20), mload(code), salt)
    }

    emit Deployed(addr, salt);
  }
}

Äre Kontrakt Code kann mat Web3 kritt ginn:

const MyContract = new web3.eth.Contract(ABI, {})
const сode = MyContract.deploy({
    data: BYTECODE,
    arguments: contructorArgs  
}).encodeABI();
const factory = new web3.eth.Contract(FACTORY_ABI, factoryAddress);
tx = factory.methods.create2(сode, salt);

Wéinst limitéierter Ënnerstëtzung an der Soliditéit kann de Gas fir e Kontrakt falsch berechent ginn wéinst e puer Subtletien vum Ether.

Besonnesch schéin ass et, datt am Fall vun engem Gasmangel de Kontrakt mat engem internen Fehler ofstëmmt, ouni ze mellen, datt et net genuch Gas war, wéi Dir et erwaart.

Elo kënne mir Tokens op Kontrakter transferéieren ouni se am Viraus ze kreéieren, a bis mir se am Netz verëffentlechen, wäert keen roden wat genau de Kontrakt mécht.

E Kueb wäert net d'Ae vun engem Kréien erauspicken

Et ass kloer, datt e richtegen Analyst, virun allem een ​​deen gutt Investitiounen am Kampf géint d'Feinde vum Regime mat Geldwäsch kritt huet, wäert net vun esou kannerech Tricken gestoppt ginn, an no der Schafung vum Kontrakt wäert hien nach ëmmer den Hash gesinn.

Wéi verhënnere mir datt den Hash ugewise gëtt?

Mir transferéieren den Swap selwer op den Offchain: d'Participanten tauschen d'Ënnerschrëfte fir en Transfer op e Swap-Kontrakt aus, an da gëtt d'Geheimnis privat opgedeckt.

Schrëtt fir SchrëttZwee "Multisigs" ginn erstallt, aus deenen d'Fongen zréckgezunn kënne ginn, wann d'Alice an de Bob Ënnerschrëften hunn.

Fir ze verhënneren datt iergendeen vun de Participanten offline geet, eng Tragedie gëtt, addéiere mir e gudden alen Timeout.

Alice a Bob maachen Dépôten parallel

  • D'Alice schätzt e Geheimnis a gëtt dem Bob en Hash vum Geheimnis an eng Transaktiouns Ënnerschrëft déi d'Bitcoins op d'Swapadress transferéiert.
  • De Bob gëtt Alice eng Ënnerschrëft fir Tokens zu engem Tauschkontrakt mat engem verstoppte Hash zréckzezéien.
  • D'Alice erzielt dem Bob e Geheimnis.

Zu dësem Moment kënnt d'Harmonie: souwuel d'Alice wéi de Bob kënnen den Deal zu all Moment ofschléissen. An esou engem frëndlechen Ëmfeld kënne si Ënnerschrëften austauschen fir Suen op déi lescht Adressen zréckzezéien.

Fir en externen Beobachter gesäit et aus wéi wann d'Suen duerch en 2-vun-2 Multisig Kontrakt gaang sinn.

Dëse Schema erlaabt och béid Parteien en Depot zur selwechter Zäit ze maachen, well d'Geheimnis no all Bestätegungen opgedeckt gëtt.

Niveau 2

Well mir Sue kënnen op eng Adress zréckzéien an keng Zwëschentransaktioun verëffentlechen, verhënnert näischt datt mir Suen op e puer Adressen zréckzéien an eng onlimitéiert Zuel vun Zwëschentransaktiounen maachen. Et ass net datt dëst e noutwendege Set fir en Austausch ass, awer wann Dir ufänkt e Swap ze sammelen, ass et schwéier ze stoppen.

Elo kënnen d'Alice an de Bob sech mat aller Kraaft ëmdréien. Zum Beispill, Berechent automatesch den Duerchschnëttspräis andeems Dir Satoshi pro Sekonn austauscht, oder einfach direkt de Maarthändler a Liquiditéitsempfänger verbannen.

Schrëtt fir Schrëtt

  • De Verkeefer mécht e Geheimnis a gëtt dem Keefer en Hash vum Geheimnis an eng Transaktiouns Ënnerschrëft wou en Deel vun de Fongen op d'p2sh Swap Adress transferéiert gëtt, an de Rescht gëtt op d'Adress vum Verkeefer zréckginn.
  • De Keefer stellt eng Ënnerschrëft of, déi et erlaabt datt d'Swap-Tokens an d'Ännerung un d'Adress vum Empfänger geschéckt ginn.
  • De Verkeefer verréit d'Geheimnis
  • D'Geschicht widderhëlt sech mat engem neie Geheimnis, an nieft dem Tausch an Ännerung gëtt de Réckzuch vun deem wat virdru op d'Adress vum Keefer kaaft gouf a scho op d'Adress vum Verkeefer bezuelt gouf.

Elo hu mir Zougang zu High-Speed ​​​​P2p Handel, den Haapt Saach ass d'Zäit ze verfollegen an den Deal virum Timeout zouzemaachen.

Wéi och ëmmer, andeems mir eis Kontrakter e bëssen upassen, kënne mir eise Kanäl Onstierflechkeet ginn, wat et vill méi einfach mécht fir eis en Netzwierk ze bauen.

Mee mir wäerten iwwer dëst an der nächster Episod schwätzen.

Source: will.com

Setzt e Commentaire