Sealed results

import { createDecipheriv } from 'node:crypto'

const unseal = (sealed: string, key: string) => {
	const data = Buffer.from(sealed, 'base64')

	if (data[0] !== 1) {
		throw new Error('Unknown sealed result version')
	}

	const decipher = createDecipheriv('aes-256-gcm', Buffer.from(key, 'base64'), data.subarray(1, 13))
	decipher.setAuthTag(data.subarray(-16))

	return JSON.parse(Buffer.concat([decipher.update(data.subarray(13, -16)), decipher.final()]).toString())
}

import { unsealResult } from '@zeno-id/server'

// Throws a plain Error when the result was changed or sealed with another key.
const event = unsealResult(sealedResult, process.env.FP_ENCRYPTION_KEY!)

import base64
import json

from cryptography.hazmat.primitives.ciphers.aead import AESGCM

def unseal(sealed: str, key: str) -> dict:
    data = base64.b64decode(sealed)
    if data[0] != 1:
        raise ValueError("Unknown sealed result version")
    # cryptography wants the tag at the end of the ciphertext, which is how
    # it's laid out already: data[13:] is ciphertext and tag together.
    # Raises cryptography.exceptions.InvalidTag when anything was changed.
    plain = AESGCM(base64.b64decode(key)).decrypt(data[1:13], data[13:], None)
    return json.loads(plain)

function unseal(string $sealed, string $key): array
{
    $data = base64_decode($sealed, true);

    if ($data === false || strlen($data) < 30 || ord($data[0]) !== 1) {
        throw new RuntimeException('Not a sealed result of a known version');
    }

    // openssl_decrypt takes the tag on its own, and returns false, not an
    // exception, when anything was changed or another key sealed it.
    $json = openssl_decrypt(
        substr($data, 13, -16),       // ciphertext
        'aes-256-gcm',
        base64_decode($key, true),    // the 32 key bytes
        OPENSSL_RAW_DATA,
        substr($data, 1, 12),         // IV
        substr($data, -16),           // tag
        ''                            // no additional data
    );

    if ($json === false) {
        throw new RuntimeException('Changed, or sealed with another key');
    }

    return json_decode($json, true, flags: JSON_THROW_ON_ERROR);
}

// Unseal opens a sealed result: standard base64 (padded) of
// version 1 | IV (12) | ciphertext | tag (16), AES-256-GCM, no additional data.
func Unseal(sealed, key string) ([]byte, error) {
	data, err := base64.StdEncoding.DecodeString(sealed)
	if err != nil {
		return nil, err
	}
	if len(data) < 30 || data[0] != 1 {
		return nil, errors.New("not a sealed result of a known version")
	}

	secret, err := base64.StdEncoding.DecodeString(key)
	if err != nil {
		return nil, err
	}
	block, err := aes.NewCipher(secret)
	if err != nil {
		return nil, err
	}
	gcm, err := cipher.NewGCM(block) // 12 byte nonce, 16 byte tag
	if err != nil {
		return nil, err
	}

	// Open takes the ciphertext and the tag together: data[13:] as it is.
	return gcm.Open(nil, data[1:13], data[13:], nil)
}