#![forbid(unsafe_code)]
use std::{collections::BTreeMap, fmt, io::Cursor, sync::OnceLock};
use ark_bls12_381::{Bls12_381, Fr, G1Affine};
use ark_ff::{PrimeField, UniformRand};
use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
use base64::{Engine as _, engine::general_purpose::URL_SAFE_NO_PAD};
use bbs_plus::{
proof::{PoKOfSignatureG1Proof, PoKOfSignatureG1Protocol},
setup::{KeypairG2, PublicKeyG2, SignatureParamsG1},
signature::SignatureG1,
};
use dock_crypto_utils::signature::MessageOrBlinding;
use rand::{RngCore, rngs::OsRng};
use schnorr_pok::{
compute_random_oracle_challenge,
discrete_log::{PokPedersenCommitment, PokPedersenCommitmentProtocol},
};
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha512};
use thiserror::Error;
use url::Url;
use zeroize::Zeroizing;
pub const PROTOCOL_VERSION: &str = "sansid/1";
pub const CIPHERSUITE: &str = "BBS+-BLS12-381-SHA-512-SANSID-1";
const SCHEMA_ID: &str = "org.sansid.age-over-18/1";
const PARAMETER_LABEL: &[u8] = b"SansID BBS+ public parameters v1";
const HOLDER_SECRET_LABEL: &[u8] = b"SansID holder secret scalar v1";
const SCHEMA_LABEL: &[u8] = b"SansID credential schema scalar v1";
const PREDICATE_LABEL: &[u8] = b"SansID predicate scalar v1";
const KEY_ID_LABEL: &[u8] = b"SansID issuer key identifier v1";
const TRANSCRIPT_LABEL: &[u8] = b"SansID BBS+ presentation transcript v1";
const ISSUANCE_TRANSCRIPT_LABEL: &[u8] = b"SansID blind issuance transcript v1";
const MESSAGE_COUNT: u32 = 3;
const HOLDER_SECRET_INDEX: usize = 0;
const SCHEMA_INDEX: usize = 1;
const PREDICATE_INDEX: usize = 2;
const NONCE_BYTES: usize = 32;
const MAX_PRESENTATION_JSON_BYTES: usize = 8 * 1024;
const MAX_PROOF_BYTES: usize = 2 * 1024;
const MAX_PUBLIC_KEY_BYTES: usize = 256;
#[derive(Debug, Error)]
pub enum SansIdError {
#[error("a verifier nonce must be exactly 32 bytes")]
InvalidNonceLength,
#[error(
"an origin must be a canonical HTTPS origin without credentials, path, query, or fragment"
)]
InvalidOrigin,
#[error("presentation does not match the verifier request")]
RequestMismatch,
#[error("credential does not satisfy the requested predicate")]
PredicateMismatch,
#[error("presentation uses an unsupported SansID protocol profile")]
UnsupportedProfile,
#[error("presentation contains malformed encoded data")]
InvalidEncoding,
#[error("presentation exceeds the protocol input limits")]
PresentationTooLarge,
#[error("presentation issuer key is not trusted for this verification")]
UntrustedIssuer,
#[error("issuer public key is invalid")]
InvalidIssuerKey,
#[error("zero-knowledge proof verification failed")]
InvalidProof,
#[error("holder secret commitment proof verification failed")]
InvalidIssuanceProof,
#[error("BBS+ operation failed")]
Crypto,
#[error("canonical serialization failed")]
Serialization,
#[error("JSON encoding or decoding failed")]
Json,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
pub enum Predicate {
#[serde(rename = "age_over_18")]
AgeOver18,
}
impl Predicate {
fn as_bytes(self) -> &'static [u8] {
match self {
Self::AgeOver18 => b"age_over_18",
}
}
}
impl fmt::Display for Predicate {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(std::str::from_utf8(self.as_bytes()).expect("static UTF-8 predicate"))
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct Origin(String);
impl Origin {
pub fn parse(value: &str) -> Result<Self, SansIdError> {
if value.len() > 255 {
return Err(SansIdError::InvalidOrigin);
}
let parsed = Url::parse(value).map_err(|_| SansIdError::InvalidOrigin)?;
if parsed.scheme() != "https"
|| parsed.host().is_none()
|| !parsed.username().is_empty()
|| parsed.password().is_some()
|| parsed.query().is_some()
|| parsed.fragment().is_some()
|| parsed.path() != "/"
{
return Err(SansIdError::InvalidOrigin);
}
Ok(Self(parsed.origin().ascii_serialization()))
}
#[must_use]
pub fn as_str(&self) -> &str {
&self.0
}
}
impl TryFrom<&str> for Origin {
type Error = SansIdError;
fn try_from(value: &str) -> Result<Self, Self::Error> {
Self::parse(value)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct ProofRequest {
origin: Origin,
predicate: Predicate,
nonce: [u8; NONCE_BYTES],
}
impl ProofRequest {
pub fn new(
origin: impl AsRef<str>,
predicate: Predicate,
nonce: &[u8],
) -> Result<Self, SansIdError> {
let nonce: [u8; NONCE_BYTES] =
nonce.try_into().map_err(|_| SansIdError::InvalidNonceLength)?;
Ok(Self { origin: Origin::parse(origin.as_ref())?, predicate, nonce })
}
pub fn from_base64(
origin: impl AsRef<str>,
predicate: Predicate,
nonce: &str,
) -> Result<Self, SansIdError> {
let decoded = decode_base64(nonce, NONCE_BYTES)?;
Self::new(origin, predicate, &decoded)
}
#[must_use]
pub fn origin(&self) -> &Origin {
&self.origin
}
#[must_use]
pub fn predicate(&self) -> Predicate {
self.predicate
}
#[must_use]
pub fn nonce_base64(&self) -> String {
URL_SAFE_NO_PAD.encode(self.nonce)
}
}
#[derive(Clone)]
pub struct HolderSecret(Zeroizing<[u8; NONCE_BYTES]>);
impl HolderSecret {
#[must_use]
pub fn generate() -> Self {
let mut bytes = [0_u8; NONCE_BYTES];
OsRng.fill_bytes(&mut bytes);
Self(Zeroizing::new(bytes))
}
pub fn from_bytes(bytes: [u8; NONCE_BYTES]) -> Result<Self, SansIdError> {
if bytes.iter().all(|byte| *byte == 0) {
return Err(SansIdError::InvalidEncoding);
}
Ok(Self(Zeroizing::new(bytes)))
}
fn scalar(&self) -> Fr {
scalar_from_bytes(HOLDER_SECRET_LABEL, self.0.as_ref())
}
pub fn begin_issuance(
self,
issuer: &IssuerPublicKey,
challenge: &IssuanceChallenge,
) -> Result<IssuanceRequest, SansIdError> {
let secret_scalar = self.scalar();
let signature_blinding = Fr::rand(&mut OsRng);
let commitment = parameters()
.commit_to_messages([(HOLDER_SECRET_INDEX, &secret_scalar)], &signature_blinding)
.map_err(|_| SansIdError::Crypto)?;
let knowledge_protocol = PokPedersenCommitmentProtocol::init(
secret_scalar,
Fr::rand(&mut OsRng),
¶meters().h[HOLDER_SECRET_INDEX],
signature_blinding,
Fr::rand(&mut OsRng),
¶meters().h_0,
);
let proof_challenge =
issuance_protocol_challenge(&knowledge_protocol, &commitment, issuer, challenge)?;
Ok(IssuanceRequest {
commitment,
knowledge_proof: knowledge_protocol.gen_proof(&proof_challenge),
holder_secret: self,
signature_blinding,
issuer_public_key: issuer.clone(),
})
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum HolderKeyBackend {
DevelopmentMemory,
Tpm2,
WindowsPlatformCryptoProvider,
AppleSecureEnclave,
AndroidKeystore,
Pkcs11,
}
pub trait HolderSecretProvider {
fn backend(&self) -> HolderKeyBackend;
fn unlock_for_presentation(&self, request: &ProofRequest) -> Result<HolderSecret, SansIdError>;
}
impl HolderSecretProvider for HolderSecret {
fn backend(&self) -> HolderKeyBackend {
HolderKeyBackend::DevelopmentMemory
}
fn unlock_for_presentation(
&self,
_request: &ProofRequest,
) -> Result<HolderSecret, SansIdError> {
Ok(self.clone())
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct IssuanceChallenge([u8; NONCE_BYTES]);
impl IssuanceChallenge {
fn generate() -> Self {
let mut nonce = [0_u8; NONCE_BYTES];
OsRng.fill_bytes(&mut nonce);
Self(nonce)
}
}
pub struct IssuanceRequest {
commitment: G1Affine,
knowledge_proof: PokPedersenCommitment<G1Affine>,
holder_secret: HolderSecret,
signature_blinding: Fr,
issuer_public_key: IssuerPublicKey,
}
impl IssuanceRequest {
pub fn complete(self, response: BlindCredential) -> Result<ProvisionedCredential, SansIdError> {
if response.issuer_public_key != self.issuer_public_key {
return Err(SansIdError::UntrustedIssuer);
}
let signature = response.signature.unblind(&self.signature_blinding);
let messages = credential_messages(&self.holder_secret, response.predicate);
signature
.verify(&messages, response.issuer_public_key.key.clone(), parameters().clone())
.map_err(|_| SansIdError::InvalidProof)?;
Ok(ProvisionedCredential {
credential: Credential {
signature,
predicate: response.predicate,
issuer_public_key: response.issuer_public_key,
},
holder_secret: self.holder_secret,
})
}
}
pub struct BlindCredential {
signature: SignatureG1<Bls12_381>,
predicate: Predicate,
issuer_public_key: IssuerPublicKey,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct IssuerPublicKey {
key: PublicKeyG2<Bls12_381>,
key_id: String,
}
impl IssuerPublicKey {
pub fn from_base64(value: &str) -> Result<Self, SansIdError> {
let bytes = decode_base64(value, MAX_PUBLIC_KEY_BYTES)?;
let key = canonical_decode::<PublicKeyG2<Bls12_381>>(&bytes)?;
if !key.is_valid() {
return Err(SansIdError::InvalidIssuerKey);
}
Self::from_key(key)
}
fn from_key(key: PublicKeyG2<Bls12_381>) -> Result<Self, SansIdError> {
let bytes = canonical_encode(&key)?;
let key_id = URL_SAFE_NO_PAD.encode(hash_bytes(KEY_ID_LABEL, &bytes));
Ok(Self { key, key_id })
}
#[must_use]
pub fn key_id(&self) -> &str {
&self.key_id
}
pub fn to_base64(&self) -> Result<String, SansIdError> {
Ok(URL_SAFE_NO_PAD.encode(canonical_encode(&self.key)?))
}
}
pub struct Issuer {
keypair: KeypairG2<Bls12_381>,
public_key: IssuerPublicKey,
}
impl Issuer {
pub fn generate() -> Result<Self, SansIdError> {
let keypair = KeypairG2::<Bls12_381>::generate_using_rng(&mut OsRng, parameters());
let public_key = IssuerPublicKey::from_key(keypair.public_key.clone())?;
Ok(Self { keypair, public_key })
}
#[must_use]
pub fn public_key(&self) -> &IssuerPublicKey {
&self.public_key
}
#[must_use]
pub fn issuance_challenge(&self) -> IssuanceChallenge {
IssuanceChallenge::generate()
}
pub fn blind_issue(
&self,
request: &IssuanceRequest,
challenge: &IssuanceChallenge,
predicate: Predicate,
) -> Result<BlindCredential, SansIdError> {
if request.issuer_public_key != self.public_key {
return Err(SansIdError::UntrustedIssuer);
}
let proof_challenge = issuance_proof_challenge(
&request.knowledge_proof,
&request.commitment,
&self.public_key,
challenge,
)?;
if !request.knowledge_proof.verify(
&request.commitment,
¶meters().h[HOLDER_SECRET_INDEX],
¶meters().h_0,
&proof_challenge,
) {
return Err(SansIdError::InvalidIssuanceProof);
}
let messages = issued_messages(predicate);
let signature = SignatureG1::<Bls12_381>::new_with_committed_messages(
&mut OsRng,
&request.commitment,
BTreeMap::from([(SCHEMA_INDEX, &messages[0]), (PREDICATE_INDEX, &messages[1])]),
&self.keypair.secret_key,
parameters(),
)
.map_err(|_| SansIdError::Crypto)?;
Ok(BlindCredential { signature, predicate, issuer_public_key: self.public_key.clone() })
}
}
pub struct Credential {
signature: SignatureG1<Bls12_381>,
predicate: Predicate,
issuer_public_key: IssuerPublicKey,
}
impl Credential {
pub fn present_with_provider<P: HolderSecretProvider>(
&self,
provider: &P,
request: &ProofRequest,
) -> Result<Presentation, SansIdError> {
let holder_secret = provider.unlock_for_presentation(request)?;
self.present(&holder_secret, request)
}
pub fn present(
&self,
holder_secret: &HolderSecret,
request: &ProofRequest,
) -> Result<Presentation, SansIdError> {
if self.predicate != request.predicate {
return Err(SansIdError::PredicateMismatch);
}
let messages = credential_messages(holder_secret, self.predicate);
let message_proof_inputs = [
MessageOrBlinding::BlindMessageRandomly(&messages[HOLDER_SECRET_INDEX]),
MessageOrBlinding::RevealMessage(&messages[SCHEMA_INDEX]),
MessageOrBlinding::RevealMessage(&messages[PREDICATE_INDEX]),
];
let protocol = PoKOfSignatureG1Protocol::<Bls12_381>::init(
&mut OsRng,
&self.signature,
parameters(),
message_proof_inputs,
)
.map_err(|_| SansIdError::Crypto)?;
let challenge = protocol_challenge(&protocol, request, &self.issuer_public_key)?;
let proof = protocol.gen_proof(&challenge).map_err(|_| SansIdError::Crypto)?;
Ok(Presentation {
protocol_version: PROTOCOL_VERSION.to_owned(),
ciphersuite: CIPHERSUITE.to_owned(),
schema: SCHEMA_ID.to_owned(),
predicate: self.predicate,
origin: request.origin.clone(),
nonce: request.nonce_base64(),
issuer_key_id: self.issuer_public_key.key_id().to_owned(),
issuer_public_key: self.issuer_public_key.to_base64()?,
proof: URL_SAFE_NO_PAD.encode(canonical_encode(&proof)?),
})
}
}
pub struct ProvisionedCredential {
credential: Credential,
holder_secret: HolderSecret,
}
impl ProvisionedCredential {
#[must_use]
pub fn into_parts(self) -> (Credential, HolderSecret) {
(self.credential, self.holder_secret)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
pub struct Presentation {
pub protocol_version: String,
pub ciphersuite: String,
pub schema: String,
pub predicate: Predicate,
pub origin: Origin,
pub nonce: String,
pub issuer_key_id: String,
pub issuer_public_key: String,
pub proof: String,
}
impl Presentation {
pub fn to_json(&self) -> Result<String, SansIdError> {
serde_json::to_string(self).map_err(|_| SansIdError::Json)
}
pub fn from_json(value: &str) -> Result<Self, SansIdError> {
if value.len() > MAX_PRESENTATION_JSON_BYTES {
return Err(SansIdError::PresentationTooLarge);
}
let presentation: Self = serde_json::from_str(value).map_err(|_| SansIdError::Json)?;
presentation.validate_structure()?;
Ok(presentation)
}
fn validate_structure(&self) -> Result<(), SansIdError> {
if self.protocol_version != PROTOCOL_VERSION
|| self.ciphersuite != CIPHERSUITE
|| self.schema != SCHEMA_ID
{
return Err(SansIdError::UnsupportedProfile);
}
if Origin::parse(self.origin.as_str())? != self.origin {
return Err(SansIdError::InvalidOrigin);
}
if decode_base64(&self.nonce, NONCE_BYTES)?.len() != NONCE_BYTES {
return Err(SansIdError::InvalidNonceLength);
}
decode_base64(&self.issuer_public_key, MAX_PUBLIC_KEY_BYTES)?;
decode_base64(&self.proof, MAX_PROOF_BYTES)?;
Ok(())
}
}
pub fn verify(
presentation: &Presentation,
request: &ProofRequest,
trusted_issuer: &IssuerPublicKey,
) -> Result<(), SansIdError> {
presentation.validate_structure()?;
if presentation.predicate != request.predicate
|| presentation.origin != request.origin
|| presentation.nonce != request.nonce_base64()
{
return Err(SansIdError::RequestMismatch);
}
if presentation.issuer_key_id != trusted_issuer.key_id() {
return Err(SansIdError::UntrustedIssuer);
}
let supplied_issuer = IssuerPublicKey::from_base64(&presentation.issuer_public_key)?;
if supplied_issuer != *trusted_issuer {
return Err(SansIdError::UntrustedIssuer);
}
let proof_bytes = decode_base64(&presentation.proof, MAX_PROOF_BYTES)?;
let proof = canonical_decode::<PoKOfSignatureG1Proof<Bls12_381>>(&proof_bytes)?;
let challenge = proof_challenge(&proof, request, trusted_issuer)?;
let revealed_messages = revealed_messages(request.predicate);
proof
.verify(&revealed_messages, &challenge, trusted_issuer.key.clone(), parameters().clone())
.map_err(|_| SansIdError::InvalidProof)
}
fn parameters() -> &'static SignatureParamsG1<Bls12_381> {
static PARAMETERS: OnceLock<SignatureParamsG1<Bls12_381>> = OnceLock::new();
PARAMETERS.get_or_init(|| {
SignatureParamsG1::<Bls12_381>::new::<Sha512>(PARAMETER_LABEL, MESSAGE_COUNT)
})
}
fn credential_messages(
secret: &HolderSecret,
predicate: Predicate,
) -> [Fr; MESSAGE_COUNT as usize] {
[secret.scalar(), issued_messages(predicate)[0], issued_messages(predicate)[1]]
}
fn issued_messages(predicate: Predicate) -> [Fr; 2] {
[
scalar_from_bytes(SCHEMA_LABEL, SCHEMA_ID.as_bytes()),
scalar_from_bytes(PREDICATE_LABEL, predicate.as_bytes()),
]
}
fn revealed_messages(predicate: Predicate) -> BTreeMap<usize, Fr> {
BTreeMap::from([
(SCHEMA_INDEX, scalar_from_bytes(SCHEMA_LABEL, SCHEMA_ID.as_bytes())),
(PREDICATE_INDEX, scalar_from_bytes(PREDICATE_LABEL, predicate.as_bytes())),
])
}
fn protocol_challenge(
protocol: &PoKOfSignatureG1Protocol<Bls12_381>,
request: &ProofRequest,
issuer: &IssuerPublicKey,
) -> Result<Fr, SansIdError> {
let mut transcript = transcript_prefix(request, issuer)?;
PoKOfSignatureG1Protocol::compute_challenge_contribution(
&protocol.A_prime,
&protocol.A_bar,
&protocol.d,
&protocol.sc_comm_1.t,
&protocol.sc_comm_2.t,
&revealed_messages(request.predicate),
parameters(),
&mut transcript,
)
.map_err(|_| SansIdError::Crypto)?;
Ok(compute_random_oracle_challenge::<Fr, Sha512>(&transcript))
}
fn proof_challenge(
proof: &PoKOfSignatureG1Proof<Bls12_381>,
request: &ProofRequest,
issuer: &IssuerPublicKey,
) -> Result<Fr, SansIdError> {
let mut transcript = transcript_prefix(request, issuer)?;
proof
.challenge_contribution(
&revealed_messages(request.predicate),
parameters(),
&mut transcript,
)
.map_err(|_| SansIdError::InvalidProof)?;
Ok(compute_random_oracle_challenge::<Fr, Sha512>(&transcript))
}
fn issuance_protocol_challenge(
protocol: &PokPedersenCommitmentProtocol<G1Affine>,
commitment: &G1Affine,
issuer: &IssuerPublicKey,
challenge: &IssuanceChallenge,
) -> Result<Fr, SansIdError> {
let mut transcript = issuance_transcript_prefix(issuer, challenge)?;
protocol
.challenge_contribution(
¶meters().h[HOLDER_SECRET_INDEX],
¶meters().h_0,
commitment,
&mut transcript,
)
.map_err(|_| SansIdError::Crypto)?;
Ok(compute_random_oracle_challenge::<Fr, Sha512>(&transcript))
}
fn issuance_proof_challenge(
proof: &PokPedersenCommitment<G1Affine>,
commitment: &G1Affine,
issuer: &IssuerPublicKey,
challenge: &IssuanceChallenge,
) -> Result<Fr, SansIdError> {
let mut transcript = issuance_transcript_prefix(issuer, challenge)?;
proof
.challenge_contribution(
¶meters().h[HOLDER_SECRET_INDEX],
¶meters().h_0,
commitment,
&mut transcript,
)
.map_err(|_| SansIdError::InvalidIssuanceProof)?;
Ok(compute_random_oracle_challenge::<Fr, Sha512>(&transcript))
}
fn transcript_prefix(
request: &ProofRequest,
issuer: &IssuerPublicKey,
) -> Result<Vec<u8>, SansIdError> {
let mut transcript = Vec::with_capacity(256);
append_transcript_field(&mut transcript, TRANSCRIPT_LABEL);
append_transcript_field(&mut transcript, PROTOCOL_VERSION.as_bytes());
append_transcript_field(&mut transcript, CIPHERSUITE.as_bytes());
append_transcript_field(&mut transcript, SCHEMA_ID.as_bytes());
append_transcript_field(&mut transcript, issuer.key_id().as_bytes());
append_transcript_field(&mut transcript, &canonical_encode(&issuer.key)?);
append_transcript_field(&mut transcript, request.origin.as_str().as_bytes());
append_transcript_field(&mut transcript, request.predicate.as_bytes());
append_transcript_field(&mut transcript, &request.nonce);
Ok(transcript)
}
fn issuance_transcript_prefix(
issuer: &IssuerPublicKey,
challenge: &IssuanceChallenge,
) -> Result<Vec<u8>, SansIdError> {
let mut transcript = Vec::with_capacity(192);
append_transcript_field(&mut transcript, ISSUANCE_TRANSCRIPT_LABEL);
append_transcript_field(&mut transcript, PROTOCOL_VERSION.as_bytes());
append_transcript_field(&mut transcript, CIPHERSUITE.as_bytes());
append_transcript_field(&mut transcript, SCHEMA_ID.as_bytes());
append_transcript_field(&mut transcript, issuer.key_id().as_bytes());
append_transcript_field(&mut transcript, &canonical_encode(&issuer.key)?);
append_transcript_field(&mut transcript, &challenge.0);
Ok(transcript)
}
fn append_transcript_field(target: &mut Vec<u8>, value: &[u8]) {
target.extend_from_slice(&(value.len() as u64).to_be_bytes());
target.extend_from_slice(value);
}
fn hash_bytes(label: &[u8], value: &[u8]) -> [u8; 64] {
let mut hash = Sha512::new();
hash.update((label.len() as u64).to_be_bytes());
hash.update(label);
hash.update((value.len() as u64).to_be_bytes());
hash.update(value);
hash.finalize().into()
}
fn scalar_from_bytes(label: &[u8], value: &[u8]) -> Fr {
let mut hash = Sha512::new();
hash.update((label.len() as u64).to_be_bytes());
hash.update(label);
hash.update((value.len() as u64).to_be_bytes());
hash.update(value);
Fr::from_le_bytes_mod_order(&hash.finalize())
}
fn canonical_encode<T: CanonicalSerialize>(value: &T) -> Result<Vec<u8>, SansIdError> {
let mut bytes = Vec::new();
value.serialize_compressed(&mut bytes).map_err(|_| SansIdError::Serialization)?;
Ok(bytes)
}
fn canonical_decode<T: CanonicalDeserialize>(bytes: &[u8]) -> Result<T, SansIdError> {
let mut cursor = Cursor::new(bytes);
let value = T::deserialize_compressed(&mut cursor).map_err(|_| SansIdError::InvalidEncoding)?;
if cursor.position() != bytes.len() as u64 {
return Err(SansIdError::InvalidEncoding);
}
Ok(value)
}
fn decode_base64(value: &str, maximum_length: usize) -> Result<Vec<u8>, SansIdError> {
if value.len() > maximum_length.saturating_mul(2) {
return Err(SansIdError::PresentationTooLarge);
}
let decoded = URL_SAFE_NO_PAD.decode(value).map_err(|_| SansIdError::InvalidEncoding)?;
if decoded.len() > maximum_length {
return Err(SansIdError::PresentationTooLarge);
}
Ok(decoded)
}
#[cfg(test)]
mod tests {
use super::*;
fn fixture() -> (Credential, HolderSecret, IssuerPublicKey, ProofRequest) {
let issuer = Issuer::generate().expect("issuer generation");
let key = issuer.public_key().clone();
let issuance_challenge = issuer.issuance_challenge();
let issuance_request = HolderSecret::generate()
.begin_issuance(issuer.public_key(), &issuance_challenge)
.expect("issuance request");
let response = issuer
.blind_issue(&issuance_request, &issuance_challenge, Predicate::AgeOver18)
.expect("blind issuance");
let (credential, holder_secret) =
issuance_request.complete(response).expect("credential completion").into_parts();
let request =
ProofRequest::new("https://video.example", Predicate::AgeOver18, &[7_u8; NONCE_BYTES])
.expect("proof request");
(credential, holder_secret, key, request)
}
#[test]
fn age_presentation_verifies() {
let (credential, holder_secret, issuer, request) = fixture();
let presentation = credential.present(&holder_secret, &request).expect("presentation");
verify(&presentation, &request, &issuer).expect("proof verifies");
}
#[test]
fn provider_boundary_authorizes_a_presentation() {
let (credential, holder_secret, issuer, request) = fixture();
assert_eq!(holder_secret.backend(), HolderKeyBackend::DevelopmentMemory);
let presentation = credential
.present_with_provider(&holder_secret, &request)
.expect("provider presentation");
verify(&presentation, &request, &issuer).expect("proof verifies");
}
#[test]
fn presentations_are_fresh_and_unlinkable_at_the_proof_layer() {
let (credential, holder_secret, issuer, request) = fixture();
let first = credential.present(&holder_secret, &request).expect("first presentation");
let second = credential.present(&holder_secret, &request).expect("second presentation");
assert_ne!(first.proof, second.proof);
verify(&first, &request, &issuer).expect("first proof verifies");
verify(&second, &request, &issuer).expect("second proof verifies");
}
#[test]
fn proof_cannot_be_replayed_for_a_different_nonce() {
let (credential, holder_secret, issuer, request) = fixture();
let presentation = credential.present(&holder_secret, &request).expect("presentation");
let other_request =
ProofRequest::new("https://video.example", Predicate::AgeOver18, &[8_u8; NONCE_BYTES])
.expect("different request");
assert!(matches!(
verify(&presentation, &other_request, &issuer),
Err(SansIdError::RequestMismatch)
));
}
#[test]
fn proof_cannot_be_replayed_for_a_different_origin() {
let (credential, holder_secret, issuer, request) = fixture();
let presentation = credential.present(&holder_secret, &request).expect("presentation");
let other_request =
ProofRequest::new("https://other.example", Predicate::AgeOver18, &[7_u8; NONCE_BYTES])
.expect("different request");
assert!(matches!(
verify(&presentation, &other_request, &issuer),
Err(SansIdError::RequestMismatch)
));
}
#[test]
fn blind_issuance_rejects_a_different_issuer_nonce() {
let issuer = Issuer::generate().expect("issuer generation");
let first_challenge = issuer.issuance_challenge();
let request = HolderSecret::generate()
.begin_issuance(issuer.public_key(), &first_challenge)
.expect("issuance request");
let second_challenge = issuer.issuance_challenge();
assert!(matches!(
issuer.blind_issue(&request, &second_challenge, Predicate::AgeOver18),
Err(SansIdError::InvalidIssuanceProof)
));
}
#[test]
fn altered_proof_bytes_are_rejected() {
let (credential, holder_secret, issuer, request) = fixture();
let mut presentation = credential.present(&holder_secret, &request).expect("presentation");
let mut proof = decode_base64(&presentation.proof, MAX_PROOF_BYTES).expect("proof bytes");
proof[0] ^= 1;
presentation.proof = URL_SAFE_NO_PAD.encode(proof);
assert!(matches!(
verify(&presentation, &request, &issuer),
Err(SansIdError::InvalidEncoding | SansIdError::InvalidProof)
));
}
#[test]
fn json_round_trip_preserves_a_valid_presentation() {
let (credential, holder_secret, issuer, request) = fixture();
let encoded = credential
.present(&holder_secret, &request)
.expect("presentation")
.to_json()
.expect("JSON encoding");
let decoded = Presentation::from_json(&encoded).expect("JSON decoding");
verify(&decoded, &request, &issuer).expect("proof verifies");
}
#[test]
fn predicate_json_uses_the_documented_wire_name() {
let encoded = serde_json::to_string(&Predicate::AgeOver18).expect("predicate serializes");
assert_eq!(encoded, "\"age_over_18\"");
let decoded: Predicate = serde_json::from_str("\"age_over_18\"").expect("parses");
assert_eq!(decoded, Predicate::AgeOver18);
}
#[test]
fn origin_must_be_canonical_https() {
assert!(Origin::parse("http://video.example").is_err());
assert!(Origin::parse("https://video.example/path").is_err());
assert!(Origin::parse("https://user@video.example").is_err());
assert_eq!(
Origin::parse("https://video.example/").expect("canonical origin").as_str(),
"https://video.example"
);
}
}