A modern computer runs programs written by many different people, used by many different users, and connected to a network full of strangers. If any program could read any file, overwrite any memory or grab any device, one buggy or malicious program could destroy everything. The operating system's job is to make sure that every process can touch only what it is allowed to touch.
This chapter covers both halves of that job. Protection is about the internal mechanisms that control access: dual mode, memory protection, protection domains, the access matrix, ACLs and capabilities, and Unix permissions (which we will try on a real Linux system). Security is about defending against attackers: authentication, passwords, malware, buffer overflows and the defences modern systems use against them.
Protection vs Security
These two words are often used interchangeably, but in OS textbooks they mean different things.
Protection | Security |
|---|---|
An internal problem: controlling which processes and users may access which resources | An external problem: defending the system against attacks and misuse |
Provides the mechanisms (permission bits, page protection, privileged instructions) | Uses those mechanisms plus authentication, encryption, auditing and good policy |
Assumes we know who the user is | Must first establish who the user is (authentication) |
Example: a process cannot write into another process's memory | Example: an attacker guesses a weak password and logs in as you |
Protection is the mechanism for controlling the access of processes and users to the resources of a computer system. Security is the measure of confidence that the integrity of the system and its data will be preserved against threats.
Perfect protection is useless if an attacker steals the administrator's password, because then the attacker is an authorised user as far as the protection system knows. That is why we need both.
Goals and Principles of Protection
Mechanism vs Policy
A mechanism says how something is enforced (for example, the kernel checks permission bits on every open()). A policy says what is allowed (for example, "students may read the course folder but not write it"). A good OS provides general mechanisms so that administrators and users can set different policies without changing the kernel.
Principle of Least Privilege
Every program, user and system component should run with the minimum privileges it needs to do its job, and for the shortest possible time.
Why? Because bugs happen. If a web server runs as root and gets hacked, the attacker owns the whole machine. If it runs as an ordinary user that can only read the website folder, the damage is limited. Closely related is the need-to-know principle: at any moment a process should be able to access only the objects it currently needs.
Other classic design principles (from Saltzer and Schroeder): fail-safe defaults (deny unless explicitly allowed), complete mediation (check every access, not just the first one), economy of mechanism (keep security code small and simple), and separation of privilege (require more than one condition, such as password plus OTP).
Hardware Foundations of Protection
Software protection is built on a few hardware features you have already met:
Dual-mode operation (see OS Structure & Kernel): privileged instructions, such as disabling interrupts, changing page tables or doing port I/O, work only in kernel mode. A user program that tries one gets a trap.
Memory protection (see Memory Management Basics and Paging): base/limit registers or page tables make sure a process can only reach its own memory. Each page-table entry also has bits such as read/write, user/supervisor and no-execute.
Timer: the kernel sets a timer interrupt before giving the CPU to a process, so a process with an infinite loop cannot keep the CPU forever (this is what makes Round Robin Scheduling possible).
Protected I/O (see I/O Systems): I/O instructions are privileged and device registers are not mapped into user address spaces, so all I/O goes through system calls where the kernel can check permissions.
Together these give the kernel a place to check every access. Everything else in this chapter is about what the kernel checks.
Domains of Protection
To talk precisely about "who may do what", textbooks use three terms:
Object: anything that needs protecting. Hardware objects (CPU, memory segments, printer, disk) and software objects (files, programs, semaphores).
Access right: an operation allowed on an object, such as read, write, execute or print.
Domain: a set of
<object, {rights}>pairs. A process always executes inside some domain, and can do exactly what its domain allows.
For example, the domain D1 = { <F1, {read}>, <F2, {read, write}> } means a process in D1 may read F1, and read or write F2, and nothing else.
A domain can be a user, a process, or even a procedure. In Unix, the domain is essentially the user ID (and group IDs) of the process. A process running as imran gets all the rights of user imran.
Associations can be static (a process stays in one domain forever) or dynamic (a process can switch domains). Dynamic switching is what lets us follow least privilege: stay in a weak domain normally and enter a stronger one only for a specific task. Examples:
A system call switches from user mode to kernel mode (the simplest two-domain system).
Running a setuid program in Unix switches the effective user ID to the owner of the program for the duration of that program (we will see this with
passwdbelow).sudoruns one command in the root domain after checking that you are allowed to.
The Access Matrix
The access matrix is the general model of protection. Rows are domains, columns are objects, and the entry access(i, j) is the set of operations a process in domain Di may perform on object Oj.
Domain \ Object | F1 | F2 | F3 | Printer |
|---|---|---|---|---|
D1 | read | read, write | ||
D2 | read, write, execute | |||
D3 | read | execute |
To check whether a process in D3 may write F2, the kernel looks at access(D3, F2) = {read}. Write is not there, so the request is denied. Empty entries mean "no access at all".
The access matrix separates policy (what the entries are, decided by users and admins) from mechanism (the kernel checking the entry on every access).
Controlling the Matrix Itself
Who is allowed to change the matrix? The model handles this by adding special rights:
Domains as objects (switch): add domains as columns. If
switchis inaccess(D1, D2), a process in D1 may switch to D2.Copy right (*):
read*in an entry means the holder may copy thereadright to other domains in the same column (to other users of that object). A variant, transfer, moves the right instead of copying it, and limited copy copies it without the asterisk so it cannot be copied further.Owner right: the owner of an object may add or remove any right in that object's column. This is exactly what
chmoddoes for a file's owner.Control right: applies to domain objects; if D2 has
controlover D4, a process in D2 may remove rights from D4's row.
Implementing the Access Matrix
The matrix is huge and mostly empty (thousands of users, millions of files, and most users have no rights to most files). So nobody stores it as a 2D array. There are four classic implementations.
1. Global Table
Store a list of triples <domain, object, rights>. Simple, but the table is too large to keep in memory, and you cannot easily express "everyone may read this file" without one triple per domain.
2. Access Control Lists (store by column)
An access control list (ACL) is attached to each object and lists the domains that have rights on it, with those rights. It is one column of the matrix, with empty entries dropped.
For our matrix:
ACL(F1) = (D1: read), (D2: read, write, execute)
ACL(F2) = (D1: read, write), (D3: read)
ACL(F3) = (D3: execute)
ACL(Printer) = (D2: print), (D3: print)
Answering "who can access this file?" is easy: read its ACL. Revoking a right is easy: edit one list. Answering "what can domain D2 access?" is hard: you must scan every object's ACL. Unix permission bits are a compressed ACL with just three entries (owner, group, others); Windows NTFS and Linux POSIX ACLs (setfacl/getfacl) support full lists.
3. Capability Lists (store by row)
A capability list is attached to each domain and lists the objects it may access with the allowed operations. It is one row of the matrix. Each item is a capability: an unforgeable token that says "the holder may do these operations on this object".
C-list(D1) = (F1: read), (F2: read, write)
C-list(D2) = (F1: read, write, execute), (Printer: print)
C-list(D3) = (F2: read), (F3: execute), (Printer: print)
To access an object, a process simply presents the capability; possession is proof of the right. The capability list itself must be protected: it is kept by the kernel (or protected by hardware tags) and user code may only refer to it, never edit it. A familiar everyday analogy is a Unix file descriptor: the permission check happens once at open(), and after that the descriptor acts like a capability for the operations it was opened with. A process that is passed a descriptor through a Unix-domain socket can use it even if it could not have opened the file itself.
4. Lock-Key Mechanism
A compromise: each object has a list of unique bit patterns called locks, each domain has a list of keys. A process in a domain may access an object if one of its keys matches one of the object's locks. Revocation is easy (remove a lock), and keys are managed by the OS so users cannot forge them.
Comparison
Feature | Access control list | Capability list |
|---|---|---|
Stored with | The object (column) | The domain (row) |
"Who can access object X?" | Easy | Hard (search all domains) |
"What can domain D access?" | Hard (search all objects) | Easy |
Check cost | Search the list on access (usually once at open) | Just verify the presented capability |
Revocation | Easy: edit the object's list | Hard: capabilities are spread over many domains |
Matches how users think | Yes ("share this file with Ravi") | Less so |
Real examples | Unix permissions, NTFS ACLs, POSIX ACLs | File descriptors, Hydra, CAP, seL4, Capsicum (FreeBSD) |
Most real systems combine both: an ACL is checked when a file is first opened, and the result is cached as a capability-like file descriptor for later reads and writes.
Revocation of Access Rights
When a right is taken away, questions arise: is it immediate or delayed, selective (some users) or general (all), partial or total, temporary or permanent? With ACLs, revocation is simple. With capabilities, systems use tricks such as reacquisition (capabilities are periodically deleted and must be requested again), back-pointers from the object to all its capabilities, indirection (capabilities point to a table entry that can be deleted), and keys (each capability carries a key that must match the object's master key; changing the master key revokes them all).
Unix/Linux File Permissions in Practice
Every file has an owner, a group and nine permission bits: rwx for the owner (user, u), for the group (g) and for everyone else (others, o). Each triplet is often written as one octal digit: r = 4, w = 2, x = 1.
Octal | Symbolic | Typical use |
|---|---|---|
644 | rw-r--r-- | Normal file: owner edits, everyone reads |
640 | rw-r----- | Group may read, others nothing |
600 | rw------- | Private file (SSH private key) |
755 | rwxr-xr-x | Program or public directory |
750 | rwxr-x--- | Directory shared only with group |
700 | rwx------ | Private directory |
On a directory the bits mean something slightly different: r = list the names in it, w = create, delete or rename entries in it, x = enter it and access files inside by name. So deleting a file needs write permission on the directory, not on the file.
How does the kernel check? Once per access it picks exactly one triplet: if your effective UID is the owner, it uses the owner bits; else if you are in the file's group, it uses the group bits; else the others bits. (Root bypasses most of these checks.)
umask: Default Permissions
New files are requested with mode 666 and new directories with 777 by most programs, and the kernel clears the bits that are set in the process's umask: final = requested AND NOT umask.
umask | New file (666) | New directory (777) |
|---|---|---|
022 | 644 rw-r--r-- | 755 rwxr-xr-x |
027 | 640 rw-r----- | 750 rwxr-x--- |
077 | 600 rw------- | 700 rwx------ |
Notice that umask only ever removes bits. It is not subtraction: with requested 666 and umask 077, the answer is 600, not 589.
Try It
The following script was run on Ubuntu 26.04 under WSL2 as an ordinary user:
umask 022
touch notes.txt; mkdir project
ls -ld notes.txt project
umask 027
touch secret.txt; mkdir private
ls -ld secret.txt private
chmod 754 notes.txt; ls -l notes.txt
chmod u-w,o+r secret.txt; ls -l secret.txt
echo hi >> secret.txt
ls -l /etc/shadow /usr/bin/passwd; ls -ld /tmpReal output:
-rw-r--r-- 1 imran imran 0 Nov 2 10:46 notes.txt
drwxr-xr-x 2 imran imran 40 Nov 2 10:46 project
drwxr-x--- 2 imran imran 40 Nov 2 10:46 private
-rw-r----- 1 imran imran 0 Nov 2 10:46 secret.txt
-rwxr-xr-- 1 imran imran 0 Nov 2 10:46 notes.txt
-r--r--r-- 1 imran imran 0 Nov 2 10:46 secret.txt
bash: secret.txt: Permission denied
-rw-r----- 1 root shadow 797 Nov 2 07:59 /etc/shadow
-rwsr-xr-x 1 root root 93640 Feb 2 2026 /usr/bin/passwd
drwxrwxrwt 11 root root 220 Nov 2 10:46 /tmp
Walk through it:
With umask 022 the file got 644 and the directory 755; with umask 027 they got 640 and 750, exactly as in the table.
chmod 754gaverwxr-xr--.chmod u-w,o+rremoved the owner's write bit and added read for others, givingr--r--r--.Even though
imranownssecret.txt, the append failed: the kernel checks the owner triplet, which no longer hasw. (The owner can of coursechmodit back, because the owner right lets them change the column.)/etc/shadowholds the password hashes. It is readable only by root and theshadowgroup, and nobody else can even read it.
Special Bits: setuid, setgid, sticky
Look at /usr/bin/passwd: -rwsr-xr-x. The s in the owner's execute position is the setuid bit. When any user runs this program, the process's effective UID becomes the file's owner (root) for as long as the program runs. That is how an ordinary user can change their own password, which requires writing to /etc/shadow, without being given general write access to that file. This is a controlled domain switch.
It is also dangerous: a bug in a setuid-root program gives an attacker root. So setuid programs must be small and extremely careful, which is least privilege again.
setgid (
sin the group position): run with the file's group; on a directory, new files inherit the directory's group.Sticky bit (
tat the end, as in/tmp'sdrwxrwxrwt): everyone may create files in/tmp, but you may delete or rename only your own files there.
Linux Capabilities: Splitting Root
Traditional Unix has only two levels: root (can do everything) and everyone else. Linux splits root's power into about 40 separate capabilities (in the POSIX.1e sense, a different meaning from capability lists above), such as CAP_NET_BIND_SERVICE (bind to ports below 1024), CAP_SYS_NICE (raise priority) and CAP_NET_RAW (raw sockets). A program can be given just the one it needs instead of full setuid root:
$ getcap /usr/bin/ping
/usr/bin/ping cap_net_raw=epHere ping gets only the raw-socket capability (e = effective, p = permitted), not all of root's powers.
Access Control Models: DAC, MAC and RBAC
Model | Who decides access | Example |
|---|---|---|
DAC (Discretionary Access Control) | The owner of an object, at their discretion | Unix permissions, Windows ACLs: you |
MAC (Mandatory Access Control) | A system-wide policy set by the administrator; users, even owners and root, cannot override it | SELinux (Android, Fedora/RHEL), AppArmor (Ubuntu), military classification levels |
RBAC (Role-Based Access Control) | Rights are given to roles; users are assigned roles | "DBA", "HR", "Auditor" roles in companies, cloud IAM roles, Solaris RBAC |
Why MAC? With DAC, a Trojan horse running as you can do anything you can do, including copying your secret files to a public place. With MAC, even if the program is compromised, the policy (for example "the web server process may only read /var/www") still holds. Linux checks both: first the normal DAC permissions, then the Linux Security Module (SELinux or AppArmor) gets a chance to deny the access.
Security: Goals and Threats
Security is usually described with the CIA triad:
Confidentiality: only authorised people can read the data.
Integrity: data and programs are not modified without authorisation.
Availability: the system and data are usable when needed.
Typical breaches map onto these: data theft (confidentiality), tampering (integrity), denial of service (availability), plus theft of service (using someone's resources, such as crypto-mining on a hacked server).
A useful vocabulary: a vulnerability is a weakness, a threat is something that could exploit it, and an attack is an actual attempt. Security must be enforced at four levels: physical (locked server room), human (phishing, social engineering), operating system, and network. A system is only as strong as its weakest level: the best kernel cannot help if someone writes the root password on a sticky note.
Authentication
Before protection can work, the OS must know who the user is. Authentication is based on:
Something you know: password, PIN.
Something you have: phone (OTP), hardware key, smart card.
Something you are: fingerprint, face.
Multi-factor authentication (MFA) combines two or more different kinds. Password plus OTP is two-factor; two passwords are not.
How the OS Stores Passwords
The OS never stores your password itself. It stores a salted, slow hash:
When you set a password, the system generates a random salt and stores
saltandhash(salt + password)in/etc/shadow.When you log in, it hashes what you typed with the stored salt and compares the results.
Why this design?
Hashing is one-way: stealing the file does not directly reveal passwords.
Salt makes two users with the same password get different hashes, and defeats precomputed tables (rainbow tables) because the attacker would need a separate table per salt.
Slow algorithms (bcrypt, scrypt, yescrypt, Argon2) make each guess expensive. Fast hashes like plain SHA-256 or MD5 are the wrong tool for passwords. Current Debian and Ubuntu releases use yescrypt by default (shadow entries starting with
$y$).
Why length matters. Suppose an attacker who stole the hashes can test 10 billion (1010) guesses per second against a fast hash. Trying every possible password:
Password | Possibilities | Time to try all |
|---|---|---|
8 lowercase letters | 268 = 208,827,064,576 | about 21 seconds |
8 chars, a-z A-Z 0-9 | 628 = 218,340,105,584,896 | about 6 hours |
8 chars, all 95 printable | 958 = 6,634,204,312,890,625 | about 7.7 days |
12 chars, a-z A-Z 0-9 | 6212 ≈ 3.2 × 1021 | about 10,000 years |
Each extra character multiplies the work by the alphabet size, which is why long passphrases beat short "complex" passwords. A slow hash that takes, say, 100,000 times longer per guess multiplies all these times by 100,000 too. (Real attackers try dictionary words first, so a long but common phrase is still weak.)
Program Threats
Threat | What it is |
|---|---|
Trojan horse | A program that looks useful but secretly does something harmful, using the rights of the user who runs it. Example: a fake "free game" that uploads your files. A classic trick is placing a program named like a common command ( |
Trap door (backdoor) | A hidden way to bypass normal authentication, left deliberately by a programmer, e.g. a secret username that always logs in. Thompson's famous "Reflections on Trusting Trust" showed one can even be hidden inside a compiler. |
Logic bomb | Code that does harm only when a condition is met, such as a date or "if my name is removed from the payroll". |
Virus | Code that attaches itself to other programs or documents and spreads when they are run or opened. Needs a host and usually a human action. |
Worm | A standalone program that spreads by itself over the network by exploiting vulnerabilities (Morris worm 1988, WannaCry 2017). |
Ransomware | Encrypts the victim's files and demands payment for the key. Good backups kept offline are the main defence. |
Stack / buffer overflow | Writing past the end of a buffer to overwrite nearby memory, such as the return address, to hijack the program. Explained below. |
System and Network Threats
Denial of Service (DoS / DDoS): overload a system so legitimate users cannot use it. On a single machine, a fork bomb (a process that keeps calling
fork(), see Process Creation (fork & exec)) fills the process table. The OS defends with per-user limits: on Linux,ulimit -u(RLIMIT_NPROC) caps the number of processes per user, and cgroups'pids.maxcaps a group, after whichfork()fails withEAGAINinstead of freezing the machine.Port scanning: probing which network services are running, to find a vulnerable one. Not an attack itself, but usually the first step.
Privilege escalation: going from a normal user to root, usually through a bug in the kernel or a setuid program.
Buffer Overflow: A Classic Attack, Live
C does not check array bounds. Look at this tiny program:
#include <stdio.h>
#include <string.h>
void greet(const char *name) {
char buf[8]; /* room for 7 characters + '\0' */
strcpy(buf, name); /* BUG: no length check */
printf("Hello, %s\n", buf);
}
int main(int argc, char *argv[]) {
greet(argc > 1 ? argv[1] : "Asha");
return 0;
}
On the stack, buf sits below the saved registers and the return address of greet. If name is longer than 7 characters, strcpy keeps writing upward and overwrites them:
higher addresses
+--------------------+
| return address | <- attacker wants to overwrite this
+--------------------+
| saved frame ptr |
+--------------------+
| canary (if on) | <- secret random value checked before return
+--------------------+
| buf[0..7] | <- strcpy starts writing here, going up
+--------------------+
lower addresses
If the attacker controls the bytes, they can make the return address point at code of their choice, and the function's return jumps there. Classic attacks put machine code ("shellcode") in the buffer itself.
Compiled with the defaults of GCC 15 on Ubuntu (which enable -fstack-protector-strong) and run in a terminal:
$ ./smash
Hello, Asha
$ ./smash Ravi
Hello, Ravi
$ ./smash AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
Hello, AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
*** stack smashing detected ***: terminated
Aborted ./smash AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
$ echo $?
134The 30 As overflowed buf and overwrote the stack canary, a random value the compiler placed between the buffer and the return address. Before returning, greet checked the canary, saw it had changed, and killed the program (exit status 134 = 128 + 6, where 6 is SIGABRT) instead of jumping to a corrupted address. When we compiled the same program with -fno-stack-protector and passed 40 As, the function really did return to the garbage address and the process died with a segmentation fault (exit status 139 = 128 + 11, where 11 is SIGSEGV; the exact message from your shell may differ slightly). With carefully chosen bytes instead of As, that jump would go where the attacker wants.
Defences Against Memory-Corruption Attacks
Defence | Idea | Layer |
|---|---|---|
Safe coding | Use bounded functions ( | Programmer |
Stack canaries | Random value before the return address, checked on return | Compiler |
NX bit / DEP (W^X) | Pages are writable or executable, not both, so injected code on the stack or heap cannot run | Hardware (page table bit) + OS |
ASLR | Randomise where code, stack, heap and libraries are loaded, so the attacker cannot guess addresses (seen in Memory Management Basics) | OS (+ compiler, PIE) |
Least privilege, sandboxing | Even if exploited, the process can do little (seccomp, MAC policies, containers) | OS |
None is perfect alone (attackers answered NX with return-oriented programming, reusing existing code), which is why systems use defence in depth: many layers, so one failure is not fatal.
Other Security Tools of the OS
Encryption: full-disk encryption (BitLocker, LUKS, FileVault) protects data if the laptop is stolen; network traffic is protected with TLS. (Details of ciphers and TLS are in the Computer Networks tutorial.)
Auditing and logging: recording logins, failed attempts and privileged actions so attacks can be detected and investigated.
Intrusion detection: signature-based (look for known attack patterns, like antivirus) or anomaly-based (flag unusual behaviour, such as a web server suddenly starting a shell).
Updates/patching: most successful attacks use known vulnerabilities that already have fixes.
Secure boot: firmware verifies digital signatures of the bootloader and kernel so that malware cannot load before the OS.
Common Mistakes
Using "protection" and "security" as synonyms in a theory answer. Protection = internal access control mechanisms; security = defence against external threats, including authentication.
Mixing up ACL and capability list. ACL = column, stored with the object. Capability list = row, stored with the domain.
Thinking umask is subtraction. It clears bits: 666 with umask 077 is 600.
Thinking you need write permission on a file to delete it. You need write (and execute) permission on the directory that contains it. The sticky bit adds the "only your own files" rule.
Believing the owner always has access. If the owner triplet lacks a bit, the owner is denied, even if "others" has it. Only one triplet is checked.
Confusing virus and worm. A virus needs a host program and usually a user action; a worm spreads on its own.
Storing passwords encrypted or with a fast hash. Use a salted, slow password hash.
Interview Questions
What is the difference between protection and security?
Protection is the set of internal mechanisms that control access of processes and users to resources. Security is the broader goal of defending the system against external and internal threats, and it also needs authentication, encryption and policy.
What is an access matrix? How is it implemented?
A matrix with domains as rows and objects as columns; each entry lists the allowed operations. Because it is large and sparse, it is implemented as a global table, access control lists (per object, columns), capability lists (per domain, rows), or the lock-key mechanism.
Compare ACLs and capability lists.
ACLs are stored with objects, make "who can access this?" and revocation easy, and match how users share files. Capabilities are stored with domains, make access checks cheap (just present the token), but revocation and auditing are harder.
What is the principle of least privilege?
Give each user, program and component only the privileges it needs, only for as long as it needs them, so that a bug or compromise causes limited damage.
What does the setuid bit do? Why is it risky?
When an executable with setuid is run, the process's effective UID becomes the file's owner. passwd uses it to update /etc/shadow. If such a program (especially setuid root) has a bug, an attacker can use it to gain the owner's privileges.
What is the sticky bit on /tmp for?
Everyone can create files in /tmp, but the sticky bit allows only the file's owner (or the directory owner, or root) to delete or rename it.
DAC vs MAC?
In DAC the object owner decides who gets access (Unix permissions). In MAC a system-wide policy decides and users cannot override it (SELinux, AppArmor).
Why are passwords salted and hashed?
Hashing means the stored value does not reveal the password; salting makes identical passwords hash differently and defeats precomputed rainbow tables; a slow hash makes each guess expensive.
What is a buffer overflow and how does the OS defend against it?
Writing more data into a buffer than it can hold, overwriting adjacent memory such as a return address to hijack control. Defences: stack canaries, non-executable stack/heap (NX/DEP), ASLR, bounds-checked code and least privilege.
Trojan horse vs virus vs worm?
A Trojan pretends to be useful and does harm with the user's rights; a virus inserts itself into other programs and spreads when they run; a worm spreads by itself across the network without a host program.
Summary
Protection controls access inside the system; security defends against threats and includes authentication.
Hardware support (dual mode, memory protection, timer, privileged I/O) lets the kernel check every access.
A domain is a set of <object, rights> pairs; the access matrix describes all domains and objects, with special rights such as switch, copy, owner and control.
The matrix is stored as ACLs (columns, with objects) or capability lists (rows, with domains), or with lock-key; real systems combine them.
Unix uses owner/group/others rwx bits, umask, and setuid/setgid/sticky bits; Linux adds POSIX ACLs, fine-grained capabilities and MAC via SELinux/AppArmor.
Security rests on the CIA triad, strong authentication (salted slow hashes, MFA) and layered defences against malware and memory-corruption attacks (canaries, NX, ASLR).
Next, in Virtualization & Containers, we will see how the OS can isolate entire operating systems and applications from each other, taking the idea of protection domains to a whole new level.