Smart contracts with functions BlackList

Nous poursuivons la série d'articles consacrée à la description des schémas frauduleux dans les contrats intelligents. Aujourd'hui, nous analyserons les contrats intelligents avec des fonctions de liste noire (BlackList).

Les dangers des contrats intelligents avec des fonctions de liste noire :

Les contrats intelligents qui incluent des fonctions de liste noire comportent certains risques et problèmes pour le projet ainsi que pour ses utilisateurs. Voici quelques dangers associés aux fonctions de liste noire :

1. Contrôle centralisé : Les fonctions de liste noire offrent souvent un contrôle centralisé au propriétaire du contrat ou aux administrateurs.


2. Abus de la liste noire pour des pratiques déloyales : Les abuseurs (y compris le propriétaire du contrat) peuvent utiliser la liste noire pour cibler des adresses spécifiques. Cela peut inclure le gel ou la restriction des fonctionnalités des comptes sans raison valable.


3. Manque de transparence : L'existence de fonctions de liste noire, surtout si elles ne sont pas documentées, peut entraîner un manque de transparence. Les utilisateurs peuvent ne pas être au courant des critères de mise sur liste noire ou de la procédure de mise sur liste noire.


4. Risques de sécurité : Si la liste noire n'est pas implémentée de manière sécurisée, il existe un risque de vulnérabilités qui pourraient permettre à des parties non autorisées de manipuler la liste noire, ce qui pourrait entraîner le gel ou le transfert non autorisé de fonds.


5. Désaveu des utilisateurs : L'existence de fonctions de liste noire peut miner la confiance des utilisateurs, car leurs actifs peuvent être mis sur liste noire sans règles claires.


6. Confiscation de jetons : Les attaquants peuvent utiliser une liste noire pour confisquer des jetons ou des actifs de certaines adresses sans justification appropriée. Cela peut entraîner des pertes financières importantes.

Comment pouvez-vous déterminer indépendamment si de telles menaces sont présentes dans les contrats intelligents ?

Lors de la validation d'un contrat intelligent, certaines étapes peuvent être prises pour déterminer s'il existe une menace liée aux fonctions de liste noire :

• Avant de commencer à travailler avec un contrat intelligent, lisez attentivement et étudiez son code, y compris toutes les fonctions liées à la mise sur liste noire. Recherchez les fonctions liées à la mise sur liste noire, au gel ou à la limitation de la fonctionnalité du compte. Vérifiez les fonctions qui permettent d'ajouter ou de supprimer des adresses de la liste noire.


• Analysez qui détient la propriété ou le contrôle administratif sur le contrat. Évaluez le degré de contrôle et les droits associés au propriétaire ou aux administrateurs.


• Examinez la documentation du contrat pour comprendre comment les fonctions de liste noire sont censées être utilisées. Recherchez des informations sur les mécanismes de gouvernance qui contrôlent l'utilisation de la liste noire.


• Évaluez la transparence : Le contrat garantit-il que les critères de mise sur liste noire sont transparents ? Vérifiez s'il existe des procédures claires pour éliminer les faux positifs ou supprimer des adresses de la liste noire.


• Audits de sécurité : vérifiez si le contrat intelligent a subi des audits de sécurité par des entreprises tierces réputées.


• Familiarisez-vous avec les retours de la communauté ou les forums en ligne sur l'utilisation des listes noires dans le projet. Soyez attentif à tout signe d'alerte soulevé par les membres de la communauté concernant des pratiques déloyales ou un manque de transparence.


• En effectuant une analyse approfondie et en tenant compte des facteurs ci-dessus, vous serez mieux à même d'évaluer les risques associés aux fonctions de liste noire dans les contrats intelligents. Restez informé des derniers développements dans notre communauté (chaîne Telegram) et des meilleures pratiques en matière de détection de fraude (notre Blog et chaîne YouTube).

 

Bonne nouvelle : notre scanner de sécurité trouve toutes les fonctions de liste noire courantes (y compris cachées) 99,9 % du temps. Utilisez notre abonnement premium et protégez vos fonds contre les menaces.

 

Ensuite, nous examinerons quelques exemples courants de fonctions de liste noire que notre plateforme détecte avec succès.

Notez que ces exemples sont simplifiés et que l'implémentation réelle peut différer. Lors de l'analyse des contrats intelligents, vous devez toujours effectuer un examen approfondi du code et tenir compte des facteurs contextuels.

Exemple 1 : Fonctionnalité de base de la liste noire

    contract TokenWithBlackListAndFee {
      address public owner;
      mapping(address => bool) public BlackList;
      uint256 public BlackListFee;
  
      constructor(uint256 _fee) {
          owner = msg.sender;
          BlackListFee = _fee;
      }
  
      modifier onlyOwner() {
          require(msg.sender == owner, "Only the owner can modify the BlackList");
          _;
      }
  
      function addToBlackListWithFee(address _account) public payable onlyOwner {
          require(msg.value >= BlackListFee, "Insufficient fee");
          BlackList[_account] = true;
      }
  
      function removeFromBlackList(address _account) public onlyOwner {
          BlackList[_account] = false;
      }
  }

Conseils de détection : Recherchez des fonctions (telles que addToBlackList et removeFromBlackList) qui ont des modificateurs d'accès (onlyOwner). La présence de tels modificateurs signifie que seul le propriétaire peut modifier la liste noire.

Exemple 2 : Mécanisme de liste noire avec frais (Liste noire avec frais)

    contract TokenWithBlackListAndFee {
      address public owner;
      mapping(address => bool) public BlackList;
      uint256 public BlackListFee;
  
      constructor(uint256 _fee) {
          owner = msg.sender;
          BlackListFee = _fee;
      }
  
      modifier onlyOwner() {
          require(msg.sender == owner, "Only the owner can modify the BlackList");
          _;
      }
  
      function addToBlackListWithFee(address _account) public payable onlyOwner {
          require(msg.value >= BlackListFee, "Insufficient fee");
          BlackList[_account] = true;
      }
  
      function removeFromBlackList(address _account) public onlyOwner {
          BlackList[_account] = false;
      }
  }

Conseils de détection : Définissez des fonctions (telles que addToBlackListWithFee) qui nécessitent un frais (msg.value) pour être mises sur liste noire. C'est un signal très dangereux.

Exemple 3 : Liste noire avec conditions dépendant du temps

    contract TokenWithTimeLock {
      address public owner;
      mapping(address => bool) public BlackList;
      uint256 public BlackListTimeLock;
  
      constructor(uint256 _timeLock) {
          owner = msg.sender;
          BlackListTimeLock = _timeLock;
      }
  
      modifier onlyOwner() {
          require(msg.sender == owner, "Only the owner can modify the BlackList");
          _;
      }
  
      function addToBlackListTimed(address _account) public onlyOwner {
          require(block.timestamp >= BlackListTimeLock, "Time lock not yet expired");
          BlackList[_account] = true;
      }
  
      function removeFromBlackList(address _account) public onlyOwner {
          BlackList[_account] = false;
      }
  }

Conseils de détection : Observez l'utilisation de conditions dépendant du temps (comme block.timestamp) pour déterminer si la suppression de la liste noire est permise. Cela peut indiquer une gestion temporelle du blacklistage.

Exemple 4 : Liste noire avec des conditions des utilisateurs spécifiques

    contract TokenWithBlackListAndEvents {
      address public owner;
      mapping(address => bool) public BlackList;
  
      event AddressAddedToBlackList(address indexed account);
      event AddressRemovedFromBlackList(address indexed account);
  
      constructor() {
          owner = msg.sender;
      }
  
      modifier onlyOwner() {
          require(msg.sender == owner, "Only the owner can modify the BlackList");
          _;
      }
  
      function addToBlackList(address _account) public onlyOwner {
          BlackList[_account] = true;
          emit AddressAddedToBlackList(_account);
      }
  
      function removeFromBlackList(address _account) public onlyOwner {
          BlackList[_account] = false;
          emit AddressRemovedFromBlackList(_account);
      }
  }

Conseils de détection : Journalisation des événements : Recherchez des événements qui enregistrent les actions de mise sur liste noire. Les événements offrent une transparence et sont très importants pour surveiller les actions du contrat. On pourrait dire que c'est le type de BlackList le plus sûr, car les développeurs ne cachent pas cette fonction mais enregistrent ouvertement tous ses appels dans les journaux d'événements.

Exemple 5 : Blacklist avec fonctions de liste blanche (Liste blanche)

    contract TokenWithBlackListAndWhitelist {
      address public owner;
      mapping(address => bool) public BlackList;
      mapping(address => bool) public whitelist;
  
      constructor() {
          owner = msg.sender;
      }
  
      modifier onlyOwner() {
          require(msg.sender == owner, "Only the owner can modify the lists");
          _;
      }
  
      function addToBlackList(address _account) public onlyOwner {
          BlackList[_account] = true;
      }
  
      function removeFromBlackList(address _account) public onlyOwner {
          BlackList[_account] = false;
      }
  
      function addToWhitelist(address _account) public onlyOwner {
          whitelist[_account] = true;
      }
  
      function removeFromWhitelist(address _account) public onlyOwner {
          whitelist[_account] = false;
      }
  }

Conseils de détection : Fonctionnalité de liste blanche : Soyez attentif aux contrats qui ont à la fois des fonctions de mise sur liste noire et de liste blanche en même temps. Une telle fonctionnalité double peut avoir des implications pour les transferts de jetons sans que le propriétaire en soit informé ou d'autres activités frauduleuses.

Exemple 6 : Blacklist avec contrôle de gouvernance (Contrôle de gouvernance)

    interface Governance {
      function canBlackList(address _caller) external view returns (bool);
  }
  
  contract TokenWithGovernanceControl {
      address public owner;
      address public governanceContract;
      mapping(address => bool) public BlackList;
  
      constructor(address _governanceContract) {
          owner = msg.sender;
          governanceContract = _governanceContract;
      }
  
      modifier onlyOwnerOrGovernance() {
          require(msg.sender == owner || Governance(governanceContract).canBlackList(msg.sender), "Not authorized");
          _;
      }
  
      function addToBlackListGoverned(address _account) public onlyOwnerOrGovernance {
          BlackList[_account] = true;
      }
  
      function removeFromBlackList(address _account) public onlyOwnerOrGovernance {
          BlackList[_account] = false;
      }
  }

Conseils de détection : Identifiez les contrats où les activités de mise sur liste noire sont soumises au contrôle par des gestionnaires de contrat externes. Lors de l'examen d'un contrat intelligent, analysez attentivement le code, en portant attention aux contrôles d'accès, aux mécanismes de paiement, aux conditions dépendantes du temps, à la journalisation des événements, aux protections contre le contournement et autres facteurs importants. De plus, prenez en compte les spécificités du projet et ses objectifs lors de l'évaluation des implications de l'utilisation des fonctions de liste noire.

Exemple 7 : Blacklist avec arrêt d'urgence (Arrêt d'urgence)

    contract TokenWithEmergencyStop {
      address public owner;
      bool public emergencyStop;
      mapping(address => bool) public BlackList;
  
      constructor() {
          owner = msg.sender;
      }
  
      modifier onlyOwner() {
          require(msg.sender == owner, "Only the owner can modify the BlackList");
          _;
      }
  
      modifier whenNotPaused() {
          require(!emergencyStop, "Contract is paused");
          _;
      }
  
      function addToBlackList(address _account) public onlyOwner whenNotPaused {
          BlackList[_account] = true;
      }
  
      function removeFromBlackList(address _account) public onlyOwner whenNotPaused {
          BlackList[_account] = false;
      }
  
      function toggleEmergencyStop() public onlyOwner {
          emergencyStop = !emergencyStop;
      }
  }

Conseils de détection : Le mécanisme d'arrêt d'urgence peut mettre en pause certaines fonctions, y compris les changements de liste noire.

Exemple 8 : Blacklist avec conditions dynamiques

    contract TokenWithDynamicBlackList {
      address public owner;
      mapping(address => bool) public BlackList;
  
      constructor() {
          owner = msg.sender;
      }
  
      modifier onlyOwner() {
          require(msg.sender == owner, "Only the owner can modify the BlackList");
          _;
      }
  
      function conditionallyBlackList(address _account, uint256 _threshold) public onlyOwner {
          require(getBalance(_account) < _threshold, "Account balance exceeds threshold");
          BlackList[_account] = true;
      }
  
      function removeFromBlackList(address _account) public onlyOwner {
          BlackList[_account] = false;
      }
  }

Conseils de détection : La mise sur liste noire est souvent basée sur certaines conditions ou événements. Étudiez attentivement les fonctions qui sont vérifiées avant d'activer la liste noire. Ces fonctions contiennent la logique pour ajouter le propriétaire à la liste noire, dans cet exemple la condition pour l'ajout est que le solde du compte est supérieur au seuil spécifié.

Exemple 9 : Suppression de la liste noire verrouillée dans le temps (Suppression de la liste noire verrouillée dans le temps)

    contract TokenWithTimeLockedRemoval {
      address public owner;
      mapping(address => bool) public BlackList;
      mapping(address => uint256) public removalTimeLock;
  
      constructor() {
          owner = msg.sender;
      }
  
      modifier onlyOwner() {
          require(msg.sender == owner, "Only the owner can modify the BlackList");
          _;
      }
  
      function addToBlackList(address _account) public onlyOwner {
          BlackList[_account] = true;
          removalTimeLock[_account] = block.timestamp + 7 days;
      }
  
      function removeFromBlackList(address _account) public onlyOwner {
          require(block.timestamp >= removalTimeLock[_account], "Time lock not expired");
          BlackList[_account] = false;
          removalTimeLock[_account] = 0;
      }
  }

Conseils de détection : Identifiez les contrats où la suppression de la liste noire est limitée dans le temps. Souvent dans de tels cas, des calculs temporels basés sur block.timestamp sont utilisés.

Exemple 10 : Liste noire avec limites de gaz (Protection de la limite de gaz)

    contract TokenWithGasLimitProtection {
      address public owner;
      mapping(address => bool) public BlackList;
  
      constructor() {
          owner = msg.sender;
      }
  
      modifier onlyOwner() {
          require(msg.sender == owner, "Only the owner can modify the BlackList");
          _;
      }
  
      modifier limitGas() {
          require(gasleft() >= 100000, "Insufficient gas");
          _;
      }
  
      function addToBlackListGasLimited(address _account) public onlyOwner limitGas {
          BlackList[_account] = true;
      }
  
      function removeFromBlackList(address _account) public onlyOwner {
          BlackList[_account] = false;
      }
  }

Conseils de détection : Identifiez les contrats où certaines fonctions, telles que la mise sur liste noire, sont soumises à des limites de gaz.

Exemple 11 : Liste noire avec intégration externe à un Oracle (Oracle)

    interface Oracle {
      function isBlackListed(address _account) external view returns (bool);
  }
  
  contract TokenWithOracleIntegration {
      address public owner;
      Oracle public oracle;
  
      constructor(address _oracleAddress) {
          owner = msg.sender;
          oracle = Oracle(_oracleAddress);
      }
  
      modifier onlyOwner() {
          require(msg.sender == owner, "Only the owner can modify the BlackList");
          _;
      }
  
      function addToBlackListByOracle(address _account) public onlyOwner {
          require(oracle.isBlackListed(_account), "Oracle did not confirm BlackListing");
      }
  }

Conseils de détection : Soyez prudent avec les contrats qui dépendent d'Oracles externes pour prendre des décisions de mise sur liste noire. Vérifiez toujours la fiabilité et la transparence des Oracles utilisés par un contrat intelligent.

Exemple 12 : Mise sur liste noire avec interaction avec un contrat externe

    interface ExternalContract {
      function addToBlackList(address _account) external;
      function removeFromBlackList(address _account) external;
  }
  
  contract TokenWithExternalInteraction {
      address public owner;
      ExternalContract public externalContract;
  
      constructor(address _externalContract) {
          owner = msg.sender;
          externalContract = ExternalContract(_externalContract);
      }
  
      modifier onlyOwner() {
          require(msg.sender == owner, "Only the owner can modify the BlackList");
          _;
      }
  
      function addToBlackListExternal(address _account) public onlyOwner {
          externalContract.addToBlackList(_account);
      }
  
      function removeFromBlackListExternal(address _account) public onlyOwner {
          externalContract.removeFromBlackList(_account);
      }
  }   

Conseils de détection : Lors de la prise de décisions de mise sur liste noire, soyez prudent avec les contrats qui interagissent avec des contrats externes, surtout si le code source du contrat externe n'est pas vérifié.

Exemple 13 : Liste noire avec seuil dynamique (Seuil dynamique)

    contract TokenWithDynamicThreshold {
      address public owner;
      mapping(address => bool) public BlackList;
      uint256 public dynamicThreshold;
  
      constructor(uint256 _initialThreshold) {
          owner = msg.sender;
          dynamicThreshold = _initialThreshold;
      }
  
      modifier onlyOwner() {
          require(msg.sender == owner, "Only the owner can modify the BlackList");
          _;
      }
  
      function addToBlackListDynamicThreshold(address _account) public onlyOwner {
          require(getBalance(_account) > dynamicThreshold, "Account balance is below threshold");
          BlackList[_account] = true;
      }
  
      function removeFromBlackList(address _account) public onlyOwner {
          BlackList[_account] = false;
      }
  
      function updateDynamicThreshold(uint256 _newThreshold) public onlyOwner {
          dynamicThreshold = _newThreshold;
      }
  }

Conseils de détection : Identifiez les contrats où le seuil de mise sur liste noire est dynamique et peut être défini par le propriétaire au fil du temps (en appelant certaines méthodes du contrat).

Astuces générales pour identifier les fonctions de liste noire (BlackList)

1. Recherchez les fonctions qui modifient la liste d'adresses (mapping) :
   Examinez le code du contrat intelligent pour identifier les fonctions qui modifient la liste d'adresses, telles que l'ajout ou la suppression d'adresses.


2. Vérifiez l'accès réservé au propriétaire :
   Les fonctions de liste noire ont souvent des restrictions d'accès qui permettent seulement au propriétaire du contrat ou aux administrateurs de les exécuter. Recherchez l'utilisation du modificateur onlyOwner ou des mécanismes de contrôle d'accès similaires.


3. Vérifiez la fonction constructor() :
   La fonction constructor() spécifie l'état initial du contrat. Vérifiez si des liaisons d'adresse ou des listes sont initialisées dans le constructeur, ce qui indique une liste noire.


4. Explorez la logique des modificateurs :
   Analysez la logique des modificateurs de type onlyOwner pour comprendre dans quelles conditions les fonctions liées à la liste noire peuvent être exécutées.


5. Trouvez les termes clés :
   Recherchez des mots-clés tels que "BlackList", "addBlackList", "removeBlackList" ou des termes similaires dans le code du contrat intelligent (dans les cas les plus simples, ces fonctions ont des noms similaires, dans des variantes plus complexes, les noms peuvent ne pas refléter l'essence de la fonction pour la dissimuler).


6. Consultez la documentation et les commentaires :
   Examinez la documentation et les commentaires du contrat pour toute mention des fonctions de mise sur liste noire. Les développeurs fournissent souvent des informations sur la manière dont certaines fonctions, y compris la mise sur liste noire, doivent être utilisées.


7. Vérifiez les appels externes (call) ou les événements (event) :
   Recherchez des appels externes ou des événements qui peuvent être déclenchés lorsqu'une adresse est ajoutée ou supprimée de la liste noire. Cela peut fournir des informations sur la manière dont le contrat interagit avec des composants externes en fonction des actions associées à la liste noire.


8. Évaluez les capacités de mise à jour et de gestion du code du contrat :
   Évaluez le contrat intelligent pour les mécanismes de mise à jour ou les structures de gouvernance qui permettent de modifier sa logique de liste noire. Comprendre comment les mises à jour sont gérées est essentiel pour anticiper les éventuels changements dans la fonctionnalité de la liste noire.


9. Vérifiez la logique de liste noire dans d'autres fonctions :
   Examinez d'autres fonctions du contrat pour les vérifications visant à déterminer si une adresse est sur liste noire avant d'effectuer certaines actions.


10. Découvrez les cas d'utilisation et la tokenomique :
    Comprenez les scénarios d'utilisation et la tokenomique du projet. Si le projet est lié à la gestion des ad resses utilisateur ou comporte des fonctions liées aux droits des utilisateurs, il peut y avoir une raison de faire une liste noire.


11. Journalisation des événements :
    Notez la présence d'un journal d'événements associé aux actions de mise sur liste noire. Les événements sont souvent utilisés pour consigner des changements d'état significatifs, offrant ainsi une transparence sur le comportement du contrat.


12. Protection de la limite de gaz :
    Soyez prudent avec les fonctions qui ont une protection de limite de gaz. Bien que cela puisse être une implémentation d'une fonction de sécurité, cela peut également être utilisé pour contrôler ou limiter les performances de certaines fonctions critiques du contrat.


13. Conditions dépendantes du temps :
    Recherchez des conditions dépendantes du temps liées à la liste noire. Par exemple, les contrats peuvent implémenter des verrous temporels sur la suppression ou d'autres mécanismes sensibles au temps.


14. Audits indépendants :
    Recherchez des contrats intelligents qui ont été audités de manière indépendante par des cabinets d'audit réputés. Les rapports d'audit fournissent un aperçu de la sécurité et de la fonctionnalité du contrat.


15. Examinez les retours de la communauté :
    Consultez les forums communautaires, les réseaux sociaux ou les canaux de communication officiels pour des discussions sur la présence et l'utilisation des fonctions de liste noire. Les utilisateurs peuvent fournir des informations précieuses et des préoccupations.










 
16.  
17.  
18.  
19.  
20.  
21.  
22.  
23.  

Lors de l'analyse d'un contrat intelligent, il est crucial de bien comprendre ses fonctionnalités et sa logique. Ces conseils vous aideront à identifier et évaluer la présence de fonctions de liste noire, vous permettant ainsi de prendre des décisions éclairées sur l'interaction avec le contrat.

Dans la mesure du possible, choisissez des contrats qui respectent les normes établies (par exemple, ERC-20). Ces normes sont souvent scrutées et bénéficient d'une réputation de fiabilité.

 

Nous espérons que ces exemples vous ont aidé à mieux comprendre les schémas de liste noire (BlackList) dans les contrats intelligents.

 

Comme toutes les informations de la blockchain sont publiques (à condition bien sûr que le code source du contrat soit vérifié), armé de ces connaissances, vous pouvez étudier indépendamment les contrats intelligents et identifier divers schémas d'escroquerie.

Cependant, nous avons déjà tout fait pour vous ! Inscrivez-vous à un abonnement premium et accédez à des filtres exclusifs sur les fonctions de contrat intelligent et à des analyses fraîches. Augmentez vos chances d'investir avec succès dans des jetons rentables.

Meilleures salutations, l'équipe de Lotus Market.

All posts