(StringComparer.OrdinalIgnoreCase);
foreach (var (name, value) in headers)
{
lookup.TryAdd(name, value);
}
if (!lookup.TryGetValue("webhook-id", out var messageId) ||
!lookup.TryGetValue("webhook-timestamp", out var timestamp) ||
!lookup.TryGetValue("webhook-signature", out var signatures))
{
return false; // unsigned request: not from Anthropic
}
if (!long.TryParse(timestamp, out var signedAt) ||
Math.Abs(DateTimeOffset.UtcNow.ToUnixTimeSeconds() - signedAt) > ToleranceSeconds)
{
return false; // replayed, or the clocks disagree
}
// Alfabeto base64 standard: un decoder URL-safe ricava byte della chiave errati.
var encodedKey = secret.StartsWith("whsec_") ? secret["whsec_".Length..] : secret;
byte[] key;
try
{
key = Convert.FromBase64String(encodedKey);
}
catch (FormatException)
{
return false; // misconfigured secret: reject rather than crash
}
byte[] payload = [.. Encoding.UTF8.GetBytes($"{messageId}.{timestamp}."), .. body];
var expected = Encoding.UTF8.GetBytes(
"v1," + Convert.ToBase64String(HMACSHA256.HashData(key, payload)));
// FixedTimeEquals è a tempo costante e restituisce false se le lunghezze non corrispondono.
return signatures.Split(' ', StringSplitOptions.RemoveEmptyEntries).Any(candidate =>
CryptographicOperations.FixedTimeEquals(Encoding.UTF8.GetBytes(candidate), expected));
}
}
```
```go Go
package hooks
import (
"crypto/hmac"
"crypto/sha256"
"encoding/base64"
"net/http"
"strconv"
"strings"
"time"
)
const toleranceSeconds = 300
// verify indica se body è stato firmato da Anthropic per questa organizzazione.
// net/http canonicalizza i nomi degli header alla ricerca, quindi i nomi con maiuscole diverse corrispondono comunque.
func verify(secret string, header http.Header, body []byte) bool {
messageID := header.Get("webhook-id")
timestamp := header.Get("webhook-timestamp")
signatures := header.Get("webhook-signature")
if messageID == "" || timestamp == "" || signatures == "" {
return false // unsigned request: not from Anthropic
}
signedAt, err := strconv.ParseInt(timestamp, 10, 64)
if err != nil {
return false
}
age := time.Now().Unix() - signedAt
if age > toleranceSeconds || age < -toleranceSeconds {
return false // replayed, or the clocks disagree
}
// Alfabeto base64 standard: un decoder URL-safe ricava byte della chiave errati.
key, err := base64.StdEncoding.DecodeString(strings.TrimPrefix(secret, "whsec_"))
if err != nil {
return false
}
mac := hmac.New(sha256.New, key)
mac.Write([]byte(messageID + "." + timestamp + "."))
mac.Write(body)
expected := "v1," + base64.StdEncoding.EncodeToString(mac.Sum(nil))
for _, candidate := range strings.Fields(signatures) {
if hmac.Equal([]byte(candidate), []byte(expected)) { // constant-time
return true
}
}
return false
}
```
```java Java
import java.nio.charset.StandardCharsets;
import java.security.GeneralSecurityException;
import java.security.MessageDigest;
import java.time.Instant;
import java.util.Base64;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
public final class InferenceHookVerifier {
private static final long TOLERANCE_SECONDS = 300;
/**
* Returns true if the body was signed by Anthropic for this organization.
*
* Anthropic sends header names in lowercase, but proxies are free to
* re-case them, so normalize the lookup to lowercase.
*/
public static boolean verify(String secret, Map headers, byte[] body) {
Map lowercased = new HashMap<>();
headers.forEach((name, value) -> lowercased.put(name.toLowerCase(Locale.ROOT), value));
String messageId = lowercased.get("webhook-id");
String timestamp = lowercased.get("webhook-timestamp");
String signatures = lowercased.get("webhook-signature");
if (messageId == null || timestamp == null || signatures == null) {
return false; // unsigned request: not from Anthropic
}
long signedAt;
try {
signedAt = Long.parseLong(timestamp);
} catch (NumberFormatException _) {
return false;
}
if (Math.abs(Instant.now().getEpochSecond() - signedAt) > TOLERANCE_SECONDS) {
return false; // replayed, or the clocks disagree
}
// Alfabeto base64 standard: un decoder URL-safe ricava byte della chiave errati.
byte[] key;
try {
key = Base64.getDecoder().decode(
secret.startsWith("whsec_") ? secret.substring("whsec_".length()) : secret);
} catch (IllegalArgumentException _) {
return false; // misconfigured secret: reject rather than crash
}
byte[] expected;
try {
Mac mac = Mac.getInstance("HmacSHA256");
mac.init(new SecretKeySpec(key, "HmacSHA256"));
mac.update((messageId + "." + timestamp + ".").getBytes(StandardCharsets.UTF_8));
expected = ("v1," + Base64.getEncoder().encodeToString(mac.doFinal(body)))
.getBytes(StandardCharsets.UTF_8);
} catch (GeneralSecurityException impossible) {
// Ogni JVM include HmacSHA256, quindi questo non si attiva mai a runtime.
throw new IllegalStateException(impossible);
}
for (String candidate : signatures.split(" ")) {
if (MessageDigest.isEqual(candidate.getBytes(StandardCharsets.UTF_8), expected)) {
return true; // MessageDigest.isEqual is constant-time
}
}
return false;
}
}
```
```php PHP
const TOLERANCE_SECONDS = 300;
/**
* Returns true if the body was signed by Anthropic for this organization.
*
* Anthropic sends header names in lowercase, but proxies are free to
* re-case them, so normalize the lookup to lowercase.
*/
function verify(string $secret, array $headers, string $body): bool
{
$lowercased = array_change_key_case($headers, CASE_LOWER);
$messageId = $lowercased['webhook-id'] ?? null;
$timestamp = $lowercased['webhook-timestamp'] ?? null;
$signatures = $lowercased['webhook-signature'] ?? null;
if ($messageId === null || $timestamp === null || $signatures === null) {
return false; // unsigned request: not from Anthropic
}
$signedAt = filter_var($timestamp, FILTER_VALIDATE_INT);
if ($signedAt === false || abs(time() - $signedAt) > TOLERANCE_SECONDS) {
return false; // replayed, or the clocks disagree
}
// Alfabeto base64 standard: un decoder URL-safe ricava byte della chiave errati.
$encodedKey = str_starts_with($secret, 'whsec_') ? substr($secret, strlen('whsec_')) : $secret;
$key = base64_decode($encodedKey, strict: true);
if ($key === false) {
return false;
}
$payload = "{$messageId}.{$timestamp}." . $body;
$expected = 'v1,' . base64_encode(hash_hmac('sha256', $payload, $key, binary: true));
foreach (explode(' ', $signatures) as $candidate) {
if (hash_equals($expected, $candidate)) { // constant-time
return true;
}
}
return false;
}
```
```ruby Ruby
# base64 è una gem inclusa in Ruby 3.4: le app gestite da Bundler aggiungono gem "base64".
require "base64"
require "openssl"
TOLERANCE_SECONDS = 300
# Restituisce true se il corpo è stato firmato da Anthropic per questa organizzazione.
#
# Anthropic invia i nomi degli header in minuscolo, ma i proxy sono liberi di
# modificarne le maiuscole, quindi normalizza la ricerca in minuscolo.
def verify(secret, headers, body)
lowercased = headers.transform_keys(&:downcase)
message_id = lowercased["webhook-id"]
timestamp = lowercased["webhook-timestamp"]
signatures = lowercased["webhook-signature"]
if message_id.nil? || timestamp.nil? || signatures.nil?
return false # unsigned request: not from Anthropic
end
signed_at = Integer(timestamp, exception: false)
if signed_at.nil? || (Time.now.to_i - signed_at).abs > TOLERANCE_SECONDS
return false # replayed, or the clocks disagree
end
# Alfabeto base64 standard: un decoder URL-safe ricava byte della chiave errati.
begin
key = Base64.strict_decode64(secret.delete_prefix("whsec_"))
rescue ArgumentError
return false # misconfigured secret: reject rather than crash
end
# Passa il corpo separatamente così la sua codifica non deve mai corrispondere a quella del prefisso.
hmac = OpenSSL::HMAC.new(key, "SHA256")
hmac.update("#{message_id}.#{timestamp}.")
hmac.update(body)
expected = "v1," + Base64.strict_encode64(hmac.digest)
signatures.split(" ").any? do |candidate|
# fixed_length_secure_compare solleva un errore se le lunghezze differiscono, quindi verificale prima.
candidate.bytesize == expected.bytesize &&
OpenSSL.fixed_length_secure_compare(candidate, expected)
end
end
```