Computer Networks Certification Test (Intermediate)

Computer Networks (Intermediate) examines networking the way it is worked out on paper: an address and a prefix length turned into a subnet, a routing table searched for its longest match, a TCP window followed round by round, a link's utilisation computed from its speed and delay. It assumes everything in the Computer Networks (Basic) test and asks for exact results and the reasons behind them.

The questions are multiple choice, and a few ask you to select every correct option, where only the exact set scores. Most describe a small scenario: an address and its prefix length, a short forwarding table, a few routers with link costs, a sender's congestion window, a message and a CRC generator. The wrong options are what the common slips produce, so careful working matters more than speed.

What each topic examines

The questions are spread evenly across eight topics. The OS, DBMS & Networks MCQs are the place to drill all of them.

• OSI and TCP/IP models. How the layers interact rather than what they are called: header overhead and goodput on a real link, the MSS for a given MTU over IPv4 and IPv6, IPv4 fragmentation and its offset field, path MTU discovery, which fields every router rewrites, which checksum catches which error, and how each routing protocol carries its messages.
• Physical and data link layers. Stop-and-wait and sliding-window utilisation, the window needed to keep a link busy, the sequence-number limits of Go-Back-N and Selective Repeat, CRC division, Hamming distance and what a code can detect and correct, two-dimensional parity, the minimum frame size for CSMA/CD, exponential backoff, and how CSMA/CA avoids collisions.
• IP addressing. Network and broadcast addresses for any prefix length, host counts, splitting a block into subnets, VLSM allocation, route summarisation, PAT, and IPv6 compression, subnetting and link-local addresses. If binary still feels slow, the bit manipulation lesson is good practice for reading masks.
• Routing. Longest-prefix match, the distance-vector update and count to infinity, split horizon and poison reverse, link-state flooding and Dijkstra's algorithm on a small graph, the difference between a next hop and a predecessor, and how RIP, OSPF and BGP choose routes. The shortest-path problems are the same algorithm in code.
• TCP and UDP. Sequence and acknowledgement numbers across an exchange, cumulative ACKs after a loss, the receive window, window-limited throughput, slow start and congestion avoidance under Reno, the sawtooth's average rate, teardown states, TIME_WAIT, and the Internet checksum.
• Application protocols. DNS caching and TTLs, reverse lookups, MX preference, why a zone apex cannot be a CNAME, DNS over TCP, round trips for persistent and non-persistent HTTP, conditional requests, and head-of-line blocking in HTTP/1.1, HTTP/2 and HTTP/3.
• Network security. What encrypts what in TLS 1.3, how a certificate chain is checked, how a server proves it owns its certificate, forward secrecy, handshake round trips, wildcard certificates, Diffie–Hellman with small numbers, rule order in a packet filter, SYN cookies and IPsec tunnel mode.
• Devices and topologies. VLANs and broadcast domains, 802.1Q trunks and the native VLAN, routing between VLANs, Spanning Tree root election, root ports and convergence time, broadcast storms, and the delay a store-and-forward switch adds.

The conventions questions state

Several of these results depend on a convention, and a question always names the one it uses. A subnet's usable hosts exclude its network and broadcast addresses. Utilisation questions say whether the acknowledgement's transmission time and processing delays count (usually they do not). Congestion-window questions number the rounds and give the starting window and threshold. OSPF costs come with the reference bandwidth, and Spanning Tree questions give the port costs and timers. Error-detection questions say which bits may be corrupted and which arrive intact. Read that sentence of each question twice: it is usually where the answer turns.

How to prepare

Work the arithmetic by hand until each kind is routine. Take a few addresses with prefixes between /19 and /30 and write out the network, broadcast and host range; then split a /24 for four LANs of different sizes, largest first. Trace Dijkstra on a six-node graph and write down the order in which nodes are fixed. Follow a TCP sender from a window of one segment through slow start, a timeout and congestion avoidance, writing the window for every round. Divide a short message by a CRC generator, and add three 16-bit words as the Internet checksum does.

Then connect the numbers to what you can observe. Running ip addr or ipconfig shows a real prefix; dig shows TTLs counting down in a resolver's cache; a browser's developer tools show whether a page loaded over HTTP/1.1, HTTP/2 or HTTP/3; and a packet capture of one download shows sequence numbers, acknowledgements and the advertised window moving together.

Where candidates lose marks

• Forgetting that a SYN and a FIN each consume one sequence number, or giving the last byte received where an acknowledgement names the next byte expected.
• Treating a timeout and three duplicate ACKs alike. Under Reno only the timeout drops the window to one segment.
• Summarising or subnetting on a boundary that is not a multiple of the block size.
• Using the one-way propagation delay where a round trip is needed, in utilisation and in minimum frame size.
• Naming the router just before the destination as the next hop.
• Assuming the public key encrypts the data in TLS. It authenticates; symmetric keys from the key exchange carry the traffic.