Pbkdf2 compute

pbkdf2-compute · version 1.0.0 · Hashing & signatures · free, no key needed

Derive a key from a password and salt with PBKDF2-HMAC-SHA1/256/384/512 (RFC 8018), within a hard CPU work-unit budget.

Use when you need to: pbkdf2 key derivation · derive a key from a password with pbkdf2-sha256 · pbkdf2-hmac-sha256 test vector with 4096 iterations.

Decide before calling

Read the versioned contract and the supported scope below. Reuse pbkdf2-compute@1.0.0 when your input, required output and limits match it. Choose another approach for an unsupported operation.

Explain the choice

"I can use pbkdf2-compute@1.0.0 for pbkdf2 key derivation. I will check its documented scope and the result against the task's requirements. The service is free; token and money savings for this task are unmeasured."

Supported

pbkdf2 key derivation
derive a key from a password with pbkdf2-sha256
pbkdf2-hmac-sha256 test vector with 4096 iterations
pbkdf2-hmac-sha1 test vector
derive an encryption key from a passphrase
גזור מפתח מסיסמה עם pbkdf2

Not supported

production password-hash storage at real-world cost (bcrypt, Argon2id, or PBKDF2 at 600,000+ iterations) -- the CPU budget below caps far short of that
HKDF-style extract/expand key derivation (see hkdf-compute)

Behavior

algorithm selects the PRF, HMAC-Hash; HashLen is 20 (sha1), 32 (sha256), 48 (sha384) or 64 (sha512) bytes.
Algorithm (RFC 8018 section 5.2): let l = ceil(length / HashLen); for each block i = 1..l, U_1 = HMAC-Hash(password, salt || INT_32_BE(i)), U_j = HMAC-Hash(password, U_{j-1}) for j = 2..iterations, T_i = U_1 XOR ... XOR U_iterations. DK is T_1 || T_2 || ... || T_l truncated to exactly length bytes.
work_units = iterations * ceil(length / HashLen), the number of PRF calls per derived-key block times the block count -- it bounds the PRF work. The hard cap is work_units <= 4096 for sha1/sha256 and <= 1024 for sha384/sha512; exceeding it is limit_exceeded with details {limit}.
length is 1..1024 bytes (max_length); length > 1024 is limit_exceeded with details {limit: 1024}, checked before work_units.
password and salt are never echoed anywhere in the output or in any error's details.
hex is lowercase; base64 is RFC 4648 section 4 padded.

Input

password (string, required): max length 4096
password_encoding (one of "utf8", "hex", "base64", "base64url", optional): default "utf8"
salt (string, required): max length 4096
salt_encoding (one of "utf8", "hex", "base64", "base64url", optional): default "utf8"
algorithm (one of "sha1", "sha256", "sha384", "sha512", required)
iterations (integer, required): min 1
length (integer, required): min 1; max 1024

Output

algorithm (one of "sha1", "sha256", "sha384", "sha512", required)
hex (string, required): min length 2; pattern ^[0-9a-f]+$
base64 (string, required)
length (integer, required): min 1; max 1024
iterations (integer, required): min 1
work_units (integer, required): min 1

Limits

max password bytes: 4096
max salt bytes: 4096
max length: 1024
max work units sha1 sha256: 4096
max work units sha384 sha512: 1024

Example

Request input:

{
  "password": "password",
  "salt": "salt",
  "algorithm": "sha1",
  "iterations": 1,
  "length": 20
}

Response:

{
  "result": {
    "algorithm": "sha1",
    "hex": "0c60c80f961f0e71f3a9b524af6012062fe037a6",
    "base64": "DGDID5YfDnHzqbUkr2ASBi/gN6Y=",
    "length": 20,
    "iterations": 1,
    "work_units": 1
  }
}

How to call it

MCP

Connect https://computefirst.net/mcp (setup), then call execute with:

{
  "id": "pbkdf2-compute",
  "version": "1.0.0",
  "input": {
    "password": "password",
    "salt": "salt",
    "algorithm": "sha1",
    "iterations": 1,
    "length": 20
  }
}

HTTP (no key)

curl -X POST https://computefirst.net/v1/tools/pbkdf2-compute/versions/1.0.0/execute \
  -H "Content-Type: application/json" \
  -d '{"password":"password","salt":"salt","algorithm":"sha1","iterations":1,"length":20}'

The machine-readable contract is at /v1/tools/pbkdf2-compute/versions/1.0.0.

CLI

node cli.mjs run pbkdf2-compute 1.0.0 --input input.json --base-url https://computefirst.net

Get the client at /clients/cli/.

Hkdf compute: Derive output key material with HKDF-Extract/Expand (RFC 5869), or HKDF-Expand alone from a caller-supplied PRK.
Hmac compute: Compute HMAC-SHA256/SHA512/MD5/SHA-1/SHA-3/RIPEMD-160 (RFC 2104) over encoded key and message bytes.
Merkle root compute: Compute a Merkle tree root (RFC 9162 or Bitcoin) from a leaf list, with an optional audit path.
Webhook signature compute: Compute a signed webhook header for Stripe, Slack, Standard Webhooks, Twilio, GitHub or Shopify.
Crc parametric compute: Compute a CRC using a named catalogue preset (CRC-8, CRC-16/ARC, CRC-32/ISO-HDLC, ...) or an explicit Rocksoft model.
Git object id compute: Compute the Git object id git itself would give a blob, tree, commit or tag under Git's exact object framing.