2018-04-24 11:21:39 +02:00
|
|
|
use bcrypt;
|
2018-04-30 19:46:27 +02:00
|
|
|
use chrono::NaiveDateTime;
|
2018-04-29 22:23:44 +02:00
|
|
|
use diesel::{self, QueryDsl, RunQueryDsl, ExpressionMethods, BelongingToDsl, PgConnection};
|
|
|
|
use diesel::dsl::any;
|
2018-05-03 19:12:01 +02:00
|
|
|
use openssl::hash::MessageDigest;
|
|
|
|
use openssl::pkey::{PKey, Private};
|
|
|
|
use openssl::rsa::Rsa;
|
2018-05-03 21:11:04 +02:00
|
|
|
use openssl::sign;
|
2018-05-01 13:48:19 +02:00
|
|
|
use reqwest::Client;
|
|
|
|
use reqwest::header::{Accept, qitem};
|
|
|
|
use reqwest::mime::Mime;
|
2018-04-24 11:21:39 +02:00
|
|
|
use rocket::request::{self, FromRequest, Request};
|
2018-04-23 11:52:44 +02:00
|
|
|
use rocket::outcome::IntoOutcome;
|
2018-05-01 13:48:19 +02:00
|
|
|
use serde_json;
|
2018-05-02 23:36:13 +02:00
|
|
|
use std::sync::Arc;
|
2018-05-01 20:02:29 +02:00
|
|
|
use url::Url;
|
2018-04-24 11:21:39 +02:00
|
|
|
|
2018-05-02 13:53:42 +02:00
|
|
|
use BASE_URL;
|
2018-05-02 22:44:03 +02:00
|
|
|
use activity_pub::activity::{Create, Activity};
|
2018-04-24 11:21:39 +02:00
|
|
|
use activity_pub::actor::{ActorType, Actor};
|
2018-05-01 16:00:29 +02:00
|
|
|
use activity_pub::inbox::Inbox;
|
2018-04-29 20:01:42 +02:00
|
|
|
use activity_pub::outbox::Outbox;
|
2018-05-03 21:11:04 +02:00
|
|
|
use activity_pub::sign::{Signer, gen_keypair};
|
2018-05-01 13:48:19 +02:00
|
|
|
use activity_pub::webfinger::{Webfinger, resolve};
|
2018-04-23 11:52:44 +02:00
|
|
|
use db_conn::DbConn;
|
2018-05-01 15:23:23 +02:00
|
|
|
use models::follows::Follow;
|
2018-04-23 14:01:32 +02:00
|
|
|
use models::instance::Instance;
|
2018-04-29 22:23:44 +02:00
|
|
|
use models::post_authors::PostAuthor;
|
|
|
|
use models::posts::Post;
|
2018-04-24 11:21:39 +02:00
|
|
|
use schema::users;
|
2018-04-23 11:52:44 +02:00
|
|
|
|
|
|
|
pub const AUTH_COOKIE: &'static str = "user_id";
|
2018-04-22 20:13:12 +02:00
|
|
|
|
2018-05-01 13:48:19 +02:00
|
|
|
#[derive(Queryable, Identifiable, Serialize)]
|
2018-04-22 20:13:12 +02:00
|
|
|
pub struct User {
|
|
|
|
pub id: i32,
|
|
|
|
pub username: String,
|
|
|
|
pub display_name: String,
|
|
|
|
pub outbox_url: String,
|
|
|
|
pub inbox_url: String,
|
|
|
|
pub is_admin: bool,
|
|
|
|
pub summary: String,
|
|
|
|
pub email: Option<String>,
|
|
|
|
pub hashed_password: Option<String>,
|
2018-04-30 19:46:27 +02:00
|
|
|
pub instance_id: i32,
|
2018-05-01 20:02:29 +02:00
|
|
|
pub creation_date: NaiveDateTime,
|
2018-05-03 19:12:01 +02:00
|
|
|
pub ap_url: String,
|
|
|
|
pub private_key: Option<String>,
|
|
|
|
pub public_key: String
|
2018-04-22 20:13:12 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Insertable)]
|
|
|
|
#[table_name = "users"]
|
|
|
|
pub struct NewUser {
|
|
|
|
pub username: String,
|
|
|
|
pub display_name: String,
|
|
|
|
pub outbox_url: String,
|
|
|
|
pub inbox_url: String,
|
|
|
|
pub is_admin: bool,
|
|
|
|
pub summary: String,
|
|
|
|
pub email: Option<String>,
|
|
|
|
pub hashed_password: Option<String>,
|
2018-05-01 20:02:29 +02:00
|
|
|
pub instance_id: i32,
|
2018-05-03 19:12:01 +02:00
|
|
|
pub ap_url: String,
|
|
|
|
pub private_key: Option<String>,
|
|
|
|
pub public_key: String
|
2018-04-22 20:13:12 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
impl User {
|
2018-04-23 12:29:27 +02:00
|
|
|
pub fn grant_admin_rights() {}
|
2018-04-22 20:13:12 +02:00
|
|
|
|
|
|
|
pub fn insert (conn: &PgConnection, new: NewUser) -> User {
|
|
|
|
diesel::insert_into(users::table)
|
|
|
|
.values(new)
|
|
|
|
.get_result(conn)
|
2018-04-23 11:52:44 +02:00
|
|
|
.expect("Error saving new user")
|
2018-04-22 20:13:12 +02:00
|
|
|
}
|
|
|
|
|
2018-04-23 11:52:44 +02:00
|
|
|
pub fn get(conn: &PgConnection, id: i32) -> Option<User> {
|
|
|
|
users::table.filter(users::id.eq(id))
|
|
|
|
.limit(1)
|
|
|
|
.load::<User>(conn)
|
|
|
|
.expect("Error loading user by id")
|
|
|
|
.into_iter().nth(0)
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn find_by_email(conn: &PgConnection, email: String) -> Option<User> {
|
|
|
|
users::table.filter(users::email.eq(email))
|
|
|
|
.limit(1)
|
|
|
|
.load::<User>(conn)
|
|
|
|
.expect("Error loading user by email")
|
|
|
|
.into_iter().nth(0)
|
|
|
|
}
|
|
|
|
|
2018-05-01 13:48:19 +02:00
|
|
|
pub fn find_by_name(conn: &PgConnection, username: String, instance_id: i32) -> Option<User> {
|
2018-04-23 11:52:44 +02:00
|
|
|
users::table.filter(users::username.eq(username))
|
2018-05-01 13:48:19 +02:00
|
|
|
.filter(users::instance_id.eq(instance_id))
|
2018-04-23 11:52:44 +02:00
|
|
|
.limit(1)
|
|
|
|
.load::<User>(conn)
|
2018-05-01 20:02:29 +02:00
|
|
|
.expect("Error loading user by name")
|
2018-04-23 11:52:44 +02:00
|
|
|
.into_iter().nth(0)
|
|
|
|
}
|
|
|
|
|
2018-05-01 13:48:19 +02:00
|
|
|
pub fn find_local(conn: &PgConnection, username: String) -> Option<User> {
|
|
|
|
User::find_by_name(conn, username, Instance::local_id(conn))
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn find_by_fqn(conn: &PgConnection, fqn: String) -> Option<User> {
|
|
|
|
if fqn.contains("@") { // remote user
|
|
|
|
match Instance::get_by_domain(conn, String::from(fqn.split("@").last().unwrap())) {
|
|
|
|
Some(instance) => {
|
|
|
|
match User::find_by_name(conn, String::from(fqn.split("@").nth(0).unwrap()), instance.id) {
|
|
|
|
Some(u) => Some(u),
|
|
|
|
None => User::fetch_from_webfinger(conn, fqn)
|
|
|
|
}
|
|
|
|
},
|
|
|
|
None => User::fetch_from_webfinger(conn, fqn)
|
|
|
|
}
|
|
|
|
} else { // local user
|
|
|
|
User::find_local(conn, fqn)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn fetch_from_webfinger(conn: &PgConnection, acct: String) -> Option<User> {
|
2018-05-01 13:52:50 +02:00
|
|
|
match resolve(acct.clone()) {
|
2018-05-01 20:02:29 +02:00
|
|
|
Ok(url) => User::fetch_from_url(conn, url),
|
2018-05-01 13:48:19 +02:00
|
|
|
Err(details) => {
|
|
|
|
println!("{}", details);
|
|
|
|
None
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-05-01 20:02:29 +02:00
|
|
|
fn fetch_from_url(conn: &PgConnection, url: String) -> Option<User> {
|
|
|
|
let req = Client::new()
|
|
|
|
.get(&url[..])
|
|
|
|
.header(Accept(vec![qitem("application/activity+json".parse::<Mime>().unwrap())]))
|
|
|
|
.send();
|
|
|
|
match req {
|
|
|
|
Ok(mut res) => {
|
|
|
|
let json: serde_json::Value = serde_json::from_str(&res.text().unwrap()).unwrap();
|
|
|
|
Some(User::from_activity(conn, json, Url::parse(url.as_ref()).unwrap().host_str().unwrap().to_string()))
|
|
|
|
},
|
|
|
|
Err(_) => None
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-05-01 13:48:19 +02:00
|
|
|
fn from_activity(conn: &PgConnection, acct: serde_json::Value, inst: String) -> User {
|
|
|
|
let instance = match Instance::get_by_domain(conn, inst.clone()) {
|
|
|
|
Some(instance) => instance,
|
|
|
|
None => {
|
2018-05-02 13:53:42 +02:00
|
|
|
Instance::insert(conn, inst.clone(), inst.clone(), false)
|
2018-05-01 13:48:19 +02:00
|
|
|
}
|
|
|
|
};
|
|
|
|
User::insert(conn, NewUser {
|
|
|
|
username: acct["preferredUsername"].as_str().unwrap().to_string(),
|
|
|
|
display_name: acct["name"].as_str().unwrap().to_string(),
|
|
|
|
outbox_url: acct["outbox"].as_str().unwrap().to_string(),
|
|
|
|
inbox_url: acct["inbox"].as_str().unwrap().to_string(),
|
|
|
|
is_admin: false,
|
|
|
|
summary: acct["summary"].as_str().unwrap().to_string(),
|
|
|
|
email: None,
|
|
|
|
hashed_password: None,
|
2018-05-01 20:02:29 +02:00
|
|
|
instance_id: instance.id,
|
2018-05-03 19:12:01 +02:00
|
|
|
ap_url: acct["id"].as_str().unwrap().to_string(),
|
|
|
|
public_key: acct["publicKey"]["publicKeyPem"].as_str().unwrap().to_string(),
|
|
|
|
private_key: None
|
2018-05-01 13:48:19 +02:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2018-04-23 11:52:44 +02:00
|
|
|
pub fn hash_pass(pass: String) -> String {
|
|
|
|
bcrypt::hash(pass.as_str(), bcrypt::DEFAULT_COST).unwrap()
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn auth(&self, pass: String) -> bool {
|
|
|
|
bcrypt::verify(pass.as_str(), self.hashed_password.clone().unwrap().as_str()).is_ok()
|
|
|
|
}
|
2018-04-23 15:12:59 +02:00
|
|
|
|
|
|
|
pub fn update_boxes(&self, conn: &PgConnection) {
|
|
|
|
if self.outbox_url.len() == 0 {
|
|
|
|
diesel::update(self)
|
|
|
|
.set(users::outbox_url.eq(self.compute_outbox(conn)))
|
|
|
|
.get_result::<User>(conn).expect("Couldn't update outbox URL");
|
|
|
|
}
|
|
|
|
|
|
|
|
if self.inbox_url.len() == 0 {
|
|
|
|
diesel::update(self)
|
|
|
|
.set(users::inbox_url.eq(self.compute_inbox(conn)))
|
2018-05-01 20:02:29 +02:00
|
|
|
.get_result::<User>(conn).expect("Couldn't update inbox URL");
|
|
|
|
}
|
|
|
|
|
|
|
|
if self.ap_url.len() == 0 {
|
|
|
|
diesel::update(self)
|
|
|
|
.set(users::ap_url.eq(self.compute_id(conn)))
|
|
|
|
.get_result::<User>(conn).expect("Couldn't update AP URL");
|
2018-04-23 15:12:59 +02:00
|
|
|
}
|
|
|
|
}
|
2018-04-29 20:01:42 +02:00
|
|
|
|
2018-05-02 23:36:13 +02:00
|
|
|
pub fn outbox(&self, conn: &PgConnection) -> Outbox {
|
2018-04-29 22:23:44 +02:00
|
|
|
Outbox::new(self.compute_outbox(conn), self.get_activities(conn))
|
2018-04-29 20:01:42 +02:00
|
|
|
}
|
|
|
|
|
2018-05-02 23:36:13 +02:00
|
|
|
fn get_activities(&self, conn: &PgConnection) -> Vec<Arc<Activity>> {
|
2018-04-29 22:23:44 +02:00
|
|
|
use schema::posts;
|
|
|
|
use schema::post_authors;
|
|
|
|
let posts_by_self = PostAuthor::belonging_to(self).select(post_authors::post_id);
|
|
|
|
let posts = posts::table.filter(posts::id.eq(any(posts_by_self))).load::<Post>(conn).unwrap();
|
2018-05-02 23:36:13 +02:00
|
|
|
posts.into_iter().map(|p| Arc::new(Create::new(self, &p, conn)) as Arc<Activity>).collect::<Vec<Arc<Activity>>>()
|
2018-04-29 20:01:42 +02:00
|
|
|
}
|
2018-05-01 15:23:23 +02:00
|
|
|
|
|
|
|
pub fn get_followers(&self, conn: &PgConnection) -> Vec<User> {
|
|
|
|
use schema::follows;
|
|
|
|
let follows = Follow::belonging_to(self).select(follows::follower_id);
|
|
|
|
users::table.filter(users::id.eq(any(follows))).load::<User>(conn).unwrap()
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn get_following(&self, conn: &PgConnection) -> Vec<User> {
|
|
|
|
use schema::follows;
|
|
|
|
let follows = follows::table.filter(follows::follower_id.eq(self.id)).select(follows::following_id);
|
|
|
|
users::table.filter(users::id.eq(any(follows))).load::<User>(conn).unwrap()
|
|
|
|
}
|
2018-05-03 19:12:01 +02:00
|
|
|
|
|
|
|
pub fn get_keypair(&self) -> PKey<Private> {
|
|
|
|
PKey::from_rsa(Rsa::private_key_from_pem(self.private_key.clone().unwrap().as_ref()).unwrap()).unwrap()
|
|
|
|
}
|
2018-04-23 11:52:44 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a, 'r> FromRequest<'a, 'r> for User {
|
|
|
|
type Error = ();
|
|
|
|
|
|
|
|
fn from_request(request: &'a Request<'r>) -> request::Outcome<User, ()> {
|
|
|
|
let conn = request.guard::<DbConn>()?;
|
|
|
|
request.cookies()
|
|
|
|
.get_private(AUTH_COOKIE)
|
|
|
|
.and_then(|cookie| cookie.value().parse().ok())
|
|
|
|
.map(|id| User::get(&*conn, id).unwrap())
|
|
|
|
.or_forward(())
|
|
|
|
}
|
2018-04-22 20:13:12 +02:00
|
|
|
}
|
2018-04-23 14:01:32 +02:00
|
|
|
|
|
|
|
impl Actor for User {
|
|
|
|
fn get_box_prefix() -> &'static str {
|
|
|
|
"@"
|
|
|
|
}
|
|
|
|
|
|
|
|
fn get_actor_id(&self) -> String {
|
|
|
|
self.username.to_string()
|
|
|
|
}
|
|
|
|
|
2018-05-03 17:34:16 +02:00
|
|
|
fn get_display_name(&self) -> String {
|
|
|
|
self.display_name.clone()
|
|
|
|
}
|
|
|
|
|
|
|
|
fn get_summary(&self) -> String {
|
|
|
|
self.summary.clone()
|
|
|
|
}
|
|
|
|
|
2018-04-23 14:01:32 +02:00
|
|
|
fn get_instance(&self, conn: &PgConnection) -> Instance {
|
|
|
|
Instance::get(conn, self.instance_id).unwrap()
|
|
|
|
}
|
2018-04-23 18:26:01 +02:00
|
|
|
|
|
|
|
fn get_actor_type() -> ActorType {
|
|
|
|
ActorType::Person
|
|
|
|
}
|
2018-05-01 20:02:29 +02:00
|
|
|
|
2018-05-05 15:46:06 +02:00
|
|
|
fn get_inbox_url(&self) -> String {
|
|
|
|
self.inbox_url.clone()
|
|
|
|
}
|
|
|
|
|
2018-05-03 21:11:04 +02:00
|
|
|
fn custom_props(&self, conn: &PgConnection) -> serde_json::Map<String, serde_json::Value> {
|
|
|
|
let mut res = serde_json::Map::new();
|
|
|
|
res.insert("publicKey".to_string(), json!({
|
|
|
|
"id": self.get_key_id(conn),
|
|
|
|
"owner": self.compute_id(conn),
|
|
|
|
"publicKeyPem": self.public_key
|
|
|
|
}));
|
2018-05-04 15:18:58 +02:00
|
|
|
res.insert("followers".to_string(), serde_json::Value::String(self.compute_box(conn, "followers")));
|
2018-05-03 21:11:04 +02:00
|
|
|
res
|
|
|
|
}
|
|
|
|
|
2018-05-01 20:02:29 +02:00
|
|
|
fn from_url(conn: &PgConnection, url: String) -> Option<User> {
|
|
|
|
let in_db = users::table.filter(users::ap_url.eq(url.clone()))
|
|
|
|
.limit(1)
|
|
|
|
.load::<User>(conn)
|
|
|
|
.expect("Error loading user by AP url")
|
|
|
|
.into_iter().nth(0);
|
|
|
|
match in_db {
|
|
|
|
Some(u) => Some(u),
|
|
|
|
None => {
|
|
|
|
// The requested user was not in the DB
|
|
|
|
// We try to fetch it if it is remote
|
2018-05-02 13:53:42 +02:00
|
|
|
if Url::parse(url.as_ref()).unwrap().host_str().unwrap() != BASE_URL.as_str() {
|
2018-05-01 20:02:29 +02:00
|
|
|
Some(User::fetch_from_url(conn, url).unwrap())
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2018-04-23 14:01:32 +02:00
|
|
|
}
|
2018-04-23 15:12:59 +02:00
|
|
|
|
2018-05-01 16:00:29 +02:00
|
|
|
impl Inbox for User {
|
|
|
|
fn received(&self, conn: &PgConnection, act: serde_json::Value) {
|
|
|
|
self.save(conn, act);
|
|
|
|
// TODO: add to stream or create notification, or whatever needs to be done
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-04-24 10:35:45 +02:00
|
|
|
impl Webfinger for User {
|
|
|
|
fn webfinger_subject(&self, conn: &PgConnection) -> String {
|
|
|
|
format!("acct:{}@{}", self.username, self.get_instance(conn).public_domain)
|
|
|
|
}
|
|
|
|
fn webfinger_aliases(&self, conn: &PgConnection) -> Vec<String> {
|
|
|
|
vec![self.compute_id(conn)]
|
|
|
|
}
|
|
|
|
fn webfinger_links(&self, conn: &PgConnection) -> Vec<Vec<(String, String)>> {
|
|
|
|
vec![
|
|
|
|
vec![
|
|
|
|
(String::from("rel"), String::from("http://webfinger.net/rel/profile-page")),
|
|
|
|
(String::from("href"), self.compute_id(conn))
|
|
|
|
],
|
|
|
|
vec![
|
|
|
|
(String::from("rel"), String::from("http://schemas.google.com/g/2010#updates-from")),
|
|
|
|
(String::from("type"), String::from("application/atom+xml")),
|
|
|
|
(String::from("href"), self.compute_box(conn, "feed.atom"))
|
|
|
|
],
|
|
|
|
vec![
|
|
|
|
(String::from("rel"), String::from("self")),
|
|
|
|
(String::from("type"), String::from("application/activity+json")),
|
|
|
|
(String::from("href"), self.compute_id(conn))
|
|
|
|
]
|
|
|
|
]
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-05-03 21:11:04 +02:00
|
|
|
impl Signer for User {
|
2018-05-03 19:12:01 +02:00
|
|
|
fn get_key_id(&self, conn: &PgConnection) -> String {
|
|
|
|
format!("{}#main-key", self.compute_id(conn))
|
|
|
|
}
|
|
|
|
|
|
|
|
fn sign(&self, to_sign: String) -> Vec<u8> {
|
|
|
|
let key = self.get_keypair();
|
2018-05-03 21:11:04 +02:00
|
|
|
let mut signer = sign::Signer::new(MessageDigest::sha256(), &key).unwrap();
|
2018-05-03 19:12:01 +02:00
|
|
|
signer.update(to_sign.as_bytes()).unwrap();
|
|
|
|
signer.sign_to_vec().unwrap()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-04-23 15:12:59 +02:00
|
|
|
impl NewUser {
|
|
|
|
/// Creates a new local user
|
|
|
|
pub fn new_local(
|
|
|
|
username: String,
|
|
|
|
display_name: String,
|
|
|
|
is_admin: bool,
|
|
|
|
summary: String,
|
|
|
|
email: String,
|
|
|
|
password: String,
|
|
|
|
instance_id: i32
|
|
|
|
) -> NewUser {
|
2018-05-03 21:11:04 +02:00
|
|
|
let (pub_key, priv_key) = gen_keypair();
|
2018-04-23 15:12:59 +02:00
|
|
|
NewUser {
|
|
|
|
username: username,
|
|
|
|
display_name: display_name,
|
|
|
|
outbox_url: String::from(""),
|
|
|
|
inbox_url: String::from(""),
|
|
|
|
is_admin: is_admin,
|
|
|
|
summary: summary,
|
|
|
|
email: Some(email),
|
|
|
|
hashed_password: Some(password),
|
2018-05-01 20:02:29 +02:00
|
|
|
instance_id: instance_id,
|
2018-05-03 19:12:01 +02:00
|
|
|
ap_url: String::from(""),
|
|
|
|
public_key: String::from_utf8(pub_key).unwrap(),
|
|
|
|
private_key: Some(String::from_utf8(priv_key).unwrap())
|
2018-04-23 15:12:59 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|