Verify requests from SRE Agent

SRE-Agent-Signature: v=1,kid=k_0123456789abcdef,t=1791640800,n=AAECAwQFBgcICQoLDA0ODw,b=e3b0c442...b855,s=TsDE9NBF...NOUU

sre-agent-request-v1
<kid>
<t>
<n>
<METHOD>
<host>
<path>
<query>
<b>

{
  "key": "srsk_AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8",
  "kid": "k_0123456789abcdef",
  "t": 1791640800,
  "vectors": [
    {
      "method": "GET",
      "host": "metrics.example.com",
      "target": "/api/v1/query?query=up&time=1791640800",
      "body": "",
      "header": "v=1,kid=k_0123456789abcdef,t=1791640800,n=AAECAwQFBgcICQoLDA0ODw,b=e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855,s=TsDE9NBFTh9ura4IkxD-gbsIsCut3jnuFwSJ8WkNOUU"
    },
    {
      "method": "POST",
      "host": "hooks.example.com",
      "target": "/sre-agent/alerts",
      "body": "{\"title\":\"disk full\"}",
      "header": "v=1,kid=k_0123456789abcdef,t=1791640800,n=AAECAwQFBgcICQoLDA0ODw,b=09685eb9c86df7299c4afd343fd9c72526b5ba687bce89f5fb786cb4e5770b6d,s=w55dXwxb7qxn5dtqqhOHYIY702oUTFrvLPKC2psThKk"
    }
  ]
}

import crypto from "node:crypto";

// kid -> key, from Settings → Request signing. Keep the old kid during a rotation.
const KEYS = { k_0123456789abcdef: process.env.SRE_AGENT_SIGNING_KEY };
const WINDOW_SECONDS = 300;

export function verifySreAgent({ method, host, target, header, body, now = Date.now() / 1000 }) {
  if (typeof header !== "string") return { ok: false, reason: "missing" };
  const f = {};
  for (const part of header.split(",")) {
    const i = part.indexOf("=");
    if (i > 0) f[part.slice(0, i).trim()] = part.slice(i + 1).trim();
  }
  if (f.v !== "1") return { ok: false, reason: "unsupported_version" };
  const key = Object.hasOwn(KEYS, f.kid) ? KEYS[f.kid] : undefined;
  if (!key) return { ok: false, reason: "unknown_key" };
  if (!/^[0-9]{1,12}$/.test(f.t ?? "") || Math.abs(now - Number(f.t)) > WINDOW_SECONDS)
    return { ok: false, reason: "stale" };
  const q = target.indexOf("?");
  const path = q === -1 ? target : target.slice(0, q);
  const query = q === -1 ? "" : target.slice(q + 1);
  const canonical = ["sre-agent-request-v1", f.kid, f.t, f.n, method.toUpperCase(),
    host.toLowerCase(), path, query, f.b].join("\n");
  const expected = crypto.createHmac("sha256", key).update(canonical, "utf8").digest();
  const given = Buffer.from(f.s ?? "", "base64url");
  if (given.length !== expected.length || !crypto.timingSafeEqual(given, expected))
    return { ok: false, reason: "bad_signature" };
  if (body !== undefined && crypto.createHash("sha256").update(body).digest("hex") !== f.b)
    return { ok: false, reason: "body_mismatch" };
  return { ok: true, kid: f.kid, nonce: f.n };
}
// verifySreAgent({ method: req.method, host: req.headers.host, target: req.originalUrl,
//                  header: req.headers["sre-agent-signature"], body: rawBodyBuffer })

import base64, hashlib, hmac, re, time

KEYS = {"k_0123456789abcdef": "srsk_..."}  # kid -> key from Settings
WINDOW_SECONDS = 300


def verify_sre_agent(method, host, target, header, body=None, now=None):
    if not header:
        return False, "missing"
    f = {}
    for part in header.split(","):
        k, sep, v = part.partition("=")
        if sep:
            f[k.strip()] = v.strip()
    if f.get("v") != "1":
        return False, "unsupported_version"
    key = KEYS.get(f.get("kid", ""))
    if key is None:
        return False, "unknown_key"
    t = f.get("t", "")
    now = time.time() if now is None else now
    if not re.fullmatch(r"[0-9]{1,12}", t) or abs(now - int(t)) > WINDOW_SECONDS:
        return False, "stale"
    path, _, query = target.partition("?")
    canonical = "\n".join(["sre-agent-request-v1", f["kid"], t, f.get("n", ""), method.upper(),
                           host.lower(), path, query, f.get("b", "")])
    expected = hmac.new(key.encode(), canonical.encode(), hashlib.sha256).digest()
    s = f.get("s", "")
    try:
        given = base64.urlsafe_b64decode(s + "=" * (-len(s) % 4))
    except ValueError:
        return False, "bad_signature"
    if not hmac.compare_digest(given, expected):
        return False, "bad_signature"
    if body is not None and hashlib.sha256(body).hexdigest() != f.get("b"):
        return False, "body_mismatch"
    return True, f["kid"]

package sreagent

import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/base64"
	"encoding/hex"
	"errors"
	"regexp"
	"strconv"
	"strings"
	"time"
)

// WindowSeconds is how far the request time may be from now, either way.
const WindowSeconds = 300

var timePattern = regexp.MustCompile(`^[0-9]{1,12}$`)

// Verify checks an SRE-Agent-Signature header. keys maps a kid to its key, both from
// Settings, Request signing; keep the old kid during a rotation. target is the request
// target as received (path and query); pass a nil body when this hop cannot read it,
// and check the body digest where it can.
func Verify(keys map[string]string, method, host, target, header string, body []byte, now time.Time) (string, error) {
	if header == "" {
		return "", errors.New("missing")
	}
	f := map[string]string{}
	for _, part := range strings.Split(header, ",") {
		if k, v, ok := strings.Cut(part, "="); ok {
			f[strings.TrimSpace(k)] = strings.TrimSpace(v)
		}
	}
	if f["v"] != "1" {
		return "", errors.New("unsupported_version")
	}
	key, ok := keys[f["kid"]]
	if !ok {
		return "", errors.New("unknown_key")
	}
	if !timePattern.MatchString(f["t"]) {
		return "", errors.New("stale")
	}
	t, _ := strconv.ParseInt(f["t"], 10, 64)
	if d := now.Unix() - t; d > WindowSeconds || d < -WindowSeconds {
		return "", errors.New("stale")
	}
	path, query, _ := strings.Cut(target, "?")
	canonical := strings.Join([]string{"sre-agent-request-v1", f["kid"], f["t"], f["n"],
		strings.ToUpper(method), strings.ToLower(host), path, query, f["b"]}, "\n")
	mac := hmac.New(sha256.New, []byte(key))
	mac.Write([]byte(canonical))
	given, err := base64.RawURLEncoding.DecodeString(f["s"])
	if err != nil || !hmac.Equal(given, mac.Sum(nil)) {
		return "", errors.New("bad_signature")
	}
	if body != nil {
		sum := sha256.Sum256(body)
		if hex.EncodeToString(sum[:]) != f["b"] {
			return "", errors.New("body_mismatch")
		}
	}
	return f["kid"], nil
}

import crypto from 'crypto';

const WINDOW_SECONDS = 300;

function keys(r) {
  const out = Object.create(null);
  for (const pair of (r.variables.sre_agent_keys || '').split(/\s+/)) {
    const i = pair.indexOf('=');
    if (i > 0) out[pair.slice(0, i)] = pair.slice(i + 1);
  }
  return out;
}

function equal(a, b) {
  if (a.length !== b.length) return false;
  let diff = 0;
  for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
  return diff === 0;
}

function verdict(r) {
  const header = r.headersIn['SRE-Agent-Signature'];
  if (!header) return 'missing';
  const f = {};
  header.split(',').forEach((part) => {
    const i = part.indexOf('=');
    if (i > 0) f[part.slice(0, i).trim()] = part.slice(i + 1).trim();
  });
  if (f.v !== '1') return 'unsupported_version';
  const key = keys(r)[f.kid];
  if (!key) return 'unknown_key';
  const now = Math.floor(Date.now() / 1000);
  if (!/^[0-9]{1,12}$/.test(f.t || '') || Math.abs(now - Number(f.t)) > WINDOW_SECONDS) return 'stale';
  const target = r.variables.request_uri;
  const q = target.indexOf('?');
  const path = q === -1 ? target : target.slice(0, q);
  const query = q === -1 ? '' : target.slice(q + 1);
  const canonical = ['sre-agent-request-v1', f.kid, f.t, f.n, r.method.toUpperCase(),
    (r.headersIn['Host'] || '').toLowerCase(), path, query, f.b].join('\n');
  const expected = crypto.createHmac('sha256', key).update(canonical).digest('base64url');
  return equal(expected, f.s || '') ? 'ok' : 'bad_signature';
}

export default { verdict };

import cf from 'cloudfront';
const crypto = require('crypto');

const kvs = cf.kvs();
const WINDOW_SECONDS = 300;

// cloudfront-js-2.0 refuses `for...of`, so every loop here uses an index.
function sign(key, f, request, query) {
  const canonical = ['sre-agent-request-v1', f.kid, f.t, f.n, request.method.toUpperCase(),
    request.headers.host.value.toLowerCase(), request.uri, query, f.b].join('\n');
  return crypto.createHmac('sha256', key).update(canonical).digest('base64url');
}

function equal(a, b) {
  if (a.length !== b.length) return false;
  let diff = 0;
  for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
  return diff === 0;
}

// CloudFront passes query values still percent-encoded, but it does not keep the order of
// different parameter names, so only a query with at most one name can be rebuilt exactly.
// Its values keep their order. An empty value may have been sent with or without "=".
function queries(querystring) {
  const names = Object.keys(querystring);
  if (names.length === 0) return [''];
  if (names.length > 1) return null;
  const entry = querystring[names[0]];
  const values = entry.multiValue ? entry.multiValue.map((m) => m.value) : [entry.value];
  const parts = [];
  for (let i = 0; i < values.length; i++) parts.push(names[0] + '=' + values[i]);
  return values.length === 1 && values[0] === '' ? [names[0] + '=', names[0]] : [parts.join('&')];
}

async function verify(request, nowSeconds) {
  const header = request.headers['sre-agent-signature'];
  if (!header) return 'missing';
  const f = {};
  const fields = header.value.split(',');
  for (let i = 0; i < fields.length; i++) {
    const at = fields[i].indexOf('=');
    if (at > 0) f[fields[i].slice(0, at).trim()] = fields[i].slice(at + 1).trim();
  }
  if (f.v !== '1') return 'unsupported_version';
  let key;
  try {
    key = await kvs.get(f.kid);
  } catch (e) {
    return 'unknown_key';
  }
  if (!/^[0-9]{1,12}$/.test(f.t || '') || Math.abs(nowSeconds - Number(f.t)) > WINDOW_SECONDS) return 'stale';
  const candidates = queries(request.querystring);
  if (candidates === null) return 'unverifiable_query';
  for (let i = 0; i < candidates.length; i++) {
    if (equal(sign(key, f, request, candidates[i]), f.s || '')) return 'ok';
  }
  return 'bad_signature';
}

async function handler(event) {
  const request = event.request;
  request.headers['x-sre-agent-verdict'] = { value: await verify(request, Math.floor(Date.now() / 1000)) };
  return request;
}