feat: gpauth support macos

This commit is contained in:
Kevin Yue committed 2025-01-09 21:22:41 +08:00
1 parent 0c9b8e6c63
commit d37ccafdc2
53 files changed
+1423 -1042

No files matched your search

+57
View File
@@ -0,0 +1,57 @@
use std::io::Cursor;
use log::info;
use tiny_http::{Header, Response, Server};
use uuid::Uuid;
pub(super) struct AuthServer {
server: Server,
auth_id: String,
}
impl AuthServer {
pub fn new() -> anyhow::Result<Self> {
let server = Server::http("127.0.0.1:0").map_err(|err| anyhow::anyhow!(err))?;
let auth_id = Uuid::new_v4().to_string();
Ok(Self { server, auth_id })
}
pub fn auth_url(&self) -> String {
format!("http://{}/{}", self.server.server_addr(), self.auth_id)
}
pub fn serve_request(&self, auth_request: &str) {
info!("auth server started at: {}", self.auth_url());
for req in self.server.incoming_requests() {
info!("received request, method: {}, url: {}", req.method(), req.url());
if req.url() != format!("/{}", self.auth_id) {
let forbidden = Response::from_string("forbidden").with_status_code(403);
let _ = req.respond(forbidden);
} else {
let auth_response = build_auth_response(auth_request);
if let Err(err) = req.respond(auth_response) {
info!("failed to respond to request: {}", err);
} else {
info!("stop the auth server");
break;
}
}
}
}
}
fn build_auth_response(auth_request: &str) -> Response<Cursor<Vec<u8>>> {
if auth_request.starts_with("http") {
let header = format!("location: {}", auth_request);
let header: Header = header.parse().unwrap();
Response::from_string("redirect")
.with_status_code(302)
.with_header(header)
} else {
let content_type: Header = "content-type: text/html".parse().unwrap();
Response::from_string(auth_request).with_header(content_type)
}
}
+121
View File
@@ -0,0 +1,121 @@
use std::{env::temp_dir, fs, os::unix::fs::PermissionsExt};
use gpapi::{auth::SamlAuthData, GP_CALLBACK_PORT_FILENAME};
use log::info;
use tokio::{io::AsyncReadExt, net::TcpListener};
use crate::browser::auth_server::AuthServer;
pub enum Browser<'a> {
Default,
Chrome,
Firefox,
Other(&'a str),
}
impl<'a> Browser<'a> {
pub fn from_str(browser: &'a str) -> Self {
match browser.to_lowercase().as_str() {
"default" => Browser::Default,
"chrome" => Browser::Chrome,
"firefox" => Browser::Firefox,
_ => Browser::Other(browser),
}
}
fn as_str(&self) -> &str {
match self {
Browser::Default => "default",
Browser::Chrome => "chrome",
Browser::Firefox => "firefox",
Browser::Other(browser) => browser,
}
}
}
pub struct BrowserAuthenticator<'a> {
auth_request: &'a str,
browser: Browser<'a>,
}
impl<'a> BrowserAuthenticator<'a> {
pub fn new(auth_request: &'a str, browser: &'a str) -> Self {
Self {
auth_request,
browser: Browser::from_str(browser),
}
}
pub async fn authenticate(&self) -> anyhow::Result<SamlAuthData> {
let auth_server = AuthServer::new()?;
let auth_url = auth_server.auth_url();
let auth_request = self.auth_request.to_string();
tokio::spawn(async move {
auth_server.serve_request(&auth_request);
});
match self.browser {
Browser::Default => {
info!("Launching the default browser...");
webbrowser::open(&auth_url)?;
}
_ => {
let app = find_browser_path(&self.browser);
info!("Launching browser: {}", app);
open::with_detached(auth_url, app)?;
}
}
info!("Please continue the authentication process in the default browser");
wait_auth_data().await
}
}
fn find_browser_path(browser: &Browser) -> String {
match browser {
Browser::Chrome => {
const CHROME_VARIANTS: &[&str] = &["google-chrome-stable", "google-chrome", "chromium"];
CHROME_VARIANTS
.iter()
.find_map(|&browser_name| which::which(browser_name).ok())
.map(|path| path.to_string_lossy().to_string())
.unwrap_or_else(|| browser.as_str().to_string())
}
_ => browser.as_str().to_string(),
}
}
async fn wait_auth_data() -> anyhow::Result<SamlAuthData> {
// Start a local server to receive the browser authentication data
let listener = TcpListener::bind("127.0.0.1:0").await?;
let port = listener.local_addr()?.port();
let port_file = temp_dir().join(GP_CALLBACK_PORT_FILENAME);
// Write the port to a file
fs::write(&port_file, port.to_string())?;
fs::set_permissions(&port_file, fs::Permissions::from_mode(0o600))?;
// Remove the previous log file
let callback_log = temp_dir().join("gpcallback.log");
let _ = fs::remove_file(&callback_log);
info!("Listening authentication data on port {}", port);
info!(
"If it hangs, please check the logs at `{}` for more information",
callback_log.display()
);
let (mut socket, _) = listener.accept().await?;
info!("Received the browser authentication data from the socket");
let mut data = String::new();
socket.read_to_string(&mut data).await?;
// Remove the port file
fs::remove_file(&port_file)?;
let auth_data = SamlAuthData::from_gpcallback(&data)?;
Ok(auth_data)
}