// TODO: rename this module to auth use std::net; use rand::{Rng, RngCore}; use bcrypt::{DEFAULT_COST, hash, verify}; use libpso::packet::login::*; use libpso::{PacketParseError, PSOPacket}; use libpso::crypto::{CipherError, PSOCipher, NullCipher}; use libpso::crypto::bb::PSOBBCipher; use elseware::pktvec; use elseware::common::pktvec::PktVec; use elseware::common::cipherkeys::{ELSEWHERE_PRIVATE_KEY, ELSEWHERE_PARRAY}; //use elseware::common::network::{PacketNetworkError}; use elseware::common::client::Client; use elseware::common::serverstate::{ServerPacket, ServerState, OnConnect}; use elseware::common::util::array_to_utf8; use crate::dataaccess::DataAccess; use crate::models::UserAccount; pub const LOGIN_PORT: u16 = 12000; //type ConnectionPool = r2d2::Pool<r2d2::ConnectionManager<PgConnection>>; #[derive(Debug)] pub enum LoginError { } #[derive(Debug)] pub enum LoginPacket { Login(Login), } impl ServerPacket for LoginPacket { fn from_bytes(data: &Vec<u8>) -> Result<LoginPacket, PacketParseError> { match data[2] { 0x93 => Ok(LoginPacket::Login(Login::from_bytes(data)?)), _ => Err(PacketParseError::WrongPacketForServerType) } } } #[derive(Clone)] pub struct SharedLoginState<DA: DataAccess> { pub data_access: DA, } impl<DA: DataAccess> SharedLoginState<DA> { pub fn new(data_access: DA) -> SharedLoginState<DA> { SharedLoginState { data_access: data_access, } } } pub struct LoginServerState<DA: DataAccess> { pub shared_state: SharedLoginState<DA>, } pub fn get_login_status(data_access: &dyn DataAccess, pkt: &Login) -> Result<UserAccount, AccountStatus> { let username = array_to_utf8(pkt.username).map_err(|_err| AccountStatus::Error)?; let password = array_to_utf8(pkt.password).map_err(|_err| AccountStatus::Error)?; let user = data_access.get_user_by_name(username).ok_or(AccountStatus::InvalidUser)?; let verified = bcrypt::verify(password, user.password.as_str()).map_err(|_err| AccountStatus::Error)?; match verified { true => Ok(user), false => Err(AccountStatus::InvalidPassword) } } impl<DA: DataAccess> LoginServerState<DA> { fn new(shared_state: SharedLoginState<DA>) -> LoginServerState<DA> { LoginServerState { shared_state: shared_state, } } fn validate_login(&mut self, pkt: &Login) -> Box<PktVec> { match get_login_status(&self.shared_state.data_access, pkt) { Ok(_user) => { let response = LoginResponse::by_status(AccountStatus::Ok, pkt.security_data); let ip = net::Ipv4Addr::new(127,0,0,1); let ip = u32::from_ne_bytes(ip.octets()); pktvec![response, RedirectClient::new(ip, crate::character::CHARACTER_PORT)] }, Err(err) => { pktvec![LoginResponse::by_status(err, pkt.security_data)] } } } } impl<DA: DataAccess> ServerState for LoginServerState<DA> { type Packet = LoginPacket; type PacketError = LoginError; fn on_connect(&mut self) -> Vec<OnConnect> { let mut rng = rand::thread_rng(); let mut server_key = [0u8; 48]; let mut client_key = [0u8; 48]; rng.fill(&mut server_key[..]); rng.fill(&mut client_key[..]); vec![OnConnect::Packet(Box::new(LoginWelcome::new(server_key, client_key))), OnConnect::Cipher((Box::new(PSOBBCipher::new(ELSEWHERE_PARRAY, ELSEWHERE_PRIVATE_KEY, client_key)), Box::new(PSOBBCipher::new(ELSEWHERE_PARRAY, ELSEWHERE_PRIVATE_KEY, server_key)))) ] } fn handle(&mut self, pkt: &LoginPacket) -> Box<dyn Iterator<Item = Box<dyn PSOPacket>>> { match pkt { LoginPacket::Login(login) => { self.validate_login(login) } } } } pub fn new_client<DA: DataAccess + 'static>(socket: mio::tcp::TcpStream, shared_state: SharedLoginState<DA>) { let state = LoginServerState::new(shared_state); let client = Client::new(socket, Box::new(state)); client.io_loop(); }