The hash function is given as h(k)=k mod 13.
The table size is 13, meaning we have indices from 0 to 12.

Step-by-Step Insertion Process

Key: 10
Hash value: h(10) = 10 mod 13 = 10. Insert 10 at index 10.

Key: 3
Hash value: h(3) = 3 mod 13 = 3. Insert 3 at index 3.

Key: 6
Hash value: h(6) = 6 mod 13 = 6. Insert 6 at index 6.

Key: 16
Hash value: h(16) = 16 mod 13 = 3. Index 3 is occupied. Use linear probing and insert 16 at index 4.

Key: 17
Hash value: h(17) = 17 mod 13 = 4. Index 4 is occupied. Use linear probing and insert 17 at index 5.

Key: 19
Hash value: h(19) = 19 mod 13 = 6. Index 6 is occupied. Use linear probing and insert 19 at index 7.

Final Hash Table

Summary
The final hash table after inserting all keys using linear probing is as follows:

[ - , - , - , 3 , 16 , 17 , 6 , 19 , - , - , 10 , - , - ]

Man-in-the-Middle (MITM) Attack on Diffie–Hellman Key Exchange

In a MITM attack on Diffie–Hellman (DH), an attacker (Mallory) sits between Alice and Bob, intercepts their public keys, and replaces them with her own. Since basic DH provides no authentication, Alice and Bob cannot verify the real sender of the public key.

Normal DH (No Attack)

• Public parameters: prime p, generator g
• Alice selects private key a, sends public key A = g^a mod p
• Bob selects private key b, sends public key B = g^b mod p
• Shared key: K = g^ab mod p

MITM Attack (Attacker Generates Two Key Pairs)

Step 1: Interception
Mallory intercepts Alice’s public key A and Bob’s public key B.

Step 2: Mallory Creates Two Private Keys
Mallory chooses two private keys: m1 (for Bob) and m2 (for Alice).

Step 3: Mallory Generates Two Public Keys
Mallory computes:
M1 = g^m1 mod p
M2 = g^m2 mod p

Step 4: Key Replacement (Fake Public Keys)
Mallory sends M1 to Bob pretending it is from Alice.
Mallory sends M2 to Alice pretending it is from Bob.

Step 5: Two Different Shared Keys are Formed

• Alice computes: K1 = (M2)^a mod p (Alice–Mallory key)
• Bob computes: K2 = (M1)^b mod p (Bob–Mallory key)
• Mallory can compute both keys:
  K1 = (A)^m2 mod p and K2 = (B)^m1 mod p

Result

• Alice and Bob do not share the same secret key.
• Mallory shares one key with Alice and another key with Bob.
• Mallory can read, modify, and re-encrypt messages between them.

Why It Works

Because basic Diffie–Hellman does not provide authentication, public keys can be replaced without detection.

Prevention

• Use Authenticated Diffie–Hellman
• Use Digital Signatures / Certificates (PKI)
• Use TLS (DHE/ECDHE + certificates)

The concepts of confidentiality, integrity, and availability (CIA triad) directly address the security concerns of falsification, interception, masquerade, and denial of service.

Confidentiality ensures that sensitive information is accessible only to authorized users, protecting against interception, where data could be accessed or stolen by unauthorized parties.

Integrity guarantees that data remains accurate and unaltered, defending against falsification, which involves malicious modification of data, and masquerade, where attackers assume false identities to tamper with information.

Availability ensures that information and resources are accessible when needed, countering denial of service (DoS) attacks that aim to make systems or data unavailable to legitimate users.

By maintaining confidentiality, integrity, and availability, organizations can effectively mitigate these four major security threats and enhance overall data protection.

#include <stdio.h>
int main () {
int n1, n2, max;
printf ("Enter two positive integers: ");
scanf ("%d %d", &n1, &n2);
// maximum number between n1 and n2 is stored in max

max = (n1> n2) ? n1: n2;
while (1) {
// Check if max is divisible by both n1 and n2
if ((max% n1 == 0)&& (max % n2 ==0)) {
 // If true, max is the LCM of n1 and n2
printf("The LCM of %d and %d is %d.", n1,n2,max);
break;
}
++max;
}
return 0;
}

    
Sample I/O:
Enter two positive integers: 14 8
The LCM of 14 and 8 is 56.
=== Code Execution Successful ===

Suitable OSI Layer for End-to-End Encryption

To implement end-to-end encryption (E2EE) while considering development time, software maintainability, and development cost, the most suitable layer of the OSI model is the Application Layer (Layer 7).

Reasons for Choosing the Application Layer

• Faster Development Time: Encryption at the application layer can be implemented directly within the application logic. Developers do not need to modify lower-level networking protocols, which significantly reduces development time.
• Better Software Maintainability: Application-layer encryption is easier to update, debug, and maintain. Changes can be made without affecting the underlying network infrastructure or operating system.
• Lower Development Cost: No changes are required in routers, switches, or transport-layer implementations. This avoids hardware upgrades and reduces overall implementation cost.
• True End-to-End Security: Data is encrypted at the sender’s application and decrypted only at the receiver’s application. Intermediate systems (routers, proxies, servers) cannot read the data.
• Platform Independence: Application-layer encryption works across different networks, protocols, and platforms without compatibility issues.

Why Not Lower Layers?

• Transport Layer (e.g., TLS): Requires certificate management and protocol-level integration, increasing complexity and cost.
• Network/Data Link Layers: Require hardware or OS-level changes, leading to high cost and poor maintainability.

Considering development time, cost efficiency, and long-term maintainability, implementing end-to-end encryption at the Application Layer is the best and most practical choice.

Method Overloading, Method Overriding, and Method Hiding

1. Method Overloading

Method overloading occurs when multiple methods in the same class have the same method name but different parameter lists (different number, type, or order of parameters).

• Resolved at compile time
• Improves code readability and flexibility

Example:

int add(int a, int b)
int add(int a, int b, int c)

2. Method Overriding

Method overriding happens when a subclass provides a new implementation of a method that is already defined in its superclass with the same method signature.

• Occurs in inheritance
• Resolved at runtime (runtime polymorphism)
• Method must be non-static

Example:

class Parent {
  void show() { }
}
class Child extends Parent {
  void show() { }
}

3. Method Hiding (Hiding Superclass Method)

Method hiding occurs when a static method in a subclass has the same name and signature as a static method in the superclass.

• Applies only to static methods
• Resolved at compile time
• Not true overriding

Example:

class Parent {
  static void display() { }
}
class Child extends Parent {
  static void display() { }
}

Summary Comparison

• Overloading: Same class, same method name, different parameters
• Overriding: Subclass redefines superclass method (non-static)
• Hiding: Static method in subclass hides static method of superclass