Revision approach
- Security reasoning
- Assets; threats; trust boundaries; justified controls
- Damaged property; failure mechanism
- Control choice and limits
- Program security; trusted OS evaluation
- Database security; four blueprint outcomes
👁 Full explanation
Security is reasoning about assets, threats, trust boundaries and justified controls. Learn mechanisms as well as names: identify the damaged property, explain the failure, choose a control and state its limits. The four blueprint outcomes include program security, evaluated trusted operating systems and database security. - Scenario analysis
- Asset; actor; violated property
- Mechanism and most direct control
👁 Full explanation
For each scenario identify the asset, actor, violated property, mechanism and most direct control. - Cryptographic calculation practice
- Key direction; classical cipher arithmetic
- Small RSA calculations
- Supplied answer key ≠ correctness
👁 Full explanation
Practise key direction, classical cipher arithmetic and small RSA calculations; justify answers from the mechanism and arithmetic. - Security contrasts
- Confidentiality versus integrity models
- Function versus assurance
- Detection versus prevention
- Backup versus replication
- Test assumptions before answer selection
👁 Full explanation
Compare confidentiality with integrity models, function with assurance, detection with prevention, and backup with replication. Test assumptions before selecting one answer.
SEC01
CIA and the property actually harmed
[Exam Focus]- CIA: property actually harmed
- Confidentiality: restricted disclosure
- Credit-card copying violates secrecy
- Intact original ≠ preserved confidentiality
- Integrity: unauthorized/improper change prevention
- Altered balance; inserted false message
- Availability: timely usable authorized service
- Crashes; resource starvation; denied access
- One event may harm multiple goals
👁 Full explanation
Confidentiality restricts disclosure: copying a credit-card database violates secrecy even if the original stays intact. Integrity restricts unauthorized or improper changes: altering a balance or inserting a false message damages correctness. Availability supplies timely, usable service to authorized users: crashes, resource starvation and denied access violate it. One event can harm several goals. - Identity, evidence and information assurance
- Authentication: identity or claim establishment
- Authorization: permitted actions
- Accountability: responsible entities linked to actions
- Reliable identity and protected logs
- Non-repudiation: origin/receipt evidence
- Signatures ≠ physically impossible denial
- Assurance: confidence, risk management, protection
- Detection; response; restoration; information lifecycle
- Data at rest, in use, in transit
- Accidental corruption and intentional attacks
👁 Full explanation
Authentication establishes an identity or other claim; authorization decides permitted actions. Accountability links actions to responsible entities through reliable identity and protected logs. Non-repudiation supplies evidence supporting origin or receipt; signatures do not make denial physically impossible. Information assurance includes confidence, risk management, protection, detection, response and restoration across the information lifecycle. Data security protects information at rest, in use and in transit, including accidental corruption as well as intentional attacks.
13 related practice questions
Blueprint: LO1 · Note references: SEC-M, SEC-N
- CIA: property actually harmed
SEC02
Threat, vulnerability, risk and control
[Exam Focus]- Asset, threat, vulnerability, attack, control
- Assets: data, software, hardware, service, reputation
- Threat: potentially harmful circumstance
- Vulnerability: exploitable weakness
- Attack: actual attempt
- Control: reduced likelihood or impact
- Software flaw ≠ active attack
- Risk: likelihood and consequence
- Unmeasured labels ≠ universally meaningful product
👁 Full explanation
An asset is something valuable: data, software, hardware, service or reputation. A threat is a potentially harmful circumstance; a vulnerability is an exploitable weakness; an attack is an actual attempt; a control reduces likelihood or impact. A software flaw is not automatically an active attack. Risk concerns likelihood and consequence, not a universally meaningful numeric product of two unmeasured labels. - Control purposes and categories
- Preventive: block; detective: reveal
- Corrective/recovery: restore safe operation
- Deterrent: discourage attempts
- Encryption: disclosure prevention
- Audit log: detection and accountability evidence
- Physical; technical; administrative categories
- Categories ≠ competing stages
- Firewall cannot replace policy or locks
👁 Full explanation
Preventive controls block events, detective controls reveal them, corrective/recovery controls restore safe operation, and deterrents discourage attempts. Encryption is preventive for disclosure; an audit log is principally detective/accountability evidence. Physical, technical and administrative are control categories, not competing stages. An external firewall cannot replace a written policy or a locked equipment room.
5 related practice questions
Blueprint: LO1 · Note references: SEC-M, SEC-N
- Asset, threat, vulnerability, attack, control
SEC03
Attack classifications and attacker intent
- Attack effects and 4D
- Interception: observe/copy
- Modification: alter
- Interruption: block
- Fabrication: false insertion
- Disclosure; deception; disruption; usurpation
- Usurpation: unauthorized control
- DoS: disruption and availability loss
- DoS need not obtain control
👁 Full explanation
Interception copies or observes data, modification alters it, interruption blocks it, and fabrication inserts false material. The 4D classification uses disclosure, deception, disruption and usurpation, the last meaning unauthorized control. DoS primarily demonstrates disruption/availability loss; it need not give control of the victim. - Passive versus active attacks
- Passive: unchanged target exchange
- Sniffing; traffic analysis
- Active: inject, alter, replay, disrupt
- Passive/active ≠ offline/online
- Encrypted traffic still exposes timing/size
- Traffic analysis infers relationships
- Neither universally easy to prevent/detect
👁 Full explanation
Passive attacks observe without changing the target exchange: sniffing and traffic analysis. Active attacks inject, alter, replay or disrupt. These are not synonyms for offline and online. Traffic analysis can infer relationships from timing/size even when content is encrypted. Neither category is universally easy to prevent or detect. - Attacker intent and trust position
- White hat: authorization and scope
- Black hat: malicious or unauthorized
- Competitor: commercial secrets
- Hacktivist: cause
- Hacker label ≠ legality
- Insider/outsider: origin and trust position
- Origin ≠ attack mechanism
👁 Full explanation
White-hat testing requires authorization and scope; black-hat activity is malicious or unauthorized. A competitor may seek commercial secrets; hacktivists pursue a cause. “Hacker” alone does not establish legality. Insider versus outsider describes origin/trust position, not the specific mechanism.
11 related practice questions
Note references: SEC-M, SEC-N
- Attack effects and 4D
SEC04
Malware: propagation, disguise and payload
- Malware replication and disguise
- Virus: attaches to program/document host
- Infected-host execution spreads virus
- Worm: independent replication, commonly networked
- Trojan: useful disguise, malicious behavior
- Trojan need not self-replicate
- Labels describe different properties
- Package may contain multiple components
👁 Full explanation
A virus replicates by attaching to a host program or document; execution of the infected host spreads it. A worm replicates independently, commonly across networks. A Trojan disguises malicious behavior as something useful and does not require self-replication. These labels describe different properties, so a malware package may contain several components. - Malware payloads and defenses
- Spyware: monitoring; keylogger: keystrokes
- Adware: unwanted ads, possible tracking
- Ransomware: encryption/locking and extortion
- Logic bomb: trigger-dependent
- Backdoor: ordinary-access bypass
- Rootkit: hidden presence/privileged activity
- Zombie/bot: remote commands; botnet: collection
- Malware: umbrella, not replication method
- Update; restrict execution; isolate compromise
- Tested offline backups
- Antivirus never guarantees complete protection
👁 Full explanation
Spyware monitors users; a keylogger records keystrokes. Adware displays unwanted advertising and may also track users. Ransomware denies access through encryption/locking and extortion. A logic bomb waits for a trigger. A backdoor bypasses ordinary access paths; a rootkit hides malicious presence or privileged activity. A zombie/bot follows remote commands; a botnet is a collection. Malware is the umbrella term, not a specific replication method. Update, restrict execution, isolate compromise and maintain tested offline backups; no antivirus guarantees complete protection.
9 related practice questions
Note references: SEC-M, SEC-N
- Malware replication and disguise
SEC05
Social engineering, spoofing and sessions
- Social engineering
- Phishing: trusted-source impersonation
- Secret theft or induced unsafe action
- Spear phishing: specific person
- Verify through independently known channel
- Shoulder surfing: observed entry
- Pretexting: invented disclosure reason
- Authorized monitoring ≠ necessarily attack
👁 Full explanation
Phishing impersonates a trusted source to obtain secrets or induce an unsafe action; spear phishing targets a specific person. Verify a request through an independently known channel. Shoulder surfing observes entry; pretexting invents a reason for disclosure. Monitoring software used with authorization is not necessarily an attack merely because it records activity. - Spoofing, replay and session attacks
- Masquerade: another identity
- ARP poisoning: local IPv4-to-MAC associations
- DNS spoofing/cache poisoning: false resolutions
- IP spoofing: false source address
- Intermediary: interception and possible alteration
- Replay: reuse valid old message
- Replay defenses: nonces, timestamps, sequence checks
- Session hijacking: stolen/predicted valid token
- Protect transport; regenerate IDs after login
- Restricted cookies; per-request server authorization
👁 Full explanation
Masquerade claims another identity. ARP spoofing poisons local IPv4-to-MAC associations; DNS spoofing/cache poisoning supplies false name resolutions; IP spoofing falsifies a source address. An intermediary attack intercepts and can alter exchanges. A replay reuses a valid old message; nonces, timestamps and sequence checks can reject it. Session hijacking steals or predicts a valid session token. Protect transport, regenerate session IDs after login, restrict cookies and check authorization server-side on every sensitive request.
9 related practice questions
Note references: SEC-M, SEC-N
- Social engineering
SEC06
DoS, wireless attacks and layer-specific defenses
- Resource-exhaustion attacks
- DoS: exhaust or disable resource
- DDoS: multiple sources
- Bots; reflected/amplified responses
- SYN flood: incomplete-handshake state
- DNS flooding: query capacity
- NXDOMAIN: nonexistent-name resolver stress
- Fragment floods: reassembly/processing exhaustion
- Rate limits; SYN cookies; filtering
- Upstream capacity controls
- Defense depends on bottleneck
👁 Full explanation
DoS exhausts or disables a resource; distributed DoS uses multiple sources, often bots or reflected/amplified responses. A SYN flood leaves many incomplete TCP handshakes occupying state. DNS flooding targets query capacity; NXDOMAIN attacks generate queries for nonexistent names to stress resolvers. Fragment floods abuse reassembly or packet-processing resources. Rate limits, SYN cookies, filtering and upstream capacity controls address different bottlenecks. - Wireless attacks and defense layers
- Rogue AP: imitate/bypass approved service
- Bluesnarfing: Bluetooth information theft
- Bluejacking: unsolicited Bluetooth messages
- Phishing not wireless-specific
- Authenticated IPsec: IP impersonation resistance
- DNSSEC: DNS-data authentication
- TLS: application-transport authentication/protection
- Bounds-safe code: overflow prevention
- HTTPS cannot repair unsafe memory copy
👁 Full explanation
Rogue access points imitate or bypass approved wireless service. Bluesnarfing steals Bluetooth information; bluejacking sends unsolicited Bluetooth messages. Phishing is not specific to wireless. Match a defense to its layer: authenticated IPsec can resist IP impersonation, DNSSEC authenticates DNS data, TLS authenticates/protects application transport, and bounds-safe code prevents overflows. HTTPS cannot fix an unsafe memory copy in a server.
7 related practice questions
Note references: SEC-M, SEC-N
- Resource-exhaustion attacks
SEC07
Identification, authentication and factors
[Exam Focus]- Access-control sequence and direction
- Identify → authenticate → authorize → record
- Identification: username/claim, not proof
- Identification omitted: authentication first available stage
- User-to-host: user proves identity to host
- Host-to-user: host proves identity to user
- Arrow: prover → verifier
👁 Full explanation
A common access sequence is identify the subject, authenticate the claim, authorize the operation, then record relevant events. Identification is the username/claim, not its proof. When a sequence begins with authentication, distinguish it from the preceding identification stage. User-to-host means a user proves identity to a host; host-to-user means the host proves its identity to a user; the arrow names the prover and verifier. - Authentication factors
- Knowledge: password/PIN
- Possession: token/card
- Inherence: biometric, fingerprint
- Behavioral: typing rhythm, handwriting
- Textbook category: something one does
- One biometric ≠ three factors
- Password plus PIN: one factor class
- Card plus PIN: two factors
- OTP factor depends on generation/delivery
👁 Full explanation
Knowledge is a password/PIN, possession is a token/card, and inherence is a biometric such as a fingerprint. Behavioral biometrics include typing rhythm or handwriting; some textbooks call these “something one does.” A body characteristic is not “three-factor authentication”: one biometric is one factor. Password plus PIN remains one factor class; card plus PIN is two. An OTP’s factor depends on its delivery/generation mechanism.
9 related practice questions
Blueprint: LO1 · Note references: SEC-M, SEC-N
- Access-control sequence and direction
SEC08
Passwords and delegated authorization
- Password attacks and protection
- Brute force: enumerate guesses
- Dictionary: prioritize likely words
- Credential stuffing: reuse leaked credentials
- Online: server rate limits
- Offline stolen verifiers: no server limits
- Short secrets vulnerable in either setting
- Unique long secrets; password manager
- Rate limiting; suitable MFA
- Salted slow hashes, not reversible plaintext
- Public salt defeats shared precomputed lookup
👁 Full explanation
Brute force enumerates guesses; dictionary attacks prioritize likely words; credential stuffing tries previously leaked credentials on another service. Online attempts face server rate limits; offline attacks against stolen verifiers do not. Short passwords can fail in either setting. Use unique long secrets and password managers, rate limiting and suitable MFA; store salted slow password hashes, not reversible plaintext passwords. A salt prevents shared precomputed lookup, but is not secret. - OAuth authorization framework
- Client: limited access tokens
- Authorization server: authentication/owner approval
- Resource server: protected-data token validation
- Authorization server may delegate identity checks
- OAuth alone ≠ complete login identity protocol
- OpenID Connect: added identity layer
👁 Full explanation
OAuth is an authorization framework: a client obtains limited access tokens, the authorization server authenticates/obtains approval from the resource owner, and the resource server validates tokens for protected data. The authorization server can delegate identity checks. OAuth alone does not define a complete end-user login identity protocol; OpenID Connect adds an identity layer.
3 related practice questions
Note references: SEC-M, SEC-N, SEC-OAUTH
- Password attacks and protection
SEC09
Access control and least privilege
[Exam Focus]- Subjects, objects and ACLs
- Subjects request operations on objects
- Object ACL: allowed subjects/actions
- Network ACL: address, protocol, port matching
- Direct effects: classification and filtering
- ACL ≠ guaranteed availability/malware detection
👁 Full explanation
Subjects request operations on objects. An ACL associates an object/resource with allowed subjects or actions; a network ACL matches traffic such as address, protocol and port. Classification and filtering are direct effects; high availability or malware detection is not guaranteed by an ACL. - Access-control models
- DAC: owner grants permissions
- Mandatory: enforced labels and policy
- Ordinary owners cannot override mandatory policy
- RBAC: permissions→roles; users→roles
- ABAC: subject/object/action/environment attributes
- Rule-based: explicit conditions
- Time or source-network rules
👁 Full explanation
DAC lets owners grant permissions; mandatory control enforces labels and policy that ordinary owners cannot override. RBAC gives permissions to roles and assigns users to roles. ABAC evaluates subject, object, action and environment attributes. Rule-based controls apply explicit conditions, such as time or source network. - Privilege restrictions
- Least privilege: needed rights, needed time
- Separation of duties: split sensitive steps
- Deny by default
- Mediate every access
- Revoke stale permissions
- SELECT allowed; UPDATE denied
- Access control supports integrity
- Business-state validity needs additional enforcement
👁 Full explanation
Least privilege gives only needed rights, for needed time. Separation of duties splits sensitive steps across parties. Deny by default, mediate every access and revoke stale permissions. Allowing SELECT but denying UPDATE is an access-control decision that helps integrity; it does not by itself enforce all valid business-state transitions.
5 related practice questions
Blueprint: LO1, LO4 · Note references: SEC-M, SEC-N
- Subjects, objects and ACLs
SEC10
Confidentiality and integrity models
[Exam Focus]- Bell–LaPadula confidentiality
- Simple security: no read up
- Star: no write down
- Strong star: same-level writes only
- TS>S>C>U
- S subject may read C
- S subject cannot write C
- Compartments and DAC may further deny
👁 Full explanation
Bell–LaPadula protects confidentiality. The simple-security rule prohibits reading above a subject’s level; the star rule prohibits writing down. The strong-star variant permits writing only at the same level. With TS>S>C>U, an S subject can read C under the simple rule but cannot write C under star; compartments and discretionary restrictions may still deny access. - Integrity models
- Strict Biba: no read down
- Strict Biba: no write up
- Prevent low-integrity input contaminating higher results
- Clark–Wilson: certified well-formed transformations
- Integrity checks; separation of duties
- Clark–Wilson ≠ confidentiality model
- MAC: enforcement category
- Mandatory policy need not be Bell–LaPadula
👁 Full explanation
Strict Biba protects integrity by preventing read down and write up: untrusted lower-integrity input should not contaminate higher-integrity results. Clark–Wilson protects integrity through certified well-formed transformations, integrity checks and separation of duties. It is not a confidentiality model. “MAC” is an enforcement category and does not force every system to use Bell–LaPadula rather than another label policy.
2 related practice questions
Blueprint: LO1, LO4 · Note references: SEC-N, SEC-MODELS
- Bell–LaPadula confidentiality
SEC11
Physical protection and resilient design
- Physical protection and threat models
- Theft; unauthorized connections
- Heat; humidity; water; surges; fire
- UPS: temporary conditioned power
- Faulty installation/battery: possible hazard
- Disconnected machine: fewer network paths
- Insiders; removable media; supply-chain attacks
- Physical access remains a threat
- Most-secure claim requires threat model
👁 Full explanation
Protect equipment against theft, unauthorized connections, heat, humidity, water, electrical surges and fire. A UPS supplies temporary conditioned power; it is normally protective, but faulty installation/battery failure can itself be hazardous. A disconnected machine loses many network attack paths yet remains exposed to insiders, removable media, supply-chain attacks and physical access. There is no universal “most secure computer” without a threat model. - Resilient security design
- Defense in depth: independent layers
- Minimization: remove unnecessary software/services
- Compartmentalization: limit blast radius
- Fail securely: errors never silently grant
- Uniformity: easier patching and prediction
- Uniformity: correlated failures
- Diversity: reduced common-mode compromise
- Diversity: higher administration cost
- Protection proportional to assets and threats
👁 Full explanation
Defense in depth layers independent controls. Minimization removes unnecessary software and services; compartmentalization limits blast radius. Fail securely means errors do not silently grant permission. Uniform configurations simplify patching and prediction but create correlated failures; diversity may reduce common-mode compromise while raising administration cost. Choose protection proportional to asset value and credible threats.
3 related practice questions
Note references: SEC-M, SEC-N
- Physical protection and threat models
SEC12
Cryptographic vocabulary and security assumptions
- Cryptographic vocabulary
- Plaintext: original; ciphertext: encrypted representation
- Key: algorithm input
- C=E_k(P); P=D_k(C)
- Symmetric five: plaintext, algorithm, secret key
- Ciphertext and decryption algorithm
- Cryptanalysis: unauthorized recovery or breaks
- Cryptology: cryptography plus cryptanalysis
- Steganography: hidden existence
- Encryption: hidden meaning
👁 Full explanation
Plaintext is the original message, ciphertext its encrypted representation, a key is input to an algorithm, encryption computes C=E_k(P), and decryption recovers P=D_k(C). The five conventional symmetric ingredients are plaintext, encryption algorithm, secret key, ciphertext and decryption algorithm. Cryptanalysis seeks recovery or other breaks without the authorized secret; cryptology includes cryptography and cryptanalysis. Steganography hides that a message exists; encryption hides its meaning. - Cryptographic security assumptions
- Known algorithm; protected keys
- Implementation secrecy not main argument
- b-bit key → 2^b possibilities
- Uniform exhaustive-search average: half keyspace
- Algorithm; key size; randomness
- Mode and implementation matter
- Symmetric ≠ inherently less secure
- Speed ratios not fixed constants
👁 Full explanation
Assume the algorithm is known and protect keys: secrecy of implementation is not the main security argument. A b-bit key has 2^b possibilities; exhaustive search averages roughly half the space if keys are uniformly random. Security depends on algorithm, key size, randomness, mode and implementation. Symmetric cryptography is not inherently less secure than public-key cryptography, and speed ratios are not fixed constants.
9 related practice questions
Note references: SEC-M, SEC-N
- Cryptographic vocabulary
SEC13
Substitution, shift and affine ciphers
- Substitution versus transposition
- Substitution: replace symbols
- Transposition: rearrange positions
- Monoalphabetic: one mapping throughout
- Frequency leakage despite large nominal keyspace
- Classical ciphers: teaching, not modern protection
👁 Full explanation
Substitution replaces symbols; transposition changes their positions. A monoalphabetic substitution preserves one mapping throughout the message and leaks frequency patterns despite a large nominal key space. Classical ciphers are teaching devices, not modern data protection. - Caesar, multiplicative and affine arithmetic
- Alphabet mapping: A=0…Z=25
- Caesar: C=(P+k) mod26
- Inverse: P=(C−k) mod26
- k=3: A→D; HELLO→KHOOR
- k=25: ATTACK→ZSSZBJ
- Wrap negatives into 0–25
- Multiplicative: C=kP mod26; gcd(k,26)=1
- Decrypt with modular inverse of k
- Affine: C=aP+b mod26; gcd(a,26)=1
- Inverse relation, not repeated numeric multiplication
👁 Full explanation
With A=0 through Z=25, Caesar encryption is C=(P+k) mod26 and decryption P=(C-k) mod26. A shift of 3 maps A→D and HELLO→KHOOR. Key25 moves back one: ATTACK→ZSSZBJ. Ensure negative results wrap into 0–25. A multiplicative cipher uses C=kP mod26 with gcd(k,26)=1; decryption uses k’s modular inverse. Affine uses C=aP+b mod26 and requires gcd(a,26)=1. The inverse-key relation, not simply the same numeric multiplication, recovers plaintext.
6 related practice questions
Note references: SEC-M, SEC-N
- Substitution versus transposition
SEC14
Vigenère, Playfair and Hill
- Vigenère and autokey
- C_i=(P_i+K_i) mod26
- Repeated or otherwise supplied shifts
- Same letter may encrypt differently
- Repeated short keys leak periodicity
- Autokey extends initial key with message
👁 Full explanation
Vigenère repeats or otherwise supplies shifts K_i and computes C_i=(P_i+K_i) mod26. The same plaintext letter may encrypt differently by position; repeated short keys still leak periodic structure. An autokey scheme extends its initial key using message material. - Playfair method
- Keyed 5×5 grid; commonly merged I/J
- Encrypt letter pairs
- Specify duplicate fillers and padding
- Same row: right
- Same column: down
- Rectangle: other column, original row
- Decrypt by reversed shifts
👁 Full explanation
Playfair uses a keyed 5×5 grid, commonly combining I/J, and encrypts letter pairs. Specify duplicate-letter fillers and padding. Same row moves right, same column moves down, and rectangle pairs take the other column in their original row; decryption reverses shifts. - Hill cipher and known plaintext
- Letter vectors: C=KP mod26
- Invertible K modulo26
- gcd(det(K),26)=1
- Linear structure
- Enough independent known blocks reveal key
- K=CP^-1 mod26
- Claimed known-plaintext resistance: false
- Polygraphic substitution ≠ modern strength
👁 Full explanation
Hill uses C=KP mod26 for letter vectors. K needs an inverse modulo26, equivalently determinant coprime to26. It is linear: enough independent known plaintext/ciphertext blocks reveal K=CP^-1 mod26. Hill is vulnerable to known-plaintext attacks; polygraphic substitution alone is not modern strength.
4 related practice questions
Note references: SEC-M, SEC-N, SEC-NKU
- Vigenère and autokey
SEC15
Transposition and one-time pads
- Transposition procedures and conventions
- Rail fence: specified zigzag, read rails
- Columnar: write rows, ordered columns
- Symbols and counts preserved
- Specify rows; column order; padding; direction
- Inconsistent source-example conventions
- Two rails ABCDEF: ACE and BDF
- Ciphertext ACEBDF
👁 Full explanation
Rail-fence writes along a specified zigzag and reads rails; columnar transposition writes rows and reads columns in a specified order. They preserve the symbols and their counts. Always state rows, column order, padding and direction before computing a transposition cipher. Two-rail zigzag for ABCDEF writes ACE on the first rail and BDF on the second, producing ACEBDF. - One-time pad conditions
- XOR with independent uniformly random secret
- Key at least message length
- Never reuse key
- Perfect secrecy requires every condition
- Reuse: C1 XOR C2=P1 XOR P2
- Vernam XOR ≠ automatically OTP
- Predictable/reused keystream loses guarantee
- Key delivery and storage costs
👁 Full explanation
A one-time pad XORs bits with an independent uniformly random secret key at least as long as the message and never reused. Its perfect secrecy depends on every condition. Reusing a pad leaks C1 XOR C2=P1 XOR P2. A Vernam XOR construction is not automatically a one-time pad: a predictable/reused keystream loses that guarantee. Key delivery and storage remain substantial costs.
2 related practice questions
Note references: SEC-M, SEC-N
- Transposition procedures and conventions
SEC16
Symmetric keys, AES and distribution
- Symmetric keys and distribution
- Shared secret; efficient bulk protection
- n users: n(n−1)/2 pairwise keys
- Trusted KDC changes architecture
- Session key: temporary communication context
- Master/key-encryption key: protects subordinate keys
- Physical distribution; authenticated protected channel
- Trusted third-party distribution
- Uncompromised old key protects new key
- Stolen old key prevents secrecy restoration
👁 Full explanation
Symmetric encryption uses a shared secret and efficiently protects bulk data. Pairwise independent keys for n users require n(n-1)/2 shared keys; a trusted key distribution center changes that architecture. A session key is temporary for a communication context; a master/key-encryption key protects subordinate keys. Distribute keys physically, via an authenticated protected channel, or through a trusted third party. An uncompromised old key can protect a new key, although this does not restore secrecy after the old key is stolen. - AES and cipher construction
- AES block: 128 bits
- Keys: 128/192/256 bits
- Rounds: 10/12/14
- Substitution/permutation design
- SubBytes; ShiftRows; MixColumns; AddRoundKey
- Final round omits MixColumns
- Block cipher: mode and nonce/IV handling
- Authenticated encryption detects tampering
- Stream cipher: data plus keystream
- Nonce uniqueness when construction requires
👁 Full explanation
AES is a 128-bit block cipher with 128/192/256-bit keys and 10/12/14 rounds. Its substitution/permutation design uses SubBytes, ShiftRows, MixColumns and AddRoundKey; the final round omits MixColumns. Block ciphers need a mode and correct nonce/IV handling; authenticated encryption also detects tampering. A stream cipher combines data with a keystream. Never reuse a nonce when the chosen construction requires uniqueness.
3 related practice questions
Note references: SEC-M, SEC-N
- Symmetric keys and distribution
SEC17
DES and Feistel mechanics
- DES Feistel mechanics
- Block: 64 bits
- Key: 56 effective bits, eight parity
- 16 rounds; initial permutation
- L_i=R_(i−1)
- R_i=L_(i−1) XOR f(R_(i−1),K_i)
- Right-half expansion: 48 bits
- XOR with 48-bit subkey
- Eight S-boxes: six→four bits each
- Permutation: 32 output bits
- S-box row: outer input bits
- S-box column: inner four bits
👁 Full explanation
DES has a 64-bit block, 56 effective key bits (eight other bits serve parity), and 16 Feistel rounds. After initial permutation, each round computes L_i=R_(i-1), R_i=L_(i-1) XOR f(R_(i-1),K_i). Its right-half expansion makes 48 bits, XOR mixes a 48-bit subkey, eight S-boxes each map six bits to four, and permutation rearranges the 32 output bits. The outer S-box input bits select a row and the inner four select a column. - Feistel inversion and DES limitations
- Nonlinear S-boxes resist simple linear descriptions
- Same structure, reversed round keys
- Round function need not be invertible
- Final swap/permutation
- DES and triple DES: legacy
- Not choices for new protection
- Three 56-bit keys ≠ 168-bit effective security
👁 Full explanation
The nonlinear S-boxes resist simple linear descriptions. Feistel inversion uses the same overall structure with reversed round keys; f need not itself be invertible. Final swapping/permutation completes DES. DES and triple DES are legacy algorithms, not choices for new protection. Triple DES repeats DES operations but does not provide 168-bit effective security merely because three 56-bit keys are supplied.
3 related practice questions
Note references: SEC-M, SEC-N
- DES Feistel mechanics
SEC18
Public keys and hybrid protection
- Public-key operation direction
- Confidentiality to B: B's authenticated public key
- B decrypts with B's private key
- A's public key targets A, not B
- A need not possess B's private key
- A signs: A's private signing key
- Others verify: A's public key
- Signing and encryption are distinct operations
- Not every public-key algorithm encrypts
👁 Full explanation
For confidentiality to B, encrypt with B’s authenticated public encryption key; B decrypts with B’s private key. Do not encrypt to A’s public key if only B should read it, and never assume A possesses B’s private key. For a signature, A signs with A’s private signing key and others verify with A’s public key. These are distinct operations; not every public-key algorithm supports encryption. - Hybrid protection and Diffie–Hellman
- Public keys require authentic identity bindings
- Public-key secret establishment/encapsulation
- Symmetric bulk-data protection
- Unauthenticated DH permits intermediary substitution
- Public p,g; private a,b
- A=g^a modp; B=g^b modp
- B^a=A^b=g^(ab) modp
- Authenticate exchange; derive separate traffic keys
👁 Full explanation
Public keys ease distribution but require authentic bindings to identities. Hybrid systems establish or encapsulate a symmetric secret with public-key mechanisms, then protect bulk data symmetrically. Diffie–Hellman agrees on a secret but unauthenticated DH permits intermediary substitution. With public p,g, A=g^a modp and B=g^b modp, both derive B^a=A^b=g^(ab) modp. Authenticate the exchange and derive separate traffic keys. - Sender key-pair requirements
- One-way confidentiality: recipient authenticated public key
- Sender key pair not inherently needed
- Sender signature requires sender key pair
- Separate recipient role may require pair
👁 Full explanation
For one-way public-key confidentiality the sender need not own a key pair; it needs the recipient’s authenticated public encryption key. A sender key pair is needed when the protocol requires its signature or separate recipient role.
5 related practice questions
Note references: SEC-M, SEC-N
- Public-key operation direction
SEC19
RSA arithmetic and key-validity conditions
- Textbook RSA construction
- Distinct primes p,q
- n=pq; φ=(p−1)(q−1)
- 1<e<φ; gcd(e,φ)=1
- d=e^-1 modφ
- Public (n,e); private includes d
- 0≤m<n
- c=m^e modn; m=c^d modn
- Large exponents: modular repeated squaring
- Real RSA requires standardized padding
- Raw arithmetic ≠ secure deployment
👁 Full explanation
For textbook RSA choose distinct primes p,q; n=pq and φ=(p-1)(q-1). Choose 1<e<φ with gcd(e,φ)=1, then compute d=e^-1 modφ. Public key is (n,e), private includes d. Encrypt 0≤m<n by c=m^e modn; decrypt by m=c^d modn. Use modular repeated squaring for large exponents. Real RSA requires appropriate standardized padding; raw arithmetic is not a secure deployment recipe. - RSA valid versus defective examples
- p=7,q=19 → n=133,φ=108
- Smallest admissible e>1: 5
- e=7 and other coprimes also valid
- e=5 → d=65
- 325≡1 mod108
- p=3,q=13,e=3,m=5
- 5^3 mod39=8
- gcd(3,24)=3 → no inverse
- Arithmetic result ≠ valid RSA key
- State defect; reject claimed key pair
👁 Full explanation
With p=7,q=19, n=133 and φ=108, e=5 is the smallest admissible e>1, but 7 and other coprime choices also work. For e=5, d=65 since 325≡1 mod108. With p=3,q=13,e=3,m=5, 5^3 mod39=8 arithmetically, but gcd(3,24)=3, so e has no inverse and this is not a valid RSA key. Check key validity before treating arithmetic results as a working encryption/decryption pair.
3 related practice questions
Note references: SEC-M, SEC-N
- Textbook RSA construction
SEC20
Hashes, MACs and signatures
- Hash versus keyed MAC
- Arbitrary input → fixed-length digest
- Deterministic; preimage and collision resistance
- Collisions necessarily exist
- Not mathematically unique fingerprints
- Unkeyed hash can be attacker-recomputed
- Hash alone needs trusted reference
- MAC: integrity, shared-secret authentication
- Both holders can create MAC
- Limited third-party non-repudiation
👁 Full explanation
A cryptographic hash maps arbitrary-length input to a fixed-length digest. It is deterministic and designed to resist preimages and collisions; collisions must exist, so hashes are not mathematically unique fingerprints. An attacker can recompute an unkeyed hash of modified data, so a hash alone needs a trusted reference. A keyed MAC provides integrity and shared-secret authentication; both holders can create it, limiting third-party non-repudiation. - Signatures and password hashes
- Private-key message/encoded-digest signing
- Public-key verification
- Signing ≠ generic private-key encryption
- DSA/ECDSA counterexamples
- Origin/integrity: identity and custody assumptions
- Signature does not conceal content
- Passwords: salted, deliberately expensive hash
- MD5/SHA-1 history ≠ modern collision-resistant choice
👁 Full explanation
A signature algorithm signs a message or its encoded digest with a private key and verifies with the public key. It is not generically “encrypting with a private key,” especially for DSA/ECDSA. Verification checks origin/integrity under key-identity and key-custody assumptions; it does not conceal content. Password verification uses a salt and deliberately expensive password hash. Historical MD5/SHA-1 examples do not justify their use for new collision-resistant signatures.
2 related practice questions
Note references: SEC-M, SEC-N
- Hash versus keyed MAC
SEC21
Certificates, TLS and HTTPS
- Certificate trust validation
- Issuer signature binds key to subject
- Chain to trusted root
- Intended hostname; time validity
- Applicable key usage and revocation policy
- Genuine certificate ≠ honest business
👁 Full explanation
A certificate binds a public key to a named subject through an issuer signature. Validate the chain to a trusted root, intended hostname, time validity and applicable key usage/revocation policy. A genuine certificate is not proof that a business is honest. - TLS and HTTPS protection boundaries
- TLS succeeds obsolete SSL
- Authenticated protected channel
- Handshake: parameters, authentication, key establishment
- Server authentication; optional client authentication
- Records: symmetric authenticated encryption
- Messages vary with TLS version
- ChangeCipherSpec narrative not universal TLS1.3
- HTTPS=HTTP over TLS
- HTTP paths, headers, content protected
- IP endpoints/timing metadata remain visible
- Compromised decrypted endpoint remains exposed
👁 Full explanation
TLS succeeds obsolete SSL and supplies an authenticated protected channel. A handshake negotiates parameters, authenticates the server and sometimes the client, and establishes keys; record protection uses symmetric authenticated encryption. Exact messages depend on TLS version: the old ChangeCipherSpec narrative is not a universal TLS1.3 sequence. HTTPS is HTTP over TLS. It protects HTTP paths, headers and content on the channel, but does not hide all metadata such as IP endpoints and traffic timing, nor protect data after a compromised endpoint decrypts it.
2 related practice questions
Note references: SEC-M, SEC-N
- Certificate trust validation
SEC22
SSH, IPsec, email protection and SET
- SSH, IPsec and VPN
- SSH: remote login, commands, SFTP
- Host keys; multiple client-authentication methods
- IPsec: network-layer IP protection
- AH: integrity/origin authentication, no encryption
- ESP: confidentiality and integrity possible
- IKE: security associations and keys
- Transport mode: upper-layer payload
- Tunnel mode: inner IP, outer header
- VPN: logical private connection
- Security depends on authenticated tunnel
👁 Full explanation
SSH protects remote login, commands and file transfer such as SFTP; it supports host keys and several client-authentication methods. IPsec protects IP traffic at network layer. AH provides integrity/origin authentication, not encryption; ESP can provide confidentiality and integrity; IKE negotiates security associations and keys. Transport mode protects upper-layer payload; tunnel mode encapsulates an inner IP packet inside an outer header. A VPN is a logical private connection; its actual security depends on the chosen authenticated tunnel. - Email protection and SET
- PGP/OpenPGP: symmetric content protection
- Public-key key handling and signatures
- S/MIME: certificate-based signed/enveloped MIME
- Separate/clear signatures need not conceal
- Envelope: encrypted content, wrapped recipient keys
- SET: Secure Electronic Transaction
- Visa/Mastercard-led card-transaction specification
- Certificates and signatures
- SET ≠ payment processor or ordinary HTTPS
👁 Full explanation
PGP/OpenPGP combines symmetric content protection with public-key key handling and signatures. S/MIME uses certificates for signed and/or enveloped MIME content. Signatures can be sent separately/clear-signed without confidentiality; enveloped data encrypts content and wraps content keys for recipients. SET, Secure Electronic Transaction, was a Visa/Mastercard-led specification for protecting card transactions using certificates and signatures; it is distinct from a payment-processing system or ordinary HTTPS. - S/MIME sign-then-encrypt construction
- Sign MIME entity
- Package content and signature
- Encrypt signed entity with fresh symmetric key
- Protect key copy per recipient
- Recipient: recover key → decrypt → verify
- Validated signer certificate/public key
- Signing ≠ generic private-key encryption
- Other nesting orders possible
- Specify order and protection coverage
👁 Full explanation
One signed-and-encrypted S/MIME construction first signs the MIME entity, packages its content and signature, then encrypts that signed entity with a fresh symmetric content key. Protect a copy of that key for each recipient. A recipient recovers the key, decrypts the signed entity and verifies its signature using the validated signer certificate/public key. Signing is not generic private-key encryption. S/MIME permits other nesting orders; specify the order and resulting coverage.
5 related practice questions
Note references: SEC-M, SEC-N, SEC-IBMSET, RFC8551
- SSH, IPsec and VPN
SEC23
Firewalls and protected boundaries
[Exam Focus]- Firewall types
- Traffic-policy enforcement
- Stateless filtering: source/destination, protocol, ports
- Stateful inspection: permitted connection context
- Application proxy: terminate, relay, inspect
- Circuit gateway: connection relay, commonly SOCKS
- No full application-content interpretation
- Textbook session/transport association
- Circuit gateway need not encrypt
- Gateway ≠ automatically VPN
👁 Full explanation
A firewall enforces traffic policy. Stateless packet filtering matches headers such as source/destination, protocol and ports. Stateful inspection tracks permitted connection context; application proxies terminate and relay application exchanges and can inspect their content. A circuit gateway relays connections, commonly SOCKS, without full application-content interpretation; textbooks associate it with session/transport functions. Such a gateway need not encrypt and is not automatically a VPN. - Firewall placement and limits
- Host firewall: individual machine
- Network firewall: segmentation and DMZ
- DMZ: public-facing services
- Explicit ordered least-privilege rules; appropriate logging
- Stateful/next-generation devices also filter ports
- Port-filter question nonexclusive
- Bypass paths; insiders; uninspected encrypted content
- Infected removable media
- Hardware firewall ≠ fixed port count
👁 Full explanation
Host firewalls protect individual machines; network firewalls segment networks and can create a DMZ for public-facing services. Rules should be explicit, ordered as implemented, least-privilege and logged appropriately. Stateful and next-generation devices can also filter ports; port filtering is not exclusive to one firewall category. Bypass paths, insiders, encrypted uninspected content and infected removable media limit firewall protection. Hardware firewall does not imply any fixed number of ports.
14 related practice questions
Blueprint: LO1 · Note references: SEC-M, SEC-N
- Firewall types
SEC24
Detection, prevention and diagnostic measures
- Detection versus prevention
- IDS: observe and alert
- IPS: enforce blocking, usually inline
- Host sensors: host events
- Network sensors: traffic
- Signature detection: known patterns
- Anomaly detection: baseline deviations, possible novelty
- Neither detects every attack
- Anomaly false positives
- Signatures can sometimes match variants
👁 Full explanation
An IDS observes and alerts; an IPS can enforce blocking, usually inline. Host-based sensors examine host events, network-based sensors inspect traffic. Signature detection recognizes known patterns; anomaly detection compares with a baseline and may detect novel behavior. Neither guarantees every attack is detected; anomaly detection can raise many false positives, and signatures can sometimes match variants. - Diagnostic measures and obfuscation
- TP: real attack detected
- FN: attack missed
- FP: innocent activity flagged
- TN: innocent activity accepted
- Recall=TP/(TP+FN)
- Precision=TP/(TP+FP)
- 90/100 spam; five innocent flags
- Recall=90%; precision=90/95≈94.7%
- Obfuscation: harder code understanding/analysis
- No reliable secret protection or vulnerability removal
👁 Full explanation
A true positive is a real attack detected, false negative is a missed attack, false positive is innocent activity flagged, and true negative is innocent activity accepted. Recall=TP/(TP+FN); precision=TP/(TP+FP). Detecting 90 of 100 spam messages with five innocent messages flagged gives recall90%, precision90/95≈94.7%. Obfuscation makes code harder to understand and can hamper analysis, but does not reliably protect embedded secrets or remove vulnerabilities.
6 related practice questions
Note references: SEC-M, SEC-N
- Detection versus prevention
SEC25
Memory safety and secure input handling
[Exam Focus]- Buffer overflows and defenses
- Write beyond allocated bounds
- Data/control corruption; possible code execution
- Execution neither definition nor inevitable outcome
- Eight-byte array ≠ eight characters plus zero
- Bounds-check lengths and indexes
- Consider integer overflow
- Safe abstractions; validate library returns
- Canaries; non-executable memory; address randomization
- Exploit mitigation ≠ repaired underlying write
👁 Full explanation
A buffer overflow writes beyond allocated bounds and can corrupt data or control information; code execution is a possible consequence, not its definition or an inevitable outcome. An array of eight bytes cannot store eight text characters plus a terminating zero. Bounds-check lengths and indexes, consider integer overflow, use safe abstractions and validate library return values. Canaries, non-executable memory and address randomization reduce exploitability but do not repair the underlying write. - Trust-boundary validation and patches
- Expected type, length, range, structure
- Server validation: clients controllable
- Destination-specific output encoding
- Validation ≠ query parameterization
- Validation ≠ HTML-context encoding
- Patches: known weakness repair
- Zero-day may lack vendor fix
- Segmentation and mitigations still useful
👁 Full explanation
Validate expected type, length, range and structure at trust boundaries. Server validation is essential because clients are controllable. Encode output for its destination; validation is not a universal substitute for query parameterization or HTML-context encoding. Security patches repair known weaknesses; a zero-day may lack a vendor fix, but segmentation and other mitigations can still help.
6 related practice questions
Blueprint: LO2 · Note references: SEC-N, SEC-CWE787
- Buffer overflows and defenses
SEC26
SQL injection, XSS and request forgery
[Exam Focus]- SQL injection prevention
- Unsafe strings let values alter syntax
- Tautology changes matching rows
- Prepared statements bind data values
- Allow-list nonparameterizable identifiers
- Least-privilege application database account
- Stored procedures/ORMs require safe SQL
- Unsafe dynamic SQL remains vulnerable
👁 Full explanation
SQL injection occurs when untrusted values alter SQL syntax through unsafe string construction. A tautology can change which rows match. Bind data values in prepared statements, allow-list identifiers that cannot be parameters, and restrict the application’s database account. Stored procedures/ORMs are safe only when they avoid unsafe dynamic SQL. - XSS mechanisms and defenses
- Attacker script under victim-site origin
- Stored: persistent; reflected: response-returned
- DOM-based: unsafe browser sinks
- Safe text insertion
- Context-specific encoding
- Careful allowed-HTML sanitization
- CSP: added protection, not sole fix
👁 Full explanation
XSS causes attacker-controlled script to execute in a victim’s browser under the site’s origin. Stored content persists; reflected content returns in a response; DOM-based XSS can arise from unsafe browser sinks. Use safe text insertion and context-specific encoding; carefully sanitize allowed HTML. CSP is added protection, not the sole fix. - CSRF, cookie limits and fuzzing
- Ambient credentials enable unwanted authenticated action
- Unpredictable request tokens
- Suitable cookie/origin controls
- HttpOnly: restricted script cookie access
- HttpOnly ≠ all XSS prevention
- Fuzzing: unexpected-input fault discovery
- Testing technique ≠ injection category
👁 Full explanation
CSRF exploits ambient credentials to submit an unwanted authenticated action. Use unpredictable request tokens and suitable cookie/origin controls. HttpOnly restricts script access to cookies but does not stop every XSS effect. Fuzzing sends unexpected inputs to discover faults; it is a testing technique, not itself a category of injection.
4 related practice questions
Blueprint: LO2 · Note references: SEC-N, SEC-SQL, SEC-XSS
- SQL injection prevention
SEC27
Races, testing and secure development
[Exam Focus]- Race conditions
- Timing/interleaving-dependent shared-state correctness
- Check-then-open: replacement between check/use
- Two workers read100, each writes90
- Lost debit
- Protect whole invariant
- Suitable atomic operations, locks, transactions
- Unrelated-variable lock ineffective
👁 Full explanation
A race occurs when correctness depends on timing/interleaving over shared state. In a check-then-open file operation, another actor may replace the file between the check and use. In a balance update, two workers can both read100 and each write90, losing one debit. Protect the whole invariant with suitable atomic operations, locks or database transactions; locking an unrelated variable does not help. - Security testing and development
- Vulnerability assessment: find/prioritize weaknesses
- Authorized penetration test: demonstrate consequences
- Static: inspect code; dynamic: execute
- Fuzzing varies inputs
- Host/network/database scanners: different exposure
- False results possible
- Correct → patch → test → recheck
- Testing ≠ proof of absence
- Threat modeling; review; least privilege
- Dependency management; safe error handling
👁 Full explanation
Vulnerability assessment finds and prioritizes weaknesses; authorized penetration testing attempts to demonstrate consequences. Static analysis inspects code, dynamic testing executes it, and fuzzing varies inputs. Host/network/database scanners see different exposures and have false results. Correct findings, patch, test and recheck; testing is not proof of absence. Build threat modeling, review, least privilege, dependency management and safe error handling into development.
1 related practice question
Blueprint: LO2 · Note references: SEC-M, SEC-N, SEC-CWE362
- Race conditions
SEC28
Trusted OS requirements and reference mediation
[Exam Focus]- Trusted operating system requirements
- Enforce stated security policy
- Identification/authentication; process and memory isolation
- Controlled privileges; object-access enforcement
- Protected auditing; safe resource reuse
- Trusted boot/update paths; recovery behavior
- TCB: policy-critical components
- Smaller analyzable boundaries simplify assurance
👁 Full explanation
A trusted OS is relied on to enforce a stated security policy. Relevant mechanisms include identification/authentication, process and memory isolation, controlled privileges, object access enforcement, protected auditing, safe resource reuse, trusted boot/update paths and recovery behavior. The trusted computing base comprises components whose failure can violate policy; smaller, analyzable boundaries simplify assurance. - Reference monitor and assurance
- Abstract access-checking mechanism
- Complete mediation; tamper resistance
- Small/simple enough for analysis
- Security kernel: core enforcement implementation
- Firewall mediates traversing traffic only
- Firewall ≠ every host-memory access
- Assurance: justified confidence in implementation
- Functionality: claimed control behavior
- GUI/multitasking alone ≠ trust
👁 Full explanation
A reference monitor is an abstract access-checking mechanism: it must mediate every relevant access, resist tampering and be sufficiently small/simple to analyze. A security kernel implements core enforcement. A firewall can mediate its traversing traffic but cannot enforce every host-memory access. Assurance is justified confidence that controls implement the claims; functionality is what controls claim to do. A GUI or multitasking support alone does not establish trust.
3 related practice questions
Blueprint: LO3 · Note references: SEC-M, SEC-N, SEC-NISTAC25
- Trusted operating system requirements
SEC29
Independent evaluation, certification and assurance
[Exam Focus]- Common Criteria evaluation roles
- TOE: Target of Evaluation
- Specified configuration and environment
- Security Target: threats, assumptions, objectives
- Functional and assurance requirements
- Protection Profile: reusable product-category requirements
- Evaluator: evidence, testing, vulnerability analysis
- Certification body: oversight/review and decision
- Sponsor commissions; developer supplies product/evidence
👁 Full explanation
Under Common Criteria, define the Target of Evaluation (TOE), its configuration and environment. A Security Target (ST) states threats, assumptions, objectives, functional requirements and assurance requirements; a Protection Profile describes reusable requirements for a product category. Evaluators examine developer evidence, test and analyze vulnerabilities against those claims. A certification body oversees/reviews the evaluation and issues the certification decision; sponsors commission work and developers supply product/evidence. - Evaluation Assurance Levels and scope
- EAL: assurance-requirement package
- EAL1–7: increasing evaluation rigor
- EAL ≠ universal security-function ranking
- Higher EAL across scopes ≠ safer
- CCRA: mutual recognition, not worldwide laboratory
- Certificate: specified product/configuration and claims
- Certification ≠ future-attack immunity
👁 Full explanation
An Evaluation Assurance Level packages assurance requirements; EAL1–7 express increasing evaluation rigor, not a universal ranking of security functions. A higher number does not make a product with different scope automatically safer. CCRA is a mutual-recognition arrangement, not a single worldwide testing laboratory. A certificate applies to a specified product/configuration and claims, not immunity to all future attacks.
10 related practice questions
Blueprint: LO3 · Note references: SEC-CC1, SEC-CCFAQ
- Common Criteria evaluation roles
SEC30
Database secrecy, permissions and key boundaries
[Exam Focus]- Database protection and permissions
- Confidentiality; integrity; availability; accountability
- Authenticate connections
- Roles: necessary table/column/row privileges only
- Restrict views; audit sensitive changes
- Report permission ≠ underlying full-table access
- Application authorization plus database rights
👁 Full explanation
Database security needs confidentiality, integrity, availability and accountability together. Authenticate connections, give roles only necessary table/column/row privileges, restrict views and audit sensitive changes. A user allowed to read a report need not read the underlying full table. Check application-level authorization as well as database rights. - Database encryption and replication limits
- At-rest encryption: stolen storage/backups
- Keys must remain separate
- Transport encryption: connection protection
- Neither blocks fully authorized queries
- Neither guarantees correctness
- Access controls, encryption, protected transmission
- Secrecy question may have multiple answers
- Replication: availability plus malicious-update copying
- Separate recovery controls still needed
👁 Full explanation
Encryption at rest protects stolen storage/backups when keys remain separate; transport encryption protects the connection. Neither prevents a fully authorized query or guarantees correctness. Strong access controls, encryption and protected transmission can all contribute to secrecy; compare their roles and assumptions. Replication is useful for availability but also copies malicious updates unless separate recovery controls exist.
4 related practice questions
Blueprint: LO4 · Note references: SEC-M, SEC-N
- Database protection and permissions
SEC31
Database integrity and reliability mechanisms
[Exam Focus]- Database integrity mechanisms
- Valid data and valid transitions
- NOT NULL: mandatory values
- UNIQUE/primary key: duplicate-identifier prevention
- Foreign key: reference preservation
- CHECK: declared predicates
- Atomic transaction: transfer debit and credit
- Concurrency control: safe interleavings
- Roles/ACLs: who may update
- Constraints/transaction logic: authorized update validity
👁 Full explanation
Integrity requires valid data and valid transitions. NOT NULL rejects missing mandatory values; UNIQUE/primary keys prevent duplicate identifiers; foreign keys preserve references; CHECK enforces declared predicates. Transactions group a transfer’s debit and credit atomically; concurrency control prevents unsafe interleavings. Roles/ACLs limit who may update, but constraints and transaction logic determine whether an authorized update is valid. - Logging, backup and reliability
- Write-ahead logging: recovery records before data
- Crash recovery
- Backups; restore tests; separately protected logs
- Deletion/corruption recovery
- Replication: alternate service, not backup replacement
- Redundancy needs appropriate failover
- Independent failure handling
- Confidentiality versus reliability versus integrity constraints
👁 Full explanation
Write-ahead logging persists recovery records before dependent data-file changes, supporting recovery after a crash. Backups, restore tests and separately protected logs recover from deletion/corruption; replication provides alternate service capacity but does not replace backups. Redundancy improves availability only with appropriate failover and independent failure handling. Distinguish confidentiality controls from reliability controls and from integrity constraints.
3 related practice questions
Blueprint: LO4 · Note references: SEC-N, SEC-PGC, SEC-PGW
- Database integrity mechanisms
SEC32
Inference control and multilevel databases
[Exam Focus]- Inference control
- Permitted outputs plus knowledge reveal secrets
- Two-person salary total minus known salary
- Blocked direct SELECT still leaks indirectly
- Restrict small groups and overlapping queries
- Track query history
- Coarsen/suppress results
- Carefully designed noise
- Utility–leakage tradeoffs
👁 Full explanation
Inference reveals protected facts by combining individually permitted outputs with other knowledge. If a report gives a two-person salary total and one salary is known, subtraction reveals the other. Blocking direct SELECT of a salary column does not stop that inference. Restrict small groups and overlapping queries, track query history, coarsen/suppress results, or introduce carefully designed noise; each trades utility against leakage. - Multilevel database security
- Different item labels; mandatory policy
- Subject clearances; classifications; compartments
- Bell–LaPadula-style read/write restrictions
- Prevent direct downward confidentiality flow
- Trusted declassification: separately controlled action
- Views alone ≠ multilevel isolation proof
- Covert channels; query results; error messages
- Assess direct access and indirect inference
👁 Full explanation
A multilevel database stores items at different labels and enforces mandatory policy using subject clearances, classifications and compartments. Bell–LaPadula-style read/write restrictions prevent direct downward confidentiality flow; trusted declassification is a separate controlled action. Views alone are not proof of multilevel isolation. Covert channels, query results and error messages may still reveal information, so evaluate both direct access and indirect inference.
3 related practice questions
Blueprint: LO4 · Note references: SEC-N, SEC-INF
- Inference control
SEC33
Policy, incident response and recovery objectives
- Policy versus procedure
- Policy: responsibilities and rules
- Procedure: operational steps
- Coordinate protection; reduce risk
- Acceptable use; access review
- Incident handling; recovery
- Policy ≠ merely passive system use
- Awareness: reporting and independent verification
- Enforcement and usable procedures
👁 Full explanation
A security policy states responsibilities and rules; a procedure supplies the steps. Policies coordinate protection, reduce risk and define acceptable use, access review, incident handling and recovery. They do not prescribe merely “passive system use.” Awareness training teaches reporting and independent verification; enforcement and usable procedures make it operational. - Incident response and recovery objectives
- Prepare roles/tools
- Detect/analyze → contain → eradicate
- Restore verified service; learn from evidence
- Preserve useful protected logs
- Disaster recovery: restore IT
- Business continuity: sustain business functions
- Workarounds and alternate facilities
- RTO: recovery-time target
- RPO: tolerable lost-data age
- Backup schedule meets recovery point
- Restore tests demonstrate recoverability
👁 Full explanation
Prepare response roles/tools, detect and analyze, contain the incident, eradicate the cause, restore verified service and learn from the evidence. Preserve useful protected logs. Disaster recovery restores IT after disruption; business continuity sustains business functions through workarounds and alternate facilities. RTO is a recovery-time target; RPO measures the tolerable age of lost data. A backup schedule must satisfy the required recovery point, and a restore test must demonstrate that data can actually be recovered.
1 related practice question
Note references: SEC-M, SEC-N
- Policy versus procedure
SEC34
Interpret security mechanisms and conditions precisely
- Flawed security-question interpretation
- Overlapping/missing mechanisms: no invented unique answer
- Asymmetric question: multiple wrong key directions
- Signature ≠ generic private-key whole-message encryption
- Body biometric ≠ three factors
- SSL/SSH both describe protected channels
- Remote-shell scope distinguishes SSH
- Malformed option labels unrecoverable from theory
👁 Full explanation
Compare each security mechanism with the stated requirement and conditions. Check asymmetric-encryption key directions carefully; signatures do not generically encrypt whole messages with private keys. Body biometrics do not imply three factors. SSL and SSH can both describe protected channels; SSH specifically supports remote-shell services. Read the full option text before matching it to a security mechanism. - Missing distinctions in security questions
- Arbitrary code execution: multiple mechanisms
- Execution consequence ≠ uniquely buffer overflow
- Database requirements: availability and confidentiality
- ACL/RBAC both restrict unauthorized writes
- Neither alone enforces all integrity constraints
- Evaluation organizations depend on national scheme
- CCRA: recognition, not evaluator
- Supported answer requires missing distinction
👁 Full explanation
Undefined “arbitrary code execution” does not uniquely identify buffer overflow: several mechanisms can produce that consequence. A database-security requirement can include both availability and confidentiality. Generic ACLs and RBAC both restrict unauthorized writes but neither independently enforces all integrity constraints. Evaluation organizations must be identified by the actual national scheme; CCRA is recognition, not an evaluator. An answer is supported only after the missing distinction is supplied.
21 related practice questions
Note references: SEC-M, SEC-N
- Flawed security-question interpretation
No matching topics. Clear the search or change the filter.
Blueprint learning outcomes
- LO1 · Understand the basic concepts in computer security
SEC01, SEC02, SEC07, SEC09, SEC10, SEC23 - LO2 · Understand issues related to program security and the common vulnerabilities in computer programs
SEC25, SEC26, SEC27 - LO3 · Explain the basic requirements for trusted operating systems, and describe the independent evaluation, including evaluation criteria and evaluation process
SEC28, SEC29 - LO4 · Describe security requirements for database security, and techniques for database reliability and integrity, secrecy, inference control, and multi-level databases
SEC09, SEC10, SEC30, SEC31, SEC32