EVM เชิงลึก - ความเสี่ยงที่อยู่เบื้องหลังเรื่องเล็กน้อยของการจัดประเภทสัญญา
ในด้านสัญญาอัจฉริยะ"เครื่องเสมือน Ethereum EVM"และอัลกอริทึมและโครงสร้างข้อมูลเป็นหลักการแรก
บทความนี้เริ่มต้นจากสาเหตุที่ควรจัดประเภทสัญญา และรวมประเภทของการโจมตีที่เป็นอันตรายในแต่ละสถานการณ์ที่อาจเผชิญ และสุดท้ายให้ชุดของอัลกอริทึมการวิเคราะห์การจัดประเภทสัญญาที่ค่อนข้างปลอดภัย
แม้ว่าเนื้อหาทางเทคนิคจะสูง แต่ก็สามารถใช้เป็นสื่อการอ่านสำหรับการพูดคุยเบ็ดเตล็ดชื่อระดับแรก
1. ทำไมจึงต้องจัดประเภทสัญญา?
เนื่องจากมีความสำคัญมาก จึงอาจกล่าวได้ว่าเป็นรากฐานที่สำคัญของ Dapps เช่น การแลกเปลี่ยน, กระเป๋าสตางค์, เบราว์เซอร์บล็อกเชน, แพลตฟอร์มการวิเคราะห์ข้อมูล ฯลฯ!
เหตุผลที่ธุรกรรมเป็นการโอน ERC 20 เนื่องจากพฤติกรรมของเขาเป็นไปตามมาตรฐาน ERC 20 อย่างน้อย:
สถานะของธุรกรรมคือสำเร็จ
ที่อยู่ To คือสัญญาที่เป็นไปตามมาตรฐาน ERC 20
เรียกว่าฟังก์ชัน Transfer ซึ่งมีลักษณะเฉพาะคือ 4 หลักแรกของธุรกรรม CallData คือ 0x a 9059 cbb
หลังจากดำเนินการแล้ว เหตุการณ์การโอนจะถูกส่งไปยังที่อยู่ถึง
หากการจัดประเภทผิด พฤติกรรมการทำธุรกรรมจะถูกตัดสินผิด
ด้วยพฤติกรรมการทำธุรกรรมเป็นรากฐานที่สำคัญ ไม่ว่าที่อยู่ 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 ของธุรกรรมหรือไม่
ท้ายที่สุด วิธีของผมคือการจัดประเภทแบบตะแกรง
สำหรับธุรกรรมที่ไม่ได้ใช้งานตามสัญญา ให้ใช้ getCode โดยตรงเพื่อรับที่อยู่ที่เกี่ยวข้องสำหรับการจัดประเภท
สำหรับธุรกรรม mempool ล่าสุด ให้กรองธุรกรรมที่มี to address ว่างเปล่า และ CallData ของใครเป็นซอร์สโค้ดที่มีตัวสร้าง
สำหรับธุรกรรมของโหมดโรงงานตามสัญญา เนื่องจากสัญญาที่ปรับใช้โดยสัญญาอาจถูกรีไซเคิลเพื่อเรียกสัญญาอื่นๆ เพื่อดำเนินการปรับใช้ จากนั้นจึงวิเคราะห์ธุรกรรมย่อยของธุรกรรมแบบวนซ้ำ และบันทึกแต่ละการโทรที่มีประเภทคือ 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. สรุปแผน
โดยย่อโดยรวมมีดังนี้
ที่อยู่สัญญาแต่ละรายการสามารถรับ bytecode ที่ปรับใช้ผ่าน rpc getcode หรือ debug_traceTransaction โดยใช้ไลบรารี VM และ ASM ใน GO และรับ opcode หลังจากการคอมไพล์
ในหลักการทำงานของ 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 นำคุณค่าจากมุมมองทางเทคนิคมาให้คุณ


