Mirrors/chatmail-core
1
0
Fork 0
mirror of https://github.com/chatmail/core.git synced 2026-05-08 17:36:29 +03:00
Code Issues Packages Projects Releases Wiki Activity

mimeparser: rename MimeMessage.get() into MimeMessage.get_header()

Browse Source
This commit is contained in:
link2xt
2021-08-22 16:28:44 +00:00
parent 90703b0dd2
commit ab1de69fbc
4 changed files with 119 additions and 98 deletions
Download Patch File Download Diff File Expand all files Collapse all files

61
src/dc_receive_imf.rs
View File

@@ -93,7 +93,7 @@ pub(crate) async fn dc_receive_imf_inner(
} }
let mut sent_timestamp = if let Some(value) = mime_parser let mut sent_timestamp = if let Some(value) = mime_parser
.get(HeaderDef::Date) .get_header(HeaderDef::Date)
.and_then(|value| mailparse::dateparse(value).ok()) .and_then(|value| mailparse::dateparse(value).ok())
{ {
value value
@@ -134,7 +134,7 @@ pub(crate) async fn dc_receive_imf_inner(
let mut create_event_to_send = Some(CreateEvent::MsgsChanged); let mut create_event_to_send = Some(CreateEvent::MsgsChanged);
let prevent_rename = let prevent_rename =
mime_parser.is_mailinglist_message() || mime_parser.get(HeaderDef::Sender).is_some(); mime_parser.is_mailinglist_message() || mime_parser.get_header(HeaderDef::Sender).is_some();
// get From: (it can be an address list!) and check if it is known (for known From:'s we add // get From: (it can be an address list!) and check if it is known (for known From:'s we add
// the other To:/Cc: in the 3rd pass) // the other To:/Cc: in the 3rd pass)
@@ -425,7 +425,7 @@ async fn add_parts(
to_id = DC_CONTACT_ID_SELF; to_id = DC_CONTACT_ID_SELF;
// handshake may mark contacts as verified and must be processed before chats are created // handshake may mark contacts as verified and must be processed before chats are created
if mime_parser.get(HeaderDef::SecureJoin).is_some() { if mime_parser.get_header(HeaderDef::SecureJoin).is_some() {
is_dc_message = MessengerMessage::Yes; // avoid discarding by show_emails setting is_dc_message = MessengerMessage::Yes; // avoid discarding by show_emails setting
chat_id = None; chat_id = None;
allow_creation = true; allow_creation = true;
@@ -526,7 +526,7 @@ async fn add_parts(
// check if the message belongs to a mailing list // check if the message belongs to a mailing list
match mime_parser.get_mailinglist_type() { match mime_parser.get_mailinglist_type() {
MailinglistType::ListIdBased => { MailinglistType::ListIdBased => {
if let Some(list_id) = mime_parser.get(HeaderDef::ListId) { if let Some(list_id) = mime_parser.get_header(HeaderDef::ListId) {
if let Some((new_chat_id, new_chat_id_blocked)) = if let Some((new_chat_id, new_chat_id_blocked)) =
create_or_lookup_mailinglist( create_or_lookup_mailinglist(
context, context,
@@ -542,7 +542,7 @@ async fn add_parts(
} }
} }
MailinglistType::SenderBased => { MailinglistType::SenderBased => {
if let Some(sender) = mime_parser.get(HeaderDef::Sender) { if let Some(sender) = mime_parser.get_header(HeaderDef::Sender) {
if let Some((new_chat_id, new_chat_id_blocked)) = if let Some((new_chat_id, new_chat_id_blocked)) =
create_or_lookup_mailinglist( create_or_lookup_mailinglist(
context, context,
@@ -649,7 +649,7 @@ async fn add_parts(
to_id = to_ids.get_index(0).cloned().unwrap_or_default(); to_id = to_ids.get_index(0).cloned().unwrap_or_default();
// handshake may mark contacts as verified and must be processed before chats are created // handshake may mark contacts as verified and must be processed before chats are created
if mime_parser.get(HeaderDef::SecureJoin).is_some() { if mime_parser.get_header(HeaderDef::SecureJoin).is_some() {
is_dc_message = MessengerMessage::Yes; // avoid discarding by show_emails setting is_dc_message = MessengerMessage::Yes; // avoid discarding by show_emails setting
chat_id = None; chat_id = None;
allow_creation = true; allow_creation = true;
@@ -675,8 +675,8 @@ async fn add_parts(
// such as systemli.org in June 2021 remove their own Received headers on incoming mails) // such as systemli.org in June 2021 remove their own Received headers on incoming mails)
// and we know Delta Chat never stores drafts on IMAP servers. // and we know Delta Chat never stores drafts on IMAP servers.
let is_draft = !context.is_sentbox(server_folder).await? let is_draft = !context.is_sentbox(server_folder).await?
&& mime_parser.get(HeaderDef::Received).is_none() && mime_parser.get_header(HeaderDef::Received).is_none()
&& mime_parser.get(HeaderDef::ChatVersion).is_none(); && mime_parser.get_header(HeaderDef::ChatVersion).is_none();
// Mozilla Thunderbird does not set \Draft flag on "Templates", but sets // Mozilla Thunderbird does not set \Draft flag on "Templates", but sets
// X-Mozilla-Draft-Info header, which can be used to detect both drafts and templates // X-Mozilla-Draft-Info header, which can be used to detect both drafts and templates
@@ -684,7 +684,10 @@ async fn add_parts(
// //
// This check is not necessary now, but may become useful if the `Received:` header check // This check is not necessary now, but may become useful if the `Received:` header check
// is removed completely later. // is removed completely later.
let is_draft = is_draft || mime_parser.get(HeaderDef::XMozillaDraftInfo).is_some(); let is_draft = is_draft
|| mime_parser
.get_header(HeaderDef::XMozillaDraftInfo)
.is_some();
if is_draft { if is_draft {
// Most mailboxes have a "Drafts" folder where constantly new emails appear but we don't actually want to show them // Most mailboxes have a "Drafts" folder where constantly new emails appear but we don't actually want to show them
@@ -783,7 +786,8 @@ async fn add_parts(
}); });
// Extract ephemeral timer from the message. // Extract ephemeral timer from the message.
let mut ephemeral_timer = if let Some(value) = mime_parser.get(HeaderDef::EphemeralTimer) { let mut ephemeral_timer = if let Some(value) = mime_parser.get_header(HeaderDef::EphemeralTimer)
{
match value.parse::<EphemeralTimer>() { match value.parse::<EphemeralTimer>() {
Ok(timer) => timer, Ok(timer) => timer,
Err(err) => { Err(err) => {
@@ -913,11 +917,11 @@ async fn add_parts(
let save_mime_headers = context.get_config_bool(Config::SaveMimeHeaders).await?; let save_mime_headers = context.get_config_bool(Config::SaveMimeHeaders).await?;
let mime_in_reply_to = mime_parser let mime_in_reply_to = mime_parser
.get(HeaderDef::InReplyTo) .get_header(HeaderDef::InReplyTo)
.cloned() .cloned()
.unwrap_or_default(); .unwrap_or_default();
let mime_references = mime_parser let mime_references = mime_parser
.get(HeaderDef::References) .get_header(HeaderDef::References)
.cloned() .cloned()
.unwrap_or_default(); .unwrap_or_default();
@@ -1369,10 +1373,13 @@ async fn create_or_lookup_group(
// now we have a grpid that is non-empty // now we have a grpid that is non-empty
// but we might not know about this group // but we might not know about this group
let grpname = mime_parser.get(HeaderDef::ChatGroupName).cloned(); let grpname = mime_parser.get_header(HeaderDef::ChatGroupName).cloned();
let mut removed_id = None; let mut removed_id = None;
if let Some(removed_addr) = mime_parser.get(HeaderDef::ChatGroupMemberRemoved).cloned() { if let Some(removed_addr) = mime_parser
.get_header(HeaderDef::ChatGroupMemberRemoved)
.cloned()
{
removed_id = Contact::lookup_id_by_addr(context, &removed_addr, Origin::Unknown).await?; removed_id = Contact::lookup_id_by_addr(context, &removed_addr, Origin::Unknown).await?;
match removed_id { match removed_id {
Some(contact_id) => { Some(contact_id) => {
@@ -1386,12 +1393,14 @@ async fn create_or_lookup_group(
None => warn!(context, "removed {:?} has no contact_id", removed_addr), None => warn!(context, "removed {:?} has no contact_id", removed_addr),
} }
} else { } else {
let field = mime_parser.get(HeaderDef::ChatGroupMemberAdded).cloned(); let field = mime_parser
.get_header(HeaderDef::ChatGroupMemberAdded)
.cloned();
if let Some(added_member) = field { if let Some(added_member) = field {
mime_parser.is_system_message = SystemMessage::MemberAddedToGroup; mime_parser.is_system_message = SystemMessage::MemberAddedToGroup;
better_msg = stock_str::msg_add_member(context, &added_member, from_id).await; better_msg = stock_str::msg_add_member(context, &added_member, from_id).await;
X_MrAddToGrp = Some(added_member); X_MrAddToGrp = Some(added_member);
} else if let Some(old_name) = mime_parser.get(HeaderDef::ChatGroupNameChanged) { } else if let Some(old_name) = mime_parser.get_header(HeaderDef::ChatGroupNameChanged) {
X_MrGrpNameChanged = true; X_MrGrpNameChanged = true;
better_msg = stock_str::msg_grp_name( better_msg = stock_str::msg_grp_name(
context, context,
@@ -1405,7 +1414,7 @@ async fn create_or_lookup_group(
) )
.await; .await;
mime_parser.is_system_message = SystemMessage::GroupNameChanged; mime_parser.is_system_message = SystemMessage::GroupNameChanged;
} else if let Some(value) = mime_parser.get(HeaderDef::ChatContent) { } else if let Some(value) = mime_parser.get_header(HeaderDef::ChatContent) {
if value == "group-avatar-changed" { if value == "group-avatar-changed" {
if let Some(avatar_action) = &mime_parser.group_avatar { if let Some(avatar_action) = &mime_parser.group_avatar {
// this is just an explicit message containing the group-avatar, // this is just an explicit message containing the group-avatar,
@@ -1445,7 +1454,7 @@ async fn create_or_lookup_group(
|| X_MrAddToGrp.is_some() && addr_cmp(&self_addr, X_MrAddToGrp.as_ref().unwrap())) || X_MrAddToGrp.is_some() && addr_cmp(&self_addr, X_MrAddToGrp.as_ref().unwrap()))
{ {
// group does not exist but should be created // group does not exist but should be created
let create_protected = if mime_parser.get(HeaderDef::ChatVerified).is_some() { let create_protected = if mime_parser.get_header(HeaderDef::ChatVerified).is_some() {
if let Err(err) = check_verified_properties(context, mime_parser, from_id, to_ids).await if let Err(err) = check_verified_properties(context, mime_parser, from_id, to_ids).await
{ {
warn!(context, "verification problem: {}", err); warn!(context, "verification problem: {}", err);
@@ -1704,7 +1713,7 @@ async fn create_or_lookup_mailinglist(
} }
fn try_getting_grpid(mime_parser: &MimeMessage) -> Option<String> { fn try_getting_grpid(mime_parser: &MimeMessage) -> Option<String> {
if let Some(optional_field) = mime_parser.get(HeaderDef::ChatGroupId) { if let Some(optional_field) = mime_parser.get_header(HeaderDef::ChatGroupId) {
return Some(optional_field.clone()); return Some(optional_field.clone());
} }
@@ -1726,7 +1735,7 @@ fn try_getting_grpid(mime_parser: &MimeMessage) -> Option<String> {
/// try extract a grpid from a message-id list header value /// try extract a grpid from a message-id list header value
fn extract_grpid(mime_parser: &MimeMessage, headerdef: HeaderDef) -> Option<&str> { fn extract_grpid(mime_parser: &MimeMessage, headerdef: HeaderDef) -> Option<&str> {
let header = mime_parser.get(headerdef)?; let header = mime_parser.get_header(headerdef)?;
let parts = header let parts = header
.split(',') .split(',')
.map(str::trim) .map(str::trim)
@@ -1891,7 +1900,7 @@ async fn check_verified_properties(
ensure!(mimeparser.was_encrypted(), "This message is not encrypted."); ensure!(mimeparser.was_encrypted(), "This message is not encrypted.");
if mimeparser.get(HeaderDef::ChatVerified).is_none() { if mimeparser.get_header(HeaderDef::ChatVerified).is_none() {
// we do not fail here currently, this would exclude (a) non-deltas // we do not fail here currently, this would exclude (a) non-deltas
// and (b) deltas with different protection views across multiple devices. // and (b) deltas with different protection views across multiple devices.
// for group creation or protection enabled/disabled, however, Chat-Verified is respected. // for group creation or protection enabled/disabled, however, Chat-Verified is respected.
@@ -2037,13 +2046,13 @@ async fn get_parent_message(
context: &Context, context: &Context,
mime_parser: &MimeMessage, mime_parser: &MimeMessage,
) -> Result<Option<Message>> { ) -> Result<Option<Message>> {
if let Some(field) = mime_parser.get(HeaderDef::References) { if let Some(field) = mime_parser.get_header(HeaderDef::References) {
if let Some(msg) = get_rfc724_mid_in_list(context, field).await? { if let Some(msg) = get_rfc724_mid_in_list(context, field).await? {
return Ok(Some(msg)); return Ok(Some(msg));
} }
} }
if let Some(field) = mime_parser.get(HeaderDef::InReplyTo) { if let Some(field) = mime_parser.get_header(HeaderDef::InReplyTo) {
if let Some(msg) = get_rfc724_mid_in_list(context, field).await? { if let Some(msg) = get_rfc724_mid_in_list(context, field).await? {
return Ok(Some(msg)); return Ok(Some(msg));
} }
@@ -2124,13 +2133,13 @@ fn dc_create_incoming_rfc724_mid(mime: &MimeMessage) -> String {
"{}@stub", "{}@stub",
hex_hash(&format!( hex_hash(&format!(
"{}-{}-{}", "{}-{}-{}",
mime.get(HeaderDef::Date) mime.get_header(HeaderDef::Date)
.map(|s| s.to_string()) .map(|s| s.to_string())
.unwrap_or_default(), .unwrap_or_default(),
mime.get(HeaderDef::From_) mime.get_header(HeaderDef::From_)
.map(|s| s.to_string()) .map(|s| s.to_string())
.unwrap_or_default(), .unwrap_or_default(),
mime.get(HeaderDef::To) mime.get_header(HeaderDef::To)
.map(|s| s.to_string()) .map(|s| s.to_string())
.unwrap_or_default() .unwrap_or_default()
)) ))

47
src/mimeparser.rs
View File

@@ -295,7 +295,7 @@ impl MimeMessage {
/// Parses system messages. /// Parses system messages.
fn parse_system_message_headers(&mut self, context: &Context) { fn parse_system_message_headers(&mut self, context: &Context) {
if self.get(HeaderDef::AutocryptSetupMessage).is_some() { if self.get_header(HeaderDef::AutocryptSetupMessage).is_some() {
self.parts = self self.parts = self
.parts .parts
.iter() .iter()
@@ -311,7 +311,7 @@ impl MimeMessage {
} else { } else {
warn!(context, "could not determine ASM mime-part"); warn!(context, "could not determine ASM mime-part");
} }
} else if let Some(value) = self.get(HeaderDef::ChatContent) { } else if let Some(value) = self.get_header(HeaderDef::ChatContent) {
if value == "location-streaming-enabled" { if value == "location-streaming-enabled" {
self.is_system_message = SystemMessage::LocationStreamingEnabled; self.is_system_message = SystemMessage::LocationStreamingEnabled;
} else if value == "ephemeral-timer-changed" { } else if value == "ephemeral-timer-changed" {
@@ -326,19 +326,19 @@ impl MimeMessage {
/// Parses avatar action headers. /// Parses avatar action headers.
async fn parse_avatar_headers(&mut self, context: &Context) { async fn parse_avatar_headers(&mut self, context: &Context) {
if let Some(header_value) = self.get(HeaderDef::ChatGroupAvatar).cloned() { if let Some(header_value) = self.get_header(HeaderDef::ChatGroupAvatar).cloned() {
self.group_avatar = self.avatar_action_from_header(context, header_value).await; self.group_avatar = self.avatar_action_from_header(context, header_value).await;
} }
if let Some(header_value) = self.get(HeaderDef::ChatUserAvatar).cloned() { if let Some(header_value) = self.get_header(HeaderDef::ChatUserAvatar).cloned() {
self.user_avatar = self.avatar_action_from_header(context, header_value).await; self.user_avatar = self.avatar_action_from_header(context, header_value).await;
} }
} }
fn parse_videochat_headers(&mut self) { fn parse_videochat_headers(&mut self) {
if let Some(value) = self.get(HeaderDef::ChatContent).cloned() { if let Some(value) = self.get_header(HeaderDef::ChatContent).cloned() {
if value == "videochat-invitation" { if value == "videochat-invitation" {
let instance = self.get(HeaderDef::ChatWebrtcRoom).cloned(); let instance = self.get_header(HeaderDef::ChatWebrtcRoom).cloned();
if let Some(part) = self.parts.first_mut() { if let Some(part) = self.parts.first_mut() {
part.typ = Viewtype::VideochatInvitation; part.typ = Viewtype::VideochatInvitation;
part.param part.param
@@ -395,11 +395,12 @@ impl MimeMessage {
} }
if let Some(mut part) = self.parts.pop() { if let Some(mut part) = self.parts.pop() {
if part.typ == Viewtype::Audio && self.get(HeaderDef::ChatVoiceMessage).is_some() { if part.typ == Viewtype::Audio && self.get_header(HeaderDef::ChatVoiceMessage).is_some()
{
part.typ = Viewtype::Voice; part.typ = Viewtype::Voice;
} }
if part.typ == Viewtype::Image || part.typ == Viewtype::Gif { if part.typ == Viewtype::Image || part.typ == Viewtype::Gif {
if let Some(value) = self.get(HeaderDef::ChatContent) { if let Some(value) = self.get_header(HeaderDef::ChatContent) {
if value == "sticker" { if value == "sticker" {
part.typ = Viewtype::Sticker; part.typ = Viewtype::Sticker;
} }
@@ -409,7 +410,7 @@ impl MimeMessage {
|| part.typ == Viewtype::Voice || part.typ == Viewtype::Voice
|| part.typ == Viewtype::Video || part.typ == Viewtype::Video
{ {
if let Some(field_0) = self.get(HeaderDef::ChatDuration) { if let Some(field_0) = self.get_header(HeaderDef::ChatDuration) {
let duration_ms = field_0.parse().unwrap_or_default(); let duration_ms = field_0.parse().unwrap_or_default();
if duration_ms > 0 && duration_ms < 24 * 60 * 60 * 1000 { if duration_ms > 0 && duration_ms < 24 * 60 * 60 * 1000 {
part.param.set_int(Param::Duration, duration_ms); part.param.set_int(Param::Duration, duration_ms);
@@ -591,12 +592,12 @@ impl MimeMessage {
} }
pub(crate) fn get_subject(&self) -> Option<String> { pub(crate) fn get_subject(&self) -> Option<String> {
self.get(HeaderDef::Subject) self.get_header(HeaderDef::Subject)
.filter(|s| !s.is_empty()) .filter(|s| !s.is_empty())
.map(|s| s.to_string()) .map(|s| s.to_string())
} }
pub fn get(&self, headerdef: HeaderDef) -> Option<&String> { pub fn get_header(&self, headerdef: HeaderDef) -> Option<&String> {
self.header.get(headerdef.get_headername()) self.header.get(headerdef.get_headername())
} }
@@ -1019,12 +1020,12 @@ impl MimeMessage {
} }
pub(crate) fn get_mailinglist_type(&self) -> MailinglistType { pub(crate) fn get_mailinglist_type(&self) -> MailinglistType {
if self.get(HeaderDef::ListId).is_some() { if self.get_header(HeaderDef::ListId).is_some() {
return MailinglistType::ListIdBased; return MailinglistType::ListIdBased;
} else if self.get(HeaderDef::Sender).is_some() { } else if self.get_header(HeaderDef::Sender).is_some() {
// the `Sender:`-header alone is no indicator for mailing list // the `Sender:`-header alone is no indicator for mailing list
// as also used for bot-impersonation via `set_override_sender_name()` // as also used for bot-impersonation via `set_override_sender_name()`
if let Some(precedence) = self.get(HeaderDef::Precedence) { if let Some(precedence) = self.get_header(HeaderDef::Precedence) {
if precedence == "list" || precedence == "bulk" { if precedence == "list" || precedence == "bulk" {
return MailinglistType::SenderBased; return MailinglistType::SenderBased;
} }
@@ -1050,8 +1051,8 @@ impl MimeMessage {
} }
pub fn get_rfc724_mid(&self) -> Option<String> { pub fn get_rfc724_mid(&self) -> Option<String> {
self.get(HeaderDef::XMicrosoftOriginalMessageId) self.get_header(HeaderDef::XMicrosoftOriginalMessageId)
.or_else(|| self.get(HeaderDef::MessageId)) .or_else(|| self.get_header(HeaderDef::MessageId))
.and_then(|msgid| parse_message_id(msgid).ok()) .and_then(|msgid| parse_message_id(msgid).ok())
} }
@@ -1238,7 +1239,7 @@ impl MimeMessage {
/// Also you should add a test in dc_receive_imf.rs (there already are lots of test_parse_ndn_* tests). /// Also you should add a test in dc_receive_imf.rs (there already are lots of test_parse_ndn_* tests).
#[allow(clippy::indexing_slicing)] #[allow(clippy::indexing_slicing)]
async fn heuristically_parse_ndn(&mut self, context: &Context) { async fn heuristically_parse_ndn(&mut self, context: &Context) {
let maybe_ndn = if let Some(from) = self.get(HeaderDef::From_) { let maybe_ndn = if let Some(from) = self.get_header(HeaderDef::From_) {
let from = from.to_ascii_lowercase(); let from = from.to_ascii_lowercase();
from.contains("mailer-daemon") || from.contains("mail-daemon") from.contains("mailer-daemon") || from.contains("mail-daemon")
} else { } else {
@@ -1313,7 +1314,7 @@ impl MimeMessage {
/// database, returns None. /// database, returns None.
pub async fn get_parent_timestamp(&self, context: &Context) -> Result<Option<i64>> { pub async fn get_parent_timestamp(&self, context: &Context) -> Result<Option<i64>> {
let parent_timestamp = if let Some(field) = self let parent_timestamp = if let Some(field) = self
.get(HeaderDef::InReplyTo) .get_header(HeaderDef::InReplyTo)
.and_then(|msgid| parse_message_id(msgid).ok()) .and_then(|msgid| parse_message_id(msgid).ok())
{ {
context context
@@ -1982,11 +1983,11 @@ mod tests {
.unwrap(); .unwrap();
// non-overwritten headers do not bubble up // non-overwritten headers do not bubble up
let of = mimeparser.get(HeaderDef::SecureJoinGroup).unwrap(); let of = mimeparser.get_header(HeaderDef::SecureJoinGroup).unwrap();
assert_eq!(of, "no"); assert_eq!(of, "no");
// unknown headers do not bubble upwards // unknown headers do not bubble upwards
let of = mimeparser.get(HeaderDef::_TestHeader).unwrap(); let of = mimeparser.get_header(HeaderDef::_TestHeader).unwrap();
assert_eq!(of, "Bar"); assert_eq!(of, "Bar");
// the following fields would bubble up // the following fields would bubble up
@@ -1995,13 +1996,15 @@ mod tests {
// for Chat-Version, also the case-insensivity is tested. // for Chat-Version, also the case-insensivity is tested.
assert_eq!(mimeparser.get_subject(), Some("outer-subject".into())); assert_eq!(mimeparser.get_subject(), Some("outer-subject".into()));
let of = mimeparser.get(HeaderDef::ChatVersion).unwrap(); let of = mimeparser.get_header(HeaderDef::ChatVersion).unwrap();
assert_eq!(of, "0.0"); assert_eq!(of, "0.0");
assert_eq!(mimeparser.parts.len(), 1); assert_eq!(mimeparser.parts.len(), 1);
// make sure, headers that are only allowed in the encrypted part // make sure, headers that are only allowed in the encrypted part
// cannot be set from the outer part // cannot be set from the outer part
assert!(mimeparser.get(HeaderDef::SecureJoinFingerprint).is_none()); assert!(mimeparser
.get_header(HeaderDef::SecureJoinFingerprint)
.is_none());
} }
#[async_std::test] #[async_std::test]

105
src/securejoin.rs
View File

@@ -484,7 +484,7 @@ pub(crate) async fn handle_securejoin_handshake(
return Err(Error::msg("Can not be called with special contact ID")); return Err(Error::msg("Can not be called with special contact ID"));
} }
let step = mime_message let step = mime_message
.get(HeaderDef::SecureJoin) .get_header(HeaderDef::SecureJoin)
.context("Not a Secure-Join message")?; .context("Not a Secure-Join message")?;
info!( info!(
@@ -520,7 +520,7 @@ pub(crate) async fn handle_securejoin_handshake(
// it just ensures, we have Bobs key now. If we do _not_ have the key because eg. MitM has removed it, // it just ensures, we have Bobs key now. If we do _not_ have the key because eg. MitM has removed it,
// send_message() will fail with the error "End-to-end-encryption unavailable unexpectedly.", so, there is no additional check needed here. // send_message() will fail with the error "End-to-end-encryption unavailable unexpectedly.", so, there is no additional check needed here.
// verify that the `Secure-Join-Invitenumber:`-header matches invitenumber written to the QR code // verify that the `Secure-Join-Invitenumber:`-header matches invitenumber written to the QR code
let invitenumber = match mime_message.get(HeaderDef::SecureJoinInvitenumber) { let invitenumber = match mime_message.get_header(HeaderDef::SecureJoinInvitenumber) {
Some(n) => n, Some(n) => n,
None => { None => {
warn!(context, "Secure-join denied (invitenumber missing)"); warn!(context, "Secure-join denied (invitenumber missing)");
@@ -576,19 +576,19 @@ pub(crate) async fn handle_securejoin_handshake(
==========================================================*/ ==========================================================*/
// verify that Secure-Join-Fingerprint:-header matches the fingerprint of Bob // verify that Secure-Join-Fingerprint:-header matches the fingerprint of Bob
let fingerprint: Fingerprint = match mime_message.get(HeaderDef::SecureJoinFingerprint) let fingerprint: Fingerprint =
{ match mime_message.get_header(HeaderDef::SecureJoinFingerprint) {
Some(fp) => fp.parse()?, Some(fp) => fp.parse()?,
None => { None => {
could_not_establish_secure_connection( could_not_establish_secure_connection(
context, context,
contact_chat_id, contact_chat_id,
"Fingerprint not provided.", "Fingerprint not provided.",
) )
.await?; .await?;
return Ok(HandshakeMessage::Ignore); return Ok(HandshakeMessage::Ignore);
} }
}; };
if !encrypted_and_signed(context, mime_message, Some(&fingerprint)) { if !encrypted_and_signed(context, mime_message, Some(&fingerprint)) {
could_not_establish_secure_connection( could_not_establish_secure_connection(
context, context,
@@ -609,7 +609,7 @@ pub(crate) async fn handle_securejoin_handshake(
} }
info!(context, "Fingerprint verified.",); info!(context, "Fingerprint verified.",);
// verify that the `Secure-Join-Auth:`-header matches the secret written to the QR code // verify that the `Secure-Join-Auth:`-header matches the secret written to the QR code
let auth_0 = match mime_message.get(HeaderDef::SecureJoinAuth) { let auth_0 = match mime_message.get_header(HeaderDef::SecureJoinAuth) {
Some(auth) => auth, Some(auth) => auth,
None => { None => {
could_not_establish_secure_connection( could_not_establish_secure_connection(
@@ -644,7 +644,7 @@ pub(crate) async fn handle_securejoin_handshake(
// the vg-member-added message is special: // the vg-member-added message is special:
// this is a normal Chat-Group-Member-Added message // this is a normal Chat-Group-Member-Added message
// with an additional Secure-Join header // with an additional Secure-Join header
let field_grpid = match mime_message.get(HeaderDef::SecureJoinGroup) { let field_grpid = match mime_message.get_header(HeaderDef::SecureJoinGroup) {
Some(s) => s.as_str(), Some(s) => s.as_str(),
None => { None => {
warn!(context, "Missing Secure-Join-Group header"); warn!(context, "Missing Secure-Join-Group header");
@@ -729,7 +729,7 @@ pub(crate) async fn handle_securejoin_handshake(
inviter_progress!(context, contact_id, 800); inviter_progress!(context, contact_id, 800);
inviter_progress!(context, contact_id, 1000); inviter_progress!(context, contact_id, 1000);
let field_grpid = mime_message let field_grpid = mime_message
.get(HeaderDef::SecureJoinGroup) .get_header(HeaderDef::SecureJoinGroup)
.map(|s| s.as_str()) .map(|s| s.as_str())
.unwrap_or_else(|| ""); .unwrap_or_else(|| "");
if let Err(err) = chat::get_chat_id_by_grpid(context, &field_grpid).await { if let Err(err) = chat::get_chat_id_by_grpid(context, &field_grpid).await {
@@ -778,7 +778,7 @@ pub(crate) async fn observe_securejoin_on_other_device(
return Err(Error::msg("Can not be called with special contact ID")); return Err(Error::msg("Can not be called with special contact ID"));
} }
let step = mime_message let step = mime_message
.get(HeaderDef::SecureJoin) .get_header(HeaderDef::SecureJoin)
.context("Not a Secure-Join message")?; .context("Not a Secure-Join message")?;
info!(context, "observing secure-join message \'{}\'", step); info!(context, "observing secure-join message \'{}\'", step);
@@ -815,19 +815,19 @@ pub(crate) async fn observe_securejoin_on_other_device(
.await?; .await?;
return Ok(HandshakeMessage::Ignore); return Ok(HandshakeMessage::Ignore);
} }
let fingerprint: Fingerprint = match mime_message.get(HeaderDef::SecureJoinFingerprint) let fingerprint: Fingerprint =
{ match mime_message.get_header(HeaderDef::SecureJoinFingerprint) {
Some(fp) => fp.parse()?, Some(fp) => fp.parse()?,
None => { None => {
could_not_establish_secure_connection( could_not_establish_secure_connection(
context, context,
contact_chat_id, contact_chat_id,
"Fingerprint not provided, please update Delta Chat on all your devices.", "Fingerprint not provided, please update Delta Chat on all your devices.",
) )
.await?; .await?;
return Ok(HandshakeMessage::Ignore); return Ok(HandshakeMessage::Ignore);
} }
}; };
if mark_peer_as_verified(context, &fingerprint).await.is_err() { if mark_peer_as_verified(context, &fingerprint).await.is_err() {
could_not_establish_secure_connection( could_not_establish_secure_connection(
context, context,
@@ -985,8 +985,8 @@ mod tests {
assert_eq!(sent.recipient(), "alice@example.com".parse().unwrap()); assert_eq!(sent.recipient(), "alice@example.com".parse().unwrap());
let msg = alice.parse_msg(&sent).await; let msg = alice.parse_msg(&sent).await;
assert!(!msg.was_encrypted()); assert!(!msg.was_encrypted());
assert_eq!(msg.get(HeaderDef::SecureJoin).unwrap(), "vc-request"); assert_eq!(msg.get_header(HeaderDef::SecureJoin).unwrap(), "vc-request");
assert!(msg.get(HeaderDef::SecureJoinInvitenumber).is_some()); assert!(msg.get_header(HeaderDef::SecureJoinInvitenumber).is_some());
// Step 3: Alice receives vc-request, sends vc-auth-required // Step 3: Alice receives vc-request, sends vc-auth-required
alice.recv_msg(&sent).await; alice.recv_msg(&sent).await;
@@ -994,7 +994,10 @@ mod tests {
let sent = alice.pop_sent_msg().await; let sent = alice.pop_sent_msg().await;
let msg = bob.parse_msg(&sent).await; let msg = bob.parse_msg(&sent).await;
assert!(msg.was_encrypted()); assert!(msg.was_encrypted());
assert_eq!(msg.get(HeaderDef::SecureJoin).unwrap(), "vc-auth-required"); assert_eq!(
msg.get_header(HeaderDef::SecureJoin).unwrap(),
"vc-auth-required"
);
// Step 4: Bob receives vc-auth-required, sends vc-request-with-auth // Step 4: Bob receives vc-auth-required, sends vc-request-with-auth
bob.recv_msg(&sent).await; bob.recv_msg(&sent).await;
@@ -1029,16 +1032,16 @@ mod tests {
let msg = alice.parse_msg(&sent).await; let msg = alice.parse_msg(&sent).await;
assert!(msg.was_encrypted()); assert!(msg.was_encrypted());
assert_eq!( assert_eq!(
msg.get(HeaderDef::SecureJoin).unwrap(), msg.get_header(HeaderDef::SecureJoin).unwrap(),
"vc-request-with-auth" "vc-request-with-auth"
); );
assert!(msg.get(HeaderDef::SecureJoinAuth).is_some()); assert!(msg.get_header(HeaderDef::SecureJoinAuth).is_some());
let bob_fp = SignedPublicKey::load_self(&bob.ctx) let bob_fp = SignedPublicKey::load_self(&bob.ctx)
.await .await
.unwrap() .unwrap()
.fingerprint(); .fingerprint();
assert_eq!( assert_eq!(
*msg.get(HeaderDef::SecureJoinFingerprint).unwrap(), *msg.get_header(HeaderDef::SecureJoinFingerprint).unwrap(),
bob_fp.hex() bob_fp.hex()
); );
@@ -1087,7 +1090,7 @@ mod tests {
let msg = bob.parse_msg(&sent).await; let msg = bob.parse_msg(&sent).await;
assert!(msg.was_encrypted()); assert!(msg.was_encrypted());
assert_eq!( assert_eq!(
msg.get(HeaderDef::SecureJoin).unwrap(), msg.get_header(HeaderDef::SecureJoin).unwrap(),
"vc-contact-confirm" "vc-contact-confirm"
); );
@@ -1136,7 +1139,7 @@ mod tests {
let msg = alice.parse_msg(&sent).await; let msg = alice.parse_msg(&sent).await;
assert!(msg.was_encrypted()); assert!(msg.was_encrypted());
assert_eq!( assert_eq!(
msg.get(HeaderDef::SecureJoin).unwrap(), msg.get_header(HeaderDef::SecureJoin).unwrap(),
"vc-contact-confirm-received" "vc-contact-confirm-received"
); );
} }
@@ -1221,16 +1224,16 @@ mod tests {
let msg = alice.parse_msg(&sent).await; let msg = alice.parse_msg(&sent).await;
assert!(msg.was_encrypted()); assert!(msg.was_encrypted());
assert_eq!( assert_eq!(
msg.get(HeaderDef::SecureJoin).unwrap(), msg.get_header(HeaderDef::SecureJoin).unwrap(),
"vc-request-with-auth" "vc-request-with-auth"
); );
assert!(msg.get(HeaderDef::SecureJoinAuth).is_some()); assert!(msg.get_header(HeaderDef::SecureJoinAuth).is_some());
let bob_fp = SignedPublicKey::load_self(&bob.ctx) let bob_fp = SignedPublicKey::load_self(&bob.ctx)
.await .await
.unwrap() .unwrap()
.fingerprint(); .fingerprint();
assert_eq!( assert_eq!(
*msg.get(HeaderDef::SecureJoinFingerprint).unwrap(), *msg.get_header(HeaderDef::SecureJoinFingerprint).unwrap(),
bob_fp.hex() bob_fp.hex()
); );
@@ -1262,7 +1265,7 @@ mod tests {
let msg = bob.parse_msg(&sent).await; let msg = bob.parse_msg(&sent).await;
assert!(msg.was_encrypted()); assert!(msg.was_encrypted());
assert_eq!( assert_eq!(
msg.get(HeaderDef::SecureJoin).unwrap(), msg.get_header(HeaderDef::SecureJoin).unwrap(),
"vc-contact-confirm" "vc-contact-confirm"
); );
@@ -1291,7 +1294,7 @@ mod tests {
let msg = alice.parse_msg(&sent).await; let msg = alice.parse_msg(&sent).await;
assert!(msg.was_encrypted()); assert!(msg.was_encrypted());
assert_eq!( assert_eq!(
msg.get(HeaderDef::SecureJoin).unwrap(), msg.get_header(HeaderDef::SecureJoin).unwrap(),
"vc-contact-confirm-received" "vc-contact-confirm-received"
); );
} }
@@ -1334,8 +1337,8 @@ mod tests {
assert_eq!(sent.recipient(), "alice@example.com".parse().unwrap()); assert_eq!(sent.recipient(), "alice@example.com".parse().unwrap());
let msg = alice.parse_msg(&sent).await; let msg = alice.parse_msg(&sent).await;
assert!(!msg.was_encrypted()); assert!(!msg.was_encrypted());
assert_eq!(msg.get(HeaderDef::SecureJoin).unwrap(), "vg-request"); assert_eq!(msg.get_header(HeaderDef::SecureJoin).unwrap(), "vg-request");
assert!(msg.get(HeaderDef::SecureJoinInvitenumber).is_some()); assert!(msg.get_header(HeaderDef::SecureJoinInvitenumber).is_some());
// Step 3: Alice receives vg-request, sends vg-auth-required // Step 3: Alice receives vg-request, sends vg-auth-required
alice.recv_msg(&sent).await; alice.recv_msg(&sent).await;
@@ -1343,7 +1346,10 @@ mod tests {
let sent = alice.pop_sent_msg().await; let sent = alice.pop_sent_msg().await;
let msg = bob.parse_msg(&sent).await; let msg = bob.parse_msg(&sent).await;
assert!(msg.was_encrypted()); assert!(msg.was_encrypted());
assert_eq!(msg.get(HeaderDef::SecureJoin).unwrap(), "vg-auth-required"); assert_eq!(
msg.get_header(HeaderDef::SecureJoin).unwrap(),
"vg-auth-required"
);
// Step 4: Bob receives vg-auth-required, sends vg-request-with-auth // Step 4: Bob receives vg-auth-required, sends vg-request-with-auth
bob.recv_msg(&sent).await; bob.recv_msg(&sent).await;
@@ -1378,16 +1384,16 @@ mod tests {
let msg = alice.parse_msg(&sent).await; let msg = alice.parse_msg(&sent).await;
assert!(msg.was_encrypted()); assert!(msg.was_encrypted());
assert_eq!( assert_eq!(
msg.get(HeaderDef::SecureJoin).unwrap(), msg.get_header(HeaderDef::SecureJoin).unwrap(),
"vg-request-with-auth" "vg-request-with-auth"
); );
assert!(msg.get(HeaderDef::SecureJoinAuth).is_some()); assert!(msg.get_header(HeaderDef::SecureJoinAuth).is_some());
let bob_fp = SignedPublicKey::load_self(&bob.ctx) let bob_fp = SignedPublicKey::load_self(&bob.ctx)
.await .await
.unwrap() .unwrap()
.fingerprint(); .fingerprint();
assert_eq!( assert_eq!(
*msg.get(HeaderDef::SecureJoinFingerprint).unwrap(), *msg.get_header(HeaderDef::SecureJoinFingerprint).unwrap(),
bob_fp.hex() bob_fp.hex()
); );
@@ -1415,7 +1421,10 @@ mod tests {
let sent = alice.pop_sent_msg().await; let sent = alice.pop_sent_msg().await;
let msg = bob.parse_msg(&sent).await; let msg = bob.parse_msg(&sent).await;
assert!(msg.was_encrypted()); assert!(msg.was_encrypted());
assert_eq!(msg.get(HeaderDef::SecureJoin).unwrap(), "vg-member-added"); assert_eq!(
msg.get_header(HeaderDef::SecureJoin).unwrap(),
"vg-member-added"
);
// Bob should not yet have Alice verified // Bob should not yet have Alice verified
let contact_alice_id = let contact_alice_id =
@@ -1442,7 +1451,7 @@ mod tests {
let msg = alice.parse_msg(&sent).await; let msg = alice.parse_msg(&sent).await;
assert!(msg.was_encrypted()); assert!(msg.was_encrypted());
assert_eq!( assert_eq!(
msg.get(HeaderDef::SecureJoin).unwrap(), msg.get_header(HeaderDef::SecureJoin).unwrap(),
"vg-member-added-received" "vg-member-added-received"
); );

4
src/securejoin/bobstate.rs
View File

@@ -236,7 +236,7 @@ impl BobState {
context: &Context, context: &Context,
mime_message: &MimeMessage, mime_message: &MimeMessage,
) -> Result<Option<BobHandshakeStage>> { ) -> Result<Option<BobHandshakeStage>> {
let step = match mime_message.get(HeaderDef::SecureJoin) { let step = match mime_message.get_header(HeaderDef::SecureJoin) {
Some(step) => step, Some(step) => step,
None => { None => {
warn!( warn!(
@@ -362,7 +362,7 @@ impl BobState {
if let QrInvite::Group { .. } = self.invite { if let QrInvite::Group { .. } = self.invite {
let member_added = mime_message let member_added = mime_message
.get(HeaderDef::ChatGroupMemberAdded) .get_header(HeaderDef::ChatGroupMemberAdded)
.map(|s| s.as_str()) .map(|s| s.as_str())
.ok_or_else(|| Error::msg("Missing Chat-Group-Member-Added header"))?; .ok_or_else(|| Error::msg("Missing Chat-Group-Member-Added header"))?;
if !context.is_self_addr(member_added).await? { if !context.is_self_addr(member_added).await? {