refactor(client)!: rename face verifier client to flamingo verifier client (#105)

* refactor(client)!: rename to FlamingoVerifierClient

* chore: clean up legacy verifier names

Author: Takaros999

README.md

@@ -1,8 +1,8 @@
-# Embedding Verifier
+# Flamingo
 
 TODO: This Readme contains a lot of AI slob and needs to be fully reworked once we move out of prototyping phase.
 
-Rust workspaces for the embedding verifier host and secure enclave.
+Rust workspaces for the Flamingo Verifier host and secure enclave.
 
 ## Structure
 
@@ -79,7 +79,7 @@ Nix builds the OCI image and converts its root filesystem directly with aws-nitr
 ```bash
 # Reproducible OCI image -> deterministic EIF + PCRs.
 # Needs Linux x86_64; Nitro hardware is only needed to run.
-scripts/build-enclaves.sh --workload verifier   # -> target/eif/flamingo-verifier-enclave.eif, flamingo-verifier-pcr.json
+scripts/build-enclaves.sh --workload verifier   # -> target/eif/verifier-enclave.eif, verifier-pcr.json
 scripts/build-enclaves.sh --workload di         # -> target/eif/di-enclave.eif, di-pcr.json
 
 # Build or inspect only the reproducible OCI boundary.

scripts/Dockerfile.carrier

@@ -12,7 +12,7 @@ FROM public.ecr.aws/amazonlinux/amazonlinux:2023
 RUN dnf install -y aws-nitro-enclaves-cli aws-nitro-enclaves-cli-devel jq && \
     dnf clean all
 
-ARG EIF_FILE=deepface-enclave.eif
+ARG EIF_FILE=verifier-enclave.eif
 COPY ${EIF_FILE} /home/enclave.eif
 
 # ENCLAVE_CID is unset by default (auto-assigned CID). Set it to pin the

verifier/client/src/client.rs

@@ -1,4 +1,4 @@
-//! HTTP client for the embedding verifier host.
+//! HTTP client for the Flamingo Verifier host.
 
 use base64::{Engine as _, engine::general_purpose::STANDARD};
 
@@ -38,19 +38,18 @@ impl VerifiedAssignment {
     }
 }
 
-// TODO: Rename FaceVerifierClient to FlamingoVerifierClient.
-/// Calls the face verifier host and verifies the attestation documents it relays.
+/// Calls the Flamingo Verifier host and verifies the attestation documents it relays.
 ///
 /// Nothing is returned until the enclave that produced it has been verified, so callers
 /// cannot accidentally use an unattested key.
 #[derive(Debug)]
-pub struct FaceVerifierClient {
+pub struct FlamingoVerifierClient {
     config: Config,
     http: reqwest::Client,
     verifier: Verifier,
 }
 
-impl FaceVerifierClient {
+impl FlamingoVerifierClient {
     /// Builds a client from `config`.
     ///
     /// # Errors
@@ -296,7 +295,7 @@ mod tests {
     use pontifex::{ChannelConsumer, ChannelDomain, ChannelEnclave};
     use serde_json::{Value, json};
 
-    use super::{FaceVerifierClient, MatchRequestBody};
+    use super::{FlamingoVerifierClient, MatchRequestBody};
     use crate::{Config, Error, PcrMeasurement};
 
     fn config(base_url: &str) -> Config {
@@ -355,7 +354,7 @@ mod tests {
     }
 
     async fn request_match_with_consumer(
-        client: &FaceVerifierClient,
+        client: &FlamingoVerifierClient,
         consumer: &ChannelConsumer,
         inputs: &MatchInputs,
     ) -> Result<MatchResult, Error> {
@@ -465,7 +464,7 @@ mod tests {
     async fn a_sealed_rejection_round_trips() {
         let answer = MatchResult::Failed(FailureReason::MatchBelowThreshold);
         let (base_url, responder, seen) = serve_enclave(answer.clone(), false).await;
-        let client = FaceVerifierClient::new(config(&base_url)).expect("client should build");
+        let client = FlamingoVerifierClient::new(config(&base_url)).expect("client should build");
 
         let result = request_match_with_consumer(&client, &consumer_for(&responder), &inputs())
             .await
@@ -491,7 +490,7 @@ mod tests {
     async fn a_reply_from_another_exchange_cannot_be_opened() {
         let (base_url, responder, _) =
             serve_enclave(MatchResult::Failed(FailureReason::MalformedInputs), true).await;
-        let client = FaceVerifierClient::new(config(&base_url)).expect("client should build");
+        let client = FlamingoVerifierClient::new(config(&base_url)).expect("client should build");
 
         let error = request_match_with_consumer(&client, &consumer_for(&responder), &inputs())
             .await
@@ -503,7 +502,7 @@ mod tests {
     #[tokio::test]
     async fn a_stale_assignment_asks_for_a_reassignment() {
         let base_url = serve_error(StatusCode::CONFLICT, "reassign_required", true).await;
-        let client = FaceVerifierClient::new(config(&base_url)).expect("client should build");
+        let client = FlamingoVerifierClient::new(config(&base_url)).expect("client should build");
         let responder = ChannelEnclave::generate(ChannelDomain::new(MATCH_CHANNEL_DOMAIN))
             .expect("channel key");
 
@@ -520,7 +519,7 @@ mod tests {
     #[tokio::test]
     async fn other_envelopes_keep_their_code_and_retry_flag() {
         let base_url = serve_error(StatusCode::PAYLOAD_TOO_LARGE, "request_too_large", false).await;
-        let client = FaceVerifierClient::new(config(&base_url)).expect("client should build");
+        let client = FlamingoVerifierClient::new(config(&base_url)).expect("client should build");
         let responder = ChannelEnclave::generate(ChannelDomain::new(MATCH_CHANNEL_DOMAIN))
             .expect("channel key");
 
@@ -549,7 +548,7 @@ mod tests {
             post(|| async { (StatusCode::BAD_GATEWAY, "not json") }),
         );
         let base_url = serve(router).await;
-        let client = FaceVerifierClient::new(config(&base_url)).expect("client should build");
+        let client = FlamingoVerifierClient::new(config(&base_url)).expect("client should build");
         let responder = ChannelEnclave::generate(ChannelDomain::new(MATCH_CHANNEL_DOMAIN))
             .expect("channel key");
 
@@ -568,7 +567,8 @@ mod tests {
                 signing_key_attestation: attestation,
             });
             let (base_url, responder, _) = serve_enclave(answer, false).await;
-            let client = FaceVerifierClient::new(config(&base_url)).expect("client should build");
+            let client =
+                FlamingoVerifierClient::new(config(&base_url)).expect("client should build");
 
             let error = request_match_with_consumer(&client, &consumer_for(&responder), &inputs())
                 .await

verifier/client/src/config.rs

@@ -25,7 +25,7 @@ const fn default_request_timeout_millis() -> u64 {
     60_000
 }
 
-/// Configuration to interact with an embedding verifier host.
+/// Configuration to interact with a Flamingo Verifier host.
 #[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
 pub struct Config {
@@ -276,7 +276,7 @@ mod tests {
         }))
         .unwrap();
         assert!(matches!(
-            crate::FaceVerifierClient::new(config),
+            crate::FlamingoVerifierClient::new(config),
             Err(Error::InvalidConfig { .. })
         ));
     }

verifier/client/src/lib.rs

@@ -1,19 +1,19 @@
-//! Client for the embedding verifier's enclave-assignment flow.
+//! Client for the Flamingo Verifier's enclave-assignment flow.
 //!
 //! Fetches an assignment, verifies the AWS Nitro attestation document it carries, and yields
 //! a [`ChannelConsumer`] bound to the separately supplied public key. The signed document
 //! commits to that key; Pontifex checks the commitment, measurements, signature and freshness.
 //!
 //! ```no_run
-//! use flamingo_verifier_client::{Config, FaceVerifierClient, PcrMeasurement};
+//! use flamingo_verifier_client::{Config, FlamingoVerifierClient, PcrMeasurement};
 //! use flamingo_verifier_sealed_types::MatchInputs;
 //!
 //! # async fn example(inputs: &MatchInputs, pcr0: [u8; 48]) -> Result<(), Box<dyn std::error::Error>> {
 //! let config = Config::new(
 //!     "https://verifier.example.com",
 //!     vec![vec![PcrMeasurement::new(0, pcr0)]],
 //! )?;
-//! let client = FaceVerifierClient::new(config)?;
+//! let client = FlamingoVerifierClient::new(config)?;
 //! let assignment = client.request_assignment().await?;
 //! let result = client.request_match(&assignment, inputs).await?;
 //! # Ok(())
@@ -32,7 +32,7 @@ mod client;
 mod config;
 mod error;
 
-pub use client::{FaceVerifierClient, VerifiedAssignment};
+pub use client::{FlamingoVerifierClient, VerifiedAssignment};
 pub use config::Config;
 pub use error::Error;
 pub use pontifex::{ChannelConsumer, PcrMeasurement};

verifier/client/tests/assignment.rs

@@ -7,7 +7,7 @@ use axum::http::StatusCode;
 use axum::routing::post;
 use flamingo_verifier_client as client;
 use flamingo_verifier_client::PcrMeasurement;
-use flamingo_verifier_client::{Config, FaceVerifierClient};
+use flamingo_verifier_client::{Config, FlamingoVerifierClient};
 use hex_literal::hex;
 
 fn config(base_url: &str) -> Config {
@@ -58,7 +58,7 @@ async fn rejects_an_assignment_whose_attestation_does_not_verify() {
     // A syntactically fine response carrying a document signed by nobody.
     let base_url = serve_assignment("hEBAQEA=", "a2V5").await;
 
-    let error = FaceVerifierClient::new(config(&base_url))
+    let error = FlamingoVerifierClient::new(config(&base_url))
         .expect("client should build")
         .request_assignment()
         .await
@@ -74,7 +74,7 @@ async fn rejects_an_assignment_whose_attestation_does_not_verify() {
 async fn rejects_malformed_base64_in_either_assignment_field() {
     for (document, key) in [("!", "a2V5"), ("hEBAQEA=", "!")] {
         let base_url = serve_assignment(document, key).await;
-        let error = FaceVerifierClient::new(config(&base_url))
+        let error = FlamingoVerifierClient::new(config(&base_url))
             .unwrap()
             .request_assignment()
             .await
@@ -91,7 +91,7 @@ async fn surfaces_a_host_error_status_rather_than_retrying() {
     ))
     .await;
 
-    let error = FaceVerifierClient::new(config(&base_url))
+    let error = FlamingoVerifierClient::new(config(&base_url))
         .expect("client should build")
         .request_assignment()
         .await

verifier/client/tests/stickiness.rs

@@ -12,7 +12,7 @@ use axum::extract::State;
 use axum::http::{HeaderMap, header};
 use axum::routing::post;
 use flamingo_verifier_client::PcrMeasurement;
-use flamingo_verifier_client::{Config, FaceVerifierClient};
+use flamingo_verifier_client::{Config, FlamingoVerifierClient};
 use hex_literal::hex;
 
 /// What a target group's `lb_cookie` stickiness looks like on the wire.
@@ -71,8 +71,8 @@ async fn carries_the_affinity_cookie_from_the_assignment_to_the_next_call() {
             .expect("stub should run");
     });
 
-    let client =
-        FaceVerifierClient::new(config(&format!("http://{address}"))).expect("client should build");
+    let client = FlamingoVerifierClient::new(config(&format!("http://{address}")))
+        .expect("client should build");
 
     for _ in 0..2 {
         client

verifier/e2e/src/main.rs

@@ -1,7 +1,7 @@
 use std::{env, fs, path::PathBuf};
 
 use anyhow::{Context, Result, anyhow, bail, ensure};
-use flamingo_verifier_client::{Config, FaceVerifierClient, VerifiedAssignment};
+use flamingo_verifier_client::{Config, FlamingoVerifierClient, VerifiedAssignment};
 use flamingo_verifier_enclave_types::MatchRequest;
 use flamingo_verifier_protocol::match_token::{self, EdDSAPublicKey};
 use flamingo_verifier_sealed_types::{MatchInputs, MatchResult};
@@ -23,7 +23,7 @@ async fn main() -> Result<()> {
     let config = load_config()?;
     let verifier = config.verifier()?;
 
-    let client = FaceVerifierClient::new(config).context("failed to build the client")?;
+    let client = FlamingoVerifierClient::new(config).context("failed to build the client")?;
     let assignment = client
         .request_assignment()
         .await

verifier/host/src/lib.rs

@@ -1,4 +1,4 @@
-//! HTTP host for the embedding verifier — the untrusted side of the enclave boundary.
+//! HTTP host for the Flamingo Verifier — the untrusted side of the enclave boundary.
 
 #![deny(
     clippy::all,