שיטות עבודה מומלצות לאיתור אבטחה

בלוג 1חדשות מפתחיםיזם הסבר על בלוקצ’יין אירועים וכנסים לחץעלונים

Contents

הירשם לניוזלטר שלנו.

כתובת דוא”ל

אנו מכבדים את פרטיותך

HomeBlog פיתוח בלוקצ’יין

שיטות עבודה מומלצות לאיתור אבטחה

מהניטור ועד לשיקולי חותמת הזמן, הנה כמה טיפים מקצוענים להבטיח שהחוזים החכמים שלך של Ethereum מבוצרים. על ידי ConsenSys 21 באוגוסט 2020 פורסם ב 21 באוגוסט 2020

גיבור שיטות עבודה מומלצות

על ידי ConsenSys Diligence, צוות המומחים שלנו לאבטחת בלוקצ’יין.

אם התייחסת לליבך את הלך הרוח לאבטחת החוזה החכם ומתייחסים להתמודדות עם המייחודיות של ה- EVM, הגיע הזמן לשקול כמה דפוסי אבטחה הספציפיים לשפת התכנות Solidity. במעגל זה נתמקד בהמלצות פיתוח מאובטחות ל- Solidity שעשויות להיות מאלפות לפיתוח חוזים חכמים בשפות אחרות. 

אוקיי, בוא נקפוץ פנימה.

השתמש ב- assert (), דורש (), חזור כראוי ()

פונקציות הנוחות לִטעוֹן ו לִדרוֹשׁ ניתן להשתמש בהם כדי לבדוק תנאים ולזרוק חריג אם התנאי לא מתקיים.

ה לִטעוֹן יש להשתמש בפונקציה רק ​​לבדיקת שגיאות פנימיות ולבדוק משתנים.

ה לִדרוֹשׁ יש להשתמש בפונקציה כדי להבטיח תנאים תקפים, כגון תשומות, או מתקיימים משתני מצב חוזה, או כדי לאמת ערכי החזרה משיחות לחוזים חיצוניים. 

בעקבות פרדיגמה זו מאפשרים לכלי ניתוח פורמליים לוודא כי לעולם לא ניתן להגיע לאופקוד הלא חוקי: כלומר, לא הופרים כל משתנים בקוד וכי הקוד מאומת רשמית.

מוצק פרגמה ^ 0.5.0; Sharer חוזה {פונקציה sendHalf (כתובת בתשלום)) תשואות ציבוריות לתשלום (יתרה uint) {דורש (msgstr =% 2 == 0, "ערך נדרש."); // Require () יכול להיות בעל מחרוזת הודעה אופציונלית uint balanceBeforeTransfer = address (this) .balance; (הצלחה bool,) = addr.call.value (msg.value / 2) (""); דורשים (הצלחה); // מכיוון שחזרנו אם ההעברה נכשלה, לא צריכה להיות // שום דרך שיהיה לנו עדיין מחצית מהכסף. לטעון (כתובת (זה). איזון == balanceBeforeTransfer – msg.value / 2); // משמש לבדיקת שגיאה פנימית לכתובת החזרה (זו). איזון; }} שפת קוד: JavaScript (javascript)

לִרְאוֹת SWC-110 & SWC-123

השתמש בשינויים רק לבדיקות

הקוד בתוך שינוי בדרך כלל מבוצע לפני גוף הפונקציה, ולכן כל שינוי במצב או שיחות חיצוניות יפרו את בדיקות-השפעות-אינטראקציות תבנית. יתרה מכך, הצהרות אלה עשויות להישאר בלתי מורשות על ידי המפתח, מכיוון שהקוד לשינוי עשוי להיות רחוק מהצהרת הפונקציה. לדוגמא, שיחה חיצונית בשינוי שינוי יכולה להוביל להתקפת כניסה חוזרת:

רישום החוזים {בעל כתובת; function isVoter (address _addr) החזרות חיצוניות (bool) {// Code}} בחירת חוזה {הרישום ברישום; modifier isEligible (כתובת _addr) {דורש (registry.isVoter (_addr)); _; } הצבעת פונקציה () isEligible (msg.sender) ציבורית {// קוד}} שפת קוד: JavaScript (javascript)

במקרה זה, חוזה הרישום יכול לבצע התקפת חוזר על ידי קריאה ל- Election.vote () בתוך isVoter ().

פתק: להשתמש משנים כדי להחליף בדיקות מצב כפולות במספר פונקציות, כגון isOwner (), אחרת שימוש נדרש או חזור בתוך הפונקציה. זה הופך את קוד החוזה החכם שלך לקריא יותר וקל יותר לביקורת.

היזהר מעיגול עם חלוקה שלמה

כל חלוקת המספרים השלמים מתעגלת למספר השלם הקרוב ביותר. אם אתה זקוק לדיוק רב יותר, שקול להשתמש במכפיל, או אחסן את המונה וגם את המכנה.

(בעתיד, למוצקות יהיה נקודה קבועה סוג, אשר יקל על כך.)

// רע uint x = 5/2; // התוצאה היא 2, כל חלוקה של מספרים שלמים מסתובבת למטה לשפה השלמה הקרובה ביותר קוד: JavaScript (javascript)

שימוש במכפיל מונע עיגול כלפי מטה, צריך להתחשב במכפיל זה בעת עבודה עם x בעתיד:

// מכפיל uint טוב = 10; uint x = (מכפיל 5 *) / 2; שפת קוד: JavaScript (javascript)

אחסון המונה והמכנה פירושו שתוכל לחשב את התוצאה של מונה / מכנה מחוץ לשרשרת:

// מונה טוב יותר = 5; מכנה uint = 2; שפת קוד: JavaScript (javascript)

היו מודעים לפשרות בין חוזים מופשטים ו ממשקים

שני הממשקים והחוזים המופשטים מספקים גישה גישה להתאמה אישית ושימוש חוזר עבור חוזים חכמים. ממשקים שהוצגו ב- Solidity 0.4.11 דומים לחוזים מופשטים אך לא ניתן ליישם פונקציות כלשהן. לממשקים יש גם מגבלות כמו אי אפשרות לגשת לאחסון או לרשת ממשקים אחרים, מה שבדרך כלל הופך את החוזים המופשטים למעשיים יותר. אמנם ממשקים בהחלט מועילים לעיצוב חוזים לפני היישום. בנוסף, חשוב לזכור כי אם חוזה יורש מחוזה מופשט, עליו ליישם את כל הפונקציות שאינן מיושמות באמצעות עקיפה או שהוא יהיה מופשט גם כן..

פונקציות Fallback

שמור על פונקציות נפילות פשוטות

פונקציות Fallback נקראים כאשר חוזה נשלח הודעה ללא ויכוחים (או כאשר אין פונקציה שתואמת), ויש להם גישה ל -2,300 גז רק כאשר מתקשרים מ- .send () או .transfer (). אם ברצונך להיות מסוגל לקבל Ether מ- .send () או .transfer (), המקסימום שתוכל לעשות בפונקציית כיבוי הוא רישום אירוע. השתמש בפונקציה מתאימה אם נדרש חישוב של יותר גז.

// פונקציה גרועה () בתשלום {יתרות [msg.sender] + = msg.value; } // פיקדון פונקציה טוב () שיש לשלם {יתרות חיצוניות [msg.sender] + = msg.value; } פונקציה () בתשלום {דורש (msg.data.length == 0); פולטים את LogDepositReceived (msg.sender); } שפת קוד: JavaScript (javascript)

בדוק את אורך הנתונים בפונקציות החזרה

מאז פונקציות נפילה לא נקרא רק להעברת אתרים רגילים (ללא נתונים) אלא גם כאשר אין פונקציה אחרת שתואמת, עליכם לבדוק שהנתונים ריקים אם פונקציית ה- fallback מיועדת לשמש רק לצורך רישום אתר המתקבל. אחרת, המתקשרים לא ישימו לב אם נעשה שימוש שגוי בחוזה שלך ונקראו פונקציות שאינן קיימות.

// פונקציה גרועה () בתשלום {emit LogDepositReceived (msg.sender); } // פונקציה טובה () בתשלום {דורש (msg.data.length == 0); פולטים את LogDepositReceived (msg.sender); } שפת קוד: JavaScript (javascript)

סמן במפורש פונקציות בתשלום ומשתני מצב

החל מ- Solidity 0.4.0, כל פונקציה שמקבלת אתר חייבת להשתמש בשינוי בתשלום, אחרת אם לעסקה יש ערך msg.value > 0 יחזור (אלא כשמאולצים).

פתק: משהו שאולי לא יהיה ברור: השינוי בתשלום חל רק על שיחות מחוזים חיצוניים. אם אני קורא לפונקציה שאינה בתשלום בפונקציה לתשלום באותו חוזה, הפונקציה שאיננה בתשלום לא תיכשל, למרות ש- msg.value עדיין מוגדר.

סמן את הנראות במפורש בפונקציות ובמשתני מצב

תייג במפורש את הנראות של פונקציות ומשתני מצב. ניתן להגדיר פונקציות כחיצוניות, ציבוריות, פנימיות או פרטיות. אנא הבין את ההבדלים ביניהם, למשל, חיצוני עשוי להספיק במקום ציבורי. עבור משתני מצב, חיצוני אינו אפשרי. תיוג הנראות במפורש יקל על תפיסת הנחות שגויות לגבי מי יכול להתקשר לפונקציה או לגשת למשתנה.

  • פונקציות חיצוניות הן חלק מממשק החוזה. לא ניתן לקרוא לפונקציה חיצונית f באופן פנימי (כלומר f () לא עובד, אבל this.f () עובד). פונקציות חיצוניות לעיתים יעילות יותר כאשר הם מקבלים מערכי נתונים גדולים.
  • פונקציות ציבוריות הן חלק מממשק החוזה וניתן להתקשר אליהם באופן פנימי או באמצעות הודעות. עבור משתני מצב ציבורי, נוצרת פונקציית גטר אוטומטית (ראה להלן).
  • ניתן לגשת לפונקציות פנימיות ולמשתני מצב פנימיים בלבד, מבלי להשתמש בזה.
  • פונקציות פרטיות ומשתני מצב נראים רק עבור החוזה שהם מוגדרים בו ולא בחוזים נגזרים. פתק: כל מה שנמצא בתוך חוזה גלוי לכל המשקיפים החיצוניים לבלוקצ’יין, אפילו משתנים פרטיים.

// רע uint x; // ברירת המחדל היא פנימית עבור משתני מצב, אך יש להפוך אותה לפונקציה מפורשת buy () {// ברירת המחדל היא ציבורית // קוד ציבורי} // טוב uint פרטי y; function buy () חיצוני {// ניתן להתקשרות חיצונית בלבד או שימוש ב- this.buy ()} כלי הפונקציה () ציבורי {// להתקשרות חיצונית, כמו גם פנימית: שינוי קוד זה דורש חשיבה על שני המקרים. } function internalAction () פנימי {// קוד פנימי} שפת קוד: PHP (php)

לִרְאוֹת SWC-100 ו SWC-108

נעל פרגמות לגרסת מהדר ספציפית

יש לפרוס חוזים עם אותה גרסת מהדר ודגלים איתם הם נבדקו הכי הרבה. נעילת הפרגמה עוזרת להבטיח כי חוזים לא יתפרסו בטעות באמצעות למשל המהדר האחרון שעשוי להיות בסיכון גבוה יותר לבאגים שלא התגלו. אחרים עשויים לפרוס חוזים והפרגמה מציינת את גרסת המהדר המיועדת על ידי המחברים המקוריים.

// מוצקות פרגמה גרועה ^ 0.4.4; // מוצק פרגמה טוב 0.4.4; שפת קוד: JavaScript (javascript)

הערה: גרסת פרגמה צפה (כלומר ^ 0.4.25) תתקבץ בסדר עם 0.4.26 מדי לילה. 2018.9.25, אולם לעולם אין להשתמש בבניית לילה לצורך קומפילציה של קוד לייצור.

אַזהָרָה: ניתן לאפשר הצהרות פרגמה לצוף כאשר חוזה מיועד לצריכה על ידי מפתחים אחרים, כמו במקרה של חוזים בספריה או בחבילת EthPM. אחרת, המפתח יצטרך לעדכן את הפרגמה באופן ידני על מנת לבצע קומפילציה מקומית.

לִרְאוֹת SWC-103

השתמש באירועים כדי לעקוב אחר פעילות החוזה

יכול להיות שימושי שיש דרך לפקח על פעילות החוזה לאחר פריסתו. אחת הדרכים להשיג זאת היא להסתכל על כל עסקאות החוזה, אולם זה עשוי להיות לא מספיק, מכיוון ששיחות הודעות בין חוזים אינן נרשמות בבלוקצ’יין. יתר על כן, הוא מציג רק את פרמטרי הקלט, ולא את השינויים שבוצעו בפועל במדינה. כמו כן, ניתן להשתמש באירועים להפעלת פונקציות בממשק המשתמש.

צדקה חוזה {מיפוי (כתובת => יתרות) פונקציה לתרום () יתרה ציבורית שישולמה [msg.sender] + = msg.value; }} משחק חוזה {פונקציה buyCoins () לתשלום ציבורי {// 5% עוברים לצדקה צדקה.donate.value (msg.value / 20) (); }} שפת קוד: JavaScript (javascript)

כאן, חוזה המשחק יבצע שיחה פנימית ל- Charity.donate (). עסקה זו לא תופיע ברשימת העסקאות החיצונית של צדקה, אלא גלויה רק ​​בעסקאות הפנימיות.

אירוע הוא דרך נוחה לרשום משהו שקרה בחוזה. אירועים שנפלטו נשארים בבלוקצ’יין יחד עם נתוני החוזה האחרים והם זמינים לביקורת עתידית. הנה שיפור בדוגמה שלמעלה, תוך שימוש באירועים כדי לספק היסטוריה של תרומות הצדקה.

צדקה חוזה {// להגדיר אירוע אירוע LogDonate (uint _amount); מיפוי (כתובת => יתרות) פונקציה לתרום () יתרה ציבורית שישולמה [msg.sender] + = msg.value; // פולט אירוע פולט את LogDonate (msg.value); }} משחק חוזה {פונקציה buyCoins () לתשלום ציבורי {// 5% עוברים לצדקה צדקה.donate.value (msg.value / 20) (); }} שפת קוד: JavaScript (javascript)

כאן, כל העסקאות שעוברות על חוזה הצדקה, באופן ישיר או לא, יופיעו ברשימת האירועים של אותו חוזה יחד עם סכום הכסף שנתרם.

הערה: העדיף מבני סולידיטי חדשים יותר. העדיפו מבנים / כינויים כגון הרס עצמי (על התאבדות) ו- keccak256 (על פני sha3). ניתן לפשט דפוסים כמו דורשים (msg.sender.send (אתר 1)) לשימוש בהעברה (), כמו ב- msg.sender.transfer (אתר 1). לבדוק יומן שינוי מוצקות לשינויים דומים יותר.

שים לב שניתן להצליל את ‘מובנים’

כרגע אפשר צֵל גלובליות מובנות בסולידיות. זה מאפשר לחוזים לבטל את הפונקציונליות של מובנים כגון msg ולהחזיר (). למרות זאת במתכוון, זה יכול להטעות משתמשים בחוזה באשר להתנהגות האמיתית של החוזה.

חוזה PretendingToRevert {function revert () קבוע פנימי {}} contractContract חוזה הוא pretendingToRevert {function somethingBad () ציבורי {revert (); }}

על משתמשי החוזה (ורואי החשבון) להיות מודעים לקוד המקור החכם החוזי המלא של כל יישום שהם מתכוונים להשתמש בו.

הימנע משימוש ב- tx.origin

לעולם אל תשתמש ב- tx.origin לצורך הרשאה, בחוזה אחר יכולה להיות שיטה שתקרא לחוזה שלך (כאשר למשל למשתמש יש כמה כספים) והחוזה שלך יאשר את העסקה הזו מכיוון שכתובתך היא tx.origin.

חוזה MyContract {בעל כתובת; פונקציה MyContract () ציבורי {owner = msg.sender; } פונקציה sendTo (מקלט כתובת, סכום קטן) ציבורי {דורש (tx.origin == בעל); (bool הצלחה,) = receiver.call.value (סכום) (""); דורשים (הצלחה); }} חוזה AttackingContract {MyContract myContract; תוקף כתובת; פונקציה AttackingContract (כתובת myContractAddress) ציבורי {myContract = MyContract (myContractAddress); תוקף = msg.sender; } function () ציבורי {myContract.sendTo (תוקף, msg.sender.balance); }} שפת קוד: JavaScript (javascript)

עליך להשתמש ב- msg.sender לצורך הרשאה (אם חוזה אחר קורא לחוזה שלך msg.sender תהיה כתובת החוזה ולא כתובת המשתמש שקרא לחוזה).

תוכלו לקרוא על כך עוד כאן: מסמכי מוצקות

אַזהָרָה: מלבד הבעיה עם ההרשאה, יש סיכוי כי tx.origin יוסר מפרוטוקול Ethereum בעתיד, כך שקוד המשתמש ב- tx.origin לא יהיה תואם למהדורות עתידיות ויטאליק: ‘אל תניח ש- tx.origin ימשיך להיות שמיש או משמעותי.’

ראוי גם להזכיר כי על ידי שימוש ב- tx.origin אתה מגביל את יכולת הפעולה ההדדית בין חוזים מכיוון שהחוזה המשתמש ב- tx.origin אינו יכול לשמש בחוזה אחר שכן חוזה אינו יכול להיות ה- tx.origin.

לִרְאוֹת SWC-115

תלות בחותמת זמן

ישנם שלושה שיקולים עיקריים בעת שימוש בחותמת זמן לביצוע פונקציה קריטית בחוזה, במיוחד כאשר פעולות כרוכות בהעברת כספים..

מניפולציה של חותמת זמן

שימו לב כי כורה יכול לתמרן את חותמת הזמן של החסימה. שקול זאת חוֹזֶה:

uint256 מלח פרטי קבוע = block.timestamp; פונקציה אקראית (uint מקסימום) תשואות פרטיות קבועות (תוצאה uint256) {// קבלו את הזרע הטוב ביותר לאקראיות uint256 x = מלח * 100 / מקס; uint256 y = מלח * block.number / (מלח% 5); זרע uint256 = block.number / 3 + (מלח% 300) + Last_Payout + y; uint256 h = uint256 (block.blockhash (זרע)); החזר uint256 ((h / x))% מקס + 1; // מספר אקראי בין 1 למקסימום} שפת קוד: PHP (php)

כאשר החוזה משתמש בחותמת הזמן כדי לזרוע מספר אקראי, הכורה יכול לפרסם חותמת זמן תוך 15 שניות לאחר אימות החסימה, ובכך לאפשר לכורה לחשב מראש אפשרות טובה יותר לסיכויים בהגרלה. חותמות זמן אינן אקראיות ואין להשתמש בהן בהקשר זה.

הכלל בן 15 השניות

ה נייר צהוב (מפרט הייחוס של Ethereum) אינו מציין אילוץ כמה בלוקים יכולים להיסחף בזמן, אבל זה כן מציין שכל חותמת זמן צריכה להיות גדולה יותר מחותמת ההורה שלה. יישומי פרוטוקול Ethereum פופולריים גת ו שִׁוּוּי שניהם דוחים חסימות עם חותמת זמן יותר מ -15 שניות בעתיד. לכן, כלל אצבע טוב בהערכת השימוש בחותמת זמן הוא: אם קנה המידה של האירוע תלוי הזמן שלך יכול להשתנות ב -15 שניות ולשמור על שלמות, זה בטוח להשתמש בבלוק..

הימנע משימוש ב- block.number כחותמת זמן

ניתן לאמוד דלתא זמן באמצעות המאפיין block.number ו- זמן חסימה ממוצע, אולם זו אינה הוכחה עתידית מכיוון שזמני החסימה עשויים להשתנות (כגון ארגון מחדש של מזלג וה פצצת קושי). במכירה המשתרעת על פני ימים, כלל 15 השניות מאפשר להשיג הערכת זמן אמינה יותר.

לִרְאוֹת SWC-116

זהירות ירושה מרובה

כאשר משתמשים בתורשה מרובה ב- Solidity, חשוב להבין כיצד המהדר מחבר את גרף הירושה.

חוזה גמר {uint ציבור a; פונקציה סופית (uint f) ציבורית {a = f; }} חוזה ב ‘הוא שכר טרחה ציבורי סופי; פונקציה B (uint f) Final (f) public {} function setFee () public {fee = 3; }} חוזה ג ‘הוא תשלום ציבורי סופי; פונקציה C (uint f) Final (f) public {} function setFee () public {fee = 5; }} חוזה A הוא B, C {פונקציה A () ציבורית B (3) C (5) {setFee (); }} שפת קוד: PHP (php)

כאשר פרוס חוזה, המהדר ישלים את הירושה מימין לשמאל (אחרי שמילת המפתח היא שההורים רשומים מהבסיסי ביותר לנגזר ביותר). הנה לינאריזציה של חוזה א ‘:

סופי <- ב <- ג <- א

התוצאה של הלינאריזציה תניב שכר טרחה של 5, מכיוון ש- C הוא החוזה הנגזר ביותר. זה אולי נראה ברור, אך דמיין תרחישים שבהם C מסוגל להצל על פונקציות מכריעות, לסדר מחדש סעיפים בוליאניים ולגרום למפתח לכתוב חוזים ניתנים לניצול. ניתוח סטטי כרגע אינו מעלה בעיה עם פונקציות מוצלות, ולכן יש לבדוק אותו ידנית.

כדי לעזור לתרום, ל- Github של Solidity יש פּרוֹיֶקט עם כל הנושאים הקשורים בירושה.

לִרְאוֹת SWC-125

השתמש בסוג ממשק במקום בכתובת לבטיחות סוג

כשפונקציה לוקחת כתובת חוזה כוויכוח, עדיף להעביר ממשק או סוג חוזה ולא כתובת גולמית. אם הפונקציה נקראת במקום אחר בתוך קוד המקור, המהדר היא תספק הבטחות בטיחות נוספות.

כאן אנו רואים שתי חלופות:

Validator חוזה {function validate (uint) החזרות חיצוניות (bool); } חוזה TypeSafeAuction {// פונקציה טובה validateBet (Validator _validator, uint _value) מחזירה פנימית (bool) {bool valid = _validator.validate (_value); החזרה תקפה; }} חוזה TypeUnsafeAuction {// פונקציה רעה validateBet (כתובת _addr, uint _value) מחזירה פנימית (bool) {Validator Validator = Validator (_addr); bool valid = validator.validate (_value); החזרה תקפה; }} שפת קוד: JavaScript (javascript)

היתרונות של השימוש בחוזה TypeSafeAuction לעיל ניתן לראות מהדוגמה הבאה. אם נקרא validateBet () עם ארגומנט כתובת, או סוג חוזה שאינו Validator, המהדר ישליך את השגיאה הזו:

מכירה פומבית של חוזה NonValidator {} היא TypeSafeAuction {NonValidator nonValidator; הימור פונקציה (uint _value) {bool valid = validateBet (nonValidator, _value); // TypeError: סוג לא חוקי עבור ארגומנט בשיחת פונקציה. // המרה משתמעת לא חוקית מחוזה NonValidator // לבקשת Validator. }} שפת קוד: JavaScript (javascript)

הימנע משימוש בקוד גודל חיצוני כדי לבדוק אם קיימים חשבונות בבעלות חיצונית

המשנה הבא (או בדיקה דומה) משמש לעתים קרובות כדי לוודא אם התקשרה מחשבון בבעלות חיצונית (EOA) או מחוזה חוזה:

// modifier bad isNotContract (address _a) {uint size; הרכבה {size: = extcodesize (_a)} דורשת (size == 0); _; } שפת קוד: JavaScript (javascript)

הרעיון הוא פשוט: אם כתובת מכילה קוד, זה לא EOA אלא חשבון חוזה. למרות זאת, בחוזה אין קוד מקור זמין במהלך הבנייה. משמעות הדבר היא שבזמן שהבנאי פועל, הוא יכול להתקשר לחוזים אחרים, אך גודל הקידוד עבור הכתובת שלו מחזיר אפס. להלן דוגמא מינימלית המראה כיצד ניתן לעקוף צ’ק זה:

חוזה OnlyForEOA {הדגל הציבורי; // modifier bad isNotContract (address _a) {uint len; הרכבה {len: = extcodesize (_a)} דורשת (len == 0); _; } function setFlag (uint i) public isNotContract (msg.sender) {flag = i; }} חוזה FakeEOA {קונסטרוקטור (כתובת _a) ציבורי {OnlyForEOA c = OnlyForEOA (_a); c.setFlag (1); }} שפת קוד: JavaScript (javascript)

מכיוון שניתן לחשב מראש את כתובות החוזה, בדיקה זו עלולה להיכשל גם אם היא תבדוק כתובת ריקה בבלוק n, אך יש לה חוזה שפרוס לה בלוק כלשהו גדול מ- n.

אַזהָרָה: נושא זה הוא ניואנסים. אם המטרה שלך היא למנוע מחוזים אחרים להתקשר לחוזה שלך, סביר להניח שבדיקת גודל הקוד מספיק. גישה חלופית היא לבדוק את הערך של (tx.origin == msg.sender), אם כי גם זה יש חסרונות.

ייתכנו מצבים אחרים שבהם בדיקת גודל הקידוד משרתת את מטרתך. לתאר את כולם כאן הוא מחוץ לתחום. הבן את ההתנהגויות הבסיסיות של ה- EVM והשתמש בשיקול הדעת שלך.

האם קוד הבלוקצ’יין שלך מאובטח?

הזמינו בדיקה נקודתית של יום אחד עם מומחי האבטחה שלנו. הזמן את היום שלך בחריצות אבטחה חוזים חכמים סולידיות עלון הירשם לניוזלטר שלנו לקבלת החדשות האחרונות של Ethereum, פתרונות ארגוניים, משאבי מפתח ועוד. כתובת דוא”ל תוכן בלעדיכיצד לבנות מוצר מצליח של בלוקצ'ייןוובינר

כיצד לבנות מוצר מצליח של בלוקצ’יין

כיצד להגדיר ולהפעיל צומת אתריוםוובינר

כיצד להגדיר ולהפעיל צומת אתריום

כיצד לבנות ממשק API משלך של Ethereumוובינר

כיצד לבנות ממשק API משלך של Ethereum

כיצד ליצור אסימון חברתיוובינר

כיצד ליצור אסימון חברתי

שימוש בכלי אבטחה בפיתוח חוזים חכםוובינר

שימוש בכלי אבטחה בפיתוח חוזים חכם

העתיד של נכסים דיגיטליים של פיננסים ו- DeFiוובינר

עתיד האוצר: נכסים דיגיטליים ו- DeFi

Mike Owergreen Administrator
Sorry! The Author has not filled his profile.
follow me
Like this post? Please share to your friends:
map