シークレットを一定時間で比較する snippet

import crypto from 'node:crypto';

// webhook verify — hash to a FIXED 32 bytes, then compare:
function signatureValid(payload, receivedHex, secret) {
  const expected = crypto.createHmac('sha256', secret)
    .update(payload).digest();            // always 32 bytes
  const received = Buffer.from(receivedHex, 'hex');
  // timingSafeEqual THROWS on length mismatch — guard first:
  return expected.length === received.length &&
         crypto.timingSafeEqual(expected, received);
}

import { createHash, timingSafeEqual } from 'node:crypto';

// the wrapper every codebase should have exactly once:
export function fixedTimeEqual(a: Buffer, b: Buffer): boolean {
  return a.length === b.length && timingSafeEqual(a, b);
}

// strings arrive at arbitrary lengths — hash to 32 fixed bytes first:
export function tokensMatch(a: string, b: string): boolean {
  const sha256 = (s: string) => createHash('sha256').update(s).digest();
  return fixedTimeEqual(sha256(a), sha256(b));
}

import (
	"crypto/hmac"
	"crypto/sha256"
	"crypto/subtle"
)

// raw primitive: returns 1 (equal) or 0 (differ) — an int, not a bool:
func fixedTimeEqual(a, b []byte) bool {
	return subtle.ConstantTimeCompare(a, b) == 1
}

// webhook shape: the MAC is a fixed 32 bytes — hash, then compare:
func signatureValid(payload, received, secret []byte) bool {
	mac := hmac.New(sha256.New, secret)
	mac.Write(payload)
	return hmac.Equal(mac.Sum(nil), received)
}

use subtle::ConstantTimeEq;

fn fixed_time_equal(a: &[u8], b: &[u8]) -> bool {
    a.ct_eq(b).into() // Choice(1)/Choice(0) -> bool
}

// MAC check — the fixed 32-byte type makes equal lengths a compile-time fact:
fn mac_is_valid(computed: &[u8; 32], received: &[u8; 32]) -> bool {
    computed.ct_eq(received).into()
}

// hash_equals(known_string, user_string) — the stored secret goes FIRST:
$valid = hash_equals($storedToken, $tokenFromRequest);

// signatures arrive hex-encoded at unknown length — hash to fixed size:
$valid = hash_equals(
    hash_hmac('sha256', $payload, $secret),
    $receivedHex
);

import hmac

# compare_digest lives in hmac (hashlib re-exports it); str inputs must be ASCII:
valid = hmac.compare_digest(expected_hex, received_hex)

# webhook shape — HMAC to a fixed hex length, then compare:
digest = hmac.new(secret, payload, 'sha256').hexdigest()
valid = hmac.compare_digest(digest, signature_header)

using System.Security.Cryptography;

static bool FixedTimeEqual(byte[] a, byte[] b)
{
    return a.Length == b.Length
        && CryptographicOperations.FixedTimeEquals(a, b);
}

import java.security.MessageDigest;

static boolean signatureValid(byte[] expected, byte[] received) {
    return MessageDigest.isEqual(expected, received);
}

import CryptoKit

// Swift has NO stdlib constant-time compare — the honest fallback:
func fixedTimeEqual(_ a: [UInt8], _ b: [UInt8]) -> Bool {
    guard a.count == b.count else { return false }  // length is public
    var diff: UInt8 = 0
    for i in a.indices {
        diff |= a[i] ^ b[i]   // fold ALL bytes, decide once at the end
    }
    return diff == 0
}

// the MAC use-case — Apple ships the real thing:
let ok = HMAC<SHA256>.isValidAuthenticationCode(
    receivedMAC, authenticating: payload, using: key)

import java.security.MessageDigest
import java.util.HexFormat

fun signatureValid(expectedHex: String, receivedHex: String): Boolean =
    MessageDigest.isEqual(
        HexFormat.of().parseHex(expectedHex),  // hex string -> bytes (JDK 17+)
        HexFormat.of().parseHex(receivedHex),
    )

require 'openssl'

valid = OpenSSL.secure_compare(expected, received)

# Rails ships the same primitive under a longer name:
# require 'active_support/security_utils'
# valid = ActiveSupport::SecurityUtils.secure_compare(expected, received)

const std = @import("std");
const HmacSha256 = std.crypto.auth.hmac.sha2.HmacSha256;

fn signatureValid(payload: []const u8, received: [32]u8, key: []const u8) bool {
    var mac: [HmacSha256.mac_length]u8 = undefined; // fixed 32 bytes
    HmacSha256.create(&mac, payload, key);
    return std.crypto.timing_safe.eql([32]u8, mac, received);
}