Network Security Basics Practice Questions

Poly-alphabetic substitution ciphers utilize multiple substitution alphabets to encrypt text, distinguishing them from mono-alphabetic ciphers that use a single fixed mapping. The Caesar cipher is mono-alphabetic, as it applies a constant shift $k$ to every character. In contrast, the Vigenère cipher uses a keyword to cyclically apply different shifts $k_i \in \{0, \dots, 25\}$ to each plaintext character, effectively rotating through multiple Caesar ciphers based on the key's position. Since the P-box performs bit permutation and the S-box is a component of modern algorithms rather than a classical poly-alphabetic cipher, the Vigenère cipher is the correct classification.

In IPsec tunnel mode, the entire original IP packet is encrypted and encapsulated within a new packet.
The resulting structure is represented as: $[New\ IP\ Header] + [IPsec\ Header] + [Original\ IP\ Packet]$
By embedding the original packet, a new outer IP header is generated to facilitate routing between VPN gateways.
This encapsulation hides the original source and destination IP addresses, providing security for the inner packet.
Therefore, the use of tunnel mode results in an IP packet containing a new header.

The Advanced Encryption Standard (AES) is a block cipher that employs the same secret key $K$ for both the encryption process $E(P, K) = C$ and the decryption process $D(C, K) = P$. Because both the sender and the receiver must possess and use the identical key to ensure data confidentiality, it is classified as a symmetric cryptosystem. Asymmetric algorithms, such as public-key cryptography, rely on a distinct pair of keys, while key exchange protocols focus on establishing keys rather than the encryption process itself. Given that AES operates using a single shared secret key, it is defined as a symmetric key algorithm.

The RSA cryptosystem relies on modular arithmetic.
I. The equations $M'=M^{e} \pmod n$ and $M=(M')^{d} \pmod n$ correctly represent the encryption and decryption processes in RSA, respectively. This is the core functionality.
II. The relationship between the public exponent $e$ and the private exponent $d$ is defined modulo $\phi(n)$, not modulo $n$. Thus, $ed=1 \pmod n$ is incorrect.
III. The condition $ed=1 \pmod{\phi (n)}$ correctly defines the relationship between the public exponent $e$ and the private exponent $d$ in RSA key generation, ensuring decryption works.
IV. The modular operations for encryption and decryption are performed modulo $n$, not modulo $\phi(n)$. Therefore, $M'=M^{e} \pmod{\phi (n)}$ and $M=(M')^{d} \pmod{\phi (n)}$ are incorrect.

Thus, I and III correctly represent parts of the RSA cryptosystem.

SHA-1 (Secure Hash Algorithm 1) is a cryptographic hash function designed to process an input of any length and produce a fixed-size $160$-bit hash value, commonly referred to as a message digest. Unlike encryption (A) or decryption (B) algorithms, hash functions are one-way, meaning the original data cannot be reconstructed from the output. It differs from key exchange algorithms (C), such as Diffie-Hellman, which facilitate secure communication establishment. Since SHA-1 is designed specifically for verifying data integrity via these fixed-length identifiers, it is classified as a message digest function.

Public key encryption utilizes an asymmetric key pair consisting of a public key ($K_{pub}$) for encryption and a private key ($K_{priv}$) for decryption. To send a message ($P$), the sender encrypts it using the recipient's public key: $C = E(K_{pub}, P)$. Because only the intended receiver possesses the corresponding private key ($K_{priv}$), they alone can decrypt the ciphertext ($C$) to recover the original plaintext ($P$): $P = D(K_{priv}, C)$. Consequently, this mechanism ensures that only the authorized receiver is able to decode the transmitted data.

In a secret key (symmetric) cryptosystem, every unique pair of $n$ individuals must share a distinct secret key. The number of such pairs is given by the combination formula $\binom{n}{2} = \frac{n(n-1)}{2}$. In a public key (asymmetric) cryptosystem, each of the $n$ individuals possesses a key pair consisting of one public key and one private key. Therefore, the total number of keys required is $n$ public keys plus $n$ private keys, which equals $n + n = 2n$. Consequently, the total keys required for secret and public key systems are $\frac{n(n-1)}{2}$ and $2n$, respectively.

The X.509 standard specifies the format for public key certificates used in Public Key Infrastructure (PKI) for secure internet communication. Options A (X.25) relates to packet-switching protocols, B (X.301) addresses network services, and C (X.409) defines the early standard for Abstract Syntax Notation One (ASN.1). Unlike these, the ITU-T standard X.509 explicitly defines the structure, encoding, and authentication protocols for digital certificates. Consequently, it serves as the essential foundation for Transport Layer Security ($TLS$) and identity verification on the internet.

We compute the powers of $3 \pmod{17}$ sequentially:
$3^1 \equiv 3$, $3^2 \equiv 9$, $3^3 \equiv 27 \equiv 10 \pmod{17}$.
Next, $3^4 \equiv 81 \equiv 13 \equiv -4 \pmod{17}$.
Then, $3^8 \equiv (3^4)^2 \equiv (-4)^2 \equiv 16 \equiv -1 \pmod{17}$.
Since $3^8 \not\equiv 1 \pmod{17}$, the minimum exponent $p$ such that $3^p \equiv 1 \pmod{17}$ must be $16$.
Verifying, $3^{16} \equiv (3^8)^2 \equiv (-1)^2 \equiv 1 \pmod{17}$.
Thus, the minimum positive integer $p$ is $16$.

To create a digital signature, a sender first generates a message digest (hash) of the data. To ensure authenticity and non-repudiation, the sender encrypts this hash using their unique $Private\_Key_{sender}$. This encrypted hash serves as the digital signature, which can be verified by the receiver using the sender's $Public\_Key_{sender}$. Because the $Private\_Key_{sender}$ is kept secret and accessible only to the sender, it is the only key used for the signing process. Therefore, the sender must use their private key.

The concatenated $32$-bit sequence of the four given bytes is $10100011001101111110100110101011$.
Dividing this sequence into $6$-bit groups yields the binary values: $101000, 110011, 011111, 101001, 101010, 110000$.
Converting these $6$-bit groups to their corresponding decimal values gives: $40, 51, 31, 41, 42, 48$.
Mapping these decimal values to the Base64 alphabet ($A-Z: 0-25$, $a-z: 26-51$), we obtain: $40 \to 'o', 51 \to 'z', 31 \to 'f', 41 \to 'p', 42 \to 'q', 48 \to 'w'$.
The resulting Base64 string is "ozfpqw", which clearly contains "fpq" as a substring.

Statement (i) is false because hash functions map inputs from an arbitrarily large domain to a fixed-size output space, which inevitably leads to collisions and violates the injective property. Formally, for a function $f: A \to B$ to be injective, it must satisfy $|A| \leq |B|$; since hash functions have $|A| \gg |B|$, they cannot be injective. Statement (ii) is true because DES is a block cipher that, for any fixed key, functions as a permutation (bijection) on the set of all possible input blocks of size $n$, where $n$ is the block size. Each unique plaintext block is mapped to a unique ciphertext block, confirming it is a permutation on the input space.

SSL provides three primary security services: secret communication (B), data integrity protection (C), and mutual authentication (A). It functions as a protocol layer built upon the reliable transport layer, typically TCP. TCP manages data reliability, which encompasses $Error \ detection \ and \ correction$ through mechanisms like checksums and acknowledgments. Because SSL assumes that the underlying protocol ensures delivery, it does not re-implement these reliability features. Therefore, error detection and correction are not responsibilities of the SSL protocol.

To maintain the state of an arbitrary number of active TCP connections, a firewall must track sequence numbers and connection statuses, which requires memory proportional to the number of concurrent connections. A Finite Automaton has fixed memory and is insufficient to track an unbounded number of connections. A Pushdown Automaton with one stack is limited by its restricted access pattern. Since a Pushdown Automaton with two stacks is computationally equivalent to a Turing Machine, it possesses the necessary capability to simulate the arbitrary storage and retrieval required to maintain a dynamic connection state table. Thus, the minimum requirement to track an unbounded set of connections is a PDA with two stacks.

A hash function is defined as a mathematical function $H$ that maps an input message $M$ of arbitrary length to a fixed-size bit string (digest) $D$, making statement I true. Because the domain of possible messages $M$ is infinite and the output range $D$ is finite, the pigeonhole principle guarantees that collisions, where distinct messages map to the same hash value, are mathematically possible, making statement III true. Conversely, statement II is incorrect as hash functions map inputs to a fixed, not variable, output length. Therefore, statements I and III are the only correct assertions.

Given public parameters are modulus $p = 7$ and primitive root $g = 3$.
Party A computes their public key $A = g^a \pmod p = 3^2 \pmod 7 = 9 \equiv 2 \pmod 7$.
Party B computes their public key $B = g^b \pmod p = 3^5 \pmod 7 = 243 \equiv 5 \pmod 7$.
The shared secret key is computed as $K = B^a \pmod p = 5^2 \pmod 7 = 25 \equiv 4 \pmod 7$.
Verification using Party A's public key yields $K = A^b \pmod p = 2^5 \pmod 7 = 32 \equiv 4 \pmod 7$.
The resulting shared secret key is 4.

In public key cryptography, a receiver possesses a key pair consisting of a public key $PK_R$ and a private key $SK_R$. To ensure confidentiality, the sender encrypts the plaintext message $M$ using the receiver's public key $PK_R$, resulting in ciphertext $C = E(M, PK_R)$. This ciphertext can only be decrypted by the receiver using their unique private key $SK_R$ via the operation $M = D(C, SK_R)$. Since the private key $SK_R$ is kept secret by the receiver, only they can access the original message. Therefore, the sender must use the receiver's public key to encrypt the message.

SYN flood attack exploits TCP's 3-way handshake: (1) Attacker sends thousands of SYN packets with random spoofed source IPs. (2) Server responds with SYN-ACK to each and allocates a Transmission Control Block (TCB) - waiting for the final ACK. (3) Since source IPs are fake, no ACK ever arrives. (4) Server's half-open connection queue fills up, refusing new legitimate connections. Mitigation - SYN cookies: instead of allocating state on SYN receipt, the server encodes connection info into the SYN-ACK's sequence number (a cryptographic cookie). State is only allocated when the client completes the handshake with the correct ACK, proving the source IP is real.

Cryptographic hash function properties: Pre-image resistance (one-way): given digest H(m), computationally infeasible to find any message m. Second pre-image resistance (weak collision resistance): given m, infeasible to find m' ≠ m with H(m) = H(m'). Collision resistance (strong collision resistance): infeasible to find ANY pair (m, m') with m ≠ m' and H(m) = H(m'). Additional properties: deterministic (same input always gives same output), fast to compute, avalanche effect (small input change causes large output change), fixed output size. D is FALSE - a hash function is one-way (not reversible). Common hash functions: MD5 (128-bit, broken), SHA-1 (160-bit, deprecated), SHA-256, SHA-3.