Decrypt encrypted attachment

FlowCrypt.xcodeproj/project.pbxproj

@@ -1318,8 +1318,8 @@
  isa = PBXGroup;
  children = (
  9F4163EC266574CB00106194 /* BackupServiceMock.swift */,
- 9F6F3C3B26ADFBC7005BD9C6 /* CoreComposeMessageMock.swift */,
  9F6F3C6926ADFBEB005BD9C6 /* MessageGatewayMock.swift */,
+ 9F6F3C3B26ADFBC7005BD9C6 /* CoreComposeMessageMock.swift */,
  9F6F3C7526ADFC37005BD9C6 /* KeyStorageMock.swift */,
  9F6F3C7C26ADFC60005BD9C6 /* ContactsServiceMock.swift */,
  );

FlowCrypt/Core/Core.swift

@@ -11,6 +11,10 @@ enum CoreError: Error, Equatable {
  case notReady(String)
  case format(String)
  case keyMismatch(String)
+ case noMDC(String)
+ case badMDC(String)
+ case needPassphrase(String)
+ case wrongPassphrase(String)
  // wrong value passed into a function
  case value(String)
 
@@ -21,6 +25,10 @@ enum CoreError: Error, Equatable {
  switch errorType {
  case "format": self = .format(coreError.error.message)
  case "key_mismatch": self = .keyMismatch(coreError.error.message)
+ case "no_mdc": self = .noMDC(coreError.error.message)
+ case "bad_mdc": self = .badMDC(coreError.error.message)
+ case "need_passphrase": self = .needPassphrase(coreError.error.message)
+ case "wrong_passphrase": self = .wrongPassphrase(coreError.error.message)
  default: return nil
  }
  }

FlowCrypt/Functionality/Mail Provider/Message Provider/MessageService.swift

@@ -8,6 +8,7 @@
 
 import Foundation
 import Promises
+import FlowCryptCommon
 
 // MARK: - MessageAttachment
 struct MessageAttachment: FileType {
@@ -47,6 +48,10 @@ enum MessageServiceError: Error {
 }
 
 final class MessageService {
+ private enum Constants {
+ static let encryptedAttachmentExtension = "pgp"
+ }
+
  private let messageProvider: MessageProvider
  private let keyService: KeyServiceType
  private let passPhraseService: PassPhraseServiceType
@@ -90,7 +95,7 @@ final class MessageService {
  reject(MessageServiceError.wrongPassPhrase(rawMimeData, passPhrase))
  } else {
  self.savePassPhrases(value: passPhrase, with: keys)
- let processedMessage = self.processMessage(rawMimeData: rawMimeData, with: decrypted)
+ let processedMessage = try self.processMessage(rawMimeData: rawMimeData, with: decrypted, keys: keys)
  resolve(processedMessage)
  }
  }
@@ -125,18 +130,30 @@ final class MessageService {
  isEmail: true
  )
 
- let processedMessage = self.processMessage(rawMimeData: rawMimeData, with: decrypted)
+ let processedMessage = try self.processMessage(rawMimeData: rawMimeData, with: decrypted, keys: keys)
  resolve(processedMessage)
  }
  }
 
- private func processMessage(rawMimeData: Data, with decrypted: CoreRes.ParseDecryptMsg) -> ProcessedMessage {
+ private func processMessage(rawMimeData: Data, with decrypted: CoreRes.ParseDecryptMsg, keys: [PrvKeyInfo]) throws -> ProcessedMessage {
  let decryptErrBlocks = decrypted.blocks
  .filter { $0.decryptErr != nil }
 
- let attachments = decrypted.blocks
+ let attachments = try decrypted.blocks
  .filter(\.isAttachmentBlock)
- .map(MessageAttachment.init)
+ .compactMap { block -> MessageAttachment? in
+ guard let attMeta = block.attMeta else { return nil }
+ var name = attMeta.name
+ let size = attMeta.length
+ var data = attMeta.data
+
+ if block.type == .encryptedAtt {
+ data = (try core.decryptFile(encrypted: data, keys: keys, msgPwd: nil).content)
+ name = name.deletingPathExtension
+ }
+
+ return MessageAttachment(name: name, size: size, data: data)
+ }
 
  let messageType: ProcessedMessage.MessageType
  let text: String

FlowCryptAppTests/Core/FlowCryptCoreTests.swift

@@ -128,6 +128,43 @@ class FlowCryptCoreTests: XCTestCase {
  XCTAssertNotNil(mime.range(of: "Subject: \(msg.subject)")) // has mime Subject header
  XCTAssertNil(mime.range(of: "In-Reply-To")) // Not a reply
  }
+
+ func testComposeEmailInlineWithAttachment() throws {
+
+ let initialFileName = "data.txt"
+ let urlPath = URL(fileURLWithPath: Bundle(for: type(of: self))
+ .path(forResource: "data", ofType: "txt")!)
+ let fileData = try! Data(contentsOf: urlPath, options: .dataReadingMapped)
+
+ let attachment = SendableMsg.Attachment(
+ name: initialFileName, type: "text/plain",
+ base64: fileData.base64EncodedString()
+ )
+
+ let msg = SendableMsg(
+ text: "this is the message",
+ to: ["email@hello.com"], cc: [], bcc: [],
+ from: "sender@hello.com",
+ subject: "subj", replyToMimeMsg: nil,
+ atts: [attachment], pubKeys: nil
+ )
+ let expectation = XCTestExpectation()
+
+ var mime: String = ""
+ core.composeEmail(msg: msg, fmt: .encryptInline, pubKeys: [TestData.k0.pub, TestData.k1.pub])
+ .sinkFuture(
+ receiveValue: { composeEmailRes in
+ mime = String(data: composeEmailRes.mimeEncoded, encoding: .utf8)!
+ expectation.fulfill()
+ }, receiveError: {_ in }
+ )
+ .store(in: &cancellable)
+ wait(for: [expectation], timeout: 3)
+ XCTAssertNil(mime.range(of: msg.text)) // text encrypted
+ XCTAssertNotNil(mime.range(of: "Content-Type: application/pgp-encrypted")) // encrypted
+ XCTAssertNotNil(mime.range(of: "name=\(attachment.name)")) // attachment
+ XCTAssertNotNil(mime.range(of: "Subject: \(msg.subject)")) // has mime Subject header
+ }
 
  func testEndToEnd() throws {
  let passphrase = "some pass phrase test"
@@ -290,7 +327,51 @@ class FlowCryptCoreTests: XCTestCase {
  XCTAssertNotNil(message.range(of: "Missing appropriate key"))
  }
  }
-
+
+ func testDecryptEncryptedFile() throws {
+ // Given
+ let initialFileName = "data.txt"
+ let urlPath = URL(fileURLWithPath: Bundle(for: type(of: self))
+ .path(forResource: "data", ofType: "txt")!)
+ let fileData = try! Data(contentsOf: urlPath, options: .dataReadingMapped)
+
+ let passphrase = "some pass phrase test"
+ let email = "e2e@domain.com"
+ let generateKeyRes = try core.generateKey(
+ passphrase: passphrase,
+ variant: KeyVariant.curve25519,
+ userIds: [UserId(email: email, name: "End to end")]
+ )
+ let k = generateKeyRes.key
+ let keys = [
+ PrvKeyInfo(
+ private: k.private!,
+ longid: k.ids[0].longid,
+ passphrase: passphrase,
+ fingerprints: k.fingerprints
+ )
+ ]
+
+ // When
+ do {
+ let encrypted = try core.encryptFile(
+ pubKeys: [k.public],
+ fileData: fileData,
+ name: initialFileName
+ )
+ let decrypted = try self.core.decryptFile(
+ encrypted: encrypted.encryptedFile,
+ keys: keys,
+ msgPwd: nil
+ )
+ // Then
+ XCTAssertEqual(decrypted.name, initialFileName)
+ XCTAssertEqual(decrypted.content.count, fileData.count)
+ } catch {
+ XCTFail("Core file decryption should not fail")
+ }
+ }
+
  func testException() throws {
  do {
  _ = try core.decryptKey(armoredPrv: "not really a key", passphrase: "whatnot")

FlowCryptCommon/Extensions/StringExtensions.swift

@@ -45,6 +45,10 @@ public extension String {
  }
  }
  }
+
+ var deletingPathExtension: String {
+ return NSString(string: self).deletingPathExtension as String
+ }
 }
 
 public extension NSAttributedString {