4. Data integrity and cybersecurity

• Data transmission: interference (electrical noise) on the cable or wireless link can flip bits; packets can be lost, arrive late or arrive damaged.
• Data storage: storage media can wear out or become damaged (bad sectors, worn flash cells), power cuts during writing can corrupt files.
• Data entry: a person can mistype data, swap two digits (transposition error, 1234 → 1243) or miss a digit out.

One bit of each byte is used as a parity bit (often the leftmost). The sender and receiver agree on even or odd parity.

• Even parity: the total number of 1s in the byte (including the parity bit) must be even.
• Odd parity: the total number of 1s must be odd.

Calculating: data 1011001 has four 1s.

• Even parity → parity bit 0 → byte 01011001 (four 1s, even).
• Odd parity → parity bit 1 → byte 11011001 (five 1s, odd).

The receiver counts the 1s; if the count is wrong for the agreed parity, an error has happened. Limitation: if two bits flip, the count is still correct, so the error is not detected; parity also cannot say which bit is wrong.

def even_parity_byte(data7: str) -> str:
    p = data7.count('1') % 2
    return str(p) + data7

print(even_parity_byte('1011001'))   # 01011001

A parity block sends several bytes, each with a parity bit, followed by a parity byte: each bit of the parity byte is the parity of that column. This can find which bit is wrong, so the error can be corrected.

Even parity block sent:

Every row and every column has an even number of 1s.

Finding an error: suppose byte 3 arrives as 11010000. Byte 3 now has three 1s (odd) and column 3 has three 1s (odd). The bit where the wrong row and wrong column cross — byte 3, column 3 — is the error; flip it back from 0 to 1.

1. The sender sends the data.
2. The receiver sends the same data back to the sender.
3. The sender compares the returned data with the original. If they are different, an error has happened and the data is sent again.

Limitation: it cannot tell whether the error happened on the way there or on the way back, and it doubles the data sent.

1. Before sending, the sender calculates a value (the checksum) from the data using an agreed algorithm, and sends it with the data (e.g. in the packet trailer).
2. The receiver recalculates the checksum from the data it received using the same algorithm.
3. If the two checksums do not match, the data has an error and is requested again.

(You will not have to calculate a checksum.)

A check digit is an extra digit, calculated from the other digits of a number and added to the end. It detects data entry errors such as a wrong digit or swapped digits.

1. The check digit is calculated when the number is created.
2. When the number is entered, the computer recalculates the check digit from the other digits.
3. If it does not match the entered check digit, the number was entered wrongly and must be re-entered.

Used in: ISBNs (book numbers), bar codes on products, airline ticket numbers and bank account numbers. (You will not have to calculate one.)

1. The receiver checks each packet it gets for errors (e.g. with a checksum or parity).
2. If it is correct, the receiver sends a positive acknowledgement (ACK) back to the sender.
3. If it has an error, the receiver sends a negative acknowledgement (NAK), asking for it to be resent.
4. The sender also starts a timer (timeout) when it sends a packet. If no acknowledgement arrives before the timeout, it resends the packet automatically.
5. This repeats until the packet is received correctly (or a set number of tries is reached).

• Brute-force attack — aim: find a password. Process: software tries every possible combination (or a list of common passwords) until one works.
• Data interception — aim: steal data in transit. Process: data travelling over a network is captured (e.g. with a packet sniffer, or on unsecured Wi-Fi) and read.
• Distributed denial of service (DDoS) — aim: stop a website or server working. Process: a huge number of requests are sent from many computers (often a botnet of infected machines) so the server is overwhelmed and real users can't get through.
• Hacking / unauthorised access — aim: get into a system without permission, to steal, change or delete data. Process: exploiting weak passwords or security flaws.

Malware is malicious software.

• Phishing — fake emails or messages that look like they come from a real organisation, with a link to a fake site where the user enters personal details.
• Pharming — malicious code on the user's computer or a DNS server redirects them to a fake website even when they type the correct URL.
• Social engineering — manipulating people (by phone, message or in person, using fear, urgency or trust) into giving away information or access.
• SQL injection — the attacker types SQL code into an input box on a website (e.g. a log-in form). If the site places the input straight into its database query, the attacker's code runs, letting them bypass log-in or read, change or delete data. For example typing ' OR '1'='1 as a password can make the condition always true.

The defence is to never build a query by joining the user's text into it; use a parameterised query and validate input:

import sqlite3

db = sqlite3.connect(':memory:')
db.execute('CREATE TABLE Users (Name TEXT, Pw TEXT)')
name, pw = 'ali', "' OR '1'='1"
# safe: the ? placeholders treat the input as data, never as SQL
rows = db.execute('SELECT Name FROM Users WHERE Name = ? AND Pw = ?', (name, pw)).fetchall()
print(rows)   # []

Encryption scrambles data (plaintext) into ciphertext using an algorithm and a key, so it can only be read by someone with the right key. It does not stop data being intercepted — it makes intercepted data useless.

• Protecting confidentiality: only the holder of the key can read the data, whether stored or transmitted.
• Ensuring integrity: changing encrypted data without the key produces nonsense when decrypted, so tampering is detected.
• Supporting authenticity and non-repudiation: data encrypted with someone's private key (a digital signature) can only have come from them, so they cannot deny sending it.

Symmetric encryption uses the same key to encrypt and decrypt.

1. The sender encrypts the plaintext with the secret key.
2. The ciphertext is sent.
3. The receiver decrypts it with the same key.

It is fast, but the key itself must be shared — if it is intercepted, all the data can be read.

Asymmetric encryption uses a pair of keys: a public key (anyone may have it) and a private key (kept secret by its owner).

1. The receiver sends their public key to the sender.
2. The sender encrypts the data with the receiver's public key.
3. Only the receiver's private key can decrypt it, so interception of the public key or the data does not help an attacker.

It solves the key-sharing problem but is slower, so in practice (e.g. TLS) asymmetric encryption is used to share a symmetric key safely, then symmetric encryption is used for the rest.