fix: address Gemini review round 3

- Validate attachment paths stay under CWD (path traversal protection)
  consistent with validate.rs patterns
- Encode non-ASCII filenames using RFC 2231 (filename*=UTF-8''...)
  for correct display in all email clients
- Add #[derive(Debug)] to Attachment struct
- Add tests for path traversal rejection, RFC 2231 encoding, and
  filename quoting

Author: pae-hexa

src/helpers/gmail/mod.rs

@@ -273,6 +273,7 @@ pub(super) fn encode_header_value(value: &str) -> String {
 }
 
 /// A file attachment to include in an outgoing email.
+#[derive(Debug)]
 pub(super) struct Attachment {
     pub filename: String,
     pub content_type: String,
@@ -315,23 +316,39 @@ pub(super) fn guess_content_type(filename: &str) -> &'static str {
 
 /// Read attachment files from a list of paths.
 ///
-/// Each path is canonicalized to resolve symlinks and `..` components; the
-/// function rejects paths that do not point to a regular file.
+/// Each path is resolved relative to the current working directory and
+/// canonicalized to resolve symlinks and `..` components. The function
+/// rejects paths that resolve outside CWD (path traversal protection,
+/// consistent with `validate.rs`) or that do not point to a regular file.
 pub(super) fn read_attachments(paths: &[String]) -> Result<Vec<Attachment>, GwsError> {
+    let cwd = std::env::current_dir().map_err(|e| {
+        GwsError::Other(anyhow::anyhow!("Failed to determine current directory: {e}"))
+    })?;
+    let canonical_cwd = cwd.canonicalize().map_err(|e| {
+        GwsError::Other(anyhow::anyhow!("Failed to canonicalize current directory: {e}"))
+    })?;
+
     let mut attachments = Vec::new();
     for path_str in paths {
         let path_str = path_str.trim();
         if path_str.is_empty() {
             continue;
         }
-        let path = std::path::Path::new(path_str);
+        let path = cwd.join(path_str);
         let canonical = path.canonicalize().map_err(|e| {
             GwsError::Other(anyhow::anyhow!(
                 "Failed to resolve attachment path '{}': {}",
                 path_str,
                 e
             ))
         })?;
+        if !canonical.starts_with(&canonical_cwd) {
+            return Err(GwsError::Other(anyhow::anyhow!(
+                "Attachment '{}' resolves to '{}' which is outside the current directory",
+                path_str,
+                canonical.display(),
+            )));
+        }
         if !canonical.is_file() {
             return Err(GwsError::Other(anyhow::anyhow!(
                 "Attachment path '{}' is not a regular file",
@@ -388,6 +405,29 @@ fn escape_quoted_string(s: &str) -> String {
         .replace('"', "\\\"")
 }
 
+/// Encode a filename for MIME Content-Type/Content-Disposition headers.
+///
+/// For ASCII-only filenames, returns a simple `name="filename"` pair.
+/// For non-ASCII filenames, uses RFC 2231 encoding (`name*=UTF-8''...`)
+/// which is supported by all modern email clients.
+fn encode_mime_filename(param: &str, filename: &str) -> String {
+    if filename.is_ascii() {
+        format!("{}=\"{}\"", param, escape_quoted_string(filename))
+    } else {
+        // RFC 2231: parameter*=charset'language'value
+        // Percent-encode non-ASCII bytes and RFC 5987 special chars.
+        let mut encoded = String::new();
+        for &byte in filename.as_bytes() {
+            if byte.is_ascii_alphanumeric() || b"!#$&+-.^_`|~".contains(&byte) {
+                encoded.push(byte as char);
+            } else {
+                encoded.push_str(&format!("%{:02X}", byte));
+            }
+        }
+        format!("{}*=UTF-8''{}", param, encoded)
+    }
+}
+
 impl MessageBuilder<'_> {
     /// Build the common RFC 2822 headers shared by both plain and multipart
     /// messages. The `content_type_line` parameter supplies the Content-Type
@@ -484,15 +524,16 @@ impl MessageBuilder<'_> {
                 offset = end;
             }
 
-            let safe_filename = escape_quoted_string(&att.filename);
+            let ct_name = encode_mime_filename("name", &att.filename);
+            let cd_filename = encode_mime_filename("filename", &att.filename);
             message.push_str(&format!(
                 "--{}\r\n\
-                 Content-Type: {}; name=\"{}\"\r\n\
-                 Content-Disposition: attachment; filename=\"{}\"\r\n\
+                 Content-Type: {}; {}\r\n\
+                 Content-Disposition: attachment; {}\r\n\
                  Content-Transfer-Encoding: base64\r\n\
                  \r\n\
                  {}\r\n",
-                boundary, att.content_type, safe_filename, safe_filename, folded,
+                boundary, att.content_type, ct_name, cd_filename, folded,
             ));
         }
 
@@ -1423,4 +1464,47 @@ mod tests {
         assert_eq!(resolved.http_method, "POST");
         assert_eq!(resolved.path, "gmail/v1/users/{userId}/messages/send");
     }
+
+    #[test]
+    fn test_encode_mime_filename_ascii() {
+        assert_eq!(
+            encode_mime_filename("name", "report.pdf"),
+            "name=\"report.pdf\""
+        );
+    }
+
+    #[test]
+    fn test_encode_mime_filename_with_quotes() {
+        assert_eq!(
+            encode_mime_filename("name", "my \"file\".pdf"),
+            "name=\"my \\\"file\\\".pdf\""
+        );
+    }
+
+    #[test]
+    fn test_encode_mime_filename_non_ascii() {
+        let result = encode_mime_filename("filename", "résumé.pdf");
+        assert!(result.starts_with("filename*=UTF-8''"));
+        assert!(result.contains("r%C3%A9sum%C3%A9.pdf"));
+    }
+
+    #[test]
+    fn test_read_attachments_rejects_path_traversal() {
+        let paths = vec!["../../../etc/passwd".to_string()];
+        let result = read_attachments(&paths);
+        assert!(result.is_err());
+        let err = result.unwrap_err().to_string();
+        assert!(
+            err.contains("outside the current directory") || err.contains("Failed to resolve"),
+            "Expected path traversal rejection, got: {err}"
+        );
+    }
+
+    #[test]
+    fn test_read_attachments_rejects_empty_paths() {
+        let paths = vec!["  ".to_string(), "".to_string()];
+        let result = read_attachments(&paths);
+        assert!(result.is_ok());
+        assert!(result.unwrap().is_empty());
+    }
 }