Skip to content

Commit 1073365

Browse files
raphaelrobertraphaelrobert
authored
feat: Introduce arbitrary batched tokens (#36)
* feat: Introduce arbitrary batched tokens * Update nom * Adaptd batched tokens to new API * Upgrade to 2024 edition
1 parent 35207d3 commit 1073365

37 files changed

+2244
-865
lines changed

‎.gitignore‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,4 @@
11
/target
22
/Cargo.lock
33
.vscode/
4+
.DS_Store

‎Cargo.toml‎

Lines changed: 10 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
[package]
22
name = "privacypass"
33
version = "0.2.0-pre.0"
4-
edition = "2021"
4+
edition = "2024"
55
description = "Implementation of Privacy Pass"
66
license = "MIT"
77
documentation = "https://docs.rs/privacypass"
@@ -20,12 +20,12 @@ categories = ["cryptography", "privacy"]
2020
async-trait = "0.1.56"
2121
base64 = "0.22.0"
2222
generic-array = "0.14.5"
23-
rand = "0.8.5"
23+
rand = "0.8"
2424
serde = "1"
2525
sha2 = "0.10.2"
26-
thiserror = "1"
27-
tls_codec = { version = "0.4.1" }
28-
tls_codec_derive = "0.4.1"
26+
thiserror = "2"
27+
tls_codec = { version = "0.4.2" }
28+
tls_codec_derive = "0.4.2"
2929
voprf = { version = "0.5", features = ["serde"] }
3030
p384 = { version = "0.13.0", default-features = false, features = [
3131
"hash2curve",
@@ -34,15 +34,17 @@ p384 = { version = "0.13.0", default-features = false, features = [
3434
blind-rsa-signatures = "0.15.0"
3535
http = "1"
3636
typenum = "1.15.0"
37-
nom = "7"
37+
nom = "8"
38+
tokio = { version = "1.20.0", features = ["full"], optional = true }
3839

3940
[features]
4041
default = []
4142
kat = ["voprf/danger"]
43+
test-utils = ["tokio"]
4244

4345
[dev-dependencies]
44-
privacypass = { path = ".", features = ["kat"] }
45-
tokio = { version = "1.20.0", features = ["full"] }
46+
privacypass = { path = ".", features = ["kat", "test-utils"] }
47+
futures = "0.3"
4648
criterion = { version = "0.5.0", features = ["async_futures", "async_tokio"] }
4749
hex = { version = "0.4.3", features = ["serde"] }
4850
serde_json = "1.0"

‎benches/batched_p384.rs‎

Lines changed: 15 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,9 @@ mod batched_memory_stores;
55
use criterion::{async_executor::FuturesExecutor, Criterion};
66
use tokio::runtime::Runtime;
77

8-
use privacypass::{auth::authenticate::TokenChallenge, TokenType};
8+
use privacypass::{
9+
auth::authenticate::TokenChallenge, batched_tokens_p384::TokenRequest, TokenType,
10+
};
911

1012
async fn create_batched_keypair(
1113
key_store: batched_memory_stores::MemoryKeyStoreP384,
@@ -62,17 +64,16 @@ pub fn criterion_batched_p384_benchmark(c: &mut Criterion) {
6264
let rt = Runtime::new().unwrap();
6365
let public_key =
6466
rt.block_on(async { server.create_keypair(&key_store).await.unwrap() });
65-
let client = privacypass::batched_tokens_p384::client::Client::new(public_key);
6667
let challenge = TokenChallenge::new(
6768
TokenType::BatchedTokenP384,
6869
"example.com",
6970
None,
7071
&["example.com".to_string()],
7172
);
72-
(client, challenge)
73+
(public_key, challenge)
7374
},
74-
|(client, challenge)| {
75-
client.issue_token_request(&challenge, NR).unwrap();
75+
|(public_key, challenge)| {
76+
TokenRequest::new(public_key, &challenge, NR).unwrap();
7677
},
7778
);
7879
},
@@ -89,15 +90,14 @@ pub fn criterion_batched_p384_benchmark(c: &mut Criterion) {
8990
let rt = Runtime::new().unwrap();
9091
let public_key =
9192
rt.block_on(async { server.create_keypair(&key_store).await.unwrap() });
92-
let client = privacypass::batched_tokens_p384::client::Client::new(public_key);
9393
let challenge = TokenChallenge::new(
9494
TokenType::BatchedTokenP384,
9595
"example.com",
9696
None,
9797
&["example.com".to_string()],
9898
);
99-
let (token_request, _token_states) =
100-
client.issue_token_request(&challenge, NR).unwrap();
99+
let (token_request, _token_state) =
100+
TokenRequest::new(public_key, &challenge, NR).unwrap();
101101
(key_store, server, token_request)
102102
},
103103
|(key_store, server, token_request)| {
@@ -118,25 +118,24 @@ pub fn criterion_batched_p384_benchmark(c: &mut Criterion) {
118118
let rt = Runtime::new().unwrap();
119119
let public_key =
120120
rt.block_on(async { server.create_keypair(&key_store).await.unwrap() });
121-
let client = privacypass::batched_tokens_p384::client::Client::new(public_key);
122121
let challenge = TokenChallenge::new(
123122
TokenType::BatchedTokenP384,
124123
"example.com",
125124
None,
126125
&["example.com".to_string()],
127126
);
128-
let (token_request, token_states) =
129-
client.issue_token_request(&challenge, NR).unwrap();
127+
let (token_request, token_state) =
128+
TokenRequest::new(public_key, &challenge, NR).unwrap();
130129
let token_response = rt.block_on(async {
131130
server
132131
.issue_token_response(&key_store, token_request)
133132
.await
134133
.unwrap()
135134
});
136-
(client, token_response, token_states)
135+
(token_response, token_state)
137136
},
138-
|(client, token_response, token_states)| {
139-
client.issue_tokens(&token_response, &token_states).unwrap();
137+
|(token_response, token_state)| {
138+
token_response.issue_tokens(&token_state).unwrap();
140139
},
141140
);
142141
},
@@ -152,22 +151,21 @@ pub fn criterion_batched_p384_benchmark(c: &mut Criterion) {
152151
let rt = Runtime::new().unwrap();
153152
let public_key =
154153
rt.block_on(async { server.create_keypair(&key_store).await.unwrap() });
155-
let client = privacypass::batched_tokens_p384::client::Client::new(public_key);
156154
let challenge = TokenChallenge::new(
157155
TokenType::BatchedTokenP384,
158156
"example.com",
159157
None,
160158
&["example.com".to_string()],
161159
);
162160
let (token_request, token_state) =
163-
client.issue_token_request(&challenge, NR).unwrap();
161+
TokenRequest::new(public_key, &challenge, NR).unwrap();
164162
let token_response = rt.block_on(async {
165163
server
166164
.issue_token_response(&key_store, token_request)
167165
.await
168166
.unwrap()
169167
});
170-
let tokens = client.issue_tokens(&token_response, &token_state).unwrap();
168+
let tokens = token_response.issue_tokens(&token_state).unwrap();
171169
(key_store, nonce_store, tokens, server)
172170
},
173171
|(key_store, nonce_store, tokens, server)| {

‎benches/batched_ristretto255.rs‎

Lines changed: 15 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,9 @@ mod batched_memory_stores;
55
use criterion::{async_executor::FuturesExecutor, Criterion};
66
use tokio::runtime::Runtime;
77

8-
use privacypass::{auth::authenticate::TokenChallenge, TokenType};
8+
use privacypass::{
9+
auth::authenticate::TokenChallenge, batched_tokens_ristretto255::TokenRequest, TokenType,
10+
};
911

1012
async fn create_batched_keypair(
1113
key_store: batched_memory_stores::MemoryKeyStoreRistretto255,
@@ -62,18 +64,16 @@ pub fn criterion_batched_ristretto255_benchmark(c: &mut Criterion) {
6264
let rt = Runtime::new().unwrap();
6365
let public_key =
6466
rt.block_on(async { server.create_keypair(&key_store).await.unwrap() });
65-
let client =
66-
privacypass::batched_tokens_ristretto255::client::Client::new(public_key);
6767
let challenge = TokenChallenge::new(
6868
TokenType::BatchedTokenRistretto255,
6969
"example.com",
7070
None,
7171
&["example.com".to_string()],
7272
);
73-
(client, challenge)
73+
(public_key, challenge)
7474
},
75-
|(client, challenge)| {
76-
client.issue_token_request(&challenge, NR).unwrap();
75+
|(public_key, challenge)| {
76+
TokenRequest::new(public_key, &challenge, NR).unwrap();
7777
},
7878
);
7979
},
@@ -90,16 +90,14 @@ pub fn criterion_batched_ristretto255_benchmark(c: &mut Criterion) {
9090
let rt = Runtime::new().unwrap();
9191
let public_key =
9292
rt.block_on(async { server.create_keypair(&key_store).await.unwrap() });
93-
let client =
94-
privacypass::batched_tokens_ristretto255::client::Client::new(public_key);
9593
let challenge = TokenChallenge::new(
9694
TokenType::BatchedTokenRistretto255,
9795
"example.com",
9896
None,
9997
&["example.com".to_string()],
10098
);
101-
let (token_request, _token_states) =
102-
client.issue_token_request(&challenge, NR).unwrap();
99+
let (token_request, _token_state) =
100+
TokenRequest::new(public_key, &challenge, NR).unwrap();
103101
(key_store, server, token_request)
104102
},
105103
|(key_store, server, token_request)| {
@@ -120,26 +118,24 @@ pub fn criterion_batched_ristretto255_benchmark(c: &mut Criterion) {
120118
let rt = Runtime::new().unwrap();
121119
let public_key =
122120
rt.block_on(async { server.create_keypair(&key_store).await.unwrap() });
123-
let client =
124-
privacypass::batched_tokens_ristretto255::client::Client::new(public_key);
125121
let challenge = TokenChallenge::new(
126122
TokenType::BatchedTokenRistretto255,
127123
"example.com",
128124
None,
129125
&["example.com".to_string()],
130126
);
131-
let (token_request, token_states) =
132-
client.issue_token_request(&challenge, NR).unwrap();
127+
let (token_request, token_state) =
128+
TokenRequest::new(public_key, &challenge, NR).unwrap();
133129
let token_response = rt.block_on(async {
134130
server
135131
.issue_token_response(&key_store, token_request)
136132
.await
137133
.unwrap()
138134
});
139-
(client, token_response, token_states)
135+
(token_response, token_state)
140136
},
141-
|(client, token_response, token_states)| {
142-
client.issue_tokens(&token_response, &token_states).unwrap();
137+
|(token_response, token_state)| {
138+
token_response.issue_tokens(&token_state).unwrap();
143139
},
144140
);
145141
},
@@ -155,23 +151,21 @@ pub fn criterion_batched_ristretto255_benchmark(c: &mut Criterion) {
155151
let rt = Runtime::new().unwrap();
156152
let public_key =
157153
rt.block_on(async { server.create_keypair(&key_store).await.unwrap() });
158-
let client =
159-
privacypass::batched_tokens_ristretto255::client::Client::new(public_key);
160154
let challenge = TokenChallenge::new(
161155
TokenType::BatchedTokenRistretto255,
162156
"example.com",
163157
None,
164158
&["example.com".to_string()],
165159
);
166160
let (token_request, token_state) =
167-
client.issue_token_request(&challenge, NR).unwrap();
161+
TokenRequest::new(public_key, &challenge, NR).unwrap();
168162
let token_response = rt.block_on(async {
169163
server
170164
.issue_token_response(&key_store, token_request)
171165
.await
172166
.unwrap()
173167
});
174-
let tokens = client.issue_tokens(&token_response, &token_state).unwrap();
168+
let tokens = token_response.issue_tokens(&token_state).unwrap();
175169
(key_store, nonce_store, tokens, server)
176170
},
177171
|(key_store, nonce_store, tokens, server)| {

‎benches/private.rs‎

Lines changed: 17 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -1,11 +1,11 @@
1-
#[path = "../tests/private_memory_stores.rs"]
2-
mod private_memory_stores;
3-
41
use criterion::{async_executor::FuturesExecutor, Criterion};
52
use generic_array::ArrayLength;
63
use tokio::runtime::Runtime;
74

8-
use privacypass::{auth::authenticate::TokenChallenge, TokenType};
5+
use privacypass::{
6+
auth::authenticate::TokenChallenge, private_tokens::TokenRequest,
7+
test_utils::private_memory_stores, TokenType,
8+
};
99

1010
async fn create_private_keypair(
1111
key_store: private_memory_stores::MemoryKeyStore,
@@ -59,17 +59,16 @@ pub fn criterion_private_benchmark(c: &mut Criterion) {
5959
let rt = Runtime::new().unwrap();
6060
let public_key =
6161
rt.block_on(async { server.create_keypair(&key_store).await.unwrap() });
62-
let client = privacypass::private_tokens::client::Client::new(public_key);
6362
let challenge = TokenChallenge::new(
6463
TokenType::PrivateToken,
6564
"example.com",
6665
None,
6766
&["example.com".to_string()],
6867
);
69-
(client, challenge)
68+
(public_key, challenge)
7069
},
71-
|(client, challenge)| {
72-
client.issue_token_request(&challenge).unwrap();
70+
|(public_key, challenge)| {
71+
TokenRequest::new(public_key, &challenge).unwrap();
7372
},
7473
);
7574
});
@@ -83,14 +82,14 @@ pub fn criterion_private_benchmark(c: &mut Criterion) {
8382
let rt = Runtime::new().unwrap();
8483
let public_key =
8584
rt.block_on(async { server.create_keypair(&key_store).await.unwrap() });
86-
let client = privacypass::private_tokens::client::Client::new(public_key);
8785
let challenge = TokenChallenge::new(
8886
TokenType::PrivateToken,
8987
"example.com",
9088
None,
9189
&["example.com".to_string()],
9290
);
93-
let (token_request, _token_state) = client.issue_token_request(&challenge).unwrap();
91+
let (token_request, _token_state) =
92+
TokenRequest::new(public_key, &challenge).unwrap();
9493
(key_store, server, token_request)
9594
},
9695
|(key_store, server, token_request)| {
@@ -108,24 +107,24 @@ pub fn criterion_private_benchmark(c: &mut Criterion) {
108107
let rt = Runtime::new().unwrap();
109108
let public_key =
110109
rt.block_on(async { server.create_keypair(&key_store).await.unwrap() });
111-
let client = privacypass::private_tokens::client::Client::new(public_key);
112110
let challenge = TokenChallenge::new(
113111
TokenType::PrivateToken,
114112
"example.com",
115113
None,
116114
&["example.com".to_string()],
117115
);
118-
let (token_request, token_state) = client.issue_token_request(&challenge).unwrap();
116+
let (token_request, token_state) =
117+
TokenRequest::new(public_key, &challenge).unwrap();
119118
let token_response = rt.block_on(async {
120119
server
121120
.issue_token_response(&key_store, token_request)
122121
.await
123122
.unwrap()
124123
});
125-
(client, token_response, token_state)
124+
(token_response, token_state)
126125
},
127-
|(client, token_response, token_state)| {
128-
client.issue_token(&token_response, &token_state).unwrap();
126+
|(token_response, token_state)| {
127+
token_response.issue_token(&token_state).unwrap();
129128
},
130129
);
131130
});
@@ -140,21 +139,21 @@ pub fn criterion_private_benchmark(c: &mut Criterion) {
140139
let rt = Runtime::new().unwrap();
141140
let public_key =
142141
rt.block_on(async { server.create_keypair(&key_store).await.unwrap() });
143-
let client = privacypass::private_tokens::client::Client::new(public_key);
144142
let challenge = TokenChallenge::new(
145143
TokenType::PrivateToken,
146144
"example.com",
147145
None,
148146
&["example.com".to_string()],
149147
);
150-
let (token_request, token_state) = client.issue_token_request(&challenge).unwrap();
148+
let (token_request, token_state) =
149+
TokenRequest::new(public_key, &challenge).unwrap();
151150
let token_response = rt.block_on(async {
152151
server
153152
.issue_token_response(&key_store, token_request)
154153
.await
155154
.unwrap()
156155
});
157-
let token = client.issue_token(&token_response, &token_state).unwrap();
156+
let token = token_response.issue_token(&token_state).unwrap();
158157
(key_store, nonce_store, token, server)
159158
},
160159
|(key_store, nonce_store, token, server)| {

0 commit comments

Comments
 (0)