refactor: rename broadcast_shared_secret -> broadcast_secret

benches/benchmark_decrypting.rs

@@ -27,9 +27,9 @@
 use std::hint::black_box;
 
 use criterion::{Criterion, criterion_group, criterion_main};
-use deltachat::internals_for_benchmarks::create_broadcast_shared_secret;
+use deltachat::internals_for_benchmarks::create_broadcast_secret;
 use deltachat::internals_for_benchmarks::create_dummy_keypair;
-use deltachat::internals_for_benchmarks::save_broadcast_shared_secret;
+use deltachat::internals_for_benchmarks::save_broadcast_secret;
 use deltachat::{
     Events,
     chat::ChatId,
@@ -142,7 +142,7 @@ fn criterion_benchmark(c: &mut Criterion) {
     let context = rt.block_on(async {
         let context = create_context().await;
         for (i, secret) in secrets.iter().enumerate() {
-            save_broadcast_shared_secret(&context, ChatId::new(10 + i as u32), secret)
+            save_broadcast_secret(&context, ChatId::new(10 + i as u32), secret)
                 .await
                 .unwrap();
         }
@@ -184,7 +184,7 @@ fn criterion_benchmark(c: &mut Criterion) {
 
 fn generate_secrets() -> Vec<String> {
     let secrets: Vec<String> = (0..NUM_SECRETS)
-        .map(|_| create_broadcast_shared_secret())
+        .map(|_| create_broadcast_secret())
         .collect();
     secrets
 }

src/chat.rs

@@ -43,14 +43,14 @@ use crate::smtp::send_msg_to_smtp;
 use crate::stock_str;
 use crate::sync::{self, Sync::*, SyncData};
 use crate::tools::{
-    IsNoneOrEmpty, SystemTime, buf_compress, create_broadcast_shared_secret, create_id,
+    IsNoneOrEmpty, SystemTime, buf_compress, create_broadcast_secret, create_id,
     create_outgoing_rfc724_mid, create_smeared_timestamp, create_smeared_timestamps, get_abs_path,
     gm2local_offset, smeared_time, time, truncate_msg_text,
 };
 use crate::webxdc::StatusUpdateSerial;
 use crate::{chatlist_events, imap};
 
-pub(crate) const PARAM_BROADCAST_SHARED_SECRET: Param = Param::Arg3;
+pub(crate) const PARAM_BROADCAST_SECRET: Param = Param::Arg3;
 
 /// An chat item, such as a message or a marker.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
@@ -3496,7 +3496,7 @@ pub(crate) async fn create_group_ex(
 /// Returns the created chat's id.
 pub async fn create_broadcast(context: &Context, chat_name: String) -> Result<ChatId> {
     let grpid = create_id();
-    let secret = create_broadcast_shared_secret();
+    let secret = create_broadcast_secret();
     create_out_broadcast_ex(context, Sync, grpid, chat_name, secret).await
 }
 
@@ -3552,7 +3552,7 @@ pub(crate) async fn create_out_broadcast_ex(
     Ok(chat_id)
 }
 
-pub(crate) async fn load_broadcast_shared_secret(
+pub(crate) async fn load_broadcast_secret(
     context: &Context,
     chat_id: ChatId,
 ) -> Result<Option<String>> {
@@ -3565,7 +3565,7 @@ pub(crate) async fn load_broadcast_shared_secret(
         .await
 }
 
-pub(crate) async fn save_broadcast_shared_secret(
+pub(crate) async fn save_broadcast_secret(
     context: &Context,
     chat_id: ChatId,
     secret: &str,
@@ -3789,10 +3789,10 @@ pub(crate) async fn add_contact_to_chat_ex(
         msg.param
             .set_int(Param::ContactAddedRemoved, contact.id.to_u32() as i32);
         if chat.typ == Chattype::OutBroadcast {
-            let secret = load_broadcast_shared_secret(context, chat_id)
+            let secret = load_broadcast_secret(context, chat_id)
                 .await?
                 .context("Failed to find broadcast shared secret")?;
-            msg.param.set(PARAM_BROADCAST_SHARED_SECRET, secret);
+            msg.param.set(PARAM_BROADCAST_SECRET, secret);
         }
         send_msg(context, chat_id, &mut msg).await?;
 

src/chat/chat_tests.rs

@@ -3258,7 +3258,7 @@ async fn test_only_broadcast_owner_can_send_1() -> Result<()> {
     );
 
     assert!(
-        load_broadcast_shared_secret(bob, bob_broadcast_id)
+        load_broadcast_secret(bob, bob_broadcast_id)
             .await?
             .is_none()
     );
@@ -3288,7 +3288,7 @@ async fn test_only_broadcast_owner_can_send_2() -> Result<()> {
     let bob_broadcast_id = tcm.exec_securejoin_qr(bob, alice, &qr).await;
 
     assert!(
-        load_broadcast_shared_secret(bob, bob_broadcast_id)
+        load_broadcast_secret(bob, bob_broadcast_id)
             .await?
             .is_some()
     );
@@ -3413,7 +3413,7 @@ async fn test_encrypt_decrypt_broadcast() -> Result<()> {
         time(),
     )
     .await?;
-    save_broadcast_shared_secret(bob, bob_chat_id, secret).await?;
+    save_broadcast_secret(bob, bob_chat_id, secret).await?;
 
     let sent = alice
         .send_text(alice_chat_id, "Symmetrically encrypted message")

src/internals_for_benchmarks.rs

@@ -25,18 +25,14 @@ pub async fn parse_and_get_text(context: &Context, imf_raw: &[u8]) -> Result<Str
     Ok(mime_parser.parts.into_iter().next().unwrap().msg)
 }
 
-pub async fn save_broadcast_shared_secret(
-    context: &Context,
-    chat_id: ChatId,
-    secret: &str,
-) -> Result<()> {
-    crate::chat::save_broadcast_shared_secret(context, chat_id, secret).await
+pub async fn save_broadcast_secret(context: &Context, chat_id: ChatId, secret: &str) -> Result<()> {
+    crate::chat::save_broadcast_secret(context, chat_id, secret).await
 }
 
 pub fn create_dummy_keypair(addr: &str) -> Result<KeyPair> {
     pgp::create_keypair(EmailAddress::new(addr)?)
 }
 
-pub fn create_broadcast_shared_secret() -> String {
-    crate::tools::create_broadcast_shared_secret()
+pub fn create_broadcast_secret() -> String {
+    crate::tools::create_broadcast_secret()
 }

src/mimefactory.rs

@@ -16,7 +16,7 @@ use tokio::fs;
 
 use crate::aheader::{Aheader, EncryptPreference};
 use crate::blob::BlobObject;
-use crate::chat::{self, Chat, PARAM_BROADCAST_SHARED_SECRET, load_broadcast_shared_secret};
+use crate::chat::{self, Chat, PARAM_BROADCAST_SECRET, load_broadcast_secret};
 use crate::config::Config;
 use crate::constants::ASM_SUBJECT;
 use crate::constants::{Chattype, DC_FROM_HANDSHAKE};
@@ -845,7 +845,7 @@ impl MimeFactory {
                 ));
 
                 if msg.param.get_cmd() == SystemMessage::MemberAddedToGroup {
-                    if let Some(secret) = msg.param.get(PARAM_BROADCAST_SHARED_SECRET) {
+                    if let Some(secret) = msg.param.get(PARAM_BROADCAST_SECRET) {
                         headers.push((
                             "Chat-Broadcast-Secret",
                             mail_builder::headers::text::Text::new(secret.to_string()).into(),
@@ -1216,7 +1216,7 @@ impl MimeFactory {
                 Loaded::Message { chat, msg }
                     if should_encrypt_with_broadcast_secret(msg, chat) =>
                 {
-                    let secret = load_broadcast_shared_secret(context, chat.id).await?;
+                    let secret = load_broadcast_secret(context, chat.id).await?;
                     if secret.is_none() {
                         // If there is no shared secret yet
                         // because this is an old broadcast channel,

src/receive_imf.rs

@@ -14,7 +14,7 @@ use mailparse::SingleInfo;
 use num_traits::FromPrimitive;
 use regex::Regex;
 
-use crate::chat::{self, Chat, ChatId, ChatIdBlocked, save_broadcast_shared_secret};
+use crate::chat::{self, Chat, ChatId, ChatIdBlocked, save_broadcast_secret};
 use crate::config::Config;
 use crate::constants::{self, Blocked, Chattype, DC_CHAT_ID_TRASH, EDITED_PREFIX, ShowEmails};
 use crate::contact::{self, Contact, ContactId, Origin, mark_contact_id_as_verified};
@@ -43,7 +43,7 @@ use crate::simplify;
 use crate::stats::STATISTICS_BOT_EMAIL;
 use crate::stock_str;
 use crate::sync::Sync::*;
-use crate::tools::{self, buf_compress, remove_subject_prefix, validate_broadcast_shared_secret};
+use crate::tools::{self, buf_compress, remove_subject_prefix, validate_broadcast_secret};
 use crate::{chatlist_events, ensure_and_debug_assert, ensure_and_debug_assert_eq, location};
 
 /// This is the struct that is returned after receiving one email (aka MIME message).
@@ -1504,7 +1504,7 @@ async fn do_chat_assignment(
                             compute_mailinglist_name(mailinglist_header, &listid, mime_parser);
                         if let Some(secret) = mime_parser
                             .get_header(HeaderDef::ChatBroadcastSecret)
-                            .filter(|s| validate_broadcast_shared_secret(s))
+                            .filter(|s| validate_broadcast_secret(s))
                         {
                             chat_id = Some(
                                 chat::create_out_broadcast_ex(
@@ -3539,8 +3539,8 @@ async fn apply_in_broadcast_changes(
     }
 
     if let Some(secret) = mime_parser.get_header(HeaderDef::ChatBroadcastSecret) {
-        if validate_broadcast_shared_secret(secret) {
-            save_broadcast_shared_secret(context, chat.id, secret).await?;
+        if validate_broadcast_secret(secret) {
+            save_broadcast_secret(context, chat.id, secret).await?;
         } else {
             warn!(context, "Not saving invalid broadcast secret");
         }

src/tools.rs

@@ -306,7 +306,7 @@ pub(crate) fn create_id() -> String {
 /// and is returned as 43 Base64 characters, each containing 6 bits of entropy.
 /// 258 is chosen because we may switch to AES-256 keys in the future,
 /// and so that the shared secret definitely won't be the weak spot.
-pub(crate) fn create_broadcast_shared_secret() -> String {
+pub(crate) fn create_broadcast_secret() -> String {
     // ThreadRng implements CryptoRng trait and is supposed to be cryptographically secure.
     let mut rng = thread_rng();
 
@@ -327,7 +327,7 @@ pub(crate) fn validate_id(s: &str) -> bool {
     s.chars().all(|c| alphabet.contains(c)) && s.len() > 10 && s.len() <= 32
 }
 
-pub(crate) fn validate_broadcast_shared_secret(s: &str) -> bool {
+pub(crate) fn validate_broadcast_secret(s: &str) -> bool {
     let alphabet = base64::alphabet::URL_SAFE.as_str();
     s.chars().all(|c| alphabet.contains(c)) && s.len() >= 43 && s.len() <= 100
 }