Jak identifikovat token BlackList DeFi?

Pokračujeme v sérii článků věnovaných popisu podvodných schémat ve chytrých smlouvách. Dnes budeme analyzovat chytré smlouvy s funkcemi Black List (BlackList).

Nebezpečí chytrých smluv s funkcemi BlackList:

Chytré smlouvy obsahující funkce Blacklist nesou určitá rizika a problémy jak pro projekt, tak pro jeho uživatele. Zde jsou některá nebezpečí spojená s funkcemi blacklistingu:

1. Centralizovaná kontrola: Funkce Blacklist často poskytují centralizovanou kontrolu vlastníkovi smlouvy nebo administrátorům.


2. Zneužití Blacklistu pro nespravedlivé praktiky: Zneužívatelé (včetně vlastníka smlouvy) mohou použít blacklist k cílení konkrétních adres. To může zahrnovat zmražení nebo omezení funkcionality účtů bez řádného důvodu.


3. Nedostatek transparentnosti: Existence funkcí blacklistingu, zejména pokud nejsou zdokumentovány, může vést k nedostatku transparentnosti. Uživatelé nemusí být informováni o kritériích pro blacklisting nebo o postupu blacklistingu.


4. Bezpečnostní rizika: Pokud BlackList není implementován bezpečně, existuje riziko zranitelností, které by mohly umožnit neautorizovaným stranám manipulovat s blacklistem, což by mohlo vést k neautorizovanému zmrazení nebo převodu prostředků.


5. Nedůvěra uživatelů: Existence funkcí blacklistu může podkopávat důvěru uživatelů, protože jejich aktiva mohou být blacklisted bez jasných pravidel.


6. Konfiskace tokenů: Útočníci mohou použít blacklist k zabavení tokenů nebo aktiv z určitých adres bez řádného odůvodnění. To může vést k významným finančním ztrátám.

Jak můžete nezávisle určit, zda jsou tyto hrozby přítomny ve chytrých smlouvách?

Při ověřování chytré smlouvy lze podniknout určité kroky k určení hrozby spojené s funkcemi blacklistingu:

• Před začátkem práce s chytrou smlouvou pečlivě čtěte a studujte její kód, včetně všech funkcí souvisejících s blacklistingem. Hledejte funkce týkající se blacklistingu, zmrazení nebo omezení funkcionality účtů. Zkontrolujte, zda existují funkce umožňující přidávání nebo odstraňování adres z blacklistu.


• Analyzujte, kdo má vlastnictví nebo administrativní kontrolu nad smlouvou. Posuďte stupeň kontroly a práv spojených s vlastníkem nebo administrátory.


• Prostudujte dokumentaci smlouvy, abyste porozuměli, jak mají být funkce blacklistingu používány. Hledejte informace o správních mechanismech, které kontrolují použití blacklistingu.


• Posuďte transparentnost: Zajišťuje smlouva, že kritéria pro blacklisting jsou transparentní? Zkontrolujte, zda existují jasné postupy pro odstranění falešných pozitiv nebo odstranění adres z blacklistu.


• Bezpečnostní audity: Zkontrolujte, zda chytrá smlouva prošla bezpečnostními audity renomovanými třetími stranami.


• Seznamte se s ohlasy komunity nebo online fór o použití blacklists v projektu. Buďte ostražití vůči jakýmkoli signálům varujícím komunitními členy o nespravedlivých praktikách nebo nedostatku transparentnosti.


• Prováděním důkladné analýzy a zohledněním výše uvedených faktorů budete lépe schopni posoudit rizika spojená s funkcemi blacklistingu ve chytrých smlouvách. Sledujte nejnovější vývoj ve naší komunitě (Telegramový kanál) a nejlepší postupy pro detekci podvodů (náš blog a YouTube kanál).

 

Dobrá zpráva: Náš bezpečnostní skener 99,9% času detekuje všechny běžné (včetně skrytých) funkce BlackList (BlackList). Využijte naši prémiovou předplatné a chráníte své prostředky před hrozbami.

 

Příště se podíváme na několik nejčastějších příkladů funkcí BlackList, které naše platforma úspěšně detekuje.

Všimněte si, že tyto jsou zjednodušené příklady a skutečná implementace se může lišit. Při analýze chytrých smluv byste měli vždy provádět důkladné přezkoumání kódu a zohledňovat kontextuální faktory.

Příklad 1: Základní funkčnost 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;
      }
  }

Tipy pro detekci: Hledejte funkce (jako addToBlackList a removeFromBlackList), které mají přístupové modifikátory (onlyOwner). P řítomnost takových modifikátorů znamená, že pouze vlastník může modifikovat blacklist.

Příklad 2: Blacklist s mechanismem poplatku (BlackList s poplatkem)

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

Tipy pro detekci: Definujte funkce (jako addToBlackListWithFee), které vyžadují poplatek (msg.value) k umístění do blacklistu. Toto je velmi nebezpečný signál.

Příklad 3: Blacklist s časově závislými podmínkami

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

Tipy pro detekci: Definujte funkce (např. addToBlackListTimed), které k blacklistu přidávají časově závislé podmínky bloku. Toto se obvykle používá pro odložené nebo naplánované blacklisty.

Příklad 4: Blacklist s logováním událostí

Pokračujeme v sérii článků věnovaných popisu podvodných schémat ve chytrých smlouvách. Dnes se podíváme na chytré smlouvy s funkcemi BlackList (BlackList) a jejich detekci.

Příklad 5: Blacklist s funkcemi Whitelist (Whitelist)

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

Tipy na detekci:Funkce Whitelist: Věnujte pozornost smlouvám, které mají současně funkce pro přidávání do Blacklistu i Whitelistu. Taková dvojitá funkčnost může mít dopady na převody tokenů bez vědomí vlastníka nebo na jiné podvodné aktivity.

Příklad 5: Černá listina s funkcemi bílé listiny (Bílá listina)

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

Tipy na detekci: Funkce bílé listiny: Věnujte pozornost smlouvám, které mají současně funkce černé a bílé listiny. Taková duální funkcionalita může mít dopady na převody tokenů bez vědomí vlastníka nebo jiné podvodné aktivity.

Příklad 6: Blacklist s kontrolou 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;
      }
  }

Tipy na detekci:Identifikujte smlouvy, kde jsou činnosti v oblasti Blacklistu pod kontrolou externích správců smluv. Při zvažování chytré smlouvy pečlivě analyzujte kód a věnujte pozornost kontrolám přístupu, platebním mechanismům, časově závislým podmínkám a podmínkám, záznamům událostí, ochranám proti obcházení a dalším důležitým faktorům. Kromě toho zvažte specifika projektu a jeho cíle při posuzování dopadů použití funkcí blacklistu.

Příklad 7: Blacklist s nouzovým zastavením (Emergency Stop)

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

Tipy na detekci:Mechanismus nouzového zastavení může zastavit některé funkce, včetně změn v blacklistu.

Příklad 8: Blacklist s dynamickými podmínkami

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

Tipy na detekci:Blacklisting často může být založeno na určitých podmínkách nebo událostech. Pečlivě zkoumejte funkce, které jsou kontrolovány před aktivací Blacklistu. Tyto funkce obsahují logiku pro přidání vlastníka do Blacklistu, v tomto případě je podmínka pro přidání, že bilance účtu překračuje stanovený limit.

Příklad 9: Časově omezené odstranění z Blacklistu (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;
      }
  }

Tipy na detekci:Identifikujte smlouvy, kde odstranění z blacklistu je časově omezené. Často se v těchto případech používají časové výpočty na základě block.timestamp.

Příklad 10: Blacklist s limity plynu (Ochrana limitu plynu)

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

Tipy na detekci:Identifikujte smlouvy, kde jsou určité funkce, jako je blacklisting, podrobeny limitům plynu.

Příklad 11: Blacklist s externí integrací s 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");
      }
  }

Tipy na detekci:Buďte opatrní na smlouvy, které spoléhají na externí Oracles k rozhodování o blacklistingu. Vždy zkontrolujte spolehlivost a transparentnost Oracles, které chytrá smlouva používá.

Příklad 12: Blacklist s interakcí s externí smlouvou

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

Tipy na detekci:Při rozhodování o blacklistingu buďte opatrní na smlouvy, které interagují s externími smlouvami, zejména pokud zdrojový kód externí smlouvy není ověřen.

Příklad 13: Blacklist s dynamickým prahem (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;
      }
  }

Tipy na detekci:Identifikujte smlouvy, kde je prah pro blacklisting dynamický a může být v průběhu času nastaven vlastníkem (voláním určitých metod smlouvy).

Obecné tipy pro identifikaci funkcí Black List (BlackList)

1. Hledejte funkce, které mění seznam adres (mapping):
   Prozkoumejte kód chytré smlouvy a identifikujte funkce, které mění seznam adres, jako je přidávání nebo odebírání adres.


2. Zkontrolujte přístup pouze pro vlastníka:
   Funkce blacklistingu často obsahují omezení přístupu, které umožňují jejich provedení pouze vlastníkovi smlouvy nebo správcům. Hledejte použití modifikátoru onlyOwner nebo podobných mechanismů kontroly přístupu.


3. Zkontrolujte konstruktor() konstrukční funkci:
   Funkce konstruktoru určuje počáteční stav smlouvy. Zkontrolujte, zda jsou v konstruktoru inicializovány nějaké vazby na adresy nebo seznamy, což naznačuje existenci blacklistu.


4. Prozkoumejte logiku modifikátorů:
   Analyzujte logiku modifikátorů typu onlyOwner, abyste porozuměli podmínkám, za jakých mohou být prováděny funkce související s blacklistingem.


5. Hledejte klíčové termíny:
   V kódu chytré smlouvy hledejte klíčová slova jako "BlackList", "addBlackList", "removeBlackList" nebo podobné termíny (v jednodušších případech tyto funkce mají podobné názvy, v složitějších variantách názvy nemusí odrážet podstatu funkce, aby byly zamaskovány).


6. Zkontrolujte dokumentaci a komentáře:
   Prozkoumejte dokumentaci a komentáře smlouvy na zmínky o funkcích blacklistingu. Vývojáři často poskytují informace o tom, jak by měly být použity určité funkce, včetně blacklistingu.


7. Zkontrolujte externí volání (call) nebo události (event):
   Hledejte externí volání nebo události, které mohou být spuštěny při přidávání nebo odebírání adres z blacklistu. To může poskytnout náhled na to, jak smlouva interaguje s externími komponentami na základě akcí spojených s blacklistingem.
8. < br />
9. Zhodnoťte aktualizační a správní schopnosti kódu smlouvy:
   Zhodnoťte chytrou smlouvu na mechanismy aktualizace nebo správy, které umožňují změny v její logice blacklistingu. Porozumění tomu, jak jsou aktualizace řízeny, je klíčové pro předvídání potenciálních změn v funkci blacklistingu.


10. Zkontrolujte logiku blacklistu v jiných funkcích:
    Prozkoumejte ostatní funkce ve smlouvě na kontrolu, zda je adresa blacklistována před prováděním určitých akcí.


11. Objasněte případy užití a tokenomiku:
    Porozumějte scénářům použití a tokenomice projektu. Pokud projekt souvisí s řízením adres uživatelů nebo má funkce související s právy uživatelů, může existovat důvod pro blacklistování.


12. Zaznamenávání událostí:
    Všimněte si přítomnosti událostního záznamu spojeného s akcemi blacklistingu. Události jsou často používány k zaznamenávání významných změn stavu, což poskytuje transparentnost chování smlouvy.


13. Ochrana limitu plynu:
    Buďte opatrní při funkcích, které mají ochranu limitu plynu. Tato funkce může být implementací bezpečnostního prvku, ale může také sloužit k řízení nebo omezování výkonu některých kritických funkcí smlouvy.


14. Časově závislé podmínky:
    Zkontrolujte časově závislé podmínky týkající se blacklistingu. Například smlouvy mohou implementovat časové zámky na smazání nebo jiné časově citlivé mechanismy.


15. Nezávislá auditace:
    Hledejte chytré smlouvy, které byly nezávisle auditovány renomovanými auditními firmami. Auditní zprávy poskytují náhled na bezpečnost a funkčnost smlouvy.


16. Zkontrolujte zpětnou vazbu komunity:
    Prozkoumejte komunitní fóra, sociální média nebo oficiální komunikační kanály pro diskuse o přítomnosti a použití funkcí blacklistingu. Uživatelé mohou poskytnout cenné návrhy a obavy.














 
17.  
18.  
19.  
20.  
21.  
22.  
23.  
24.  
25.  
26.  
27.  
28.  

Při analýze chytré smlouvy je kritické mít plné porozumění jejím funkcím a funkcionalitě. Tyto tipy vám pomohou identifikovat a vyhodnotit přítomnost funkcí Blacklist, což vám umožní informovaně rozhodovat o interakci se smlouvou.

Pokud je to možné, vybírejte smlouvy, které splňují etablované standardy (např. ERC-20). Tyto standardy jsou často pečlivě zkoumány a mají dobrou pověst pro spolehlivost.

 

Doufáme, že vám tyto příklady pomohly lépe porozumět schémám Black List (BlackList) v chytrých smlouvách.

 

Vzhledem k tomu, že veškeré informace v blockchainu jsou veřejné (pokud je samozřejmě ověřen zdrojový kód smlouvy), s tímto znalostním arzenálem můžete nezávisle studovat chytré smlouvy a identifikovat různé podvodné schémata.

Nicméně, my jsme již všechno udělali za vás! Přihlaste se k prémiovému předplatnému a získejte přístup k exkluzivním filtrům funkcí chytré smlouvy a čerstvým analytickým datům. Zvyšte své šance na úspěšné investování do ziskových tokenů.

S pozdravem, tým Lotus Market.

All posts