Cum se identifică tokenul BlackList DeFi?

Continuăm seria de articole dedicate descrierii schemelor frauduloase în smart contracts. Astăzi vom analiza smart contracts cu funcții de listă neagră (BlackList).

Pericolele smart contracts cu funcții BlackList:

Smart contracts care includ funcții de listă neagră prezintă anumite riscuri și probleme atât pentru proiect, cât și pentru utilizatorii săi. Iată câteva dintre pericolele asociate cu funcțiile de listă neagră:

1. Control centralizat: Funcțiile de listă neagră oferă adesea control centralizat proprietarului contractului sau administratorilor.


2. Abuzul listei negre pentru practici incorecte: Abuzatorii (inclusiv proprietarul contractului) pot folosi lista neagră pentru a viza adrese specifice. Acest lucru poate include înghețarea sau restricționarea funcționalității conturilor fără motive întemeiate.


3. Lipsa de transparență: Existența funcțiilor de listă neagră, în special dacă nu sunt documentate, poate duce la o lipsă de transparență. Utilizatorii ar putea să nu fie conștienți de criteriile de listare neagră sau de procedura de listare neagră.


4. Riscuri de securitate: Dacă funcțiile de listă neagră nu sunt implementate în siguranță, există riscul ca vulnerabilitățile să permită părților neautorizate să manipuleze lista neagră, ceea ce ar putea duce la înghețarea sau transferul neautorizat de fonduri.


5. Neîncrederea utilizatorilor: Existența funcțiilor de listă neagră poate submina încrederea utilizatorilor, deoarece activele lor pot fi listate pe lista neagră fără reguli clare.


6. Confiscarea tokenurilor: Atacatorii pot folosi o listă neagră pentru a confisca tokenuri sau active de la anumite adrese fără justificare adecvată. Acest lucru poate duce la pierderi financiare semnificative.

Cum puteți determina independent dacă aceste amenințări sunt prezente în smart contracts?

La validarea unui smart contract, se pot lua anumite măsuri pentru a determina dacă există o amenințare asociată cu funcțiile de listă neagră:

• Înainte de a începe să lucrați cu un smart contract, citiți și studiați cu atenție codul său, inclusiv toate funcțiile legate de listarea neagră. Căutați funcții legate de listarea neagră, înghețarea sau limitarea funcționalității contului. Verificați existența funcțiilor care permit adăugarea sau eliminarea adreselor din lista neagră.


• Analizați cine are controlul proprietății sau controlul administrativ asupra contractului. Evaluați gradul de control și drepturile asociate cu proprietarul sau administratorii.


• Examinați documentația contractului pentru a înțelege cum se intenționează să fie utilizate funcțiile de listare neagră. Căutați informații despre mecanismele de guvernanță care controlează utilizarea funcțiilor de listare neagră.


• Evaluați transparența: Contractul asigură criterii transparente pentru listarea neagră? Verificați dacă există proceduri clare pentru eliminarea pozitivelor false sau pentru eliminarea adreselor din lista neagră.


• Audituri de securitate: verificați dacă smart contractul a fost supus unor audituri de securitate de către companii terțe de renume.


• Familiarizați-vă cu feedback-ul comunității sau forumurile online despre utilizarea listelor negre în proiect. Fiti atenți la orice semnal de alarmă ridicat de membrii comunității despre practici incorecte sau lipsa de transparență.


• Prin efectuarea unei analize amănunțite și luând în considerare factorii de mai sus, veți fi mai bine echipați să evaluați riscurile asociate cu funcțiile de listă neagră în smart contracts. Rămâneți la curent cu cele mai recente dezvoltări din comunitatea noastră (canalul Telegram) și cu cele mai bune practici pentru detectarea fraudelor (Blog-ul nostru și canalul YouTube).

 

Vești bune: Scanner-ul nostru de securitate detectează toate funcțiile comune (inclusiv cele ascunse) de listare neagră (BlackList) în 99,9% din cazuri. Folosiți abonamentul nostru premium și protejați-vă fondurile de amenințări.

 

În continuare, vom examina câteva dintre cele mai comune exemple de funcții de listă neagră pe care platforma noastră le detectează cu succes.

Rețineți că acestea sunt exemple simplificate și implementarea reală poate diferi. Când analizați smart contracts, ar trebui să efectuați întotdeauna o revizuire amănunțită a codului și să luați în considerare factorii dependenți de context.

Exemplu 1: Funcționalitatea de bază a Listei Negre

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

Sfaturi pentru detectare:Căutați funcții (cum ar fi addToBlackList și removeFromBlackList) care au modificatori de acces (onlyOwner). Prezența acestor modificatori înseamnă că doar proprietarul poate modifica lista neagră.

Exemplu 2: Listă neagră cu mecanism de taxare (BlackList cu Taxă)

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

Sfaturi pentru detectare:Definiți funcții (cum ar fi addToBlackListWithFee) care necesită o taxă (msg.value) pentru a fi incluse în lista neagră. Acesta este un semnal foarte periculos.

Exemplu 3: Listă neagră cu condiții dependente de timp

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

Sfaturi pentru detectare:Definiți funcții (de exemplu, addToBlackListTimed) care impun condiții dependente de timp pe listă neagră. Acestea sunt utilizate de obicei pentru listele negre întârziate sau programate.

Exemplu 4: Listă neagră cu jurnalizare de evenimente

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

Sfaturi pentru detectare:Jurnalizarea evenimentelor: Căutați evenimente care înregistrează acțiunile de listare neagră. Evenimentele oferă transparență și sunt foarte importante pentru monitorizarea acțiunilor contractului. Se poate spune că aceasta este cea mai sigură formă de listă neagră, deoarece dezvoltatorii nu ascund această funcție, ci înregistrează deschis toate apelurile sale în jurnalele de evenimente.

Exemplu 5: Listă neagră cu funcții de listă albă (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;
      }
  }

Sfaturi pentru detectare:Funcționalitate de listă albă: Acordați atenție contractelor care au atât funcții de listă neagră, cât și funcții de listă albă în același timp. Această dublă funcționalitate poate avea implicații asupra transferurilor de tokenuri fără cunoștința proprietarului sau alte activități frauduloase.

Exemplu 6: Listă neagră cu control de guvernanță (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;
      }
  }

Sfaturi pentru detectare:Identificați contractele în care activitățile de listare neagră sunt supuse controlului de către managerii de contracte externe. Când analizați un smart contract, studiați cu atenție codul, acordând atenție controalelor de acces, mecanismelor de plată, termenilor și condițiilor dependente de timp, jurnalizării evenimentelor, protecțiilor anti-eludare și altor factori importanți. În plus, luați în considerare specificul proiectului și obiectivele acestuia atunci când evaluați implicațiile utilizării funcțiilor de listă neagră.

Exemplu 7: Listă neagră cu oprire de urgență

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

Sfaturi pentru detectare:Mecanismul de oprire de urgență poate opri unele funcții, inclusiv modificările listei negre.

Exemplu 8: Listă neagră cu condiții dinamice

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

Sfaturi pentru detectare:Listarea neagră poate fi adesea bazată pe anumite condiții sau evenimente. Studiați cu atenție funcțiile care sunt verificate înainte de activarea listei negre. Aceste funcții conțin logica pentru adăugarea proprietarului în lista neagră, în acest exemplu condiția de adăugare este ca soldul contului să fie sub pragul specificat.

Exemplu 9: Listă neagră cu eliminare blocată în timp (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;
      }
  }

Sfaturi pentru detectare:Identificați contractele în care eliminarea din lista neagră este limitată de timp. Adesea în astfel de cazuri, se folosesc calcule temporale bazate pe block.timestamp.

Exemplu 10: Listă neagră cu limite de gaz (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;
      }
  }

Sfaturi pentru detectare:Identificați contractele în care anumite funcții, cum ar fi listarea neagră, sunt supuse limitelor de gaz.

Exemplu 11: Listă neagră cu integrare externă cu 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");
      }
  }

Sfaturi pentru detectare:Fiți atenți la contractele care se bazează pe Oracles externe pentru a lua decizii de listare neagră. Verificați întotdeauna fiabilitatea și transparența Oracles pe care le utilizează un smart contract.

Exemplu 12: Listare neagră cu interacțiune cu un contract extern

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

Sfaturi pentru detectare:Când luați decizii de listare neagră, fiți atenți la contractele care interacționează cu contracte externe, în special dacă codul sursă al contractului extern nu este verificat.

Exemplu 13: Listă neagră cu prag dinamic (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;
      }
  }

Sfaturi pentru detectare:Identificați contractele unde pragul pentru listarea neagră este dinamic și poate fi stabilit de către proprietar în timp (prin apelarea anumitor metode ale contractului).

Sfaturi generale pentru identificarea funcțiilor de listă neagră (BlackList)

1. Căutați funcții care modifică lista de adrese (mapping):
   Examinați codul smart contractului pentru a identifica funcții care modifică lista de adrese, cum ar fi adăugarea sau eliminarea adreselor.


2. Verificați accesul restricționat doar pentru proprietar:
   Funcțiile de listă neagră au adesea restricții de acces care permit doar proprietarului contractului sau administratorilor să le execute. Căutați utilizarea modificatorului onlyOwner sau mecanisme similare de control al accesului.


3. Verificați funcția constructor() a constructorului:
   Funcția constructor specifică starea inițială a contractului. Verificați dacă sunt inițializate legături de adrese sau liste în constructor, indicând o listă neagră.


4. Explorați logica modificatorilor:
   Analizați logica modificatorilor de tip onlyOwner pentru a înțelege în ce condiții pot fi executate funcțiile legate de listarea neagră.


5. Găsiți termeni cheie:
   Căutați cuvinte cheie precum "BlackList", "addBlackList", "removeBlackList" sau termeni similari în codul smart contractului (în cazurile cele mai simple, aceste funcții au nume similare, în variantele mai complexe, numele pot să nu reflecte esența funcției pentru a o deghiza).


6. Verificați documentația și comentariile:
   Revizuiți documentația și comentariile contractului pentru orice mențiune a funcțiilor de listare neagră. Dezvoltatorii oferă adesea informații despre modul în care ar trebui utilizate anumite funcții, inclusiv listarea neagră.


7. Verificați apelurile externe (call) sau evenimentele (event):
   Căutați apeluri externe sau evenimente care pot fi declanșate atunci când o adresă este adăugată sau eliminată din lista neagră. Acest lucru poate oferi informații despre modul în care contractul interacționează cu componente externe pe baza acțiunilor asociate cu lista neagră.


8. Evaluați capacitățile de actualizare și management ale codului contractului:
   Evaluați contractul inteligent pentru mecanisme de actualizare sau structuri de guvernanță care permit modificări ale logicii de listare neagră. Înțelegerea modului în care sunt gestionate actualizările este esențială pentru anticiparea schimbărilor potențiale ale funcționalității listei negre.


9. Verificați logica listei negre în alte funcții:
   Examinați alte funcții din contract pentru verificări care determină dacă o adresă este pe lista neagră înainte de a efectua anumite acțiuni.


10. Descoperiți cazurile de utilizare și tokenomics:
    Înțelegeți scenariile de utilizare și tokenomics ale proiectului. Dacă proiectul este legat de managementul adreselor utilizatorilor sau are funcții legate de drepturile utilizatorilor, poate exista un motiv pentru listarea neagră.


11. Înregistrarea evenimentelor:
    Notați prezența unui jurnal de evenimente asociat cu acțiunile de listare neagră. Evenimentele sunt adesea utilizate pentru a înregistra schimbări semnificative de stare, oferind transparență în comportamentul contractului.


12. Protecția prin limitarea gazului:
    Fiți precauți cu funcțiile care au protecție prin limitarea gazului. Deși aceasta poate fi o implementare a unei funcții de siguranță, poate fi folosită și pentru a controla sau a limita performanța unor funcții critice ale contractului.


13. Condiții dependente de timp:
    Verificați condițiile dependente de timp legate de listarea neagră. De exemplu, contractele pot implementa blocaje temporale pentru ștergere sau alte mecanisme sensibile la timp.


14. Audite independente:
    Căutați contracte inteligente care au fost auditate independent de firme de audit de renume. Rapoartele de audit oferă informații despre securitatea și funcționalitatea contractului.


15. Revizuiți feedback-ul comunității:
    Verificați forumurile comunității, rețelele sociale sau canalele oficiale de comunicare pentru discuții despre prezența și utilizarea funcțiilor de listă neagră. Utilizatorii pot oferi informații și preocupări valoroase.



 
16.  

Când analizați un smart contract, este esențial să aveți o înțelegere completă a funcțiilor și caracteristicilor sale. Aceste sfaturi vă vor ajuta să identificați și să evaluați prezența funcțiilor de listă neagră, permițându-vă să luați decizii informate despre interacțiunea cu contractul.

Acolo unde este posibil, alegeți contracte care respectă standardele stabilite (de exemplu, ERC-20). Aceste standarde sunt adesea verificate și au o reputație de fiabilitate.

 

Sperăm că aceste exemple v-au ajutat să înțelegeți mai bine schemele de listă neagră (BlackList) în smart contracte.

 

Deoarece toate informațiile din blockchain sunt deschise (cu condiția, desigur, ca codul sursă al contractului să fie verificat), înarmați cu aceste cunoștințe, puteți studia independent smart contractele și identifica diverse scheme de înșelătorie.

Totuși, am făcut deja totul pentru tine! Înscrie-te pentru un abonament premium și obține acces la filtre exclusive pe funcțiile smart contractelor și la analize proaspete. Crește-ți ș ansele de a investi cu succes în tokenuri profitabile.

Cu respect, echipa Lotus Market.

All posts