Network Security Basics Practice Questions

The avalanche effect is a fundamental cryptographic property ensuring that minor modifications to the input, specifically the plaintext ($P$) or the key ($K$), result in significant, unpredictable changes in the output ciphertext ($C$). Mathematically, flipping a single input bit should cause each output bit to change with a probability of approximately $0.5$ (or $50\%$). Since this property demands high sensitivity to even minimal changes in either the encryption key or the plaintext to resist cryptanalysis, both options A and B accurately describe the core requirements of the avalanche effect.

[CORRECT_OPTION: A, B]

To solve the columnar transposition cipher for the plaintext "the tomato is a plant in the night shade family" with the keyword "TOMATO", we first remove spaces to obtain the 38-character string: "thetomatoisaplantinthenightshadefamily". Since the keyword "TOMATO" has 6 letters, we fill a grid with 6 columns, row-by-row, and pad the remaining $42 - 38 = 4$ positions with 'X':

Ordering the keyword "TOMATO" alphabetically (A, M, O, O, T, T) assigns indices $\{3, 2, 1, 5, 0, 4\}$ to the columns. Extracting the columns in this order (Col 3, Col 2, Col 1, Col 5, Col 0, Col 4) yields:

1. Column 3 (A): "TINESAX"
2. Column 2 (M): "EOAHTFX"
3. Column 1 (O): "HTLTHEY"
4. Column 5 (O): "MAIIAIX"
5. Column 0 (T): "TAPNGDL"
6. Column 4 (T): "OSTNHMX"

Combining these gives the ciphertext "TINESAX / EOAHTFX / HTLTHEY / MAIIAIX / TAPNGDL / OSTNHMX".

In the RSA algorithm, we are given the modulus $n = pq = 3007$ and Euler's totient function $\phi(n) = (p-1)(q-1) = 2880$.
By expanding the totient function expression, we get $pq - p - q + 1 = 2880$.
Substituting $pq = 3007$, we have $3007 - (p+q) + 1 = 2880$.
Solving for the sum of the primes, we find $p+q = 3008 - 2880 = 128$.
We now need to find two prime numbers, $p$ and $q$, such that their sum is 128 and their product is 3007. By solving the quadratic equation $x^2 - 128x + 3007 = 0$ or by inspection, we find the factors to be 31 and 97. The prime factor that is greater than 50 is 97.

To encrypt "WELCOME TO NETWORK SECURITY!" using the keyword "LAYER", first remove spaces to get 25 characters: WELCOMETONETWORKSECURITY!. Arrange these in a grid with 5 columns corresponding to the keyword "LAYER". Alphabetical order for "LAYER" ($A=1, E=2, L=3, R=4, Y=5$) assigns columns as follows:

Reading the columns in alphabetical order ($A, E, L, R, Y$) produces the sequence: EETSI + COOCY + WMEKR + ONRU! + LTWET. This results in the string EETSICOOCYWMEKRONRU!LTWET.

The avalanche effect is a cryptographic property where a small change in the input (e.g., flipping a single bit) causes a significant, statistically unpredictable change in the output ciphertext. Mathematically, for a block cipher with block size $n$, this means a 1-bit change in plaintext $P$ results in approximately $n/2$ bits changing in the ciphertext $C = E_K(P)$. This behavior is crucial because it ensures high diffusion, preventing cryptanalysts from exploiting statistical patterns or correlations between inputs and outputs to perform linear or differential cryptanalysis. By making the output look random, the avalanche effect drastically increases the security of the algorithm. Therefore, it is a highly desirable property for any robust cryptographic system.

Asymmetric cryptography relies on key pairs, consisting of a public key $K_{pub}$ and a private key $K_{priv}$, whereas symmetric cryptography uses a single shared secret key $K$. The RSA algorithm is a well-known public-key cryptosystem based on integer factorization, and the Diffie-Hellman algorithm is a standard protocol for asymmetric key exchange. In contrast, the Electronic Code Book (ECB) is a fundamental mode of operation specifically designed for symmetric block ciphers, where each block of plaintext $P_i$ is encrypted independently using the same key $K$. Therefore, because ECB is inherently a symmetric encryption method, it is not used in asymmetric key cryptography.

A two-firewall DMZ architecture uses a front-end and a back-end firewall to separate traffic across three distinct zones: the external network $N_1$, the DMZ $N_2$, and the internal network $N_3$.
This setup enforces strict segmentation, allowing administrators to define specific security policies for each interface.
By isolating $N_2$ from $N_3$ and $N_1$, the firewalls act as checkpoints that regulate the flow of data packets between any two zones.
Therefore, this configuration grants the administrator precise control over where traffic is permitted or denied across the three defined network segments.

To find the private key $d$ in the RSA algorithm, we follow these steps:

1. Calculate the modulus $n = p \times q$.
   $n = 13 \times 17 = 221$.
2. Calculate Euler's totient function $\phi(n) = (p-1)(q-1)$.
   $\phi(n) = (13-1)(17-1) = 12 \times 16 = 192$.
3. The private key $d$ is the modular multiplicative inverse of the public key $e=35$ modulo $\phi(n)$. We need to solve the congruence:
   $e \cdot d \equiv 1 \pmod{\phi(n)} \implies 35d \equiv 1 \pmod{192}$.
4. By testing the options, we check $d=11$:
   $35 \times 11 = 385$.
   $385 \pmod{192} = (2 \times 192 + 1) \pmod{192} = 1$.
   The congruence holds, so the private key is 11.

A birthday attack on a digital signature involves finding two different messages, m and m', that have the same hash value. The sender (S), who possesses the private key, can exploit this. S can generate an innocent message m and a fraudulent one m', find a hash collision, and get the receiver (R) to agree to m. S then provides the signature for hash(m). Later, S can claim to have sent m', as the signature is also valid for it. A third party or the receiver cannot perform this attack because they lack the sender's private key to create a valid signature for any message.

Pretty Good Privacy (PGP) is a cryptographic software application used to provide privacy, data integrity, and authentication for digital communications. Its primary and most widely recognized implementation is in the realm of email security, where it allows users to encrypt the body of an email and sign the message to verify the sender's identity. While PGP can be utilized for file encryption, it does not serve as a standard security protocol for browser traffic (typically handled by TLS/SSL) or FTP (typically handled by SFTP/FTPS). Therefore, PGP is fundamentally associated with secure email transmission.

The Message Digest Algorithm 5 (MD5) is a widely used cryptographic hash function designed to produce a fixed-size output from an input of arbitrary length. The algorithm operates by processing the input data in $512$-bit blocks through a series of logical and arithmetic operations. After these transformations, the process results in a final hash value that is exactly $128$ bits in length. This $128$-bit digest is typically represented as a $32$-digit hexadecimal number. Therefore, the output size of the MD5 hash function is $128$ bits.

To digitally sign a message $m$, the sender (B) must generate a signature by encrypting the message digest $H(m)$ using their own private key, denoted as $K_{B}^{-}$. The resulting signature is $K_{B}^{-}(H(m))$, which ensures authenticity and non-repudiation, as only B possesses the private key $K_{B}^{-}$. The receiver (A) verifies this signature using B's corresponding public key $K_{B}^{+}$. Therefore, the message $m$ is sent alongside the signature as $\{m, K_{B}^{-}(H(m))\}$.

Digital signatures rely on asymmetric cryptography. The sender, Anarkali, creates a signature by using her own private key. To verify the authenticity of this signature, the receiver, Salim, must use the sender's corresponding public key. This process confirms that the message was indeed signed by Anarkali and has not been altered in transit. Therefore, Salim requires Anarkali's public key for verification.

In the class hierarchy $A \leftarrow B \leftarrow C$ using public inheritance, class $B$ inherits $A$'s public and protected members as public and protected, respectively.
Similarly, class $C$ inherits these members from $B$, along with $B$'s own public and protected data.
A member function of class $C$ can access all its own members, including private, protected, and public data.
However, it cannot directly access the private data of classes $A$ or $B$.
Consequently, $C$ can access all its own data, plus the public and protected data belonging to $A$ and $B$.

In a symmetric key cryptographic system, each unique pair of people requires one shared secret key to communicate privately. To find the total number of keys, we must calculate the number of distinct pairs that can be formed from a group of $N$ people. This is mathematically equivalent to the number of combinations of $N$ items taken $2$ at a time, denoted as $\binom{N}{2}$. Using the combination formula:

$\binom{N}{2} = \frac{N!}{2!(N-2)!} = \frac{N \times (N-1) \times (N-2)!}{2 \times (N-2)!} = \frac{N(N-1)}{2}$

Thus, the total number of keys required is $\frac{N(N-1)}{2}$.

To find the decryption key $d$, first calculate the Euler's totient function $\phi(n) = (p-1)(q-1)$:
$\phi(n) = (5-1)(11-1) = 4 \times 10 = 40$.
The decryption key $d$ satisfies the modular inverse equation $d \times e \equiv 1 \pmod{\phi(n)}$, where $e=27$.
Substituting the values, we solve $27d \equiv 1 \pmod{40}$.
Testing option A ($d=3$): $27 \times 3 = 81$.
Since $81 \equiv 1 \pmod{40}$, the condition is satisfied, making $d=3$ the correct decryption key.

To identify which protocols generate a message digest, we need to understand the function of each option:
RSA (Rivest-Shamir-Adleman) is an asymmetric encryption algorithm used for secure data transmission. It does not generate message digests.
SHA-1 (Secure Hash Algorithm 1) is a cryptographic hash function that takes an input and produces a 160-bit (20-byte) hash value known as a message digest.
DES (Data Encryption Standard) is a symmetric-key algorithm for the encryption of electronic data. It does not generate message digests.
MD5 (Message-Digest Algorithm 5) is a widely used cryptographic hash function that produces a 128-bit (16-byte) hash value, or message digest.

Therefore, SHA-1 and MD5 are the protocols used to generate a message digest.

To add a digital signature, X uses their private key to sign $\sigma$. This ensures authenticity and non-repudiation, meaning Y can verify the sender and that the message hasn't been tampered with.
Next, for confidentiality, X encrypts the signed message $\lt M, \sigma \gt$ using Y's public key. Only Y, who possesses the corresponding private key, can decrypt this message.
Upon receiving the message, Y first decrypts it using their own private key to reveal $\lt M, \sigma \gt$.
Finally, Y verifies X's digital signature using X's public key. This confirms the message's origin and integrity.

The plaintext "ISRO" maps to numerical values $I=8, S=18, R=17, O=14$.
Applying the cipher function $C(M) = (7M + 13) \mod 26$ to each value:
$M=8 (I): (7 \times 8 + 13) \mod 26 = 69 \mod 26 = 17 (R)$.
$M=18 (S): (7 \times 18 + 13) \mod 26 = 139 \mod 26 = 9 (J)$.
$M=17 (R): (7 \times 17 + 13) \mod 26 = 132 \mod 26 = 2 (C)$.
$M=14 (O): (7 \times 14 + 13) \mod 26 = 111 \mod 26 = 7 (H)$.
Concatenating these results yields the ciphertext "RJCH".

The Feistel structure is a symmetric block cipher design that splits an input block of size $2w$ into left ($L$) and right ($R$) halves. Each round $i$ follows the transformation $L_i = R_{i-1}$ and $R_i = L_{i-1} \oplus F(R_{i-1}, K_i)$, where $F$ is a round function and $K_i$ is the round subkey. Analyzing the options: AES uses a Substitution-Permutation Network (SPN), RSA is an asymmetric algorithm based on integer factorization, and RC4 is a stream cipher. The Data Encryption Standard (DES) is a well-known block cipher that explicitly utilizes this 16-round Feistel structure to process 64-bit data blocks.