feat: reused the oauth

feat: device code

Author: Eveeifyeve

src/code.rs

@@ -0,0 +1,68 @@
+#![forbid(unsafe_code)]
+#![warn(clippy::pedantic)]
+
+use serde::{Deserialize, Serialize};
+use reqwest::Client;
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct PreResponse {
+    pub device_code: String,
+    pub user_code: String,
+    pub verification_uri: String,
+    pub expires_in: u32,
+    pub interval: u16,
+    pub message: String,
+}
+
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Response {
+    pub expires_in: u16,
+    access_token: String,
+}
+
+
+
+
+
+pub async fn code(client_id: &str, content: &str) -> Result<PreResponse, reqwest::Error> {
+    let request_url = format!(
+        "https://login.microsoftonline.com/common/oauth2/v2.0/devicecode?client_id={}",
+        client_id
+    );
+ 
+    let client = Client::new();
+    let response = client
+        .post(request_url)
+        .header("Content-Type", content)
+        .send()
+        .await?;
+ 
+    let response_data: PreResponse = response.json().await?;
+ 
+    Ok(response_data)
+ }
+
+
+
+ pub async fn auth(device_code: &str, client_id: &str) -> Result<(u16, String), reqwest::Error> {
+    let client = Client::new();
+    let request_url = format!(
+        "https://login.microsoftonline.com/common/oauth2/v2.0/token?grant_type=urn:ietf:params:oauth:grant-type:device_code&client_id={}&device_code={}",
+        client_id,
+        device_code
+    );
+
+    let request = client.post(request_url).header("Content-Type", "application/x-www-form-urlencoded").send().await?;
+
+    let response_data: Response = request.json().await?;
+
+    let expires_in = response_data.expires_in;
+    let token = response_data.access_token;
+
+
+    Ok((expires_in, token))
+ }
+
+
+

src/lib.rs

@@ -0,0 +1,114 @@
+/* Minecraft-Essentials
+ * Copyright (C) 2024 minecraft-essentials
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License v3.0
+ * along with this program.
+ */
+
+#![doc = include_str!("../README.md")]
+#![forbid(unsafe_code, missing_docs)]
+#![warn(clippy::pedantic)]
+
+mod server;
+mod token;
+mod xbox;
+mod xts;
+mod code;
+
+// External Imports
+use rand::Rng;
+
+// Local Imports
+pub use server::Info as ServerInfo;
+
+/// Minecraft OAuth Authentification Method. 
+pub struct Oauth {
+    url: String,
+    port: u16,
+}
+
+
+
+/// Implemation of the oauth.
+impl Oauth {
+    /// Create the oauth url.
+    pub fn new(clientid: &str) -> Self {
+        // Randomized port part.
+        let mut rng = rand::thread_rng();
+        let port = rng.gen_range(25535..=65535);
+
+        let url = format!("https://login.microsoftonline.com/common/oauth2/v2.0/authorize?client_id={}&response_type=code&redirect_uri=http://localhost:{}&response_mode=query&scope=openid%20offline_access%20https%3A%2F%2Fgraph.microsoft.com%2Fmail.read&state=12345", clientid, port);
+
+        // Returns the port and url as self.
+        Self { url, port }
+    }
+
+    /// Returns the URL of the OAuth object.
+    pub fn url(&self) -> &str {
+        &self.url
+    }
+
+    /// The launch function
+    pub async fn launch(&self) -> std::io::Result<ServerInfo> {
+        // Launches the temporary http server.
+        server::launch(self.port).await
+    }
+}
+
+/// Minecraft Device Code Authentification Method. 
+pub struct DeviceCode {
+    url: String,
+    message: String,
+    expires_in: u32,
+    user_code: String,
+    device_code: String,
+}
+
+
+/// Implemation of the device code.
+impl DeviceCode {
+    /// Proccess to get the code.
+    pub async fn new(client_id: &str) -> Result<Self, reqwest::Error> {
+        pub const CONTENT_TYPE: &str = "application/x-www-form-urlencoded";
+        let response_data = code::code(client_id, CONTENT_TYPE).await?;
+     
+        Ok(Self {
+            url: response_data.verification_uri,
+            message: response_data.message,
+            expires_in: response_data.expires_in,
+            user_code: response_data.user_code,
+            device_code: response_data.device_code,
+        })
+     }
+
+    /// The prelaunch stuff. 
+    pub fn prelaunch(&self) -> (&str, &str, u32, &str) {
+        (&self.url, &self.message, self.expires_in, &self.user_code)
+    }
+
+    /// The launch function
+    pub async fn launch(&self, client_id: &str) {
+        let _ = code::auth(&self.device_code, client_id).await;
+    }
+}
+
+
+
+/// Authentification Data once done.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct AuthData {
+    /// The access token.
+    pub access_token: String,
+    /// The Optional UUID.
+    pub uuid: Option<String>,
+}

src/server.rs

@@ -0,0 +1,43 @@
+#![forbid(unsafe_code, missing_docs)]
+#![warn(clippy::pedantic)]
+
+//! The server for OAauth login Technically
+
+use actix_web::{web, App, HttpResponse, HttpServer};
+use serde::Deserialize;
+use std::str;
+use tokio::sync::mpsc;
+
+/// Infomation from the temporary http server.
+#[derive(Deserialize)]
+pub struct Info {
+    /// The code
+    pub code: String,
+    /// The state
+    pub state: String,
+}
+
+pub async fn launch(port: u16) -> std::io::Result<Info> {
+    let (tx, mut rx) = mpsc::channel::<Info>(1);
+
+    let server = tokio::spawn(
+        HttpServer::new(move || {
+            App::new().app_data(tx.clone()).route(
+                "/",
+                web::get().to(|web::Query(info): web::Query<Info>, tx: web::Data<mpsc::Sender<Info>>| async move {
+                    tx.try_send(info).unwrap();
+                    HttpResponse::Ok()
+                }),
+            )
+        })
+        .bind(format!("127.0.0.1:{}", port))?
+        .workers(1)
+        .run(),
+    );
+
+    let info = rx.recv().await.expect("server did not launch");
+
+    server.abort();
+
+    Ok(info)
+}