Ethereum insecure

Октябрь 2, 2012

Jule

4 comments

ethereum insecure

They are written in programming languages like Solidity and are executed by the Ethereum Virtual Machine (EVM). Since these contracts are. Passwords like this are insecure because they are prone to a simple hacking technique known as a dictionary attack. Example of a weak password. Another major cause of the proliferation of insecure smart contracts is that the documentation of known vulnerabilities is scattered through several sources. GAINS PERCENT ETHEREUM

At the time of the tweet, hackers had managed to make off with 3. Someone tries to make quick money by scanning port , looking for geth clients and stealing their cryptocurrency good thing geth by default only listens on local port. So far it has only got 3.

The same wallet address shows an average transaction amount of as much as 7 ETH. Remember this old twitter we posted? Guess how much these guys have in their wallets? And, the transaction is visible to each node in the transaction pool, so its execution order can be observed. Figure 4 Transaction order dependence attack. The attacker observes the transactions that may contain the target contract in the pool.

If they exist, the status of the contract that is not conducive to the attacker or the authority of the contract will be modified by the attacker. Attackers can also steal transaction data, create their own transactions at a higher gas price, and then package their own transactions in the block before the original transaction, thus obtaining transaction processing priority.

In Ethereum geth client, txpool consists of two parts, namely, pending queue and queued queue. Attacks of Contract Layer As an indispensable part of blockchain technology, smart contract not only expands the application of blockchain technology but also increases the attack surface faced by the blockchain system. The smart contract is written in a high-level language like solidity, and then the contract will be compiled into bytecode, which will be deployed to the blockchain by the contract owner and run on various virtual machines similar to Ethereum virtual machines.

In the process, the smart contract will face various security threats [ 31 ]. Integer Overflow Attack Integer overflow is a typical loophole in the blockchain system, which once caused serious economic losses in the development of blockchain. In the Ethereum platform, Solidity language is the most mainstream language for writing intelligent contracts. Because of the insecurity of its design, integer overflow is a serious problem.

Generally speaking, integer overflow can be divided into integer overflow and integer underflow. According to arithmetic classification, there are three overflow problems: multiplication overflow, addition overflow, and subtraction overflow. In April , nearly RMB 6 billion was stolen by hackers due to integer overflow loopholes in the contract code of the American Chain BEC project, which reduced the market value of tokens to almost zero.

In the same month, hackers used the integer overflow vulnerability of SMT project side to create a huge amount of SMT currency for selling, and the Firecoin Exchange suspended the recharge and withdrawal of all other currencies for this purpose.

In Solidity, the variable supports unsigned integers, and the value after uint represents the number of bits occupied by its unsigned integers in storage, and supports 8-bit unsigned integers to bit unsigned integers. An unsigned integer of type uint8 stored in the range of 0 to , that is, [0, ], and an unsigned integer of type uint stored in the range of 0 to.

Because the range of stored integers from uint8 to uint is limited, and the range of represented integers is also limited, there is an overflow problem. The integer overflow attack is shown in Figure 5. When , it results in an underflow. Figure 5 Integer Overflow attack. Re-Entrancy Attack Re-entrancy attack is a typical attack in Ethereum, which directly led to the hard bifurcation of Ethereum. The main reason for the attack is the sequencing and atomicity of updating smart contract variables and transferring operations, the re-entrancy attack is shown in Figure 6.

When the logic in the smart contract code adopts the sequence of transferring operation first and then modifying the variable value, the attacker can construct a smart contract with the malicious callback function. If the object of the transfer operation is a malicious contract, it can lead to recursively calling the contract, destroying the original business logic of the contract, and bypassing its inspection to obtain additional transfer income.

Figure 6 Re-entrancy attack. By default, the Ethereum smart contract has an unnamed callback function, which has no parameters or return values. If no function can be found in the calling contract to match the hash of the provided function, the callback function will be called. When the contract receives a transfer without data, it will also call the callback function. In addition, in order to receive Ether, the callback function must be marked as payable. If it is not marked as payable, the contract can only receive Ether by calling other functions marked with payable.

Imagine such a scenario, if a special callback function is constructed, in which the transfer function of the other party is called, then a recursive transfer will be generated, and the contract with loopholes will continuously transfer money to the special contract until the gas is exhausted.

It should be noted that this attack is only aimed at the transfer method of address. Honeypot Attack Honeypot contracts are the most interesting findings. These contracts hold ether, and pretend to do so insecurely. In short, they are scam contracts that try to fool us into thinking we can steal the ether they hold, while in fact all we can do is lose ether.

As Figure 7 shows, CryptoRoulette is a type of honeypot attack. The submitted number is stored in the second location. A common pattern they follow is, in order to win the ether they hold, we must send them some ether of our own first. However, if we try that, we are in for a nasty surprise: the smart contract eats up our ether, and we find out that the smart contract does not do what we thought it would.

Figure 7 Honeypot attack. Short Url Attack Short url attack is a typical attack in Ethereum, which usually occurs in exchanges. In Ethereum virtual machine, the data end of the input will be automatically filled with 0. Malicious attackers can use an address account with the end of 0, and the exchange fails to verify the address length input by the user, which causes the transferred related variables to shift and enlarge, thus expanding the actual transfer amount by several times, and malicious attackers can obtain a large amount of benefits.

There are two main reasons for this vulnerability; one is that the exchange has not verified the incoming address length of the user, and the other is that the Ethereum virtual machine has an automatic completion mechanism for the data whose length does not conform to the specification when calling the smart contract, resulting in the shift amplification of parameters. We can use sendRawTransaction to achieve this attack and the code is shown in Figure 8.

Figure 8 Short URL attack. Airdrop Hunting Attack The airdrop hunting attack uses multiple new accounts to call the airdrop function in order to obtain airdrop coins, and attackers transfer them to their account to achieve wealth accumulation.

This attack is relatively common that as long as it is a contract with an airdrop function, it can make multiple profits. The first automated attack was the Simoleon contract. As Figure 9 shows, the contract was designed to give some amount of ether to initialized an account, so the attacker thinks that we can create a few more accounts to get rewards, then transfer all the money to one account.

The attacker write attack the contract and create many temporary contracts, and call this function in these contracts. Figure 9 Airdrop hunting attack. Writing of Arbitrary Storage Address Attack The attack of arbitrary memory address writing is a common and harmful attack in the blockchain system. The attack can cause malicious users to write and overwrite any storage variable in the smart contract.

In Ethereum, the state variables of intelligent contracts will be stored in the storage area, which is an important and open contract storage space. Generally speaking, contract developers will set strict access control to the global variables stored in the storage area to ensure the security of contracts. Storage key-value pair mapping is used to store data.

If the user can arbitrarily control the key value of storage when writing, he or she can modify any storage variable value, so as to avoid all the related detection operations in the contract that uses the state variable value to check the authority, and thus achieve the purpose of improving the authority. In addition, because the attacker can use this vulnerability to destroy the contract storage structure, and perform any variable overwriting operation, such as overwriting the value of the state variable storing the address of the contract owner, this may cause abnormal execution of contract functions, freezing of funds, and other hazards.

Since the required guard is invalid, the contract owner can try to underflow the array size by executing the code of Figure 10 when the array length bonusCodes is 0. Therefore, we can write to any location in the storage arbitrarily. Figure 10 Writing of arbitrary storage address attack. Attacks of Network Layer The network layer is the most basic technical architecture in the blockchain system.

But these features also provide convenience for attackers who can easily launch a DoS attack. The purpose of the attack is to make users temporarily or permanently unable to use these services provided by the smart contract. Gas Exhaustion Denial of Service Attack According to the design of Ethereum, when the smart contract is deployed or the function in the smart contract is called, the execution of the contract code needs a certain amount of gas to ensure that the calculation is completed completely.

At the same time, the Ethereum system limits the maximum total amount of gas consumed by each block, and the total amount of gas of all transactions in the block cannot exceed the maximum total amount of gas in this block.

Once an operation in an intelligent contract consumes a lot of gas, resulting in the consumed gas value reaching the maximum total amount of gas in the block, the operation will not be successfully executed, and all processes depending on the operation will fail, so the contract cannot normally complete other functions, resulting in a denial of service state.

As Figure 11 shows, transferring money to everyone at once is likely to result in reaching the gas limit of ethereum blocks. Usually, this denial of service attack occurs when a contract developer does not consider the block gasLimit and introduces the operation of modifying dynamic data structure variables such as arrays whose size will change with time. After a block is mined, an attacker can issue multiple transactions at a higher gas price immediately, and then use the above operations of the contract to consume the gas limit of the whole block, so that the block does not contain any other transaction before a certain time, thus preventing other users from using the functions of the contract normally.

Figure 11 Gas exhaustion denial of service attack. Security Protection Schemes In this section, we propose the protection schemes against the ten attacks mentioned in the previous section. The details follow. Protection Schemes of the Application Layer We can prevent the replay attack in the following ways: 1 Avoiding using the transferProxy function and using a more secure signature method. The nonce generation algorithm does not adopt the design of self-increment from 0 to avoid the same value as other scenarios.

To prevent the false top-up attack, we judge not only transaction success but also whether the balance of the top-up wallet address increases accurately. This judgment can be made through the Event log. Many centralized exchanges, wallets, and other service platforms obtain the transfer amount and judge the accuracy of the transfer through Event logs.

However, we need to pay special attention to the evil situation of the smart contract, because the Event can be written arbitrarily, and it is not a mandatory default option that cannot be tampered with. The required and asserted methods can also be used that an exception will be thrown directly to interrupt the execution of the subsequent instructions of the contract when the conditions are not met.

The protection of transaction order dependence attack is a very complicated process. For the ERC20 transaction order dependence attack that happened once, it only needs the contract developers to pay attention to this problem and follow the best programming practices. For the attack scenario constructed in this example, this problem is not the problem of the contract developer, but the problem of the Ethereum system itself.

At present, the better solution is to confuse transactions, such as hiding transactions as internal transactions, and so on. Protection Schemes of Contract Layer For the problem of integer overflow, we can consider the results of each step by setting up a complete inspection mechanism, but this method is difficult and cumbersome, and it is not universal.

Therefore, OpenZeppelin provides SafeMath [ 32 ] in an intelligent contract function library, which can effectively prevent integer overflow. There are two ways to use the SafeMath library. The first one is to use the library functions directly, such as SafeMath. The other is that library functions can be called after using SafeMath for unit.

For example, a. For the protection of re-entrancy attack, the most fundamental solution is to update all the states that should be changed in advance before the transfer, instead of updating them after the transfer, which depends on the smart contract developers to follow the best practices. In addition, it is also an idea to use other transfer methods instead of the msg.

For the designed attack scenarios, we use these two methods to test them, respectively. In this way, the code re-entrancy attack is successfully prevented, and the protection scheme is effective. For the second scheme, we use the transfer function to replace the msg. The above two schemes can well prevent a re-entrancy attack, but the best scheme is the first one, which updates the status first and then transfers money. Honeypot contracts are diverse and unpredictable. For the CryptoRoulette attack, we can clearly use memory or storage for variables.

We can also use the new version of the compiler with version 0. Finally, we remind everyone that some people use Ethereum smart contracts to cheat. Because these creators spend for fees to create these contracts, they have a purpose that putting a certain amount of ether can get all the balance of the account, so it is definitely arbitrage. Publishing the source code on Github also uses various tricks to make people not find loopholes in a short time, thus encouraging users to enter the trap.

Short url attack protection only needs the exchange to increase the address length check at the client. In addition, for contract developers, the web3 interface used has already fixed the vulnerability. When users call the contract with web3, if they find that the data length is insufficient, they will not add 0 at the end, but add 0 at the beginning of the field, which effectively prevents the short url attack.

In a word, the protection of this vulnerability mainly depends on two parts, one is that the client actively checks the address length, the other is that the parameter format check is added at the web3 level. Although this vulnerability can be reproduced at the virtual machine level of Ethereum, there will be no problem in the actual application scenario of the blockchain. To prevent an airdrop hunting attack, we can set permission control for the airdrop function. For example, only the contract creator can distribute tokens to target addresses.

Or only externally owned accounts can receive airdrop rewards, and contract accounts cannot participate. For any memory address write attack, this attack is rare, and it is often the result of many factors. Therefore, the protection of this attack can be achieved by the contract developers following the best practices. In the development of contracts, developers need to pay attention to dynamic arrays.

Errors in the processing of dynamic arrays may lead to contract loop-holes in an unobvious way. Therefore, in unnecessary cases, dynamic array is not used, which can effectively avoid this attack. Protection Schemes of the Network Layer Gas exhaustion denial of service attack protection also depends on the best practices of contract developers.

The size of the gas consumed by different instructions is not certain. By debugging the attack scenario, it is found that the sload instruction was executed in the loop, consuming gas. However, the operation with high gas consumption is usually to operate the data in the storage area, so the contract developer should try not to operate the data in the storage area in the loop. Besides, we can also add an end mark of the loop in the execution.

Program Evaluation 6. The server is running with Ubuntu Smart contracts are written by Solidity programming language. Experiment Processes Based on the above configuration, we implemented ten defense methods as mentioned in the previous section. To analyze their efficiency, we tested time cost of 50, , , , , and transactions. The experimental results are shown in Figure Figure 12 Time cost with different protection schemes.

Ethereum insecure cbs sports phone number

INFOND FOREX BROKER

AES this has a bit key, no known purely cryptanalytic attack better than brute force, and is thus much better than the password. CTR mode: with AES's bit block, the only way key-stream reuse could kick in would be a bad random number generator for the IV see 6 The size of the plaintext can be effortlessly deduced from the size of the ciphertext.

This is explicitly not a theoretical weakness of encryption, since length is excluded from what a cipher is supposed to hide about plaintext. However, that can be a practical weakness. Say analysis of ciphertext concludes that it is octets; and there exists, somewhere in the prosecution's exhibits a file with exactly that size, demonstrably predating search and seizure of the ciphertext, and which mere detention is illegal.

Lack of detection of intentional or accidental ciphertext alterations, corresponding to predictable alteration in the plaintext: again this is explicitly not a theoretical weakness of encryption, but can allow some attacks if the adversary can alter the ciphertext example: if the plaintext is an executable or PDF with a known fraction, that can allow changing what the executable does to about anything, or make the PDF display as about anything.

Random number generator: if this is bad, or worse gets more or less stuck obligatory XKCD and Dilbert which turn to reality all too often , that would enable recovering plaintext in many scenarios, including repeatedly enciphering different English text or email addresses with the same password.

A side channel, that is broadly speaking unforeseen or unmitigated leak of information in the implementation or usage context. Anything you can own can be represented, traded and put to use as non-fungible tokens NFTs. You can tokenise your art and get royalties automatically every time it's re-sold.

Or use a token for something you own to take out a loan. The possibilities are growing all the time. More on NFTs An open internet Today, we gain access to 'free' internet services by giving up control of our personal data. Ethereum services are open by default — you just need a wallet.

These are free and easy to set up, controlled by you, and work without any personal info.