Revision approach
- Administration and evidence-based diagnosis
- Useful, available, controlled services
- Configuration, monitoring, troubleshooting, repeatable automation
- Failed connection: multiple possible causes
- Expired lease ≠ unique cause
- Organization size ≠ best storage design
👁 Full explanation
Administration keeps services useful, available and controlled through configuration, monitoring, troubleshooting and repeatable automation. Diagnose from evidence: a failed connection, expired lease or large organization alone does not identify one cause or one best storage design. - Service-provisioning chain
- Link→address→route→DNS
- Transport connection→authentication→application
- Tools matched to actual evidence
👁 Full explanation
Practice service provisioning as a chain: link, address, route, DNS, transport connection, authentication and application. Match each tool to the evidence it can actually provide. - Requirement-based comparisons
- Accounts and permissions
- RAID layouts
- Backup types
- Security controls
- Unconditional best choices: avoid
👁 Full explanation
Compare account/permission models, RAID layouts, backup types and security controls using stated requirements rather than unconditional best choices. - Script tracing and reusable tasks
- Python 3 and shell
- Inputs, branches, repeated work
- Failures and outputs
- Reusable checks and backups
👁 Full explanation
Read and trace small Python 3 or shell scripts. Identify inputs, branching, repeated work, failures and outputs; then construct a reusable check or backup task.
NSA01
Roles, principles and change discipline
[Exam Focus]- Administrative roles and qualities
- Systems: hosts/accounts/storage/software/availability
- Networks: connectivity/addressing/routes/devices/performance
- Security: controls and policy
- Overlapping account/patch/training duties
- Job titles ≠ exclusive duties
- Patience, communication, ethics
- Technical understanding and organization
- Beyond command knowledge
👁 Full explanation
System administrators maintain hosts, accounts, storage, software and availability; network administrators maintain connectivity, addressing, routes, network devices and performance. Security administrators coordinate controls and policy. These duties overlap, so account management, testing patches and training users are not exclusive to one job title. Patience, communication, ethics, technical understanding and organization matter alongside command knowledge. - Administration and measured change
- Documentation, standardization, least privilege, automation
- Record current state and intended change
- Rollback and validation
- Maintenance: service impact and urgency
- Calendar date alone insufficient
- Fault management: restore failures
- Performance: measure service behavior
- Configuration: track settings
- Security: control access
- Accounting: track usage
👁 Full explanation
Use documentation, standardization, least privilege, automation and measured change. Record the current state, intended change, rollback and validation. Schedule maintenance according to service impact and urgency, not merely because a calendar date arrived. Fault management restores failures; performance management measures service behavior; configuration management tracks settings; security management controls access; accounting tracks usage.
8 related practice questions
Blueprint: LO1 · Note references: NSA-M
- Administrative roles and qualities
NSA02
Network foundations for administrators
- Client/server and peer roles
- Client: requests; server: provides
- Peer-to-peer: both roles
- Server may request DNS/backups
- Dedicated server ≠ never client
- Network OS ≠ dedicated-server-only
- Clients require networking support
- Centralized service software versus participant OS
👁 Full explanation
Clients request services; servers provide them. Peer-to-peer systems can do both. A server can also be a client of DNS or backups, so dedicated role does not mean it never makes requests. A network OS is not universally installed only on a dedicated server: clients also require networking support. Specify centralized service software versus the OS on all participants. - Forwarding, transport and diagrams
- Switching: LAN frames by MAC
- Routing: inter-network IP packets
- TCP: ordered reliable byte stream
- UDP: datagrams, no equivalent guarantee
- Ports: application endpoints, not connectors
- Diagram switches, links, subnets, gateways
- Service hosts and dependencies
- Topology shape ≠ security guarantee
👁 Full explanation
Switching normally forwards frames using MAC addresses within a LAN; routing forwards IP packets between networks. TCP supplies an ordered reliable byte stream, while UDP preserves datagrams without that guarantee. Ports distinguish application endpoints, not physical connectors. Draw switches, links, subnets, gateways, service hosts and dependencies in a network diagram. A topology’s shape alone does not guarantee security.
2 related practice questions
Note references: NSA-M, NSA-N
- Client/server and peer roles
NSA03
Addresses, prefixes, gateways and loopback
- IPv4 addressing rules
- IPv4: 32 bits
- CIDR prefix determines network
- Network=address AND mask
- Remote subnet: route/gateway
- Private: 10/8,172.16/12,192.168/16
- Private ≠ directly Internet-routable
- IP/class label alone ≠ subnet
👁 Full explanation
An IPv4 address is 32 bits; a CIDR prefix determines its network. Compute network=address AND mask; devices use a route/gateway for remote subnets. Private ranges are 10/8,172.16/12 and 192.168/16; private addresses are not directly Internet-routable. Neither IP alone nor a class label determines today’s subnet. - Loopback meaning and test limits
- 127.0.0.1: conventional local IPv4 loopback
- 127/8 reserved
- Tests local protocol processing
- No cable/switch/remote reachability proof
- Local service use
- Multiple loopback descriptions may fit
- Multiple 127/8 choices may fit
👁 Full explanation
127.0.0.1 conventionally names the local IPv4 loopback interface; 127/8 is reserved for loopback. Loopback tests local protocol processing, not cable, switch or remote reachability. Programs can use it for local services. Several loopback descriptions or several 127/8 addresses may be valid; compare each with the stated role. - Worked example Subnet-boundary example
- 192.168.2.70/26
- Block size: 64 addresses
- Network .64; broadcast .127
- Ordinary hosts .65–.126
- Gateway requires appropriate reachable route
- NAT ≠ missing-route repair
👁 Full explanation
Worked microexample192.168.2.70/26 has 64-address blocks: network .64, broadcast .127, ordinary host range .65–.126. A gateway must be reachable through an appropriate route; NAT does not repair a missing route.
2 related practice questions
Note references: NSA-M, NSA-N, NSA-LOOP
- IPv4 addressing rules
NSA04
DHCP exchange and lease lifecycle
[Exam Focus]- DHCP initial allocation
- Addresses and configuration options
- Discover→Offer→Request→ACK
- Scope/pool and allocated leases
- Exclusions and reservations
- Mask, gateway, DNS options
- Dynamic lease: specified interval
- Lease ≠ forever
👁 Full explanation
DHCP supplies addresses and configuration options. Typical initial IPv4 allocation is Discover→Offer→Request→ACK. The server manages its scope/pool, allocated leases, exclusions and reservations; options may include mask, gateway and DNS servers. A dynamic lease lasts for a specified interval, not forever. - Lease renewal and reuse
- Renew before expiry
- Failed renewal: later rebinding
- Disconnected host ≠ perpetual renewal
- Expiry: address eligible for reuse
- Server-policy conditions
- Reconnection: validate/renew/new allocation
- Expiry alone ≠ persistent failure
- Reservation: known client, predictable address
- DHCP configuration retained
👁 Full explanation
A client renews before expiry; it later tries rebinding if renewal fails. A disconnected host does not automatically renew forever. On lease expiry the address becomes eligible for reuse, subject to server policy. Reconnection normally triggers validation/renewal/new allocation, so an expired lease alone does not prove persistent failure. A reservation gives a predictable address to a known client while retaining DHCP configuration. - Worked example Expired disconnected-client example
- Expiry while other clients allocate
- Old address may be reassigned
- Validate configuration before reuse
- No unvalidated old-address resumption
👁 Full explanation
Worked microexampleIf a disconnected client’s lease expires while other clients obtain addresses, its old address may be reassigned. It must not simply resume using it without validating its configuration.
4 related practice questions
Blueprint: LO2 · Note references: NSA-DHCP
- DHCP initial allocation
NSA05
DHCP deployment and diagnosis
[Exam Focus]- DHCP deployment rules
- Subnet-matching scope
- Exclude manual server/router addresses
- Correct configuration options
- Relay: broadcasts across router
- Static and DHCP coexist
- Avoid address conflicts
- Less repetitive administration
- Availability/security: deployment-dependent
- Rogue-reply protection
- Location change ≠ guaranteed connectivity
👁 Full explanation
Use a scope matching the subnet, exclude manually assigned server/router addresses, set correct options and provide a relay when client broadcasts must cross a router. Static assignments and DHCP can coexist; avoid address conflicts. DHCP lowers repetitive administration but availability/security depend on deployment and protection from rogue replies. It does not guarantee connectivity whenever a device changes location. - DHCP returning-client diagnosis
- Inspect current lease/address
- Server/relay reachability
- Free pool capacity and logs
- New devices: possible pool exhaustion
- Exhaustion requires evidence
- Link-local fallback: 169.254.2.33 example
- Same-link communication
- Not ordinary routed Internet access
- 0.0.0.0: unspecified
- 255.255.255.255: limited broadcast
👁 Full explanation
For a returning client, inspect current lease/address, reachable server/relay, free pool capacity and logs. New devices can exhaust a pool, but absent observations this is only a hypothesis. Some clients self-configure IPv4 link-local addresses such as 169.254.2.33 after DHCP failure; these support same-link communication, not ordinary routed Internet access. 0.0.0.0 is unspecified and 255.255.255.255 is limited broadcast.
4 related practice questions
Blueprint: LO2 · Note references: NSA-M, NSA-LL, NSA-DHCP
- DHCP deployment rules
NSA06
DNS resolution and diagnostic evidence
[Exam Focus]- DNS record roles
- Forward: name→address
- A: IPv4; AAAA: IPv6
- Reverse: address→name
- PTR: reverse namespace
- CNAME: alias
- MX: mail exchangers
- NS: authoritative name servers
- Forward/reverse: independent existence
- Not necessarily perfect inverses
👁 Full explanation
Forward resolution obtains an address from a name, using A for IPv4 and AAAA for IPv6. Reverse lookup uses a PTR record in the reverse namespace to obtain a name from an address. CNAME aliases a name, MX identifies mail exchangers and NS identifies authoritative name servers. Forward and reverse records need not both exist or be perfect inverses. - DNS caching and diagnosis
- Resolver caching: TTL
- nslookup name
- Explicit DNS-server query
- Configured resolver versus authoritative answer
- Address ping succeeds, lookup fails
- Naming/configuration trouble suggested
- Ping by name: resolved address possible
- nslookup: direct DNS diagnostic
- Resolving includes forward resolution
👁 Full explanation
Resolvers cache answers for their TTL. Query nslookup name or specify the DNS server explicitly; compare the configured resolver with the authoritative answer when appropriate. A successful ping by address but failed name lookup suggests naming/configuration trouble. Ping by name may display a resolved address, but nslookup is the direct DNS diagnostic. “Resolving” is a general term that includes forward resolution.
3 related practice questions
Blueprint: LO2 · Note references: NSA-M, NSA-N, NSA-DNS, NSA-NSLOOKUP
- DNS record roles
NSA07
Commands and observable state
[Exam Focus]- Address-configuration commands
- Windows ipconfig: address/mask/gateway
- ipconfig /all: complete adapters
- Physical/MAC, DHCP, DNS information
- /renew: request renewal
- /release: dynamic address release
- /flushdns: client DNS cache clearing
- Linux ip addr: addresses
- Linux ip route: routes
- Persistent configuration: distribution-specific
👁 Full explanation
Windows ipconfig shows addresses, mask and gateway; ipconfig /all adds complete adapter configuration including physical/MAC address, DHCP and DNS information. /renew requests renewal, /release releases a dynamic address and /flushdns clears the client DNS cache. Linux ip addr and ip route show interface addresses and routes; exact persistent configuration varies by distribution. - Connection and path diagnostics
- netstat: endpoints/protocols/TCP states
- netstat -ano: numeric addresses/ports/PIDs
- Literal netstart ≠ netstat
- Ping: IP reachability probes
- traceroute/tracert: responding hops
- TTL/hop-limit expiry
- ICMP filtering: replies may fail
- Missing reply ≠ service-down proof
- nslookup: DNS inspection
👁 Full explanation
netstat displays connections/endpoints/protocols and TCP states; netstat -ano displays numeric addresses/ports and PIDs. Use the exact command name netstat rather than netstart. ping probes IP reachability; traceroute/tracert reveals responding hops using TTL/hop-limit expiry. ICMP filtering can prevent replies without proving the service is down. nslookup inspects DNS.
7 related practice questions
Blueprint: LO2, LO3 · Note references: NSA-M, NSA-IPCONFIG, NSA-NETSTAT, NSA-NSLOOKUP
- Address-configuration commands
NSA08
Repeatable troubleshooting procedure
[Exam Focus]- Evidence-led troubleshooting sequence
- Symptom, scope, time, recent changes
- Configuration, baseline, logs
- Testable hypothesis
- Least disruptive explanation first
- Isolate failing component
- Targeted fix; verify user service
- Document results
- One relevant factor at a time
- Reboot may hide evidence
- Reboot ≠ diagnosis
👁 Full explanation
Define the symptom, scope, time and recent changes; gather the configuration, baseline and logs. Form a testable hypothesis, test the least disruptive explanation, isolate the failing component, apply a targeted fix, verify the user service and document the result. Change one relevant factor at a time when possible. A reboot can hide evidence and is not a diagnosis by itself. - Troubleshooting approaches
- Bottom-up: physical link first
- Top-down: application errors first
- Divide-and-conquer: test middle layer
- Narrow working/failing boundary
- Divide-and-conquer ≠ random trial-and-error
- Reboot/update/reset/scan: context-dependent actions
- No fault evidence: no unique ranking
👁 Full explanation
Use bottom-up checks from physical link, top-down checks from application errors, or divide-and-conquer by testing a middle layer. Divide-and-conquer narrows the working/failing boundary; it is not random trial-and-error. Rebooting, updates, resetting settings and scanning can all be troubleshooting actions in suitable circumstances; use fault evidence to choose among them. - Worked example Scope-based diagnosis examples
- One client fails: inspect client
- Link, address and policy first
- All name lookups fail
- Server IPs still reachable
- Inspect shared DNS/configuration first
- Cable replacement: unsupported by naming-only failure
👁 Full explanation
Worked microexampleOne client fails while others work: inspect that client’s link, address and policy first. All clients fail name lookup but reach server IPs: inspect shared DNS/its configuration before replacing every cable.
4 related practice questions
Blueprint: LO3 · Note references: NSA-M
- Evidence-led troubleshooting sequence
NSA09
Connectivity diagnosis by layers
[Exam Focus]- Layered connectivity checklist
- Power, cable/connector, link state
- NIC and driver state
- VLAN membership
- Address/prefix and local gateway
- Route, DNS, application port/authentication
- Recognized NIC: driver absence less likely
- Recognition ≠ working physical link
- Ethernet: commonly RJ45
- RJ11 telephone jack ≠ expected Ethernet
👁 Full explanation
Check power, cable/connector and link state, then NIC/driver state, VLAN membership, address/prefix, local gateway, route, DNS and finally application port/authentication. A recognized NIC makes a missing driver less likely, not proof of a working physical link. Ethernet commonly uses RJ45 connectors; an RJ11 telephone jack is not the expected Ethernet connection. - Interpreting connectivity symptoms
- Local works, remote fails
- Inspect gateway/routes/filtering
- Application works, ping fails
- ICMP filtering plausible
- Port refused: destination reachable enough
- Inspect service/listener policy
- Timeout: loss/filtering/down host possible
- Timeout requires further evidence
👁 Full explanation
If same-subnet traffic works but remote traffic fails, compare gateway/routes and filtering. If ping fails but the application connection works, ICMP filtering is plausible. If an application port is refused, the destination is reachable enough to reject it; inspect service/listener policy. A timeout can result from loss, filtering or a down host and needs more evidence. - Worked example Post-replacement NIC example
- Recognized/enabled adapter; no link light
- Try known-good Ethernet cable
- Try known-good switch port
- Recognition ≠ one defective-cable diagnosis
👁 Full explanation
Worked microexampleAfter NIC replacement, recognized/enabled adapter but no link light: try a known-good Ethernet cable and switch port. Merely knowing that the OS recognizes the NIC cannot prove one particular cable is defective.
2 related practice questions
Blueprint: LO2, LO3 · Note references: NSA-M
- Layered connectivity checklist
NSA10
Service catalog and remote access
[Exam Focus]- Service protocol roles
- DNS: names; DHCP: host configuration
- SMTP: mail send/relay
- IMAP/POP: mail retrieval
- FTP: named file-transfer protocol
- HTTP also transfers files
- File transfer ≠ exclusive FTP description
- HTTP/HTTPS: web resources
- SSH: encrypted remote login
- SFTP: file transfer over SSH
- SFTP ≠ FTP/FTPS
👁 Full explanation
DNS resolves names; DHCP supplies host configuration. SMTP sends/relays mail, while IMAP/POP retrieve it. FTP is a named file-transfer protocol; HTTP also transfers files, so “transfers files” is not an exclusive FTP description. HTTP/HTTPS serve web resources. SSH provides encrypted remote login; SFTP transfers files over SSH and differs from FTP or FTPS. - VPN, media and service administration
- VPN: private connectivity over another network
- Secure tunnel: encryption/authentication
- Protocol/configuration conditions
- RTP: real-time timing/sequence information
- Often over UDP
- RTP ≠ timely-delivery guarantee
- Network printers: shared services
- Service accounts, permissions, configuration
- Monitoring and recovery
👁 Full explanation
A VPN extends private connectivity over another network; secure tunneling commonly encrypts/authenticates traffic but depends on protocol/configuration. RTP carries real-time media timing/sequence information, often over UDP; it does not guarantee timely delivery. Network printers expose services shared by clients. Provide accounts, permissions, configuration, monitoring and recovery for each service, not just its protocol name.
5 related practice questions
Blueprint: LO1, LO2 · Note references: NSA-M, NSA-N
- Service protocol roles
NSA11
Routing, NAT and port translation
- Routing versus NAT/PAT
- Routing: destination-prefix next-hop selection
- NAT: address rewriting
- PAT/NAPT: many-to-one address-and-port translation
- Distinct bindings on one public address
- Two private sockets→ports 40001,40002
- Replies translated to correct clients
👁 Full explanation
Routing selects a next hop using a destination prefix; NAT rewrites addresses. Many-to-one address-and-port translation (PAT/NAPT) maps internal flows to one public address using distinct port bindings. For example, two private client sockets can appear as public-address ports 40001 and 40002, with replies translated back to the correct clients. - NAT scope and limits
- Private IPv4→public networks: common use
- NAT ≠ gateway/route/firewall/authentication replacement
- One-to-one NAT
- Destination translation
- NAT ≠ always many-to-one
- Public LAN addresses: NAT not automatic
- Unsolicited inbound service: explicit mapping possible
- Filtering requirements
👁 Full explanation
NAT is often used when private IPv4 clients access public networks; it does not itself replace a gateway, route, firewall or authentication. One-to-one NAT and destination translation are other forms, so NAT does not always mean many hosts share one address. Public addressing inside a LAN does not automatically require NAT. Unsolicited inbound service access may require explicit mapping and filtering.
3 related practice questions
Note references: NSA-M
- Routing versus NAT/PAT
NSA12
Proxies, gateways and QoS
- Proxy and gateway functions
- Proxy: client/backend representative
- Cache, filter, mediate application requests
- Default IP gateway: next-hop router
- Application gateway: possible protocol translation
- Gateway ≠ mandatory modem/router combination
- Functions may coexist on one machine
👁 Full explanation
A proxy acts on behalf of a client or backend service and can cache, filter or mediate application requests. A default IP gateway is a next-hop router; an application gateway may translate protocols. It need not be a modem/router combination. These terms describe functions that can coexist on one machine. - QoS and mixed-category questions
- QoS: classify, queue, prioritize traffic
- Low-delay/limited-loss objectives
- Operates across layers
- Supports applications
- QoS ≠ exclusively application-layer service
- New-service installation: administrative action
- Email configuration: administrative action
- Proxies/agents: components
- Mixed taxonomy: unique exclusion needs scope
👁 Full explanation
QoS classifies, queues and prioritizes traffic to meet performance objectives such as low delay or limited loss. It can operate across layers and support applications, so it is not exclusively an application-layer service. Installing a new service is an administrative action; email configuration is another action and proxies/agents are components. Distinguish service-management actions from components using a stated taxonomy.
2 related practice questions
Note references: NSA-M, NSA-N
- Proxy and gateway functions
NSA13
Workgroups, domains and directories
[Exam Focus]- Workgroup versus domain
- Workgroup: per-machine local accounts
- Local credentials and per-host sharing
- Domain: centralized identities/policies
- Directory infrastructure
- Administrative arrangement ≠ physical topology
- Recommended size ≠ hard protocol limit
- HomeGroup: historical Windows sharing
- HomeGroup ≠ AD domain
👁 Full explanation
A workgroup has locally managed accounts on individual machines; sharing may require local credentials and per-host configuration. A domain centralizes identities and policies through directory infrastructure. These are administrative arrangements, not physical topologies. Avoid treating an old recommended workgroup size as a hard protocol limit. HomeGroup is a historical Windows sharing feature, not another name for an AD domain. - Domain controllers and availability
- Controller: AD DS
- Domain authentication and directory replication
- Redundancy: dependencies/failure domains matter
- Two virtual controllers, one physical host
- Shared host failure ≠ independent availability
- Provisioning: addressing, DNS, time
- Supported OS/hardware
- Version minima ≠ universal architecture rules
👁 Full explanation
A domain controller runs AD DS, authenticates domain accounts and participates in directory replication. Redundant controllers improve service continuity only if dependencies and failure domains are considered; two virtual controllers on one failed physical host are not independent availability. Provisioning requires correct addressing, DNS, time and supported OS/hardware; version-specific minimum sizes are not universal architecture rules.
Blueprint: LO1, LO2 · Note references: NSA-M
- Workgroup versus domain
NSA14
LDAP and secure directory access
- LDAP operations and transport protection
- Entries/attributes: distinguished names
- Bind: session authentication
- Search: matching entries
- Compare: attribute-value test
- Add/delete/modify: entry changes
- Modify-DN: rename/move
- Unbind: end session
- StartTLS: upgrade connection where supported
- LDAPS: TLS from setup
- Protect credentials; verify server identity
👁 Full explanation
LDAP accesses directory entries/attributes identified by distinguished names. Bind authenticates a session; search retrieves matching entries; compare tests an attribute value; add/delete/modify change entries; modify-DN renames or moves; unbind ends the session. StartTLS upgrades a connection to TLS where supported; LDAPS uses TLS from connection setup. Protect credentials and verify server identity. - Directory ports and security caveats
- LDAP: commonly TCP 389
- LDAPS: commonly TCP 636
- Acronym/port ≠ secure authentication
- AD also uses DNS/Kerberos
- LDAP ≠ entire directory product
- LDAPS-retired-with-LDAPv2 claim: unreliable
- Modern TLS-protected LDAP distinction
👁 Full explanation
LDAP commonly uses TCP 389 and LDAPS TCP 636; an acronym/port alone does not make authentication secure. AD also uses DNS and Kerberos; LDAP is not identical to the entire directory product. Do not equate modern TLS-protected LDAP or LDAPS with retired LDAPv2.
Note references: NSA-M, NSA-LDAPS
- LDAP operations and transport protection
NSA15
AD structure and delegation
- Directory objects and logical hierarchy
- Objects: users/computers/groups/resources
- Schema-defined attributes
- Security principals: SIDs
- Display name ≠ sole security identity
- Domain: objects plus replicated database
- Tree: contiguous DNS namespace domains
- Forest: grouped trees
- Shared schema/configuration
- Global-catalog framework
👁 Full explanation
A directory object represents a user, computer, group or resource and has schema-defined attributes. Security principals have SIDs; display names are not the sole security identity. A domain groups directory objects and a replicated domain database. A tree groups domains in a contiguous DNS namespace; a forest groups trees with a shared schema/configuration and global-catalog framework. - OUs, groups and schema restrictions
- OUs: object organization
- Delegation and Group Policy scopes
- OUs ≠ separate forests/security boundaries
- Groups: access assignment
- OUs: policy/delegation structure
- Schema changes: broad propagation, care
- Ordinary objects: deletion possible
- Schema-definition restrictions: special scope
- Schema restrictions ≠ all object restrictions
👁 Full explanation
OUs organize objects and provide convenient scopes for delegated administration and Group Policy; they are not separate forests/security boundaries. Use groups to assign access and OUs to structure policy/delegation. Schema changes require care because they propagate broadly; ordinary directory objects can be deleted, unlike the special restrictions on schema definitions. Apply schema restrictions to the specific directory object type being discussed.
Note references: NSA-M
- Directory objects and logical hierarchy
NSA16
Sites, replication and trusts
- AD sites and replication
- Sites: grouped IP subnets
- Network locality model
- Controller selection
- Replication traffic management
- Sites ≠ domains/OUs
- Replicate changes among controllers
- Intrasite notification-triggered pulls
- Intersite schedules/link costs
- Replication ≠ prior-good-state backup
👁 Full explanation
Sites group IP subnets to model network locality, influence controller selection and manage replication traffic. They are distinct from domains/OUs. AD replicates directory changes among controllers; notification can trigger pulls within a site while schedules/link costs influence traffic between sites. Replication is not an independent backup of previous good states. - Trust direction and permissions
- A trusts B
- B identities authenticate for A resources
- Permissions still required
- Trust ≠ automatic file access
- One/two-way direction
- Transitive/nontransitive extension
- Direction and transitivity: independent
- Explicit trust ≠ fixed direction/transitivity
- Trust type/configuration determines behavior
- State direction before drawing arrows
👁 Full explanation
If domain A trusts B, B’s identities can be authenticated for resources in A, subject to permissions. Trust alone grants no automatic file access. Direction (one/two way) and transitivity (extends/does not extend) are independent. An explicit trust is not necessarily one-way or nontransitive; the trust type/configuration determines that. State the direction in words before drawing arrows.
Note references: NSA-M, NSA-TRUST
- AD sites and replication
NSA17
Accounts, rights and password diagnosis
[Exam Focus]- Account lifecycle and access models
- Named accounts
- Only needed groups/rights
- Disable departed users
- Audit privileged activity
- Authentication: verify account
- Authorization: permitted operations
- User right: remote logon
- File permission: object-specific
- Groups easier to review than individual grants
👁 Full explanation
Create named accounts, assign only needed groups/rights, disable departed users and audit privileged activity. Authentication verifies the account; authorization permits operations. A user right such as remote logon differs from a permission on one file. Group-based administration is easier to review than many hidden individual grants. - Single-user password-change diagnosis
- Inspect cannot-change-password account setting
- Relevant policy/permission
- Minimum age, password rules, account state
- Plausible cause ≠ proven conclusion
- One failure ≠ infrastructure-wide diagnosis
- Administrators membership ≠ inherent change prohibition
- Privileged reset ≠ user-initiated change
👁 Full explanation
If only one domain user cannot change a password, inspect that account’s cannot-change-password setting and relevant policy/permission before blaming all directory infrastructure. Other possibilities include minimum password age, password rules or account state; the setting is a plausible exam cause, not a conclusion from failure alone. Membership in Administrators does not inherently prohibit changing one’s password. Privileged reset and user-initiated password change are different operations.
3 related practice questions
Blueprint: LO1, LO2 · Note references: NSA-M
- Account lifecycle and access models
NSA18
Windows permissions and effective access
[Exam Focus]- Windows permission evaluation
- Read, write, read/execute
- Modify and full control
- Granular rights: delete
- Inherited versus explicit entries
- Group membership and deny entries
- Object scope
- Effective-access view: real account
- Informal permission-label addition insufficient
- Network access: share plus filesystem constraints
👁 Full explanation
Windows file/folder permissions include read, write, read/execute, modify and full control, plus more granular rights such as delete. Inherited and explicit entries, group membership, deny entries and object scope affect effective access; use the effective-access view for a real account rather than adding labels informally. Network access can be constrained by both share and filesystem permissions. - Rights and access distinctions
- Delete: valid Windows permission
- OS-unspecified Delete exclusion: false
- Modify ≠ full control
- Full control: permission/ownership capabilities
- Data access ≠ logon rights
- Read ≠ write
- Read ≠ parent-folder administration
👁 Full explanation
Deleting can be an explicit permission in Windows; specify the operating system before comparing permission names. Modify and full control are not identical: full control includes changing permission/ownership capabilities. Separate data access from logon rights. A user allowed to read a file is not necessarily allowed to write it or administer its parent folder.
1 related practice question
Blueprint: LO2 · Note references: NSA-M
- Windows permission evaluation
NSA19
Unix rwx and octal permissions
[Exam Focus]- Unix permission interpretation
- Nine bits: owner/group/other triplets
- Read=4; write=2; execute=1
- Sum enabled bits per octal digit
- Leading ls -l character: file type
- Directory read: list names
- Directory execute: traverse/search
- Directory write: change entries
- Other checks apply
- Deletion: usually parent-directory permissions
- Sticky-bit/ACL rules possible
👁 Full explanation
The nine ordinary permission bits are owner, group and other triplets. In each triplet read=4,write=2,execute=1; sum enabled bits to get an octal digit. A leading ls -l character denotes file type, not another permission bit. For directories, read lists names, execute permits traversal/search, and write changes entries subject to other checks. File deletion usually depends on parent directory permissions, with sticky-bit/ACL rules also possible. - Worked example Octal and damaged-string examples
- -rwxr--r--: ordinary file
- Owner7/group4/other4 → 744
- 755 → rwxr-xr-x
- Damaged bank string: -rwxr-r—
- Missing hyphens: no guessing
- Confirm all nine bits before choice
👁 Full explanation
Worked microexample-rwxr--r-- means ordinary file, owner7/group4/other4, hence 744. 755 means rwxr-xr-x. A permission string must include all nine ordinary permission bits; missing hyphens cannot be inferred. Confirm the complete nine-bit permission string before converting it to octal.
2 related practice questions
Blueprint: LO2 · Note references: NSA-M, NSA-MODE
- Unix permission interpretation
NSA20
Linux paths, filesystems and checks
- Linux directory roles
- /: filesystem root
- /root: administrator home
- /etc: configuration
- /home: ordinary user homes
- /var: variable data/logs
- /dev: device nodes
- /proc: kernel/process information
- /boot: boot material
- /tmp: temporary files
- Cleanup/mount layouts vary
- lost+found ≠ every partition guarantee
- Reboot ≠ every temporary directory erased
👁 Full explanation
/ is the filesystem root; /root is the administrative user’s home. /etc stores configuration, /home ordinary user homes, /var variable data/logs, /dev device nodes, /proc kernel/process information, /boot boot material and /tmp temporary files. Cleanup/mount layouts vary; do not assume every partition has lost+found or every reboot erases every temporary directory. - Filesystems, checking and mounting
- ext2: Linux filesystem
- ext4: later filesystem
- HPFS: historical OS/2 association
- Swap: backing space, not ordinary filesystem
- fsck: filesystem-specific checks/optional repairs
- fsck ≠ init/halt/inittab
- Supported offline/safe repair procedure
- Mount: filesystem attached to directory
- Storage administration: partitioning/mounts/quotas/capacity
👁 Full explanation
ext2 is a Linux filesystem; ext4 is a later filesystem; HPFS is historically associated with OS/2, while swap is backing space rather than an ordinary user-file filesystem. fsck checks and optionally repairs filesystems through filesystem-specific tools; it is not init, halt or an inittab file. Repairs require the filesystem’s supported offline/safe procedure. Mount attaches a filesystem to a directory; partitioning, mounting, quotas and capacity belong to storage administration. - Filesystem origin versus driver support
- Foreign filesystem access possible
- HPFS access: available driver required
- Origin ≠ Linux support
- Swap: paging area
- Native Linux filesystem: ext2
- Native-Linux scope must be explicit
- Broad Linux-use wording: ext2/HPFS ambiguity
👁 Full explanation
Linux can access some foreign-origin filesystems, including HPFS when its driver is available. Filesystem origin and Linux driver support are different questions. Swap is a paging area rather than an ordinary user-file filesystem. ext2 is a native Linux-filesystem example; broader Linux filesystem support can also include HPFS, so distinguish origin from driver support.
4 related practice questions
Note references: NSA-M, NSA-FSCK, LINUX-HPFS
- Linux directory roles
NSA21
Profiles, registry and persistent configuration
- User profile variants
- Local: settings on one client
- Roaming: server synchronization at logon/logoff
- Supported user settings/data
- Large profiles: slower logon/logoff
- Folder redirection: avoid repeated folder copying
- Central profile backup: policy-dependent
- Cached profile ≠ independent local security account
👁 Full explanation
A local profile keeps settings on one client; a roaming profile synchronizes supported user settings/data through a server at logon/logoff. Large profiles can slow these operations; redirected folders avoid repeatedly copying selected folders. A central profile is backed up only if the server’s backup policy actually includes it. A cached profile is not a newly created independent local security account. - Windows registry
- Hierarchical configuration database
- Keys, subkeys, typed values
- HKLM: machine settings
- HKCU: current-user view
- Registry ACLs
- Historical root handles: version-dependent
- Record/export relevant configuration before change
- Authorized change; verify service behavior
👁 Full explanation
The Windows registry is a hierarchical configuration database with keys, subkeys and typed values. HKLM describes machine settings and HKCU the current user view. ACLs protect registry access. Not all historical root handles apply to current versions. Record/export the relevant configuration before an authorized change, and verify the intended service behavior afterward.
Note references: NSA-M
- User profile variants
NSA22
Performance monitoring and bottlenecks
- Performance diagnosis before hardware changes
- Baseline and interval sampling
- Workload comparison and symptom correlation
- CPU utilization/run queues: processing pressure
- Low free memory: weak evidence alone
- Reclaimable cache
- Persistent paging plus latency: memory pressure
- Storage capacity ≠ I/O latency
- Nearly empty disk: saturation possible
- Nearly full disk: light load possible
👁 Full explanation
Measure a baseline, sample over an interval, compare with workload and correlate symptoms before changing hardware. CPU utilization/run queues identify processing pressure; low free memory alone is weak evidence because cache may be reclaimable. Persistent paging with high latency indicates memory pressure. Storage capacity and I/O latency are separate: a disk can be nearly empty but saturated, or nearly full while lightly loaded. - Network measurements and collection methods
- Interface bytes/second
- Errors, drops, delay/loss
- Utilization versus link rate
- Capacity: maximum available rate
- Throughput: observed rate
- Logs: security and performance evidence
- Counters: measured events
- System calls/APIs/log parsers: collection routes
- Methods need not be exclusive
👁 Full explanation
Measure interface bytes/second, errors, drops, packet delay/loss and utilization against link rate. Distinguish capacity (maximum available rate) from observed throughput. Logs can reveal both security incidents and performance faults. Performance counters expose measured events; system calls/APIs and log parsers are ways scripts can collect them. - Worked example Performance calculation and diagnosis examples
- 80 MB/10 s=8 MB/s
- Approximately 64 Mb/s before overhead
- CPU 95% plus growing runnable queue
- Suggested CPU pressure
- Disk 95%-full: capacity action
- Low latency ≠ sufficient free capacity
👁 Full explanation
Worked microexampleTransferring 80 MB in 10 s gives 8 MB/s≈64 Mb/s before overhead. A 95%-busy CPU with a growing runnable queue suggests CPU pressure; a 95%-full disk requires capacity action even if its latency is low.
1 related practice question
Note references: NSA-M
- Performance diagnosis before hardware changes
NSA23
Monitoring, capture and assessment tools
- Monitoring-tool capabilities
- Task Manager: processes/resource use
- Resource Monitor/Performance Monitor: detailed counters
- Wireshark: packet capture/dissection
- Nmap: host/port/service discovery
- Nessus: vulnerability/configuration assessment
- Snort: detection and alerts
- Snort inline: prevention possible
- Snort: sniffing/logging roles
- Packet capture: not exclusive
- Wireshark: conventional analyzer choice
👁 Full explanation
Task Manager shows running processes/resource use; Resource Monitor/Performance Monitor give more detailed counters. Wireshark captures and dissects packets. Nmap discovers hosts/ports/services. Nessus assesses vulnerabilities/configuration. Snort can detect suspicious traffic and alert, and can prevent traffic in suitable inline deployments; it also has sniffing/logging roles. Thus packet-capture capability is not exclusive to one product, although Wireshark is the conventional analyzer choice. - Detection, prevention and evidence limits
- IDS: detect/alert
- IPS: inline blocking
- Scan: potential weaknesses
- Scan ≠ proven exploitation
- Packet/open port/alert: context required
- Usage monitoring ≠ access control
- Usage monitoring ≠ encryption
👁 Full explanation
An IDS detects/alerts; an IPS can block inline. Scanning identifies potential weaknesses rather than proving successful exploitation. A captured packet, open port or alert needs context. Monitoring network usage is not the same as configuring access control or encrypting communications.
4 related practice questions
Note references: NSA-M, NSA-WIRE, NSA-NMAP, NSA-SNORT, NSA-NESSUS
- Monitoring-tool capabilities
NSA24
Backups, restore and continuity
[Exam Focus]- Backup purpose and independence
- Recover previous data
- Deletion, compromise, corruption
- Failed upgrades/migrations; hardware loss
- Authorization: current access, different purpose
- Mirror/replica copies deletions/corruption
- Replica ≠ versioned independent backup
- Protected separate failure domains
- Retention and restore tests
👁 Full explanation
Backups recover previous data after deletion, compromise, corruption, failed upgrades/migrations or hardware loss. Authorization controls current access, a different function. A mirror/replica also copies deletions or corruption and does not replace versioned independent backups. Keep protected copies in separate failure domains, define retention and test restores. - Backup types and recovery objectives
- Full: chosen dataset
- Incremental: since last backup
- Differential: since last full
- Incremental restore: full plus subsequent incrementals
- Differential restore: full plus latest differential
- RPO: tolerable lost-data time
- RTO: tolerable restoration time
- Compression: reduced storage
- Scheduling: operation timing
- Restore testing: recovery usability
👁 Full explanation
A full backup copies the chosen dataset; incremental copies changes since the last backup; differential copies changes since the last full backup. Restoring incrementals generally needs the full plus each subsequent incremental, whereas differential needs the full plus latest differential. RPO is tolerable lost-data time and RTO tolerable restoration time. Compression reduces storage, scheduling runs the operation and restore testing establishes whether recovery actually works.
2 related practice questions
Blueprint: LO1 · Note references: NSA-M
- Backup purpose and independence
NSA25
RAID layouts, capacity and selection
- RAID layout mechanisms
- RAID0: striping, capacity/throughput
- RAID0: no disk-failure tolerance
- RAID1: mirroring
- Two-disk mirror: one disk's usable capacity
- Two-disk mirror: survives one disk failure
- RAID2: bit striping/Hamming redundancy
- RAID3: byte striping/dedicated parity
- RAID4: block striping/dedicated parity
- RAID5: block striping/distributed parity
- RAID6: distributed dual parity
- RAID6: two disk failures tolerated
- RAID10: striped mirrored pairs
- RAID10 survival: failed-disk placement dependent
👁 Full explanation
RAID0 stripes for capacity/throughput with no disk-failure tolerance. RAID1 mirrors; a two-disk mirror has one disk’s usable capacity and survives one disk failure. RAID2 uses bit striping/Hamming-code redundancy, RAID3 byte striping with dedicated parity, RAID4 block striping with dedicated parity and RAID5 block striping with distributed parity. RAID6 distributes dual parity and tolerates two disk failures. RAID10 stripes mirrored pairs; survival depends on which disks fail. - RAID capacity and selection rules
- N equal disks, each capacity D
- RAID0=ND
- Paired RAID1/10≈ND/2
- RAID5=(N−1)D
- RAID6=(N−2)D
- Hardware controller resources/cache: possible offload
- Hardware ≠ universally faster software RAID
- Rebuild bandwidth and parity-write overhead
- University/bank size ≠ level selection
- Striping/parity ≠ uniquely RAID5
- Distributed block parity: RAID5 distinction
👁 Full explanation
With N equal disks of capacity D, RAID0 usable=ND, paired RAID1/10≈ND/2, RAID5=(N−1)D and RAID6=(N−2)D. Hardware RAID may offload work to controller resources/cache but does not universally outperform software RAID. Rebuilds consume bandwidth; parity writes have overhead. A large university/bank alone does not select a level. Striping plus parity is not uniquely RAID5 unless distributed block parity is specified. - Worked example Four-disk capacity example
- Four 2 TB disks
- RAID0=8 TB; RAID10=4 TB
- RAID5=6 TB; RAID6=4 TB
- Metadata ignored
- Failure tolerance, workload, capacity, recovery
- RAID layouts ≠ backups
👁 Full explanation
Worked microexampleFour 2 TB disks give 8 TB RAID0, 4 TB RAID10, 6 TB RAID5 or4 TB RAID6, ignoring metadata. Choose using failure tolerance, workload, capacity and recovery requirements; none of these layouts replaces backups.
5 related practice questions
Note references: NSA-M, NSA-RAID
- RAID layout mechanisms
NSA26
Security policy development and purpose
[Exam Focus]- Security-policy lifecycle
- Required behavior, scope, accountability, enforcement
- Assets and service objectives
- Assess threats and weaknesses
- Choose controls
- Exceptions and incident procedures
- Approve and communicate
- Monitor and periodic review
- CIA: confidentiality, integrity, availability
- No single universal primary objective
👁 Full explanation
A security policy states required behavior, scope, accountable roles and enforcement. Begin with assets/service objectives, assess threats and weaknesses, choose controls, define exceptions/incident procedures, approve/communicate, monitor and periodically review. CIA means confidentiality, integrity and availability; neither sensitive-data protection nor availability alone is the universal primary goal. - Policy requirements and implementation
- Password controls and approved encryption
- Restricted administrative access
- Backups and patch deadlines
- Firewall rules: partial implementation
- Unrestricted wireless conflicts with internal control
- Isolated intentional guest service: exception
- Passive system use ≠ policy purpose
- Coordinated action and reduced risk
- Policy ≠ all attacks fail
👁 Full explanation
A policy can require password controls, approved encryption, restricted administrative access, backups and patch deadlines; firewall rules implement part of it. Open unrestricted wireless access conflicts with controlled internal access unless intentionally isolated as a guest service. “Use the system passively” is not a purpose of security policy. Policies coordinate action and reduce risk; they do not guarantee every attack will fail.
5 related practice questions
Blueprint: LO1, LO3 · Note references: NSA-M, NSA-G
- Security-policy lifecycle
NSA27
Hardening, controls and vulnerabilities
[Exam Focus]- Hardening and risk
- Remove unnecessary services
- Supported patches
- Restricted accounts/permissions
- Appropriate port filtering
- Unused known-port blocking: possible hardening
- Blocking useful ports: availability destroyed
- Weak passwords/unpatched exploitable software: vulnerabilities
- Attacks exploit weaknesses
- Risk: likelihood with impact
👁 Full explanation
Hardening reduces exposure through unnecessary-service removal, supported patches, restricted accounts/permissions and appropriate port filtering. Blocking an unused known port can be hardening; blocking every useful port merely destroys availability. Weak passwords and unpatched exploitable software are vulnerabilities; attacks exploit weaknesses, and risk combines likelihood with impact. - Control functions and patch discipline
- Preventive: restrict harmful actions
- Detective: expose harmful actions
- Recovery: restore service
- Accounts/backups/configuration/traffic analysis: possible controls
- Stated objective determines control relevance
- Vulnerability scan: weakness patterns, not bandwidth
- Test/stage patches
- Prepare rollback; deploy; verify
- Testing/installation: both administrator duties
👁 Full explanation
Preventive controls restrict harmful actions, detective controls expose them and recovery controls restore service. Account lifecycle, backup procedures, device configuration and traffic analysis can all be security controls under a stated objective. A vulnerability scan checks known weakness patterns, not bandwidth. Test/stage patches, prepare rollback, deploy and verify; testing and installation are both legitimate administrator duties.
6 related practice questions
Blueprint: LO1, LO3 · Note references: NSA-M
- Hardening and risk
NSA28
Encryption, hashes and script secrets
- Cryptographic purpose distinctions
- Encryption: confidentiality
- Correct key/nonce use
- Authenticated encryption: integrity/authenticity too
- Unspecified encryption ≠ both guarantees
- Password hash: one-way verification
- Hash ≠ reversible credential store
- Recoverable credential encryption: protected separate key
👁 Full explanation
Encryption provides confidentiality with correct key/nonce use; authenticated encryption adds integrity/authenticity. Unspecified encryption alone does not guarantee both properties. A password hash supports verification without recovering the original password; it is not a reversible credential store. Encryption can protect a recoverable credential only if its key is separately protected. - Script-secret handling
- No reusable secrets in source/logs
- Protected credential service
- Restricted runtime source
- Environment variables/configuration files: storage/transport
- Neither automatically encrypted
- Service authentication: actual credential/token often required
- One-way hash ≠ usable replacement
- Verification versus recoverable service credentials
👁 Full explanation
Keep reusable secrets out of source code and routine logs; obtain them from an appropriately protected credential service or restricted runtime source. Environment variables and configuration files are transport/storage choices, not automatic encryption. A script that must authenticate to another service often needs the actual credential/token, so replacing it with a one-way hash will not work. State whether the question is about password verification or recoverable service credentials.
2 related practice questions
Note references: NSA-M, NSA-AEAD
- Cryptographic purpose distinctions
NSA29
Incidents, evidence and reports
[Exam Focus]- Incident-response lifecycle and reporting
- Prepare; detect/analyze
- Contain; remove cause
- Restore service; learn
- Investigation: reactive response
- Patching/backups: normally preventive/preparatory
- Timestamps and affected systems
- Evidence, impact, actions
- Responsible people and recovery results
- Report may include policy violations
- Incident scope broader than violations
👁 Full explanation
Incident response prepares, detects/analyzes, contains, removes the cause, restores service and learns from the event. Investigation is reactive response; routine patching and backup are normally preventive/preparatory operations. Document timestamps, affected systems, evidence, impact, actions, responsible people and recovery results. An incident report may record policy violations, but its scope is broader than that alone. - Attacks and evidence handling
- DoS: availability harm
- DDoS: distributed sources
- Phishing: user deception
- Brute force: credential attempts
- Interception: communications read/altered
- Correlate logs by time/identity/context
- Preserve evidence before resets
- Suspicious event ≠ confirmed compromise
- Record facts and uncertainty
👁 Full explanation
DoS harms service availability; DDoS uses distributed sources. Phishing deceives users, brute force tries credentials and an interception attack reads/alters communications. Correlate logs using time and identity/context. Preserve relevant evidence before resetting systems. A suspicious event is not automatically confirmed compromise; record facts and uncertainty.
4 related practice questions
Blueprint: LO3 · Note references: NSA-M, NSA-G
- Incident-response lifecycle and reporting
NSA30
Segmentation, NAC and remote administration
[Exam Focus]- Segmentation and admission control
- Separate system groups
- Routing/filtering: allowed flows
- VLAN membership ≠ complete security
- NAC: device/user admission assessment
- Reject/quarantine unauthorized/noncompliant devices
- Authentication: prove identity
- Access rules: allowed resources
👁 Full explanation
Segmentation separates groups of systems and enforces allowed flows with routing/filtering policies; VLAN membership alone does not establish complete security. NAC assesses device/user admission and can reject or quarantine unauthorized/noncompliant devices. Authentication proves an identity, while access rules decide which resources it may use. - Protected remote administration
- SSH/secured management services
- Authentication and protection
- Restricted source access; auditing
- VPN: defined protected-connectivity model
- VPN ≠ packet analyzer
- Firewall: policy-based permit/block
- Firewall filtering ≠ inherent encryption
- Management route/firewall changes: connectivity-loss risk
- Plan for remote lockout
👁 Full explanation
Use authenticated protected remote administration such as SSH or properly secured management services, with restricted source access and auditing. VPNs provide protected connectivity under their defined security model; they are not packet analyzers. Firewall filtering permits/blocks traffic according to policy; it is not inherently encryption. Losing remote connectivity while changing a management route/firewall is an operational risk to plan for.
6 related practice questions
Blueprint: LO1, LO2, LO3 · Note references: NSA-M, NSA-NAC
- Segmentation and admission control
NSA31
Scripting inputs and reusable operations
[Exam Focus]- Administrative script building blocks
- Repeatable automation
- Scripts ≠ inherently faster/secure
- Python, shells, PowerShell
- HTML: markup
- Define inputs and outputs
- Variables: state
- if/elif/else: decisions
- Loops: repetition
- Functions: reuse
- Python indentation: blocks
- ==: comparison; =: assignment
👁 Full explanation
Scripts automate repeatable administration; they are not inherently faster than compiled programs or automatically secure. Python, shells and PowerShell are common choices; HTML is markup. Define inputs and outputs, use variables for state, if/elif/else for decisions, loops for repeated work and functions for reusable operations. Python indentation defines blocks; == compares while = assigns. - Predictable and safe reruns
- Compute desired state
- Compare current state
- Change only differences
- Small dry run before mutation
- Read-only reporting: avoid unnecessary privilege
- Report failures
- Meaningful exit status
- No unconditional success output
👁 Full explanation
Make reruns predictable: compute the desired state, compare with current state and change only what differs. Validate a small dry run before mutation. Avoid requiring privilege for read-only reporting. A good script reports failures and has a meaningful exit status rather than printing success unconditionally. - Worked example Threshold-function trace
- def warn_percent(values, limit)
- Loop unpacking: name,percent
- Condition: percent>=limit
- Inputs: root=92,data=40,limit=90
- Only root meets threshold
- print: space-separated output
- root high 92
👁 Full explanation
Worked microexampledef warn_percent(values, limit): for name, percent in values: if percent >= limit: print(name, "high", percent) warn_percent([("root", 92), ("data", 40)], 90) # Output: root high 92 (with spaces from print). Only the first pair meets the threshold.
2 related practice questions
Blueprint: LO4 · Note references: NSA-FLOW
- Administrative script building blocks
NSA32
Python subprocess command launching
[Exam Focus]- subprocess module and run contract
- Python module ≠ universal shell command
- run: child launch and result
- capture_output: stdout/stderr collection
- text=True: text decoding
- timeout: bounded wait
- check=True: nonzero exit raises
- Argument list: avoid shell interpretation
- List arguments versus shell-string quoting
👁 Full explanation
Python subprocess is a module, not a universal shell command. run launches a child program and returns its result; capture_output collects stdout/stderr, text=True decodes text, timeout bounds waiting and check=True raises for nonzero exit. Pass an argument list to avoid accidental shell interpretation; quote handling differs from composing a shell string. - Command versus language abstraction
- Echo: print
- grep: text search
- ipconfig/ifconfig: network reporting/configuration
- Neither general Python child-process abstraction
- Generic command question: language required
👁 Full explanation
Echo prints, grep searches text and ipconfig/ifconfig reports/configures networking; none is the general Python child-process abstraction. Specify the scripting language before selecting subprocess for process execution. - Worked example subprocess example and failures
- subprocess.run: ip addr show
- text=True; capture_output=True
- check=True; timeout=5
- print(result.stdout)
- Linux; iproute2 installed
- Missing program: OSError
- Nonzero status: CalledProcessError
- Timeout: TimeoutExpired
👁 Full explanation
Worked microexampleimport subprocess result = subprocess.run(["ip", "addr", "show"], text=True, capture_output=True, check=True, timeout=5) print(result.stdout) # Linux with iproute2 installed. Missing program raises OSError; # nonzero status raises CalledProcessError; timeout raises TimeoutExpired.
1 related practice question
Blueprint: LO4 · Note references: NSA-PROC
- subprocess module and run contract
NSA33
File I/O, parsing and updates
[Exam Focus]- Configuration-processing tools
- File I/O: obtain/persist configuration
- String operations: parse values
- Regex: recognize patterns
- Broad useful-concept question: multiple answers
- JSON/INI: format-specific parser
- Avoid blind global substring replacement
- Explicit text encoding
- with: closure even after failure
👁 Full explanation
File I/O obtains/persists configuration; string operations parse values; regex can recognize patterns. File I/O, string operations and regex can all help manipulate configuration; choose according to the task. Use the format’s parser for structured JSON/INI rather than blindly replacing every matching substring. Open text with an explicit encoding and use with so files close even when processing fails. - Configuration-update sequence
- Validate desired output
- Preserve known-good copy
- Temporary file: same filesystem
- Atomic target replacement where supported
- Check permissions and syntax
- Reload affected service
- Verify; retain rollback
- Repeated append ≠ idempotent
👁 Full explanation
For changes, validate the desired output, preserve a known-good copy, write to a temporary file in the same filesystem, then atomically replace the target where supported. Check permissions and configuration syntax, reload the affected service, verify and retain a rollback. Merely appending the same setting on every run is not idempotent. - Worked example JSON validation example
- with open: settings.json, encoding=utf-8
- json.load(handle)
- port=config["port"]
- isinstance(port,int) required
- 1<=port<=65535
- Invalid type/range: ValueError
- Output: validated port and value
- Reporting only; no system-file change
👁 Full explanation
Worked microexampleimport json with open("settings.json", encoding="utf-8") as handle: config = json.load(handle) port = config["port"] if not isinstance(port, int) or not 1 <= port <= 65535: raise ValueError("port must be 1..65535") print("validated port", port) # This example validates/reports and does not alter a system file.
1 related practice question
Blueprint: LO4 · Note references: NSA-IO
- Configuration-processing tools
NSA34
Arguments and targeted error handling
[Exam Focus]- Command-line parsing
- Named typed values and usage
- Python argparse
- Positional arguments: required inputs
- Flags: options
- Validate ranges and paths
- Unchecked input ≠ executable shell text
👁 Full explanation
Command-line parsing converts user inputs into named, typed values and displays usage. In Python argparse, positional arguments supply required inputs and flags enable options. Validate ranges and paths before work; do not let unchecked input become executable shell text. - Worked example Argument/error-handling trace
- ArgumentParser and parse_args
- logfile: Path
- --limit: int, default 10
- limit<1 → p.error
- read_text: UTF-8
- [:limit]: characters, not lines
- Catch OSError/UnicodeError
- Exception skips remaining try
- p.exit(1): read-failed message
- Specific catches expose unexpected programming errors
👁 Full explanation
Worked microexampleimport argparse from pathlib import Path p = argparse.ArgumentParser() p.add_argument("logfile", type=Path) p.add_argument("--limit", type=int, default=10) a = p.parse_args() if a.limit <1: p.error("limit must be positive") try: print(a.logfile.read_text(encoding="utf-8")[:a.limit]) except (OSError, UnicodeError) as exc: p.exit(1, f"read failed: {exc}\n") # Input limit controls characters here. Exceptions skip the rest of try; # catching specific failures makes unexpected programming errors visible.
2 related practice questions
Blueprint: LO4 · Note references: NSA-ARGS, NSA-ERR
- Command-line parsing
NSA35
Regex analysis and log rotation
[Exam Focus]- Regex contracts and log rotation
- Text patterns, not encryption/compression/rotation
- search: match anywhere
- fullmatch: entire string
- Raw strings: backslash-heavy patterns
- Capture needed fields only
- Explicit unmatched/malformed-line handling
- Rotation: bounded size, historical segments
- Parsing and rotation: complementary
👁 Full explanation
Regex recognizes textual patterns; it does not encrypt, compress or rotate logs. search finds a match anywhere, while fullmatch requires the entire string to fit. Use raw Python strings for backslash-heavy patterns, capture only the needed fields and treat unmatched/malformed lines explicitly. Log rotation bounds file size and preserves historical segments; it is complementary to parsing. - Log-analysis evidence
- Count requested event
- Correlate timestamps and hosts
- No matches ≠ unreadable log
- Security and performance uses
- Neither purpose universally exclusive
👁 Full explanation
Count the event actually requested, use timestamps/hosts to correlate, and separate absence of matches from failure to read the log. Logs support security and performance analysis, so neither purpose is universally exclusive. - Worked example Regex status-count example
- re.compile: status=(\d{3})\b
- Three digits and word boundary
- pattern.search per line
- if match: group(1)
- counts.get(code,0)+1
- 200 and 503: one each
- Noise deliberately ignored
👁 Full explanation
Worked microexampleimport re pattern = re.compile(r"status=(\d{3})\b") counts = {} for line in ["status=200 ok", "status=503 unavailable", "noise"]: match = pattern.search(line) if match: code = match.group(1) counts[code] = counts.get(code,0)+1 print(counts) # {"200":1,"503":1}; noise is deliberately ignored.
2 related practice questions
Blueprint: LO4 · Note references: NSA-RE
- Regex contracts and log rotation
NSA36
CPU and memory measurements
[Exam Focus]- Interval CPU measurement
- Cumulative counters: two samples required
- Lifetime total ≠ current utilization
- Linux /proc/stat: CPU categories
- Define idle categories
- Avoid guest-field double counting
- Busy_fraction=1−Δidle/Δtotal
- Chosen nonbusy: idle+iowait
- Iowait interpretation limitations
👁 Full explanation
A cumulative CPU counter must be sampled twice to calculate interval use; a single lifetime total is not current utilization. On Linux /proc/stat exposes cumulative CPU categories; define which categories count as idle and avoid double-counting guest fields. A simple convention is busy fraction=1−Δidle/Δtotal using idle+iowait as the chosen nonbusy categories. Iowait interpretation has limitations. - Available-memory measurement
- /proc/meminfo: MemAvailable
- Estimate without swapping
- MemFree excludes reclaimable memory
- Windows Performance Counters/OS APIs
- Analogous metrics, different interfaces
- System calls/counters/log parsing: complementary
- Only-technique claim requires platform/API
👁 Full explanation
/proc/meminfo exposes MemAvailable, an estimate of memory available without swapping; MemFree alone excludes reclaimable memory. Windows Performance Counters and OS APIs expose analogous measurements through different interfaces. System calls, counters and log parsing can all contribute; selecting one as the only monitoring technique is unjustified without a platform/API. - Worked example Measurement calculation example
- Δtotal=1000 ticks; Δidle=250
- Busy≈75%
- MemTotal=8192 MiB; MemAvailable=2048 MiB
- Approximate unavailable/used=75%
- MemAvailable ≠ exact-allocation success guarantee
👁 Full explanation
Worked microexampleIf total CPU counters grow by 1000 ticks and chosen idle counters by 250, measured busy≈75%. If MemTotal=8192 MiB and MemAvailable=2048 MiB, approximate unavailable/used fraction is75%, not a prediction that an allocation of exactly 2048 MiB must succeed.
1 related practice question
Blueprint: LO4 · Note references: NSA-M, NSA-CPU, NSA-MEM
- Interval CPU measurement
NSA37
Backup scheduling and restore verification
[Exam Focus]- Recurring-job scheduling
- Unix: cron/systemd timers
- Windows: Task Scheduler
- User crontab: minute,hour,day-of-month,month,day-of-week,command
- Absolute paths and known environment
- Protected inputs and logs
- Bounded runtime
- Lock unsafe overlapping jobs
- Interactive PATH/CWD/credentials: not assumed
👁 Full explanation
Schedule recurring work using cron/systemd timers on suitable Unix systems or Task Scheduler on Windows. A user crontab uses minute,hour,day-of-month,month,day-of-week then command. Use absolute paths, known environment, protected inputs, logs, bounded runtime and a lock when overlap is unsafe. Do not assume an interactive PATH, current directory or stored credentials exist in a scheduled job. - Backup verification and tool purposes
- Compression: data packaging
- Scheduling: operation timing
- Check exit status and archive contents
- Restore sample into isolated destination
- Command success ≠ usable backup proof
- Script version control: review aid
- Version control ≠ data backup
👁 Full explanation
Compression packages data; scheduling chooses when the operation runs. Test exit status and the archive contents, then restore a sample into an isolated destination. A successful command alone does not prove a usable backup. Version control of scripts helps review but does not replace data backup. - Worked example Cron entry interpretation
- 0 2 * * *
- Daily 02:00, scheduler timezone
- Runs as crontab owner
- /usr/bin/python3 /opt/backup.py /srv /bak
- Source/destination arguments
- >>/var/log/bak.log: append output
- 2>&1: stderr joins stdout
- Command kept on one line
- Paths/permissions/logging/program: preconfigured
- User crontab: no username field
- System crontab: username possible
👁 Full explanation
Worked microexampleOne user-crontab entry (keep the command on one line): 0 2 * * * /usr/bin/python3 /opt/backup.py /srv /bak >>/var/log/bak.log 2>&1 This runs daily at 02:00 in the scheduler’s timezone as the crontab owner. The script takes its configured source and destination arguments. Paths, permissions, logging and the backup program must already be configured. Standard user crontabs omit a username field; system crontabs may include one.
1 related practice question
Blueprint: LO4 · Note references: NSA-M, NSA-CRON
- Recurring-job scheduling
NSA38
Constructing a bounded backup script
[Exam Focus]- Backup-script structure and limitations
- Separate parsing, preconditions, archive creation, reporting
- Source directory required
- Destination outside source
- Unique output names
- Failed partial ≠ completed backup
- Application consistency and capacity checks
- Retention and independent protected copies
- Teaching script: directory packaging
- No silent scheduled-job installation
👁 Full explanation
Separate argument parsing, preconditions, copying/archive creation and result reporting. Require a source directory, avoid putting the backup inside that source, create unique output names and ensure a failed partial file is not mistaken for a completed backup. Real backup policies also need application consistency, capacity checks, retention and independent protected copies. The following teaching script packages a directory; it does not silently install a scheduled job. - Worked example Backup-script trace and verification
- argparse source/destination: Path
- resolve(): absolute source/destination
- is_dir(): existing directories required
- dst==src or src in dst.parents
- Reject destination inside/equal source
- UTC timestamp name; microseconds
- shutil.make_archive: gztar, root_dir=src
- OSError: remove partial .tar.gz
- unlink(missing_ok=True)
- p.exit(1): failure report
- print completed archive path
- Verify archive members
- Restore into different empty directory
- Compare selected files
👁 Full explanation
Worked microexampleimport argparse, shutil from pathlib import Path from datetime import datetime, timezone p = argparse.ArgumentParser() p.add_argument("source", type=Path) p.add_argument("destination", type=Path) a = p.parse_args() src, dst = a.source.resolve(), a.destination.resolve() if not src.is_dir() or not dst.is_dir(): p.error("source and destination must be existing directories") if dst == src or src in dst.parents: p.error("destination must be outside source") name = datetime.now(timezone.utc).strftime("copy-%Y%m%dT%H%M%S%fZ") base = dst /name try: archive = shutil.make_archive(str(base), "gztar", root_dir=src) except OSError as exc: base.with_suffix(".tar.gz").unlink(missing_ok=True) p.exit(1, f"backup failed: {exc}\n") print(archive) # Run against a teaching directory, verify archive members, then restore # into a different empty directory and compare selected files.
Blueprint: LO4 · Note references: NSA-FLOW, NSA-IO, NSA-ERR, NSA-SHUTIL
- Backup-script structure and limitations
No matching topics. Clear the search or change the filter.
Blueprint learning outcomes
- LO1 · Understand the concepts, principles, and roles of system and network administration
NSA01, NSA10, NSA13, NSA17, NSA24, NSA26, NSA27, NSA30 - LO2 · Provide network services to users
NSA04, NSA05, NSA06, NSA07, NSA09, NSA10, NSA13, NSA17, NSA18, NSA19, NSA30 - LO3 · Identify security policies and troubleshooting
NSA07, NSA08, NSA09, NSA26, NSA27, NSA29, NSA30 - LO4 · Apply scripting for system administration
NSA31, NSA32, NSA33, NSA34, NSA35, NSA36, NSA37, NSA38