crates/api/src/lib.rs

   1 use actix_web::web::Data;
   2 use base64::{engine::general_purpose::STANDARD_NO_PAD as base64, Engine};
   3 use captcha::Captcha;
   4 use lemmy_api_common::{context::LemmyContext, utils::local_site_to_slur_regex};
   5 use lemmy_db_schema::source::local_site::LocalSite;
   6 use lemmy_utils::{
   7   error::{LemmyError, LemmyErrorExt, LemmyErrorType},
   8   utils::slurs::check_slurs,
   9 };
  10 use std::io::Cursor;
  11
  12 mod comment;
  13 mod comment_report;
  14 mod community;
  15 mod local_user;
  16 mod post;
  17 mod post_report;
  18 mod private_message;
  19 mod private_message_report;
  20 mod site;
  21
  22 #[async_trait::async_trait(?Send)]
  23 pub trait Perform {
  24   type Response: serde::ser::Serialize + Send + Clone + Sync;
  25
  26   async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError>;
  27 }
  28
  29 /// Converts the captcha to a base64 encoded wav audio file
  30 pub(crate) fn captcha_as_wav_base64(captcha: &Captcha) -> Result<String, LemmyError> {
  31   let letters = captcha.as_wav();
  32
  33   // Decode each wav file, concatenate the samples
  34   let mut concat_samples: Vec<i16> = Vec::new();
  35   let mut any_header: Option<wav::Header> = None;
  36   for letter in letters {
  37     let mut cursor = Cursor::new(letter.unwrap_or_default());
  38     let (header, samples) = wav::read(&mut cursor)?;
  39     any_header = Some(header);
  40     if let Some(samples16) = samples.as_sixteen() {
  41       concat_samples.extend(samples16);
  42     } else {
  43       return Err(LemmyErrorType::CouldntCreateAudioCaptcha)?;
  44     }
  45   }
  46
  47   // Encode the concatenated result as a wav file
  48   let mut output_buffer = Cursor::new(vec![]);
  49   let header = match any_header {
  50     Some(header) => header,
  51     None => return Err(LemmyErrorType::CouldntCreateAudioCaptcha)?,
  52   };
  53   wav::write(
  54     header,
  55     &wav::BitDepth::Sixteen(concat_samples),
  56     &mut output_buffer,
  57   )
  58   .with_lemmy_type(LemmyErrorType::CouldntCreateAudioCaptcha)?;
  59
  60   Ok(base64.encode(output_buffer.into_inner()))
  61 }
  62
  63 /// Check size of report and remove whitespace
  64 pub(crate) fn check_report_reason(reason: &str, local_site: &LocalSite) -> Result<(), LemmyError> {
  65   let slur_regex = &local_site_to_slur_regex(local_site);
  66
  67   check_slurs(reason, slur_regex)?;
  68   if reason.is_empty() {
  69     return Err(LemmyErrorType::ReportReasonRequired)?;
  70   }
  71   if reason.chars().count() > 1000 {
  72     return Err(LemmyErrorType::ReportTooLong)?;
  73   }
  74   Ok(())
  75 }
  76
  77 #[cfg(test)]
  78 mod tests {
  79   use lemmy_api_common::utils::check_validator_time;
  80   use lemmy_db_schema::{
  81     source::{
  82       instance::Instance,
  83       local_user::{LocalUser, LocalUserInsertForm},
  84       person::{Person, PersonInsertForm},
  85       secret::Secret,
  86     },
  87     traits::Crud,
  88     utils::build_db_pool_for_tests,
  89   };
  90   use lemmy_utils::{claims::Claims, settings::SETTINGS};
  91   use serial_test::serial;
  92
  93   #[tokio::test]
  94   #[serial]
  95   async fn test_should_not_validate_user_token_after_password_change() {
  96     let pool = &build_db_pool_for_tests().await;
  97     let pool = &mut pool.into();
  98     let secret = Secret::init(pool).await.unwrap();
  99     let settings = &SETTINGS.to_owned();
 100
 101     let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
 102       .await
 103       .unwrap();
 104
 105     let new_person = PersonInsertForm::builder()
 106       .name("Gerry9812".into())
 107       .public_key("pubkey".to_string())
 108       .instance_id(inserted_instance.id)
 109       .build();
 110
 111     let inserted_person = Person::create(pool, &new_person).await.unwrap();
 112
 113     let local_user_form = LocalUserInsertForm::builder()
 114       .person_id(inserted_person.id)
 115       .password_encrypted("123456".to_string())
 116       .build();
 117
 118     let inserted_local_user = LocalUser::create(pool, &local_user_form).await.unwrap();
 119
 120     let jwt = Claims::jwt(
 121       inserted_local_user.id.0,
 122       &secret.jwt_secret,
 123       &settings.hostname,
 124     )
 125     .unwrap();
 126     let claims = Claims::decode(&jwt, &secret.jwt_secret).unwrap().claims;
 127     let check = check_validator_time(&inserted_local_user.validator_time, &claims);
 128     assert!(check.is_ok());
 129
 130     // The check should fail, since the validator time is now newer than the jwt issue time
 131     let updated_local_user =
 132       LocalUser::update_password(pool, inserted_local_user.id, "password111")
 133         .await
 134         .unwrap();
 135     let check_after = check_validator_time(&updated_local_user.validator_time, &claims);
 136     assert!(check_after.is_err());
 137
 138     let num_deleted = Person::delete(pool, inserted_person.id).await.unwrap();
 139     assert_eq!(1, num_deleted);
 140   }
 141 }