求基于IMAP服务器的Python脚本：添加自定义X-TAG邮件头并适配Popfile

Great question—your approach is absolutely feasible, and it’s a solid way to handle both adding custom headers (like your X-TAG for Popfile) and future email decryption tasks. Let’s break this down clearly:

Why This Works #

IMAP servers fully support modifying message content (including headers) by fetching the raw RFC822 message, altering it locally, and re-saving it back. Since Popfile processes messages via IMAP, it will pick up the X-TAG header just like any other standard header once the modified message is stored.

Key Steps to Implement #

Here’s a step-by-step breakdown of the workflow you described:

• Connect to your IMAP server over SSL (for security).
• Fetch the target message using its UID (avoids confusion with message sequence numbers that can change).
• Parse the raw RFC822 content into an email.message.EmailMessage object (Python’s built-in email library handles this perfectly).
• Add your custom X-TAG header (you can overwrite existing ones or add multiple instances with add_header()).
• Convert the modified message back to a raw string.
• Replace the original message on the IMAP server (since IMAP doesn’t have a direct "edit" command, we’ll append the modified message and delete the original).

Sample Python Script #

Here’s a minimal, working script that implements this logic. Replace the placeholder values with your IMAP details:

import imaplib
import email
from email.message import EmailMessage

def add_custom_tag(imap_host, imap_user, imap_pass, mailbox, uid, tag_value):
    # Connect to IMAP server (use SSL for security)
    with imaplib.IMAP4_SSL(imap_host) as imap:
        imap.login(imap_user, imap_pass)
        imap.select(mailbox, readonly=False)  # Read-write mode

        # Fetch the raw RFC822 message using UID
        result, data = imap.uid('FETCH', uid, '(RFC822)')
        if result != 'OK':
            print(f"Failed to fetch message UID {uid}")
            return

        # Parse the message
        raw_msg = data[0][1]
        msg = email.message_from_bytes(raw_msg, policy=email.policy.default)

        # Add or overwrite the X-TAG header
        msg['X-TAG'] = tag_value
        # To add multiple tags (if needed), use:
        # msg.add_header('X-TAG', 'another-tag')

        # Convert modified message back to raw string
        modified_msg = msg.as_string()

        # Append the modified message to the same mailbox
        imap.append(mailbox, '', imaplib.Time2Internaldate(email.utils.localtime()), modified_msg.encode('utf-8'))

        # Mark original message for deletion
        imap.uid('STORE', uid, '+FLAGS.SILENT', '\\Deleted')
        # Expunge to permanently remove deleted messages (some servers auto-expunge)
        imap.expunge()

        print(f"Successfully added X-TAG: {tag_value} to message UID {uid}")

# Example usage
if __name__ == "__main__":
    IMAP_HOST = "your-imap-server.com"
    IMAP_USER = "your-email@example.com"
    IMAP_PASS = "your-app-password-or-password"  # Use app password for 2FA accounts
    MAILBOX = "INBOX"
    TARGET_UID = "12345"  # Replace with your message UID
    TAG_VALUE = "Popfile-Custom-Tag"

    add_custom_tag(IMAP_HOST, IMAP_USER, IMAP_PASS, MAILBOX, TARGET_UID, TAG_VALUE)

Notes for Your Use Case #

• Popfile Compatibility: Ensure Popfile is configured to scan for the X-TAG header in its rules—this should work seamlessly since Popfile processes messages as RFC822 objects.
• Decryption Future Plan: This exact framework works for decryption too. After fetching the message, you’d decrypt the body/content, update the message (e.g., replace encrypted body with plaintext, add an X-DECRYPTED: True header), then save it back using the same append/delete workflow.
• Safety First: Before running this on critical messages, test with a test mailbox or duplicate messages to avoid accidental data loss. Some IMAP servers (like Gmail) keep deleted messages in the Trash, but it’s better to be cautious.
• Existing Scripts: While there’s no one-size-fits-all script for this exact task, the components are all using Python’s standard libraries, so assembling your own is straightforward and gives you full control (which is perfect for your future decryption needs).

Content of the question originates from Stack Exchange, asked by Stephan