Skip to main content

rustbasic_passport/
server.rs

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
807/// Perbandingan rahasia bebas timing attack: kedua sisi di-hash (SHA-256,
808/// ukuran output tetap) lalu dibandingkan secara constant-time.
809fn 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}