stereo.cat/boxy
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

chore: clean up, rename types.rs to server.rs

Browse source
This commit is contained in:
hexlocation 2025-07-29 12:35:03 +02:00
parent a8bc61f40c
commit 0c68399210
9 changed files with 110 additions and 41 deletions
Download patch file Download diff file Expand all files Collapse all files

2
config.yaml
View file

@ -17,4 +17,4 @@ hosts: # ignore this it doesn't function
clients:
- name: 'eu-central-1' # Example Client right here (the client in this case would be for example the stereo.cat backend)
secret: '$2b$12$5wH/0p702PPqVp7fCpVS4.1GA2/wAbk89w2nMjwuS8439OhjCUGbK' # password123
hashed_secret: '$2b$12$5wH/0p702PPqVp7fCpVS4.1GA2/wAbk89w2nMjwuS8439OhjCUGbK' # password123

21
src/config.rs
View file

@ -27,7 +27,26 @@ pub struct Api {
#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
pub struct Client {
pub name: String,
pub secret: String,
pub hashed_secret: String,
}
impl Client {
pub async fn verify(us: String, config: Config) -> bool {
// us stands for user:secret btw
let us_split: Vec<&str> = us.split(':').collect();
let name = us_split.first().unwrap();
let secret = us_split.last().unwrap();
let client: Client = config
.clients
.into_iter()
.filter(|x| x.name.eq(name))
.nth(0)
.unwrap();
return bcrypt::verify(secret, client.hashed_secret.as_str()).unwrap();
}
}
#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]

5
src/db.rs
View file

@ -1,4 +1,7 @@
use std::{error::Error, net::{IpAddr, SocketAddr}};
use std::{
error::Error,
net::{IpAddr, SocketAddr},
};
use tokio_postgres::{Client, Socket, tls::MakeTlsConnect};

20
src/main.rs
View file

@ -1,7 +1,7 @@
mod config;
mod db;
mod server;
mod services;
mod types;
use std::{env, sync::Arc};
@ -11,16 +11,20 @@ use db::BoxyDatabase;
use log::{error, info};
use nanoid::nanoid;
use ring::rand::SystemRandom;
use server::Server;
use services::{api::ApiService, controller::ControllerService};
use tokio::{fs::File, io::AsyncReadExt, sync::Mutex};
use tokio_postgres::{NoTls, tls::NoTlsError};
use types::Server;
const VERSION: &str = "v0.1a";
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
pretty_env_logger::formatted_builder()
.filter(None, log::LevelFilter::Info)
.init();
if env::var("RUST_LOG").is_err() {
unsafe { env::set_var("RUST_LOG", "info") };
}
pretty_env_logger::init();
let args: Vec<String> = env::args().collect();
@ -37,6 +41,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
return Ok(());
}
"version" => {
info!("Version: {}", VERSION);
return Ok(());
}
_ => {}
}
}
@ -64,7 +72,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
let api_svc = ApiService {
database: database_shared.clone(),
config: config.clone(),
_address: None
_address: None,
};
let svc = ControllerService {

4
src/types.rs → src/server.rs
View file

@ -25,7 +25,7 @@ pub struct Server<S> {
}
pub trait TcpIntercept {
fn handle(&mut self, stream: &TcpStream);
fn stream(&mut self, stream: &TcpStream);
}
impl<S> Server<S>
@ -43,7 +43,7 @@ where
let (stream, _) = self.listener.accept().await.unwrap();
let mut svc_clone = self.service.clone();
svc_clone.handle(&stream);
svc_clone.stream(&stream);
let io = TokioIo::new(stream);
tokio::task::spawn(async move {

4
src/services.rs
View file

@ -1,3 +1,3 @@
pub mod proxy;
pub mod controller;
pub mod api;
pub mod controller;
pub mod proxy;

88
src/services/api.rs
View file

@ -1,16 +1,20 @@
use std::{hash, net::{IpAddr, SocketAddr}, pin::Pin, sync::Arc};
use std::{net::IpAddr, pin::Pin, sync::Arc};
use base64::{Engine, prelude::BASE64_STANDARD};
use bcrypt::DEFAULT_COST;
use bcrypt::bcrypt;
use http_body_util::{BodyExt, Full};
use hyper::{
body::{Bytes, Incoming}, service::Service, Method, Request, Response, StatusCode, Uri
Method, Request, Response, StatusCode,
body::{Bytes, Incoming},
service::Service,
};
use log::{info, trace};
use log::{debug, info, warn};
use tokio::{net::TcpStream, sync::Mutex};
use crate::{
config::{Client, Config}, db::{BoxyDatabase, Endpoint}, types::{GeneralBody, GeneralResponse, TcpIntercept}
config::{Client, Config},
db::{BoxyDatabase, Endpoint},
server::{GeneralBody, GeneralResponse, TcpIntercept},
};
#[derive(Debug, Clone)]
@ -20,7 +24,7 @@ pub struct ApiService {
pub _address: Option<IpAddr>,
}
async fn default_response() -> Response<http_body_util::Either<Incoming, Full<Bytes>>> {
async fn default_response() -> GeneralResponse {
Response::builder()
.status(404)
.body(GeneralBody::Right(Full::from(Bytes::from(
@ -29,7 +33,7 @@ async fn default_response() -> Response<http_body_util::Either<Incoming, Full<By
.unwrap()
}
async fn custom_resp(e: StatusCode, m: String) -> Response<http_body_util::Either<Incoming, Full<Bytes>>> {
async fn custom_resp(e: StatusCode, m: &'static str) -> GeneralResponse {
Response::builder()
.status(e)
.body(GeneralBody::Right(Full::from(Bytes::from(m))))
@ -37,7 +41,7 @@ async fn custom_resp(e: StatusCode, m: String) -> Response<http_body_util::Eithe
}
impl TcpIntercept for ApiService {
fn handle(&mut self, stream: &TcpStream) {
fn stream(&mut self, stream: &TcpStream) {
self._address = Some(stream.peer_addr().unwrap().ip());
}
}
@ -51,37 +55,73 @@ impl Service<Request<Incoming>> for ApiService {
let database = self.database.clone();
let config = self.config.clone();
let address = self._address.clone().unwrap();
Box::pin(async move {
match *req.method() {
Method::POST => match req.uri().path() {
"/register" => {
let encoded_header = req.headers().get(hyper::header::AUTHORIZATION).unwrap().to_str().unwrap();
let auth_string = String::from_utf8(BASE64_STANDARD.decode(&encoded_header[6..]).unwrap()).unwrap();
let auth_string_split: Vec<&str> = auth_string.split(':').collect();
debug!("new api register request from {}", address);
let name = auth_string_split.first().unwrap();
let secret = auth_string_split.get(1).unwrap();
let encoded_header = req
.headers()
.get(hyper::header::AUTHORIZATION)
.unwrap()
.to_str()
.unwrap();
let matched_clients: Vec<&Client> = config.clients.iter().filter(|x| x.name.eq(name)).collect();
debug!("authorization header: {}", encoded_header);
let client = matched_clients.first().unwrap();
let auth_string = String::from_utf8(
BASE64_STANDARD.decode(&encoded_header[6..]).unwrap(),
)
.unwrap();
if !bcrypt::verify(secret, client.secret.as_str()).unwrap() {
return Ok(custom_resp(StatusCode::UNAUTHORIZED, "Invalid credentials.".to_string()).await);
debug!("decoded auth string: {}", auth_string);
if !Client::verify(auth_string.clone(), config).await {
warn!(
"Authentication for string {} from {} failed.",
auth_string, address
);
return Ok(custom_resp(
StatusCode::UNAUTHORIZED,
"Invalid credentials.",
)
.await);
}
let body = String::from_utf8(req.collect().await.unwrap().to_bytes().iter().cloned().collect::<Vec<u8>>()).unwrap();
let body = String::from_utf8(
req.collect()
.await
.unwrap()
.to_bytes()
.iter()
.cloned()
.collect::<Vec<u8>>(),
)
.unwrap();
let json = json::parse(body.as_str()).unwrap();
info!("body: {}", body);
debug!("body: {}", body);
let mut endpoint = Endpoint::new(None, address, json["port"].as_u16().unwrap(), json["callback"].as_str().unwrap_or("/").to_string()).await;
let mut endpoint = Endpoint::new(
None,
address,
json["port"].as_u16().unwrap(),
json["callback"].as_str().unwrap_or("/").to_string(),
)
.await;
endpoint.register(*database.lock().await, json["hostname"].as_str().unwrap().to_string()).await.unwrap();
endpoint
.register(
*database.lock().await,
json["hostname"].as_str().unwrap().to_string(),
)
.await
.unwrap();
Ok(custom_resp(StatusCode::OK, "yay".to_string()).await)
Ok(custom_resp(StatusCode::OK, "").await)
}
_ => Ok(default_response().await),
},

5
src/services/controller.rs
View file

@ -12,7 +12,7 @@ use tokio::sync::Mutex;
use crate::{
config::{self, Client, Config, Host},
db::{BoxyDatabase, Endpoint},
types::{GeneralBody, GeneralResponse, TcpIntercept},
server::{GeneralBody, GeneralResponse, TcpIntercept},
};
use super::proxy::ProxyService;
@ -23,8 +23,7 @@ pub struct ControllerService {
}
impl TcpIntercept for ControllerService {
fn handle(&mut self, stream: &tokio::net::TcpStream) {
}
fn stream(&mut self, _: &tokio::net::TcpStream) {}
}
impl Service<Request<Incoming>> for ControllerService {

2
src/services/proxy.rs
View file

@ -5,7 +5,7 @@ use hyper_util::rt::TokioIo;
use log::error;
use tokio::net::TcpStream;
use crate::types::{GeneralResponse, to_general_response};
use crate::server::{GeneralResponse, to_general_response};
#[derive(Debug, Clone)]
pub struct ProxyService {