Κρυμμένες παγίδες στο Honeypot

Τα έξυπνα συμβόλαια Honeypot είναι ένας τύπος δόλιων έξυπνων συμβολαίων που φαίνονται ελκυστικά στους χρήστες και υπόσχονται οικονομικά οφέλη. Ωστόσο, οι συμβάσεις αυτές περιέχουν κρυφές παγίδες ή κακόβουλο κώδικα, με αποτέλεσμα οι χρήστες να χάνουν τα κεφάλαιά τους αντίθετα.

Για να προστατευτείτε από τις έξυπνες συμβάσεις Honeypot πρέπει να ερευνήσετε και να επαληθεύσετε διεξοδικά τον κώδικα της σύμβασης πριν ασχοληθείτε με αυτήν. Ο κόσμος των έξυπνων συμβολαίων και του blockchain εξελίσσεται συνεχώς, με νέα τρωτά σημεία και μεθόδους εξαπάτησης να εμφανίζονται τακτικά, οπότε είναι κρίσιμο για τους προγραμματιστές, τους ελεγκτές και τους χρήστες να ενημερώνονται για τις τελευταίες τάσεις και εξελίξεις στον τομέα αυτό.

Υπάρχουν πολλά παραδείγματα έξυπνων συμβολαίων Honeypot. Σε αυτό το άρθρο θα εξετάσουμε μερικά από τα παραδείγματα.

1. Λειτουργία Fallback honeypot

Σε αυτό το είδος honeypot, το συμβόλαιο διαθέτει μια ευάλωτη λειτουργία "rollback" που φαινομενικά επιτρέπει σε οποιονδήποτε να κατέχει το συμβόλαιο και να αφαιρεί το υπόλοιπό του. Ωστόσο, μια τέτοια λειτουργία περιέχει μια κρυφή συνθήκη που εμποδίζει την επιτυχή εκτέλεση.

Κώδικας παραδείγματος:

pragma solidity 0.4.18

contract FallbackHoneypot {
  address public owner;

  function() public payable {
      if (owner == 0) {
          owner = msg.sender;
      } else {
          revert();
      }
  }

  function withdraw() public {
      require(msg.sender == owner);
      msg.sender.transfer(this.balance);
  }
}

Σε αυτό το παράδειγμα, η συνάρτηση πτώσης επιτρέπει σε οποιονδήποτε χρήστη να γίνει ιδιοκτήτης. Ωστόσο, ο τελεστής revert() διασφαλίζει ότι η αλλαγή ιδιοκτησίας δεν θα συμβεί ποτέ, αφήνοντας τα κεφάλαια του επιτιθέμενου παγιδευμένα στο συμβόλαιο.

2. Honeypot με κρυφές συνθήκες

Αυτά τα συμβόλαια περιέχουν μια κρυφή συνθήκη ή απαίτηση που πρέπει να ικανοποιηθεί για να πετύχει η φαινομενικά ευάλωτη λειτουργία. Οι χρήστες μπορεί να νομίζουν ότι μπορούν να χρησιμοποιήσουν το συμβόλαιο, αλλά η κρυφή συνθήκη διασφαλίζει ότι δεν μπορούν.

Κώδικας παραδείγματος:

pragma solidity 0.4.18

contract HiddenConditionHoneypot {
  uint256 public counter = 0;

  function deposit() public payable {
      require(msg.value == 1 ether);
      counter++;
  }

  function withdraw() public {
      require(counter > 100);
      msg.sender.transfer(this.balance);
  }
}

Σε αυτό το συμβόλαιο, ο χρήστης μπορεί να καταθέσει 1 αιθέρα και φαίνεται ότι μετά από 100 καταθέσεις, ο χρήστης μπορεί να αποσύρει ολόκληρο το υπόλοιπο του συμβολαίου. Ωστόσο, η συνθήκη counter > 100 διασφαλίζει ότι η ανάληψη είναι δυνατή μόνο μετά από 101 καταθέσεις, γεγονός που καθυστερεί τα κεφάλαια στο συμβόλαιο.

3. Reentrancy honeypot

Σε αυτόν τον τύπο honeypot, το συμβόλαιο είναι ευάλωτο σε μια επίθεση reentrancy, όπου ένας επιτιθέμενος μπορεί να επικαλεστεί επανειλημμένα μια συνάρτηση του συμβολαίου κατά τη διάρκεια της ανάληψης. Ωστόσο, το συμβόλαιο περιέχει έναν κρυφό μηχανισμό που αποτρέπει την επιτυχή εκμετάλλευση.

Κώδικας παραδείγματος:

pragma solidity 0.4.18

contract ReentrancyHoneypot {
  mapping(address => uint256) public balances;

  function deposit() public payable {
      balances[msg.sender] += msg.value;
  }

  function withdraw(uint256 _amount) public {
      require(balances[msg.sender] >= _amount);
      if (msg.sender.call.value(_amount)()) {
          balances[msg.sender] -= _amount;
      }
  }
}

Σε αυτό το παράδειγμα, το συμβόλαιο είναι ευάλωτο στην επίθεση επανεισαγωγής λόγω της χρήσης του msg.sender.call.value(_amount)(). Ωστόσο, το συμβόλαιο δεν επιτρέπει στους χρήστες να καταθέσουν περισσότερα χρήματα από το αρχικό υπόλοιπο, καθυστερώντας ουσιαστικά τα χρήματά τους.

4. Honeypot με όριο αερίου

Σε αυτόν τον τύπο honeypot, το συμβόλαιο φαίνεται να επιτρέπει στον χρήστη να κάνει ανάληψη χρημάτων, αλλά η ποσότητα αερίου που απαιτείται για την εκτέλεση της λειτουργίας ανάληψης υπερβαίνει το όριο μπλοκαρίσματος αερίου, καθιστώντας τη συναλλαγή αδύνατη.

Κώδικας παραδείγματος:

pragma solidity 0.4.18

contract GasLimitHoneypot {
  uint256 constant public numArrayElements = 1000;
  uint256[numArrayElements] public someArray;

  function deposit() public payable {
      for (uint256 i = 0; i < numArrayElements; i++) {
          someArray[i] = 0;
      }
  }

  function withdraw() public {
      uint256 balance = address(this).balance;
      for (uint256 i = 0; i < numArrayElements; i++) {
          someArray[i] = 1;
      }
      msg.sender.transfer(balance);
  }
}

Σε αυτό το παράδειγμα, η συνάρτηση κατάθεσης αρχικοποιεί έναν πίνακα με 1000 στοιχεία. Η συνάρτηση ανάληψης μεταφέρει το υπόλοιπο του συμβολαίου στον αποστολέα, αλλά τροποποιεί τα στοιχεία του πίνακα. Το αέριο που απαιτείται για την εκτέλεση του βρόχου υπερβαίνει το όριο του μπλοκ αερίου, γεγονός που εμποδίζει την ανάληψη και την καθυστερεί στο συμβόλαιο.

5. Honeypot χειραγώγησης χρονοσφραγίδας

Σε αυτόν τον τύπο honeypot, το συμβόλαιο χρησιμοποιεί τη χρονοσφραγίδα της αλυσίδας μπλοκ του Ethereum ως συνθήκη εκτέλεσης. Ωστόσο, δεδομένου ότι οι ανθρακωρύχοι μπορούν να χειραγωγήσουν τη χρονοσφραγίδα μπλοκ, το συμβόλαιο καθίσταται ευάλωτο.

Κώδικας παραδείγματος:

pragma solidity 0.4.18

contract TimestampHoneypot {
  uint256 public lastInteraction;
  uint256 public prize;

  function deposit() public payable {
      lastInteraction = now;
      prize += msg.value;
  }

  function withdraw() public {
      require(now >= lastInteraction + 1 hours);
      msg.sender.transfer(prize);
      prize = 0;
  }
}

Σε αυτό το συμβόλαιο, οι χρήστες μπορούν να καταθέσουν χρήματα και να αποσύρουν ολόκληρο το υπόλοιπο του συμβολαίου μετά από 1 ώρα από την τελευταία αλληλεπίδραση. Ωστόσο, δεδομένου ότι οι ανθρακωρύχοι μπορούν να χειραγωγήσουν τη χρονοσφραγίδα μπλοκ, μπορούν να ενεργοποιήσουν τη λειτουργία ανάληψης νωρίτερα από το αναμενόμενο και έτσι να κλέψουν στην πραγματικότητα τα κεφάλαια.

6. Κρυφό συμβόλαιο μελιού

Σε αυτό το είδος συμβολαίου μελιού, το συμβόλαιο περιέχει μια κρυφή μεταφορά κεφαλαίων στη διεύθυνση του επιτιθέμενου, η οποία δίνει την εντύπωση ενός νόμιμου συμβολαίου, αλλά στην πραγματικότητα οδηγεί σε απώλεια κεφαλαίων.

Κώδικας παραδείγματος:

pragma solidity 0.4.18

contract HiddenTransferHoneypot {
  address public owner;

  constructor() public {
      owner = msg.sender;
  }

  function deposit() public payable {
      if (msg.value >= 1 ether) {
          owner.transfer(msg.value);
      }
  }

  function withdraw() public {
      require(msg.sender == owner);
      owner.transfer(address(this).balance);
  }
}

Σε αυτό το παράδειγμα, το συμβόλαιο φαίνεται να επιτρέπει καταθέσεις και αναλήψεις. Ωστόσο, η συνάρτηση κατάθεσης περιέχει μια κρυφή μεταφορά χρημάτων στον ιδιοκτήτη (επιτιθέμενο) εάν το ποσό κατάθεσης είναι ίσο ή μεγαλύτερο από 1 αιθέρα. Οι ανυποψίαστοι χρήστες που καταθέτουν χρήματα θα χάσουν τους αιθέρες τους, καθώς θα μεταφερθούν στη διεύθυνση του επιτιθέμενου.

7. Reentrancy honeypot

Το reentrancy honeypot βασίζεται στην εκμετάλλευση της ευπάθειας reentrancy στο συμβόλαιο, όπου μια συνάρτηση του συμβολαίου μπορεί να κληθεί αναδρομικά πριν ενημερωθεί η κατάστασή του.

Κώδικας παραδείγματος:

pragma solidity 0.4.18

contract ReentrancyHoneypot {
  mapping(address => uint256) public balances;

  function deposit() public payable {
      balances[msg.sender] += msg.value;
  }

  function withdraw() public {
      uint256 amount = balances[msg.sender];
      (bool success,) = msg.sender.call.value(amount)("");
      require(success, "Withdrawal failed.");
      balances[msg.sender] = 0;
  }
}

Σε αυτό το παράδειγμα, το συμβόλαιο επιτρέπει καταθέσεις και αναλήψεις. Ωστόσο, είναι ευάλωτο σε επιθέσεις επανεισαγωγής. Ένας επιτιθέμενος θα μπορούσε να δημιουργήσει ένα κακόβουλο συμβόλαιο που καλεί αναδρομικά τη συνάρτηση withdraw πριν το υπόλοιπο μηδενιστεί, εξαντλώντας ολόκληρο το υπόλοιπο του συμβολαίου.

8. Type casting and overflow honeypot

Σε αυτόν τον τύπο honeypot, ο επιτιθέμενος χρησιμοποιεί μετατροπή τύπου και υπερχείλιση ακεραίων για να ξεγελάσει τους χρήστες και να τους κάνει να πιστέψουν ότι το συμβόλαιο είναι ασφαλές, αλλά στην πραγματικότητα περιέχει κρυφές παγίδες.

Κώδικας παραδείγματος:

pragma solidity 0.4.18

contract TypeCastingHoneypot {
  uint8 public count = 0;
  uint256 public reward = 1 ether;

  function increment() public payable {
      require(msg.value >= reward);

      uint8 prevCount = count;
      count++;

      if (count < prevCount) {
          msg.sender.transfer(address(this).balance);
      }
  }
}

Σε αυτό το παράδειγμα, το συμβόλαιο επιβραβεύει τους χρήστες που αυξάνουν τη μεταβλητή count όταν στέλνουν ένα ποσό ίσο ή μεγαλύτερο από το ποσό επιβράβευσης. Ωστόσο, λόγω της χρήσης της uint8 για τη μεταβλητή count, προκύπτει υπερχείλιση ακέραιου αριθμού όταν η τιμή φτάσει το 255. Μετά την υπερχείλιση, το count μηδενίζεται και ένας εισβολέας μπορεί να αποκτήσει ολόκληρο το υπόλοιπο του συμβολαίου.

9. Delegatecall honeypot

Σε αυτόν τον τύπο honeypot, ο επιτιθέμενος χρησιμοποιεί τη συνάρτηση delegatecall για να εκτελέσει κακόβουλο κώδικα εκ μέρους ενός φαινομενικά ασφαλούς συμβολαίου.

Κώδικας παραδείγματος:

pragma solidity 0.4.18

contract DelegateCallHoneypot {
  address public owner;

  constructor() public {
      owner = msg.sender;
  }

  function() external payable {}

  function withdraw() public {
      require(msg.sender == owner);
      owner.transfer(address(this).balance);
  }

  function execute(address _target, bytes memory _data) public {
      require(msg.sender == owner);
      (bool success,) = _target.delegatecall(_data);
      require(success, "Execution failed.");
  }
}

Σε αυτό το παράδειγμα, το συμβόλαιο επιτρέπει καταθέσεις, αναλήψεις και εκτέλεση κώδικα μέσω της συνάρτησης execute. Ωστόσο, ένας επιτιθέμενος μπορεί να δημιουργήσει κακόβουλο κώδικα που μπορεί να χειριστεί την κατάσταση του συμβολαίου, συμπεριλαμβανομένης της μεταβλητής owner, εκτελώντας τη συνάρτηση delegatecall. Αλλάζοντας τον ιδιοκτήτη, ένας επιτιθέμενος μπορεί να αποκτήσει τον έλεγχο του συμβολαίου και να αδειάσει το υπόλοιπό του.

10. Κρυφό honeypot χειραγώγησης αποθήκευσης

Σε αυτόν τον τύπο honeypot, ο επιτιθέμενος χειρίζεται κρυφά τις μεταβλητές αποθήκευσης για να εξαπατήσει τους χρήστες ώστε να πάρουν τον έλεγχο του συμβολαίου.

Κώδικας παραδείγματος:

pragma solidity 0.4.18

contract HiddenStorageManipulation {
  mapping(address => uint256) public balances;
  uint256 public totalSupply;
  address public owner;

  constructor() public {
      owner = msg.sender;
      balances[owner] = 1000;
      totalSupply = 1000;
  }

  function transfer(address _to, uint256 _value) public {
      require(balances[msg.sender] >= _value);
      balances[msg.sender] -= _value;
      balances[_to] += _value;

      if (totalSupply - balances[owner] >= 1000) {
          owner = _to;
      }
  }
}

Σε αυτό το παράδειγμα, το συμβόλαιο μοιάζει με ένα απλό συμβόλαιο με κουπόνια. Οι χρήστες μπορούν να μεταβιβάσουν token μεταξύ τους και ο ιδιοκτήτης ορίζεται αρχικά ως ο δημιουργός του συμβολαίου. Ωστόσο, ένας επιτιθέμενος μπορεί να χειραγωγήσει κρυφά τις μεταβλητές totalSupply και balances για να ανακτήσει τον έλεγχο του συμβολαίου. Όταν η διαφορά μεταξύ totalSupply και balances[owner] φτάσει το 1000, η μεταβλητή owner ενημερώνεται, επιτρέποντας στον επιτιθέμενο να ανακτήσει τον έλεγχο του συμβολαίου.

11. Honeypot σύγκρουσης ονομάτων συναρτήσεων

Σε αυτόν τον τύπο honeypot, ο επιτιθέμενος χρησιμοποιεί συγκρούσεις ονομάτων συναρτήσεων για να εξαπατήσει τους χρήστες ώστε να καλέσουν λάθος συνάρτηση.

Κώδικας παραδείγματος:

pragma solidity 0.4.18

contract FunctionNameCollision {
  address public owner;

  constructor() public {
      owner = msg.sender;
  }

  function withdraw() external {
      require(msg.sender == owner);
      msg.sender.transfer(address(this).balance);
  }

  function withdraw(uint256 amount) external {
      require(msg.sender == owner);
      owner.transfer(amount);
  }

  function() external payable {}
}

Σε αυτό το παράδειγμα, το συμβόλαιο έχει δύο λειτουργίες ανάληψης. Η μία από αυτές επιτρέπει στον ιδιοκτήτη να αποσύρει ολόκληρο το υπόλοιπο και η άλλη επιτρέπει στον ιδιοκτήτη να αποσύρει ένα συγκεκριμένο ποσό. Ωστόσο, εάν ο χρήστης προσπαθήσει να αποσύρει ένα συγκεκριμένο ποσό καλώντας την κλήση withdraw(uint256), λόγω σύγκρουσης ονομάτων συναρτήσεων, ο χρήστης θα καλέσει κατά λάθος την κλήση withdraw() χωρίς ορίσματα, με αποτέλεσμα να αποσύρει ολόκληρο το υπόλοιπο του συμβολαίου.

12. Honeypot ευπάθειας delegatecall

Σε αυτόν τον τύπο honeypot, ο επιτιθέμενος χρησιμοποιεί την delegatecall για να εκτελέσει μια κακόβουλη συνάρτηση σε ένα άλλο συμβόλαιο, γεγονός που μπορεί να οδηγήσει στην κλοπή χρημάτων από τους χρήστες.

Κώδικας παραδείγματος:

pragma solidity 0.4.18

contract DelegatecallVulnerability {
  address public owner;

  constructor() public {
      owner = msg.sender;
  }

  function withdraw() external {
      require(msg.sender == owner);
      msg.sender.transfer(address(this).balance);
  }

  function () external payable {
      if (msg.value > 1 ether) {
          this.delegatecall(msg.data);
      }
  }
}

contract Malicious {
  function withdraw() external {
      msg.sender.transfer(address(this).balance);
  }
}

Σε αυτό το παράδειγμα, το συμβόλαιο φαίνεται αθώο, με μια απλή συνάρτηση withdraw() που επιτρέπει στον ιδιοκτήτη να αποσύρει το υπόλοιπο του συμβολαίου. Ωστόσο, το συμβόλαιο περιέχει επίσης μια εφεδρική συνάρτηση που, όταν λαμβάνει περισσότερους από 1 αιθέρες, εκτελεί μια κλήση delegatecall ενός άλλου συμβολαίου χρησιμοποιώντας το msg.data. Εάν ένας επιτιθέμενος δημιουργήσει ένα κακόβουλο συμβόλαιο με τη λειτουργία withdraw() που κλέβει το υπόλοιπο του συμβολαίου και στέλνει περισσότερους από 1 αιθέρες στο συμβόλαιο-θύμα, η delegatecall θα εκτελέσει την κακόβουλη λειτουργία withdraw(), κλέβοντας το υπόλοιπο του συμβολαίου.

13. Pseudo-integers overflow honeypot

Αυτό το είδος honeypot βασίζεται στο γεγονός ότι το Solidity δεν έχει ενσωματωμένη υποστήριξη για αριθμούς κινητής υποδιαστολής. Οι επιτιθέμενοι μπορούν να δημιουργήσουν συμβόλαια που εξωτερικά χρησιμοποιούν δεκαδικούς αριθμούς, αλλά στην πραγματικότητα χειρίζονται με δόλιο τρόπο ακέραιους αριθμούς.

Κώδικας παραδείγματος:

pragma solidity 0.4.18

contract PseudoIntegersOverflow {
  mapping(address => uint256) public balances;

  function deposit() external payable {
      require(msg.value > 0);
      uint256 pseudoValue = msg.value * 100;
      balances[msg.sender] += pseudoValue;
  }

  function withdraw(uint256 amount) external {
      uint256 pseudoAmount = amount * 100;
      require(balances[msg.sender] >= pseudoAmount);
      balances[msg.sender] -= pseudoAmount;
      msg.sender.transfer(amount);
  }
}

Αυτό το παράδειγμα δίνει την εντύπωση ότι το συμβόλαιο διαχειρίζεται το υπόλοιπο του χρήστη με δεκαδική ακρίβεια πολλαπλασιάζοντας τις τιμές επί 100 πριν τις αποθηκεύσει. Ωστόσο, αυτή η προσέγγιση είναι παραπλανητική επειδή το Solidity δεν υποστηρίζει αριθμούς κινητής υποδιαστολής. Όταν ο χρήστης επιχειρεί να κάνει ανάληψη των χρημάτων του, το συμβόλαιο υπολογίζει εσφαλμένα το ψευδοάθροισμα λόγω της περικοπής ακεραίων αριθμών και ο χρήστης ενδέχεται να μην είναι σε θέση να κάνει ανάληψη ολόκληρου του υπολοίπου του.

Για να προστατευτείτε από αυτού του είδους τα honeypot, πρέπει να κατανοήσετε τους περιορισμούς της γλώσσας Solidity και τον τρόπο με τον οποίο χειρίζεται τις αριθμητικές πράξεις. Να είστε προσεκτικοί όταν εργάζεστε με συμβόλαια που ισχυρίζονται ότι υποστηρίζουν δεκαδική ακρίβεια και να ελέγχετε πάντα τον κώδικα του συμβολαίου για πιθανά προβλήματα.

14. Κρυφές χρεώσεις σε έξυπνες συμβάσεις

Κάποιες κακόβουλες έξυπνες συμβάσεις μπορούν να επιβάλλουν κρυφές πληρωμές στους χρήστες εν αγνοία τους. Τέτοιες πληρωμές μπορεί να είναι συγκαλυμμένες στον κώδικα της σύμβασης ή να ενεργοποιούνται μόνο υπό ορισμένες συνθήκες.

Κώδικας παραδείγματος:

pragma solidity 0.4.18

contract HiddenFees {
  address public owner;
  uint256 public feePercentage;

  constructor(uint256 _feePercentage) public {
      owner = msg.sender;
      feePercentage = _feePercentage;
  }

  function withdraw(uint256 amount) external {
      uint256 fee = amount * feePercentage / 100;
      uint256 netAmount = amount - fee;
      require(address(this).balance >= netAmount);
      msg.sender.transfer(netAmount);
      owner.transfer(fee);
  }
}

Σε αυτό το παράδειγμα, ο δημιουργός του συμβολαίου ορίζει ένα τέλος (feePercentage) κατά την ανάπτυξη του συμβολαίου. Κατά την αλληλεπίδραση με το συμβόλαιο, οι χρήστες ενδέχεται να μην γνωρίζουν αυτό το τέλος. Όταν ένας χρήστης κάνει ανάληψη των χρημάτων του, το συμβόλαιο υπολογίζει την αμοιβή, την αφαιρεί από το ποσό ανάληψης και στέλνει το υπόλοιπο στον χρήστη. Στη συνέχεια, η προμήθεια μεταφέρεται στον ιδιοκτήτη του συμβολαίου.

Για να αποφύγετε να πέσετε σε αυτή την παγίδα, ελέγξτε προσεκτικά τον κώδικα του συμβολαίου και βεβαιωθείτε ότι έχετε κατανοήσει όλες τις σχετικές χρεώσεις. Αναζητήστε κρυμμένους ή συγκαλυμμένους διακανονισμούς.

15. Κρυφή χειραγώγηση της κατάστασης

Σε ορισμένες περιπτώσεις, οι κακόβουλες συμβάσεις μπορεί να επιτρέπουν στον ιδιοκτήτη της σύμβασης ή σε κάποιον εισβολέα να χειραγωγεί την εσωτερική κατάσταση της σύμβασης, οδηγώντας σε απροσδόκητες συνέπειες για άλλους χρήστες.

Κώδικας παραδείγματος:

pragma solidity 0.4.18

contract HiddenStateManipulation {
  address public owner;
  mapping(address => uint256) public balances;

  constructor() public {
      owner = msg.sender;
  }

  function deposit() external payable {
      balances[msg.sender] += msg.value;
  }

  function withdraw(uint256 amount) external {
      require(balances[msg.sender] >= amount);
      msg.sender.transfer(amount);
      balances[msg.sender] -= amount;
  }

  function manipulateBalance(address user, uint256 newBalance) external {
      require(msg.sender == owner);
      balances[user] = newBalance;
  }
}

Σε αυτό το παράδειγμα, η σύμβαση επιτρέπει στους χρήστες να καταθέτουν και να αποσύρουν χρήματα. Ωστόσο, η συνάρτηση manipulateBalance επιτρέπει στον ιδιοκτήτη του συμβολαίου να αλλάξει αυθαίρετα το υπόλοιπο οποιουδήποτε χρήστη. Αυτό μπορεί να οδηγήσει σε απροσδόκητες απώλειες για τους χρήστες ή να επιτρέψει στον ιδιοκτήτη του συμβολαίου να κλέψει κεφάλαια.

Ο κώδικας του συμβολαίου θα πρέπει να ελέγχεται εξονυχιστικά για λειτουργίες που επιτρέπουν τη χειραγώγηση της κατάστασης, ειδικά αν μόνο ο ιδιοκτήτης του συμβολαίου ή ορισμένες διευθύνσεις έχουν πρόσβαση σε αυτές.

16. Κρυφή κλοπή token

Σε ορισμένες περιπτώσεις, τα κακόβουλα συμβόλαια μπορεί να περιέχουν κρυφά χαρακτηριστικά που επιτρέπουν στον ιδιοκτήτη του συμβολαίου ή στον επιτιθέμενο να κλέβει token από ανυποψίαστους χρήστες.

Κώδικας παραδείγματος:

pragma solidity 0.4.18

contract HiddenTokenStealing {
  address public owner;
  mapping(address => uint256) public balances;

  constructor() public {
      owner = msg.sender;
  }

  function deposit(IERC20 token, uint256 amount) external {
      require(token.transferFrom(msg.sender, address(this), amount));
      balances[msg.sender] += amount;
  }

  function withdraw(IERC20 token, uint256 amount) external {
      require(balances[msg.sender] >= amount);
      require(token.transfer(msg.sender, amount));
      balances[msg.sender] -= amount;
  }

  function stealTokens(IERC20 token, address user, uint256 amount) external {
      require(msg.sender == owner);
      require(token.transfer(owner, amount));
      balances[user] -= amount;
  }
}

Σε αυτό το παράδειγμα, το συμβόλαιο επιτρέπει στους χρήστες να καταθέτουν και να αποσύρουν μάρκες ERC20. Ωστόσο, η συνάρτηση stealTokens επιτρέπει στον ιδιοκτήτη του συμβολαίου να κλέψει tokens από οποιονδήποτε χρήστη.

Συμπεράσματα:

Το Honeypot είναι μόνο ένα από τα πολλά δόλια σχήματα της DeFi που χρησιμοποιεί όχι μόνο τον περιορισμό ανάληψης, αλλά και τις διάφορες κρυφές παγίδες που περιγράφηκαν παραπάνω.

Για να μην πέσετε στο δόλωμα πρέπει να κατανοήσετε τις ιδιαιτερότητες του δόλιου σχήματος, τις λεπτές αποχρώσεις της γλώσσας προγραμματισμού Solidity και να μελετήσετε διεξοδικά τα έξυπνα συμβόλαια πριν αλληλεπιδράσετε με αυτά.

Με το να παραμένετε ενημερωμένοι και να διεξάγετε ενδελεχή έλεγχο, μπορείτε να ελαχιστοποιήσετε τους κινδύνους που σχετίζονται με τη χρήση έξυπνων συμβολαίων.

 

Αν έχετε αμφιβολίες σχετικά με την ασφάλεια ή τη λειτουργικότητα ενός έξυπνου συμβολαίου, χρησιμοποιήστε την πλατφόρμα Lotus Market.

 

 

Η πλατφόρμα Lotus Market δημιουργήθηκε από μια ομάδα έμπειρων προγραμματιστών και επαγγελματιών ελεγκτών. Στόχος του έργου είναι να ελαχιστοποιήσει τους κινδύνους επένδυσης σε απατηλά tokens και να βοηθήσει στην ασφαλή και άνετη διαπραγμάτευση κρυπτονομισμάτων.

 

Χαιρετισμούς, ομάδα Lotus Market.

All posts