diff --git a/FlowCrypt.xcodeproj/project.pbxproj b/FlowCrypt.xcodeproj/project.pbxproj index 55b72cc80..2cd8f0090 100644 --- a/FlowCrypt.xcodeproj/project.pbxproj +++ b/FlowCrypt.xcodeproj/project.pbxproj @@ -170,6 +170,7 @@ 95473C1B297E61DE006C8957 /* SequenceExtension.swift in Sources */ = {isa = PBXBuildFile; fileRef = 95473C1A297E61DE006C8957 /* SequenceExtension.swift */; }; 9547EF212A5F106E00A048FF /* PassPhraseAlertNode.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9547EF202A5F106E00A048FF /* PassPhraseAlertNode.swift */; }; 9547EF242A5FBA2B00A048FF /* MenuSeparatorCellNode.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9547EF232A5FBA2B00A048FF /* MenuSeparatorCellNode.swift */; }; + 9577CEDD2AA7A4A40084AC62 /* PublicKeyDetailNode.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9577CEDC2AA7A4A40084AC62 /* PublicKeyDetailNode.swift */; }; 9582BC5A2A782DA700439728 /* pass_phrase_hint.html in Resources */ = {isa = PBXBuildFile; fileRef = 9582BC592A782DA700439728 /* pass_phrase_hint.html */; }; 958566B72A6126DE001C84D3 /* EncryptedStorage.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9F92EE71236F165E009BE0D7 /* EncryptedStorage.swift */; }; 958566B92A612822001C84D3 /* ASButtonNode.swift in Sources */ = {isa = PBXBuildFile; fileRef = 958566B82A612822001C84D3 /* ASButtonNode.swift */; }; @@ -628,6 +629,7 @@ 95473C1A297E61DE006C8957 /* SequenceExtension.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SequenceExtension.swift; sourceTree = ""; }; 9547EF202A5F106E00A048FF /* PassPhraseAlertNode.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PassPhraseAlertNode.swift; sourceTree = ""; }; 9547EF232A5FBA2B00A048FF /* MenuSeparatorCellNode.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MenuSeparatorCellNode.swift; sourceTree = ""; }; + 9577CEDC2AA7A4A40084AC62 /* PublicKeyDetailNode.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PublicKeyDetailNode.swift; sourceTree = ""; }; 9582BC592A782DA700439728 /* pass_phrase_hint.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = pass_phrase_hint.html; sourceTree = ""; }; 958566B82A612822001C84D3 /* ASButtonNode.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ASButtonNode.swift; sourceTree = ""; }; 95E014CE2A8BF27C00D4B4F5 /* AvatarCheckboxNode.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AvatarCheckboxNode.swift; sourceTree = ""; }; @@ -2233,6 +2235,7 @@ 51B9EE6E27567B520080B2D5 /* MessageRecipientsNode.swift */, 9547EF202A5F106E00A048FF /* PassPhraseAlertNode.swift */, 95E014CE2A8BF27C00D4B4F5 /* AvatarCheckboxNode.swift */, + 9577CEDC2AA7A4A40084AC62 /* PublicKeyDetailNode.swift */, ); path = Nodes; sourceTree = ""; @@ -2881,6 +2884,7 @@ 51B9EE6F27567B520080B2D5 /* MessageRecipientsNode.swift in Sources */, D211CE6E23FC354200D1CE38 /* CellNode.swift in Sources */, D24ABA6023FDB26C002EE9DD /* Helpers.swift in Sources */, + 9577CEDD2AA7A4A40084AC62 /* PublicKeyDetailNode.swift in Sources */, D211CE7323FC35AC00D1CE38 /* TextViewCellNode.swift in Sources */, D2A9CA392426197400E1D898 /* SigninButtonNode.swift in Sources */, D211CE7423FC35AC00D1CE38 /* ButtonCellNode.swift in Sources */, diff --git a/FlowCrypt/Controllers/Threads/ThreadDetailsViewController+TableView.swift b/FlowCrypt/Controllers/Threads/ThreadDetailsViewController+TableView.swift index 9bd794e57..90e591aa4 100644 --- a/FlowCrypt/Controllers/Threads/ThreadDetailsViewController+TableView.swift +++ b/FlowCrypt/Controllers/Threads/ThreadDetailsViewController+TableView.swift @@ -24,16 +24,20 @@ extension ThreadDetailsViewController: ASTableDelegate, ASTableDataSource { case thread, message, divider } - let attachmentsCount = input[section - 1].processedMessage?.attachments.count ?? 0 - return Parts.allCases.count + attachmentsCount + let processedMessage = input[section - 1].processedMessage + let attachmentsCount = processedMessage?.attachments.count ?? 0 + let pubkeysCount = processedMessage?.keyDetails.count ?? 0 + return Parts.allCases.count + attachmentsCount + pubkeysCount } + // swiftlint:disable cyclomatic_complexity function_body_length func tableNode(_ tableNode: ASTableNode, nodeBlockForRowAt indexPath: IndexPath) -> ASCellNodeBlock { return { [weak self] in guard let self else { return ASCellNode() } + let row = indexPath.row guard indexPath.section > 0 else { - if indexPath.row == 0 { + if row == 0 { let subject = self.inboxItem.subject ?? "no subject" return MessageSubjectNode(subject.attributed(.medium(18))) } else { @@ -44,7 +48,7 @@ extension ThreadDetailsViewController: ASTableDelegate, ASTableDataSource { let messageIndex = indexPath.section - 1 let message = self.input[messageIndex] - if !message.rawMessage.isDraft, indexPath.row == 0 { + if !message.rawMessage.isDraft, row == 0 { return ThreadMessageInfoCellNode( input: .init(threadMessage: message, index: messageIndex), onReplyTap: { [weak self] _ in self?.handleReplyTap(at: indexPath) }, @@ -54,7 +58,7 @@ extension ThreadDetailsViewController: ASTableDelegate, ASTableDataSource { } if message.rawMessage.isDraft { - if indexPath.row == 0 { + if row == 0 { return self.draftNode(messageIndex: messageIndex, isExpanded: message.isExpanded) } else { return self.dividerNode(indexPath: indexPath) @@ -64,17 +68,29 @@ extension ThreadDetailsViewController: ASTableDelegate, ASTableDataSource { guard message.isExpanded, let processedMessage = message.processedMessage else { return self.dividerNode(indexPath: indexPath) } - guard indexPath.row > 1 else { + guard row > 1 else { return MessageTextSubjectNode( input: .init( message: processedMessage.attributedMessage, quote: processedMessage.attributedQuote, - index: messageIndex + index: messageIndex, + isEncrypted: processedMessage.type == .encrypted ) ) } - let attachmentIndex = indexPath.row - 2 + let keyCount = processedMessage.keyDetails.count + let keyIndex = row - 2 + if keyIndex < keyCount { + let keyDetails = processedMessage.keyDetails[keyIndex] + let node = PublicKeyDetailNode(input: getPublicKeyDetailInput(for: keyDetails)) + node.onImportKey = { + self.importPublicKey(indexPath: indexPath, keyDetails: keyDetails) + } + return node + } + + let attachmentIndex = row - 2 - keyCount if let attachment = processedMessage.attachments[safe: attachmentIndex] { return AttachmentNode( input: .init( @@ -88,6 +104,8 @@ extension ThreadDetailsViewController: ASTableDelegate, ASTableDataSource { } } + // swiftlint:enable cyclomatic_complexity function_body_length + func tableNode(_ tableNode: ASTableNode, didSelectRowAt indexPath: IndexPath) { switch tableNode.nodeForRow(at: indexPath) { case is ThreadMessageInfoCellNode: @@ -103,6 +121,13 @@ extension ThreadDetailsViewController: ASTableDelegate, ASTableDataSource { } } + private func importPublicKey(indexPath: IndexPath, keyDetails: KeyDetails) { + if let email = keyDetails.pgpUserEmails.first { + try? localContactsProvider.updateKey(for: email, pubKey: .init(keyDetails: keyDetails)) + node.reloadRows(at: [indexPath], with: .automatic) + } + } + private func dividerNode(indexPath: IndexPath) -> ASCellNode { let height = indexPath.section < input.count ? 1 / UIScreen.main.nativeScale : 0 return DividerCellNode( @@ -111,6 +136,21 @@ extension ThreadDetailsViewController: ASTableDelegate, ASTableDataSource { height: height ) } + + func getPublicKeyDetailInput(for keyDetails: KeyDetails) -> PublicKeyDetailNode.Input { + let email = keyDetails.pgpUserEmails.first ?? "N/A" + let localPublicKeys = (try? localContactsProvider.retrievePubKeys(for: email, shouldUpdateLastUsed: false)) ?? [] + let importStatus: PublicKeyDetailNode.PublicKeyImportStatus = { + if localPublicKeys.contains(keyDetails.public) { return .alreadyImported } + return localPublicKeys.isNotEmpty ? .differentKeyImported : .notYetImported + }() + return PublicKeyDetailNode.Input( + email: email, + publicKey: keyDetails.public, + fingerprint: keyDetails.fingerprints.first ?? "N/A", + importStatus: importStatus + ) + } } // MARK: - Drafts diff --git a/FlowCrypt/Controllers/Threads/ThreadDetailsViewController+TapActions.swift b/FlowCrypt/Controllers/Threads/ThreadDetailsViewController+TapActions.swift index e5dd45732..d48e82fd0 100644 --- a/FlowCrypt/Controllers/Threads/ThreadDetailsViewController+TapActions.swift +++ b/FlowCrypt/Controllers/Threads/ThreadDetailsViewController+TapActions.swift @@ -275,7 +275,7 @@ extension ThreadDetailsViewController { let sectionIndex = indexPath.section - 1 let section = input[sectionIndex] - let attachmentIndex = indexPath.row - 2 + let attachmentIndex = indexPath.row - 2 - (section.processedMessage?.keyDetails.count ?? 0) guard let rawAttachment = section.processedMessage?.attachments[attachmentIndex] else { throw MessageHelperError.attachmentNotFound diff --git a/FlowCrypt/Controllers/Threads/ThreadDetailsViewController.swift b/FlowCrypt/Controllers/Threads/ThreadDetailsViewController.swift index 689c43efc..c78a655c8 100644 --- a/FlowCrypt/Controllers/Threads/ThreadDetailsViewController.swift +++ b/FlowCrypt/Controllers/Threads/ThreadDetailsViewController.swift @@ -32,6 +32,7 @@ final class ThreadDetailsViewController: TableNodeViewController { ) let appContext: AppContextWithUser + let localContactsProvider: LocalContactsProviderType let messageOperationsApiClient: MessageOperationsApiClient let threadOperationsApiClient: MessagesThreadOperationsApiClient var inboxItem: InboxItem @@ -58,7 +59,7 @@ final class ThreadDetailsViewController: TableNodeViewController { ) async throws { self.appContext = appContext let clientConfiguration = try await appContext.clientConfigurationProvider.configuration - let localContactsProvider = LocalContactsProvider( + self.localContactsProvider = LocalContactsProvider( encryptedStorage: appContext.encryptedStorage ) let mailProvider = try appContext.getRequiredMailProvider() diff --git a/FlowCrypt/Functionality/Mail Provider/Message Provider/MessageHelper.swift b/FlowCrypt/Functionality/Mail Provider/Message Provider/MessageHelper.swift index 4a71c3749..862bb47fe 100644 --- a/FlowCrypt/Functionality/Mail Provider/Message Provider/MessageHelper.swift +++ b/FlowCrypt/Functionality/Mail Provider/Message Provider/MessageHelper.swift @@ -93,6 +93,17 @@ final class MessageHelper { ) } + func getKeyDetailsFromAttachment(attachments: inout [MessageAttachment], messageId: Identifier) async throws -> [KeyDetails] { + var keyDetailsList: [KeyDetails] = [] + for (index, attachment) in attachments.enumerated() where attachment.treatAs == "publicKey" { + let attachmentData = try await fetchOrDownloadData(for: attachment, messageId: messageId) + let parsedKeys = try await Core.shared.parseKeys(armoredOrBinary: attachmentData) + keyDetailsList += parsedKeys.keyDetails + attachments[index].data = attachmentData + } + return keyDetailsList + } + func process( message: Message, onlyLocalKeys: Bool, @@ -102,8 +113,12 @@ final class MessageHelper { var message = message try await parseAttachmentTypes(message: &message) + let keyDetails: [KeyDetails] = try await getKeyDetailsFromAttachment( + attachments: &message.attachments, + messageId: message.identifier + ) guard message.isPgp else { - return ProcessedMessage(message: message) + return ProcessedMessage(message: message, keyDetails: keyDetails) } return try await decryptAndProcess( @@ -114,6 +129,11 @@ final class MessageHelper { ) } + private func fetchOrDownloadData(for attachment: MessageAttachment, messageId: Identifier) async throws -> Data { + if let data = attachment.data { return data } + return try await download(attachment: attachment, messageId: messageId, progressHandler: nil) + } + private func getKeypairs(email: String, isUsingKeyManager: Bool) async throws -> [Keypair] { let keys = try await keyAndPassPhraseStorage.getKeypairsWithPassPhrases(email: email) @@ -247,18 +267,21 @@ final class MessageHelper { ) } - let attachments: [MessageAttachment] + var attachments: [MessageAttachment] if message.raw != nil || message.attachments.isEmpty { attachments = decrypted.blocks.compactMap(\.attMeta).compactMap(MessageAttachment.init) } else { attachments = message.attachments } + let keyDetails: [KeyDetails] = try await getKeyDetailsFromAttachment(attachments: &attachments, messageId: message.identifier) + return ProcessedMessage( message: message, text: text, type: messageType, attachments: attachments, + keyDetails: keyDetails, signature: signature ) } diff --git a/FlowCrypt/Functionality/Mail Provider/Message Provider/ProcessedMessage.swift b/FlowCrypt/Functionality/Mail Provider/Message Provider/ProcessedMessage.swift index 42b697e2d..1516cc8c4 100644 --- a/FlowCrypt/Functionality/Mail Provider/Message Provider/ProcessedMessage.swift +++ b/FlowCrypt/Functionality/Mail Provider/Message Provider/ProcessedMessage.swift @@ -83,6 +83,7 @@ struct ProcessedMessage { let quote: String? let type: MessageType var attachments: [MessageAttachment] + var keyDetails: [KeyDetails] = [] var signature: MessageSignature? } @@ -92,21 +93,24 @@ extension ProcessedMessage { text: String, type: MessageType, attachments: [MessageAttachment] = [], + keyDetails: [KeyDetails] = [], signature: MessageSignature? = nil ) { self.message = message (self.text, self.quote) = Self.parseQuote(text: text) self.type = type self.attachments = attachments + self.keyDetails = keyDetails self.signature = signature } - init(message: Message) { + init(message: Message, keyDetails: [KeyDetails] = []) { self.message = message (self.text, self.quote) = Self.parseQuote(text: message.body.text) self.type = .plain self.attachments = message.attachments self.signature = .unsigned + self.keyDetails = keyDetails } } diff --git a/FlowCrypt/Functionality/Services/Local Contacts Provider/LocalContactsProvider.swift b/FlowCrypt/Functionality/Services/Local Contacts Provider/LocalContactsProvider.swift index 30af1de30..c3d78462c 100644 --- a/FlowCrypt/Functionality/Services/Local Contacts Provider/LocalContactsProvider.swift +++ b/FlowCrypt/Functionality/Services/Local Contacts Provider/LocalContactsProvider.swift @@ -23,6 +23,7 @@ protocol LocalContactsProviderType: PublicKeyProvider { func searchRecipients(query: String) throws -> [Recipient] func remove(recipient: RecipientWithSortedPubKeys) throws func updateKeys(for recipient: RecipientWithSortedPubKeys) throws + func updateKey(for email: String, pubKey: PubKey) throws func getAllRecipients() async throws -> [RecipientWithSortedPubKeys] } @@ -89,6 +90,19 @@ extension LocalContactsProvider: LocalContactsProviderType { } } + func updateKey(for email: String, pubKey: PubKey) throws { + guard let recipientObject = try find(with: email) else { + try save(RecipientRealmObject(email: email, name: nil, lastUsed: nil, keys: [pubKey])) + return + } + + if let storedPubKey = recipientObject.pubKeys.first(where: { $0.primaryFingerprint == pubKey.fingerprint }) { + try update(storedPubKey: storedPubKey, newPubKey: pubKey) + } else { + try add(pubKey: pubKey, to: recipientObject) + } + } + func searchRecipient(with email: String) async throws -> RecipientWithSortedPubKeys? { guard let recipient = try find(with: email).ifNotNil(Recipient.init) else { return nil } return try await parseRecipient(from: recipient) diff --git a/FlowCrypt/Resources/en.lproj/Localizable.strings b/FlowCrypt/Resources/en.lproj/Localizable.strings index d7985e1fb..fec8d5958 100644 --- a/FlowCrypt/Resources/en.lproj/Localizable.strings +++ b/FlowCrypt/Resources/en.lproj/Localizable.strings @@ -429,3 +429,12 @@ "contacts_created" = "Created:"; "contacts_expires" = "Expires:"; "contacts_user" = "User:"; + +// Public Key Detail Node +"show_public_key" = "Show Public Key"; +"public_key_for" = "Public key for %@"; +"fingerprint_label_value" = "(Fingerprint: %@)"; +"import_public_key" = "Import Public Key"; +"update_public_key" = "Update Public Key"; +"already_imported" = "Already imported"; +"public_key_import_warning" = "Manually importing Public Keys received over email can be dangerous.\nContact the sender to verify that the fingerprint matches."; diff --git a/FlowCryptAppTests/Mocks/LocalContactsProviderMock.swift b/FlowCryptAppTests/Mocks/LocalContactsProviderMock.swift index f085e91b1..f4a1533f6 100644 --- a/FlowCryptAppTests/Mocks/LocalContactsProviderMock.swift +++ b/FlowCryptAppTests/Mocks/LocalContactsProviderMock.swift @@ -26,4 +26,6 @@ final class LocalContactsProviderMock: LocalContactsProviderType { } func removePubKey(with fingerprint: String, for email: String) {} + + func updateKey(for email: String, pubKey: FlowCrypt.PubKey) throws {} } diff --git a/FlowCryptCommon/Extensions/StringExtensions.swift b/FlowCryptCommon/Extensions/StringExtensions.swift index 0e9827331..e7263171b 100644 --- a/FlowCryptCommon/Extensions/StringExtensions.swift +++ b/FlowCryptCommon/Extensions/StringExtensions.swift @@ -42,6 +42,12 @@ public extension String { ) } + func spaced(every n: Int) -> String { + return enumerated().reduce("") { + $0 + ($1.offset % n == 0 && $1.offset != 0 ? " " : "") + String($1.element) + } + } + func slice(from: String, to: String) -> String? { (range(of: from)?.upperBound).flatMap { substringFrom in (range(of: to, range: substringFrom ..< endIndex)?.lowerBound).map { substringTo in diff --git a/FlowCryptUI/Cell Nodes/CellNode.swift b/FlowCryptUI/Cell Nodes/CellNode.swift index ec62c033e..c3dd691ba 100644 --- a/FlowCryptUI/Cell Nodes/CellNode.swift +++ b/FlowCryptUI/Cell Nodes/CellNode.swift @@ -9,6 +9,23 @@ import AsyncDisplayKit open class CellNode: ASCellNode { + var leftBorder: ASDisplayNode? + + func addLeftBorder(width: CGFloat, color: UIColor?) { + let border = ASDisplayNode() + border.backgroundColor = color + border.style.width = ASDimension(unit: .points, value: width) + border.style.height = ASDimension(unit: .fraction, value: 1) + addSubnode(border) + leftBorder = border + } + + override public func layout() { + super.layout() + let leftBorderWidth = leftBorder?.style.width.value ?? 0 + leftBorder?.frame = CGRect(x: 0, y: 0, width: leftBorderWidth, height: self.bounds.height) + } + override public init() { super.init() automaticallyManagesSubnodes = true diff --git a/FlowCryptUI/Cell Nodes/MessageTextSubjectNode.swift b/FlowCryptUI/Cell Nodes/MessageTextSubjectNode.swift index 8e72dd935..30b60e228 100644 --- a/FlowCryptUI/Cell Nodes/MessageTextSubjectNode.swift +++ b/FlowCryptUI/Cell Nodes/MessageTextSubjectNode.swift @@ -13,11 +13,13 @@ public final class MessageTextSubjectNode: CellNode { let message: NSAttributedString? let quote: NSAttributedString? let index: Int + let isEncrypted: Bool - public init(message: NSAttributedString?, quote: NSAttributedString?, index: Int) { + public init(message: NSAttributedString?, quote: NSAttributedString?, index: Int, isEncrypted: Bool) { self.message = message self.quote = quote self.index = index + self.isEncrypted = isEncrypted } } @@ -26,8 +28,6 @@ public final class MessageTextSubjectNode: CellNode { private let messageNode = ASEditableTextNode() private let quoteNode = ASEditableTextNode() - private let insets = UIEdgeInsets.deviceSpecificTextInsets(top: 8, bottom: 8) - private var shouldShowQuote = false private lazy var toggleQuoteButtonNode: ASButtonNode = { @@ -55,6 +55,7 @@ public final class MessageTextSubjectNode: CellNode { if let quote = input.quote { setupTextNode(quoteNode, text: quote, accessibilityIdentifier: "aid-message-\(input.index)-quote") } + addLeftBorder(width: .threadLeftBorderWidth, color: input.isEncrypted ? .main : UIColor(hex: "777777")) } private func setupTextNode(_ node: ASEditableTextNode, text: NSAttributedString?, accessibilityIdentifier: String) { @@ -95,7 +96,7 @@ public final class MessageTextSubjectNode: CellNode { } return ASInsetLayoutSpec( - insets: insets, + insets: .threadMessageInsets, child: specChild ) } diff --git a/FlowCryptUI/Cell Nodes/SwitchCellNode.swift b/FlowCryptUI/Cell Nodes/SwitchCellNode.swift index 91ae04191..fbdaae767 100644 --- a/FlowCryptUI/Cell Nodes/SwitchCellNode.swift +++ b/FlowCryptUI/Cell Nodes/SwitchCellNode.swift @@ -12,20 +12,26 @@ import AsyncDisplayKit public final class SwitchCellNode: CellNode { public struct Input { let attributedText: NSAttributedString + let accessibilityIdentifier: String? let insets: UIEdgeInsets let backgroundColor: UIColor? let isOn: Bool + let switchJustifyContent: ASStackLayoutJustifyContent public init( isOn: Bool, attributedText: NSAttributedString, + accessibilityIdentifier: String? = nil, insets: UIEdgeInsets = UIEdgeInsets(top: 8, left: 16, bottom: 8, right: 16), - backgroundColor: UIColor? = nil + backgroundColor: UIColor? = nil, + switchJustifyContent: ASStackLayoutJustifyContent = .start ) { self.attributedText = attributedText + self.accessibilityIdentifier = accessibilityIdentifier self.insets = insets self.backgroundColor = backgroundColor self.isOn = isOn + self.switchJustifyContent = switchJustifyContent } } @@ -33,6 +39,7 @@ public final class SwitchCellNode: CellNode { private lazy var switchNode = ASDisplayNode { () -> UIView in let view = UISwitch() view.isOn = self.input?.isOn ?? false + view.accessibilityIdentifier = self.input?.accessibilityIdentifier view.addTarget(self, action: #selector(self.handleAction(_:)), for: .valueChanged) return view } @@ -65,7 +72,7 @@ public final class SwitchCellNode: CellNode { return ASStackLayoutSpec( direction: .horizontal, spacing: 8, - justifyContent: .start, + justifyContent: input?.switchJustifyContent ?? .start, alignItems: .center, children: [ ASInsetLayoutSpec( diff --git a/FlowCryptUI/Nodes/PublicKeyDetailNode.swift b/FlowCryptUI/Nodes/PublicKeyDetailNode.swift new file mode 100644 index 000000000..468cb6992 --- /dev/null +++ b/FlowCryptUI/Nodes/PublicKeyDetailNode.swift @@ -0,0 +1,162 @@ +// +// PublicKeyDetailNode.swift +// FlowCryptUI +// +// Created by Ioan Moldovan on 9/5/23 +// Copyright © 2017-present FlowCrypt a. s. All rights reserved. +// + +import AsyncDisplayKit +import UIKit + +public final class PublicKeyDetailNode: CellNode { + + public enum PublicKeyImportStatus { + case alreadyImported + case differentKeyImported + case notYetImported + } + + public struct Input { + let email: String + let publicKey: String + let fingerprint: String + let importStatus: PublicKeyImportStatus + + public init( + email: String, + publicKey: String, + fingerprint: String, + importStatus: PublicKeyImportStatus + ) { + self.email = email + self.publicKey = publicKey + self.fingerprint = fingerprint + self.importStatus = importStatus + } + } + + enum Constants { + static let fontStyle: NSAttributedString.Style = .regular(15) + } + + private lazy var publicKeyLabelNode: ASTextNode = { + let node = ASTextNode() + node.attributedText = "public_key_for" + .localizeWithArguments(input.email) + .attributed(Constants.fontStyle) + node.accessibilityIdentifier = "aid-public-key-label" + return node + }() + + private lazy var fingerprintNode: ASTextNode = { + let node = ASTextNode() + node.attributedText = "fingerprint_label_value" + .localizeWithArguments(input.fingerprint.spaced(every: 4)) + .attributed(Constants.fontStyle) + node.accessibilityIdentifier = "aid-fingerprint-value" + return node + }() + + private lazy var warningLabel: ASTextNode = { + let node = ASTextNode() + node.attributedText = "public_key_import_warning" + .localized + .attributed(Constants.fontStyle, color: .warningColor) + node.accessibilityIdentifier = "aid-warning-label" + return node + }() + + private lazy var toggleNode: SwitchCellNode = { + let input = SwitchCellNode.Input( + isOn: false, + attributedText: "show_public_key" + .localized + .attributed(Constants.fontStyle, color: .textColor), + accessibilityIdentifier: "aid-toggle-public-key-node", + backgroundColor: .clear, + switchJustifyContent: .center + ) + let node = SwitchCellNode(input: input) { isOn in + self.shouldDisplayPublicKey = isOn + } + return node + }() + + private lazy var publicKeyValueNode: ASTextNode = { + let node = ASTextNode() + node.attributedText = input.publicKey.attributed(Constants.fontStyle, color: .main) + node.accessibilityIdentifier = "aid-public-key-value" + return node + }() + + private lazy var importKeyButtonNode: ASButtonNode = { + let node = ASButtonNode() + var title: String + var isEnabled = true + var bgColor: UIColor = .warningColor + + switch input.importStatus { + case .alreadyImported: + title = "already_imported" + isEnabled = false + bgColor = .gray + case .differentKeyImported: + title = "update_public_key" + case .notYetImported: + title = "import_public_key" + } + + node.setTitle(title.localized, with: .boldSystemFont(ofSize: 16), with: .white, for: .normal) + node.accessibilityIdentifier = "aid-import-key-button" + node.addTarget(self, action: #selector(importKeyButtonTapped), forControlEvents: .touchUpInside) + + node.isEnabled = isEnabled + node.backgroundColor = bgColor + node.style.flexGrow = 1.0 + node.style.flexShrink = 1.0 + node.style.preferredSize.height = 40 + + return node + }() + + var shouldDisplayPublicKey = false { + didSet { + setNeedsLayout() + } + } + + public var onImportKey: (() -> Void)? + + let input: Input + + public init(input: Input) { + self.input = input + super.init() + backgroundColor = UIColor.colorFor(darkStyle: UIColor(hex: "303030")!, lightStyle: UIColor(hex: "FAFAFA")!) + addLeftBorder(width: .threadLeftBorderWidth, color: UIColor(hex: "989898")) + } + + @objc func importKeyButtonTapped() { + onImportKey?() + } + + override public func layoutSpecThatFits(_: ASSizeRange) -> ASLayoutSpec { + let verticalStack = ASStackLayoutSpec.vertical() + verticalStack.spacing = 10 + + verticalStack.children = [ + publicKeyLabelNode, + fingerprintNode, + input.importStatus != .alreadyImported ? warningLabel : nil, + toggleNode, + shouldDisplayPublicKey ? publicKeyValueNode : nil, + importKeyButtonNode + ].compactMap { $0 } + + return ASInsetLayoutSpec( + insets: .threadMessageInsets, + child: verticalStack + ) + } +} diff --git a/FlowCryptUI/UIConstants.swift b/FlowCryptUI/UIConstants.swift index ee37a3b46..97cf0196b 100644 --- a/FlowCryptUI/UIConstants.swift +++ b/FlowCryptUI/UIConstants.swift @@ -22,6 +22,8 @@ public extension UIEdgeInsets { let top: CGFloat = UIDevice.isIpad ? 16 : 8 return UIEdgeInsets.deviceSpecificInsets(top: top, bottom: top) } + + static var threadMessageInsets = UIEdgeInsets(top: 15, left: .Insets.textSide + .threadLeftBorderWidth, bottom: 15, right: .Insets.textSide) } public extension CGFloat { @@ -44,4 +46,6 @@ public extension CGFloat { static var width: CGFloat = 44 static var height: CGFloat = 44 } + + static var threadLeftBorderWidth: CGFloat = 4 } diff --git a/appium/api-mocks/apis/google/exported-messages/message-export-18a8888351cc96c3.json b/appium/api-mocks/apis/google/exported-messages/message-export-18a8888351cc96c3.json new file mode 100644 index 000000000..a367ff30b --- /dev/null +++ b/appium/api-mocks/apis/google/exported-messages/message-export-18a8888351cc96c3.json @@ -0,0 +1,126 @@ +{ + "acctEmail": "e2e.enterprise.test@flowcrypt.com", + "full": { + "id": "18a8888351cc96c3", + "threadId": "18a8888351cc96c3", + "labelIds": [ + "IMPORTANT", + "CATEGORY_PERSONAL", + "INBOX" + ], + "snippet": "-----BEGIN PGP MESSAGE----- Version: FlowCrypt Email Encryption 8.5.0 Comment: Seamlessly send and receive encrypted email wV4DT2ZlSmhZ1GoSAQdAgFF8gX6a7a7gna8+jZxMReo+E2fFhWysM+k97XkA", + "payload": { + "partId": "", + "mimeType": "multipart/mixed", + "filename": "", + "headers": [ + { + "name": "X-Gm-Message-State", + "value": "AOJu0YyiuZFQZiXGAbc/IznlGtk0Z/dkalgdM4h/KJQfpjsYtuuD1g/X JGeooMZLkYjeXTsg1m8m5yfrHvTv66aAzLmSYTmvh/xix4g=" + }, + { + "name": "Openpgp", + "value": "id=E8F0517BA6D7DAB6081C96E4ADAC279C95093207" + }, + { + "name": "From", + "value": "sender@domain.com" + }, + { + "name": "MIME-Version", + "value": "1.0" + }, + { + "name": "Date", + "value": "Tue, 12 Sep 2023 01:35:40 -0700" + }, + { + "name": "Subject", + "value": "Encrypted email with public key attached" + }, + { + "name": "To", + "value": "flowcrypt.compatibility@gmail.com" + }, + { + "name": "Content-Type", + "value": "multipart/mixed; boundary=\"0000000000000524f106052554b2\"" + } + ], + "body": { + "size": 0 + }, + "parts": [ + { + "partId": "0", + "mimeType": "text/plain", + "filename": "", + "headers": [ + { + "name": "Content-Type", + "value": "text/plain; charset=\"UTF-8\"" + } + ], + "body": { + "size": 2696, + "data": "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" + } + }, + { + "partId": "1", + "mimeType": "application/pgp-keys", + "filename": "0xADAC279C95093207.asc", + "headers": [ + { + "name": "Content-Type", + "value": "application/pgp-keys; name=\"0xADAC279C95093207.asc\"" + }, + { + "name": "Content-Disposition", + "value": "attachment; filename=\"0xADAC279C95093207.asc\"" + }, + { + "name": "Content-Transfer-Encoding", + "value": "base64" + }, + { + "name": "Content-ID", + "value": "" + }, + { + "name": "X-Attachment-Id", + "value": "f_zdPmOReKOJGezzQdUVxGPXKFGWsrXL@flowcrypt" + } + ], + "body": { + "attachmentId": "ANGjdJ--zY6aZDSN86KsI4hzfoiRTK3fTOwV59LkyDVD7w_zDH8NtMWpvsfvrWVCIJe3K2Lu5iiFIZCc1HpVstvDtMvxrg3RtRTKBNlt2gaiwm2BVLrSmmry2uX4PVwunlxBvL5xDE8k8jvqi4IBdV2H0ays0giQX0V76040AFLTmCtWlbSd-dINGrDGIQv2s2h7p4EXQHg0PGKwRrplaVKVtQJD1UetU3iNBQscbyFb3CEC8trvl1ONiXku7B3VfjHlnbjPAwVZ2jgBpDdXqvI9BvBqSjskWEz6Nve2_3C9gUEIZbpvmHEVCW5MhVDTQBbOZT-c0QmLasMpNKsLoTCAt6JR5P3sTFClubolzHTXfkDz3i0e-jMleS6QzMqqP_mnbteXl7WlB68ZOTFi", + "size": 3256 + } + } + ] + }, + "sizeEstimate": 12816, + "historyId": "273528", + "internalDate": "1694507740000" + }, + "attachments": { + "ANGjdJ--zY6aZDSN86KsI4hzfoiRTK3fTOwV59LkyDVD7w_zDH8NtMWpvsfvrWVCIJe3K2Lu5iiFIZCc1HpVstvDtMvxrg3RtRTKBNlt2gaiwm2BVLrSmmry2uX4PVwunlxBvL5xDE8k8jvqi4IBdV2H0ays0giQX0V76040AFLTmCtWlbSd-dINGrDGIQv2s2h7p4EXQHg0PGKwRrplaVKVtQJD1UetU3iNBQscbyFb3CEC8trvl1ONiXku7B3VfjHlnbjPAwVZ2jgBpDdXqvI9BvBqSjskWEz6Nve2_3C9gUEIZbpvmHEVCW5MhVDTQBbOZT-c0QmLasMpNKsLoTCAt6JR5P3sTFClubolzHTXfkDz3i0e-jMleS6QzMqqP_mnbteXl7WlB68ZOTFi": { + "data": "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", + "size": 3256 + } + }, + "raw": { + "id": "18a8888351cc96c3", + "threadId": "18a8888351cc96c3", + "labelIds": [ + "IMPORTANT", + "CATEGORY_PERSONAL", + "INBOX" + ], + "snippet": "-----BEGIN PGP MESSAGE----- Version: FlowCrypt Email Encryption 8.5.0 Comment: Seamlessly send and receive encrypted email wV4DT2ZlSmhZ1GoSAQdAgFF8gX6a7a7gna8+jZxMReo+E2fFhWysM+k97XkA", + "sizeEstimate": 12816, + "raw": "Delivered-To: e2e.enterprise.test@flowcrypt.com
Received: by 2002:a05:6359:ba3:b0:139:7972:fc24 with SMTP id gf35csp2439426rwb;
        Tue, 12 Sep 2023 01:35:43 -0700 (PDT)
X-Received: by 2002:a17:90a:13ca:b0:268:2500:b17e with SMTP id s10-20020a17090a13ca00b002682500b17emr9828091pjf.23.1694507742664;
        Tue, 12 Sep 2023 01:35:42 -0700 (PDT)
ARC-Seal: i=1; a=rsa-sha256; t=1694507742; cv=none;
        d=google.com; s=arc-20160816;
        b=LeXIQw9oxW94R4SKC+xkpPHS7jVBumimZw9PpUDFch8jhSxpZLftNIGeK6czMfSlvQ
         CmWS+Lt14K+o62ORqYFVAFaxzOgtnk4CMg3NAz5HfmzZH/zmzPFuVaoD0J169VachoW8
         qBIm2nZ92sBp9iY1G1yE8Dk859RJ5gHgDvEJUkr0m29Taqm8dh0tUBkmhYV91sFzOUN2
         d1+OWMeP5Y6CIL1b+ufUm+pDLv1sce28kFNmHDu24HmVGOvw6R+oA54Eohhslt23kERU
         HmfKLAtxFo937ESLzODm2KdaHiTfJB8xUjEBRgAw85QEHT8GCCz2IuU6n44oMs831FU5
         LaXA==
ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816;
        h=to:subject:message-id:date:mime-version:from:openpgp:dkim-signature;
        bh=hio78DjUIdPdqN0q0G+WNGvSInTxLbZUACdCugWCw0Q=;
        fh=t5nl6y2O6IgT0e/ZuzCiLyQqjUIoNfNuArPk5eRLqlg=;
        b=AdBER41eXiECxb+eDkj0wWmplgNHd5IhY9eFofNCJH4bIbSwvVCn63g8ceObi0ebDl
         BJ8TwxSJgmIRRBbEufRuRQYOrFfXNetL+txaMr7nKLeQc7hnKFDLX+Uz/wKeYg9UBAAG
         arbOUP78XvBjbQl2iTYa1+5AMO5GHZYf+w5wqzqJoWMg6uhlNk24U6EA14XcIbLh2PHz
         TnJowIBBobUxyag3tbPLYwu9PYncG3D8fO18Tttxoc1bzegsHGJzkae1k/ZKYPMPx2w2
         d7iYkpOI0GldBkvL1A9oH0ENaiFG7KNKIBQ6mNDKImsB6WOSoAI0kN1M/KLxwYhWVVUI
         Ykig==
ARC-Authentication-Results: i=1; mx.google.com;
       dkim=pass header.i=@gmail.com header.s=20221208 header.b=eBDBjld+;
       spf=pass (google.com: domain of flowcrypt.compatibility@gmail.com designates 209.85.220.41 as permitted sender) smtp.mailfrom=flowcrypt.compatibility@gmail.com;
       dmarc=pass (p=NONE sp=QUARANTINE dis=NONE) header.from=gmail.com
Return-Path: <flowcrypt.compatibility@gmail.com>
Received: from mail-sor-f41.google.com (mail-sor-f41.google.com. [209.85.220.41])
        by mx.google.com with SMTPS id f12-20020a17090a664c00b00271c3bdb794sor1837136pjm.0.2023.09.12.01.35.42
        for <e2e.enterprise.test@flowcrypt.com>
        (Google Transport Security);
        Tue, 12 Sep 2023 01:35:42 -0700 (PDT)
Received-SPF: pass (google.com: domain of flowcrypt.compatibility@gmail.com designates 209.85.220.41 as permitted sender) client-ip=209.85.220.41;
Authentication-Results: mx.google.com;
       dkim=pass header.i=@gmail.com header.s=20221208 header.b=eBDBjld+;
       spf=pass (google.com: domain of flowcrypt.compatibility@gmail.com designates 209.85.220.41 as permitted sender) smtp.mailfrom=flowcrypt.compatibility@gmail.com;
       dmarc=pass (p=NONE sp=QUARANTINE dis=NONE) header.from=gmail.com
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed;
        d=gmail.com; s=20221208; t=1694507742; x=1695112542; darn=flowcrypt.com;
        h=to:subject:message-id:date:mime-version:from:openpgp:from:to:cc
         :subject:date:message-id:reply-to;
        bh=hio78DjUIdPdqN0q0G+WNGvSInTxLbZUACdCugWCw0Q=;
        b=eBDBjld+hDk8QUtV+Nc4QZwRHH26yZ7IUjbCptf8vpbPxdEaEHXK9QYZcxcw2oUmlk
         unXhr3u290Nh2Qtj20MF7pfuxVeje6Ug2znZxnm25vciowH+BSqxI8mo5er1eIB8LewY
         gVTkL+UQZfos68+fqrOaNOloXEE+Kgnq2/FGmoGWA7ADLRQgjR8axkNmjKuSdV/GobbI
         uT0hItyGQSG/EkPJMGtYEVXgCryDXZ+qxBVJv1zAOrJPhgnF9RK372/eyaamVzJDtbPm
         MLOU/H4sj0tBRULkLyi9mpmJjTj5odOGjGYBFpDeS7wC+qJXKwTa1i65qTvc+EMU2YxB
         GvJA==
X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed;
        d=1e100.net; s=20230601; t=1694507742; x=1695112542;
        h=to:subject:message-id:date:mime-version:from:openpgp
         :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to;
        bh=hio78DjUIdPdqN0q0G+WNGvSInTxLbZUACdCugWCw0Q=;
        b=Sc0fcjtSTc8GAOYhu/mTSUbf4eBVcEGJ6QosyWQvs3qKvg1tdvvAdDC6yOUlrRY9uA
         qUPpVzPEbhN8mj/Pd5rTbdDMz9SaQkUaWzNa2WGFHWBH2Fm/72UFDMf8OmXKshq5CBsU
         DKnc+Zi+s+1z5QlA5kJHuhJ7bGXIGbeXJj0Q2STSHEJ58RRyzqQ1eBJDwRz33ohmfBuo
         Ffdxb5jox3ygp8qxRfvUztRz9lsLnSYw7M0dnS5VIbo9llRmTlta5auvlN3kITdYwwAn
         WIl/udB4xq0lrqjVGD/nox8E0P0JObIAOoWYamiwmhU2h8cRrCe12IIhLnKCKePnY0Mc
         d07Q==
X-Gm-Message-State: AOJu0YyiuZFQZiXGAbc/IznlGtk0Z/dkalgdM4h/KJQfpjsYtuuD1g/X
	JGeooMZLkYjeXTsg1m8m5yfrHvTv66aAzLmSYTmvh/xix4g=
X-Google-Smtp-Source: AGHT+IGeoBDiqsTiGaKxzZrd/s3tWMLF8HYqs5gczgMec/8otqfO3gayWp+Y8M4Q1WjsZLXIokVYC2kBsgC24jCyMQQ=
X-Received: by 2002:a17:90a:1002:b0:26d:4ade:fcf0 with SMTP id
 b2-20020a17090a100200b0026d4adefcf0mr10653362pja.4.1694507741807; Tue, 12 Sep
 2023 01:35:41 -0700 (PDT)
Received: from 717284730244 named unknown by gmailapi.google.com with
 HTTPREST; Tue, 12 Sep 2023 01:35:40 -0700
Openpgp: id=E8F0517BA6D7DAB6081C96E4ADAC279C95093207
From: FlowCrypt Compatibility <flowcrypt.compatibility@gmail.com>
MIME-Version: 1.0
Date: Tue, 12 Sep 2023 01:35:40 -0700
Message-ID: <CAKbuLTpjz2O+GjOGirUuxDXRQfd-TgfQHOvwyXfubLPYrR0B+w@mail.gmail.com>
Subject: Encrypted email with public key attached
To: e2e.enterprise.test@flowcrypt.com
Content-Type: multipart/mixed; boundary="0000000000000524f106052554b2"

--0000000000000524f106052554b2
Content-Type: text/plain; charset="UTF-8"

-----BEGIN PGP MESSAGE-----
Version: FlowCrypt Email Encryption 8.5.0
Comment: Seamlessly send and receive encrypted email

wV4DT2ZlSmhZ1GoSAQdAgFF8gX6a7a7gna8+jZxMReo+E2fFhWysM+k97XkA
91owMeVuAzStckPiyOqNuUBH4+tmVwnwJPppc9g7+aSsJA8EB1QxtnCiX6nL
n7vYF2b7wcFMA0taL/zmLZUBAQ/+Jmz+omOHGhz9xo3xryW9kyXQeSqhr0eF
W+ysqTemx5VAi9b+jpwfY7ww5NIcHA+gNi2ZTu4adYQbY/whSxaPFy7zKmB4
tm1hudPl0PYGheB9I+nzuBY8M8AcVJPDBhrT5Goq8EJbv4T1em6fIkpM0ucd
qt0YQvFmk+5rAoIThDi8gqppyBXRuc+/QebiisdUQVb5Fh6ZD5JuwyXLdOFr
jlNdrqyFwWRKzTNgGKH/Fq/pciu1lFfNxKik9Ppqq8A6Xyqu7BgulCOEvbEb
ew2tTGW9eL91rODmmE7uHlsKYbydLnyeVjg1lvj+xF0UQRc33V2cK5AK0/mc
q1fDaTLwUE2XERk1gtbYK1MuMTE8zgX1obyOZF4aLcd0cToYtC5g/pMjb9fv
ZQMqkIDmxSFjOkg+tznRoivZJJU7l4fdozge1WUg2wyQSCcMPBai0ub++Yg/
OWH+S6M+cbFT3b6a0NNTJFYFfInwn3ZnQJQKfcyGFJ35ckv+aXuWOnSK+E1V
3QbPR5NFLF2NwsRF07M5z735lGUn50BXmhRZUnVDdTFu4cV+u/4ddClMHJzP
4FrO1Xw/NAQ0zMu0BIUTf0hamP3X6RPFvrUZ5mTbGr/BQr1PvumSLHQrzmWf
CmJuMECxTL+TX79X34xHFL5aFnq0dw/MzWuisFzizpChqJdvCJTBwUwDvb12
YPaZjcQBD/9WZFfcNyz2W2jpfQ0fHvj55Ro7IwTtUcjxoT4tSdXuubE4Busi
YvMIwA0poLiahVlY5HuQCFqb3yqkCbe/2N2uDtfvG2SswyYrDjkVmQCYQHs+
0dkHH8epxY3YMStgotaoXsxEzf+EPLE3iM04UDPywYCJgxnzuQJc8SXOI7z4
1jEGzOhoqGoVvV+TDblhU4jTvVSaNHtsVpwqiV7zsp9X2ZdWG9bqKncoJST/
soLwaTPxtwpkVUC0b7Q0Jvov59qauLfUoi7EFD0Y8WqLABPrbLgr2WLqoqZM
aPxRzAy5kNQjn4oh523JbVjCV7Ua8Z/k0MFLYxvm2R46YWgzO1Eq40jfoT8p
/hdyIZ770fiMiuEmzheQkFpiBsebhcWwLROI/DDPS5Pcx5a5y3/3HUDwMcIU
jfVKONyf1cIWrBG4ZA3eqP+0bx3xO0KTTahB6yi597b1WH2amtxCkxykcTPP
xHfxsOMH33U17umQasUrHOP0OwI5UC4899kXjXfZvPdYXb9WsP1KRjIbJ/gc
kKmP8xhW7BiC2S6dH6w8YZWOLXTPPB/8ddk7GOsstZwp1wwMUrE4WrX0vIAx
qQBisYjUCdgG9wrV0EoEHmhdLIg7B3T+9W9jOxMqm+bwJ7BLAr3z+w1ZTqvP
aDPCSfhCR/tngVZ7241zD8Gi106CUyvza9LB7gEPzhMF+0XvoOyO0W62OTUn
r/cn4i2I/I2frT8pjkOQO8HLll37A7VnvTtzmHd7eAZJubEjrbY98C6gAE7X
NO1DkI6wbrXKrQM2DAAubb7epzv+Cz3Oqt7uximj6WTCnKSoF2SoNpkE4cBT
JmRSR6M+Vy67s5G2d/+inLaKfk7taI4YkPJM82B8u0lLQUSoT5AUm60OHsNW
ESafBgj0hvam11YRNEmiiAW/ipD08J6K40gEADa+kIQqbzADiKPzcVZPI3km
Tsi02j34Jr1KSfRT61xvkh4DT2mgaOJVOIXilIC4T5UceNDBQq8zga31VYB6
kE2uDbWbUQQcCG5nzxle3VW6mN/wGEQ/szzMctbDLVKusQ5F/rFMLWtWPQI0
6JAn3nGp7t96SmDp1XKUB2pIsh7w8MzC/A1g6K4WecmT/+TtO53eo5gGndbl
VmUXTuyyYc4fIK3Ln72nN46h3n14lPK/oph5CLSaLqsfCucwwOrZs6oBmtxu
Q4pEGyLvQDAglY19eoNYfFffvPfGWT297k7ty5aHydu17qmjiwOIMRhZJpMs
3lbRgI7tIfOhJybfFA16l2RHOdC1DOd4OGRuhie4m3M2F6oz2CNHhrdSdBFD
3uiOqVxPVvQRq/dfAJA9pLDyC8gBX5t23tjmIxcIqRuZr7osyBcnGi47E/1j
fahd4aeGYD4+QiUd6wVqO9tXwVpqJmCnqWB9W3ST0CsCRC7ow2wb4XixFkve
SoxCW6jy7hp5qstSVG70162ANaVruSiPTbrwoKRZHELqaxZ+tTZzqpcjbUd9
mLN8pA4/syzFZlHU3U3BTNgDJuHk1ieBN3XTp8HoDYdYHu1tr4gyTPaRKw0q
AwMjD22+TTBAvAUWrhgSfJBM+qMpmamthIo0rQKrW/5v3hqzitqH
=itmQ
-----END PGP MESSAGE-----

--0000000000000524f106052554b2
Content-Type: application/pgp-keys; name="0xADAC279C95093207.asc"
Content-Disposition: attachment; filename="0xADAC279C95093207.asc"
Content-Transfer-Encoding: base64
Content-ID: <f_zdPmOReKOJGezzQdUVxGPXKFGWsrXL@flowcrypt>
X-Attachment-Id: f_zdPmOReKOJGezzQdUVxGPXKFGWsrXL@flowcrypt
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--0000000000000524f106052554b2--
", + "historyId": "273528", + "internalDate": "1694507740000" + } +} \ No newline at end of file diff --git a/appium/api-mocks/apis/google/exported-messages/message-export-18a88891abaf2322.json b/appium/api-mocks/apis/google/exported-messages/message-export-18a88891abaf2322.json new file mode 100644 index 000000000..51bb53bb7 --- /dev/null +++ b/appium/api-mocks/apis/google/exported-messages/message-export-18a88891abaf2322.json @@ -0,0 +1,110 @@ +{ + "acctEmail": "e2e.enterprise.test@flowcrypt.com", + "full": { + "id": "18a88891abaf2322", + "threadId": "18a888876a910440", + "labelIds": ["INBOX"], + "snippet": "Email with another user public key attached", + "payload": { + "partId": "", + "mimeType": "multipart/mixed", + "filename": "", + "headers": [ + { + "name": "MIME-Version", + "value": "1.0" + }, + { + "name": "Date", + "value": "Tue, 12 Sep 2023 04:36:38 -0400" + }, + { + "name": "Subject", + "value": "Email with another user public key attached" + }, + { + "name": "From", + "value": "sender@domain.com" + }, + { + "name": "To", + "value": "e2e.enterprise.test@flowcrypt.com" + }, + { + "name": "Content-Type", + "value": "multipart/mixed; boundary=\"0000000000008ed83c060525575e\"" + } + ], + "body": { + "size": 0 + }, + "parts": [ + { + "partId": "0", + "mimeType": "text/plain", + "filename": "", + "headers": [ + { + "name": "Content-Type", + "value": "text/plain; charset=\"UTF-8\"" + } + ], + "body": { + "size": 45, + "data": "RW1haWwgd2l0aCBhbm90aGVyIHVzZXIgcHVibGljIGtleSBhdHRhY2hlZA0K" + } + }, + { + "partId": "1", + "mimeType": "application/octet-stream", + "filename": "Demo User (82BD5F7C) – Public.asc", + "headers": [ + { + "name": "Content-Type", + "value": "application/octet-stream; name=\"Demo User (82BD5F7C) – Public.asc\"" + }, + { + "name": "Content-Disposition", + "value": "attachment; filename=\"Demo User (82BD5F7C) – Public.asc\"" + }, + { + "name": "Content-Transfer-Encoding", + "value": "base64" + }, + { + "name": "X-Attachment-Id", + "value": "f_lmg26v090" + }, + { + "name": "Content-ID", + "value": "" + } + ], + "body": { + "attachmentId": "ANGjdJ9KBYYna2Iv_SpVT0qxwi6hnLRSRnWlnk3wdhdzG-O1ShrqUhrs6Zwkbv1IKiQnCzfOlGF0IsSF_L-STLFPevVwKJFJL7COk7mL4aCK5ViaNddZjUUtpFly5LkS1ZVz4JgtrTZB4leD-wIgZdLbXiv-adtmWZ545tO7ZSp9kH6sT9IqJ1ASYn8vQr0g6WdUdcJeRVbs8uTHOZYBU72ftzRKKvGITfePYZ4JHjXyZRTnxD2Yhn7OtzxzY3sqvX4npT7z-Vzkkfnem5o5NZMFp_RJ5qF7Uc41x98_bmwX8GeA3xcz1F57QkrAQWM", + "size": 3955 + } + } + ] + }, + "sizeEstimate": 6326, + "historyId": "273526", + "internalDate": "1694507798000" + }, + "attachments": { + "ANGjdJ9KBYYna2Iv_SpVT0qxwi6hnLRSRnWlnk3wdhdzG-O1ShrqUhrs6Zwkbv1IKiQnCzfOlGF0IsSF_L-STLFPevVwKJFJL7COk7mL4aCK5ViaNddZjUUtpFly5LkS1ZVz4JgtrTZB4leD-wIgZdLbXiv-adtmWZ545tO7ZSp9kH6sT9IqJ1ASYn8vQr0g6WdUdcJeRVbs8uTHOZYBU72ftzRKKvGITfePYZ4JHjXyZRTnxD2Yhn7OtzxzY3sqvX4npT7z-Vzkkfnem5o5NZMFp_RJ5qF7Uc41x98_bmwX8GeA3xcz1F57QkrAQWM": { + "data": "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", + "size": 3955 + } + }, + "raw": { + "id": "18a88891abaf2322", + "threadId": "18a888876a910440", + "labelIds": ["INBOX"], + "snippet": "Email with another user public key attached", + "sizeEstimate": 6326, + "raw": "MIME-Version: 1.0
Date: Tue, 12 Sep 2023 04:36:38 -0400
Message-ID: <CAGKkJUa8gzRLb38sDhumSHUC0E=o1OW8V5XEwvCAk-m6K-M8jg@mail.gmail.com>
Subject: Email with another user public key attached
From: e2e enterprise test at FlowCrypt <e2e.enterprise.test@flowcrypt.com>
To: FlowCrypt Compatibility <flowcrypt.compatibility@gmail.com>
Content-Type: multipart/mixed; boundary="0000000000008ed83c060525575e"

--0000000000008ed83c060525575e
Content-Type: text/plain; charset="UTF-8"

Email with another user public key attached

--0000000000008ed83c060525575e
Content-Type: application/octet-stream; 
	name="=?UTF-8?Q?Demo_User_=2882BD5F7C=29_=E2=80=93_Public=2Easc?="
Content-Disposition: attachment; 
	filename="=?UTF-8?Q?Demo_User_=2882BD5F7C=29_=E2=80=93_Public=2Easc?="
Content-Transfer-Encoding: base64
X-Attachment-Id: f_lmg26v090
Content-ID: <f_lmg26v090>
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--0000000000008ed83c060525575e--", + "historyId": "273526", + "internalDate": "1694507798000" + } +} diff --git a/appium/api-mocks/apis/google/google-messages.ts b/appium/api-mocks/apis/google/google-messages.ts index 6b0f5bdf1..23c33301f 100644 --- a/appium/api-mocks/apis/google/google-messages.ts +++ b/appium/api-mocks/apis/google/google-messages.ts @@ -27,4 +27,6 @@ export type GoogleMockMessage = | 'rich text message with empty body and attachment' | 'message with kdbx file' | 'mime message with large attachment' - | 'Test forward message with attached pub key'; + | 'Test forward message with attached pub key' + | 'Encrypted email with public key attached' + | 'Email with another user public key attached'; diff --git a/appium/tests/data/index.ts b/appium/tests/data/index.ts index 614d70e6b..e12af6707 100644 --- a/appium/tests/data/index.ts +++ b/appium/tests/data/index.ts @@ -97,6 +97,16 @@ export const CommonData = { attachmentName: 'simple.txt', encryptedAttachmentName: 'simple.txt.pgp', }, + encryptedEmailWithPublicKey: { + subject: 'Encrypted email with public key attached', + publicKeyEmail: 'flowcrypt.compatibility@gmail.com', + publicKeyFingerPrint: 'E8F0 517B A6D7 DAB6 081C 96E4 ADAC 279C 9509 3207', + }, + emailWithAnotherUserPublicKey: { + subject: 'Email with another user public key attached', + publicKeyEmail: 'demo@flowcrypt.com', + publicKeyFingerPrint: 'A0D5 9CF1 5045 523C 67B2 C1EA 6AC1 4D76 82BD 5F7C', + }, encryptedEmailWithAttachmentWithoutPreview: { sender: 'flowcrypt.compatibility@gmail.com', subject: 'message with kdbx file', diff --git a/appium/tests/helpers/ElementHelper.ts b/appium/tests/helpers/ElementHelper.ts index d21b1455f..d03479cad 100644 --- a/appium/tests/helpers/ElementHelper.ts +++ b/appium/tests/helpers/ElementHelper.ts @@ -109,11 +109,20 @@ class ElementHelper { }; //wait for text in element during 15 seconds (if the text doesn't appear during 15s, it will show the error) - static waitForText = async (element: WebdriverIO.Element, text: string, timeout: number = DEFAULT_TIMEOUT) => { + static waitForText = async ( + element: WebdriverIO.Element, + text: string, + timeout: number = DEFAULT_TIMEOUT, + checkContains = false, + ) => { await this.waitElementVisible(element); await element.waitUntil( async function () { - return (await element.getText()) === text; + const elementText = await element.getText(); + if (checkContains) { + return elementText.includes(text); + } + return elementText === text; }, { timeout: timeout, diff --git a/appium/tests/screenobjects/email.screen.ts b/appium/tests/screenobjects/email.screen.ts index d1b9db56c..1c9e187b8 100644 --- a/appium/tests/screenobjects/email.screen.ts +++ b/appium/tests/screenobjects/email.screen.ts @@ -30,6 +30,12 @@ const SELECTORS = { ENCRYPTION_BADGE: '~aid-encryption-badge', SIGNATURE_BADGE: '~aid-signature-badge', ATTACHMENT_TEXT_VIEW: '~aid-attachment-text-view', + PUBLIC_KEY_LABEL: '~aid-public-key-label', + FINGEPRINT_LABEL_VALUE: '~aid-fingerprint-value', + PUBLIC_KEY_IMPORT_WARNING: '~aid-warning-label', + TOGGLE_PUBLIC_KEY_NODE: '~aid-toggle-public-key-node', + PUBLIC_KEY_VALUE: '~aid-public-key-value', + IMPORT_PUBLIC_KEY_BUTTON: '~aid-import-key-button', }; class EmailScreen extends BaseScreen { @@ -137,6 +143,30 @@ class EmailScreen extends BaseScreen { return $(SELECTORS.SIGNATURE_BADGE); } + get publicKeyLabel() { + return $(SELECTORS.PUBLIC_KEY_LABEL); + } + + get fingerprintLabelValue() { + return $(SELECTORS.FINGEPRINT_LABEL_VALUE); + } + + get publicKeyImportWarningLabel() { + return $(SELECTORS.PUBLIC_KEY_IMPORT_WARNING); + } + + get publicKeyToggle() { + return $(SELECTORS.TOGGLE_PUBLIC_KEY_NODE); + } + + get publicKeyValueLabel() { + return $(SELECTORS.PUBLIC_KEY_VALUE); + } + + get importPublicKeyButton() { + return $(SELECTORS.IMPORT_PUBLIC_KEY_BUTTON); + } + get attachmentTextView() { return $(SELECTORS.ATTACHMENT_TEXT_VIEW); } @@ -329,6 +359,26 @@ class EmailScreen extends BaseScreen { expect(text.includes(value)).toBeTruthy(); }; + checkPublicKeyImportView = async (email: string, fingerprint: string, isAlreadyImported = false) => { + await ElementHelper.waitForText(await this.publicKeyLabel, email, 3000, true); + await ElementHelper.waitForText(await this.fingerprintLabelValue, fingerprint, 3000, true); + await ElementHelper.waitElementVisible(await this.importPublicKeyButton); + if (!isAlreadyImported) { + await ElementHelper.waitElementVisible(await this.publicKeyImportWarningLabel); + } + // Check if public key toggle works correctly (should show/hide public key value label) + await ElementHelper.waitAndClick(await this.publicKeyToggle); + await ElementHelper.waitElementVisible(await this.publicKeyValueLabel); + await ElementHelper.waitAndClick(await this.publicKeyToggle); + await ElementHelper.waitElementInvisible(await this.publicKeyValueLabel); + }; + + importPublicKey = async () => { + await ElementHelper.waitAndClick(await this.importPublicKeyButton); + await ElementHelper.waitForText(await this.importPublicKeyButton, 'Already imported'); + await ElementHelper.waitElementInvisible(await this.publicKeyImportWarningLabel); + }; + draftBody = async (index: number) => { return $(`~aid-draft-body-${index}`); }; diff --git a/appium/tests/specs/mock/inbox/ImportPublicKeyReceivedByEmail.spec.ts b/appium/tests/specs/mock/inbox/ImportPublicKeyReceivedByEmail.spec.ts new file mode 100644 index 000000000..b8b0b47e7 --- /dev/null +++ b/appium/tests/specs/mock/inbox/ImportPublicKeyReceivedByEmail.spec.ts @@ -0,0 +1,66 @@ +import { + ContactScreen, + EmailScreen, + MailFolderScreen, + MenuBarScreen, + SettingsScreen, + SetupKeyScreen, + SplashScreen, +} from '../../../screenobjects/all-screens'; + +import { MockApi } from 'api-mocks/mock'; +import { MockApiConfig } from 'api-mocks/mock-config'; +import { MockUserList } from 'api-mocks/mock-data'; +import { CommonData } from '../../../data'; + +describe('INBOX: ', () => { + it('user is able to import public key received by email', async () => { + const emailSubject = CommonData.encryptedEmailWithPublicKey.subject; + const publicKeyEmail = CommonData.encryptedEmailWithPublicKey.publicKeyEmail; + const publicKeyFingerPrint = CommonData.encryptedEmailWithPublicKey.publicKeyFingerPrint; + const emailSubject2 = CommonData.emailWithAnotherUserPublicKey.subject; + const publicKeyEmail2 = CommonData.emailWithAnotherUserPublicKey.publicKeyEmail; + const publicKeyFingerPrint2 = CommonData.emailWithAnotherUserPublicKey.publicKeyFingerPrint; + const mockApi = new MockApi(); + + mockApi.fesConfig = MockApiConfig.defaultEnterpriseFesConfiguration; + mockApi.ekmConfig = MockApiConfig.defaultEnterpriseEkmConfiguration; + mockApi.addGoogleAccount('e2e.enterprise.test@flowcrypt.com', { + messages: ['Encrypted email with public key attached', 'Email with another user public key attached'], + }); + mockApi.attesterConfig = { + servedPubkeys: { + [MockUserList.e2e.email]: MockUserList.e2e.pub!, + }, + }; + + await mockApi.withMockedApis(async () => { + await SplashScreen.mockLogin(); + await SetupKeyScreen.setPassPhrase(); + await MailFolderScreen.checkInboxScreen(); + + await MailFolderScreen.clickOnEmailBySubject(emailSubject); + await EmailScreen.checkPublicKeyImportView(publicKeyEmail, publicKeyFingerPrint, false); + await EmailScreen.importPublicKey(); + await EmailScreen.clickBackButton(); + + // Go to Contacts screen and see if pubkey is imported correctly + await MenuBarScreen.clickMenuBtn(); + await MenuBarScreen.clickSettingsButton(); + await SettingsScreen.clickOnSettingItem('Contacts'); + await ContactScreen.checkContact(publicKeyEmail); + + // Now go back to inbox screen and check `email with another user pubkey attached` + await ContactScreen.clickBackButton(); + await MenuBarScreen.clickMenuBtn(); + await MenuBarScreen.clickInboxButton(); + await MailFolderScreen.clickOnEmailBySubject(emailSubject2); + await EmailScreen.checkPublicKeyImportView(publicKeyEmail2, publicKeyFingerPrint2, false); + await EmailScreen.importPublicKey(); + // Check if import button changed to `Already imported` after public key is imported + await EmailScreen.clickBackButton(); + await MailFolderScreen.clickOnEmailBySubject(emailSubject2); + await EmailScreen.checkPublicKeyImportView(publicKeyEmail2, publicKeyFingerPrint2, true); + }); + }); +});