148
Ethereum uses KECCAK-256. It should be noted that it does not follow
the FIPS-202 based standard (a.k.a SHA-3), which was finalized in August 2015.
According to this, NIST changed the padding to SHA3-256(M) = KECCAK [512] (M || 01, 256).
This was different from the padding proposed by the Keccak team in The Keccak SHA-3 submission version 3 (final, winning ...
30
keccak256 (new alias for sha3) is cheapest.
Source: Yellow Paper
Appendix G mentions the gas cost of sha3 is:
30 gas + 6 gas for each word (rounded up) for input data to a SHA3 Keccak-256 operation.
Appendix E has the costs for the others.
sha256 (SHA2-256) costs:
60 gas + 12 gas for each word (rounded up) for input data to a SHA2-256 operation.
...
28
Jehan's answer is great, but we need to explain one more thing: Why does sha3(1) in solidity produce b10e2d...fa0cf6?
This is because solidity's sha3 function hashes its inputs based on the argument types. Thus the value 1 will generate a different hash if it is stored as bytes8, bytes16, bytes32, etc. Since sha3(1) is being passed 1 as a number literal, it ...
24
Ethereum uses Keccak-256, instead of the SHA-3 FIPS 202 standard. In the sha3 libraries you are using, try looking for the option to specify using Keccak-256.
For Python see Getting Method ID "Keccak hash" in Python
For Javascript, this library js-sha3 would involve using the keccak_256 function instead of sha3_256.
keccak_256('');
// ...
20
To make it clearer that Ethereum uses KECCAK-256 instead of the NIST standardized SHA-3 hash function, Solidity 0.4.3 has introduced keccak256. (It is an alias to sha3, meaning that keccak256 produces identical results to sha3, but with the intent to avoid confusion, especially for developers new to Ethereum.) It's recommended that new code use keccak256 ...
17
Like any hash, it has an infinite input space. This enables one to "make a hash" of a super large file where each input causes the internal state to scramble up some more. The hash should entirely change if a single bit of data in the source is different - unlike say a CRC32, or a checksum. It means your password could be a million chars long maybe....
16
topics[0] is the hash of the signature of the event.
Example from Solidity docs:
keccak256("Deposit(address,bytes32,uint256)") is the signature of the event:
event Deposit(
address indexed _from,
bytes32 indexed _id,
uint _value
);
15
Extending on this answer:
Ethereum uses Keccak hashing, which was submitted to the NIST competition for SHA3. It was subsequently selected as a winner in 2012, but the final standard was only released in August 2015.
Ethereum uses Keccak in its form as it was selected in 2012. Too bad some parameters of the algorithm were tweaked for the final ...
12
from an answer to What are the key differences between the draft SHA-3 standard and the Keccak submission?:
No they did not, the internals and security levels have not been
changed from the draft Keccak submission, only the padding rule has
changed.
The padding change is the only difference, this allows
future tree hashing modes as well as the ...
9
The function signatures need to be unique only within a contract. The Solidity compiler will detect and prevent collisions if they are not unique in this case. If you have fewer than 2^16 functions in your contract, collisions are unlikely to happen by chance.
There was a Reddit thread about this recently, but it seems a bit contrived to me and not a ...
9
Solidity use HEX values internally.
> web3.sha3(web3.toHex(1))
"5fe7f977e71dba2ea1a68e21057beebb9be2ac30c6410aa38d4f3fbe41dcffd2"
9
You can use web3.utils.soliditySha3()
Alternatively you can try this way:
web3.sha3(web3.utils.toHex(string1) + address1, {encoding:"hex"});
Note that address1 should not be prefixed with 0x.
Example:
> web3.sha3(web3.utils.toHex("test1") + "0AbdAce70D3790235af448C88547603b945604ea", {encoding:"hex"});
"...
8
Solidity's sha3 function hashes the byte representation of a uint. That is, the number in hex (base 16), padded to 32 bytes. 32 empty bytes in hex representation is 64 zeros.
To do this in JS, we can utilize the infamous left-pad package:
const jsHashWeb3 = web3.sha3(leftPad((1).toString(16), 64, 0), { encoding: 'hex' })
// ...
8
web3.sha3() takes an encoding parameter to specify that you are passing in a hex address:
address_string = '0x5b2063246f2191f18f2675cedb8b28102e957458';
web3.sha3(address_string, {encoding: 'hex'});
As a general side-note: you have to pay gas costs to do any custom work in Solidity so, when possible, you are best off working on the javascript side.
8
You can use our Firefly Hardware Wallet (https://firefly.city) for the ATmega328 to do:
secp256k1 signing
RLP decoding transactions
keccak256
generating checksum addresses (or raw addresses)
Signing requires in the neighbourhood of around 700 bytes of free memory, I believe, but everything else requires a fairly slim memory footprint.
If you require an ...
7
The arguments are expressed as bytes, left-padded with zeroes to the maximum length of the data type you've passed in, and concatenated without any kind of delimiter.
In Python, given two hex-encoded bytes32s prepended with a 0x called first and second, it looks something like:
# keccak, change before upgrading pysha >= 3.10
from sha3 import sha3_256
...
7
I believe this is just a bit mask.
The code loads the call data, shifts it to the right, and then does a bitwise AND with 0xFFFFFFFF to get the (now) bottom four bytes (the function selector).
Then it compares the four bytes extracted with the known function selector. It doesn't matter that the function signature you're looking for happens to be 0xFFFFFFFF....
6
You need to install the latest pyethereum; I just uploaded it as pyethereum 1.3.7, or from the state_revamp branch. That should also automatically install the latest pyrlp, which has one compatibility fix; if it doesn't then you can install it yourself from http://github.com/ethereum/pyrlp.
If you don't do this, then there are going to be a few bugs that ...
6
In your NodeJS you have to fix the input you are passing to its keccak function. The fix might simply be: keccak_256(firstName+lastName+ studentId); but you have to check your NodeJS library as well as the types you're passing in.
Solidity docs:
keccak256(...) returns (bytes32): compute the Ethereum-SHA-3
(Keccak-256) hash of the (tightly packed) ...
6
I came across this paper that looks at using Keccak-256 (the original one that Ethereum uses, not SHA3) as a PRNG. It subjects the output of the hash to a large number of tests of randomness and it passes them all.
Conclusion:
The experimental results show the KECCAK hash function has excellent
pseudo randomness, and its security shows that it can be ...
6
The function abi.encodePacked() only concatenates its input data in a bytes array in memory it doesn't transform the data in any way. So it is totaly safe to use in production code.
The function keccak256() is a cryptographic hash function. One of its properties is that is computationally hard to find a preimage, ie given king is in practice impossible to ...
6
A comparison between two bytes32 IS possible in solidity. Consider this simple contract:
pragma solidity 0.5.4;
contract Test {
bytes32 public constant bytes32_ = "Hello World!";
bytes32 public constant anotherBytes32 = "Hello World!";
function areTheyEqual() public pure returns(bool) {
return (bytes32_ == anotherBytes32);
}
}
...
5
keccak256 is available in Solidity 0.4.3 and later.
If you're using browser-solidity, Solidity 0.4.4 and later is needed: keccak256 Error Undeclared identifier in browser-solidity
5
A hash function is different to a proof-of-work algorithm. Much of the effort in following a proof-of-work algorithm involves making hashes, but they're distinct things.
Ethash is the proof-of-work algorithm. Keccak-256 is the most commonly-used hash function. Keccak-256 is used internally in places like when making hashes for block headers, but the place ...
5
With a recent (>=1.0) version of pysha3 you can recreate the method ID with:
from sha3 import keccak_256
sha3_hash = keccak_256("baz(uint32,bool)").hexdigest()
method_id = "0x"+sha3_hash[:8]
print method_id
If your pysha3 is old (eg pinned atpysha3==0.3) you need:
from sha3 import sha3_256
sha3_hash = sha3_256("baz(uint32,bool)").hexdigest()
method_id = "...
5
As mentioned by @jaime in the comments you need the position of the mapping variable to find the relation between address and storage key.
You can find a code I have written to detect the position for a basic erc20 contract below (using web3.py):
import json
from web3.auto.infura import w3
from eth_utils import remove_0x_prefix, to_int, ...
5
Yes, you are exactly correct, except for the empty string.
keccak256("") costs 30 gas.
keccak256("0") costs 36 gas.
keccak256("0123456789ABCDEF0123456789ABCDEF") still costs 36 gas.
keccak256("0123456789ABCDEF0123456789ABCDEF_") costs 42 gas.
These gas costs do not include costs other than the actual KECCAK256 opcode, such as pushing the pointer and ...
5
TLDR: Use address 0.
Depending on your definition of a private key, then yes or no. The public key is generated from the private key by scalar elliptic curve multiplication.
P = k * G
We know that the order of the generator G is
n = FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFE BAAEDCE6 AF48A03B BFD25E8C D0364141
and so every k in the range [0, n) gives a ...
5
Maybe you can use the online Ethereum IDE (Remix):
Paste the whole code of the address you posted.
Select the same compiler version: v0.4.25+commit.59dbf8f1.
Select the contract by name: SaiProxyCreateAndExecute.
Press on Compilation Details and check the functionHashes section. You will get something like the following:
{
"581f3c50": "createAndOpen(...
5
As far as I'm aware there is no SHA256 opcode. I tried finding one but couldn't find - not listed at least in, for example, this list: https://github.com/crytic/evm-opcodes
Maybe you're mixing it up with sha3 (keccak256)? It's a different algorithm.
So if you want to use SHA256 you need to call the precompiled contract. But if you're worried about gas ...
Only top voted, non community-wiki answers of a minimum length are eligible