1use std::sync::Arc;
2
3use base64::Engine as _;
4use serde::{Deserialize, Serialize};
5use sha2::{Digest, Sha256};
6use subtle::ConstantTimeEq as _;
7
8use crate::entity::{
9 AccessToken, AuthCode, Client, DeviceCode, PersonalAccessTokenResult, RefreshToken, UserId,
10};
11use crate::error::Error;
12use crate::jwt::{AccessTokenClaims, SigningKey, now_secs, sign_access_token, verify_access_token};
13use crate::store::Stores;
14
15pub const DEVICE_CODE_GRANT_TYPE: &str = "urn:ietf:params:oauth:grant-type:device_code";
16
17#[derive(Debug, Clone)]
18pub struct Config {
19 pub issuer: String,
20 pub audience: String,
21 pub access_token_ttl_secs: i64,
22 pub refresh_token_ttl_secs: i64,
23 pub auth_code_ttl_secs: i64,
24 pub personal_access_token_ttl_secs: i64,
25 pub device_code_ttl_secs: i64,
26 pub device_code_interval_secs: i64,
27 pub verification_uri: String,
28 pub allow_plain_pkce: bool,
29}
30
31impl Default for Config {
32 fn default() -> Self {
33 let year = 365 * 24 * 60 * 60;
34 Self {
35 issuer: "rustbasic-passport".into(),
36 audience: "rustbasic-passport".into(),
37 access_token_ttl_secs: year,
38 refresh_token_ttl_secs: year,
39 auth_code_ttl_secs: 10 * 60,
40 personal_access_token_ttl_secs: year,
41 device_code_ttl_secs: 10 * 60,
42 device_code_interval_secs: 5,
43 verification_uri: "https://localhost/oauth/device".into(),
44 allow_plain_pkce: true,
45 }
46 }
47}
48
49#[derive(Debug, Clone, Default, Deserialize)]
50#[serde(default)]
51pub struct TokenRequest {
52 pub grant_type: Option<String>,
53 pub client_id: Option<String>,
54 pub client_secret: Option<String>,
55 pub username: Option<String>,
56 pub password: Option<String>,
57 pub scope: Option<String>,
58 pub code: Option<String>,
59 pub redirect_uri: Option<String>,
60 pub code_verifier: Option<String>,
61 pub refresh_token: Option<String>,
62 pub device_code: Option<String>,
63 pub user_id: Option<String>,
64}
65
66#[derive(Debug, Clone, Serialize)]
67pub struct TokenResponse {
68 pub token_type: String,
69 pub expires_in: i64,
70 pub access_token: String,
71 #[serde(skip_serializing_if = "Option::is_none")]
72 pub refresh_token: Option<String>,
73 #[serde(skip_serializing_if = "Option::is_none")]
74 pub scope: Option<String>,
75}
76
77#[derive(Debug, Clone, Default, Deserialize)]
78#[serde(default)]
79pub struct AuthorizeRequest {
80 pub client_id: Option<String>,
81 pub redirect_uri: Option<String>,
82 pub response_type: Option<String>,
83 pub scope: Option<String>,
84 pub state: Option<String>,
85 pub code_challenge: Option<String>,
86 pub code_challenge_method: Option<String>,
87 pub user_id: Option<String>,
88}
89
90#[derive(Debug, Clone)]
91pub struct AuthorizeDecision {
92 pub redirect_uri: String,
93 pub code: String,
94 pub state: Option<String>,
95}
96
97#[derive(Debug, Clone, Default, Deserialize)]
98#[serde(default)]
99pub struct DeviceAuthorizationRequest {
100 pub client_id: Option<String>,
101 pub client_secret: Option<String>,
102 pub scope: Option<String>,
103}
104
105#[derive(Debug, Clone, Serialize)]
106pub struct DeviceAuthorizationResponse {
107 pub device_code: String,
108 pub user_code: String,
109 pub verification_uri: String,
110 pub verification_uri_complete: String,
111 pub expires_in: i64,
112 pub interval: i64,
113}
114
115#[derive(Debug, Clone)]
116pub struct ValidatedToken {
117 pub claims: AccessTokenClaims,
118 pub token: AccessToken,
119}
120
121struct ServerInner<S: Stores> {
122 config: Config,
123 key: SigningKey,
124 stores: S,
125}
126
127pub struct PassportServer<S: Stores> {
128 inner: Arc<ServerInner<S>>,
129}
130
131impl<S: Stores> Clone for PassportServer<S> {
132 fn clone(&self) -> Self {
133 Self {
134 inner: Arc::clone(&self.inner),
135 }
136 }
137}
138
139impl<S: Stores> PassportServer<S> {
140 pub fn new(stores: S, key: SigningKey, config: Config) -> Self {
141 Self {
142 inner: Arc::new(ServerInner {
143 config,
144 key,
145 stores,
146 }),
147 }
148 }
149
150 pub fn config(&self) -> &Config {
151 &self.inner.config
152 }
153
154 pub fn stores(&self) -> &S {
155 &self.inner.stores
156 }
157
158 pub fn signing_key(&self) -> &SigningKey {
159 &self.inner.key
160 }
161
162 pub async fn issue_token(&self, req: &TokenRequest) -> Result<TokenResponse, Error> {
163 let grant = req
164 .grant_type
165 .as_deref()
166 .ok_or_else(|| Error::InvalidRequest("grant_type is required".into()))?;
167 match grant {
168 "authorization_code" => self.grant_authorization_code(req).await,
169 "password" => self.grant_password(req).await,
170 "client_credentials" => self.grant_client_credentials(req).await,
171 "refresh_token" => self.grant_refresh_token(req).await,
172 "personal_access" => self.grant_personal_access(req).await,
173 DEVICE_CODE_GRANT_TYPE => self.grant_device_code(req).await,
174 other => Err(Error::UnknownGrant(other.into())),
175 }
176 }
177
178 pub async fn grant_password(&self, req: &TokenRequest) -> Result<TokenResponse, Error> {
179 let client = self.resolve_client(req, "password").await?;
180 let username = req
181 .username
182 .as_deref()
183 .ok_or_else(|| Error::InvalidRequest("username is required".into()))?;
184 let password = req
185 .password
186 .as_deref()
187 .ok_or_else(|| Error::InvalidRequest("password is required".into()))?;
188 let user_id = self
189 .inner
190 .stores
191 .users()
192 .find_by_credentials(username, password)
193 .await?
194 .ok_or_else(|| Error::InvalidGrant("invalid username or password".into()))?;
195
196 let scopes = parse_scopes(req.scope.as_deref());
197 let (access, jwt) = self
198 .create_access_token(&client.id, Some(user_id), scopes, None)
199 .await?;
200 let refresh = self
201 .create_refresh_token(&client.id, &access.id, self.inner.config.refresh_token_ttl_secs)
202 .await?;
203 Ok(TokenResponse {
204 token_type: "Bearer".into(),
205 expires_in: self.inner.config.access_token_ttl_secs,
206 access_token: jwt,
207 refresh_token: Some(refresh.id),
208 scope: join_scopes(&access.scopes),
209 })
210 }
211
212 pub async fn grant_client_credentials(
213 &self,
214 req: &TokenRequest,
215 ) -> Result<TokenResponse, Error> {
216 let client = self.resolve_client(req, "client_credentials").await?;
217 let scopes = parse_scopes(req.scope.as_deref());
218 let (access, jwt) = self
219 .create_access_token(&client.id, None, scopes, None)
220 .await?;
221 Ok(TokenResponse {
222 token_type: "Bearer".into(),
223 expires_in: self.inner.config.access_token_ttl_secs,
224 access_token: jwt,
225 refresh_token: None,
226 scope: join_scopes(&access.scopes),
227 })
228 }
229
230 pub async fn grant_authorization_code(
231 &self,
232 req: &TokenRequest,
233 ) -> Result<TokenResponse, Error> {
234 let client = self.resolve_client(req, "authorization_code").await?;
235 let code_id = req
236 .code
237 .as_deref()
238 .ok_or_else(|| Error::InvalidRequest("code is required".into()))?;
239 let code = self
240 .inner
241 .stores
242 .auth_codes()
243 .find_by_id(code_id)
244 .await?
245 .ok_or_else(|| Error::InvalidGrant("authorization code not found".into()))?;
246 if code.revoked {
247 return Err(Error::InvalidGrant(
248 "authorization code has been used".into(),
249 ));
250 }
251 if code.expires_at < now_secs() {
252 return Err(Error::InvalidGrant("authorization code has expired".into()));
253 }
254 if code.client_id != client.id {
255 return Err(Error::InvalidGrant(
256 "authorization code was issued to another client".into(),
257 ));
258 }
259 let redirect_uri = req
260 .redirect_uri
261 .as_deref()
262 .ok_or_else(|| Error::InvalidRequest("redirect_uri is required".into()))?;
263 if redirect_uri != code.redirect_uri {
264 return Err(Error::RedirectUriMismatch);
265 }
266 self.verify_pkce(req, &code).await?;
267
268 let revoked = self
269 .inner
270 .stores
271 .auth_codes()
272 .revoke_if_unrevoked(code_id)
273 .await?;
274 if !revoked {
275 return Err(Error::InvalidGrant(
276 "authorization code has been used".into(),
277 ));
278 }
279
280 let scopes = if let Some(requested) = req.scope.as_deref() {
281 let requested = parse_scopes(Some(requested));
282 if !is_subset(&requested, &code.scopes) {
283 return Err(Error::InvalidScope(
284 "requested scope exceeds the authorized scope".into(),
285 ));
286 }
287 requested
288 } else {
289 code.scopes.clone()
290 };
291
292 let (access, jwt) = self
293 .create_access_token(&client.id, code.user_id.clone(), scopes, None)
294 .await?;
295 let refresh = self
296 .create_refresh_token(&client.id, &access.id, self.inner.config.refresh_token_ttl_secs)
297 .await?;
298 Ok(TokenResponse {
299 token_type: "Bearer".into(),
300 expires_in: self.inner.config.access_token_ttl_secs,
301 access_token: jwt,
302 refresh_token: Some(refresh.id),
303 scope: join_scopes(&access.scopes),
304 })
305 }
306
307 pub async fn grant_refresh_token(&self, req: &TokenRequest) -> Result<TokenResponse, Error> {
308 let client = self.resolve_client(req, "refresh_token").await?;
309 let rt_id = req
310 .refresh_token
311 .as_deref()
312 .ok_or_else(|| Error::InvalidRequest("refresh_token is required".into()))?;
313 let refresh = self
314 .inner
315 .stores
316 .refresh_tokens()
317 .find_by_id(rt_id)
318 .await?
319 .ok_or_else(|| Error::InvalidGrant("refresh token not found".into()))?;
320 if refresh.revoked {
321 return Err(Error::InvalidGrant("refresh token has been used".into()));
322 }
323 if refresh.expires_at < now_secs() {
324 return Err(Error::InvalidGrant("refresh token has expired".into()));
325 }
326 if refresh.client_id != client.id {
327 return Err(Error::InvalidGrant(
328 "refresh token was issued to another client".into(),
329 ));
330 }
331
332 let revoked = self
333 .inner
334 .stores
335 .refresh_tokens()
336 .revoke_if_unrevoked(rt_id)
337 .await?;
338 if !revoked {
339 return Err(Error::InvalidGrant("refresh token has been used".into()));
340 }
341
342 let old_access = self
343 .inner
344 .stores
345 .tokens()
346 .find_by_id(&refresh.access_token_id)
347 .await?
348 .ok_or_else(|| Error::InvalidGrant("access token not found".into()))?;
349
350 let scopes = if let Some(requested) = req.scope.as_deref() {
351 let requested = parse_scopes(Some(requested));
352 if !is_subset(&requested, &old_access.scopes) {
353 return Err(Error::InvalidScope(
354 "requested scope exceeds the original token scope".into(),
355 ));
356 }
357 requested
358 } else {
359 old_access.scopes.clone()
360 };
361
362 let (access, jwt) = self
363 .create_access_token(
364 &client.id,
365 old_access.user_id.clone(),
366 scopes,
367 old_access.name.clone(),
368 )
369 .await?;
370 let new_refresh = self
371 .create_refresh_token(&client.id, &access.id, self.inner.config.refresh_token_ttl_secs)
372 .await?;
373 Ok(TokenResponse {
374 token_type: "Bearer".into(),
375 expires_in: self.inner.config.access_token_ttl_secs,
376 access_token: jwt,
377 refresh_token: Some(new_refresh.id),
378 scope: join_scopes(&access.scopes),
379 })
380 }
381
382 pub async fn grant_personal_access(&self, req: &TokenRequest) -> Result<TokenResponse, Error> {
383 let client = self.resolve_client(req, "personal_access").await?;
384 let user_id = req
385 .user_id
386 .clone()
387 .ok_or_else(|| Error::InvalidRequest("user_id is required".into()))?;
388 let scopes = parse_scopes(req.scope.as_deref());
389 let (access, jwt) = self
390 .create_access_token(&client.id, Some(user_id), scopes, None)
391 .await?;
392 Ok(TokenResponse {
393 token_type: "Bearer".into(),
394 expires_in: self.inner.config.personal_access_token_ttl_secs,
395 access_token: jwt,
396 refresh_token: None,
397 scope: join_scopes(&access.scopes),
398 })
399 }
400
401 pub async fn issue_device_code(
402 &self,
403 req: &DeviceAuthorizationRequest,
404 ) -> Result<DeviceAuthorizationResponse, Error> {
405 let client = self.resolve_device_client(req).await?;
406 let scopes = parse_scopes(req.scope.as_deref());
407 let now = now_secs();
408 let ttl = self.inner.config.device_code_ttl_secs;
409 let user_code = generate_user_code();
410 let code = DeviceCode {
411 id: uuid::Uuid::new_v4().to_string(),
412 user_id: None,
413 client_id: client.id,
414 user_code: user_code.clone(),
415 scopes,
416 revoked: false,
417 user_approved_at: None,
418 last_polled_at: None,
419 expires_at: now + ttl,
420 };
421 self.inner.stores.device_codes().save(&code).await?;
422 let verification_uri_complete = format!(
423 "{}?user_code={}",
424 self.inner.config.verification_uri, user_code
425 );
426 Ok(DeviceAuthorizationResponse {
427 device_code: code.id,
428 user_code,
429 verification_uri: self.inner.config.verification_uri.clone(),
430 verification_uri_complete,
431 expires_in: ttl,
432 interval: self.inner.config.device_code_interval_secs,
433 })
434 }
435
436 pub async fn approve_device_code(
437 &self,
438 user_id: impl Into<String>,
439 user_code: &str,
440 ) -> Result<DeviceCode, Error> {
441 let normalized = normalize_user_code(user_code);
442 let mut code = self
443 .inner
444 .stores
445 .device_codes()
446 .find_by_user_code(&normalized)
447 .await?
448 .ok_or_else(|| Error::InvalidGrant("user code not found".into()))?;
449 if code.expires_at < now_secs() {
450 return Err(Error::DeviceCodeExpired);
451 }
452 code.user_id = Some(user_id.into());
453 code.user_approved_at = Some(now_secs());
454 self.inner.stores.device_codes().save(&code).await?;
455 Ok(code)
456 }
457
458 pub async fn grant_device_code(&self, req: &TokenRequest) -> Result<TokenResponse, Error> {
459 let client = self.resolve_client(req, DEVICE_CODE_GRANT_TYPE).await?;
460 let code_id = req
461 .device_code
462 .as_deref()
463 .ok_or_else(|| Error::InvalidRequest("device_code is required".into()))?;
464 let mut code = self
465 .inner
466 .stores
467 .device_codes()
468 .find_by_device_code(code_id)
469 .await?
470 .ok_or_else(|| Error::InvalidGrant("device code not found".into()))?;
471 if code.client_id != client.id {
472 return Err(Error::InvalidGrant(
473 "device code was issued to another client".into(),
474 ));
475 }
476 if code.expires_at < now_secs() {
477 return Err(Error::DeviceCodeExpired);
478 }
479 if code.revoked {
480 return if code.user_approved_at.is_some() {
481 Err(Error::InvalidGrant("device code has been used".into()))
482 } else {
483 Err(Error::AccessDenied)
484 };
485 }
486 let now = now_secs();
487 if let Some(last) = code.last_polled_at
488 && now - last < self.inner.config.device_code_interval_secs
489 {
490 return Err(Error::SlowDown);
491 }
492 code.last_polled_at = Some(now);
493 self.inner.stores.device_codes().save(&code).await?;
494 if code.user_approved_at.is_none() {
495 return Err(Error::AuthorizationPending);
496 }
497
498 code.revoked = true;
499 self.inner.stores.device_codes().save(&code).await?;
500 let (access, jwt) = self
501 .create_access_token(&client.id, code.user_id.clone(), code.scopes.clone(), None)
502 .await?;
503 let refresh = self
504 .create_refresh_token(&client.id, &access.id, self.inner.config.refresh_token_ttl_secs)
505 .await?;
506 Ok(TokenResponse {
507 token_type: "Bearer".into(),
508 expires_in: self.inner.config.access_token_ttl_secs,
509 access_token: jwt,
510 refresh_token: Some(refresh.id),
511 scope: join_scopes(&access.scopes),
512 })
513 }
514
515 async fn resolve_device_client(
516 &self,
517 req: &DeviceAuthorizationRequest,
518 ) -> Result<Client, Error> {
519 let id = req
520 .client_id
521 .as_deref()
522 .ok_or_else(|| Error::InvalidRequest("client_id is required".into()))?;
523 let client = self
524 .inner
525 .stores
526 .clients()
527 .find_by_id(id)
528 .await?
529 .ok_or(Error::InvalidClient)?;
530 if client.revoked {
531 return Err(Error::InvalidClient);
532 }
533 if !client.has_grant_type(DEVICE_CODE_GRANT_TYPE) {
534 return Err(Error::InvalidGrant(
535 "client is not allowed to use the device authorization grant".into(),
536 ));
537 }
538 match (&client.secret, req.client_secret.as_deref()) {
539 (Some(expected), Some(provided)) if constant_time_eq(expected, provided) => {}
540 (None, None) => {}
541 (None, Some("")) => {}
542 _ => return Err(Error::InvalidClient),
543 }
544 Ok(client)
545 }
546
547 pub async fn create_personal_access_token(
548 &self,
549 user_id: impl Into<String>,
550 name: impl Into<String>,
551 scopes: Vec<String>,
552 ) -> Result<PersonalAccessTokenResult, Error> {
553 let client = self
554 .inner
555 .stores
556 .clients()
557 .find_personal_access_client()
558 .await?
559 .ok_or(Error::PersonalAccessClientNotFound)?;
560 if client.revoked {
561 return Err(Error::InvalidClient);
562 }
563 let (token, jwt) = self
564 .create_access_token(&client.id, Some(user_id.into()), scopes, Some(name.into()))
565 .await?;
566 Ok(PersonalAccessTokenResult {
567 access_token: jwt,
568 token,
569 })
570 }
571
572 pub async fn authorize(
573 &self,
574 user_id: impl Into<String>,
575 req: &AuthorizeRequest,
576 ) -> Result<AuthorizeDecision, Error> {
577 if req.response_type.as_deref() != Some("code") {
578 return Err(Error::UnsupportedResponseType(
579 req.response_type
580 .clone()
581 .unwrap_or_else(|| "missing".into()),
582 ));
583 }
584 let client_id = req
585 .client_id
586 .clone()
587 .ok_or_else(|| Error::InvalidRequest("client_id is required".into()))?;
588 let client = self
589 .inner
590 .stores
591 .clients()
592 .find_by_id(&client_id)
593 .await?
594 .ok_or(Error::ClientNotFound)?;
595 if client.revoked {
596 return Err(Error::InvalidClient);
597 }
598 if !client.has_grant_type("authorization_code") {
599 return Err(Error::InvalidGrant(
600 "client is not allowed to use the authorization_code grant".into(),
601 ));
602 }
603 let redirect_uri = req.redirect_uri.clone().ok_or(Error::RedirectUriMismatch)?;
604 if !client.redirect_uris.iter().any(|uri| uri == &redirect_uri) {
605 return Err(Error::RedirectUriMismatch);
606 }
607 let scopes = parse_scopes(req.scope.as_deref());
608 let now = now_secs();
609 let code = AuthCode {
610 id: uuid::Uuid::new_v4().to_string(),
611 user_id: Some(user_id.into()),
612 client_id,
613 scopes,
614 revoked: false,
615 expires_at: now + self.inner.config.auth_code_ttl_secs,
616 redirect_uri: redirect_uri.clone(),
617 code_challenge: req.code_challenge.clone(),
618 code_challenge_method: req.code_challenge_method.clone(),
619 };
620 self.inner.stores.auth_codes().save(&code).await?;
621 Ok(AuthorizeDecision {
622 redirect_uri,
623 code: code.id,
624 state: req.state.clone(),
625 })
626 }
627
628 pub async fn validate_access_token(&self, token_str: &str) -> Result<ValidatedToken, Error> {
629 let claims = verify_access_token(
630 &self.inner.key,
631 token_str,
632 &self.inner.config.issuer,
633 &self.inner.config.audience,
634 )?;
635 let token = self
636 .inner
637 .stores
638 .tokens()
639 .find_by_id(&claims.jti)
640 .await?
641 .ok_or_else(|| Error::Unauthorized("token not found".into()))?;
642 if token.revoked {
643 return Err(Error::TokenRevoked);
644 }
645 Ok(ValidatedToken { claims, token })
646 }
647
648 pub async fn revoke_token(&self, token_str: &str) -> Result<(), Error> {
649 let claims = verify_access_token(
650 &self.inner.key,
651 token_str,
652 &self.inner.config.issuer,
653 &self.inner.config.audience,
654 )?;
655 let mut token = self
656 .inner
657 .stores
658 .tokens()
659 .find_by_id(&claims.jti)
660 .await?
661 .ok_or(Error::Unauthorized("token not found".into()))?;
662 token.revoked = true;
663 self.inner.stores.tokens().save(&token).await?;
664 Ok(())
665 }
666
667 async fn resolve_client(&self, req: &TokenRequest, grant_type: &str) -> Result<Client, Error> {
668 let id = req
669 .client_id
670 .as_deref()
671 .ok_or_else(|| Error::InvalidRequest("client_id is required".into()))?;
672 let client = self
673 .inner
674 .stores
675 .clients()
676 .find_by_id(id)
677 .await?
678 .ok_or(Error::InvalidClient)?;
679 if client.revoked {
680 return Err(Error::InvalidClient);
681 }
682 if !client.has_grant_type(grant_type) {
683 return Err(Error::InvalidGrant(format!(
684 "client is not allowed to use the {grant_type} grant"
685 )));
686 }
687 match (&client.secret, req.client_secret.as_deref()) {
688 (Some(expected), Some(provided)) if constant_time_eq(expected, provided) => {}
689 (None, None) => {}
690 (None, Some("")) => {}
691 _ => return Err(Error::InvalidClient),
692 }
693 Ok(client)
694 }
695
696 async fn verify_pkce(&self, req: &TokenRequest, code: &AuthCode) -> Result<(), Error> {
697 let Some(challenge) = code.code_challenge.as_deref() else {
698 return Ok(());
699 };
700 let verifier = req
701 .code_verifier
702 .as_deref()
703 .ok_or(Error::PkceVerificationFailed)?;
704 let method = code.code_challenge_method.as_deref().unwrap_or("plain");
705 let ok = match method {
706 "S256" => {
707 let digest = Sha256::digest(verifier.as_bytes());
708 let expected = base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(digest);
709 expected == challenge
710 }
711 "plain" => {
712 if self.inner.config.allow_plain_pkce {
713 constant_time_eq(verifier, challenge)
714 } else {
715 return Err(Error::UnsupportedPkceMethod(method.into()));
716 }
717 }
718 other => return Err(Error::UnsupportedPkceMethod(other.into())),
719 };
720 if !ok {
721 return Err(Error::PkceVerificationFailed);
722 }
723 Ok(())
724 }
725
726 async fn create_access_token(
727 &self,
728 client_id: &str,
729 user_id: Option<UserId>,
730 scopes: Vec<String>,
731 name: Option<String>,
732 ) -> Result<(AccessToken, String), Error> {
733 let now = now_secs();
734 let ttl = self.inner.config.access_token_ttl_secs;
735 let id = uuid::Uuid::new_v4().to_string();
736 let token = AccessToken {
737 id: id.clone(),
738 user_id: user_id.clone(),
739 client_id: client_id.into(),
740 name,
741 scopes: scopes.clone(),
742 revoked: false,
743 expires_at: now + ttl,
744 created_at: now,
745 updated_at: now,
746 };
747 self.inner.stores.tokens().save(&token).await?;
748 let claims = AccessTokenClaims {
749 iss: self.inner.config.issuer.clone(),
750 sub: user_id.unwrap_or_else(|| client_id.to_string()),
751 aud: self.inner.config.audience.clone(),
752 jti: id,
753 iat: now,
754 nbf: now,
755 exp: now + ttl,
756 scopes,
757 client_id: client_id.into(),
758 };
759 let jwt = sign_access_token(&self.inner.key, claims)?;
760 Ok((token, jwt))
761 }
762
763 async fn create_refresh_token(
764 &self,
765 client_id: &str,
766 access_token_id: &str,
767 ttl_secs: i64,
768 ) -> Result<RefreshToken, Error> {
769 let now = now_secs();
770 let id = uuid::Uuid::new_v4().to_string();
771 let token = RefreshToken {
772 id: id.clone(),
773 client_id: client_id.into(),
774 access_token_id: access_token_id.into(),
775 revoked: false,
776 expires_at: now + ttl_secs,
777 };
778 self.inner.stores.refresh_tokens().save(&token).await?;
779 Ok(token)
780 }
781}
782
783fn parse_scopes(scope: Option<&str>) -> Vec<String> {
784 let mut out: Vec<String> = Vec::new();
785 if let Some(scope) = scope {
786 for part in scope.split_whitespace() {
787 if !out.iter().any(|p| p == part) {
788 out.push(part.to_string());
789 }
790 }
791 }
792 out
793}
794
795fn join_scopes(scopes: &[String]) -> Option<String> {
796 if scopes.is_empty() {
797 None
798 } else {
799 Some(scopes.join(" "))
800 }
801}
802
803fn is_subset(requested: &[String], allowed: &[String]) -> bool {
804 requested.iter().all(|r| allowed.contains(r))
805}
806
807fn constant_time_eq(a: &str, b: &str) -> bool {
810 let a = Sha256::digest(a.as_bytes());
811 let b = Sha256::digest(b.as_bytes());
812 bool::from(a.as_slice().ct_eq(b.as_slice()))
813}
814
815const USER_CODE_ALPHABET: &[u8] = b"BCDFGHJKLMNPQRSTVWXZ23456789";
816
817fn generate_user_code() -> String {
818 use rand::Rng;
819 let mut rng = rand::thread_rng();
820 let mut out = String::with_capacity(8);
821 for _ in 0..8 {
822 let idx = rng.gen_range(0..USER_CODE_ALPHABET.len());
823 out.push(USER_CODE_ALPHABET[idx] as char);
824 }
825 out
826}
827
828fn normalize_user_code(user_code: &str) -> String {
829 user_code
830 .chars()
831 .filter(|c| !c.is_whitespace() && *c != '-')
832 .flat_map(char::to_uppercase)
833 .collect()
834}
835
836#[cfg(test)]
837mod tests {
838 use std::collections::HashMap;
839 use std::sync::Mutex;
840
841 use async_trait::async_trait;
842
843 use super::*;
844 use crate::entity::{AuthCode, Client, DeviceCode, RefreshToken};
845 use crate::store::{
846 AccessTokenStore, AuthCodeStore, ClientStore, DeviceCodeStore, RefreshTokenStore,
847 StoreBundle, UserProvider,
848 };
849
850 struct MemClients(Mutex<Vec<Client>>);
851 struct MemTokens(Mutex<Vec<AccessToken>>);
852 struct MemAuthCodes(Mutex<Vec<AuthCode>>);
853 struct MemRefreshTokens(Mutex<Vec<RefreshToken>>);
854 struct MemDeviceCodes(Mutex<Vec<DeviceCode>>);
855 struct MemUsers(Mutex<HashMap<String, String>>);
856
857 #[async_trait]
858 impl ClientStore for MemClients {
859 async fn find_by_id(&self, id: &str) -> Result<Option<Client>, Error> {
860 Ok(self.0.lock().unwrap().iter().find(|c| c.id == id).cloned())
861 }
862 async fn find_personal_access_client(&self) -> Result<Option<Client>, Error> {
863 Ok(self
864 .0
865 .lock()
866 .unwrap()
867 .iter()
868 .find(|c| !c.revoked && c.has_grant_type("personal_access"))
869 .cloned())
870 }
871 async fn save(&self, client: &Client) -> Result<(), Error> {
872 let mut list = self.0.lock().unwrap();
873 if let Some(existing) = list.iter_mut().find(|c| c.id == client.id) {
874 *existing = client.clone();
875 } else {
876 list.push(client.clone());
877 }
878 Ok(())
879 }
880 }
881
882 #[async_trait]
883 impl AccessTokenStore for MemTokens {
884 async fn find_by_id(&self, id: &str) -> Result<Option<AccessToken>, Error> {
885 Ok(self.0.lock().unwrap().iter().find(|t| t.id == id).cloned())
886 }
887 async fn save(&self, token: &AccessToken) -> Result<(), Error> {
888 let mut list = self.0.lock().unwrap();
889 if let Some(existing) = list.iter_mut().find(|t| t.id == token.id) {
890 *existing = token.clone();
891 } else {
892 list.push(token.clone());
893 }
894 Ok(())
895 }
896 }
897
898 #[async_trait]
899 impl AuthCodeStore for MemAuthCodes {
900 async fn find_by_id(&self, id: &str) -> Result<Option<AuthCode>, Error> {
901 Ok(self.0.lock().unwrap().iter().find(|c| c.id == id).cloned())
902 }
903 async fn save(&self, code: &AuthCode) -> Result<(), Error> {
904 let mut list = self.0.lock().unwrap();
905 if let Some(existing) = list.iter_mut().find(|c| c.id == code.id) {
906 *existing = code.clone();
907 } else {
908 list.push(code.clone());
909 }
910 Ok(())
911 }
912 async fn revoke_if_unrevoked(&self, id: &str) -> Result<bool, Error> {
913 let mut list = self.0.lock().unwrap();
914 if let Some(existing) = list.iter_mut().find(|c| c.id == id) {
915 if existing.revoked {
916 return Ok(false);
917 }
918 existing.revoked = true;
919 return Ok(true);
920 }
921 Ok(false)
922 }
923 }
924
925 #[async_trait]
926 impl RefreshTokenStore for MemRefreshTokens {
927 async fn find_by_id(&self, id: &str) -> Result<Option<RefreshToken>, Error> {
928 Ok(self.0.lock().unwrap().iter().find(|t| t.id == id).cloned())
929 }
930 async fn save(&self, token: &RefreshToken) -> Result<(), Error> {
931 let mut list = self.0.lock().unwrap();
932 if let Some(existing) = list.iter_mut().find(|t| t.id == token.id) {
933 *existing = token.clone();
934 } else {
935 list.push(token.clone());
936 }
937 Ok(())
938 }
939 async fn revoke_if_unrevoked(&self, id: &str) -> Result<bool, Error> {
940 let mut list = self.0.lock().unwrap();
941 if let Some(existing) = list.iter_mut().find(|t| t.id == id) {
942 if existing.revoked {
943 return Ok(false);
944 }
945 existing.revoked = true;
946 return Ok(true);
947 }
948 Ok(false)
949 }
950 }
951
952 #[async_trait]
953 impl DeviceCodeStore for MemDeviceCodes {
954 async fn find_by_device_code(&self, id: &str) -> Result<Option<DeviceCode>, Error> {
955 Ok(self.0.lock().unwrap().iter().find(|c| c.id == id).cloned())
956 }
957 async fn find_by_user_code(&self, user_code: &str) -> Result<Option<DeviceCode>, Error> {
958 Ok(self
959 .0
960 .lock()
961 .unwrap()
962 .iter()
963 .find(|c| c.user_code == user_code)
964 .cloned())
965 }
966 async fn save(&self, code: &DeviceCode) -> Result<(), Error> {
967 let mut list = self.0.lock().unwrap();
968 if let Some(existing) = list.iter_mut().find(|c| c.id == code.id) {
969 *existing = code.clone();
970 } else {
971 list.push(code.clone());
972 }
973 Ok(())
974 }
975 }
976
977 #[async_trait]
978 impl UserProvider for MemUsers {
979 async fn find_by_credentials(
980 &self,
981 identifier: &str,
982 password: &str,
983 ) -> Result<Option<String>, Error> {
984 Ok(self
985 .0
986 .lock()
987 .unwrap()
988 .get(identifier)
989 .filter(|p| p.as_str() == password)
990 .map(|_| identifier.to_string()))
991 }
992 }
993
994 fn test_server() -> PassportServer<
995 StoreBundle<
996 MemClients,
997 MemTokens,
998 MemAuthCodes,
999 MemRefreshTokens,
1000 MemDeviceCodes,
1001 MemUsers,
1002 >,
1003 > {
1004 test_server_with_config(Config::default())
1005 }
1006
1007 fn test_server_with_config(
1008 config: Config,
1009 ) -> PassportServer<
1010 StoreBundle<
1011 MemClients,
1012 MemTokens,
1013 MemAuthCodes,
1014 MemRefreshTokens,
1015 MemDeviceCodes,
1016 MemUsers,
1017 >,
1018 > {
1019 let clients = MemClients(Mutex::new(vec![
1020 Client {
1021 id: "web".into(),
1022 owner_type: None,
1023 owner_id: None,
1024 name: "Web App".into(),
1025 secret: Some("secret-web".into()),
1026 provider: None,
1027 redirect_uris: vec!["https://app.example/callback".into()],
1028 grant_types: vec![
1029 "authorization_code".into(),
1030 "password".into(),
1031 "refresh_token".into(),
1032 ],
1033 revoked: false,
1034 },
1035 Client {
1036 id: "machine".into(),
1037 owner_type: None,
1038 owner_id: None,
1039 name: "Machine".into(),
1040 secret: Some("secret-machine".into()),
1041 provider: None,
1042 redirect_uris: vec![],
1043 grant_types: vec!["client_credentials".into()],
1044 revoked: false,
1045 },
1046 Client {
1047 id: "pat".into(),
1048 owner_type: None,
1049 owner_id: None,
1050 name: "Personal Access".into(),
1051 secret: Some("secret-pat".into()),
1052 provider: None,
1053 redirect_uris: vec![],
1054 grant_types: vec!["personal_access".into()],
1055 revoked: false,
1056 },
1057 Client {
1058 id: "tv".into(),
1059 owner_type: None,
1060 owner_id: None,
1061 name: "Smart TV".into(),
1062 secret: Some("secret-tv".into()),
1063 provider: None,
1064 redirect_uris: vec![],
1065 grant_types: vec![DEVICE_CODE_GRANT_TYPE.into(), "refresh_token".into()],
1066 revoked: false,
1067 },
1068 ]));
1069 let mut users = HashMap::new();
1070 users.insert("user-1".to_string(), "password-1".to_string());
1071 let stores = StoreBundle::new(
1072 clients,
1073 MemTokens(Mutex::new(vec![])),
1074 MemAuthCodes(Mutex::new(vec![])),
1075 MemRefreshTokens(Mutex::new(vec![])),
1076 MemDeviceCodes(Mutex::new(vec![])),
1077 MemUsers(Mutex::new(users)),
1078 );
1079 let key = SigningKey::generate("test").unwrap();
1080 PassportServer::new(stores, key, config)
1081 }
1082
1083 #[tokio::test]
1084 async fn password_grant_issues_and_validates_token() {
1085 let server = test_server();
1086 let resp = server
1087 .issue_token(&TokenRequest {
1088 grant_type: Some("password".into()),
1089 client_id: Some("web".into()),
1090 client_secret: Some("secret-web".into()),
1091 username: Some("user-1".into()),
1092 password: Some("password-1".into()),
1093 scope: Some("read write".into()),
1094 ..Default::default()
1095 })
1096 .await
1097 .unwrap();
1098 assert_eq!(resp.token_type, "Bearer");
1099 assert!(resp.refresh_token.is_some());
1100 assert_eq!(resp.scope.as_deref(), Some("read write"));
1101
1102 let validated = server
1103 .validate_access_token(&resp.access_token)
1104 .await
1105 .unwrap();
1106 assert_eq!(validated.claims.sub, "user-1");
1107 assert_eq!(validated.claims.client_id, "web");
1108 assert_eq!(validated.claims.scopes, vec!["read", "write"]);
1109 assert_eq!(validated.token.user_id.as_deref(), Some("user-1"));
1110 }
1111
1112 #[tokio::test]
1113 async fn password_grant_rejects_bad_credentials() {
1114 let server = test_server();
1115 let err = server
1116 .issue_token(&TokenRequest {
1117 grant_type: Some("password".into()),
1118 client_id: Some("web".into()),
1119 client_secret: Some("secret-web".into()),
1120 username: Some("user-1".into()),
1121 password: Some("wrong".into()),
1122 ..Default::default()
1123 })
1124 .await
1125 .unwrap_err();
1126 assert_eq!(err.to_oauth_error().error, "invalid_grant");
1127 }
1128
1129 #[tokio::test]
1130 async fn password_grant_rejects_wrong_client_secret() {
1131 let server = test_server();
1132 let err = server
1133 .issue_token(&TokenRequest {
1134 grant_type: Some("password".into()),
1135 client_id: Some("web".into()),
1136 client_secret: Some("nope".into()),
1137 username: Some("user-1".into()),
1138 password: Some("password-1".into()),
1139 ..Default::default()
1140 })
1141 .await
1142 .unwrap_err();
1143 assert_eq!(err.to_oauth_error().error, "invalid_client");
1144 }
1145
1146 #[tokio::test]
1147 async fn client_credentials_grant() {
1148 let server = test_server();
1149 let resp = server
1150 .issue_token(&TokenRequest {
1151 grant_type: Some("client_credentials".into()),
1152 client_id: Some("machine".into()),
1153 client_secret: Some("secret-machine".into()),
1154 scope: Some("read".into()),
1155 ..Default::default()
1156 })
1157 .await
1158 .unwrap();
1159 assert!(resp.refresh_token.is_none());
1160 let validated = server
1161 .validate_access_token(&resp.access_token)
1162 .await
1163 .unwrap();
1164 assert_eq!(validated.claims.sub, "machine");
1165 assert!(validated.token.user_id.is_none());
1166 }
1167
1168 #[tokio::test]
1169 async fn authorization_code_grant_with_pkce() {
1170 let server = test_server();
1171 let challenge = {
1172 let verifier = "s3cr3tv3r1f13r-0123456789";
1173 let digest = Sha256::digest(verifier.as_bytes());
1174 base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(digest)
1175 };
1176 let decision = server
1177 .authorize(
1178 "user-1",
1179 &AuthorizeRequest {
1180 client_id: Some("web".into()),
1181 redirect_uri: Some("https://app.example/callback".into()),
1182 response_type: Some("code".into()),
1183 scope: Some("read".into()),
1184 state: Some("xyz".into()),
1185 code_challenge: Some(challenge.clone()),
1186 code_challenge_method: Some("S256".into()),
1187 ..Default::default()
1188 },
1189 )
1190 .await
1191 .unwrap();
1192 assert_eq!(decision.state.as_deref(), Some("xyz"));
1193 assert!(decision.redirect_uri.starts_with("https://app.example"));
1194
1195 let resp = server
1196 .issue_token(&TokenRequest {
1197 grant_type: Some("authorization_code".into()),
1198 client_id: Some("web".into()),
1199 client_secret: Some("secret-web".into()),
1200 code: Some(decision.code.clone()),
1201 redirect_uri: Some("https://app.example/callback".into()),
1202 code_verifier: Some("s3cr3tv3r1f13r-0123456789".into()),
1203 ..Default::default()
1204 })
1205 .await
1206 .unwrap();
1207 let validated = server
1208 .validate_access_token(&resp.access_token)
1209 .await
1210 .unwrap();
1211 assert_eq!(validated.claims.sub, "user-1");
1212
1213 let err = server
1214 .issue_token(&TokenRequest {
1215 grant_type: Some("authorization_code".into()),
1216 client_id: Some("web".into()),
1217 client_secret: Some("secret-web".into()),
1218 code: Some(decision.code),
1219 redirect_uri: Some("https://app.example/callback".into()),
1220 code_verifier: Some("s3cr3tv3r1f13r-0123456789".into()),
1221 ..Default::default()
1222 })
1223 .await
1224 .unwrap_err();
1225 assert_eq!(err.to_oauth_error().error, "invalid_grant");
1226 }
1227
1228 #[tokio::test]
1229 async fn authorization_code_rejects_wrong_verifier() {
1230 let server = test_server();
1231 let decision = server
1232 .authorize(
1233 "user-1",
1234 &AuthorizeRequest {
1235 client_id: Some("web".into()),
1236 redirect_uri: Some("https://app.example/callback".into()),
1237 response_type: Some("code".into()),
1238 code_challenge: Some("wrong-challenge".into()),
1239 code_challenge_method: Some("plain".into()),
1240 ..Default::default()
1241 },
1242 )
1243 .await
1244 .unwrap();
1245 let err = server
1246 .issue_token(&TokenRequest {
1247 grant_type: Some("authorization_code".into()),
1248 client_id: Some("web".into()),
1249 client_secret: Some("secret-web".into()),
1250 code: Some(decision.code),
1251 redirect_uri: Some("https://app.example/callback".into()),
1252 code_verifier: Some("also-wrong".into()),
1253 ..Default::default()
1254 })
1255 .await
1256 .unwrap_err();
1257 assert_eq!(err.to_oauth_error().error, "invalid_grant");
1258 }
1259
1260 #[tokio::test]
1261 async fn refresh_token_cannot_be_redeemed_by_another_client() {
1262 let server = test_server();
1263 let resp = server
1264 .issue_token(&TokenRequest {
1265 grant_type: Some("password".into()),
1266 client_id: Some("web".into()),
1267 client_secret: Some("secret-web".into()),
1268 username: Some("user-1".into()),
1269 password: Some("password-1".into()),
1270 ..Default::default()
1271 })
1272 .await
1273 .unwrap();
1274 let err = server
1275 .issue_token(&TokenRequest {
1276 grant_type: Some("refresh_token".into()),
1277 client_id: Some("tv".into()),
1278 client_secret: Some("secret-tv".into()),
1279 refresh_token: resp.refresh_token.clone(),
1280 ..Default::default()
1281 })
1282 .await
1283 .unwrap_err();
1284 assert_eq!(err.to_oauth_error().error, "invalid_grant");
1285 let rt = resp.refresh_token.unwrap();
1286 let stored = server
1287 .inner
1288 .stores
1289 .refresh_tokens()
1290 .find_by_id(&rt)
1291 .await
1292 .unwrap()
1293 .unwrap();
1294 assert!(!stored.revoked, "failed redemption must not revoke");
1295 }
1296
1297 #[tokio::test]
1298 async fn auth_code_redeemed_concurrently_is_single_use() {
1299 let server = test_server();
1300 let decision = server
1301 .authorize(
1302 "user-1",
1303 &AuthorizeRequest {
1304 client_id: Some("web".into()),
1305 redirect_uri: Some("https://app.example/callback".into()),
1306 response_type: Some("code".into()),
1307 ..Default::default()
1308 },
1309 )
1310 .await
1311 .unwrap();
1312 let server = Arc::new(server);
1313 let mut handles = Vec::new();
1314 for _ in 0..8 {
1315 let server = Arc::clone(&server);
1316 let code = decision.code.clone();
1317 handles.push(tokio::spawn(async move {
1318 server
1319 .issue_token(&TokenRequest {
1320 grant_type: Some("authorization_code".into()),
1321 client_id: Some("web".into()),
1322 client_secret: Some("secret-web".into()),
1323 code: Some(code),
1324 redirect_uri: Some("https://app.example/callback".into()),
1325 ..Default::default()
1326 })
1327 .await
1328 }));
1329 }
1330 let mut successes = 0;
1331 for handle in handles {
1332 if handle.await.unwrap().is_ok() {
1333 successes += 1;
1334 }
1335 }
1336 assert_eq!(successes, 1, "auth code must be single use even under concurrency");
1337 }
1338
1339 #[tokio::test]
1340 async fn refresh_token_is_rotated() {
1341 let server = test_server();
1342 let first = server
1343 .issue_token(&TokenRequest {
1344 grant_type: Some("password".into()),
1345 client_id: Some("web".into()),
1346 client_secret: Some("secret-web".into()),
1347 username: Some("user-1".into()),
1348 password: Some("password-1".into()),
1349 ..Default::default()
1350 })
1351 .await
1352 .unwrap();
1353 let rotated = server
1354 .issue_token(&TokenRequest {
1355 grant_type: Some("refresh_token".into()),
1356 client_id: Some("web".into()),
1357 client_secret: Some("secret-web".into()),
1358 refresh_token: first.refresh_token.clone(),
1359 ..Default::default()
1360 })
1361 .await
1362 .unwrap();
1363 assert_ne!(rotated.refresh_token, first.refresh_token);
1364
1365 let err = server
1366 .issue_token(&TokenRequest {
1367 grant_type: Some("refresh_token".into()),
1368 client_id: Some("web".into()),
1369 client_secret: Some("secret-web".into()),
1370 refresh_token: first.refresh_token.clone(),
1371 ..Default::default()
1372 })
1373 .await
1374 .unwrap_err();
1375 assert_eq!(err.to_oauth_error().error, "invalid_grant");
1376 }
1377
1378 #[tokio::test]
1379 async fn personal_access_token_creation() {
1380 let server = test_server();
1381 let result = server
1382 .create_personal_access_token("user-1", "My Token", vec!["read".into(), "write".into()])
1383 .await
1384 .unwrap();
1385 assert_eq!(result.token.name.as_deref(), Some("My Token"));
1386 let validated = server
1387 .validate_access_token(&result.access_token)
1388 .await
1389 .unwrap();
1390 assert_eq!(validated.claims.sub, "user-1");
1391 assert_eq!(validated.claims.scopes, vec!["read", "write"]);
1392 }
1393
1394 #[tokio::test]
1395 async fn revoked_token_is_rejected() {
1396 let server = test_server();
1397 let resp = server
1398 .issue_token(&TokenRequest {
1399 grant_type: Some("password".into()),
1400 client_id: Some("web".into()),
1401 client_secret: Some("secret-web".into()),
1402 username: Some("user-1".into()),
1403 password: Some("password-1".into()),
1404 ..Default::default()
1405 })
1406 .await
1407 .unwrap();
1408 server.revoke_token(&resp.access_token).await.unwrap();
1409 let err = server
1410 .validate_access_token(&resp.access_token)
1411 .await
1412 .unwrap_err();
1413 assert!(matches!(err, Error::TokenRevoked));
1414 }
1415
1416 #[tokio::test]
1417 async fn unsupported_grant_type() {
1418 let server = test_server();
1419 let err = server
1420 .issue_token(&TokenRequest {
1421 grant_type: Some("implicit".into()),
1422 ..Default::default()
1423 })
1424 .await
1425 .unwrap_err();
1426 assert_eq!(err.to_oauth_error().error, "unsupported_grant_type");
1427 }
1428
1429 #[tokio::test]
1430 async fn client_must_declare_grant_type() {
1431 let server = test_server();
1432 let err = server
1433 .issue_token(&TokenRequest {
1434 grant_type: Some("client_credentials".into()),
1435 client_id: Some("web".into()),
1436 client_secret: Some("secret-web".into()),
1437 ..Default::default()
1438 })
1439 .await
1440 .unwrap_err();
1441 assert_eq!(err.to_oauth_error().error, "invalid_grant");
1442 }
1443
1444 #[tokio::test]
1445 async fn device_authorization_flow() {
1446 let server = test_server_with_config(Config {
1447 device_code_interval_secs: 0,
1448 ..Config::default()
1449 });
1450 let issued = server
1451 .issue_device_code(&DeviceAuthorizationRequest {
1452 client_id: Some("tv".into()),
1453 client_secret: Some("secret-tv".into()),
1454 scope: Some("read".into()),
1455 })
1456 .await
1457 .unwrap();
1458 assert_eq!(issued.user_code.len(), 8);
1459 assert_eq!(issued.expires_in, server.config().device_code_ttl_secs);
1460 assert_eq!(issued.interval, server.config().device_code_interval_secs);
1461 assert!(issued.verification_uri_complete.contains(&issued.user_code));
1462
1463 let pending = server
1464 .issue_token(&TokenRequest {
1465 grant_type: Some(DEVICE_CODE_GRANT_TYPE.into()),
1466 client_id: Some("tv".into()),
1467 client_secret: Some("secret-tv".into()),
1468 device_code: Some(issued.device_code.clone()),
1469 ..Default::default()
1470 })
1471 .await
1472 .unwrap_err();
1473 assert_eq!(pending.to_oauth_error().error, "authorization_pending");
1474
1475 server
1476 .approve_device_code("user-1", &issued.user_code)
1477 .await
1478 .unwrap();
1479
1480 let resp = server
1481 .issue_token(&TokenRequest {
1482 grant_type: Some(DEVICE_CODE_GRANT_TYPE.into()),
1483 client_id: Some("tv".into()),
1484 client_secret: Some("secret-tv".into()),
1485 device_code: Some(issued.device_code.clone()),
1486 ..Default::default()
1487 })
1488 .await
1489 .unwrap();
1490 let validated = server
1491 .validate_access_token(&resp.access_token)
1492 .await
1493 .unwrap();
1494 assert_eq!(validated.claims.sub, "user-1");
1495 assert_eq!(validated.claims.scopes, vec!["read"]);
1496 assert!(resp.refresh_token.is_some());
1497 }
1498
1499 #[tokio::test]
1500 async fn device_code_is_one_time_use() {
1501 let server = test_server();
1502 let issued = server
1503 .issue_device_code(&DeviceAuthorizationRequest {
1504 client_id: Some("tv".into()),
1505 client_secret: Some("secret-tv".into()),
1506 ..Default::default()
1507 })
1508 .await
1509 .unwrap();
1510 server
1511 .approve_device_code("user-1", &issued.user_code)
1512 .await
1513 .unwrap();
1514 server
1515 .issue_token(&TokenRequest {
1516 grant_type: Some(DEVICE_CODE_GRANT_TYPE.into()),
1517 client_id: Some("tv".into()),
1518 client_secret: Some("secret-tv".into()),
1519 device_code: Some(issued.device_code.clone()),
1520 ..Default::default()
1521 })
1522 .await
1523 .unwrap();
1524 let err = server
1525 .issue_token(&TokenRequest {
1526 grant_type: Some(DEVICE_CODE_GRANT_TYPE.into()),
1527 client_id: Some("tv".into()),
1528 client_secret: Some("secret-tv".into()),
1529 device_code: Some(issued.device_code),
1530 ..Default::default()
1531 })
1532 .await
1533 .unwrap_err();
1534 assert_eq!(err.to_oauth_error().error, "invalid_grant");
1535 }
1536
1537 #[tokio::test]
1538 async fn device_polling_respects_interval() {
1539 let server = test_server();
1540 let issued = server
1541 .issue_device_code(&DeviceAuthorizationRequest {
1542 client_id: Some("tv".into()),
1543 client_secret: Some("secret-tv".into()),
1544 ..Default::default()
1545 })
1546 .await
1547 .unwrap();
1548 let _pending = server
1549 .issue_token(&TokenRequest {
1550 grant_type: Some(DEVICE_CODE_GRANT_TYPE.into()),
1551 client_id: Some("tv".into()),
1552 client_secret: Some("secret-tv".into()),
1553 device_code: Some(issued.device_code.clone()),
1554 ..Default::default()
1555 })
1556 .await;
1557 server
1558 .approve_device_code("user-1", &issued.user_code)
1559 .await
1560 .unwrap();
1561 let err = server
1562 .issue_token(&TokenRequest {
1563 grant_type: Some(DEVICE_CODE_GRANT_TYPE.into()),
1564 client_id: Some("tv".into()),
1565 client_secret: Some("secret-tv".into()),
1566 device_code: Some(issued.device_code),
1567 ..Default::default()
1568 })
1569 .await
1570 .unwrap_err();
1571 assert_eq!(err.to_oauth_error().error, "slow_down");
1572 }
1573}