Skip to content

Rename protocols #38

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
raphaelrobert merged 5 commits into from
May 15, 2025
Merged

Rename protocols #38

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
5 commits
Select commit Hold shift + click to select a range
3122ee7
Minor fixes ahead of renaming
raphaelrobert May 12, 2025
15dd1b0
Rename batched -> amortized
raphaelrobert May 12, 2025
e8a0189
Rename arbitrary -> generic
raphaelrobert May 12, 2025
f870fc8
Rename structs
raphaelrobert May 12, 2025
abda714
Adjust benchmarks & nits
raphaelrobert May 12, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
3 changes: 2 additions & 1 deletion README.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -9,4 +9,5 @@ for the following token types:

- Privately Verifiable Tokens
- Publicly Verifiable Tokens
- Batched Tokens
- Amortized Tokens
- Generic Tokens
128 changes: 71 additions & 57 deletions benches/batched.rs → benches/amortized.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -4,34 +4,36 @@ use tokio::runtime::Runtime;

use privacypass::{
PPCipherSuite,
amortized_tokens::{
AmortizedBatchTokenRequest, AmortizedBatchTokenResponse, AmortizedToken, server::Server,
},
auth::authenticate::TokenChallenge,
batched_tokens::{BatchedToken, TokenRequest, TokenResponse, server::Server},
test_utils::{nonce_store::MemoryNonceStore, private_memory_store::MemoryKeyStoreVoprf},
};
use voprf::Ristretto255;

async fn create_batched_keypair<CS: PPCipherSuite>(
async fn create_amortized_keypair<CS: PPCipherSuite>(
key_store: MemoryKeyStoreVoprf<CS>,
server: Server<CS>,
) {
let _public_key = server.create_keypair(&key_store).await.unwrap();
}

async fn issue_batched_token_response<CS: PPCipherSuite>(
async fn issue_amortized_token_response<CS: PPCipherSuite>(
key_store: MemoryKeyStoreVoprf<CS>,
server: Server<CS>,
token_request: TokenRequest<CS>,
) -> TokenResponse<CS> {
token_request: AmortizedBatchTokenRequest<CS>,
) -> AmortizedBatchTokenResponse<CS> {
server
.issue_token_response(&key_store, token_request)
.await
.unwrap()
}

async fn redeem_batched_token<CS: PPCipherSuite>(
async fn redeem_amortized_token<CS: PPCipherSuite>(
key_store: MemoryKeyStoreVoprf<CS>,
nonce_store: MemoryNonceStore,
token: BatchedToken<CS>,
token: AmortizedToken<CS>,
server: Server<CS>,
) {
server
Expand All @@ -40,31 +42,37 @@ async fn redeem_batched_token<CS: PPCipherSuite>(
.unwrap();
}

pub fn criterion_batched_p384_benchmark(c: &mut Criterion) {
pub fn criterion_amortized_p384_benchmark(c: &mut Criterion) {
flow::<NistP384>(c);
}

pub fn criterion_batched_ristretto255_benchmark(c: &mut Criterion) {
pub fn criterion_amortized_ristretto255_benchmark(c: &mut Criterion) {
flow::<Ristretto255>(c);
}

pub fn flow<CS: PPCipherSuite>(c: &mut Criterion) {
const NR: u16 = 100;
// Key pair generation
c.bench_function("BATCHED P384 SERVER: Generate key pair", move |b| {
b.to_async(FuturesExecutor).iter_with_setup(
|| {
let key_store = MemoryKeyStoreVoprf::<CS>::default();
let server = Server::new();
(key_store, server)
},
|(key_store, server)| create_batched_keypair(key_store, server),
);
});
c.bench_function(
&format!("AMORTIZED SERVER ({}): Generate key pair", CS::ID),
move |b| {
b.to_async(FuturesExecutor).iter_with_setup(
|| {
let key_store = MemoryKeyStoreVoprf::<CS>::default();
let server = Server::new();
(key_store, server)
},
|(key_store, server)| create_amortized_keypair(key_store, server),
);
},
);

// Issue token request
c.bench_function(
&format!("BATCHED P384 CLIENT: Issue token request for {NR} tokens"),
&format!(
"AMORTIZED CLIENT ({}): Issue token request for {NR} tokens",
CS::ID
),
move |b| {
b.iter_with_setup(
|| {
Expand All @@ -82,15 +90,18 @@ pub fn flow<CS: PPCipherSuite>(c: &mut Criterion) {
(public_key, challenge)
},
|(public_key, challenge)| {
TokenRequest::<CS>::new(public_key, &challenge, NR).unwrap();
AmortizedBatchTokenRequest::<CS>::new(public_key, &challenge, NR).unwrap();
},
);
},
);

// Issue token response
c.bench_function(
&format!("BATCHED P384 SERVER: Issue token response for {NR} tokens"),
&format!(
"AMORTIZED SERVER ({}): Issue token response for {NR} tokens",
CS::ID
),
move |b| {
b.to_async(FuturesExecutor).iter_with_setup(
|| {
Expand All @@ -106,19 +117,19 @@ pub fn flow<CS: PPCipherSuite>(c: &mut Criterion) {
&["example.com".to_string()],
);
let (token_request, _token_state) =
TokenRequest::new(public_key, &challenge, NR).unwrap();
AmortizedBatchTokenRequest::new(public_key, &challenge, NR).unwrap();
(key_store, server, token_request)
},
|(key_store, server, token_request)| {
issue_batched_token_response(key_store, server, token_request)
issue_amortized_token_response(key_store, server, token_request)
},
);
},
);

// Issue token
c.bench_function(
&format!("BATCHED P384 CLIENT: Issue {NR} tokens"),
&format!("AMORTIZED CLIENT ({}): Issue {NR} tokens", CS::ID),
move |b| {
b.iter_with_setup(
|| {
Expand All @@ -134,7 +145,7 @@ pub fn flow<CS: PPCipherSuite>(c: &mut Criterion) {
&["example.com".to_string()],
);
let (token_request, token_state) =
TokenRequest::new(public_key, &challenge, NR).unwrap();
AmortizedBatchTokenRequest::new(public_key, &challenge, NR).unwrap();
let token_response = rt.block_on(async {
server
.issue_token_response(&key_store, token_request)
Expand All @@ -151,35 +162,38 @@ pub fn flow<CS: PPCipherSuite>(c: &mut Criterion) {
);

// Redeem token
c.bench_function("BATCHED P384 SERVER: Redeem token", move |b| {
b.to_async(FuturesExecutor).iter_with_setup(
|| {
let key_store = MemoryKeyStoreVoprf::<CS>::default();
let nonce_store = MemoryNonceStore::default();
let server = Server::new();
let rt = Runtime::new().unwrap();
let public_key =
rt.block_on(async { server.create_keypair(&key_store).await.unwrap() });
let challenge = TokenChallenge::new(
CS::token_type(),
"example.com",
None,
&["example.com".to_string()],
);
let (token_request, token_state) =
TokenRequest::new(public_key, &challenge, NR).unwrap();
let token_response = rt.block_on(async {
server
.issue_token_response(&key_store, token_request)
.await
.unwrap()
});
let tokens = token_response.issue_tokens(&token_state).unwrap();
(key_store, nonce_store, tokens, server)
},
|(key_store, nonce_store, tokens, server)| {
redeem_batched_token(key_store, nonce_store, tokens[0].clone(), server)
},
);
});
c.bench_function(
&format!("AMORTIZED SERVER ({}): Redeem token", CS::ID),
move |b| {
b.to_async(FuturesExecutor).iter_with_setup(
|| {
let key_store = MemoryKeyStoreVoprf::<CS>::default();
let nonce_store = MemoryNonceStore::default();
let server = Server::new();
let rt = Runtime::new().unwrap();
let public_key =
rt.block_on(async { server.create_keypair(&key_store).await.unwrap() });
let challenge = TokenChallenge::new(
CS::token_type(),
"example.com",
None,
&["example.com".to_string()],
);
let (token_request, token_state) =
AmortizedBatchTokenRequest::new(public_key, &challenge, NR).unwrap();
let token_response = rt.block_on(async {
server
.issue_token_response(&key_store, token_request)
.await
.unwrap()
});
let tokens = token_response.issue_tokens(&token_state).unwrap();
(key_store, nonce_store, tokens, server)
},
|(key_store, nonce_store, tokens, server)| {
redeem_amortized_token(key_store, nonce_store, tokens[0].clone(), server)
},
);
},
);
}
8 changes: 4 additions & 4 deletions benches/benchmark.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,10 +1,10 @@
mod batched;
mod amortized;
mod private;
mod public;

use criterion::{criterion_group, criterion_main};

use batched::{criterion_batched_p384_benchmark, criterion_batched_ristretto255_benchmark};
use amortized::{criterion_amortized_p384_benchmark, criterion_amortized_ristretto255_benchmark};
use private::{criterion_private_p384_benchmark, criterion_private_ristretto255_benchmark};
use public::criterion_public_benchmark;

Expand All @@ -13,7 +13,7 @@ criterion_group!(
criterion_private_p384_benchmark,
criterion_private_ristretto255_benchmark,
criterion_public_benchmark,
criterion_batched_ristretto255_benchmark,
criterion_batched_p384_benchmark
criterion_amortized_ristretto255_benchmark,
criterion_amortized_p384_benchmark
);
criterion_main!(benches);
Loading