Question 1

What is the difference between Keccak-256 and SHA-3-256?

Accepted Answer

Keccak-256 and SHA-3-256 use the same Keccak sponge construction but differ in one padding bit added during NIST standardization in 2012. The padding byte changed from 0x01 (original Keccak) to 0x06 (FIPS SHA-3). Both accept the same input size and produce a 256-bit output — but they hash every input differently. Ethereum, Solidity's keccak256(), address derivation, storage slot hashing, CREATE2, and EIP-712 all use the pre-NIST Keccak-256 (0x01 padding). Python's hashlib.sha3_256 and Node's crypto.createHash('sha3-256') use FIPS SHA-3-256 (0x06 padding). If you compute a hash with a standard library and it does not match what Solidity produces, this is why.

Question 2

How do I compute an Ethereum function selector with this tool?

Accepted Answer

Switch to the 'function signature' input mode, then type the canonical signature without spaces: for example transfer(address,uint256). The tool computes the Keccak-256 hash of that UTF-8 string and returns both the full 32-byte hash and the first 4 bytes — the function selector. Solidity uses the first 4 bytes of keccak256(functionSignature) to route calldata to the correct function. The selector for transfer(address,uint256) is 0xa9059cbb.

Question 3

Does this tool send my input to a server?

Accepted Answer

No. The Keccak-256 permutation runs inside js-sha3@0.9.3, which loads once from the jsDelivr CDN on page open and then runs entirely in your browser's JavaScript engine. Nothing you type or paste is transmitted anywhere. To verify: open DevTools (F12), click Network, then paste any input and click Compute hash — zero additional network requests fire after the initial page load. This matters for smart contract security audits where you may be hashing private keys, seeds, or internal function signatures.

Question 4

What is the difference between the text input mode and the hex bytes mode?

Accepted Answer

Text input mode UTF-8 encodes your string before hashing — this matches Solidity's keccak256(abi.encodePacked('string')). Hex bytes mode treats your input as raw bytes in hexadecimal notation (e.g. 0x1234abcd or 1234abcd) and hashes those bytes directly without any encoding. Use hex bytes mode when you are hashing raw ABI-encoded calldata, packed struct fields, or any input where the byte representation matters rather than the string representation.

Question 5

Why does my hash not match what Solidity's keccak256() produces?

Accepted Answer

The three most common causes are: (1) You are using a SHA-3 library that implements FIPS SHA-3-256 instead of Keccak-256 — they look identical but differ in padding. This tool always uses pre-NIST Keccak-256. (2) Your input encoding differs — Solidity's keccak256(abi.encodePacked('hello')) hashes the UTF-8 bytes of 'hello', not a hex string or a zero-padded 32-byte word. Make sure you are hashing the same bytes. (3) ABI encoding adds padding — keccak256(abi.encode('hello')) zero-pads the string to 32 bytes before hashing, producing a different result than keccak256(abi.encodePacked('hello')).

Question 6

Where does Ethereum use Keccak-256 in practice?

Accepted Answer

Keccak-256 is used throughout the Ethereum protocol: deriving contract addresses from deployer address and nonce, function selectors (first 4 bytes of the hash of the canonical function signature), event topic IDs (full 32-byte hash of the event signature), storage slot derivation for mappings (keccak256(key . slot)), the CREATE2 opcode address determinism formula, and the EIP-712 typed structured data signing scheme. Solidity's keccak256() built-in exposes the same primitive for smart contract logic.

Algorithm	Padding byte	Used by	Hash of empty string
Keccak-256	0x01	Ethereum (`keccak256()`), Solidity, address derivation, storage slot hashing, CREATE2, EIP-712	c5d24601...
FIPS SHA-3-256	0x06	NIST standard, most crypto libraries (`hashlib.sha3_256` in Python, `crypto.createHash('sha3-256')` in Node), most online SHA-3 tools	a7ffc6f8...

Use case	How Keccak-256 is used	Example
Function selectors	First 4 bytes of `keccak256(functionSignature)`	`transfer(address,uint256)` → `0xa9059cbb`
Event topic IDs	Full 32-byte hash of the event signature	`Transfer(address,address,uint256)` → `0xddf252ad...`
Ethereum addresses	Last 20 bytes of `keccak256(publicKey)`	The last step of deriving an EOA address from a secp256k1 public key
Storage slot hashing	`keccak256(abi.encode(key, slot))` for mappings	EVM uses this to locate a mapping value; Foundry's `cast storage` uses the same formula
CREATE2 address	`keccak256(0xff ++ deployer ++ salt ++ keccak256(initcode))`	Predetermines a contract's address before deployment
EIP-712 typed data	Hashes struct types and values for structured signing	`keccak256(encodeType(typeHash))` for each type in the struct

Keccak-256 Hash Tool — the one Ethereum uses

All hashing happens in your browser.

Why your SHA-3 library gives the wrong answer for Ethereum.

Where Keccak-256 shows up in Ethereum development