Storage Format

wdk-cli/
├── config.json
├── daemon.pid
├── daemon.sock                 # macOS and Linux only
└── wallets/
    └── WALLET_NAME/
        └── seed.enc

wdk config path

{
  "version": 1,
  "salt": "64 hexadecimal characters",
  "iv": "24 hexadecimal characters",
  "tag": "32 hexadecimal characters",
  "ciphertext": "variable-length hexadecimal ciphertext"
}

import { createDecipheriv, scryptSync } from 'node:crypto'
import { readFile } from 'node:fs/promises'
import { emitKeypressEvents } from 'node:readline'
import process from 'node:process'

const SCRYPT = {
  N: 2 ** 16,
  r: 8,
  p: 1,
  maxmem: 128 * 1024 * 1024
}

function decodeHex(field, value, expectedBytes) {
  if (typeof value !== 'string' || value.length === 0) {
    throw new Error(`${field} must be a non-empty hexadecimal string`)
  }
  if (value.length % 2 !== 0 || !/^[0-9a-f]+$/i.test(value)) {
    throw new Error(`${field} is not valid hexadecimal`)
  }

  const decoded = Buffer.from(value, 'hex')
  if (decoded.length * 2 !== value.length) {
    throw new Error(`${field} is not valid hexadecimal`)
  }
  if (expectedBytes !== undefined && decoded.length !== expectedBytes) {
    throw new Error(`${field} must decode to ${expectedBytes} bytes`)
  }
  return decoded
}

function validatePayload(payload) {
  if (payload === null || typeof payload !== 'object' || Array.isArray(payload)) {
    throw new Error('seed.enc must contain a JSON object')
  }
  if (payload.version !== 1) {
    throw new Error(`unsupported seed.enc version: ${String(payload.version)}`)
  }

  return {
    salt: decodeHex('salt', payload.salt, 32),
    iv: decodeHex('iv', payload.iv, 12),
    tag: decodeHex('tag', payload.tag, 16),
    ciphertext: decodeHex('ciphertext', payload.ciphertext)
  }
}

function promptHidden(message) {
  if (!process.stdin.isTTY || !process.stdout.isTTY ||
      typeof process.stdin.setRawMode !== 'function') {
    throw new Error('run this script directly in a private interactive terminal')
  }

  emitKeypressEvents(process.stdin)
  const wasRaw = process.stdin.isRaw
  let secret = ''

  process.stdin.setRawMode(true)
  process.stdin.resume()

  return new Promise((resolve, reject) => {
    function finish(error) {
      process.stdin.removeListener('keypress', onKeypress)
      process.stdin.setRawMode(Boolean(wasRaw))
      if (!wasRaw) process.stdin.pause()
      process.stdout.write('\n')

      if (error) reject(error)
      else resolve(secret)
    }

    function onKeypress(text, key = {}) {
      if (key.ctrl && key.name === 'c') {
        finish(new Error('recovery cancelled'))
        return
      }
      if (key.name === 'return' || key.name === 'enter') {
        finish()
        return
      }
      if (key.name === 'backspace') {
        secret = secret.slice(0, -1)
        return
      }
      if (typeof text === 'string' && !key.ctrl && !key.meta &&
          !/[\u0000-\u001f\u007f]/.test(text)) {
        secret += text
      }
    }

    process.stdin.on('keypress', onKeypress)
    process.stdout.write(message)
  })
}

function writeOutput(chunk) {
  return new Promise((resolve, reject) => {
    process.stdout.write(chunk, (error) => {
      if (error) reject(error)
      else resolve()
    })
  })
}

async function main() {
  const args = process.argv.slice(2)
  if (args.length !== 1) {
    throw new Error('usage: node recover-wdk-seed.mjs /path/to/seed.enc')
  }

  const file = await readFile(args[0], 'utf8')
  let payload
  try {
    payload = JSON.parse(file)
  } catch {
    throw new Error('seed.enc is not valid JSON')
  }

  const { salt, iv, tag, ciphertext } = validatePayload(payload)
  const passphrase = await promptHidden('Passphrase: ')
  const key = scryptSync(passphrase, salt, 32, SCRYPT)
  let decryptedChunk
  let authenticatedTail
  let plaintext

  try {
    const decipher = createDecipheriv('aes-256-gcm', key, iv)
    decipher.setAuthTag(tag)
    decryptedChunk = decipher.update(ciphertext)
    authenticatedTail = decipher.final()
    plaintext = Buffer.concat([decryptedChunk, authenticatedTail])

    await writeOutput('Recovered seed phrase:\n')
    await writeOutput(plaintext)
    await writeOutput('\n')
  } finally {
    key.fill(0)
    decryptedChunk?.fill(0)
    authenticatedTail?.fill(0)
    plaintext?.fill(0)
  }
}

main().catch((error) => {
  console.error(`Recovery failed: ${error.message}`)
  process.exitCode = 1
})

chmod 700 recover-wdk-seed.mjs
node recover-wdk-seed.mjs "$HOME/.config/wdk-cli/wallets/WALLET_NAME/seed.enc"