Information Security

Hash function

A hash function $H$ takes a message $M$ of any length and produces a fixed-size output $h = H(M)$, called a hash value or message digest. A cryptographic hash function should have these properties:

• Variable input size, fixed output size.
• Easy to compute $H(M)$.
• Preimage resistance (one-way) – given $h$, it is infeasible to find $M$ with $H(M)=h$.
• Second preimage resistance – given $M$, it is infeasible to find $M' \ne M$ with $H(M')=H(M)$.
• Collision resistance – it is infeasible to find any $x \ne y$ with $H(x)=H(y)$.

Uses: message authentication, digital signatures, password storage, integrity checking.

MD5 algorithm (128-bit digest)

Step 1 – Append padding bits. The message is padded so that its length is congruent to 448 mod 512 (that is, 64 bits less than a multiple of 512). Padding is a single 1 bit followed by 0 bits, and is always added, even if the length is already 448 mod 512.

Step 2 – Append length. A 64-bit representation of the length of the original message (before padding) is appended (low-order bytes first; modulo $2^{64}$ if longer). The message is now a multiple of 512 bits, i.e. $L$ blocks $Y_0,\dots,Y_{L-1}$ of 512 bits, or 16 32-bit words each.

Step 3 – Initialise the MD buffer. A 128-bit buffer of four 32-bit registers $(A,B,C,D)$ is initialised (little-endian hex):

$A=\text{67452301},\; B=\text{EFCDAB89},\; C=\text{98BADCFE},\; D=\text{10325476}$

Step 4 – Process the message in 512-bit blocks. Each block goes through the compression function $H_{MD5}$, which has 4 rounds of 16 steps each (64 steps in total). Each round uses a different nonlinear function of $B,C,D$:

$F=(B\wedge C)\vee(\neg B\wedge D),\quad G=(B\wedge D)\vee(C\wedge\neg D),\quad H=B\oplus C\oplus D,\quad I=C\oplus(B\vee\neg D)$

Each step updates the buffer:

$A \leftarrow B + \big((A + g(B,C,D) + X[k] + T[i]) \lll s\big)$

then the registers rotate $(A,B,C,D)\to(D,A,B,C)$. Here $X[k]$ is a 32-bit word of the current block (the order of $k$ differs by round), $T[i]=\lfloor 2^{32}\times|\sin(i)|\rfloor$ is one of 64 constants, $\lll s$ is a circular left shift, and addition is modulo $2^{32}$. After the 64 steps, the outputs are added to the input chaining values: $A=A+A_{in}$, etc. (modulo $2^{32}$). The result is the input to the next block.

Step 5 – Output. After all $L$ blocks, the concatenation of the final $A\,\|\,B\,\|\,C\,\|\,D$ (little-endian) is the 128-bit message digest.

Ethical issues in computing

• Privacy – collection, storage and use of personal data without consent; surveillance and data breaches.
• Intellectual property and piracy – copying software, music or content, plagiarism, and licence violation.
• Computer crime and unauthorised access – hacking, malware, identity theft, fraud.
• Accuracy and reliability – responsibility for errors and failures of software, particularly in critical systems.
• Access and digital divide – unequal access to technology and information.
• Confidentiality and professional responsibility – honest reporting, competence, and protection of clients' data.
• Impact on society – job loss from automation, algorithmic bias, harmful content and AI misuse.

RSA algorithm

RSA is a public-key cipher whose security rests on the difficulty of factoring $n=pq$.

Key generation

1. Choose two large primes $p,q$.
2. Compute $n=pq$ and $\phi(n)=(p-1)(q-1)$.
3. Choose $e$ with $1<e<\phi(n)$ and $\gcd(e,\phi(n))=1$.
4. Compute $d$ with $ed\equiv1 \pmod{\phi(n)}$.
5. Public key $=(e,n)$; private key $=(d,n)$.

Encryption: $C = M^e \bmod n$ Decryption: $M = C^d \bmod n$

Example

Let $p=7,\;q=11$. Then $n=77$ and $\phi(n)=6\times10=60$. Choose $e=7$ (gcd(7,60)=1). Find $d$ with $7d\equiv1 \pmod{60}$: $d=43$, since $7\times43=301=5\times60+1$.

Public key $(7,77)$, private key $(43,77)$.

Encrypt $M=5$: $C=5^7 \bmod 77$ $5^2=25$, $5^4=625 \bmod 77=9$, so $5^7=5^4\cdot5^2\cdot5=9\cdot25\cdot5=1125 \bmod 77=47$. So $C=47$.

Decrypt: $M=47^{43} \bmod 77$. By the Chinese remainder theorem: mod 7, $47\equiv5$, $5^{43}=5^{(6\cdot7+1)}\equiv5$; mod 11, $47\equiv3$, $3^{43}=3^{(5\cdot8+3)}\equiv27\equiv5$. Both give 5, so $M=5$, the original message.

Symmetric cryptography

In symmetric (conventional, secret-key) cryptography the same secret key is used by sender and receiver for encryption and decryption: $C=E_K(P)$, $P=D_K(C)$. It is fast and suited to bulk data, but needs a secure way to share the key. Examples: DES, 3DES, AES.

DES

DES is a Feistel block cipher with a 64-bit block, a 56-bit effective key (64 bits with 8 parity bits) and 16 rounds. It starts with an initial permutation (IP), then 16 rounds, then a swap of halves and the inverse permutation $IP^{-1}$.

Round operation

The 64-bit block is split into $L_{i-1}$ and $R_{i-1}$ (32 bits each):

$L_i = R_{i-1},\qquad R_i = L_{i-1}\oplus F(R_{i-1},K_i)$

The function $F$:

1. Expansion (E) – $R_{i-1}$ is expanded from 32 to 48 bits by permuting and duplicating bits.
2. Key mixing – XOR with the 48-bit round key $K_i$.
3. Substitution (S-boxes) – the 48 bits are split into eight 6-bit groups; each goes through an S-box (outer two bits select the row, inner four the column), giving a 4-bit output, i.e. 32 bits in total.
4. Permutation (P) – the 32-bit result is permuted.

Sub-key generation

1. The 64-bit key goes through Permuted Choice 1 (PC-1), which drops the 8 parity bits and permutes the remaining 56 bits, then splits them into two 28-bit halves $C_0$ and $D_0$.
2. For each round $i=1..16$, both halves are circularly shifted left by 1 bit (rounds 1, 2, 9, 16) or 2 bits (other rounds).
3. The shifted halves $C_i,D_i$ are concatenated (56 bits) and passed through Permuted Choice 2 (PC-2), which selects and permutes 48 bits to give $K_i$.
4. The shifted $C_i,D_i$ become the input to the next round. Decryption uses the same subkeys in reverse order, $K_{16}$ to $K_1$.

Access control is the process of granting or denying requests to use resources, so that only authorised subjects (users, processes) can perform permitted operations (read, write, execute) on objects (files, devices). It rests on authentication, authorisation and audit. Main models are discretionary (DAC), mandatory (MAC), role-based (RBAC) and attribute-based (ABAC).

Attribute-based access control (ABAC)

ABAC decides access from attributes of the subject, the object, the operation and the environment, evaluated against policy rules, rather than from identity or role alone.

Attribute types:

• Subject attributes – name, role, department, clearance, age.
• Object (resource) attributes – owner, type, classification, creation date.
• Environment attributes – time, location, device, threat level.

Operation: a subject requests access; the policy decision point evaluates the policy rules against the attributes; the policy enforcement point permits or denies access.

Example: A hospital policy: "A user may view a patient record if user.role = Doctor AND user.department = record.department AND the request time is within the user's shift." Dr. Sita (Cardiology, on shift) can read a cardiology patient record, but the same doctor is denied access to a neurology record or outside her shift. ABAC is flexible and fine-grained, needs no explicit per-user permission, and scales well, but policy design and attribute management are complex.

Hill cipher encryption is $C = KP \bmod 26$, so decryption is $P = K^{-1}C \bmod 26$, with $A=0,\dots,Z=25$.

Ciphertext blocks: CRHG gives $(C,R)=(2,17)$ and $(H,G)=(7,6)$.

Key: $K=\begin{pmatrix}3&4\\3&5\end{pmatrix}$

$\det K = 15-12 = 3$. The inverse of 3 mod 26 is 9, since $3\times9=27\equiv1$.

$K^{-1}=9\begin{pmatrix}5&-4\\-3&3\end{pmatrix}=\begin{pmatrix}45&-36\\-27&27\end{pmatrix}\equiv\begin{pmatrix}19&16\\25&1\end{pmatrix}\pmod{26}$

Check: $3\cdot19+4\cdot25=157\equiv1$ and $3\cdot16+4\cdot1=52\equiv0$, good.

Block 1: $\begin{pmatrix}19&16\\25&1\end{pmatrix}\begin{pmatrix}2\\17\end{pmatrix}=\begin{pmatrix}38+272\\50+17\end{pmatrix}=\begin{pmatrix}310\\67\end{pmatrix}\equiv\begin{pmatrix}24\\15\end{pmatrix}\to \text{YP}$

Block 2: $\begin{pmatrix}19&16\\25&1\end{pmatrix}\begin{pmatrix}7\\6\end{pmatrix}=\begin{pmatrix}133+96\\175+6\end{pmatrix}=\begin{pmatrix}229\\181\end{pmatrix}\equiv\begin{pmatrix}21\\25\end{pmatrix}\to \text{VZ}$

Plaintext = YPVZ

Euler totient function

$\phi(n)$ is the number of positive integers less than $n$ that are relatively prime to $n$. Properties: $\phi(p)=p-1$ for prime $p$; $\phi(pq)=(p-1)(q-1)$ for distinct primes; $\phi(1)=1$.

Miller-Rabin test for $n=37$

Write $n-1=36=2^k q$ with $q$ odd: $36=2^2\times9$, so $k=2$, $q=9$.

Choose a base $a=2$ and compute $a^q \bmod n$:

$2^5=32$, $2^9=2^5\cdot2^4=32\cdot16=512 \bmod 37=31$ (since $37\times13=481$).

So $2^9\equiv31\equiv-6$, which is neither $1$ nor $36$. Square it ($j=1$):

$31^2=961 \bmod 37=36 \;(\text{since }37\times25=925)$

This equals $n-1=36$, so the test passes: 37 is "probably prime" (inconclusive for composite).

Since the test never found a witness for compositeness (and any other base gives the same outcome for a prime), 37 is not composite; it is prime. (Indeed, 37 is not divisible by 2, 3 or 5, and $\sqrt{37}<7$.)

(a) Phishing attack

Phishing is a social-engineering attack in which the attacker poses as a trustworthy entity (a bank, an online service, a colleague) in email, SMS (smishing), calls (vishing) or fake websites, to trick victims into revealing usernames, passwords, card numbers or into installing malware. A typical email contains an urgent message and a link to a look-alike login page. Variants include spear phishing (targeted at a person), whaling (executives) and clone phishing.

Countermeasures: check sender and URL, never enter credentials via email links, use spam filters, two-factor authentication, anti-phishing browser tools and user awareness training.

(b) Two-factor authentication (2FA)

2FA requires two different kinds of proof of identity from: something you know (password, PIN), something you have (phone, smart card, token) and something you are (fingerprint, face). Example: an ATM needs the card (have) and PIN (know); a login needs a password followed by a one-time code sent to the mobile phone. Even if the password is stolen, the attacker lacks the second factor, so security is much stronger.

Authentication is the process of verifying a claimed identity of a user, device or process, i.e. establishing that the entity is who it claims to be. It is done with something the user knows (password), has (token, smart card) or is (biometrics), or with a combination.

Biometric authentication

Biometric authentication uses physical (static) or behavioural (dynamic) characteristics unique to a person, such as fingerprint, face, iris, retina, hand geometry, voice, signature and keystroke dynamics.

Process:

1. Enrolment – the user's biometric sample is captured, key features are extracted and stored as a template in a database, along with the user ID.
2. Authentication – at login, a fresh sample is captured by a sensor and features are extracted.
3. Matching – the new template is compared to the stored one. If the match score exceeds a threshold, the user is authenticated (verification, one-to-one); for identification, the sample is compared with many templates (one-to-many).

Performance is measured by the false accept rate (FAR) and false reject rate (FRR), balanced by the threshold. Advantages: cannot be forgotten or easily shared. Limitations: cost, privacy concerns, errors, and a compromised biometric cannot be reissued.

Security risk assessment is the process of identifying the assets of an organisation, the threats and vulnerabilities that affect them, and the likelihood and impact of loss, in order to decide which risks to treat with controls. Risk is considered as a function of threat, vulnerability and impact.

Steps: identify and value assets; identify threats and vulnerabilities; estimate likelihood and consequence; rank the risks; select countermeasures (avoid, reduce, transfer or accept); monitor and review.

Aspects of a successful risk assessment:

• Clear scope and objectives aligned with the business.
• Complete asset identification and valuation (hardware, software, data, people).
• Accurate threat and vulnerability analysis, using current intelligence and testing.
• Realistic likelihood and impact estimation, using a consistent qualitative or quantitative method.
• Management support and involvement of the stakeholders.
• Cost-effective control selection – the cost of control should not exceed the risk.
• Documentation and reporting, with a risk register.
• Regular review, since the threat environment and systems change.

Security threat: a potential danger that might exploit a vulnerability to breach security and cause harm. It is a possible event (for example, a hacker, a disgruntled employee, a natural disaster).

Attack: an actual attempt, intelligent act or assault on a system to evade security services and violate the security policy. An attack is the realisation of a threat.

Types of attacks

Passive attacks (do not alter data; hard to detect, prevented by encryption):

• Release of message contents – eavesdropping on a conversation, mail or file transfer.
• Traffic analysis – observing patterns, length and frequency of messages even if encrypted.

Active attacks (modify the data stream or create false data; detected and recovered from):

• Masquerade – one entity pretends to be another.
• Replay – captured data is retransmitted to produce an unauthorised effect.
• Modification of messages – part of a legitimate message is altered, delayed or reordered.
• Denial of service – prevents normal use of communications facilities, for example by flooding a server.

Other categories: inside vs. outside attacks (by an authorised user or by an outsider), and malware, phishing, SQL injection, man-in-the-middle attacks.

The Diffie-Hellman protocol lets two parties establish a shared secret key over an insecure channel without having previously met. Its security rests on the difficulty of the discrete logarithm problem.

Protocol

1. Alice and Bob publicly agree on a prime $q$ and a primitive root $\alpha$ of $q$.
2. Alice chooses a secret $X_A<q$ and computes the public value $Y_A=\alpha^{X_A}\bmod q$; Bob chooses a secret $X_B$ and computes $Y_B=\alpha^{X_B}\bmod q$.
3. They exchange $Y_A$ and $Y_B$.
4. Alice computes $K=Y_B^{X_A}\bmod q$; Bob computes $K=Y_A^{X_B}\bmod q$.

Both get $K=\alpha^{X_AX_B}\bmod q$.

Example

Let $q=23$, $\alpha=5$. Alice's secret $X_A=6$, Bob's secret $X_B=15$.

• $Y_A=5^6\bmod23=15625\bmod23=8$
• $Y_B=5^{15}\bmod23=19$
• Alice: $K=19^6\bmod23=2$
• Bob: $K=8^{15}\bmod23=2$

The shared secret key is $K=2$. An eavesdropper sees only $23,5,8,19$ and would have to solve a discrete logarithm. The plain protocol is vulnerable to a man-in-the-middle attack because it does not authenticate the parties.

Role of hash functions in message authentication

A hash function $H$ maps a message of any length to a fixed-length digest. For authentication, the digest acts as a fingerprint of the message:

• Integrity – the sender sends $M\,\|\,H(M)$ (or a protected form); the receiver recomputes $H(M)$ and compares. Any change in $M$ changes the hash.
• Encrypted hash – $E_K[M\,\|\,H(M)]$ with a shared key gives both confidentiality and authentication.
• Encrypting only the hash – $M\,\|\,E_K[H(M)]$ authenticates with less encryption work.
• Digital signature – the hash is encrypted with the sender's private key, $E_{PR_a}[H(M)]$, which provides authentication, integrity and non-repudiation.
• Keyed hash (HMAC) – a secret value is combined with the message: $H(K\,\|\,M\,\|\,K)$ style constructions authenticate without encryption and are faster.

SHA-1 algorithm

SHA-1 produces a 160-bit digest from a message of length less than $2^{64}$ bits, processing 512-bit blocks.

1. Append padding bits – a 1 bit then 0 bits, so that the length is $\equiv448\pmod{512}$.
2. Append length – a 64-bit big-endian value of the original length. The message is now a multiple of 512 bits, $Y_0..Y_{L-1}$.
3. Initialise the buffer – five 32-bit registers: $A=\text{67452301},\;B=\text{EFCDAB89},\;C=\text{98BADCFE},\;D=\text{10325476},\;E=\text{C3D2E1F0}$
4. Process each 512-bit block with the compression function of 80 steps in 4 rounds of 20 steps. The 16 words of the block are expanded into 80 words: $W_t=(W_{t-3}\oplus W_{t-8}\oplus W_{t-14}\oplus W_{t-16})\lll1,\quad 16\le t\le79$ Each step: $T=(A\lll5)+f_t(B,C,D)+E+W_t+K_t$ $E\leftarrow D,\; D\leftarrow C,\; C\leftarrow B\lll30,\; B\leftarrow A,\; A\leftarrow T$ where $f_t$ is the round function: $(B\wedge C)\vee(\neg B\wedge D)$ for steps 0-19, $B\oplus C\oplus D$ for 20-39, $(B\wedge C)\vee(B\wedge D)\vee(C\wedge D)$ for 40-59, and $B\oplus C\oplus D$ for 60-79. Constants $K_t$ are 5A827999, 6ED9EBA1, 8F1BBCDC, CA62C1D6 for the four rounds. Additions are modulo $2^{32}$.
5. After 80 steps, the registers are added to the block's input values (mod $2^{32}$) to form the input to the next block.
6. Output – after the last block, $A\|B\|C\|D\|E$ is the 160-bit digest.

Euler totient function

$\phi(n)$ is the number of positive integers less than $n$ that are relatively prime to $n$ (with $\phi(1)=1$).

• For a prime $p$: $\phi(p)=p-1$.
• For distinct primes $p,q$: $\phi(pq)=(p-1)(q-1)$.

Example: $\phi(12)$: the numbers below 12 coprime to 12 are 1, 5, 7, 11, so $\phi(12)=4$. Check: $12=2^2\cdot3$, $\phi=12(1-\tfrac12)(1-\tfrac13)=4$. Also $\phi(7)=6$ and $\phi(35)=\phi(5)\phi(7)=4\times6=24$.

GCD(12, 32) by the extended Euclidean algorithm

Euclid steps:

$32=2\cdot12+8$ $12=1\cdot8+4$ $8=2\cdot4+0$

So $\gcd(12,32)=4$.

Back-substitution:

$4=12-1\cdot8$ $8=32-2\cdot12$ $4=12-(32-2\cdot12)=3\cdot12-1\cdot32$

So $4 = 3(12) + (-1)(32)$, i.e. $x=3$, $y=-1$.

Tabular check: $(r,s,t)$: $32=(32,0,1)$, $12=(12,1,0)$ giving $(8,-2,1)$, then $(4,3,-1)$, and $4=3\cdot12-1\cdot32=36-32=4$. Correct.

Threat vs. attack

Computer security strategy

A security strategy has three parts: specification/policy (what is the security scheme supposed to do: assets, threats, objectives), implementation and correctness/assurance. Implementation follows four actions:

• Prevention – stop attacks from succeeding (encryption, authentication, firewalls, access control).
• Detection – discover attacks in progress or after the fact (IDS, logging, audit).
• Response – take action to halt the attack and limit damage.
• Recovery – restore the system after an attack (backups, rollback, redundancy).

Also: defence in depth, least privilege, and regular risk assessment.

Diffie-Hellman calculation

$q=23$, $\alpha=9$, Alice's private key $X_A=5$, Bob's private key $X_B=6$.

Alice's public value: $Y_A=9^5\bmod23$. $9^2=81\bmod23=12$; $9^4=12^2=144\bmod23=6$; $9^5=6\cdot9=54\bmod23=8$. So $Y_A=8$.

Bob's public value: $Y_B=9^6\bmod23=9^4\cdot9^2=6\cdot12=72\bmod23=3$. So $Y_B=3$.

Alice's key: $K=Y_B^{X_A}=3^5=243\bmod23=243-230=13$.

Bob's key: $K=Y_A^{X_B}=8^6=262144\bmod23$. Computing stepwise: $8^2=64\bmod23=18$; $8^3=18\cdot8=144\bmod23=6$; $8^6=6^2=36\bmod23=13$.

The shared secret key is 13.

Two-factor authentication (2FA) verifies a user with two independent factors taken from different categories:

1. Knowledge factor – something you know: password, PIN.
2. Possession factor – something you have: mobile phone, hardware token, smart card, ATM card.
3. Inherence factor – something you are: fingerprint, face, iris.

Because the factors are independent, an attacker who steals one (for example a password through phishing) still cannot log in without the other.

Example – online banking: The user enters a username and password (factor 1). The bank then sends a one-time password (OTP) by SMS to the registered mobile number, or the user generates a time-based code in an authenticator app; the user enters this code (factor 2). Access is granted only when both are correct. Another everyday example is withdrawing cash from an ATM: the card (have) plus the PIN (know).

Strengths: much stronger than passwords alone. Weaknesses: extra effort, device loss, SIM-swap and real-time phishing can still defeat SMS codes.

Access control limits who (subject) may do what (rights) to which resource (object). Different access control principles/models are:

1. Discretionary access control (DAC) – the owner of a resource decides who may access it. Permissions are stored in an access control matrix, access control lists (ACL) or capability lists. It is flexible (used in UNIX, Windows) but a user can pass rights on, and it is vulnerable to Trojan horses.
2. Mandatory access control (MAC) – access is decided by the system based on security labels: subjects have clearances and objects have classifications (Top Secret, Secret, Confidential...). Users cannot change it. Bell-LaPadula ("no read up, no write down") is a common model. Used in military systems.
3. Role-based access control (RBAC) – permissions are assigned to roles, and users get roles according to their job (for example, teller, manager). It simplifies administration, and supports least privilege and separation of duties.
4. Attribute-based access control (ABAC) – access depends on attributes of subject, object and environment evaluated against policy rules; it is flexible and fine-grained.

General principles: least privilege, separation of duties and need-to-know.

Malicious software (malware) is software designed to damage, disrupt or gain unauthorised access to a system. Two common types are:

1. Virus A piece of code that attaches itself to a host program or file and replicates by infecting other files when the host is run. Phases: dormant, propagation, triggering and execution. Types include parasitic, boot-sector, macro, memory-resident and polymorphic/metamorphic (to evade detection). It needs a user action to spread, and its payload may delete or corrupt data or slow the system.

2. Worm A standalone program that replicates itself and spreads through networks, without needing a host file or user action. It exploits vulnerabilities in services, email or file sharing to find new targets, causing congestion and carrying payloads such as backdoors or bots. Examples are the Morris worm, Code Red and Conficker.

(Other types: Trojan horse, logic bomb, spyware, ransomware, rootkit and bots/zombies.)

Risk assessment

Risk assessment is the process of identifying assets, threats and vulnerabilities in an organisation, estimating the likelihood and impact of each risk, and selecting controls to reduce the risk to an acceptable level. Steps: asset identification, threat and vulnerability identification, likelihood and impact analysis, risk ranking, control selection and monitoring.

Security auditing architecture

A security audit is an independent review and examination of system records and activities to test the adequacy of controls and detect breaches. The architecture (X.816 model) has these parts:

• Event discriminator – a logic that decides which events are of interest and should be recorded (based on the audit policy).
• Audit recorder – a logging component that writes the selected events as audit records.
• Alarm processor – generates alarms/actions when the events suggest a security violation.
• Audit trail (log) storage – the protected store holding the records; later it is read by:
• Audit analyzer – processes the audit trail, detecting patterns and anomalies, and may feed back to the discriminator.
• Audit archiver – retains the old records for future review.
• Audit provider – gives access to the audit trail to an authorised audit trail examiner, who produces reports.

Audit records contain the subject, action, object, time and outcome. The trail itself must be protected against alteration.

They are related, but not exactly the same.

Computer crime is any illegal act in which a computer is the target, tool or storage of the crime. It includes offences that can happen on a stand-alone machine without any network.

Cybercrime is crime carried out through or against networks and the Internet (cyberspace). Every cybercrime is a computer crime, but not every computer crime is a cybercrime; cybercrime also covers crimes against people over the net.

So the terms overlap heavily and are often used interchangeably, but cybercrime is the networked subset (plus online crimes like harassment), while computer crime is the broader category involving computers as targets or tools.

Countermeasures for malware

Countermeasures are the measures to prevent, detect and recover from malware. The ideal is prevention (policy, awareness, patching, least privilege), but when it fails:

• Detection – determine that infection has occurred and locate the malware.
• Identification – identify the specific malware.
• Removal – remove all traces and restore the system.

Generations of antivirus software: simple scanners (signatures), heuristic scanners (integrity checking, suspicious code), activity traps (monitor behaviour) and full-featured protection (combination). Other measures: firewalls, intrusion detection, sandboxing, patching, backups, and user training. Host-based and perimeter scanning, and digital immune systems, are also used.

Audit trail analysis

An audit trail (log) records security-relevant events (logins, file access, privilege use, network connections). Audit trail analysis is the examination of these records to:

• detect intrusions, policy violations and anomalies (for example repeated failed logins);
• reconstruct events after an incident (forensics) and establish accountability;
• check compliance, and assess the effectiveness of controls.

Analysis may be real-time or post-hoc, using filtering, statistical profiling, rule-based and automated correlation tools. Logs must be protected from tampering and kept long enough.

Issues for user authentication

• Weak or reused passwords – guessable, shared or written down; vulnerable to brute-force, dictionary attacks and credential stuffing.
• Credential theft – phishing, keyloggers, shoulder surfing and social engineering.
• Eavesdropping and replay of authentication data over the network.
• Storage of credentials – plain-text or poorly hashed password databases.
• Biometric errors (false accept/reject), privacy and non-revocability.
• Token loss or theft, and cost of tokens/cards.
• Usability and account recovery – the trade-off between security and convenience; weak reset procedures.
• Insider and impersonation threats, and multiple accounts across services.

Trust framework

A trust framework is a set of agreed technical standards, operational rules, policies and legal agreements that lets different organisations (identity providers, relying parties, users) rely on each other's identity and authentication assertions. It specifies the required assurance level, identity proofing, credential management and liability, so that a user authenticated by one provider can be trusted by another. Examples: federated identity (SAML, OpenID Connect), national digital identity schemes, and the NIST levels of assurance. It supports single sign-on across organisations.

Role of digital signatures in message authentication

A digital signature is created by encrypting (signing) a hash of the message with the sender's private key: $S=E_{PR_A}[H(M)]$. The receiver verifies it by decrypting with the sender's public key and comparing the result with a newly computed $H(M)$.

It provides:

• Message authentication – proves that the message came from the claimed sender, since only the sender has the private key.
• Integrity – any modification of the message changes the hash, so verification fails.
• Non-repudiation – the sender cannot later deny having sent it, because a third party can verify the signature with the public key (unlike a MAC, where the key is shared).

Algorithms: RSA signatures, DSA/DSS, ECDSA.

Two natures of zombies

A zombie (bot) is a compromised computer controlled remotely by an attacker, usually as part of a botnet.

1. It is controlled remotely without the owner's knowledge, and the owner usually notices nothing.
2. It is used to launch attacks such as DDoS, spam, phishing and click fraud, while hiding the attacker's identity.

RSA is an asymmetric (public-key) cryptosystem whose security rests on the difficulty of factoring a large number $n = pq$.

Key generation

1. Choose two large distinct primes $p$ and $q$.
2. Compute $n = p \times q$.
3. Compute Euler's totient $\phi(n) = (p-1)(q-1)$.
4. Choose an integer $e$ with $1 < e < \phi(n)$ and $\gcd(e, \phi(n)) = 1$.
5. Compute $d$ such that $d \cdot e \equiv 1 \pmod{\phi(n)}$ (using the extended Euclidean algorithm).
6. Public key $PU = \{e, n\}$; private key $PR = \{d, n\}$. Discard $p$, $q$ and $\phi(n)$ (or keep them secret).

Encryption (sender uses the receiver's public key), plaintext $M < n$:

$C = M^{e} \bmod n$

Decryption (receiver uses own private key):

$M = C^{d} \bmod n$

Decryption works because $ed \equiv 1 \pmod{\phi(n)}$, so $C^d = M^{ed} = M^{1 + k\phi(n)} \equiv M \pmod n$ by Euler's theorem.

Given $p = 11$, $q = 7$.

$n = pq = 77,\qquad \phi(n) = (p-1)(q-1) = 10 \times 6 = 60$

(i) Public key. Choose $e = 7$, since $\gcd(7, 60) = 1$ and $1 < 7 < 60$.

Public key $= (e, n) = (7, 77)$.

(ii) Private key. Find $d$ with $7d \equiv 1 \pmod{60}$. Taking $d = 43$: $7 \times 43 = 301 = 5 \times 60 + 1$, so $7 \cdot 43 \equiv 1 \pmod{60}$.

Private key $= (d, n) = (43, 77)$.

(iii) Ciphertext for $M = 6$.

$C = M^e \bmod n = 6^7 \bmod 77$

• $6^2 = 36$
• $6^3 = 216 \bmod 77 = 62$
• $6^4 = 62 \times 6 = 372 \bmod 77 = 64$
• $6^7 = 6^4 \cdot 6^3 = 64 \times 62 = 3968 \bmod 77 = 41$

Hence $C = 41$.

(Check: $41^{43} \bmod 77 = 6$ recovers the message.)

DES (Data Encryption Standard) is a symmetric Feistel block cipher. It encrypts a 64-bit block using a 56-bit key (64 bits with 8 parity bits) in 16 rounds.

Encryption

1. Initial Permutation (IP): the 64-bit plaintext block is rearranged by a fixed table and split into a left half $L_0$ and a right half $R_0$ of 32 bits each.
2. 16 Feistel rounds: for $i = 1 \dots 16$ $L_i = R_{i-1},\qquad R_i = L_{i-1} \oplus f(R_{i-1}, K_i)$
3. Round function $f$:
   • Expansion (E): $R_{i-1}$ is expanded from 32 to 48 bits.
   • Key mixing: the 48 bits are XORed with the 48-bit round subkey $K_i$.
   • Substitution: the result is split into eight 6-bit groups; each passes through an S-box giving 4 bits (32 bits in total).
   • Permutation (P): the 32 bits are permuted.
4. Swap and Final Permutation ($IP^{-1}$): after round 16 the halves are swapped ($R_{16}L_{16}$) and the inverse initial permutation gives the 64-bit ciphertext.

Subkeys: the 56-bit key (after PC-1) is split into two 28-bit halves, which are rotated left by 1 or 2 bits each round and compressed by PC-2 to a 48-bit $K_i$.

Decryption

Decryption uses the same algorithm with the subkeys applied in reverse order ($K_{16}, K_{15}, \dots, K_1$). This works because of the Feistel structure: $R_{i-1} = L_i$ and $L_{i-1} = R_i \oplus f(L_i, K_i)$, so each round can be undone without inverting $f$.

Subjects: active entities that request access to resources, such as a user, a process running on behalf of a user, or an application. Example: a user Ram or a running program.

Objects: passive resources to which access is controlled, such as files, records, databases, devices or programs. Example: salary.xlsx, a database table.

Access rights: the operations a subject may perform on an object, such as read, write, execute, delete, create, search. Example: Ram has read and write on report.doc but only read on salary.xlsx.

Together they form the access matrix, with subjects as rows, objects as columns and rights in the cells.

RBAC versus ABAC

A dictionary attack tries likely passwords (common words, names, leaked passwords and their variations) rather than all possible combinations.

Offline dictionary attack

1. The attacker first obtains the system's password file of hashed passwords (by breaching the server, a backup or a leak).
2. They hash each word of a dictionary, with common variations, using the same hash function (and salt, if known).
3. They compare each result against the stolen hashes; a match reveals the password.

It needs no interaction with the system, so lockouts and rate limits do not apply and it can run at very high speed (also with precomputed rainbow tables and GPUs). Defences: salting, slow hash functions (bcrypt, scrypt, Argon2), protecting the password file.

Online dictionary attack

1. The attacker targets a specific account on a live system.
2. They submit candidate passwords from the dictionary through the normal login interface, one after another.
3. A success is recognised by a login being accepted.

It is slow and noisy because every attempt goes through the server. Defences: account lockout, rate limiting, CAPTCHA, multi-factor authentication, monitoring of failed logins.

The Open Identity Trust Framework (OITF) is a model for federated identity in which trust between the parties is defined by common rules. It has three main roles.

• Identity provider (IdP): creates and manages the user's digital identity, authenticates the user, and issues assertions of identity (for example a login with Google). Relying parties trust its assertion.
• Attribute provider (AP): an authoritative source that holds and supplies additional attributes about the user, such as age, address, qualification or credit rating, usually with the user's consent. Examples are a bank, a university or a government registry.
• Relying party (RP): the service provider or application that needs to know the user's identity or attributes before granting access. It does not manage credentials itself but relies on the identity and attribute assertions from the IdP and APs to make its authorisation decision.

The user (subject) consents to the exchange, and a trust framework (legal, technical and policy rules) binds all the parties.

Zombie: a compromised computer connected to the Internet that has been taken over by an attacker through malware and is controlled remotely, without the owner's knowledge. Large numbers of zombies form a botnet, used for DDoS attacks, spam and further attacks that hide the attacker's identity.

Rootkit: a set of programs installed on a system to gain and maintain hidden, privileged (root/administrator) access. It modifies the operating system, hiding its own files, processes, network connections and other malware from the user and from antivirus tools, and is therefore difficult to detect and remove.

Trojan horse: a program that appears to be useful or legitimate but contains hidden malicious code which runs when the user executes it. It does not replicate by itself. It is used to steal data, open backdoors, install other malware or damage the system, and spreads by tricking users into running it.

Nepal's cyber law is still developing.

• Electronic Transactions Act, 2063 (2008): the main law. It gives legal recognition to electronic records and digital signatures, regulates the Controller of Certifying Authorities and certifying authorities, and defines computer-related offences such as unauthorised access, damage to computer systems and source code, publishing illegal material in electronic form, and breach of confidentiality. It provides penalties of fines and imprisonment and creates the Information Technology Tribunal and an appellate tribunal to deal with cases.
• Constitution of Nepal (2072): guarantees the right to privacy.
• Related laws: the Individual Privacy Act, 2075, the Muluki Criminal Code, 2074 (some cyber-related provisions), and the National Cyber Security Policy, 2080 and the Information Technology and Cyber Security Bill, which were introduced to address gaps.
• Weaknesses: the Act is old and does not adequately cover modern crimes such as cyberbullying, online fraud, data protection and social-media abuse; enforcement capacity, trained manpower and awareness are limited. A comprehensive and updated law is needed.

After risks are identified and assessed in security risk analysis, an organisation chooses how to treat each risk. The main options are:

1. Risk acceptance: knowingly accepting the risk without further action when its likelihood or impact is low, or when the cost of control exceeds the potential loss.
2. Risk avoidance: eliminating the risk by not carrying out the activity or not using the vulnerable system or service (for example, not exposing a service to the Internet).
3. Risk reduction (mitigation): applying controls to reduce the likelihood or the impact, such as firewalls, patching, encryption, access control, backups and staff training.
4. Risk transfer (sharing): shifting the financial consequences to a third party, for example through insurance or outsourcing, with contractual agreements.

The selected treatment is documented in a risk treatment plan; any residual risk that remains after treatment must be reviewed and formally accepted by management.

Use of S-boxes in DES. The S-boxes provide the substitution step of each DES round and are its only non-linear component, giving confusion (a complex relationship between key and ciphertext). Without them, DES would be linear and easily broken. There are eight S-boxes; each takes a 6-bit input and produces a 4-bit output, so the 48-bit output of the key-mixing step becomes 32 bits.

Operation. Each S-box is a table of 4 rows (0-3) and 16 columns (0-15). For a 6-bit input $b_1b_2b_3b_4b_5b_6$:

• the row is given by the outer bits $b_1b_6$;
• the column is given by the inner four bits $b_2b_3b_4b_5$;
• the entry at that row and column, written in 4 bits, is the output.

Example. Input to S1 = 011011.

• Outer bits 0 and 1 give 01 = row 1.
• Inner bits 1101 = column 13.
• S1, row 1, column 13 = 5, so the output is 0101.

The 6-bit block 011011 is thus replaced by the 4-bit block 0101.

SHA-2 is a family of hash functions (SHA-224, 256, 384, 512). The description below is for SHA-256, which produces a 256-bit digest from a message of up to $2^{64}$ bits, using 512-bit blocks.

1. Padding: append a single 1 bit, then 0 bits until the length is 448 mod 512, then a 64-bit field holding the original message length, so the total is a multiple of 512 bits.
2. Parsing: divide the padded message into 512-bit blocks $M_1, \dots, M_N$.
3. Initial hash value: eight 32-bit words $H_0 \dots H_7$ (the fractional parts of the square roots of the first eight primes).
4. Message schedule: for each block, expand the 16 words into 64 words $W_0 \dots W_{63}$ using $W_t = \sigma_1(W_{t-2}) + W_{t-7} + \sigma_0(W_{t-15}) + W_{t-16}$
5. Compression: initialise working variables $a \dots h$ with the current hash value. For 64 rounds, update them using the functions Ch, Maj, $\Sigma_0$, $\Sigma_1$ (bitwise rotations, shifts and XOR), the word $W_t$ and a round constant $K_t$ (from the cube roots of the first 64 primes). All additions are modulo $2^{32}$.
6. Update the hash: add the working variables to the current hash value ($H_i = H_i + a, \dots$).
7. Output: after the last block, the concatenation $H_0 \| H_1 \| \dots \| H_7$ is the 256-bit digest.

Rabin-Miller (Miller-Rabin) algorithm to test whether $n$ (odd) is prime:

1. Write $n - 1 = 2^s \cdot d$ with $d$ odd.
2. Choose a random base $a$ with $1 < a < n-1$.
3. Compute $x = a^d \bmod n$. If $x = 1$ or $x = n-1$, $n$ is probably prime for this base.
4. Otherwise repeat $s-1$ times: $x = x^2 \bmod n$. If $x = n-1$, $n$ is probably prime for this base; if $x = 1$, $n$ is composite.
5. If $n-1$ was never reached, $n$ is composite.
6. Repeat with several bases; if $n$ passes all, it is probably prime (error probability at most $4^{-k}$ for $k$ bases).

Test of $n = 341$

$n - 1 = 340 = 2^2 \times 85$, so $s = 2$, $d = 85$. Take $a = 2$.

• $2^{10} = 1024 = 3 \times 341 + 1 \equiv 1 \pmod{341}$.
• $x_0 = 2^{85} = (2^{10})^8 \cdot 2^5 \equiv 32 \pmod{341}$. This is neither 1 nor 340.
• $x_1 = 32^2 = 1024 \equiv 1 \pmod{341}$. This is 1, not 340.

The value $n-1 = 340$ never appears, and we reached 1 without passing through $-1$. Hence 341 is composite (indeed $341 = 11 \times 31$), even though it passes the simple Fermat test to base 2.

Interception: an attack on confidentiality in which an unauthorised party gains access to data or communication in transit or storage without altering it. Example: sniffing packets on an unsecured Wi-Fi network to read someone's login details, or wiretapping a phone call.

Repudiation: a party denies having performed an action, such as sending a message or making a transaction, or denies having received it. Example: a customer claims they never placed an online order, or a sender denies sending an email. It is countered by non-repudiation measures: digital signatures, logs and audit trails.

Incapacitation: an attack that disables or reduces the availability of a system, service or resource, or its ability to perform its function. Example: a DDoS attack making a website unreachable, or malware that destroys a server's data or damages equipment.

Substitution versus transposition cipher

Generation of the 16 DES subkeys

1. The 64-bit key is passed through Permuted Choice 1 (PC-1), which drops the 8 parity bits and permutes the rest, giving 56 bits.
2. The 56 bits are split into two 28-bit halves $C_0$ and $D_0$.
3. In each round $i$, both halves are circularly shifted left by 1 bit (rounds 1, 2, 9, 16) or 2 bits (other rounds), giving $C_i$ and $D_i$.
4. $C_i$ and $D_i$ are joined (56 bits) and passed through Permuted Choice 2 (PC-2), which selects and permutes 48 bits to give subkey $K_i$.
5. The shifted halves are carried to the next round. This is repeated to get $K_1 \dots K_{16}$.

Finite field

A finite field (Galois field, $GF(p^n)$) is a set with a finite number of elements in which addition, subtraction, multiplication and division (except by zero) are defined and obey the usual field axioms. The number of elements is always a prime power $p^n$. $GF(p)$ is the integers modulo a prime $p$; $GF(2^n)$ uses polynomials modulo an irreducible polynomial.

Implications: arithmetic never leaves the set, so results stay of fixed size; every non-zero element has a multiplicative inverse, which allows decryption and key calculation. Finite fields are the basis of AES (GF($2^8$)), elliptic-curve cryptography, RSA-related modular arithmetic and Diffie-Hellman.

Purposes of message authentication

• To verify the integrity of a message, i.e. that it was not altered in transit.
• To verify the authenticity of the source, i.e. that it really came from the claimed sender.
• To detect replay, delay or reordering (timeliness and sequence).
• To support non-repudiation when combined with digital signatures.

Techniques include message authentication codes (MACs), hash functions and digital signatures.

MD5 (Message Digest 5) produces a 128-bit hash from a message of any length, processing 512-bit blocks.

1. Padding: append a 1 bit and then 0 bits until the length is 448 mod 512.
2. Append length: add the original length as a 64-bit value, so that the total is a multiple of 512 bits.
3. Initialise the buffer: four 32-bit registers $A = 67452301$, $B = EFCDAB89$, $C = 98BADCFE$, $D = 10325476$ (hex).
4. Process each 512-bit block (sixteen 32-bit words) in four rounds of 16 steps (64 steps in total). Each round uses a different nonlinear function: $F = (B \wedge C) \vee (\neg B \wedge D)$, $G = (B \wedge D) \vee (C \wedge \neg D)$, $H = B \oplus C \oplus D$, $I = C \oplus (B \vee \neg D)$. Each step is $a = b + ((a + f(b,c,d) + M_i + K_t) \lll s)$ with $K_t$ a constant from the sine function and $s$ a left-rotation amount; the registers are then rotated.
5. After each block, the results are added to the previous values of $A, B, C, D$.
6. Output: the concatenation of $A, B, C, D$ (128 bits) is the message digest.

MD5 is now considered insecure because collisions can be found easily.

Malicious software (malware) is any program or code deliberately created to harm, disrupt, or gain unauthorised access to a computer system, its data or its users, without the owner's knowledge or consent.

Types of malware

1. Virus: attaches itself to a legitimate program or file and replicates when the host is executed, spreading to other files. It may corrupt data or slow the system.
2. Worm: a self-replicating program that spreads over networks by itself exploiting vulnerabilities, without needing a host file or user action. It consumes bandwidth and resources.
3. Trojan horse: appears to be a useful program but carries hidden malicious functions; does not replicate itself.
4. Ransomware: encrypts the victim's files, or locks the system, and demands payment for the key.
5. Spyware: secretly gathers information, such as browsing habits and passwords, and sends it to an attacker. Keyloggers record keystrokes.
6. Adware: displays unwanted advertisements and may track user behaviour.
7. Rootkit: hides its presence and gives the attacker privileged persistent access.
8. Backdoor (trapdoor): a hidden entry point that bypasses normal authentication.
9. Logic bomb: code that is triggered by a certain condition or date and performs a harmful action.
10. Bots/zombies and botnets: compromised machines controlled remotely, used for DDoS and spam.
11. Fileless malware and scareware also exist; they run in memory or deceive users into buying fake security tools.

Protection includes antivirus software, patching, firewalls, backups and user awareness.

Let $f(x) = 2x^2 + 4x + 2$ and $g(x) = 5x + 6$ over $GF(7)$, so all coefficients are reduced mod 7.

Addition

$f + g = 2x^2 + (4+5)x + (2+6) = 2x^2 + 9x + 8 \equiv 2x^2 + 2x + 1$

Subtraction

$f - g = 2x^2 + (4-5)x + (2-6) = 2x^2 - x - 4 \equiv 2x^2 + 6x + 3$

Multiplication

$f \cdot g = (2x^2)(5x) + (2x^2)(6) + (4x)(5x) + (4x)(6) + (2)(5x) + (2)(6)$ $= 10x^3 + 12x^2 + 20x^2 + 24x + 10x + 12 = 10x^3 + 32x^2 + 34x + 12$

Reducing mod 7 ($10 \to 3$, $32 \to 4$, $34 \to 6$, $12 \to 5$):

$f \cdot g = 3x^3 + 4x^2 + 6x + 5$

Assets: anything of value to the organisation that needs protection: hardware, software, data and information, network infrastructure, services, people, and reputation. Security measures are chosen according to the value of the asset.

Threats: potential events or actors that could exploit a vulnerability and cause harm to an asset. Examples: hackers, malware, natural disasters, insider misuse, hardware failure. A threat is only a possibility of harm.

Attacks: actual attempts or actions that exploit a vulnerability to compromise an asset. They are the realisation of a threat.

• Passive attacks only observe or monitor (eavesdropping, traffic analysis); they are hard to detect.
• Active attacks modify data or disrupt service (masquerade, replay, modification of messages, denial of service).

Relationship: an attacker (threat agent) carries out an attack by exploiting a vulnerability in an asset; the result is loss of confidentiality, integrity or availability. Risk is the combination of threat likelihood and asset impact.

Need for two-factor authentication (2FA)

A password alone is a single factor ("something you know") and is weak: it can be guessed, phished, stolen from a database, captured by a keylogger or reused across sites. 2FA requires a second, independent factor, from "something you have" (OTP token, phone, smart card) or "something you are" (fingerprint, face), so that a stolen password alone is not enough to log in. It greatly reduces account takeover.

Security issues in user authentication

• Weak, default or reused passwords and poor user practice.
• Dictionary and brute-force attacks (online and offline).
• Phishing and social engineering.
• Eavesdropping on credentials in transit, replay attacks and man-in-the-middle attacks.
• Theft of the password file or a poorly protected (unsalted) hash store.
• Keyloggers and shoulder surfing.
• Lost or stolen tokens and smart cards; cloned cards.
• Biometric problems: false acceptance and rejection, spoofing, and the fact that a compromised biometric cannot be changed.
• Weak account recovery procedures.

Security auditing is the independent review and analysis of system records and activities to check compliance with policy, detect violations and support investigation. The security auditing architecture (as in X.816 and Stallings) has these components:

• Event discriminator: logic that decides which events (for example logins, access to files, privilege changes) are of interest and passes them on for audit.
• Audit recorder: takes the selected events, formats them and writes them to the audit trail (log).
• Alarm processor: generates alarms or notifications for certain critical events, such as repeated failed logins.
• Audit trail: the stored record of events, protected from tampering, and used for later analysis.
• Audit analyzer: analyses the trail to detect patterns, anomalies or intrusions and may feed new rules back to the discriminator.
• Audit archiver: moves old audit records to long-term storage.
• Audit provider: gives authorised users access to the records.
• Audit trail examiner and reports: the auditor uses these to review activity and produce summary reports.

Data may be collected at application, system, network and user level, and it must be protected for integrity and confidentiality.

Cybercrime: any criminal activity carried out using computers, networks or the Internet, where the computer may be a tool, a target or a place of crime. Examples: online fraud, hacking, identity theft, cyberstalking, child exploitation material.

Computer crime: a crime in which a computer is the target or is directly involved in the offence, for example unauthorised access, data theft or damage, malware and denial-of-service attacks. It is often treated as a narrower category within cybercrime, which also includes traditional crimes committed online.

Intellectual property (IP): creations of the mind that are legally protected so that the creator controls their use.

• Copyright: protects original works, such as software, books, music and databases.
• Patents: protect inventions for a limited period.
• Trademarks: protect names, logos and brands.
• Trade secrets: protect confidential business information.

Cyber-related IP issues include software piracy, illegal copying and distribution of content, counterfeiting, domain-name squatting and theft of source code or trade secrets. Law and digital rights management try to protect them.

Attack tree: a hierarchical, tree-structured diagram that models how a system can be attacked. The root node is the attacker's ultimate goal; child nodes are sub-goals or steps needed to reach it. Nodes are joined by OR (any child suffices) or AND (all children are required). Leaf nodes are individual attacks and may be given costs or probabilities. It helps to analyse threats, find the weakest paths and decide on countermeasures. Example: goal "obtain user's password" with branches phishing, keylogger, guessing and stealing the password file.

Password-based authentication: the user proves identity by supplying a secret password (something you know) with a user ID.

• The system stores not the password but a hash of it, usually with a salt (a random per-user value), as $H(\text{password} \| \text{salt})$ in the password file.
• At login, the entered password is hashed with the stored salt and compared with the stored value.
• It is simple and cheap but vulnerable to guessing, dictionary and brute-force attacks, phishing and keyloggers.
• Countermeasures: strong password policy, slow hashing algorithms, salting, account lockout, restricted access to the password file, and multi-factor authentication.

Subjects, objects and access rights

• Subject: an active entity that requests access, such as a user or a process acting for the user.
• Object: a passive resource that is accessed, such as a file, database, device or program.
• Access right: the permitted operation of a subject on an object, such as read, write, execute, delete, create.

Example: user Sita (subject) has read and write rights on grades.db (object) but only read right on policy.pdf.

Ethical issues in cyber security

• Privacy and confidentiality: monitoring of users, collection and handling of personal data, and the extent to which it is justified.
• Responsible disclosure: how a security researcher or ethical hacker reports a vulnerability instead of exploiting or selling it.
• Authorised testing: penetration testing must be done only with permission and within scope.
• Misuse of privileged access by administrators and insiders.
• Intellectual property: piracy and misuse of licensed software and content.
• Professional conduct: honesty, competence, following codes of ethics (ACM, IEEE), and avoiding conflicts of interest.
• Dual-use tools and cyberwarfare or surveillance concerns.

Security policy: a formal, documented statement of an organisation's rules, practices and responsibilities for protecting its information and systems. It specifies what is to be protected, what is allowed and prohibited, and the consequences of violations. It is approved by management and forms the basis for choosing controls, for example acceptable-use, password, access control and incident response policies.

Implementing the logging function

1. Decide which events must be logged according to the policy: logins and failures, privilege changes, access to sensitive files, configuration changes, errors and network connections.
2. Record for each event: timestamp (synchronised clocks), user or process ID, source address, action, object and outcome. Never record passwords or secrets.
3. Implement logging at the right levels: application (code calls a logging library), operating system (syslog, event log), and network devices (firewall and IDS logs).
4. Send the logs to a central, separate log server to prevent tampering by a compromised host.
5. Protect them with restricted access, integrity checks (hashes, signatures), encryption in transit and in storage.
6. Define retention, rotation and archiving, and review them regularly using automated analysis or SIEM tools with alerts.