BTC
ETH
HTX
SOL
BNB
ดูตลาด
简中
繁中
English
日本語
한국어
ภาษาไทย
Tiếng Việt

EVM เชิงลึก - ความเสี่ยงที่อยู่เบื้องหลังเรื่องเล็กน้อยของการจัดประเภทสัญญา

十四君
特邀专栏作者
บทความนี้มีประมาณ 3491 คำ การอ่านทั้งหมดใช้เวลาประมาณ 5 นาที
เริ่มต้นจากสาเหตุที่ควรจัดประเภทสัญญา รวมกับประเภทของการโจมตีที่เป็นอันตรายในแต่ละสถา
สรุปโดย AI
เริ่มต้นจากสาเหตุที่ควรจัดประเภทสัญญา รวมกับประเภทของการโจมตีที่เป็นอันตรายในแต่ละสถา

ในด้านสัญญาอัจฉริยะ"เครื่องเสมือน Ethereum EVM"และอัลกอริทึมและโครงสร้างข้อมูลเป็นหลักการแรก

บทความนี้เริ่มต้นจากสาเหตุที่ควรจัดประเภทสัญญา และรวมประเภทของการโจมตีที่เป็นอันตรายในแต่ละสถานการณ์ที่อาจเผชิญ และสุดท้ายให้ชุดของอัลกอริทึมการวิเคราะห์การจัดประเภทสัญญาที่ค่อนข้างปลอดภัย

แม้ว่าเนื้อหาทางเทคนิคจะสูง แต่ก็สามารถใช้เป็นสื่อการอ่านสำหรับการพูดคุยเบ็ดเตล็ดชื่อระดับแรก

1. ทำไมจึงต้องจัดประเภทสัญญา?

เนื่องจากมีความสำคัญมาก จึงอาจกล่าวได้ว่าเป็นรากฐานที่สำคัญของ Dapps เช่น การแลกเปลี่ยน, กระเป๋าสตางค์, เบราว์เซอร์บล็อกเชน, แพลตฟอร์มการวิเคราะห์ข้อมูล ฯลฯ!

เหตุผลที่ธุรกรรมเป็นการโอน ERC 20 เนื่องจากพฤติกรรมของเขาเป็นไปตามมาตรฐาน ERC 20 อย่างน้อย:

  1. สถานะของธุรกรรมคือสำเร็จ

  2. ที่อยู่ To คือสัญญาที่เป็นไปตามมาตรฐาน ERC 20

  3. เรียกว่าฟังก์ชัน Transfer ซึ่งมีลักษณะเฉพาะคือ 4 หลักแรกของธุรกรรม CallData คือ 0x a 9059 cbb

  4. หลังจากดำเนินการแล้ว เหตุการณ์การโอนจะถูกส่งไปยังที่อยู่ถึง

หากการจัดประเภทผิด พฤติกรรมการทำธุรกรรมจะถูกตัดสินผิด

ด้วยพฤติกรรมการทำธุรกรรมเป็นรากฐานที่สำคัญ ไม่ว่าที่อยู่ To สามารถจัดประเภทได้อย่างถูกต้องหรือไม่ จะนำไปสู่ข้อสรุปที่แตกต่างไปจากเดิมอย่างสิ้นเชิงในการตัดสินของ CallData สำหรับ Dapp การสื่อสารข้อมูลทั้งในและนอกเครือข่ายนั้นขึ้นอยู่กับการเฝ้าติดตามเหตุการณ์การทำธุรกรรมเป็นอย่างสูง และรหัสเหตุการณ์เดียวกันจะเชื่อถือได้ก็ต่อเมื่อรหัสนั้นถูกส่งไปในสัญญาที่ตรงตามมาตรฐานเท่านั้น

หากการจัดหมวดหมู่ผิด ธุรกรรมจะเข้าสู่หลุมดำโดยไม่ได้ตั้งใจ

หากผู้ใช้โอนโทเค็นไปยังสัญญาบางฉบับ หากสัญญาไม่มีวิธีฟังก์ชันที่กำหนดไว้ล่วงหน้าสำหรับการโอนโทเค็น เงินจะถูกล็อคเหมือนกับการเบิร์นและไม่สามารถควบคุมได้

และตอนนี้โครงการจำนวนมากได้เริ่มเพิ่มการรองรับ wallet ในตัว การจัดการ wallet สำหรับผู้ใช้จึงเป็นสิ่งที่หลีกเลี่ยงไม่ได้ จำเป็นต้องจำแนกสัญญาที่ปรับใช้ล่าสุดจาก chain ตามเวลาจริงตลอดเวลาไม่ว่าจะตอบสนองได้หรือไม่ มาตรฐานสินทรัพย์

อ่านเพิ่มเติมย่อหน้าที่ 1:[การตีความสัญญา] CryptoPunk เป็นตลาดซื้อขาย NFT แบบกระจายศูนย์แห่งแรกของโลก

2. ความเสี่ยงของการจำแนกประเภทคืออะไร?

ห่วงโซ่เป็นสถานที่ที่ไม่มีตัวตนและไม่มีหลักนิติธรรมคุณไม่สามารถหยุดธุรกรรมปกติได้แม้ว่าจะเป็นอันตรายก็ตาม

เขาสามารถเป็นหมาป่าที่แสร้งทำเป็นคุณยาย ทำพฤติกรรมส่วนใหญ่ที่คุณคาดหวังให้คุณยายทำ แต่มีวัตถุประสงค์เพื่อบุกเข้าไปในบ้านและปล้น

ประกาศมาตรฐาน แต่อาจไม่เป็นไปตามสาระสำคัญ

วิธีการจัดประเภทโดยทั่วไปคือการใช้มาตรฐาน EIP-165 โดยตรง และอ่านว่าที่อยู่นั้นรองรับ ERC 20 หรือไม่ เป็นต้น แน่นอนว่านี่เป็นวิธีที่มีประสิทธิภาพ แต่หลังจากนั้น สัญญาจะถูกควบคุมโดยอีกฝ่ายหนึ่ง ดังนั้นแถลงการณ์ สามารถปลอมแปลงได้

แบบสอบถามมาตรฐาน 165 เป็นเพียงวิธีการป้องกันไม่ให้เงินถูกโอนเข้าสู่หลุมดำด้วยต้นทุนที่ต่ำที่สุดในรหัสการดำเนินการที่จำกัดบนห่วงโซ่

นี่คือเหตุผลที่เมื่อเราวิเคราะห์ NFT ก่อนหน้านี้ เรากล่าวถึงเป็นพิเศษว่าจะมีเมธอด SafeTransferFrom ในมาตรฐาน โดยที่ Safe หมายถึงการใช้มาตรฐาน 165 เพื่อระบุว่าอีกฝ่ายหนึ่งมีความสามารถในการถ่ายโอน NFT

อ่านเพิ่มเติมวรรค 2.2:[การตีความซอร์สโค้ด] NFT ที่คุณซื้อคืออะไรกันแน่

เฉพาะโดยเริ่มจาก bytecode ของสัญญา ทำการวิเคราะห์แบบสแตติกในระดับซอร์สโค้ด และเริ่มจากลักษณะการทำงานที่คาดไว้ของสัญญาเท่านั้น จึงจะแม่นยำยิ่งขึ้น

3. การออกแบบโครงร่างการจัดประเภทสัญญา

ต่อไป เราจะวิเคราะห์แผนโดยรวมอย่างเป็นระบบ ให้ความสนใจกับของเราเป้าหมายคือตัวบ่งชี้หลักสองประการคือ "ความแม่นยำ" และ "ประสิทธิภาพ"

คุณต้องรู้ว่าแม้ว่าทิศทางจะถูกต้องแต่หนทางที่จะไปถึงอีกฝั่งของมหาสมุทรนั้นไม่ชัดเจน จุดแรกในการวิเคราะห์ bytecode คือการได้รับรหัส

3.1. จะรับรหัสได้อย่างไร?

จากมุมมองของ chain มี getCode ซึ่งเป็นเมธอด RPC ซึ่งสามารถรับ bytecode จาก address ที่ระบุบน chain อ่านได้เร็วมาก เนื่องจาก codeHash ถูกวางไว้ในโครงสร้างบัญชีของ EVM . ที่ด้านบนสุด

แต่วิธีนี้เทียบเท่ากับการได้รับที่อยู่เพียงแห่งเดียวต้องการปรับปรุงความแม่นยำและประสิทธิภาพให้ดียิ่งขึ้นหรือไม่?

หากเป็นธุรกรรมการปรับใช้ตามสัญญา จะรับรหัสที่ใช้งานหลังจากดำเนินการแล้วหรือแม้ในขณะที่ยังคงอยู่ในพูลหน่วยความจำได้อย่างไร

หากธุรกรรมอยู่ในโหมดโรงงานตามสัญญา มีซอร์สโค้ดใดๆ ใน Calldata ของธุรกรรมหรือไม่

ท้ายที่สุด วิธีของผมคือการจัดประเภทแบบตะแกรง

  1. สำหรับธุรกรรมที่ไม่ได้ใช้งานตามสัญญา ให้ใช้ getCode โดยตรงเพื่อรับที่อยู่ที่เกี่ยวข้องสำหรับการจัดประเภท

  2. สำหรับธุรกรรม mempool ล่าสุด ให้กรองธุรกรรมที่มี to address ว่างเปล่า และ CallData ของใครเป็นซอร์สโค้ดที่มีตัวสร้าง

  3. สำหรับธุรกรรมของโหมดโรงงานตามสัญญา เนื่องจากสัญญาที่ปรับใช้โดยสัญญาอาจถูกรีไซเคิลเพื่อเรียกสัญญาอื่นๆ เพื่อดำเนินการปรับใช้ จากนั้นจึงวิเคราะห์ธุรกรรมย่อยของธุรกรรมแบบวนซ้ำ และบันทึกแต่ละการโทรที่มีประเภทคือ CREATE หรือ CREATE 2 .

เมื่อฉันทำการสาธิตการใช้งาน ฉันพบว่าโชคดีที่เวอร์ชัน rpc ค่อนข้างสูงในขณะนี้ เนื่องจากส่วนที่ยากที่สุดของกระบวนการทั้งหมดคือวิธีค้นหาการเรียกใช้ประเภทที่ระบุซ้ำเมื่อดำเนินการ 3 วิธีการระดับล่างสุดคือ เพื่อกู้คืนบริบทผ่าน opcode ฉันผงะ!

โชคดีที่มีเมธอด debug_traceTransaction ในเวอร์ชัน geth ปัจจุบัน ซึ่งสามารถช่วยจัดเรียงข้อมูลบริบทของการโทรแต่ละครั้งผ่านรหัสการดำเนินการ opcode และจัดเรียงฟิลด์หลัก

ในตอนท้าย สามารถรับรหัสไบต์ดั้งเดิมของโหมดการปรับใช้ต่างๆ (การปรับใช้โดยตรง, การปรับใช้ครั้งเดียวในโหมดโรงงาน, การปรับใช้แบบกลุ่มในโหมดโรงงาน)

3.2. จำแนกจากรหัสอย่างไร?

วิธีที่ง่ายที่สุดแต่ไม่ปลอดภัยคือจับคู่โค้ดกับสตริงโดยตรง ยกตัวอย่าง ERC 20 ฟังก์ชันที่สอดคล้องกับมาตรฐานมี

หลังชื่อฟังก์ชัน มันคือลายเซ็นของฟังก์ชัน ดังที่กล่าวไว้ในการวิเคราะห์ก่อนหน้านี้ ธุรกรรมขึ้นอยู่กับการจับคู่ 4 หลักแรกของ callData เพื่อค้นหาฟังก์ชันเป้าหมาย อ่านเพิ่มเติม:

ดังนั้นต้องเก็บลายเซ็นของทั้ง 6 ฟังก์ชันนี้ไว้ในสัญญาไบต์โค้ด

ชื่อเรื่องรอง

3.3. การปรับปรุงอัตราความแม่นยำ 1- การคอมไพล์

วิธีที่แม่นยำยิ่งขึ้นคือการถอดรหัส Opcode! การคอมไพล์คือกระบวนการแปลง bytecodes ที่ได้รับเป็น opcode และการคอมไพล์ขั้นสูงกว่านั้นคือการแปลงให้เป็น pseudocodes ซึ่งเอื้อต่อการอ่านของมนุษย์ ในเวลานี้ เราไม่ต้องการมัน วิธีการ decompilation แสดงอยู่ในภาคผนวกที่ ท้ายบทความ

solidity (ภาษาระดับสูง) -> bytecode (bytecode) -> opcode (รหัสปฏิบัติการ)

เราสามารถหาคุณลักษณะได้อย่างชัดเจน ลายเซ็นของฟังก์ชันจะถูกดำเนินการโดย opcode PUSH 4 ดังนั้นวิธีการเพิ่มเติมคือการแยกเนื้อหาหลังจาก PUSH 4 ออกจากข้อความแบบเต็มและจับคู่กับมาตรฐานของฟังก์ชัน

ฉันยังได้ทำการทดลองประสิทธิภาพง่ายๆ และฉันต้องบอกว่าภาษา Go นั้นมีประสิทธิภาพมากและใช้เวลาเพียง 220 ms ในการถอดรหัส 1 W ครั้ง

ต่อไปนี้จะลำบาก

3.4. การปรับปรุงอัตราความแม่นยำ 2- ค้นหาบล็อคโค้ด

อัตราความแม่นยำข้างต้นได้รับการปรับปรุง แต่ยังไม่เพียงพอ เนื่องจากเป็นการค้นหาข้อความแบบเต็ม PUSH 4 เนื่องจากเรายังสามารถสร้างตัวแปรซึ่งเป็นประเภทไบต์ 4 ซึ่งจะเรียกใช้คำสั่ง PUSH 4 ด้วย

เวลาทุกข์ใจ นึกถึงการดำเนินโครงการ open source บ้าง ETL เป็นเครื่องมือสำหรับอ่านข้อมูลบน chain เพื่อวิเคราะห์ โดยจะวิเคราะห์การโอน ERC 20 และ 721 ออกเป็นตารางแยกกัน ดังนั้น จึงต้องมีความสามารถ จำแนกสัญญา

หลังจากวิเคราะห์แล้ว จะพบว่าเป็นไปตามการจัดประเภทของโค้ดบล็อก และประมวลผลเฉพาะคำสั่ง push 4 ใน basic_blocks แรกเท่านั้น[ 0 ]

จากนั้นคำถามก็มาถึง วิธีการตัดสินบล็อกรหัสอย่างถูกต้อง

แนวคิดของบล็อคโค้ดมาจาก REVERT + JUMPDEST สองตัวติดต่อกัน และที่นี่จำเป็นต้องมี opcode สองตัวติดต่อกัน เนื่องจากในช่วง opcode ของตัวเลือกฟังก์ชันทั้งหมด หากมีฟังก์ชันมากเกินไป ตรรกะของการพลิกหน้าจะปรากฏขึ้น จากนั้นคำสั่ง JUMPDEST ก็จะปรากฏขึ้นเช่นกัน

3.5. ปรับปรุงความแม่นยำ 3-ค้นหา ตัวเลือกฟังก์ชั่น

ฟังก์ชันของตัวเลือกฟังก์ชันคืออ่าน 4 ไบต์แรกของ Calldata ของธุรกรรม และจับคู่กับลายเซ็นฟังก์ชันสัญญาที่ตั้งไว้ล่วงหน้าในโค้ด และช่วยคำสั่งให้ข้ามไปยังตำแหน่งหน่วยความจำที่ระบุโดยเมธอดฟังก์ชัน

มาลองดำเนินการจำลองขั้นต่ำ

ส่วนนี้เป็นที่เก็บตัวเลือก (uint 256) และดึงข้อมูล () ของทั้งสองฟังก์ชัน และลายเซ็นสามารถคำนวณเป็น 2 e 64 cec 1, 6057361 d

หลังจากถอดรหัสแล้ว คุณจะได้สตริง opcode ต่อไปนี้ ซึ่งสามารถพูดได้ว่าแบ่งออกเป็นสองส่วน

ส่วนที่หนึ่ง:

ในคอมไพเลอร์ เฉพาะส่วนตัวเลือกฟังก์ชันของสัญญาเท่านั้นที่จะได้รับเนื้อหาของ callData ซึ่งหมายถึงการได้รับลายเซ็นการเรียกใช้ฟังก์ชันของ CallData ดังแสดงในรูปด้านล่าง

เราสามารถเห็นผลได้โดยการจำลองการเปลี่ยนแปลงพูลหน่วยความจำของ EVM

ส่วนที่สอง:

กระบวนการตัดสินว่าตรงกับค่าของตัวเลือกหรือไม่

1. ส่งลายเซ็นฟังก์ชัน 4 ไบต์ (0x 2 e 64 cec 1) ของการดึง () ไปยังสแต็ก

2. EQ opcode จะแสดงตัวแปร 2 ตัวจากพื้นที่สแต็ก ได้แก่ 0x 2 e 64 cec 1 และ 0x 6057361 d และตรวจสอบว่าเท่ากันหรือไม่

3. PUSH 2 ถ่ายโอนข้อมูล 2 ไบต์ (0x 003 b ที่นี่ 59 เป็นทศนิยม) ไปยังสแต็ก และมีตัวนับโปรแกรมในพื้นที่สแต็ก ซึ่งระบุตำแหน่งของคำสั่งดำเนินการถัดไปใน bytecode ที่นี่เราตั้งค่า 59 เพราะนั่นคือจุดเริ่มต้นของการดึงข้อมูล () bytecode

4. ตัวแทนบริษัทจัมปี้"ถ้า...ก็ข้ามไปที่..."ซึ่งดึงค่า 2 ค่าจาก stack เป็นอินพุต และถ้าเงื่อนไขเป็นจริง ตัวนับโปรแกรมจะอัพเดตเป็น 59

นี่คือวิธีที่ EVM กำหนดตำแหน่งของฟังก์ชัน bytecode ที่จำเป็นต้องดำเนินการตามการเรียกใช้ฟังก์ชันในสัญญา

ในความเป็นจริงแล้ว เป็นเพียงชุด "คำสั่ง if" ง่ายๆ สำหรับทุกฟังก์ชันในสัญญาและตำแหน่งที่ข้ามไป

4. สรุปแผน

โดยย่อโดยรวมมีดังนี้

  1. ที่อยู่สัญญาแต่ละรายการสามารถรับ bytecode ที่ปรับใช้ผ่าน rpc getcode หรือ debug_traceTransaction โดยใช้ไลบรารี VM และ ASM ใน GO และรับ opcode หลังจากการคอมไพล์

  2. ในหลักการทำงานของ EVM สัญญาจะมีลักษณะดังต่อไปนี้

    • ใช้ opcodes สองตัวที่ต่อเนื่องกัน REVERT+JUMPDEST เป็นความแตกต่างของบล็อกโค้ด

    • สัญญาต้องมีฟังก์ชันของตัวเลือกฟังก์ชัน และฟังก์ชันนี้ต้องอยู่ในโค้ดบล็อคแรกด้วย

    • ในตัวเลือกฟังก์ชัน เมธอดฟังก์ชันทั้งหมดใช้ PUSH 4 เป็น opcode

    • ใน opcode ที่มีอยู่ในตัวเลือกนี้จะมี PUSH 1 00; CALLDATALOAD; PUSH 1 e 0; SHR; DUP 1 ติดต่อกัน ฟังก์ชันหลักคือการโหลดข้อมูล callDate และดำเนินการ displacement และไวยากรณ์อื่น ๆ จะไม่สร้าง

3. ลายเซ็นของฟังก์ชันที่เกี่ยวข้องถูกกำหนดเป็น eip และมีคำแนะนำที่ชัดเจนและบังคับ

4.1. หลักฐานความเป็นเอกลักษณ์

ณ จุดนี้ เราสามารถพูดได้ว่าโดยพื้นฐานแล้วเราบรรลุวิธีการวิเคราะห์สัญญาที่มีประสิทธิภาพสูงและมีความแม่นยำสูง แน่นอน เนื่องจากเราเข้มงวดมาเป็นเวลานาน เราอาจเข้มงวดมากขึ้นด้วย ในรูปแบบข้างต้น เรา ใช้ REVER+JUMPDEST เพื่อสร้างความแตกต่างของบล็อกโค้ด และรวมการโหลดและการแทนที่ของ CallDate ที่หลีกเลี่ยงไม่ได้เพื่อสร้างการตัดสินที่ไม่เหมือนใคร มีอยู่จริงที่ฉันสามารถใช้สัญญาที่มั่นคงเพื่อดำเนินการลำดับ opcode ที่คล้ายกันได้หรือไม่

ฉันทำการทดลองเปรียบเทียบ แม้ว่าจะมีวิธีการรับ CallData เช่น msg.sig จากระดับไวยากรณ์ที่เข้มงวด

5. สรุป

หลังจากการวิเคราะห์อย่างฉะฉาน 3 วันผ่านไป

แม้ว่าจะพิถีพิถันมาก แต่อาจเป็นเรื่องเล็กน้อยสำหรับสัญญาที่ใช้ไบต์ 4 เพื่อสร้างความสับสนว่าเป็นไปตามมาตรฐานในชีวิตประจำวันหรือไม่

ดังนั้น ในความเป็นจริง ROI ของการลงทุนในการวิเคราะห์สำหรับ 3 วันนี้จึงต่ำมาก แต่ท่ามกลางสายน้ำแห่งกาลเวลาที่ไม่มีวันสิ้นสุด สิ่งต่าง ๆ ที่มีความน่าจะเป็นแม้แต่น้อยที่สุดก็จะเกิดขึ้นในที่สุด

ด้วยหลักการของความไม่ไว้วางใจเท่านั้นที่จะทำให้เราไปได้ไกลกว่าในโลกของ web3

วันนี้มีเพื่อนคนหนึ่งถามฉันในหัวข้อที่น่าคิดจุดจบของการเป็น KOL ในอุตสาหกรรมคืออะไร รูปแบบธุรกิจของคุณคืออะไร?

แม้ว่าฉันรู้ว่าการเข้าชมบทความทางเทคนิคนั้นดูเยือกเย็นอยู่เสมอ แต่การเข้าชมนั้นไม่ใช่จุดประสงค์ ฉันหวังว่ามันจะเป็นไปตามวิสัยทัศน์เดิมเสมอ:

ข้อความ

ข้อความ

หากคุณต้องการตัวอย่างโค้ด opcode และโค้ดตัวอย่างที่คอมไพล์แล้ว Go คุณสามารถรับได้โดยตอบกลับไปที่ "การจัดประเภทสัญญา" ในพื้นหลังของบัญชีอย่างเป็นทางการ

ห้องสมุดขึ้นอยู่กับ:

https://pkg.go.dev/github.com/ethereum/go-ethereum@v1.11.6/core/asm#Compiler.Feed

https://pkg.go.dev/github.com/ethereum/go-ethereum@v1.11.6/core/vm

การวิเคราะห์หลักการ:

https://whileydave.com/2023/01/04/disassembling-evm-bytecode-the-basics/

https://yanniss.github.io/elipmoc-oopsla 22.pdf

https://yanniss.github.io/gigahorse-icse 19.pdf

https://www.evm.codes/? fork=shanghai

https://learnblockchain.cn/article/4800 

https://learnblockchain.cn/article/3647 

การอ้างอิงซอร์สโค้ดโครงการโอเพ่นซอร์ส:

https://github.com/blockchain-etl/ethereum-etl/blob/2d a 9 d 050 f 4 ae 4 fa 4 e 818 bbfb 22 d5 cfb 5234 b 2 e 29/ethereumetl/service/eth_contract_service.py#L2 9-L 43 

https://github.com/ethereum/evmdasmhttps://github.com/tintinweb/ethereum-dasm/blob/master/ethereum_dasm/evmdasm.py#L3 42 

    กดไลค์และติดตาม 14 นำคุณค่าจากมุมมองทางเทคนิคมาให้คุณ

    Web3.0
    NFT
    เทคโนโลยี
    สัญญาที่ชาญฉลาด
    ยินดีต้อนรับเข้าร่วมชุมชนทางการของ Odaily
    กลุ่มสมาชิก:
    https://t.me/Odaily_News
    กลุ่มสนทนา:
    https://t.me/Odaily_GoldenApe
    บัญชีทางการ:
    https://twitter.com/OdailyChina
    สารบัญบทความ
    คลังบทความของผู้เขียน
    十四君
    ดาวน์โหลดแอพ Odaily พลาเน็ตเดลี่
    ให้คนบางกลุ่มเข้าใจ Web3.0 ก่อน
    IOS
    Android