Skip to content

Commit bbcd7a6

Browse files
raphaelrobertraphaelrobert
authored
Rename protocols (#38)
* Minor fixes ahead of renaming * Rename batched -> amortized * Rename arbitrary -> generic * Rename structs * Adjust benchmarks & nits
1 parent 126c08e commit bbcd7a6

27 files changed

+450
-444
lines changed

‎README.md‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -9,4 +9,5 @@ for the following token types:
99

1010
- Privately Verifiable Tokens
1111
- Publicly Verifiable Tokens
12-
- Batched Tokens
12+
- Amortized Tokens
13+
- Generic Tokens

benches/batched.rs renamed to benches/amortized.rs

Lines changed: 71 additions & 57 deletions
Original file line numberDiff line numberDiff line change
@@ -4,34 +4,36 @@ use tokio::runtime::Runtime;
44

55
use privacypass::{
66
PPCipherSuite,
7+
amortized_tokens::{
8+
AmortizedBatchTokenRequest, AmortizedBatchTokenResponse, AmortizedToken, server::Server,
9+
},
710
auth::authenticate::TokenChallenge,
8-
batched_tokens::{BatchedToken, TokenRequest, TokenResponse, server::Server},
911
test_utils::{nonce_store::MemoryNonceStore, private_memory_store::MemoryKeyStoreVoprf},
1012
};
1113
use voprf::Ristretto255;
1214

13-
async fn create_batched_keypair<CS: PPCipherSuite>(
15+
async fn create_amortized_keypair<CS: PPCipherSuite>(
1416
key_store: MemoryKeyStoreVoprf<CS>,
1517
server: Server<CS>,
1618
) {
1719
let _public_key = server.create_keypair(&key_store).await.unwrap();
1820
}
1921

20-
async fn issue_batched_token_response<CS: PPCipherSuite>(
22+
async fn issue_amortized_token_response<CS: PPCipherSuite>(
2123
key_store: MemoryKeyStoreVoprf<CS>,
2224
server: Server<CS>,
23-
token_request: TokenRequest<CS>,
24-
) -> TokenResponse<CS> {
25+
token_request: AmortizedBatchTokenRequest<CS>,
26+
) -> AmortizedBatchTokenResponse<CS> {
2527
server
2628
.issue_token_response(&key_store, token_request)
2729
.await
2830
.unwrap()
2931
}
3032

31-
async fn redeem_batched_token<CS: PPCipherSuite>(
33+
async fn redeem_amortized_token<CS: PPCipherSuite>(
3234
key_store: MemoryKeyStoreVoprf<CS>,
3335
nonce_store: MemoryNonceStore,
34-
token: BatchedToken<CS>,
36+
token: AmortizedToken<CS>,
3537
server: Server<CS>,
3638
) {
3739
server
@@ -40,31 +42,37 @@ async fn redeem_batched_token<CS: PPCipherSuite>(
4042
.unwrap();
4143
}
4244

43-
pub fn criterion_batched_p384_benchmark(c: &mut Criterion) {
45+
pub fn criterion_amortized_p384_benchmark(c: &mut Criterion) {
4446
flow::<NistP384>(c);
4547
}
4648

47-
pub fn criterion_batched_ristretto255_benchmark(c: &mut Criterion) {
49+
pub fn criterion_amortized_ristretto255_benchmark(c: &mut Criterion) {
4850
flow::<Ristretto255>(c);
4951
}
5052

5153
pub fn flow<CS: PPCipherSuite>(c: &mut Criterion) {
5254
const NR: u16 = 100;
5355
// Key pair generation
54-
c.bench_function("BATCHED P384 SERVER: Generate key pair", move |b| {
55-
b.to_async(FuturesExecutor).iter_with_setup(
56-
|| {
57-
let key_store = MemoryKeyStoreVoprf::<CS>::default();
58-
let server = Server::new();
59-
(key_store, server)
60-
},
61-
|(key_store, server)| create_batched_keypair(key_store, server),
62-
);
63-
});
56+
c.bench_function(
57+
&format!("AMORTIZED SERVER ({}): Generate key pair", CS::ID),
58+
move |b| {
59+
b.to_async(FuturesExecutor).iter_with_setup(
60+
|| {
61+
let key_store = MemoryKeyStoreVoprf::<CS>::default();
62+
let server = Server::new();
63+
(key_store, server)
64+
},
65+
|(key_store, server)| create_amortized_keypair(key_store, server),
66+
);
67+
},
68+
);
6469

6570
// Issue token request
6671
c.bench_function(
67-
&format!("BATCHED P384 CLIENT: Issue token request for {NR} tokens"),
72+
&format!(
73+
"AMORTIZED CLIENT ({}): Issue token request for {NR} tokens",
74+
CS::ID
75+
),
6876
move |b| {
6977
b.iter_with_setup(
7078
|| {
@@ -82,15 +90,18 @@ pub fn flow<CS: PPCipherSuite>(c: &mut Criterion) {
8290
(public_key, challenge)
8391
},
8492
|(public_key, challenge)| {
85-
TokenRequest::<CS>::new(public_key, &challenge, NR).unwrap();
93+
AmortizedBatchTokenRequest::<CS>::new(public_key, &challenge, NR).unwrap();
8694
},
8795
);
8896
},
8997
);
9098

9199
// Issue token response
92100
c.bench_function(
93-
&format!("BATCHED P384 SERVER: Issue token response for {NR} tokens"),
101+
&format!(
102+
"AMORTIZED SERVER ({}): Issue token response for {NR} tokens",
103+
CS::ID
104+
),
94105
move |b| {
95106
b.to_async(FuturesExecutor).iter_with_setup(
96107
|| {
@@ -106,19 +117,19 @@ pub fn flow<CS: PPCipherSuite>(c: &mut Criterion) {
106117
&["example.com".to_string()],
107118
);
108119
let (token_request, _token_state) =
109-
TokenRequest::new(public_key, &challenge, NR).unwrap();
120+
AmortizedBatchTokenRequest::new(public_key, &challenge, NR).unwrap();
110121
(key_store, server, token_request)
111122
},
112123
|(key_store, server, token_request)| {
113-
issue_batched_token_response(key_store, server, token_request)
124+
issue_amortized_token_response(key_store, server, token_request)
114125
},
115126
);
116127
},
117128
);
118129

119130
// Issue token
120131
c.bench_function(
121-
&format!("BATCHED P384 CLIENT: Issue {NR} tokens"),
132+
&format!("AMORTIZED CLIENT ({}): Issue {NR} tokens", CS::ID),
122133
move |b| {
123134
b.iter_with_setup(
124135
|| {
@@ -134,7 +145,7 @@ pub fn flow<CS: PPCipherSuite>(c: &mut Criterion) {
134145
&["example.com".to_string()],
135146
);
136147
let (token_request, token_state) =
137-
TokenRequest::new(public_key, &challenge, NR).unwrap();
148+
AmortizedBatchTokenRequest::new(public_key, &challenge, NR).unwrap();
138149
let token_response = rt.block_on(async {
139150
server
140151
.issue_token_response(&key_store, token_request)
@@ -151,35 +162,38 @@ pub fn flow<CS: PPCipherSuite>(c: &mut Criterion) {
151162
);
152163

153164
// Redeem token
154-
c.bench_function("BATCHED P384 SERVER: Redeem token", move |b| {
155-
b.to_async(FuturesExecutor).iter_with_setup(
156-
|| {
157-
let key_store = MemoryKeyStoreVoprf::<CS>::default();
158-
let nonce_store = MemoryNonceStore::default();
159-
let server = Server::new();
160-
let rt = Runtime::new().unwrap();
161-
let public_key =
162-
rt.block_on(async { server.create_keypair(&key_store).await.unwrap() });
163-
let challenge = TokenChallenge::new(
164-
CS::token_type(),
165-
"example.com",
166-
None,
167-
&["example.com".to_string()],
168-
);
169-
let (token_request, token_state) =
170-
TokenRequest::new(public_key, &challenge, NR).unwrap();
171-
let token_response = rt.block_on(async {
172-
server
173-
.issue_token_response(&key_store, token_request)
174-
.await
175-
.unwrap()
176-
});
177-
let tokens = token_response.issue_tokens(&token_state).unwrap();
178-
(key_store, nonce_store, tokens, server)
179-
},
180-
|(key_store, nonce_store, tokens, server)| {
181-
redeem_batched_token(key_store, nonce_store, tokens[0].clone(), server)
182-
},
183-
);
184-
});
165+
c.bench_function(
166+
&format!("AMORTIZED SERVER ({}): Redeem token", CS::ID),
167+
move |b| {
168+
b.to_async(FuturesExecutor).iter_with_setup(
169+
|| {
170+
let key_store = MemoryKeyStoreVoprf::<CS>::default();
171+
let nonce_store = MemoryNonceStore::default();
172+
let server = Server::new();
173+
let rt = Runtime::new().unwrap();
174+
let public_key =
175+
rt.block_on(async { server.create_keypair(&key_store).await.unwrap() });
176+
let challenge = TokenChallenge::new(
177+
CS::token_type(),
178+
"example.com",
179+
None,
180+
&["example.com".to_string()],
181+
);
182+
let (token_request, token_state) =
183+
AmortizedBatchTokenRequest::new(public_key, &challenge, NR).unwrap();
184+
let token_response = rt.block_on(async {
185+
server
186+
.issue_token_response(&key_store, token_request)
187+
.await
188+
.unwrap()
189+
});
190+
let tokens = token_response.issue_tokens(&token_state).unwrap();
191+
(key_store, nonce_store, tokens, server)
192+
},
193+
|(key_store, nonce_store, tokens, server)| {
194+
redeem_amortized_token(key_store, nonce_store, tokens[0].clone(), server)
195+
},
196+
);
197+
},
198+
);
185199
}

‎benches/benchmark.rs‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,10 +1,10 @@
1-
mod batched;
1+
mod amortized;
22
mod private;
33
mod public;
44

55
use criterion::{criterion_group, criterion_main};
66

7-
use batched::{criterion_batched_p384_benchmark, criterion_batched_ristretto255_benchmark};
7+
use amortized::{criterion_amortized_p384_benchmark, criterion_amortized_ristretto255_benchmark};
88
use private::{criterion_private_p384_benchmark, criterion_private_ristretto255_benchmark};
99
use public::criterion_public_benchmark;
1010

@@ -13,7 +13,7 @@ criterion_group!(
1313
criterion_private_p384_benchmark,
1414
criterion_private_ristretto255_benchmark,
1515
criterion_public_benchmark,
16-
criterion_batched_ristretto255_benchmark,
17-
criterion_batched_p384_benchmark
16+
criterion_amortized_ristretto255_benchmark,
17+
criterion_amortized_p384_benchmark
1818
);
1919
criterion_main!(benches);

0 commit comments

Comments
 (0)