Come identificare il token BlackList DeFi?

Proseguiamo la serie di articoli dedicati alla descrizione dei schemi fraudolenti nei contratti intelligenti. Oggi analizzeremo i contratti intelligenti con funzioni Black List (BlackList).

I pericoli dei contratti intelligenti con funzioni BlackList:

I contratti intelligenti che includono funzioni di Blacklist comportano certi rischi e problemi sia per il progetto che per i suoi utenti. Ecco alcuni dei pericoli associati alle funzioni di blacklist:

1. Controllo centralizzato: Le funzioni di Blacklist spesso forniscono un controllo centralizzato al proprietario del contratto o agli amministratori.


2. Abuso della Blacklist per pratiche ingiuste: Gli abusatori (incluso il proprietario del contratto) possono usare la blacklist per mirare a specifici indirizzi. Ciò può includere il congelamento o la restrizione delle funzionalità degli account senza un motivo valido.


3. Mancanza di trasparenza: L'esistenza delle funzioni di blacklisting, specialmente se non sono documentate, può portare a una mancanza di trasparenza. Gli utenti potrebbero non essere consapevoli dei criteri di blacklist o della procedura di blacklist.


4. Rischi di sicurezza: Se BlackList non è implementata in modo sicuro, c'è il rischio di vulnerabilità che potrebbero permettere a parti non autorizzate di manipolare la blacklist, il che potrebbe portare a congelamenti o trasferimenti non autorizzati di fondi.


5. Difidenza degli utenti: L'esistenza delle funzioni di blacklist può minare la fiducia degli utenti poiché i loro asset possono essere inseriti nella blacklist senza regole chiare.


6. Confisca dei token: Gli attaccanti possono usare una blacklist per confiscare token o asset da determinati indirizzi senza giustificazione adeguata. Ciò può comportare significative perdite finanziarie.

Come è possibile determinare indipendentemente la presenza di tali minacce nei contratti intelligenti?

Quando si convalida un contratto intelligente, è possibile intraprendere determinati passi per determinare se vi è una minaccia associata alle funzioni di blacklist:

• Prima di iniziare a lavorare con un contratto intelligente, leggere e studiare attentamente il suo codice, comprese tutte le funzioni relative al blacklist. Cercare funzioni relative al blacklist, congelamento o limitazione della funzionalità dell'account. Verificare la presenza di funzioni che consentano di aggiungere o rimuovere indirizzi dalla blacklist.


• Analizzare chi ha il possesso o il controllo amministrativo del contratto. Valutare il grado di controllo e i diritti associati al proprietario o agli amministratori.


• Esaminare la documentazione del contratto per capire come sono destinati ad essere utilizzate le funzioni di blacklist. Cercare informazioni sui meccanismi di governance che controllano l'uso del blacklist.


• Valutare la trasparenza: Il contratto garantisce che i criteri di blacklist siano trasparenti? Verificare se ci sono procedure chiare per eliminare falsi positivi o rimuovere indirizzi dalla blacklist.


• Audit di sicurezza: verificare se il contratto intelligente è stato sottoposto a audit di sicurezza da parte di aziende terze affidabili.


• Familiarizzare con i feedback della comunità o dei forum online sull'uso delle blacklist nel progetto. Stare attenti a eventuali segnali di pericolo sollevati dai membri della comunità riguardo a pratiche ingiuste o mancanza di trasparenza.


• Conducente un'analisi approfondita e tenendo conto dei fattori sopra citati, sarà possibile valutare meglio i rischi associati alle funzioni di blacklist nei contratti intelligenti. Restate aggiornati con gli ultimi sviluppi nella nostra comunità (canale Telegram) e le migliori pratiche per la rilevazione delle frodi (il nostro Blog e canale YouTube).

 

Buone notizie: il nostro Security Scanner trova tutte le funzioni comuni (incluso quelle nascoste) di Blacklist (BlackList) nel 99.9% dei casi. Utilizza la nostra sottoscrizione premium e proteggi i tuoi fondi dalle minacce.

 

Successivamente, esamineremo alcuni degli esempi più comuni di funzioni BlackList che la nostra Piattaforma riesce a individuare con successo.

Nota che questi sono esempi semplificati e l'implementazione effettiva può differire. Quando si analizzano i contratti intelligenti, è sempre necessario effettuare una revisione approfondita del codice e considerare i fattori dipendenti dal contesto.

Esempio 1: Funzionalità di base della Black List

    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;
      }
  }

Suggerimenti per la rilevazione:Cerca funzioni (come addToBlackList e removeFromBlackList) che hanno modificatori di accesso (onlyOwner). La presenza di tali modificatori significa che solo il proprietario può modificare la blacklist.

Esempio 2: Blacklist con meccanismo di tariffa (BlackList con Tariffa)

    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;
      }
  }

Suggerimenti per la rilevazione:Definire funzioni (come addToBlackListConFee) che richiedono un addebito (msg.value) per essere inseriti nella blacklist. Questo è un segnale molto pericoloso.

Esempio 3: Blacklist con condizioni dipendenti dal tempo

    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;
      }
  }

Suggerimenti per il rilevamento: Definire funzioni (ad esempio addToBlackListTimed) che impongono condizioni dipendenti dal tempo del blocco sulla blacklist. Questo è tipicamente utilizzato per blacklist ritardate o programmate.

Esempio 4: Blacklist con registrazione degli eventi

    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);
      }
  }

Suggerimenti per il rilevamento: Registrazione degli eventi: Cerca eventi che registrano azioni di blacklist. Gli eventi forniscono trasparenza e sono molto importanti per il monitoraggio delle azioni del contratto. Si potrebbe dire che questo è il tipo più sicuro di BlackList poiché gli sviluppatori non nascondono questa funzione ma registrano apertamente tutte le sue chiamate nei log degli eventi.

Esempio 5: Blacklist con funzioni Whitelist (Whitelist)

    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;
      }
  }

Suggerimenti per il rilevamento: Funzionalità Whitelist: Prestare attenzione ai contratti che hanno contemporaneamente funzioni di blacklist e whitelist. Tale funzionalità doppia potrebbe avere implicazioni per i trasferimenti di token senza la conoscenza del proprietario o altre attività fraudolente.

Esempio 6: Blacklist con controllo di governance (Governance Control)

    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;
      }
  }

Suggerimenti per il rilevamento: Identifica i contratti in cui le attività di blacklist sono soggette al controllo da parte di gestori di contratti esterni. Quando si considera un contratto intelligente, analizza attentamente il codice, prestando attenzione ai controlli di accesso, ai meccanismi di pagamento, ai termini e condizioni dipendenti dal tempo, alla registrazione degli eventi, alle protezioni anti-elusione e ad altri fattori importanti. Inoltre, considera le specificità del progetto e dei suoi obiettivi quando valuti le implicazioni dell'uso delle funzioni di blacklist.

Esempio 7: Blacklist con stop di emergenza

    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;
      }
  }

Suggerimenti per il rilevamento: Il meccanismo di pausa del crash può interrompere alcune funzioni, inclusi i cambiamenti della blacklist.

Esempio 8: Blacklist con condizioni dinamiche

    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;
      }
  }

Suggerimenti per il rilevamento: Il blacklist può spesso basarsi su determinate condizioni o eventi. Studiare attentamente le funzioni che vengono controllate prima di attivare la Blacklist. Queste funzioni contengono la logica per aggiungere il proprietario alla Blacklist, in questo esempio la condizione per l'aggiunta è che il saldo dell'account superi la soglia specificata.

Esempio 9: Blacklist di rimozione con blocco temporale (Time-Locked Removal)

    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;
      }
  }

Suggerimenti per il rilevamento: Identifica i contratti in cui la rimozione dalla blacklist è limitata nel tempo. Spesso in questi casi si utilizzano calcoli temporali basati su block.timestamp.

Esempio 10: Blacklist con limiti di gas (Gas Limit Protection)

    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;
      }
  }

Suggerimenti per il rilevamento: Identifica i contratti in cui determinate funzioni, come la blacklist, sono soggette a limiti di gas.

Esempio 11: Blacklist con integrazione esterna tramite 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");
      }
  }

Suggerimenti per il rilevamento: Attenzione ai contratti che si affidano agli Oracle esterni per prendere decisioni di blacklist. Verifica sempre la affidabilità e la trasparenza degli Oracle utilizzati da un contratto intelligente.

Esempio 12: Blacklist con interazione con un contratto esterno

    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);
      }
  }            

Suggerimenti per il rilevamento: Quando si prendono decisioni sulla blacklist, fare attenzione ai contratti che interagiscono con contratti esterni, specialmente se il codice sorgente del contratto esterno non è verificato.

Esempio 13: Blacklist con Threshold dinamico (Dynamic Threshold)

    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;
      }
  }

Suggerimenti per il rilevamento: Identifica i contratti in cui la soglia di blacklist è dinamica e può essere impostata nel tempo dal proprietario (tramite chiamate di determinati metodi del contratto).

Suggerimenti generali per identificare le funzioni di Black List (BlackList)

1. Cerca funzioni che modificano l'elenco degli indirizzi (mapping):
   Esamina il codice del contratto intelligente per identificare funzioni che modificano l'elenco degli indirizzi, come l'aggiunta o la rimozione di indirizzi.


2. Verifica l'accesso solo del proprietario:
   Le funzioni di blacklist spesso hanno restrizioni di accesso che consentono solo al proprietario del contratto o agli amministratori di eseguirle. Cerca l'uso del modificatore onlyOwner o meccanismi simili di controllo degli accessi.


3. Controlla la funzione constructor():
   La funzione constructor() specifica lo stato iniziale del contratto. Verifica se ci sono collegamenti o liste di indirizzi inizializzati nel costruttore, indicando una blacklist.


4. Esplora la logica dei modificatori:
   Analizza la logica dei modificatori di tipo onlyOwner per capire in quali condizioni possono essere eseguite le funzioni relative alla blacklist.


5. Trova termini chiave:
   Cerca parole chiave come "BlackList", "addBlackList", "removeBlackList" o termini simili nel codice del contratto intelligente (nei casi più semplici queste funzioni hanno nomi simili, nelle varianti più complesse i nomi possono non riflettere l'essenza della funzione per mascherarla).


6. Controlla la documentazione e i commenti:
   Esamina la documentazione e i commenti del contratto per eventuali menzioni di funzioni di blacklist. Gli sviluppatori forniscono spesso informazioni su come dovrebbero essere utilizzate determinate funzioni, inclusa la blacklist.


7. Controlla le chiamate esterne (call) o gli eventi (event):
   Cerca chiamate esterne o eventi che possono essere attivati quando un indirizzo viene aggiunto o rimosso dalla blacklist. Questo può fornire informazioni su come il contratto interagisce con componenti esterni basati sulle azioni associate alla blacklist.


8. Valuta le capacità di aggiornamento e gestione del codice del contratto:
   Valuta il contratto intelligente per meccanismi di aggiornamento o strutture di governance che consentano modifiche alla sua logica di blacklist. Comprendere come vengono gestiti gli aggiornamenti è fondamentale per anticipare potenziali modifiche alla funzionalità della blacklist.


9. Controlla la logica della blacklist in altre funzioni:
   Esamina altre funzioni nel contratto per controlli che determinano se un indirizzo è blacklistato prima di eseguire determinate azioni.


10. Scopri i casi d'uso e l'economia del token:
    Comprendi gli scenari di utilizzo e l'economia del progetto. Se il progetto è legato alla gestione degli indirizzi degli utenti o ha funzioni relative ai diritti degli utenti, potrebbe esserci una ragione per la blacklist.


11. Registrazione degli eventi:
    Nota la presenza di un registro degli eventi associato alle azioni di blacklist. Gli eventi vengono spesso utilizzati per registrare cambiamenti significativi dello stato, fornendo trasparenza sul comportamento del contratto.


12. Protezione dal limite di gas:
    Usa cautela con le funzioni che hanno protezione dal limite di gas. Sebbene questo possa essere un'implementazione di una funzione di sicurezza, può anche essere utilizzato per controllare o limitare le prestazioni di alcune funzioni critiche del contratto.


13. Condizioni dipendenti dal tempo:
    Controlla le condizioni dipendenti dal tempo relative alla blacklist. Ad esempio, i contratti possono implementare blocchi temporali sulla cancellazione o su altri meccanismi sensibili al tempo.


14. Audit indipendenti:
    Cerca contratti intelligenti che siano stati auditati in modo indipendente da aziende di audit rispettabili. I rapporti di audit forniscono informazioni sulla sicurezza e sulla funzionalità del contratto.


15. Esamina i feedback della comunità:
    Controlla i forum della comunità, i social media o i canali di comunicazione ufficiali per discussioni sulla presenza e sull'uso delle funzioni di blacklist. Gli utenti possono fornire preziosi spunti e preoccupazioni.






 
16.  
17.  
18.  
19.  

Quando si analizza un contratto intelligente, è fondamentale comprendere appieno le sue funzionalità e la sua funzionalità. Questi suggerimenti ti aiuteranno a identificare ed valutare la presenza di funzioni di blacklist, consentendoti di prendere decisioni informate sull'interazione con il contratto.

Quando possibile, scegli contratti che rispettino gli standard stabiliti (ad esempio ERC-20). Questi standard sono spesso scrutinati e hanno una reputazione di affidabilità.

 

Speriamo che questi esempi ti abbiano aiutato a comprendere meglio gli schemi di Black List (BlackList) nei contratti intelligenti.

 

Poiché tutte le informazioni sulla blockchain sono pubbliche (a condizione, ovviamente, che il codice sorgente del contratto sia verificato), armati di questa conoscenza puoi studiare autonomamente i contratti intelligenti e identificare vari schemi di truffa.

Tuttavia, abbiamo già fatto tutto per te! Iscriviti a un abbonamento premium e ottieni accesso a filtri esclusivi sulle funzioni dei contratti intelligenti e a analisi fresche. Aumenta le tue possibilità di investire con successo in token redditizi.

Cordiali saluti, il team di Lotus Market.

All posts