From 73b0fb8762dcf06096757511ad32e0113450b306 Mon Sep 17 00:00:00 2001
From: BitHeaven <bit.heaven@bk.ru>
Date: Fri, 15 Mar 2024 08:17:14 +0500
Subject: [PATCH] Add some users and jwt

---
 Cargo.lock        |  41 +++--
 Cargo.toml        |   2 +-
 src/main.rs       | 408 ++++++++++++++++++++++++++++++----------------
 src/type_users.rs |  22 ++-
 4 files changed, 305 insertions(+), 168 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 0e2b17d..bfcffa5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -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",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index dd398ed..05df1fd 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -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"] }
diff --git a/src/main.rs b/src/main.rs
index 4c08173..8cb12ab 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -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;
 
diff --git a/src/type_users.rs b/src/type_users.rs
index bc92bad..845a8de 100644
--- a/src/type_users.rs
+++ b/src/type_users.rs
@@ -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))
 	}
 }