HIGH severity: Stops Transactions. The transactions can be stopped by the owner, but cannot be disabled again once enabled.

Vulnerable code:
//SPDX-License-Identifier: MIT

pragma solidity ^0.8.19;



abstract contract Context {

    function _msgSender() internal view virtual returns (address) {

        return msg.sender;

    }



    function _msgData() internal view virtual returns (bytes calldata) {

        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691

        return msg.data;

    }

}



interface IBEP20 {

    function totalSupply() external view returns (uint256);

    function balanceOf(address account) external view returns (uint256);

    function transfer(address recipient, uint256 amount) external returns (bool);

    function allowance(address owner, address spender) external view returns (uint256);

    function approve(address spender, uint256 amount) external returns (bool);



    function transferFrom(

        address sender,

        address recipient,

        uint256 amount

    ) external returns (bool);



    event Transfer(address indexed from, address indexed to, uint256 value);



    event Approval(address indexed owner, address indexed spender, uint256 value);

}



interface IBEP20Metadata is IBEP20 {

    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function decimals() external view returns (uint8);

}



contract BEP20 is Context, IBEP20, IBEP20Metadata {

    mapping(address => uint256) internal _balances;



    mapping(address => mapping(address => uint256)) internal _allowances;



    uint256 private _totalSupply;



    string private _name;

    string private _symbol;



    constructor(string memory name_, string memory symbol_) {

        _name = name_;

        _symbol = symbol_;

    }



    function name() public view virtual override returns (string memory) {

        return _name;

    }



    function symbol() public view virtual override returns (string memory) {

        return _symbol;

    }



    function decimals() public view virtual override returns (uint8) {

        return 18;

    }



    function totalSupply() public view virtual override returns (uint256) {

        return _totalSupply;

    }



    function balanceOf(address account) public view virtual override returns (uint256) {

        return _balances[account];

    }



    function transfer(address recipient, uint256 amount)

        public

        virtual

        override

        returns (bool)

    {

        _transfer(_msgSender(), recipient, amount);

        return true;

    }



    function allowance(address owner, address spender)

        public

        view

        virtual

        override

        returns (uint256)

    {

        return _allowances[owner][spender];

    }



    function approve(address spender, uint256 amount) public virtual override returns (bool) {

        _approve(_msgSender(), spender, amount);

        return true;

    }



    function transferFrom(

        address sender,

        address recipient,

        uint256 amount

    ) public virtual override returns (bool) {

        _transfer(sender, recipient, amount);



        uint256 currentAllowance = _allowances[sender][_msgSender()];

        require(currentAllowance >= amount, "BEP20: transfer amount exceeds allowance");

        _approve(sender, _msgSender(), currentAllowance - amount);



        return true;

    }



    function increaseAllowance(address spender, uint256 addedValue)

        public

        virtual

        returns (bool)

    {

        _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);

        return true;

    }



    function decreaseAllowance(address spender, uint256 subtractedValue)

        public

        virtual

        returns (bool)

    {

        uint256 currentAllowance = _allowances[_msgSender()][spender];

        require(currentAllowance >= subtractedValue, "BEP20: decreased allowance below zero");

        _approve(_msgSender(), spender, currentAllowance - subtractedValue);



        return true;

    }



    function _transfer(

        address sender,

        address recipient,

        uint256 amount

    ) internal virtual {

        require(sender != address(0), "BEP20: transfer from the zero address");

        require(recipient != address(0), "BEP20: transfer to the zero address");



        uint256 senderBalance = _balances[sender];

        require(senderBalance >= amount, "BEP20: transfer amount exceeds balance");

        _balances[sender] = senderBalance - amount;

        _balances[recipient] += amount;



        emit Transfer(sender, recipient, amount);

    }



    function _tokengeneration(address account, uint256 amount) internal virtual {

        _totalSupply = amount;

        _balances[account] = amount;

        emit Transfer(address(0), account, amount);

    }



    function _approve(

        address owner,

        address spender,

        uint256 amount

    ) internal virtual {

        require(owner != address(0), "BEP20: approve from the zero address");

        require(spender != address(0), "BEP20: approve to the zero address");



        _allowances[owner][spender] = amount;

        emit Approval(owner, spender, amount);

    }

}



library Address {

    function sendValue(address payable recipient, uint256 amount) internal {

        require(address(this).balance >= amount, "Address: insufficient balance");



        (bool success, ) = recipient.call{ value: amount }("");

        require(success, "Address: unable to send value, recipient may have reverted");

    }

}



abstract contract Ownable is Context {

    address private _owner;



    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);



    constructor() {

        _setOwner(_msgSender());

    }



    function owner() public view virtual returns (address) {

        return _owner;

    }



    modifier onlyOwner() {

        require(owner() == _msgSender(), "Ownable: caller is not the owner");

        _;

    }



    function renounceOwnership() public virtual onlyOwner {

        _setOwner(address(0));

    }



    function transferOwnership(address newOwner) public virtual onlyOwner {

        require(newOwner != address(0), "Ownable: new owner is the zero address");

        _setOwner(newOwner);

    }



    function _setOwner(address newOwner) private {

        address oldOwner = _owner;

        _owner = newOwner;

        emit OwnershipTransferred(oldOwner, newOwner);

    }

}



interface IFactory {

    function createPair(address tokenA, address tokenB) external returns (address pair);

}



interface IRouter {

    function factory() external pure returns (address);

    function WETH() external pure returns (address);

}



contract CEOLinda is BEP20, Ownable {

    using Address for address payable;

    IRouter public router;

    address private pair;

    bool public tradingEnabled = false;

    mapping(address => bool) private whitelist;



    address public constant deadWallet = 0x000000000000000000000000000000000000dEaD;

    

    constructor() BEP20("Elon Linda CEO", "CEOLinda") {

        _tokengeneration(msg.sender, 1e15 * 10**decimals());

        IRouter _router = IRouter(0x10ED43C718714eb63d5aA57B78B54704E256024E);

        address _pair = IFactory(_router.factory()).createPair(address(this), _router.WETH());



        router = _router;

        pair = _pair;

        whitelist[msg.sender] = true;

        whitelist[address(this)] = true;

        whitelist[deadWallet] = true;

    }



    function approve(address spender, uint256 amount) public override returns (bool) {

        _approve(_msgSender(), spender, amount);

        return true;

    }



    function transferFrom(

        address sender,

        address recipient,

        uint256 amount

    ) public override returns (bool) {

        _transfer(sender, recipient, amount);



        uint256 currentAllowance = _allowances[sender][_msgSender()];

        require(currentAllowance >= amount, "BEP20: transfer amount exceeds allowance");

        _approve(sender, _msgSender(), currentAllowance - amount);



        return true;

    }



    function increaseAllowance(address spender, uint256 addedValue)

        public

        override

        returns (bool)

    {

        _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);

        return true;

    }



    function decreaseAllowance(address spender, uint256 subtractedValue)

        public

        override

        returns (bool)

    {

        uint256 currentAllowance = _allowances[_msgSender()][spender];

        require(currentAllowance >= subtractedValue, "BEP20: decreased allowance below zero");

        _approve(_msgSender(), spender, currentAllowance - subtractedValue);



        return true;

    }



    function transfer(address recipient, uint256 amount) public override returns (bool) {

        _transfer(msg.sender, recipient, amount);

        return true;

    }



    function _transfer(

        address sender,

        address recipient,

        uint256 amount

    ) internal override {

        require(amount > 0, "Transfer amount must be greater than zero");



        if (!whitelist[sender] && !whitelist[recipient]) {

            require(tradingEnabled, "Trading not enabled");

        }

       

        super._transfer(sender, recipient, amount);

    }



    function go_live() external onlyOwner {

        require(!tradingEnabled, "Trading is already enabled");

        tradingEnabled = true;

    }

   

   function rescueETH() external {

        uint256 contractETHBalance = address(this).balance;

        require(contractETHBalance > 0, "Amount should be greater than zero");

        payable(owner()).transfer(contractETHBalance);

    }



   function rescueERC20(address _tokenAddy, uint256 _amount) external {

        require(_tokenAddy != address(this), "Owner can't claim contract's balance of its own tokens");

        require(_amount > 0, "Amount should be greater than zero");

        require(_amount <= IBEP20(_tokenAddy).balanceOf(address(this)), "Insufficient Amount");

        IBEP20(_tokenAddy).transfer(owner(), _amount);

    }



    function burnERC20(address _tokenAdd, uint256 _amount) external onlyOwner {

       require(_amount > 0, "Amount should be greater than zero");

        IBEP20(_tokenAdd).transfer(deadWallet, _amount);

    }



    // fallbacks

    receive() external payable {}

}

Vulnerability type: CWE-664|CWE-404|CWE-772