Understanding What Is Electronic Mail Email Core Concepts And Evolution

Published

Table of Contents

Electronic mail, commonly known as email, has revolutionized global communication by replacing traditional postal systems with instantaneous digital exchanges. Since its inception in the 1960s, email has evolved from a niche ARPANET experiment into the backbone of modern correspondence, enabling seamless information transfer across continents in seconds. Beyond its role as a messaging tool, email integrates technical protocols, encryption standards, and user-friendly interfaces to address the demands of both personal and professional environments.

The system’s efficiency stems from its structured components—sender, recipient, subject, and metadata—each contributing to a standardized format governed by protocols like SMTP, IMAP, and POP3. These elements interact within a robust infrastructure of mail servers, DNS records, and ISPs, ensuring reliable delivery while balancing speed, security, and accessibility. As email continues to shape digital interactions, understanding its technical foundations and historical milestones provides insight into its enduring relevance in an increasingly interconnected world.

what is electronic mail email

Definition and Core Concepts of Electronic Mail (Email)

Electronic mail, commonly referred to as email, represents a digital communication method enabling the transmission of messages, documents, and multimedia between users via computer networks. Unlike traditional mail, which relies on physical delivery systems, email leverages the internet to transmit information instantaneously, reducing time and cost barriers. Its primary purpose is to facilitate secure, structured, and efficient exchange of information globally, supporting both personal and professional interactions.

Email systems operate as decentralized networks where messages are transmitted using standardized protocols, ensuring compatibility across diverse platforms. The core components of an email system include the sender, recipient, subject line, message body, attachments, and metadata such as timestamps, headers, and encryption details. These elements collectively define the structure and functionality of email communication, enabling users to organize, prioritize, and retrieve messages effectively.

Key Components of an Email System

An email system comprises several essential elements that define its functionality and user experience. The sender initiates the communication by composing a message, while the recipient receives it upon delivery. The subject line provides a concise summary of the message’s purpose, aiding in prioritization. The body contains the primary content, which may include text, formatted content, or embedded media. Attachments allow users to share additional files, such as documents, images, or spreadsheets, directly within the email.

Metadata plays a critical role in email systems, including:

  • Timestamps: Recording the date and time of sending, receiving, and potential read receipts.
  • Headers: Containing technical details such as IP addresses, server paths, and encryption certificates.
  • Carbon Copy (CC) and Blind Carbon Copy (BCC): Enabling multiple recipients to receive the same message while maintaining privacy for BCC addresses.

    • These components collectively ensure that emails are structured, traceable, and secure, supporting both individual and organizational workflows.

    Comparison of Traditional Mail and Electronic Mail

    The following table highlights the key differences between traditional mail and electronic mail across critical attributes:
    Attribute Traditional Mail Electronic Mail (Email)
    Speed Delivery time varies (hours to days), dependent on distance and postal services. Near-instantaneous transmission, typically delivered within seconds to minutes.
    Cost Incurred based on weight, distance, and additional services (e.g., express delivery). Minimal cost for sending; recipients may incur data charges for large attachments.
    Permanence Physical copies may degrade over time; archival requires manual storage. Digital storage allows for easy backup, retrieval, and long-term preservation.
    Accessibility Limited to physical locations where mail is delivered; requires manual handling. Accessible globally via internet-connected devices, enabling real-time communication.
    Security Vulnerable to interception during transit; relies on physical safeguards. Encryption and authentication protocols (e.g., TLS, S/MIME) enhance security.
    Scalability Manual processes limit scalability for large volumes of correspondence. Supports mass distribution (e.g., newsletters, bulk emails) with automated tools.
    This comparison underscores email’s efficiency, cost-effectiveness, and global reach, making it the preferred communication method for modern organizations and individuals.

    Technical Infrastructure of Email Systems

    Email systems rely on a robust technical infrastructure to ensure reliable transmission and retrieval of messages. The process involves protocols, servers, and network components that collaborate to deliver emails securely and efficiently.

    Email Protocols define the rules governing message transmission and retrieval:

  • Simple Mail Transfer Protocol (SMTP): Responsible for sending emails between servers. SMTP operates on port 25 (standard) or 587 (submission) and ensures messages are routed to the correct recipient’s mail server.
  • Internet Message Access Protocol (IMAP): Enables users to access and manage emails stored on a remote server, synchronizing changes across devices. IMAP operates on port 143 (standard) or 993 (with SSL/TLS).
  • Post Office Protocol 3 (POP3): Retrieves emails from a server and downloads them to the user’s device, typically deleting them from the server. POP3 operates on port 110 (standard) or 995 (with SSL/TLS).

    • Mail Servers act as intermediaries, storing and forwarding emails. Key server types include:

  • Mail Transfer Agent (MTA): Handles the sending and receiving of emails between servers (e.g., Postfix, Exim).
  • Mail Delivery Agent (MDA): Delivers incoming emails to the recipient’s mailbox (e.g., Procmail, Dovecot).
  • Mail User Agent (MUA): The interface used by end-users to compose and read emails (e.g., Outlook, Thunderbird).

    • Domain Name System (DNS) Records, particularly MX (Mail Exchange) records, specify which mail servers are authorized to accept emails for a domain. For example, an MX record for `example.com` might direct emails to `mail.example.com`.

    Step-by-Step Email Transmission Process

    The journey of an email from sender to recipient involves multiple stages, coordinated by protocols, DNS, and mail servers. Below is a detailed breakdown:

    1. Composition and Submission
    The sender composes an email using a Mail User Agent (MUA) and submits it to their Mail Transfer Agent (MTA) via SMTP. The MTA checks the recipient’s domain to determine the appropriate mail server using DNS MX records.

    2. DNS Lookup
    The sender’s MTA queries the DNS to resolve the recipient’s domain name into an IP address and identify the responsible mail server. If multiple MX records exist, the MTA selects the server with the lowest priority value.

    3. Routing Through ISPs
    The email travels through Internet Service Providers (ISPs) and intermediate networks, using the TCP/IP protocol suite for reliable data transmission. Firewalls and security protocols (e.g., TLS) may encrypt the message to prevent interception.

    4. Delivery to Recipient’s MTA
    The recipient’s MTA receives the email and verifies the sender’s details, checks spam filters, and applies security policies (e.g., SPF, DKIM, DMARC). If valid, the email is stored in the recipient’s mailbox or forwarded to an MDA for processing.

    5. Access by Recipient
    The recipient accesses their email using an MUA, which connects to their mail server via IMAP or POP3 to retrieve the message. The MUA displays the email, including headers, body, and attachments, while metadata (e.g., read receipts) may be updated.

    Example of Email Path:
    Sender (Gmail) → Gmail’s MTA → DNS resolves MX record for recipient’s domain (e.g., Outlook) → Outlook’s MTA receives and stores email → Recipient opens email via Outlook’s MUA.
    This process ensures that emails are delivered efficiently, even across international networks, while maintaining security and reliability.

    what is electronic mail email - Ilustrasi 2

    Historical Evolution of Electronic Mail

    The development of electronic mail (email) represents a pivotal milestone in digital communication, transitioning from experimental network protocols to a ubiquitous tool shaping modern interaction. Originating in the early days of computer networking, email evolved alongside technological advancements, addressing the need for decentralized, asynchronous messaging. Its trajectory reflects broader shifts in computing infrastructure, user interfaces, and internet commercialization, ultimately redefining how individuals and organizations exchange information globally.

    Email’s foundational principles emerged from the collaborative efforts of researchers and engineers in the 1960s, driven by the necessity to facilitate communication across distributed systems. The subsequent decades witnessed rapid innovation, from rudimentary command-line interfaces to intuitive graphical applications, each stage introducing features that enhanced accessibility, security, and functionality. This evolution paralleled the internet’s expansion, with email becoming a cornerstone of both personal and professional digital ecosystems.

    Origins and Early Experiments (1960s–1971)

    The concept of electronic messaging predates the internet but gained traction through ARPANET, the precursor to the modern internet, developed by the U.S. Department of Defense in 1969. Early experiments focused on message-switching protocols, where users could send text-based communications between connected computers. One of the first implementations was MAILBOX, created in 1972 by Tom Van Vleck at MIT, which allowed users to compose, send, and store messages in a centralized system. However, these systems lacked standardization and relied on proprietary formats, limiting interoperability.

    A critical breakthrough occurred in 1971, when Ray Tomlinson, an engineer at BBN Technologies, introduced two transformative innovations:

  • The use of the @ symbol to separate the recipient’s local part from their domain (e.g., `user@host`), enabling addressing across networks.
  • The first email program that ran on the ARPANET, allowing messages to traverse multiple machines.
    • Tomlinson’s work laid the groundwork for modern email addressing conventions, though early systems remained text-based and required manual configuration via command-line interfaces (CLIs). These interfaces demanded technical proficiency, restricting email adoption to researchers, academics, and military personnel.

    Standardization and the Rise of Widely Used Systems (1970s–1980s)

    The 1970s and 1980s saw efforts to standardize email protocols, addressing the fragmentation of early systems. Key milestones included:
  • 1975: The RFC 680 (Request for Comments) introduced the Simple Mail Transfer Protocol (SMTP), a protocol for sending emails between servers, published by Jon Postel. SMTP remains the backbone of email transmission today.
  • 1976: The Multipurpose Internet Mail Extensions (MIME) standard (RFC 2045–2049) was later developed to support non-text content (e.g., attachments, images) in emails, though its full adoption occurred in the 1990s.
  • 1982: The ARPANET transitioned to the TCP/IP protocol suite, standardizing network communication and enabling email to function across diverse systems.

    • During this period, email clients evolved beyond CLIs to include graphical user interfaces (GUIs), making the technology more accessible. Notable early GUI-based systems included:

  • 1988: Eudora, developed by Steve Dorner at Qualcomm, introduced a user-friendly interface with features like spell-checking and address books. It became one of the first widely adopted email clients for personal computers.
  • 1991: Microsoft Exchange and Lotus Notes emerged as enterprise solutions, offering calendar integration, shared folders, and collaborative tools, though they required proprietary servers.

    • Despite these advancements, email remained largely confined to academic, government, and corporate environments. The lack of widespread internet access and high costs of computing infrastructure limited its adoption among the general public.

    Timeline of Major Milestones in Email Development

    The following table outlines key milestones in email’s evolution, highlighting technological, protocol, and usability advancements:
    Year Milestone Impact
    1969 ARPANET established; early message-switching experiments Foundational network infrastructure for email communication.
    1971 Ray Tomlinson introduces @ symbol and first email program Standardized addressing and enabled cross-network messaging.
    1975 SMTP (RFC 680) published by Jon Postel Established protocol for email server communication.
    1982 ARPANET adopts TCP/IP; email becomes network-agnostic Enabled interoperability across different computer systems.
    1988 Eudora releases first widely used GUI email client Democratized email for non-technical users.
    1991 World Wide Web launched; email integrates with browsers Bridged email with emerging web technologies.
    1996 Hotmail launches first webmail service Introduced cloud-based email access without local software.
    1997 Microsoft Outlook 97 introduces unified inbox and calendar Set new standards for enterprise email clients.
    2004 Gmail releases with 1GB storage and AJAX interface Redefined user experience with search, labels, and scalability.
    2010s Adoption of end-to-end encryption (e.g., PGP, S/MIME) Enhanced security for sensitive communications.

    Comparison of Early and Modern Email Systems

    The transition from command-line interfaces to modern email clients reflects significant improvements in usability, security, and feature richness. Early systems (1970s–1980s) were characterized by:
  • Text-only interfaces: Users typed commands such as `MAIL`, `SEND`, or `RECEIVE` to interact with the system, requiring memorization of syntax.
  • Limited addressing: Recipients were often identified by numeric or cryptic identifiers rather than human-readable email addresses.
  • No attachments: Messages were restricted to plain text, with binary data (e.g., documents) transmitted separately via FTP or other methods.
  • Centralized servers: Email storage and retrieval depended on specific machines, creating single points of failure.

    • In contrast, modern email systems (2000s–present) offer:

  • Graphical interfaces: Drag-and-drop functionality, rich text formatting, and visual previews of messages.
  • Universal addressing: Standardized email formats (e.g., `user@domain.com`) with autocomplete and contact management.
  • Multimedia support: Native handling of attachments (PDFs, images, videos) and embedded content (e.g., Google Docs, Calendly links).
  • Cloud synchronization: Access to emails across devices via services like Gmail, Outlook, or Apple Mail, with automatic updates.
  • Enhanced security: Protocols such as TLS (Transport Layer Security) for encrypted transmission, SPF/DKIM/DMARC to combat spoofing, and end-to-end encryption for private communications.
  • Automation and AI: Features like spam filtering (e.g., Gmail’s "Promotions" tab), smart replies, and predictive typing.

    • The shift from server-dependent to cloud-based models further transformed email accessibility, enabling users to manage messages from any internet-connected device. However, this evolution also introduced challenges, such as privacy concerns (e.g., data retention policies) and cybersecurity threats (e.g., phishing, malware).

    Impact of Internet Commercialization and the Spam Epidemic (1990s)

    The commercialization of the internet in the 1990s marked a turning point for email, accelerating its adoption but also introducing new challenges. Key developments included:
  • 1991: The National Science Foundation (NSF) lifted

    • what is electronic mail email - Ilustrasi 3

    Technical Workings of Email Systems

    Electronic mail systems rely on a combination of protocols, servers, and security mechanisms to facilitate the transmission, storage, and retrieval of messages. At the core of this infrastructure are standardized communication protocols that govern how emails are sent, routed, and accessed. Understanding these technical components—such as SMTP for transmission, IMAP/POP3 for retrieval, and DNS-based routing—enables administrators and users to configure systems efficiently while ensuring security and reliability. This section dissects the operational mechanics of these protocols, their interactions, and the role of encryption in safeguarding email communications.

    Role of SMTP in Email Transmission

    The Simple Mail Transfer Protocol (SMTP) is the foundational protocol for sending emails across the internet, operating on port 25 (unencrypted) or 587 (submission with TLS). SMTP employs a client-server model, where the sender’s Mail User Agent (MUA) or Mail Transfer Agent (MTA) initiates a connection to the recipient’s mail server. The protocol uses a text-based command-response structure, where each command (e.g., `HELO`, `MAIL FROM`, `RCPT TO`, `DATA`) triggers a server response indicating success or failure.

    During transmission, SMTP follows a three-phase process:
    1. Handshake Phase: The client establishes a connection and identifies itself (e.g., `HELO example.com`).
    2. Mail Transaction Phase: The sender specifies the email address of the sender (`MAIL FROM: `) and recipient (`RCPT TO: `).
    3. Data Transfer Phase: The email content, including headers and body, is transmitted in 7-bit ASCII format using the `DATA` command, terminated by a single period (`.`).

    Key SMTP Commands and Responses:

    1. HELO/EHLO: Identifies the client to the server. EHLO supports extended SMTP (ESMTP) features like authentication and TLS.
    2. MAIL FROM: Specifies the sender’s email address. Example: MAIL FROM: <sender@example.com>.
    3. RCPT TO: Designates the recipient. Example: RCPT TO: <recipient@domain.com>.
    4. DATA: Initiates the transfer of email headers and body, ending with ..
    5. QUIT: Terminates the SMTP session.
    SMTP operates in store-and-forward mode, meaning emails may traverse multiple MTAs before reaching the destination. Intermediate servers (e.g., relay servers) temporarily store messages and forward them upon establishing a connection to the next hop. Errors during transmission (e.g., undeliverable addresses) trigger bounce messages sent back to the sender via SMTP.

    IMAP and POP3: Email Retrieval Protocols

    Email retrieval protocols enable clients to access messages stored on a mail server, differing primarily in synchronization behavior and resource usage. Both protocols operate over TCP/IP, but their design philosophies influence how emails are managed locally versus remotely.

    IMAP (Internet Message Access Protocol)
    IMAP, operating on port 143 (unencrypted) or 993 (IMAPS with SSL/TLS), is a stateful protocol that maintains a real-time synchronization between the client and server. Key features include:

  • Server-Side Storage: Emails remain on the server unless explicitly deleted or moved.
  • Folder Hierarchy: Supports nested folders and shared mailboxes.
  • Partial Retrieval: Clients can fetch headers, specific messages, or attachments without downloading entire mailboxes.
  • Idempotent Operations: Commands like `FETCH` or `STORE` modify server state predictably, reducing redundancy.

    • IMAP uses a tag-based command-response model, where each client command (e.g., `LOGIN`, `SELECT`, `FETCH`) is prefixed with a unique tag for tracking responses. For example:

    C: A001 LOGIN username password
    S: A001 OK Logged in
    C: A002 SELECT INBOX
    S: A002 OK [PERMANENTFLAGS (...) UNSEEN 42] Select completed
    POP3 (Post Office Protocol version 3)
    POP3, operating on port 110 (unencrypted) or 995 (POP3S with SSL/TLS), follows a stateless, download-and-delete approach. Key characteristics:
  • Client-Centric: Emails are downloaded to the local device by default, with server-side retention configurable via `DELE` (delete) commands.
  • No Synchronization: Conflicts arise if multiple clients access the same mailbox, as changes (e.g., deletions) are applied only after disconnection.
  • Simplified Commands: Uses a minimal set of commands (`USER`, `PASS`, `RETR`, `DELE`, `QUIT`) compared to IMAP.

    • Comparison of IMAP and POP3:

    Feature IMAP POP3
    Synchronization Real-time; server and client stay in sync. None; local changes may overwrite server state.
    Server Storage Emails remain unless explicitly removed. Emails deleted locally unless configured otherwise.
    Bandwidth Usage Efficient; fetches only necessary data. Inefficient; downloads entire mailbox by default.
    Use Case Multi-device access, shared mailboxes. Single-device access, low-resource environments.
    Implications for Email Management:
    IMAP is preferred for collaborative environments or users accessing emails from multiple devices, as it preserves server-side organization. POP3 suits offline-centric workflows where local storage is prioritized, but risks data loss if the client device fails. Modern deployments often use IMAP with TLS to balance synchronization and security.

    MX Records and Email Routing

    Mail Exchange (MX) records are DNS resource records that specify which mail servers are authoritative for receiving emails on behalf of a domain. They function as prioritized pointers, directing messages to the correct Mail Transfer Agent (MTA). MX records follow the format:
    domain.com. IN MX 10 mail1.example.com.
    domain.com. IN MX 20 mail2.example.com.
    Here, `10` and `20` are preference values (lower = higher priority), and `mail1.example.com.` is the mail server hostname.

    Email Routing Process:
    1. DNS Lookup: The sender’s MTA queries DNS for the recipient’s domain (e.g., `recipient@domain.com`).
    2. MX Record Resolution: DNS returns MX records for `domain.com`, ordered by preference.
    3. Connection Attempt: The sender’s MTA connects to the highest-priority MX server (e.g., `mail1.example.com` on port 25).
    4. SMTP Handshake: If the connection fails, the MTA retries with the next MX server in the list.

    Hypothetical Example:
    Consider sending an email to `user@company.org`. The DNS lookup for `company.org` returns:

    1. MX Record: `10 mail.company.org` (priority 10).
    2. MX Record: `20 backup-mail.company.org` (priority 20).
    The sender’s MTA first attempts to deliver the email to `mail.company.org`. If this server is unreachable, it proceeds to `backup-mail.company.org`.

    Key Considerations:

  • Multiple MX Records: Redundancy ensures deliverability even if primary servers fail.
  • SPF and DMARC: MX records interact with Sender Policy Framework (SPF) and Domain-based Message Authentication, Reporting & Conformance (DMARC) to prevent spoofing.
  • A Records as Fallback: If no MX records exist, the MTA uses the domain’s A record (IPv4) or AAAA record (IPv6) to route emails.

    • Email Encryption Methods

    Email encryption protects data during transmission (in-flight) and

    Email Formats, Standards, and Protocols

    Email communication relies on standardized formats and protocols to ensure interoperability, security, and efficient transmission across diverse systems. The structure of an email message adheres to RFC 5322, defining mandatory fields such as sender, recipient, and subject, while optional fields like carbon copy (CC) and blind carbon copy (BCC) enhance routing flexibility. Protocols like SMTP, IMAP, and POP3 govern message delivery, retrieval, and storage, while MIME extends functionality by enabling attachments, multimedia, and non-ASCII text. This section examines the technical specifications governing email formats, their metadata roles, and the protocols underpinning modern email systems.

    Structure of an Email Message According to RFC 5322

    The RFC 5322 standard defines the syntax for email message headers and bodies, ensuring consistency across email clients and servers. An email consists of two primary components: the header (metadata) and the body (content). The header includes mandatory fields such as `From:`, `To:`, and `Subject:`, while optional fields like `CC:`, `BCC:`, and `Reply-To:` refine recipient handling and response management.

    Mandatory Fields:

  • `From:` – Specifies the sender’s email address.
  • `To:` – Lists primary recipients.
  • `Subject:` – Describes the email’s purpose.
  • `Date:` – Indicates when the email was sent (format: `DD Mon YYYY HH:MM:SS +ZZZZ`).
  • `Message-ID:` – A unique identifier for tracking and referencing the email.

    • Optional Fields:

  • `CC:` – Carbon copies for secondary recipients.
  • `BCC:` – Blind carbon copies to hide recipients from others.
  • `Reply-To:` – Overrides the default reply address.
  • `In-Reply-To:` – References a parent email in threaded conversations.
  • `References:` – Lists message IDs to establish conversation threads.

    • Example Header Metadata:

    From: sender@example.com
    To: recipient@example.org
    Subject: Project Update - Q3 2024
    Date: Mon, 1 Oct 2024 14:30:00 +0000
    Message-ID: Received: from mail.example.com (mail.example.com [192.0.2.1])
    by mx.google.com with SMTP;
    1 Oct 2024 14:30:01 -0000 (UTC)

    The `Received` lines document the email’s transmission path, aiding in debugging and spam analysis. Each hop (server relay) appends a `Received` entry, creating a trail of IP addresses and timestamps.

    Email Content Types and Security Considerations

    Email messages support multiple content formats, primarily plaintext, HTML, and multipart (combining both). Plaintext emails are universally compatible but lack formatting options, while HTML emails enable rich media but introduce security risks such as phishing, XSS (Cross-Site Scripting), and malicious attachments.

    Content Type Use Cases:

  • Plaintext (`text/plain`) – Default for compatibility; used in legacy systems or security-sensitive environments.
  • HTML (`text/html`) – Supports styling, images, and interactive elements; preferred for marketing and newsletters.
  • Multipart (`multipart/alternative` or `multipart/mixed`) – Delivers both plaintext and HTML versions or combines attachments with the message body.

    • Security Risks in HTML Emails:

  • Embedded Scripts: JavaScript in HTML emails can execute malicious code if rendered.
  • CSS/Style Injection: Attackers manipulate styling to disguise phishing links.
  • Attachment Exploits: Malicious scripts in attached files (e.g., `.js`, `.exe`) bypass email filters.

    • Mitigation Strategies:

  • Sanitize HTML Content: Strip scripts and unsafe tags via email gateways.
  • Disable External Content: Block embedded images/links from untrusted domains.
  • Use Digital Signatures (S/MIME or DKIM): Verify sender authenticity and message integrity.

    • Role of MIME in Email Extensibility

    The Multipurpose Internet Mail Extensions (MIME) protocol, defined in RFC 2045–2049, extends email beyond ASCII text to support:
  • Attachments (files encoded as `application/octet-stream`).
  • Non-ASCII Text (e.g., UTF-8 for Unicode characters).
  • Multimedia (images, audio, video via `image/jpeg`, `audio/mpeg`).
  • Encapsulated Messages (nested emails or forwarded content).

    • MIME Structure Example:

    Content-Type: multipart/mixed; boundary="boundary123"
    --boundary123
    Content-Type: text/plain; charset=UTF-8
    Content-Transfer-Encoding: base64

    SGVsbG8gV29ybGQh
    --boundary123
    Content-Type: application/pdf; name="report.pdf"
    Content-Transfer-Encoding: base64
    Content-Disposition: attachment; filename="report.pdf"

    JVBERi0xLjQK... (Base64-encoded PDF data)
    --boundary123--

    MIME uses boundaries to segment multipart messages and Content-Transfer-Encoding (e.g., `base64`, `quoted-printable`) to encode binary data for ASCII-safe transmission.

    Common Email Protocols and Their Technical Specifications

    Email systems rely on standardized protocols for transmission, retrieval, and authentication. Below is a comparative table of key protocols, their ports, functions, and security features:
    Protocol Port(s) Primary Function Security Features
    SMTP (Simple Mail Transfer Protocol) 25 (unencrypted), 465 (SMTPS), 587 (Submission) Transmits emails between servers; used for sending and relaying.
    • TLS/SSL Encryption: Secures data in transit (SMTPS on port 465).
    • STARTTLS: Upgrades unencrypted SMTP (port 25) to TLS.
    • SPF/DKIM/DMARC: Authentication mechanisms to prevent spoofing.
    IMAP (Internet Message Access Protocol) 143 (unencrypted), 993 (IMAPS) Retrieves and manages emails on a server; supports folders, flags, and offline sync.
    • TLS Encryption: IMAPS (port 993) encrypts all communications.
    • Authentication: SASL mechanisms (e.g., CRAM-MD5, OAuth2).
    • IDLE Command: Enables real-time notifications (requires TLS).
    POP3 (Post Office Protocol v3) 110 (unencrypted), 995 (POP3S) Downloads emails to a local device; simple but lacks sync capabilities.
    • TLS Encryption: POP3S (port 995) secures the connection.
    • APOP Authentication: Prevents replay attacks via challenge-response.
    • Limited Use Case: Not recommended for shared devices due to lack of server-side management.
    DNS (Domain Name System) 53 (TCP/UDP) Resolves domain names to IP addresses; critical for MX record lookup in email routing.