Skip to main content

canic_core/dto/
auth.rs

1use crate::dto::{error::Error, prelude::*, rpc::RootRequestMetadata};
2
3//
4// DelegationCert
5//
6
7#[derive(CandidType, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
8pub struct DelegationCert {
9    pub root_pid: Principal,
10    pub shard_pid: Principal,
11    pub issued_at: u64,
12    pub expires_at: u64,
13    pub scopes: Vec<String>,
14    pub aud: Vec<Principal>,
15}
16
17//
18// DelegationProof
19//
20
21#[derive(CandidType, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
22pub struct DelegationProof {
23    pub cert: DelegationCert,
24    pub cert_sig: Vec<u8>,
25}
26
27//
28// DelegationProofInstallIntent
29//
30
31#[derive(CandidType, Clone, Copy, Debug, Deserialize, Eq, PartialEq)]
32pub enum DelegationProofInstallIntent {
33    Provisioning,
34    Prewarm,
35    Repair,
36}
37
38//
39// DelegationProofInstallRequest
40//
41
42#[derive(CandidType, Clone, Debug, Deserialize)]
43pub struct DelegationProofInstallRequest {
44    pub proof: DelegationProof,
45    pub intent: DelegationProofInstallIntent,
46    #[serde(default)]
47    pub root_public_key_sec1: Option<Vec<u8>>,
48    #[serde(default)]
49    pub shard_public_key_sec1: Option<Vec<u8>>,
50}
51
52//
53// DelegatedTokenClaims
54//
55
56#[derive(CandidType, Clone, Debug, Deserialize)]
57pub struct DelegatedTokenClaims {
58    pub sub: Principal,
59    pub shard_pid: Principal,
60    pub scopes: Vec<String>,
61    pub aud: Vec<Principal>,
62    pub iat: u64,
63    pub exp: u64,
64    // Optional signed application payload. CANIC preserves this field but does
65    // not interpret it; applications own its schema and authorization meaning.
66    #[serde(default)]
67    pub ext: Option<Vec<u8>>,
68}
69
70//
71// DelegatedToken
72//
73
74#[derive(CandidType, Clone, Debug, Deserialize)]
75pub struct DelegatedToken {
76    pub claims: DelegatedTokenClaims,
77    pub proof: DelegationProof,
78    pub token_sig: Vec<u8>,
79}
80
81//
82// DelegationRequest
83//
84
85#[derive(CandidType, Clone, Debug, Deserialize)]
86pub struct DelegationRequest {
87    pub shard_pid: Principal,
88    pub scopes: Vec<String>,
89    pub aud: Vec<Principal>,
90    pub ttl_secs: u64,
91    pub verifier_targets: Vec<Principal>,
92    pub include_root_verifier: bool,
93    #[serde(default)]
94    pub shard_public_key_sec1: Option<Vec<u8>>,
95    #[serde(default)]
96    pub metadata: Option<RootRequestMetadata>,
97}
98
99//
100// RoleAttestationRequest
101//
102
103#[derive(CandidType, Clone, Debug, Deserialize)]
104pub struct RoleAttestationRequest {
105    pub subject: Principal,
106    pub role: CanisterRole,
107    #[serde(default)]
108    pub subnet_id: Option<Principal>,
109    #[serde(default)]
110    pub audience: Option<Principal>,
111    pub ttl_secs: u64,
112    pub epoch: u64,
113    #[serde(default)]
114    pub metadata: Option<RootRequestMetadata>,
115}
116
117//
118// RoleAttestation
119//
120
121#[derive(CandidType, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
122pub struct RoleAttestation {
123    pub subject: Principal,
124    pub role: CanisterRole,
125    #[serde(default)]
126    pub subnet_id: Option<Principal>,
127    #[serde(default)]
128    pub audience: Option<Principal>,
129    pub issued_at: u64,
130    pub expires_at: u64,
131    pub epoch: u64,
132}
133
134//
135// SignedRoleAttestation
136//
137
138#[derive(CandidType, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
139pub struct SignedRoleAttestation {
140    pub payload: RoleAttestation,
141    pub signature: Vec<u8>,
142    pub key_id: u32,
143}
144
145//
146// AttestationKeyStatus
147//
148
149#[derive(CandidType, Clone, Copy, Debug, Deserialize, Eq, PartialEq)]
150pub enum AttestationKeyStatus {
151    Current,
152    Previous,
153}
154
155//
156// AttestationKey
157//
158
159#[derive(CandidType, Clone, Debug, Deserialize, Eq, PartialEq)]
160pub struct AttestationKey {
161    pub key_id: u32,
162    pub public_key: Vec<u8>,
163    pub status: AttestationKeyStatus,
164    #[serde(default)]
165    pub valid_from: Option<u64>,
166    #[serde(default)]
167    pub valid_until: Option<u64>,
168}
169
170//
171// AttestationKeySet
172//
173
174#[derive(CandidType, Clone, Debug, Deserialize, Eq, PartialEq)]
175pub struct AttestationKeySet {
176    pub root_pid: Principal,
177    pub generated_at: u64,
178    pub keys: Vec<AttestationKey>,
179}
180
181// admin-only: not part of canonical delegation flow.
182// used for controlled provisioning and tooling flows.
183//
184// DelegationProvisionRequest
185//
186
187#[derive(CandidType, Clone, Debug, Deserialize)]
188pub struct DelegationProvisionRequest {
189    pub cert: DelegationCert,
190    pub signer_targets: Vec<Principal>,
191    pub verifier_targets: Vec<Principal>,
192    #[serde(default)]
193    pub shard_public_key_sec1: Option<Vec<u8>>,
194}
195
196// admin-only: not part of canonical delegation flow.
197// used for controlled provisioning and tooling flows.
198//
199// DelegationProvisionResponse
200//
201
202#[derive(CandidType, Clone, Debug, Deserialize, Serialize)]
203pub struct DelegationProvisionResponse {
204    pub proof: DelegationProof,
205    pub results: Vec<DelegationProvisionTargetResponse>,
206}
207
208//
209// DelegationVerifierProofPushRequest
210//
211
212#[derive(CandidType, Clone, Debug, Deserialize, Eq, PartialEq)]
213pub struct DelegationVerifierProofPushRequest {
214    pub proof: DelegationProof,
215    pub verifier_targets: Vec<Principal>,
216}
217
218//
219// DelegationVerifierProofPushResponse
220//
221
222#[derive(CandidType, Clone, Debug, Deserialize)]
223pub struct DelegationVerifierProofPushResponse {
224    pub results: Vec<DelegationProvisionTargetResponse>,
225}
226
227//
228// DelegationProofStatus
229//
230
231#[derive(CandidType, Clone, Debug, Deserialize, Eq, PartialEq)]
232pub struct DelegationProofStatus {
233    pub shard_pid: Principal,
234    pub issued_at: u64,
235    pub expires_at: u64,
236}
237
238#[derive(CandidType, Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
239pub enum DelegationProvisionTargetKind {
240    Signer,
241    Verifier,
242}
243
244#[derive(CandidType, Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
245pub enum DelegationProvisionStatus {
246    Ok,
247    Failed,
248}
249
250//
251// DelegationAdminCommand
252//
253
254#[derive(CandidType, Clone, Debug, Deserialize)]
255pub enum DelegationAdminCommand {
256    PrewarmVerifiers(DelegationVerifierProofPushRequest),
257    RepairVerifiers(DelegationVerifierProofPushRequest),
258}
259
260//
261// DelegationAdminResponse
262//
263
264#[derive(CandidType, Clone, Debug, Deserialize)]
265pub enum DelegationAdminResponse {
266    PrewarmedVerifiers {
267        result: DelegationVerifierProofPushResponse,
268    },
269    RepairedVerifiers {
270        result: DelegationVerifierProofPushResponse,
271    },
272}
273
274//
275// DelegationProvisionTargetResponse
276//
277
278#[derive(CandidType, Clone, Debug, Deserialize, Serialize)]
279pub struct DelegationProvisionTargetResponse {
280    pub target: Principal,
281    pub kind: DelegationProvisionTargetKind,
282    pub status: DelegationProvisionStatus,
283    pub error: Option<Error>,
284}