Introduction to Cryptography: Lecture 1 by Christof Paar

Asymmetric cryptography uses pairs of public and private keys for secure communication. Diffie-Hellman key exchange (1976) allows two parties to establish a shared symmetric key over insecure channels without transmitting the key directly. Each party combines their private key with the other's public key to derive the same symmetric key. RSA (1977) by Rivest, Shamir, and Adelman uses large prime numbers for encryption, decryption, and digital signatures. DSA modifies Diffie-Hellman for digital signatures and is FIPS-compliant. These protocols form the foundation of modern secure communications, enabling secure key establishment and authentication without prior shared secrets.

Asymmetric cryptography enables secure communication through key pairs generated from large random numbers and prime values. The encryption process involves obtaining a recipient's public key, combining plaintext with it to create ciphertext, and decrypting using the corresponding private key. Diffie-Hellman key exchange allows parties to establish identical symmetric keys without transmitting them directly by combining private and public keys on both sides. This hybrid approach solves the fundamental key distribution problem that symmetric encryption alone cannot address, forming the basis of modern internet security protocols.

Public key cryptography enables secure communication between parties who have never met before by using asymmetric encryption where different keys are used for encryption and decryption; the Diffie-Hellman key exchange allows two parties to establish a shared secret key over an insecure channel through modular arithmetic, while RSA provides a practical implementation using prime factorization as a one-way function that makes it computationally infeasible to derive the private key from the public key.

Asymmetric encryption uses mathematically related key pairs - a public key that can be shared openly and a private key that must be kept secret. Data encrypted with the public key can only be decrypted with the corresponding private key, eliminating the need for secure key exchange. The Diffie-Hellman key exchange allows two parties to establish a shared secret key over an insecure channel by each generating a public-private key pair, exchanging public keys, and computing the shared secret using their private key and the other party's public key. This protocol is based on the difficulty of computing discrete logarithms. RSA is another public-key encryption algorithm based on the difficulty of factoring large numbers, using modular exponentiation for encryption and decryption.

Symmetric key cryptography requires a unique shared secret for each pair of communicating parties, which becomes impractical for large-scale systems (100 million users would require ~5 trillion keys). This scalability problem motivated asymmetric cryptography, which uses public-private key pairs. Diffie-Hellman allows two parties to establish a shared secret over an insecure channel using public parameters (prime P, generator G). Each party generates a private random number, computes a public value (G^private mod P), and exchanges these values. Each party then raises the received value to their own private exponent, resulting in the same shared secret. RSA uses large prime numbers to create public-private key pairs where the public key encrypts and the private key decrypts. RSA key generation: (1) Select two large random primes p and q, (2) Compute n = p × q (modulus), (3) Compute φ(n) = (p-1)(q-1), (4) Choose public exponent e coprime to φ(n), (5) Compute private exponent d such that e × d ≡ 1 (mod φ(n)). RSA encryption: C = M^e mod n. RSA decryption: M = C^d mod n. Correctness relies on Euler's theorem: a^φ(n) ≡ 1 (mod n) for a coprime to n. RSA is computationally expensive due to modular exponentiation with large numbers, making it unsuitable for encrypting large data directly. Instead, RSA exchanges a symmetric session key, which is then used for efficient data encryption. Key strength is measured by effective search space: RSA 1024-bit keys provide ~80 bits of security (due to factoring difficulty), while AES-256 provides 256 bits. RSA keys must be much longer than symmetric keys for equivalent security. Current recommendations suggest RSA 2048-bit keys for adequate security.

Message Authentication Codes (MACs) are cryptographic mechanisms that ensure data integrity and authenticity by generating a fixed-length tag from a message and secret key, allowing recipients to verify that a received message has not been modified during transmission; MACs defeat adaptive chosen ciphertext attacks by making most ciphertexts invalid without the secret key, and they prevent padding oracle attacks by ensuring decryption never proceeds when the authentication tag is invalid, thereby protecting against ciphertext modification vulnerabilities that exist in encryption-only systems.

Message authentication verifies message authenticity and integrity through three approaches: (1) Message encryption-based authentication uses symmetric encryption where successful decryption proves sender identity; (2) Message Authentication Codes (MAC) generate fixed codes from messages and secret keys using MAC algorithms; (3) Hash functions generate message digests (digital fingerprints) for integrity verification. MD5 produces 128-bit digests through 64 rounds of processing with logical functions and modular addition, while SHA-1 produces 160-bit digests through 80 rounds. Both have been cryptographically weakened but remain useful for file integrity checking. HMAC combines hash functions with secret keys for authenticated integrity. The choice depends on security requirements and performance needs.

Hash functions provide integrity against random errors but not against malicious attackers who can modify both the message and its hash. Message Authentication Codes (MAC) provide both integrity and authentication by using a shared secret key. A MAC consists of a generation function (key + message → tag) and a verification function (key + message + tag → valid/invalid). Secure MACs must resist adaptive chosen-message attacks, where attackers can request tags for messages of their choice and then attempt to forge a tag for a new message. The unforgeability property ensures that even with unlimited access to valid message-tag pairs, attackers cannot produce valid tags for messages they did not previously request.

This section covers two fundamental cryptographic techniques for ensuring message integrity and authenticity. Message Authentication Codes (MACs) use a shared secret key to generate a small data block appended to messages, allowing receivers to verify authenticity without encryption. One-way hash functions transform variable-length messages into fixed-size digests without secret keys, offering three authentication methods: conventional encryption, public key encryption, and secret value appending. Both approaches rely on computational irreversibility—unlike encryption algorithms, MAC and hash functions cannot derive original inputs from outputs. These techniques form the foundation of secure communication protocols where data integrity must be verified while maintaining confidentiality.

A Message Authentication Code (MAC) combines hash functions with symmetric cryptography to verify both data integrity and authenticity. The sender computes the MAC using a shared secret key known only to the sender and receiver, then sends both the message and MAC. The receiver recomputes the MAC using the same key and compares it with the received MAC. If they match, the message is authentic and unmodified. Unlike simple hash functions, MACs prevent replay attacks because the shared secret key is required to generate a valid MAC, ensuring only authorized parties can produce valid authentication codes.

Secure communication protocols include: (1) SSL/TLS for establishing encrypted web connections, where students can examine packets to understand how secure tunnels are set up, (2) SSH for authenticating remote connections, and (3) IPsec for VPN-type protocols. These protocols implement the cryptographic concepts discussed in the module to provide practical secure communication channels. Understanding these protocols is essential for implementing real-world security solutions.

Secure communication protocols implement cryptographic principles to protect data across networks. TLS (Transport Layer Security) secures web communications through asymmetric key exchange followed by symmetric encryption, protecting against eavesdropping, tampering, and forgery. It evolved from SSL through versions 1.0 to 1.3, with TLS 1.3 reducing handshake round trips and eliminating outdated algorithms. IPsec (Internet Protocol Security) secures IP communications by authenticating and encrypting each packet, operating in two phases: Phase 1 negotiates Security Associations (SAs) for secure channel establishment, while Phase 2 secures actual data traffic using ESP or AH for confidentiality, integrity, and authenticity. SSH (Secure Shell) enables secure remote access through four phases: connection establishment, key exchange, host authentication (preventing man-in-the-middle attacks), user authentication (passwords or public key), and encrypted session creation. These protocols collectively secure web transactions, virtual private networks, and remote system administration across modern networks.

TLS (Transport Layer Security) uses three primary cryptographic primitives to secure internet communications: (1) Key exchange, which establishes a shared session key between two parties; (2) Digital signatures, which provide authentication to verify the identity of communicating parties; and (3) Symmetric encryption, which uses the established key to encrypt data over the insecure internet channel.

SSL/TLS (used for HTTPS) and SSH (Secure Shell) are protocols that implement public and private key cryptography to secure internet communications. SSL/TLS encrypts web traffic between browsers and servers, while SSH provides secure remote command-line access to computers. Both protocols use key exchange to establish secure sessions, then use symmetric encryption for efficient data transfer. These protocols protect against eavesdropping and man-in-the-middle attacks.

Security protocols protect data transmission: (1) SSL/TLS (Secure Socket Layer/Transport Layer Security) - encrypts data for secure transmission, (2) IPsec (Internet Protocol Security) - authenticates and encrypts IP packets, (3) SSH (Secure Shell) - enables secure remote login and command execution. These protocols ensure data confidentiality and integrity during transmission.