Confidentiality, integrity, availability

You have learned what a computer does and how to read what it logs. Now we start thinking like a defender. The first tool is a way of sorting problems: when something goes wrong, which of three things was lost?

The three goals

Confidentiality means only the people and programs that should see information can see it. A password hidden from strangers is confidentiality. When it breaks, we call it a leak or a data breach.

Integrity means information and systems are correct and have not been changed by anyone who should not have changed them. A bank balance that only changes through real transactions has integrity. When it breaks, you get tampering: altered records, swapped files, a quietly modified program.

Availability means the thing works when someone needs it. A website that loads and a database that answers have availability. When it breaks, you get an outage, whether caused by an attack, a failure or a mistake.

Together these are called the CIA triad. Every control you will meet in this course, from passwords to backups, exists to protect at least one of the three.

Sorting real situations

The skill is to read a scenario and say which goal it breaks. Try these (all illustrative):

Notice the ransomware row. One incident can hit more than one goal. The triad is a checklist of questions, not a set of boxes where each event fits exactly once.

Who guards each goal

Different tools protect different goals, and it helps to know which is which:

• Confidentiality: passwords, encryption (scrambling data so only holders of a key can read it), and file permissions from the earlier lesson.
• Integrity: checksums (a short fingerprint of a file that changes if the file changes), digital signatures, version history, and permissions that stop people writing where they should only read.
• Availability: backups, spare capacity, redundant servers, and rate limits that stop one user flooding a service.

You already know one of these. The w in a permission string is mostly an integrity control, and the r is mostly a confidentiality control.

The goals pull against each other

Strengthening one goal can weaken another, and good defenders know it:

• Locking a system down hard (confidentiality) can make it hard to reach in an emergency (availability).
• Keeping many copies of data (availability) gives attackers more places to steal it (confidentiality).
• Checking every action before allowing it (integrity) slows people down, and slow tools get bypassed.

So there is no "maximum security". There is a decision: for this particular asset, which goal matters most and what are we willing to trade? A hospital chart system and a private journal app make opposite choices, and both can be right.

A worked example

Imagine a small clinic with an appointment website that stores patient names and phone numbers.

1. Confidentiality matters a great deal: names tied to a clinic are sensitive. Controls: limit who can open the patient list, never put it in a public folder.
2. Integrity matters: a changed phone number or a deleted booking means a missed appointment. Controls: only staff can edit, and edits are logged (you practised reading logs last time).
3. Availability matters on the day: if the site is down, front-desk staff cannot see who is arriving. Controls: nightly backup, and a printed list as a fallback.

Writing three short sentences like these for anything you protect is the beginning of a threat model, which is the next lesson.

How AI changes this

AI does not add a fourth goal. It changes how each of the three gets broken, and who is doing the breaking.

Confidentiality. An AI agent that works for you reads files, terminal output and web pages as input, and it runs with your permissions. If it is tricked by text in a document it reads (this is called prompt injection), it may send what it can read to someone else, which is data exfiltration. The leak does not need a bug in your software; the agent is working as designed, for the wrong instructor.

Integrity. An agent writes files and runs commands, so it can alter things quickly and at scale, including by honest mistake. A confident wrong edit or a destructive command is an integrity and availability failure with no attacker at all. Also, you can no longer assume that code in your project was written by a person who understood it; code review matters more.

Availability. Agents can burn through paid API usage fast, which can take a service offline or run up a bill (see denial of wallet). Attackers also use AI to automate floods and scans, so availability attacks cost them less than before.

What is the same: the triad still sorts every one of these. What is new is that the actor is software with your credentials, acting at machine speed, and that its input is untrusted text.

On the defender side, AI is useful for triage, such as reading a pile of logs and flagging the lines that look like a leak or a deletion. Treat its output as a lead to verify, not a verdict.

Try it

This lab protects integrity on your own machine, using only files you create.

mkdir ~/cia-lab && cd ~/cia-lab
echo "pay 100 to account 1234" > invoice.txt
shasum -a 256 invoice.txt > invoice.sha256
cat invoice.sha256

On Linux use sha256sum instead of shasum -a 256. The long string is the file's fingerprint. Now check it, then tamper with the file and check again:

shasum -a 256 -c invoice.sha256
echo "pay 100 to account 9999" > invoice.txt
shasum -a 256 -c invoice.sha256

The first check says OK. The second says FAILED. You changed one number and the fingerprint noticed. Clean up with cd ~ && rm -r ~/cia-lab.

Check yourself

Next

You can now name what is being lost. Next we ask the question that comes before it: who would attack this, why, and how. That is a threat model.