HTTPS (Hypertext Transfer Protocol Secure) fundamentally relies on TCP (Transmission Control Protocol) as its transport layer protocol. This is a crucial architectural decision that affects everything from connection reliability to performance characteristics.

The TCP protocol provides several essential features that make it ideal for HTTPS:

// Example of TCP's three-way handshake in HTTPS
1. SYN - Client initiates connection
2. SYN-ACK - Server acknowledges
3. ACK - Connection established
4. TLS handshake begins

While traditional HTTPS uses TCP, the emerging HTTP/3 specification introduces QUIC (Quick UDP Internet Connections) which operates over UDP:

// Sample UDP packet structure for QUIC
typedef struct {
    uint8_t flags;
    uint64_t connection_id;
    uint32_t packet_number;
    uint8_t payload[];
} quic_packet;

TCP's reliability comes at a cost:

• Head-of-line blocking in TCP can impact performance
• TCP requires more round trips for connection establishment
• QUIC over UDP can provide better performance for mobile scenarios

When implementing HTTPS solutions, developers should consider:

// Python example showing socket preference
import socket

# Traditional HTTPS/TCP socket
tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# HTTP/3 would use UDP
# udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

For troubleshooting HTTPS connections:

// Using openssl to inspect TCP-based HTTPS
openssl s_client -connect example.com:443 -showcerts

// For QUIC (HTTP/3) debugging
curl --http3 https://example.com -v

When implementing secure web communication, one fundamental question arises: does HTTPS operate over TCP or UDP? This choice directly impacts connection reliability, performance characteristics, and implementation details for developers working with web protocols.

HTTPS (HTTP Secure) exclusively uses TCP (Transmission Control Protocol) as its transport layer protocol. This design decision stems from several critical requirements of secure web communication:

// Example of HTTPS connection in Node.js
const https = require('https');
const fs = require('fs');

const options = {
  key: fs.readFileSync('server.key'),
  cert: fs.readFileSync('server.cert')
};

https.createServer(options, (req, res) => {
  res.writeHead(200);
  res.end('HTTPS connection established over TCP');
}).listen(443);

The TCP protocol provides three essential features that HTTPS requires:

• Reliable delivery: Ensures all packets arrive in order
• Connection-oriented: Establishes a stable session for TLS handshake
• Flow control: Manages data transmission rates

While HTTPS doesn't use UDP, some related protocols do:

// QUIC protocol example (HTTP/3 over UDP)
const quic = require('node-quic');
quic.listen(4433, (socket) => {
  socket.on('stream', (stream) => {
    stream.write('HTTP/3 uses UDP via QUIC');
    stream.end();
  });
});

The TCP handshake (SYN-SYN/ACK-ACK) combined with TLS negotiation creates latency. HTTP/3 (QUIC) addresses this by using UDP, but traditional HTTPS remains TCP-based:

When working with HTTPS:

1. TCP port 443 must be open in firewalls
2. Connection pooling is more effective than with UDP
3. Keep-alive headers reduce handshake overhead

# Python HTTPS client example
import requests

response = requests.get('https://example.com', verify=True)
print(response.text)  # Underlying TCP connection managed automatically

Common tools for examining HTTPS/TCP traffic:

• Wireshark (with TLS decryption)
• tcpdump
• openssl s_client

# Using openssl to inspect TCP connection
openssl s_client -connect example.com:443 -showcerts