psn_rs 0.1.0

Interact with PlayStation Network API in full Rust!
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

use reqwest::header::{
    AUTHORIZATION, CONTENT_TYPE, COOKIE, HeaderMap, HeaderName, HeaderValue, LOCATION, USER_AGENT,
};
use serde::Serialize;

use crate::{PSNApiResult, PSNClient, models::TokenResponse};

impl PSNClient {
    pub async fn authenticate(&mut self) -> PSNApiResult<()> {
        let authorization_code = self.get_authorization_code().await?;
        log::debug!("got authorization code");

        self.fetch_access_code_from_authorization(authorization_code)
            .await?;

        log::debug!("successfully authenticated");
        Ok(())
    }

    async fn get_authorization_code(&mut self) -> PSNApiResult<String> {
        log::debug!("getting authorization code");

        let mut headers = HeaderMap::new();
        headers.insert(
            COOKIE,
            HeaderValue::from_str(&format!("npsso={}", self.npsso))?,
        );
        headers.insert(
            CONTENT_TYPE,
            HeaderValue::from_static("application/x-www-form-urlencoded"),
        );
        headers.insert(
            "X-Requested-With",
            HeaderValue::from_static("com.scee.psxandroid"),
        );
        headers.insert("Sec-Fetch-Dest", HeaderValue::from_static("document"));
        headers.insert("Sec-Fetch-Mode", HeaderValue::from_static("navigate"));
        headers.insert("Sec-Fetch-Site", HeaderValue::from_static("same-site"));
        headers.insert("Sec-Fetch-User", HeaderValue::from_static("?1"));

        let query = vec![
            ("access_type", "offline"),
            ("cid", self.cid.as_str()),
            ("client_id", "09515159-7237-4370-9b40-3806e67c0891"),
            ("device_base_font_size", "10"),
            ("device_profile", "mobile"),
            ("elements_visibility", "no_aclink"),
            ("enable_scheme_error_code", "true"),
            ("no_captcha", "true"),
            ("PlatformPrivacyWs1", "minimal"),
            ("redirect_uri", "com.scee.psxandroid.scecompcall://redirect"),
            ("response_type", "code"),
            ("scope", "psn:mobile.v2.core psn:clientapp"),
            ("service_entity", "urn:service-entity:psn"),
            ("service_logo", "ps"),
            ("smcid", "psapp:signin"),
            ("support_scheme", "sneiprls"),
            ("turnOnTrustedBrowser", "true"),
            ("ui", "pr"),
        ];

        let response = self
            .get(
                "https://ca.account.sony.com/api/authz/v3/oauth/authorize",
                Some(headers),
                Some(query),
            )
            .await?;

        let location_url = response.headers().get(LOCATION).unwrap().to_str().unwrap();
        let parsed_location_url = url::Url::parse(location_url)?;
        let parsed_location_query_pairs = parsed_location_url.query_pairs().collect::<Vec<_>>();
        let filtered = parsed_location_query_pairs
            .iter()
            .filter(|v| v.0 == "code")
            .collect::<Vec<_>>();

        let authorization_code = filtered.first().unwrap().1.to_string();

        Ok(authorization_code)
    }

    async fn fetch_access_code_from_authorization<S: AsRef<str>>(
        &mut self,
        authorization_code: S,
    ) -> PSNApiResult<()> {
        log::debug!("fetching access code from authorization");

        let mut headers = HeaderMap::new();
        headers.insert(
            AUTHORIZATION,
            HeaderValue::from_static(
                "Basic MDk1MTUxNTktNzIzNy00MzcwLTliNDAtMzgwNmU2N2MwODkxOnVjUGprYTV0bnRCMktxc1A=",
            ),
        );
        headers.insert(
            CONTENT_TYPE,
            HeaderValue::from_static("application/x-www-form-urlencoded"),
        );
        headers.insert(
            USER_AGENT,
            HeaderValue::from_static("com.sony.snei.np.android.sso.share.oauth.versa.USER_AGENT"),
        );
        headers.insert(
            HeaderName::from_static("x-psn-correlation-id"),
            HeaderValue::from_str(self.cid.as_str())?,
        );

        #[derive(Serialize)]
        struct Data {
            cid: String,
            code: String,
            grant_type: String,
            redirect_uri: String,
            scope: String,
            token_format: String,
        }

        let data = Data {
            cid: self.cid.clone(),
            code: authorization_code.as_ref().to_string(),
            grant_type: "authorization_code".to_string(),
            redirect_uri: "com.scee.psxandroid.scecompcall://redirect".to_string(),
            scope: "psn:mobile.v2.core psn:clientapp".to_string(),
            token_format: "jwt".to_string(),
        };

        let response = self
            .post(
                "https://ca.account.sony.com/api/authz/v3/oauth/token",
                Some(headers),
                Some(&data),
            )
            .await?
            .error_for_status()?;

        let token_response = response.json::<TokenResponse>().await?;

        self.token_response = Some(token_response);

        Ok(())
    }
}