What is security about? The CIA triad

Computer security has three main goals. Together they are called the CIA triad.

• Confidentiality — only the right people can read the data. Example: your exam result should be visible only to you, not to strangers.
• Integrity — the data is not changed by anyone in a wrong way. Example: nobody should be able to change your bank balance from 5000 to 500.
• Availability — the system works when you need it. Example: the bank website should be up when you want to pay a bill.

Every attack breaks at least one of these. Reading someone's private email breaks confidentiality. Changing a file secretly breaks integrity. Crashing a server breaks availability.

Basic terms

• Plaintext — the original readable message. Example: "HELLO".
• Ciphertext — the scrambled, unreadable message. Example: "KHOOR".
• Key — the secret value used to scramble and unscramble.
• Encryption — plaintext + key → ciphertext.
• Decryption — ciphertext + key → plaintext.
• Cryptanalysis — trying to break a cipher without knowing the key.

In math form, with encryption function \(E\) and decryption function \(D\):

Caesar cipher — the simplest cipher

The Caesar cipher shifts every letter by a fixed number. With shift \(k\), letter position \(P\) becomes:

Vigenère cipher (briefly)

The Caesar cipher uses one shift for all letters. The Vigenère cipher uses a keyword, so different letters get different shifts. The key repeats over the message.

Substitution vs Transposition

Classical ciphers work in two basic ways:

• Substitution — replace each letter with another letter. The letters change, their positions stay. Caesar and Vigenère are substitution ciphers.
• Transposition — rearrange the positions of letters. The letters stay the same, their order changes. Example: write "ATTACK" in 2 columns and read column by column: A T T A C K → columns (A,T,C) and (T,A,K) → "ATCTAK".

Modern ciphers like AES mix both ideas many times (this is called confusion and diffusion).

Kerckhoffs' principle

Kerckhoffs' principle: a cipher must stay secure even if the attacker knows everything about the algorithm — the only secret should be the key. Why? Algorithms leak, get published, or are reverse engineered. Keys can be changed easily; algorithms cannot. "Security through obscurity" (hiding the algorithm) is considered bad design.

Brute force attack

A brute force attack tries every possible key one by one. Defense is simple: make the key space huge.

• Caesar cipher: only 25 useful shifts → broken in seconds by hand.
• DES: \(2^{56}\) keys → breakable with modern hardware.
• AES-128: \(2^{128}\) keys → far too many to try; safe against brute force.

The shared-key idea

In symmetric encryption, the sender and the receiver use the same secret key. Think of a box with one lock: the same key locks it and unlocks it. Alice encrypts with key \(K\), Bob decrypts with the same \(K\).

Symmetric ciphers are very fast, so they are used for encrypting big data: files, disk drives, video streams, most of the traffic on the internet.

Block ciphers vs stream ciphers

• Block cipher — encrypts data in fixed-size chunks (blocks). AES uses 128-bit blocks. If the message is bigger, it is cut into blocks; if the last block is short, it is padded.
• Stream cipher — generates a stream of key bits (keystream) and XORs it with the data bit by bit or byte by byte. Good for live data like voice calls. Examples: RC4 (old, now broken), ChaCha20 (modern).

DES — a brief history

DES (Data Encryption Standard) was the US standard from 1977. It is a block cipher: 64-bit blocks, 56-bit key, 16 rounds of mixing (a Feistel structure). By the late 1990s, computers became fast enough to brute force \(2^{56}\) keys — a special machine broke DES in days. A patch called 3DES (Triple DES) runs DES three times with different keys, but it is slow. So a new standard was chosen.

AES — the current standard

AES (Advanced Encryption Standard), chosen in 2001 (the Rijndael algorithm), is today's standard block cipher.

• Block size: always 128 bits.
• Key sizes: 128, 192, or 256 bits.
• Rounds: 10 rounds (128-bit key), 12 rounds (192-bit), 14 rounds (256-bit).

Each round mixes the data with substitution (SubBytes — an S-box), permutation (ShiftRows, MixColumns), and the key (AddRoundKey). Many rounds of small mixing make the output look totally random.

Modes of operation: ECB vs CBC

A block cipher only knows how to encrypt one block. A mode of operation says how to handle many blocks.

• ECB (Electronic Codebook) — encrypt each block separately: \(C_i = E_K(P_i)\). Problem: the same plaintext block always gives the same ciphertext block. Patterns in the data stay visible in the ciphertext.
• CBC (Cipher Block Chaining) — XOR each plaintext block with the previous ciphertext block first: \(C_i = E_K(P_i \oplus C_{i-1})\), starting with a random IV (initialization vector). Now identical plaintext blocks give different ciphertext blocks, so patterns disappear.

The key distribution problem

Symmetric encryption has one big weakness: both sides must already share the secret key. How do you send the key safely? If you send it over the network, an attacker may grab it. Meeting in person does not scale.

Also, keys grow fast. If \(n\) people all want private pairwise channels, each pair needs its own key:

The public/private key idea

In asymmetric encryption (also called public-key cryptography), every person has two keys:

• Public key — shared with everyone. Used to encrypt messages sent to you.
• Private key — kept secret. Used to decrypt messages you receive.

Mailbox analogy: your public key is like the slot of your mailbox. Anyone can drop a letter in (encrypt). But only you have the key to open the box and read the letters (decrypt with the private key).

The magic: the two keys are mathematically linked, but knowing the public key does not let you compute the private key (in a practical amount of time). This kills the key distribution problem — you never need to share a secret in advance.

RSA — how it works

RSA (Rivest–Shamir–Adleman, 1977) is the most famous asymmetric algorithm. Its safety comes from one hard math fact: multiplying two big primes is easy, but factoring the product back into the primes is extremely hard.

Key generation steps (memorize this order):

1. Choose two primes \(p\) and \(q\).
2. Compute \(n = p \times q\). This \(n\) is the modulus.
3. Compute Euler's totient: \(\varphi(n) = (p-1)(q-1)\).
4. Choose public exponent \(e\) with \(1 < e < \varphi(n)\) and \(\gcd(e, \varphi(n)) = 1\).
5. Find private exponent \(d\) such that \(e \times d \equiv 1 \pmod{\varphi(n)}\).

Public key = \((e, n)\). Private key = \((d, n)\). Then:

Diffie-Hellman key exchange

Diffie-Hellman (DH) solves a different problem: two people build a shared secret over a public channel, without ever sending the secret itself. It is used to agree on a symmetric key.

Setup: everyone agrees on a public prime \(p\) and a base \(g\). Then:

1. Alice picks secret \(a\), sends \(A = g^a \bmod p\).
2. Bob picks secret \(b\), sends \(B = g^b \bmod p\).
3. Alice computes \(S = B^a \bmod p\). Bob computes \(S = A^b \bmod p\).
4. Both get the same \(S = g^{ab} \bmod p\) — the shared secret.

An eavesdropper sees \(p, g, A, B\) but cannot find \(a\) or \(b\) — that would need solving the discrete logarithm problem, which is very hard for big numbers.

Paint analogy: both start with the same public color. Each mixes in a private color and swaps the mixture. Each then adds their private color again. Both end with the same final color, but an observer who saw only the mixtures cannot un-mix the paint.

Symmetric vs Asymmetric — comparison

Hybrid encryption — best of both

Real systems use both together. Asymmetric crypto is slow, so we do not encrypt whole files with RSA. Instead:

1. Generate a random symmetric session key.
2. Encrypt the big data with the session key (fast AES).
3. Encrypt only the small session key with the receiver's public key (RSA).
4. Send both. The receiver unlocks the session key with the private key, then decrypts the data.

This is exactly how HTTPS/TLS, PGP email, and most secure systems work.

What is a hash function?

A cryptographic hash function takes any input (a message, a file of any size) and produces a fixed-size output called the hash or digest. Example: SHA-256("hello") is always the same 256-bit value.

Key properties:

• Deterministic — same input always gives the same hash.
• Fast — quick to compute for any input.
• One-way (preimage resistance) — given a hash, you cannot find the input. There is no "decrypt" for a hash.
• Collision resistance — it is practically impossible to find two different inputs with the same hash.
• Avalanche effect — change one bit of the input and about half of the output bits flip. "hello" and "hellp" give totally different hashes.

Common hash functions

Password storage and salting

Servers must never store passwords as plaintext. They store the hash of the password. At login, the server hashes what you typed and compares hashes.

But attackers precompute hashes of common passwords (rainbow tables). The fix is a salt: a random value added to each password before hashing.

stored = hash(salt + password)   // salt is random, stored next to the hash

• Same password + different salts → different hashes. Precomputed tables become useless.
• Two users with the same password get different stored hashes.
• Real systems also use slow hashes (bcrypt, scrypt, Argon2) so brute forcing each guess is expensive.

MAC — Message Authentication Code

A plain hash proves nothing about who sent the message — anyone can hash. A MAC mixes a shared secret key into the hash: \( \text{MAC} = H(K, M) \). Only someone who knows \(K\) can produce or verify the MAC. It gives integrity + authenticity between two parties who share a key. HMAC (e.g., HMAC-SHA256) is the standard construction.

Digital signatures

A digital signature is like a handwritten signature, but unforgeable and tied to the exact document. The trick: use the asymmetric keys in the opposite direction from encryption.

1. Sign: the sender hashes the message, then encrypts the hash with their private key. That encrypted hash is the signature.
2. Verify: the receiver decrypts the signature with the sender's public key to get hash₁, hashes the received message to get hash₂, and checks hash₁ = hash₂.

If they match: the message came from the private-key owner (authenticity), was not changed (integrity), and the sender cannot deny sending it (non-repudiation).

Signature vs encryption — direction matters:

• Encryption for secrecy: encrypt with receiver's public key → decrypt with receiver's private key.
• Signature for proof: sign with sender's private key → verify with sender's public key.

Certificates and the CA chain (briefly)

One question remains: how do you know a public key really belongs to "bob.com" and not to an attacker? A digital certificate answers this. It is a document saying "this public key belongs to bob.com", signed by a trusted third party called a Certificate Authority (CA).

• Your browser ships with a list of trusted root CAs.
• A root CA signs an intermediate CA's certificate; the intermediate signs the website's certificate. This is the chain of trust.
• The browser verifies each signature up the chain to a trusted root. If any link fails, you see a certificate warning.

Authentication — proving who you are

Authentication means proving your identity to a system. There are three classic factors:

• Something you know — password, PIN, security question.
• Something you have — phone (OTP app/SMS), smart card, hardware token.
• Something you are — biometrics: fingerprint, face, iris, voice.

Two-factor authentication (2FA) combines two different factors — for example password (know) + OTP on phone (have). Even if the password leaks, the attacker still cannot log in. Password + security question is NOT 2FA — both are "something you know".

Password best practice: long passphrases beat short complex ones; unique password per site; use a password manager; server side, store salted slow hashes (previous section).

Biometrics: convenient, hard to forge, but they have false accepts/rejects, and you cannot change your fingerprint if the template leaks. Best used as one factor among several.

Authentication vs Authorization

• Authentication — who are you? (login step)
• Authorization — what are you allowed to do? (permission step, after login)

Example: you log into the university portal (authentication). Then a student can view grades but only a teacher can edit them (authorization). Authentication always happens first.

Access control models: DAC, MAC, RBAC

ACL vs Capabilities

Think of the access control matrix: rows = users, columns = resources. Two ways to store it:

• ACL (Access Control List) — stored per resource (column): "file report.txt: Alice can read+write, Bob can read." Easy question: "who can access this file?"
• Capability list — stored per user (row): "Alice holds tickets for: report.txt (rw), photo.png (r)." Easy question: "what can Alice access?" A capability is like a movie ticket — holding it is the permission.

Principle of least privilege

Give every user and every program the minimum access needed to do its job — nothing more. A web server does not need to read user home directories; an intern does not need admin rights. If something is compromised, the damage stays small. Related idea: defense in depth — use several layers of protection so one failure does not sink the whole system.

Malware types

Malware = malicious software. Know the difference between the main types — exams love this table.

Phishing and social engineering

Social engineering attacks the human, not the machine — tricking people into giving up secrets. Phishing is the most common form: a fake email or website that looks real (e.g., "your bank" asking you to "verify" your password). Spear phishing targets a specific person with personalized details.

Defense: check the real sender address and URL, never enter credentials from an email link, enable 2FA (so a stolen password alone fails), and train users. Organizations run awareness training because no firewall can stop a user who is tricked.

DoS and DDoS

A Denial of Service (DoS) attack floods a server with so many requests (or such heavy requests) that real users cannot be served — it attacks availability. A DDoS (Distributed DoS) does this from thousands of hijacked machines (a botnet) at once, which is much harder to block because there is no single source to filter.

Defense: rate limiting, traffic filtering, load balancers, and large CDN/scrubbing services that absorb and clean the traffic.

Man-in-the-middle (MITM)

An attacker secretly sits between two parties, relaying (and possibly changing) their messages. Both sides think they talk directly. Example risk: open public Wi-Fi where the attacker controls the access point.

Defense: authenticated encryption — HTTPS/TLS with certificates. The certificate check is exactly what stops an attacker from pretending to be the server. This is also why plain Diffie-Hellman needs signatures/certificates.

DHCP starvation

Remember: a DHCP server hands out IP addresses to devices that join a network, and it only has a limited pool of addresses. In a DHCP starvation attack, the attacker sends a flood of DHCP DISCOVER requests, each with a different spoofed (fake) MAC address. The server thinks many new devices are joining and reserves an IP for each fake one. Soon the whole address pool is empty — real clients ask for an IP and get nothing, so they cannot use the network. It is a DoS attack on the DHCP service (an attack on availability).

It gets worse: the attacker often pairs this with a rogue DHCP server. Once the real server is starved, the attacker's fake server answers the clients instead — handing out attacker-controlled settings like a malicious gateway or DNS server. Now the attacker sits in the middle of everyone's traffic (a MITM setup).

Defense: at the switch level. DHCP snooping lets the switch mark which ports may carry DHCP server replies (trusted ports) and drops fake server replies from other ports. Port security limits how many MAC addresses one switch port may use, so one port cannot pretend to be thousands of devices.

SQL injection

A web form asks for a username. The server builds a query by gluing strings:

query = "SELECT * FROM users WHERE name = '" + input + "'";

If the input contains SQL syntax (like a quote character), the data becomes part of the command — the attacker's text is executed as SQL. This can leak or destroy the whole database. It breaks the rule: never mix code and data.

Why parameterized queries fix it: a parameterized (prepared) statement sends the SQL command and the data separately:

stmt = prepare("SELECT * FROM users WHERE name = ?");
stmt.bind(1, input);   // input is ALWAYS treated as pure data

The database compiles the query structure first, then plugs the input in as a pure value. Whatever the user types, it can never change the query's structure. Extra layers: input validation and least-privilege database accounts.

XSS — Cross-Site Scripting

XSS is the same "code mixed with data" mistake, but in the browser. A site shows user-submitted content (like a comment) without cleaning it. If the comment contains a script tag, other visitors' browsers run it — it can steal their cookies/sessions.

Defense: escape/encode output (so < is shown as text, not parsed as HTML), validate input, and set a Content Security Policy (CSP). Frameworks like React escape output by default.

Firewalls

A firewall sits between networks and decides which traffic may pass, based on rules.

• Packet-filtering firewall — checks each packet alone: source/destination IP, port, protocol. Fast, simple, but has no memory of connections.
• Stateful firewall — remembers active connections; allows replies that belong to a connection you started, blocks unexpected packets. This is the common modern type.
• Application-layer firewall / WAF — understands the application protocol (e.g., HTTP) and can block things like SQL injection patterns.

IDS and IPS

• IDS (Intrusion Detection System) — watches traffic/logs and raises an alarm when it sees an attack. It does not block.
• IPS (Intrusion Prevention System) — sits inline and blocks the attack traffic automatically.

Detection styles: signature-based (matches known attack patterns; misses new attacks) vs anomaly-based (flags unusual behavior; can catch new attacks but gives false positives).

VPN

A VPN (Virtual Private Network) builds an encrypted tunnel between your device and a VPN server. All your traffic travels inside the tunnel, so people on the local network (like café Wi-Fi) see only encrypted data going to the VPN server. Companies use VPNs so remote employees can reach the office network as if they were inside it.

SSL/TLS handshake (overview)

TLS (the modern name for SSL) is the protocol behind HTTPS. It combines almost everything in this chapter. Simplified handshake:

1. Hello: client and server agree on TLS version and cipher suite; they exchange random values.
2. Certificate: the server sends its certificate. The client verifies the CA chain — this authenticates the server.
3. Key exchange: using Diffie-Hellman (or the server's RSA key), both sides derive a shared session key.
4. Secure channel: all further data is encrypted with fast symmetric encryption (e.g., AES) plus integrity protection (MAC/AEAD).

So: certificates + signatures give authenticity, DH gives the shared key, AES gives speed — the hybrid model in action.