HIGH severity: ST - Stops Transactions. The owner can enable transactions for all users, but once enabled, they cannot be disabled again.

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



//Social: https://linktr.ee/starlinksatire



//Buy fee: %5

//Sell fee: %5

//Transfer Fee: %0

//Owner can't change fees

//Owner can't stop trade

//Owner can't blacklist anyone

//There is no max or min limit in transaction count

//Developed By DiSpectra Finance Technologies | contact@dispectra.com | t.me/dispectranetwork

//Contract Revision 7cGcU874 - By AgentWo.sh



pragma solidity ^0.8.17;



abstract contract Context {

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

        return msg.sender;

    }



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

        return msg.data;

    }

}





pragma solidity ^0.8.0;



abstract contract Ownable is Context {

    address private _owner;



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



    constructor() {

        _transferOwnership(_msgSender());

    }



    modifier onlyOwner() {

        _checkOwner();

        _;

    }



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

        return _owner;

    }



    function _checkOwner() internal view virtual {

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

    }



    function renounceOwnership() public virtual onlyOwner {

        _transferOwnership(address(0));

    }



    function transferOwnership(address newOwner) public virtual onlyOwner {

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

        _transferOwnership(newOwner);

    }



    function _transferOwnership(address newOwner) internal virtual {

        address oldOwner = _owner;

        _owner = newOwner;

        emit OwnershipTransferred(oldOwner, newOwner);

    }

}





pragma solidity ^0.8.0;



interface IERC20 {

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

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

    function totalSupply() external view returns (uint256);

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

    function transfer(address to, 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 from,

        address to,

        uint256 amount

    ) external returns (bool);

}





pragma solidity ^0.8.0;



interface IERC20Metadata is IERC20 {

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

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

    function decimals() external view returns (uint8);

}





pragma solidity ^0.8.0;



contract ERC20 is Context, IERC20, IERC20Metadata {

    mapping(address => uint256) private _balances;

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



    uint256 private _totalSupply;

    address public pairAddress;

    bool public tradeEnabled = false;

    uint256 btax = 5; // Buy tax definition

    uint256 stax = 5; // Sell tax definition

    address public _owner;



    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 to, uint256 amount) public virtual override returns (bool) {

        address owner = _msgSender();

        _transfer(owner, to, 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) {

        address owner = _msgSender();

        _approve(owner, spender, amount);

        return true;

    }



    function transferFrom(

        address from,

        address to,

        uint256 amount

    ) public virtual override returns (bool) {

        address spender = _msgSender();

        _spendAllowance(from, spender, amount);

       _transfer(from, to, amount);

        return true;

    }



    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {

        address owner = _msgSender();

        _approve(owner, spender, allowance(owner, spender) + addedValue);

        return true;

    }



    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {

        address owner = _msgSender();

        uint256 currentAllowance = allowance(owner, spender);

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

        unchecked {

            _approve(owner, spender, currentAllowance - subtractedValue);

        }



        return true;

    }



    function _transfer(

        address from,

        address to,

        uint256 amount

    ) internal virtual {

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

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



        _beforeTokenTransfer(from, to, amount);



        uint256 fromBalance = _balances[from];

        uint256 buyTax = amount * btax / 100;

        uint256 sellTax = amount * stax / 100;

        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");

        unchecked {

            if (from == pairAddress) {

                if (tradeEnabled == true || msg.sender == _owner) {

                    _balances[from] = fromBalance - amount;

                    _balances[to] += amount - buyTax;

                    _balances[address(this)] += buyTax;

                } else {

                    revert("Trade is not opened");

                }

            } else if (to == pairAddress) {

                if (tradeEnabled == true || msg.sender == _owner) {

                    _balances[from] = fromBalance - amount;

                    _balances[to] += amount - sellTax;

                    _balances[address(this)] += sellTax;

                } else {

                    revert("Trade is not opened");

                }

            }

            else {

                _balances[from] = fromBalance - amount;

                _balances[to] += amount;

            }

        }



        emit Transfer(from, to, amount);



        _afterTokenTransfer(from, to, amount);

    }



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

        require(account != address(0), "ERC20: mint to the zero address");



        _beforeTokenTransfer(address(0), account, amount);



        _totalSupply += amount;

        unchecked {

            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.

            _balances[account] += amount;

        }

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



        _afterTokenTransfer(address(0), account, amount);

    }



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

        require(account != address(0), "ERC20: burn from the zero address");



        _beforeTokenTransfer(account, address(0), amount);



        uint256 accountBalance = _balances[account];

        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");

        unchecked {

            _balances[account] = accountBalance - amount;

            _totalSupply -= amount;

        }



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



        _afterTokenTransfer(account, address(0), amount);

    }



    function _approve(

        address owner,

        address spender,

        uint256 amount

    ) internal virtual {

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

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



        _allowances[owner][spender] = amount;

        emit Approval(owner, spender, amount);

    }



    function _spendAllowance(

        address owner,

        address spender,

        uint256 amount

    ) internal virtual {

        uint256 currentAllowance = allowance(owner, spender);

        if (currentAllowance != type(uint256).max) {

            require(currentAllowance >= amount, "ERC20: insufficient allowance");

            unchecked {

                _approve(owner, spender, currentAllowance - amount);

            }

        }

    }



    function _beforeTokenTransfer(

        address from,

        address to,

        uint256 amount

    ) internal virtual {}



    function _afterTokenTransfer(

        address from,

        address to,

        uint256 amount

    ) internal virtual {}

}





pragma solidity ^0.8.17;



contract StarlinkSatire_BEP20 is ERC20, Ownable {

    address public marketingWallet;

    uint256 maxSupply = 1000000000000;

    uint256 constant public buyTax = 5;

    uint256 constant public sellTax = 5;



    function openTrade() public onlyOwner {

        tradeEnabled = true;

    }



    function changePairAddress(address newPairAddress) onlyOwner public {

        pairAddress = newPairAddress; // Setting pair address for fee

    }



    function changeMarketingWallet(address newWallet) onlyOwner public {

        marketingWallet = newWallet;

    }



    function withdrawFee() public onlyOwner {

        _transfer(address(this), marketingWallet, balanceOf(address(this)));

    }



    constructor() ERC20("Starlink Satire", "STR") {

        _mint(msg.sender, maxSupply * 10 ** decimals());

    }

}

Vulnerability type: CWE-664