Bit.Corp/Bit.Auth-r
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add some users and jwt

Browse Source
This commit is contained in:
BitHeaven 2024-03-15 08:17:14 +05:00
parent 1577486736
commit 73b0fb8762
4 changed files with 305 additions and 168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
Cargo.lock generated
View File

@ -130,9 +130,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
[[package]]
name = "bitflags"
version = "2.4.1"
version = "2.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "327762f6e5a765692301e5bb513e0d9fef63be86bbc14528052b1cd3e6f03e07"
checksum = "ed570934406eb16438a4e976b1b4500774099c13b8cb96eec99f620f05090ddf"
[[package]]
name = "blowfish"
@ -588,9 +588,9 @@ checksum = "4ec2a862134d2a7d32d7983ddcdd1c4923530833c9f2ea1a44fc5fa473989058"
[[package]]
name = "linux-raw-sys"
version = "0.4.12"
version = "0.4.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c4cd1a83af159aa67994778be9070f0ae1bd732942279cabb14f86f986a21456"
checksum = "01cda141df6706de531b6c46c3a33ecca755538219bd484262fa09410c13539c"
[[package]]
name = "lock_api"
@ -738,11 +738,11 @@ checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
[[package]]
name = "openssl"
version = "0.10.62"
version = "0.10.64"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8cde4d2d9200ad5909f8dac647e29482e07c3a35de8a13fce7c9c7747ad9f671"
checksum = "95a0481286a310808298130d22dd1fef0fa571e05a8f44ec801801e84b216b1f"
dependencies = [
"bitflags 2.4.1",
"bitflags 2.4.2",
"cfg-if",
"foreign-types",
"libc",
@ -770,9 +770,9 @@ checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf"
[[package]]
name = "openssl-sys"
version = "0.9.98"
version = "0.9.101"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c1665caf8ab2dc9aef43d1c0023bd904633a6a05cb30b0ad59bec2ae986e57a7"
checksum = "dda2b0f344e78efc2facf7d195d098df0dd72151b26ab98da807afc26c198dff"
dependencies = [
"cc",
"libc",
@ -877,9 +877,9 @@ dependencies = [
[[package]]
name = "pkg-config"
version = "0.3.28"
version = "0.3.30"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "69d3587f8a9e599cc7ec2c00e331f71c4e69a5f9a4b8a6efd5b07466b9736f9a"
checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec"
[[package]]
name = "powerfmt"
@ -1003,11 +1003,11 @@ checksum = "d626bb9dae77e28219937af045c257c28bfd3f69333c512553507f5f9798cb76"
[[package]]
name = "rustix"
version = "0.38.30"
version = "0.38.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "322394588aaf33c24007e8bb3238ee3e4c5c09c084ab32bc73890b99ff326bca"
checksum = "6ea3e1a662af26cd7a3ba09c0297a31af215563ecf42817c98df621387f4e949"
dependencies = [
"bitflags 2.4.1",
"bitflags 2.4.2",
"errno",
"libc",
"linux-raw-sys",
@ -1137,9 +1137,9 @@ dependencies = [
[[package]]
name = "sky-derive"
version = "0.2.0"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9549afdc45cc6a085341f42c448d30a1b8d4fbd2879876d39d26224942067920"
checksum = "8a5d926a1f01fa0f21cf9ba651777b78e0a8a236be400d94cbb03396f5e22287"
dependencies = [
"proc-macro2",
"quote",
@ -1148,9 +1148,9 @@ dependencies = [
[[package]]
name = "skytable"
version = "0.8.3"
version = "0.8.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "921ad91fc76119f84e8fa928bd4d2c206213e059c7a6fb297d6267d5b49161b2"
checksum = "03e8d2a2164bdf8d5612caf70c31baf3ae905bc7bc4292dd631cfbe67eb097a9"
dependencies = [
"async-trait",
"bb8",
@ -1240,13 +1240,12 @@ dependencies = [
[[package]]
name = "tempfile"
version = "3.9.0"
version = "3.10.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "01ce4141aa927a6d1bd34a041795abd0db1cccba5d5f24b009f694bdf3a1f3fa"
checksum = "85b77fafb263dd9d05cbeac119526425676db3784113aa9295c88498cbf8bff1"
dependencies = [
"cfg-if",
"fastrand",
"redox_syscall",
"rustix",
"windows-sys 0.52.0",
]

2
Cargo.toml
View File

@ -16,7 +16,7 @@ jsonwebtoken = "9.2.0"
rand = "0.8.5"
rsa = "0.9.6"
serde_json = "1.0.111"
skytable = "0.8.3"
skytable = "0.8.6"
tokio = { version = "1.35.1", features = ["full"] }
urlencoding = "2.1.3"
uuid = { version = "1.6.1", features = ["v4", "v5"] }

408
src/main.rs
View File

@ -1,76 +1,94 @@
use std::{
sync::Arc,
net::SocketAddr,
collections::HashMap,
time::{SystemTime, UNIX_EPOCH},
};
use chrono::{
DateTime,
};
use http_body_util::{
Full,
BodyExt,
};
use hyper::{
StatusCode,
Request,
Response,
Method,
HeaderMap,
header::HeaderValue,
body::{Bytes, Incoming},
server::conn::http1 as Server,
service::service_fn,
};
use hyper_util::{
rt::TokioIo,
};
use tokio::{
net::TcpListener,
};
use rsa::{
pkcs1::{EncodeRsaPublicKey, EncodeRsaPrivateKey},
RsaPrivateKey,
RsaPublicKey,
};
use urlencoding::{
decode as url_decode,
};
use jsonwebtoken as jwt;
use jwt::{
Header,
Algorithm,
TokenData,
Validation,
EncodingKey,
DecodingKey,
encode as jwt_encode,
decode as jwt_decode,
};
use serde_json::{
Value as Json,
json,
};
use uuid::{
Uuid,
};
use skytable::{
Config,
pool::{self, ConnectionMgrTcp},
query,
};
use bb8::{
Pool,
};
mod type_users;
mod type_sites;
use crate::{
type_users::Users,
type_sites::Sites,
use {
std::{
sync::Arc,
net::SocketAddr,
collections::HashMap,
time::{
SystemTime,
UNIX_EPOCH,
},
},
chrono::{
DateTime,
},
http_body_util::{
Full,
BodyExt,
},
hyper::{
StatusCode,
Request,
Response,
Method,
HeaderMap,
header::HeaderValue,
body::{
Bytes,
Incoming,
},
server::conn::http1 as Server,
service::service_fn,
},
hyper_util::{
rt::TokioIo,
},
tokio::{
net::TcpListener,
},
rsa::{
pkcs1::{
EncodeRsaPublicKey,
EncodeRsaPrivateKey,
},
RsaPrivateKey,
RsaPublicKey,
},
urlencoding::{
decode as url_decode,
},
jsonwebtoken as jwt,
jwt::{
Header,
Algorithm,
TokenData,
Validation,
EncodingKey,
DecodingKey,
encode as jwt_encode,
decode as jwt_decode,
},
serde_json::{
Value as Json,
json,
},
uuid::{
Uuid,
},
skytable::{
query,
Config,
pool::{
self,
ConnectionMgrTcp
},
error::Error as SkyError,
},
bb8::{
Pool,
},
crate::{
type_users::Users,
type_sites::Sites,
},
};
type Res<T, E> = std::result::Result<T, E>;
type Result<T> = std::result::Result<T, Box<dyn std::error::Error + Send + Sync>>;
type DBPool = Arc<Pool<ConnectionMgrTcp>>;
type FullBytes = Result<Response<Full<Bytes>>>;
const PORT: u16 = 8081;
@ -98,6 +116,7 @@ const HEADER_HTML: &str = r#"
<main>
"#;
const FOOTER_HTML: &str = r#"
</main>
<footer>
<hr>
Made by BitHeaven.
@ -136,6 +155,8 @@ const RECOVER_HTML: &str = "<h1>recover</h1>";
const NF_HTML: &str = "<h1>404</h1>think about it.";
const CSS3: &str = r#"<style>
:root { color-scheme: dark; }
body { margin: auto; max-width: 768px; }
footer { text-align: right; }
</style>"#;
#[tokio::main]
@ -143,7 +164,12 @@ async fn main() -> Result<()> {
let addr = SocketAddr::from(([0, 0, 0, 0], PORT));
let listener = TcpListener::bind(addr).await?;
let pool = Arc::new(pool::get_async(DB_POOL, Config::new(DB_ADDR, DB_PORT, DB_USER, DB_PASS)).await.unwrap());
let pool = Arc::new(
pool::get_async(
DB_POOL,
Config::new(DB_ADDR, DB_PORT, DB_USER, DB_PASS)
).await.unwrap()
);
init_tables(pool.clone()).await?;
println!("Server started on port: {}", PORT);
@ -158,7 +184,11 @@ async fn main() -> Result<()> {
let this_pool = pool.clone();
tokio::task::spawn(async move {
if let Err(err) = Server::Builder::new().serve_connection(
io, service_fn(move |req| handle_connection(req, this_pool.clone(), ip.clone()))
io, service_fn(move |req| handle_connection(
req,
this_pool.clone(),
ip.clone()
))
).await {
println!("Error serving connection: {:?}", err);
}
@ -166,17 +196,10 @@ async fn main() -> Result<()> {
}
}
async fn handle_connection(req: Request<Incoming>, pool: Arc<Pool<ConnectionMgrTcp>>, ip: String) -> Result<Response<Full<Bytes>>> {
async fn handle_connection(req: Request<Incoming>, pool: DBPool, ip: String) -> FullBytes {
if ip == "1.1.1.1" {
}
// let mut con = pool.get().await?;
// let q = con.query_parse::<Forwards>(&query!("SELECT * FROM bitproxy.forwards WHERE domain = ?", host)).await;
// if !q.is_ok() {
// }
// let target_url = q.unwrap().address.to_owned()
// .parse::<hyper::Uri>().unwrap();
let res = Response::new(Full::new(Bytes::new()));
let (mut parts, _) = res.into_parts();
let body: String;
@ -191,7 +214,12 @@ async fn handle_connection(req: Request<Incoming>, pool: Arc<Pool<ConnectionMgrT
_ => ""
};
if token != "" && jwt_verify(pool.clone(), token).await?.claims.as_object().unwrap().len() == 0 {
println!("{}", token);
if token != "" && jwt_verify(pool.clone(), token)
.await?.claims.as_object().unwrap().len() == 0
{
println!("Invalid suka");
parts.status = StatusCode::FOUND;
set_cookie(&mut headers, "token", "");
set_location(&mut headers, "/");
@ -203,8 +231,9 @@ async fn handle_connection(req: Request<Incoming>, pool: Arc<Pool<ConnectionMgrT
"/" => uri_index(),
"/cabinet" => uri_login(req, pool.clone(), &mut headers).await?,
"/login" => uri_login(req, pool.clone(), &mut headers).await?,
"/register" => uri_register(req, pool.clone()).await?,
"/register" => uri_register(req, pool.clone(), &mut headers).await?,
"/recover" => uri_recover(),
x if x.starts_with("/@") => uri_user(req, pool.clone()).await?,
x if x.starts_with("/api") => uri_api(req),
_ => uri_404()
};
@ -220,9 +249,15 @@ fn build_html(body: &str) -> String {
}
fn set_cookie(headers: &mut HeaderMap, key: &str, value: &str) {
let time = DateTime::from_timestamp((time() + REFRESH_LIFETIME) as i64, 0).expect("REASON").to_rfc2822();
let time = DateTime::from_timestamp((time() + REFRESH_LIFETIME) as i64, 0)
.expect("REASON")
.to_rfc2822();
let time = time.replace("+0000", "GMT");
headers.append(hyper::header::SET_COOKIE, HeaderValue::from_str(format!("{}={}; HttpOnly; Expires={}", key, value, time).as_str()).unwrap());
headers.append(
hyper::header::SET_COOKIE,
HeaderValue::from_str(format!("{}={}; HttpOnly; Expires={}", key, value, time).as_str())
.unwrap()
);
}
fn get_cookies(headers: HeaderMap) -> HashMap<String, String> {
@ -236,21 +271,23 @@ fn get_cookies(headers: HeaderMap) -> HashMap<String, String> {
}
fn set_location(headers: &mut HeaderMap, location: &str) {
headers.append(hyper::header::LOCATION, HeaderValue::from_str(format!("{}", location).as_str()).unwrap());
headers.append(
hyper::header::LOCATION,
HeaderValue::from_str(format!("{}", location).as_str()).unwrap()
);
}
async fn uri_login(req: Request<Incoming>, pool: Arc<Pool<ConnectionMgrTcp>>, headers: &mut HeaderMap) -> Result<(String, StatusCode, HeaderValue)> {
let mut cookie: String = Default::default();
async fn uri_login(req: Request<Incoming>, pool: DBPool, headers: &mut HeaderMap) -> Result<(String, StatusCode, HeaderValue)> {
if *req.method() == Method::POST {
let body = get_body_from_request(req).await?;
let body = String::from_utf8(body).unwrap();
let body = double_split(body, "&", "=");
cookie = login_user(pool.clone(), body).await?;
}
let (access, refresh) = login_user(pool.clone(), body).await?;
set_cookie(headers, "token", &cookie);
set_cookie(headers, "token", &access);
set_cookie(headers, "refresh", &refresh);
}
let restype: HeaderValue = "text/html".parse().unwrap();
Ok((build_html(LOGIN_HTML), StatusCode::OK, restype))
@ -261,20 +298,34 @@ fn uri_index() -> (String, StatusCode, HeaderValue) {
(build_html(INDEX_HTML), StatusCode::OK, restype)
}
async fn uri_register(req: Request<Incoming>, pool: Arc<Pool<ConnectionMgrTcp>>) -> Result<(String, StatusCode, HeaderValue)> {
if *req.method() == Method::POST {
let body = get_body_from_request(req).await?;
let body = String::from_utf8(body).unwrap();
let body = double_split(body, "&", "=");
async fn uri_register(req: Request<Incoming>, pool: DBPool, headers: &mut HeaderMap) -> Result<(String, StatusCode, HeaderValue)> {
let mut body = "".to_owned();
let mut status = StatusCode::OK;
let restype: HeaderValue = "text/html".parse().unwrap();
match create_user(pool.clone(), body).await? {
true => println!("Created"),
_ => println!("Failed")
if *req.method() == Method::POST {
let request = get_body_from_request(req).await?;
let request = String::from_utf8(request).unwrap();
let request = double_split(request, "&", "=");
match create_user(pool.clone(), request).await? {
true => {
println!("Created");
set_location(headers, "/login");
},
_ => {
println!("Failed");
set_location(headers, "/register");
}
}
status = StatusCode::FOUND;
}
else {
body = build_html(REG_HTML);
}
let restype: HeaderValue = "text/html".parse().unwrap();
Ok((build_html(REG_HTML), StatusCode::OK, restype))
Ok((body, status, restype))
}
fn uri_recover() -> (String, StatusCode, HeaderValue) {
@ -283,8 +334,8 @@ fn uri_recover() -> (String, StatusCode, HeaderValue) {
}
fn uri_api(req: Request<Incoming>) -> (String, StatusCode, HeaderValue) {
let uri_api: &str = req.uri().path().as_ref();
let res: Json = match &uri_api[4..uri_api.len()] {
let uri: &str = req.uri().path().as_ref();
let res: Json = match &uri[4..uri.len()] {
"/test" => json!({"error": false, "msg": "test"}),
_ => json!({"error": true, "msg": "No endpoint"})
};
@ -293,24 +344,59 @@ fn uri_api(req: Request<Incoming>) -> (String, StatusCode, HeaderValue) {
(res.to_string(), StatusCode::IM_A_TEAPOT, restype)
}
async fn uri_user(req: Request<Incoming>, pool: DBPool) -> Res<(String, StatusCode, HeaderValue), SkyError> {
let uri: &str = req.uri().path().as_ref();
let login = &uri[2..uri.len()];
let body: String;
let user = get_user(pool, login.to_string()).await;
if user.is_ok() {
body = format!("{}", user?.uuid);
}
else {
body = "Not fond :(".to_owned();
}
let restype: HeaderValue = "text/html".parse().unwrap();
Ok((build_html(&body), StatusCode::OK, restype))
}
fn uri_404() -> (String, StatusCode, HeaderValue) {
let restype: HeaderValue = "text/html".parse().unwrap();
(build_html(NF_HTML), StatusCode::NOT_FOUND, restype)
}
async fn init_tables(pool: Arc<Pool<ConnectionMgrTcp>>) -> Res<(), skytable::error::Error> {
async fn init_tables(pool: DBPool) -> Res<(), SkyError> {
let mut con = pool.get().await.unwrap();
let _ = con.query_parse::<()>(&query!("CREATE SPACE IF NOT EXISTS bitauth")).await;
let _ = con.query_parse::<()>(&query!(
"CREATE MODEL IF NOT EXISTS bitauth.users(login: string, uuid: string, password: string, null email: string)"
)).await;
let _ = con.query_parse::<()>(&query!(
"CREATE MODEL IF NOT EXISTS bitauth.sites(uuid: string, uid: string, domain: string, pkey: binary, skey: binary)"
)).await;
let _ = con.query_parse::<()>(&query!(
"CREATE MODEL IF NOT EXISTS bitauth.tokens(uuid: string, uid: string, sid: string, ref: string, refend: uint32)"
)).await;
let _ = con.query_parse::<()>(&query!(r#"
CREATE MODEL IF NOT EXISTS bitauth.users(
login: string,
uuid: string,
password: string,
email: string,
tokens: list {type: string}
)
"#)).await;
let _ = con.query_parse::<()>(&query!(r#"
CREATE MODEL IF NOT EXISTS bitauth.sites(
uuid: string,
uid: string,
domain: string,
pkey: binary,
skey: binary
)
"#)).await;
let _ = con.query_parse::<()>(&query!(r#"
CREATE MODEL IF NOT EXISTS bitauth.tokens(
uuid: string,
uid: string,
sid: string,
ref: string,
refend: uint32
)
"#)).await;
let q = con.query_parse::<Sites>(&query!("SELECT * FROM bitauth.sites WHERE uuid = 0")).await;
if q.is_err() {
@ -324,47 +410,82 @@ async fn init_tables(pool: Arc<Pool<ConnectionMgrTcp>>) -> Res<(), skytable::err
Ok(())
}
async fn login_user(pool: Arc<Pool<ConnectionMgrTcp>>, data: HashMap<String, String>) -> Res<String, skytable::error::Error> {
let mut err = false;
let mut ret: String = Default::default();
async fn get_user(pool: DBPool, login: String) -> Res<Users, SkyError> {
let mut con = pool.get().await.unwrap();
let login = data.get("login").unwrap();
let q = con
.query_parse::<Users>(&query!("SELECT * FROM bitauth.users WHERE login = ?", login))
.await;
Ok(q?)
}
async fn login_user(pool: DBPool, data: HashMap<String, String>) -> Res<(String, String), SkyError> {
let mut err = false;
let mut ret: (String, String) = Default::default();
let mut con = pool.get().await.unwrap();
let login = &data.get("login").unwrap().trim().to_lowercase();
let pass = data.get("password").unwrap().trim();
let q = con.query_parse::<Users>(&query!("SELECT * FROM bitauth.users WHERE login = ?", login)).await;
let q = con
.query_parse::<Users>(&query!("SELECT * FROM bitauth.users WHERE login = ?", login))
.await;
if q.is_err() { err = true };
if !err {
let q = q.unwrap();
if bcrypt::verify(pass, q.password.as_str()).unwrap() {
ret = jwt_sign(pool.clone(), json!({
"login": q.login,
"uuid": q.uuid,
// "refresh": q.ref,
// "refexp": q.refend,
"iat": time(),
"exp": time() + TOKEN_LIFETIME
})).await.unwrap();
let token = format!("{}", uuid_v4().as_hyphenated());
let reftoken = format!("{}", uuid_v4().as_hyphenated());
let time = time();
let uuid: String = q.uuid;
let login: String = q.login;
let _ = con.query_parse::<()>(&query!(
"INSERT INTO bitauth.tokens { uuid: ?, uid: ?, sid: ?, ref: ?, refend: ? }",
token.clone(), uuid.clone(), "0", reftoken.clone(), time + REFRESH_LIFETIME
)).await;
let _ = con.query_parse::<()>(&query!(
"UPDATE bitauth.users SET tokens += ? WHERE login = ?",
token.clone(), login.clone()
)).await;
ret = (
jwt_sign(pool.clone(), json!({
"login": login.clone(),
"uuid": uuid.clone(),
"iat": time,
"exp": time + TOKEN_LIFETIME
})).await.unwrap(),
jwt_sign(pool.clone(), json!({
"uuid": token.clone(),
"iat": time,
"ref": reftoken.clone(),
"exp": time + REFRESH_LIFETIME
})).await.unwrap()
);
}
}
Ok(ret)
}
async fn create_user(pool: Arc<Pool<ConnectionMgrTcp>>, data: HashMap<String, String>) -> Res<bool, skytable::error::Error> {
async fn create_user(pool: DBPool, data: HashMap<String, String>) -> Res<bool, SkyError> {
let mut ret = true;
let mut con = pool.get().await.unwrap();
let login = data.get("login").unwrap();
let email = data.get("email").unwrap();
let pass = data.get("password").unwrap();
let pass2 = data.get("password2").unwrap();
let login = &data.get("login").unwrap().trim().to_lowercase();
let email = &data.get("email").unwrap().trim().to_lowercase();
let pass = data.get("password").unwrap().trim();
let pass2 = data.get("password2").unwrap().trim();
if pass != pass2 { ret = false };
if pass.len() < 8 { ret = false };
let q = con.query_parse::<(String,)>(&query!("SELECT uuid FROM bitauth.users WHERE login = ?", login)).await;
let q = con
.query_parse::<(String,)>(&query!("SELECT uuid FROM bitauth.users WHERE login = ?", login))
.await;
if q.is_ok() { ret = false };
if ret {
@ -373,15 +494,16 @@ async fn create_user(pool: Arc<Pool<ConnectionMgrTcp>>, data: HashMap<String, St
let q = con.query_parse::<()>(&query!(
r#"INSERT INTO bitauth.users {
uuid: ?,
login: ?,
uuid: ?,
password: ?,
email: ?
email: ?,
tokens: []
}"#,
uuid,
login,
uuid,
pass,
email
email,
)).await;
if q.is_err() { ret = false }
@ -406,8 +528,12 @@ fn double_split(body: String, first: &str, second: &str) -> HashMap<String, Stri
body.split(first)
.filter_map(|c| {
c.split_once(second)
.map(|(l, r)| (l.trim().to_owned(), format!("{}", url_decode(r).expect("UTF-8")).trim().to_owned()))})
.collect::<HashMap<String, String>>()
.map(|(l, r)| (
l.trim().to_owned(),
format!("{}", url_decode(r).expect("UTF-8")).trim().to_owned()
))
})
.collect::<HashMap<String, String>>()
}
fn rsa_gen() -> (Vec<u8>, Vec<u8>) {
@ -422,10 +548,12 @@ fn rsa_gen() -> (Vec<u8>, Vec<u8>) {
(skey, pkey)
}
async fn jwt_sign(pool: Arc<Pool<ConnectionMgrTcp>>, data: Json) -> Result<String> {
async fn jwt_sign(pool: DBPool, data: Json) -> Result<String> {
let mut con = pool.get().await.unwrap();
let q = con.query_parse::<Sites>(&query!("SELECT * FROM bitauth.sites WHERE uuid = ?", "0")).await;
let q = con
.query_parse::<Sites>(&query!("SELECT * FROM bitauth.sites WHERE uuid = ?", "0"))
.await;
if q.is_err() { return Ok("".to_owned()) };
let skey = q.unwrap().skey;
@ -436,11 +564,13 @@ async fn jwt_sign(pool: Arc<Pool<ConnectionMgrTcp>>, data: Json) -> Result<Strin
Ok(token)
}
async fn jwt_verify(pool: Arc<Pool<ConnectionMgrTcp>>, token: &str) -> Result<TokenData<Json>> {
async fn jwt_verify(pool: DBPool, token: &str) -> Result<TokenData<Json>> {
let mut con = pool.get().await.unwrap();
let mut ret = TokenData { header: Header::new(Algorithm::RS512), claims: json![{}] };
let q = con.query_parse::<Sites>(&query!("SELECT * FROM bitauth.sites WHERE uuid = ?", "0")).await;
let q = con
.query_parse::<Sites>(&query!("SELECT * FROM bitauth.sites WHERE uuid = ?", "0"))
.await;
if q.is_err() { return Ok(ret) };
let pkey = q.unwrap().pkey;

22
src/type_users.rs
View File

@ -1,7 +1,11 @@
use skytable::{
query::SQParam,
response::{FromResponse, Response},
ClientResult,
query::SQParam,
response::{
FromResponse,
Response,
Value,
},
ClientResult,
};
@ -9,16 +13,18 @@ pub struct Users {
pub login: String,
pub uuid: String,
pub password: String,
pub email: String,
pub email: String,
pub tokens: Vec<Value>,
}
impl Users {
pub fn new(login: String, uuid: String, password: String, email: String) -> Self {
pub fn new(login: String, uuid: String, password: String, email: String, tokens: Vec<Value>) -> Self {
Self {
login,
uuid,
password,
email,
tokens,
}
}
}
@ -27,12 +33,14 @@ impl SQParam for Users {
fn append_param(&self, q: &mut Vec<u8>) -> usize {
self.login.append_param(q)
+ self.uuid.append_param(q)
+ self.password.append_param(q)
+ self.email.append_param(q)
}
}
impl FromResponse for Users {
fn from_response(resp: Response) -> ClientResult<Self> {
let (login, uuid, password, email) = FromResponse::from_response(resp)?;
Ok(Self::new(login, uuid, password, email))
let (login, uuid, password, email, tokens) = FromResponse::from_response(resp)?;
Ok(Self::new(login, uuid, password, email, tokens))
}
}