Explanation: The computer boots from the device with the highest priority. Setting the SSD as the first boot device allows the installed OS to load instead of booting from the network.

Two-Factor Authentication (2FA):

2FA is a security method that requires two different authentication factors to verify a user's identity before granting access.

Types of Authentication Factors:
1. Something You Know: Password or PIN.
2. Something You Have: Smartphone OTP or security token.
3. Something You Are: Fingerprint or facial recognition.

CIA Triad:

The CIA Triad is a basic information security model consisting of three principles:

1. Confidentiality: Ensures that data is accessible only to authorized users.

2. Integrity: Ensures that data remains accurate, complete, and unaltered.

3. Availability: Ensures that systems and data are accessible to authorized users whenever needed.

Three Main Components of a URL

Given URL: https://www.bb.org.bd/index.php

1. Protocol (Scheme): https://
It defines the communication protocol used to transfer data securely between the browser and the web server.

2. Domain Name (Host): www.bb.org.bd
It is the human-readable address of the web server. Here, it refers to the Bangladesh Bank website.

3. File Path (Resource): /index.php
It identifies the requested resource on the server, such as the PHP script used to generate a webpage.

1. More Simultaneous Applications: RAM Upgrade (8 GB to 16 GB)
RAM stores the data and instructions of running applications. Increasing RAM allows more applications to run simultaneously and smoothly.

2. More Data Storage: SSD Upgrade (256 GB to 512 GB)
SSD provides permanent storage for the Operating System, software, documents, and other files. Increasing SSD capacity allows more data to be stored.

(a) Remaining Mailbox Storage:

Total Quota = 2 GB = 2,000 MB

Total Used = 350 + 1,250 + 0.9 + 120 = 1,720.9 MB

Remaining Storage = 2,000 − 1,720.9 = 279.1 MB

(b) To Receive a 300 MB File:

Required Space = 300 − 279.1 = 20.9 MB

The recipient should free up at least 20.9 MB of mailbox storage, preferably 21 MB, by deleting unnecessary emails and emptying Trash. Alternatively, the sender can share the file through Google Drive or OneDrive.

Advantages of Mobile Banking:

1. 24/7 Accessibility: Allows transactions anytime and anywhere without visiting a bank.

2. Financial Inclusion: Provides banking services to rural and unbanked people.

3. Time and Cost Efficiency: Saves time, travel costs, and transaction expenses.

4. Instant Transactions: Enables quick fund transfers and bill payments.

5. Automated Tracking: SMS alerts and digital statements help monitor transactions and expenses.

Challenges of Mobile Banking:

1. Security and Fraud Risks: Users may face phishing, SIM swapping, malware, and credential theft.

2. Network Infrastructure: Poor internet or mobile network coverage can interrupt services.

3. Digital Illiteracy: Some users struggle to operate mobile banking applications safely.

4. Device Dependency: Services depend on a functioning mobile device and sufficient battery power.

5. System Downtime and Limits: Server outages and transaction limits may delay payments or transfers.

Three Fundamental Principles of Information Security:

1. Principle of Least Privilege (PoLP): Users and applications should receive only the minimum access permissions necessary to perform their tasks. This reduces the risk of unauthorized access and damage.

2. Defense in Depth: Multiple layers of security, such as firewalls, MFA, antivirus, and encryption, are used to protect systems. If one layer fails, other layers provide additional protection.

3. Non-Repudiation: Ensures that a person cannot deny an action or message they have performed or sent. Digital signatures and audit logs help establish proof.

#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 ===

Initial array as a binary tree:

          56
       /      \
     33        48
    /  \      /  \
  29   99   12  344

          56
       /      \
     33        12
    /  \      /  \
  29   99   48  344

          56
       /      \
     29        12
    /  \      /  \
  33   99   48  344

          12
       /      \
     29        56
    /  \      /  \
  33   99   48  344

          12
       /      \
     29        48
    /  \      /  \
  33   99   56  344

Final Result

The array now satisfies the min heap property: every parent node is smaller than or equal to its children.

          12
       /      \
     29        48
    /  \      /  \
  33   99   56  344

Complete Binary Tree Adjacency List Representation

Adjacency Matrix Representation

#include <iostream>
using namespace std;
int main() {
    int size1, size2;
    // Taking input size of first array
    cout << "Enter size of first array: "; 
    cin >> size1;
    int arr1[size1];
    cout << "Enter elements of first array:\n";
    for (int i = 0; i < size1; i++) {
        cin >> arr1[i];
    }
    // Taking input size of second array
    cout << "Enter size of second array: ";
    cin >> size2;
    int arr2[size2];
    cout << "Enter elements of second array:\n";
    for (int i = 0; i < size2; i++) {
        cin >> arr2[i];
    }
    // To store common elements
    int commonElements[size1 < size2 ? size1 : size2];
    int count = 0;
    // Check each element in arr1 against arr2
    for (int i = 0; i < size1; i++) {
        bool found = false;
        for (int j = 0; j < size2; j++) {
            if (arr1[i] == arr2[j]) {
                found = true;
                break;
            }
        }
        if (found) {
            // Check for duplicates
            bool alreadyExists = false;
            for (int k = 0; k < count; k++) {
                if (commonElements[k] == arr1[i]) {
                    alreadyExists = true;
                    break;
                }
            }
            if (!alreadyExists) {
                commonElements[count] = arr1[i];
                count++;
            }
        }
    }
    // Print common elements
    cout << "Common elements: ";
    for (int i = 0; i < count; i++) {
        cout << commonElements[i] << " ";
    }
    cout << endl;
    // Print total count
    cout << "Total number of common elements: " << count << endl;
    return 0;
}

Sample I/O:
Enter size of first array: 5
Enter elements of first array: 0 20 30 40 50
Enter size of second array: 6
Enter elements of second array: 10 2 20 30 60 90
Common elements: 20 30 
Total number of common elements: 2

=== Code Execution Successful ===

The Need matrix is calculated as: Need = Max - Allocation For each process, we subtract the Allocation from the Max to get the Need Matrix.

Step-by-step checking for our system:

• P0: Needs [0, 0, 0, 0] ≤ Available [1, 5, 2, 0] → yes, so finish P0.
• Update Available by adding P0's allocation: [1, 5, 2, 0] + [0, 0, 1, 2] = [1, 5, 3, 2]
• P1: Needs [0, 7, 5, 0] ≤ Available [1, 5, 3, 2] → no, cannot finish yet.
• P2: Needs [1, 0, 0, 2] ≤ Available [1, 5, 3, 2] → yes, finish P2.
• Update Available : [1, 5, 3, 2] + [1, 3, 5, 4] = [2, 8, 8, 6]
• P3: Needs [0, 0, 2, 0] ≤ Available [2, 8, 8, 6] → yes, finish P3.
• Update Available : [2, 8, 8, 6] + [0, 6, 3, 2] = [2, 14, 11, 8]
• P4: Needs [0, 6, 4, 2] ≤ Available [2, 14, 11, 8] → yes, finish P4.
• Update Available : [2, 14, 11, 8] + [0, 0, 1, 4] = [2, 14, 12, 12]
• P1 (rechecked): Needs [0, 7, 5, 0] ≤ Available [2, 14, 12, 12] → yes, finish P1.
• Update Available : [2, 14, 12, 12] + [1, 0, 0, 0] = [3, 14, 12, 12]

Since all processes can finish in this order, the system is in a safe state.

Safe sequence: <P0, P2, P3, P4, P1>

Protocols used in Application Layer and Transport Layer:

Application Layer: The protocol commonly used here for sending emails is SMTP (Simple Mail Transfer Protocol).

Transport Layer: This layer is responsible for the reliable transmission of data between applications. The commonly used protocol at this layer is TCP (Transmission Control Protocol), which ensures that the data is delivered accurately and in order.

ব্যাখ্যা দেখুন:

Application Layer Protocol :Simple Mail Transfer Protocol(SMTP)

ইমেইল পাঠানোর জন্য Application Layer-এ SMTP ব্যবহৃত হয়। SMTP এর কাজ হলো একটি কম্পিউটার থেকে অন্য কম্পিউটারে ইমেইল মেসেজ পাঠানো। এটি ব্যবহারকারীকে সহজে ইমেইল লিখে পাঠানোর সুযোগ দেয় এবং সার্ভারগুলোর মধ্যে মেসেজ ট্রান্সফার পরিচালনা করে।

Transport Layer Protocol :TCP (Transmission Control Protocol)

Transport Layer-এর মূল কাজ হলো ডেটা নির্ভরযোগ্যভাবে (reliably) গন্তব্যে পৌঁছে দেওয়া।

TCP (Transmission Control Protocol) ব্যবহার করা হয় কারণ:

• এটি ডেটাকে ছোট ছোট অংশে (segments) ভেঙে পাঠায়।
• প্রতিটি অংশ ঠিকভাবে এবং সঠিক ক্রমে (in order) পৌঁছেছে কিনা তা যাচাই করে।
• ডেটা হারিয়ে গেলে পুনরায় পাঠানোর ব্যবস্থা করে।

ইমেইল একটি গুরুত্বপূর্ণ যোগাযোগ মাধ্যম। যদি মেসেজের কোনো অংশ হারিয়ে যায় বা এলোমেলোভাবে পৌঁছে যায়, তাহলে ইমেইলটি অপূর্ণ বা ভুল হয়ে যাবে। এজন্য Application Layer-এ SMTP ইমেইল পাঠানোর নিয়ম ঠিক করে দেয়, আর Transport Layer-এ TCP ডেটা সঠিকভাবে, সম্পূর্ণভাবে এবং নির্ভরযোগ্যভাবে পৌঁছানো নিশ্চিত করে।

(b) Answer:
The diagram illustrates the process of sending an email from the sender to the receiver

ব্যাখ্যা দেখুন:

Sender’s Device → Sender’s Mail Server এর সাথে SMTP protocol ব্যবহার করে যোগাযোগ করে।
Sender’s Mail Server → ইন্টারনেটের মাধ্যমে SMTP ব্যবহার করে ইমেইলটি Receiver’s Mail Server-এ পাঠায়।
Receiver’s Mail Server → ইমেইলটি Receiver’s Device-এ পৌঁছে দেওয়ার জন্য POP3 অথবা IMAP protocol ব্যবহার করে।

Original Schema:

The original schema had attributes like Branch_name, Acc_name, Balance, Branch_city, and Assets.

Initially, everything was in a single table, but it had some issues because Branch_name was part of the key for identifying branch info, while Acc_no was the key for account info.

After Decomposition:

1. Account Table:

• Primary Key: Acc_no (Each account has a unique identifier).
• Foreign Key: Branch_name (This links each account to a branch).
• Non-key attributes (Acc_name, Balance) fully depend on Acc_no.

2. Branch Table:

• Primary Key: Branch_name (Each branch has a unique name).
• Non-key attributes (Branch_city, Assets) fully depend on Branch_name.

Why 2NF?

2NF (Second Normal Form) means:

• There are no partial dependencies (where attributes depend on part of the key).
• In each table, all non-key attributes depend entirely on the full primary key.

So, by breaking up the data into two tables, we've removed partial dependencies and made the schema 2NF.

Explanation:

১. প্রথমে একক টেবিলের স্কিমা:

আমাদের কাছে প্রথমে ছিল একটি টেবিল, এই টেবিলটির মধ্যে অ্যাট্রিবিউটগুলো হলো:

(Branch_name, Acc_name, Balance, Branch_city, Assets)

এই টেবিলটি ছিল একক টেবিল, কিন্তু এতে কিছু সমস্যা ছিল—বিশেষত partial dependency। এর মানে হলো, কিছু অ্যাট্রিবিউট (যেমন Branch_city এবং Assets) Branch_name এর উপর নির্ভরশীল, যেটি এই টেবিলের একটি অংশ। যাতে নরমালাইজেশন ছিলো না।

২. ডিকম্পোজিশন (Decomposition):

এখন, এই সমস্যা সমাধান করতে আমরা টেবিলটিকে দুটি আলাদা টেবিলে ভাগ করি:

Account Table:

(Account_no, Acc_name, Balance, Branch_name)

• Primary Key: Acc_noAcc_no একটি ইউনিক আইডেন্টিফায়ার, যা প্রতিটি অ্যাকাউন্টকে ইউনিক করে।
• Foreign Key: Branch_nameBranch_name একটি ফরেন কী হিসেবে কাজ করে, যা Branch টেবিলের শাখার নামের সাথে সম্পর্কিত।

Branch Table:

• Primary Key: Branch_nameBranch_name শাখার ইউনিক আইডেন্টিফায়ার।
• Foreign Key: এখানে কোনো ফরেন কী নেই।

৩. ২NF (Second Normal Form):

Partial Dependency:

প্রথম স্কিমাতে Branch_name ছিল একটি অংশ, যা Branch_city এবং Assets এর মতো শাখার তথ্য ধারণ করছিল। তবে, অ্যাকাউন্টের জন্য প্রাথমিক কী Acc_no পুরোপুরি অ্যাকাউন্টের তথ্য (Acc_name, Balance) নির্ধারণ করতে ব্যবহৃত হয়।

ডিকম্পোজিশন করার পর, Account টেবিলের সমস্ত অ-প্রাথমিক অ্যাট্রিবিউট Acc_no এর উপর নির্ভরশীল হয়েছে, আর Branch টেবিলের সমস্ত অ-প্রাথমিক অ্যাট্রিবিউট Branch_name এর উপর নির্ভরশীল।

এটি partial dependency দূর করেছে, যেখানে কোনো অ্যাট্রিবিউট প্রাথমিক কীর একটি অংশের উপর নির্ভরশীল ছিল না।

২NF অর্জিত হয়েছে কারণ:

• Account টেবিলের সকল Non-key Attribute Acc_no এর উপর নির্ভরশীল।
• Branch টেবিলের সকল Non-key Attribute Branch_name এর উপর নির্ভরশীল

এই ডিকম্পোজিশনটি নিশ্চিত করেছে যে, আমরা partial dependency দূর করেছি এবং প্রতিটি টেবিলের Non-key Attribute তাদের পুরো primary keyএর উপর নির্ভরশীল। এর ফলে আমরা ২NF (Second Normal Form) অর্জন করেছি।

• Distance between Dhaka and Rangpur = 30 km = 30,000 meters
• Speed of fiber optic link = 2 × 10⁸ m/s
• Link capacity = 1 Gbps = 1 × 10⁹ bps
• Average size of data packets = 15,000 bytes = 120,000 bits (15,000 × 8)
• Delay at each router/switch = 5 ms
• RTT between Dhaka and Rangpur = 50 ms

Propagation Delay

Propagation Delay = Distance / Propagation Speed

= 30,000 meters / (2 × 10⁸ m/s) = 0.00015 seconds = 0.15 ms

Transmission Delay

Transmission Delay = Packet Size (bits) / Link Capacity (bps)

= 120,000 bits / (1 × 10⁹ bps) = 0.00012 seconds = 0.12 ms

Router Delay

There are 1 routers and 1 switch each with 5 ms delay:

Router Delay = 2 × 5 ms = 10 ms

Total One-Way Latency

Total Latency = Propagation Delay + Transmission Delay + Router Delay

= 0.15 ms + 0.12 ms + 10 ms = 10.27 ms (Answer)

Round Trip Time (RTT)

RTT = 2 × One-way latency (since round trip includes going and coming back)

RTT=2×10.27 ms=20.54 ms

The given RTT (50 ms) is higher, which suggests additional delays are present such as queuing delay, processing delay, or other network factors not explicitly included in the simple calculation.

The diagram represents a secure network architecture for Bangladesh Bank, where client-server communication is protected using firewalls:

The diagram illustrates a secure client-server architecture for Bangladesh Bank, where clients communicate with different servers through a firewall to ensure network security.

Clients (Users): Users access Bangladesh Bank's online services through the Internet using web browsers or mobile applications.
Perimeter Firewall: The first firewall acts as a security gateway between the Internet and the bank's servers. It filters incoming and outgoing traffic, allowing only authorized requests while blocking unauthorized access and cyber attacks.
DMZ (Demilitarized Zone): Public-facing servers are placed in the DMZ to minimize the risk of exposing the internal network. These include:
Web Server – Handles HTTP/HTTPS requests from clients.
Mail Server – Provides email services using SMTP/SMTPS protocols.
DNS Server – Resolves domain names to IP addresses for client requests.
Internal Firewall: A second firewall separates the DMZ from the bank's internal network. It allows only necessary communication between the public servers and the internal systems, preventing attackers from directly accessing sensitive resources.
Application Server: This server hosts Bangladesh Bank's core banking applications and business logic. It processes requests received from the Web Server and communicates with the Database Server.
Database Server: Stores confidential banking information such as customer records, transaction data, and account details. It is accessible only by the Application Server and is never exposed directly to the Internet.

Security Features

Filters unauthorized network traffic.
Allows only required ports and services (HTTP/HTTPS, SMTP, DNS).
Protects internal servers from external attacks.
Isolates public-facing servers using a DMZ.
Restricts access to sensitive banking data through an Internal Firewall.
Enhances confidentiality, integrity, and availability of banking services.

Conclusion:
By deploying perimeter and internal firewalls along with a DMZ architecture, Bangladesh Bank ensures that client requests are securely processed while protecting its critical application and database servers from unauthorized access and cyber threats

Initial array as a binary tree:

          56
       /      \
     33        48
    /  \      /  \
  29   99   12  344

          56
       /      \
     33        12
    /  \      /  \
  29   99   48  344

          56
       /      \
     29        12
    /  \      /  \
  33   99   48  344

          12
       /      \
     29        56
    /  \      /  \
  33   99   48  344

          12
       /      \
     29        48
    /  \      /  \
  33   99   56  344

Final Result

The array now satisfies the min heap property: every parent node is smaller than or equal to its children.

          12
       /      \
     29        48
    /  \      /  \
  33   99   56  344

The Need matrix is calculated as: Need = Max - Allocation For each process, we subtract the Allocation from the Max to get the Need Matrix.

Step-by-step checking for our system:

• P0: Needs [0, 0, 0, 0] ≤ Available [1, 5, 2, 0] → yes, so finish P0.
• Update Available by adding P0's allocation: [1, 5, 2, 0] + [0, 0, 1, 2] = [1, 5, 3, 2]
• P1: Needs [0, 7, 5, 0] ≤ Available [1, 5, 3, 2] → no, cannot finish yet.
• P2: Needs [1, 0, 0, 2] ≤ Available [1, 5, 3, 2] → yes, finish P2.
• Update Available : [1, 5, 3, 2] + [1, 3, 5, 4] = [2, 8, 8, 6]
• P3: Needs [0, 0, 2, 0] ≤ Available [2, 8, 8, 6] → yes, finish P3.
• Update Available : [2, 8, 8, 6] + [0, 6, 3, 2] = [2, 14, 11, 8]
• P4: Needs [0, 6, 4, 2] ≤ Available [2, 14, 11, 8] → yes, finish P4.
• Update Available : [2, 14, 11, 8] + [0, 0, 1, 4] = [2, 14, 12, 12]
• P1 (rechecked): Needs [0, 7, 5, 0] ≤ Available [2, 14, 12, 12] → yes, finish P1.
• Update Available : [2, 14, 12, 12] + [1, 0, 0, 0] = [3, 14, 12, 12]

Since all processes can finish in this order, the system is in a safe state.

Safe sequence: <P0, P2, P3, P4, P1>

In direct mapping physical address is divided into three parts i.e., Tag bits, Cache Line Number and Byte offset.

Given:-

Cache size: 16 KB

Block size: 4 words

Word size: 4 bytes (assuming a typical 32-bit architecture where each word is 4 bytes)

Address size: 32 bits

Calculate the Block Size in Bytes:

Since each block contains 4 words and each word is 4 bytes:

Block size = \( 4 \text{ words} \times 4 \text{ bytes/word} = 16 = 2^4 \text{ bytes} \)

Number of offset bits = \( \log_2 2^4 \) = 4 bits

Calculate the Number of Cache Blocks:

Block size = Line size = \( 2^4 \text{ bytes} \)

The total cache size is 16 KB = \( 2^{14} \text{ bytes} \) [ 1 KB = 2¹⁰B]

Number of Lines = \( \frac{\text{Total cache size}}{\text{Line size}} = \frac{2^{14}}{2^4} = 2^{10} \text{ lines} \)

Number of Lines in the cache:

Number of index bits = \( \log_2 \text{(Number of lines)} = \log_2 2^{10} = \) 10 bits

Number of tag bits = Total Address bit − (Index bits + Offset bits) = \( 32 – (10 + 4) = \) 18 bits.

Parity Bit and Error Detection

During data transmission, electrical noise may change the logic level of a signal, causing errors. To detect such errors, a parity bit (an extra bit 0 or 1) is added to the original data.

Even Parity Method: The sender counts the number of 1s in the data. If the count is odd, the parity bit is set to 1 to make the total number of 1s even. If the count is already even, the parity bit is set to 0. The receiver again counts the number of 1s (including the parity bit). If the total is even, the data is assumed correct; otherwise, an error is detected.

Example: Suppose the data 1101 is transmitted with parity bit 1. If due to noise the receiver gets 1111, the total number of 1s becomes odd. Hence, the receiver detects an error and may request retransmission.

ASCII Code for “Delta”

The complete binary bit stream for “Delta” is:
01000100 01100101 01101100 01110100 01100001

Solution: Here, The source uses 480 x 500 pixels/picture And, 30 pictures are sent per second.

So, we can find the source rate in pixels/s as: \[ (30 \, \text{pictures/s}) \times (480 \times 500 \, \text{pixels/picture})\] \[= 7.2 \times 10^6 \, \text{pixels/s} \]

Now, each pixel can take on one of 32 intensity values and these 32 intensity values can be represented by: \[ \log_2 32 = \log_2 2^5 = 5 \, \text{bits} \] We can find the source rate in bits/s (bps) as:

R = \( 7.2 \times 10^6 \, \text{pixels/s} \times 5 \, \text{bits/pixel} \) \[ = 36 \times 10^6 \, \text{bps} = 36 \, \text{Mbps} \]

Regions of Operation of a Transistor

A transistor operates in three main regions based on the biasing of its junctions: Cut-off region, Active region, and Saturation region. These regions are explained below with reference to the load line diagram.

(i) Cut-off Region

The cut-off region is the point where the load line intersects the curve for I_B = 0. In this region, the base current is zero, and only a very small collector leakage current (I_CEO) flows.

• Base-emitter junction is not forward biased.
• Collector-base junction is reverse biased.
• Transistor is in OFF state.
• Collector-emitter voltage is maximum: V_CE ≈ V_CC.

(ii) Saturation Region

The saturation region occurs where the load line intersects the curve for I_B = I_B(sat). In this region, both the base current and collector current are maximum.

• Base-emitter junction is forward biased.
• Collector-base junction is no longer reverse biased.
• Transistor is fully ON.
• Collector-emitter voltage is minimum: V_CE(sat) ≈ 0.

(iii) Active Region

The active region lies between cut-off and saturation. In this region, the transistor operates normally and is used for amplification.

• Base-emitter junction is forward biased.
• Collector-base junction is reverse biased.
• Collector current is proportional to base current.
• Transistor works as an amplifier.

Working Principle of an N-Channel JFET

An N-channel Junction Field Effect Transistor (JFET) is a voltage-controlled semiconductor device where the current flows through an n-type channel between the Source and Drain. The current is controlled by the voltage applied between the Gate and Source (V_GS).

Case 1: V_GS = 0 and Small V_DS

When no gate voltage is applied (V_GS = 0) and a small drain-source voltage (V_DS) is applied, electrons flow freely from source to drain. The channel is wide, and the drain current (I_D) increases linearly with V_DS. This region is called the ohmic or linear region.

Case 2: V_GS = 0 and Increasing V_DS

As V_DS increases, the depletion region near the drain widens. At a particular V_DS, the channel becomes constricted at the drain end. This condition is called pinch-off. Beyond this point, the drain current becomes almost constant. This is the saturation region.

Case 3: Negative V_GS and Constant V_DS

When a negative voltage is applied to the gate (V_GS < 0), the depletion regions expand further, narrowing the channel. As a result, the drain current decreases. More negative V_GS reduces I_D further.

Case 4: V_GS = V_GS(off)

When V_GS reaches a sufficiently negative value known as cut-off voltage (V_GS(off)), the channel is completely closed. The drain current becomes zero, and the JFET is in the cut-off region.

Determine the Payload Size

The payload size is the part of a packet that excludes the header.

Payload Size = Total Packet Size − Header Size

Given:
Total Packet Size = 1500 bytes
Header Size = 5 bytes

Payload Size = 1500 − 5 = 1495 bytes

Convert Payload Size to Bits

Since data rate is given in bits per second, payload size must be converted to bits.

Payload Size (bits) = 1495 × 8 = 11,960 bits

Calculate Packetization Delay

Packetization delay is the time needed to fill a packet with data.

Packetization Delay = Packet Length (bits) / Source Data Rate

Packet Length = 12,000 bits
Source Data Rate = 128,000 bps

Packetization Delay = 12,000 / 128,000 = 0.09375 s = 93.75 ms

Calculate Transmission Time

Transmission time is the time required to send the payload over the network.

Transmission Time = Payload Size (bits) / Data Rate

Transmission Time = 11,960 / 128,000 = 0.0934375 s = 93.4375 ms

• Payload Size: 11,960 bits
• Packetization Delay: 93.75 milliseconds
• Transmission Time: 93.4375 milliseconds

Infrastructure as a Service (IaaS)

IaaS provides the most basic level of cloud services by offering virtualized computing resources over the internet. Organizations can rent servers, storage, and networking resources on a pay-as-you-go basis, reducing the need for physical hardware.

Examples: Amazon Web Services (AWS EC2), Microsoft Azure Virtual Machines, Google Compute Engine (GCE)

Platform as a Service (PaaS)

PaaS provides a complete development platform that allows developers to build, deploy, and manage applications without managing the underlying infrastructure. It includes operating systems, databases, and development tools.

Examples: Google App Engine, Microsoft Azure App Service, Heroku

Software as a Service (SaaS)

SaaS delivers software applications over the internet. Users can access these applications through a web browser without installing or maintaining software locally.

Examples: Google Workspace, Microsoft 365, Salesforce

Challenges in Optimizing Energy Efficiency of Data Centers

Optimizing energy efficiency in data centers is critical but challenging due to several technical and operational factors.

• High Cooling Requirements: Servers generate a large amount of heat, requiring continuous cooling systems that consume significant energy.
• Underutilized Servers: Many servers run at low utilization but still consume near-maximum power.
• Growing Data Demand: Increasing data processing, cloud services, and AI workloads raise overall energy consumption.
• Power Distribution Loss: Energy losses occur during power conversion and distribution within the data center.
• Legacy Infrastructure: Older hardware and cooling systems are less energy-efficient.
• Complex Monitoring: Tracking and optimizing energy usage across thousands of components is difficult.
• Balancing Performance and Efficiency: Reducing energy use without affecting performance and availability is challenging.

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

Virtual Machine:

A virtual machine (VM) is a software-based simulation of a physical computer. It runs an operating system and applications just like a physical computer.

Virtual Machine Operation:

=>VMs run on a physical host computer using a hypervisor (e.g., VMware, Hyper-V, VirtualBox)
=>A hypervisor, also known as a virtual machine monitor (VMM) or virtualizer, is a type of computer software, firmware or hardware that creates and runs virtual machines
=>The hypervisor allows multiple VMs to share the resources of a single physical host.

Benefits of Virtual Machines
Cost Efficiency: Reduced need for physical hardware.
Flexibility: Easy to test and deploy different operating systems and applications.
Resource Optimization: Better utilization of physical resources.
Disaster Recovery: Easier backup and restoration of VMs.

Possible Risk and Threat Scenarios Faced by Mr. X While Auditing Payment Gateways

While auditing two different payment gateway service providers for a bank, Mr. X may encounter the following risk and threat scenarios:

• Data Breach Risk: Sensitive customer data such as card numbers, CVV, or PINs may be exposed due to weak encryption or poor security controls.
• Man-in-the-Middle (MITM) Attacks: Attackers may intercept communication between the bank and the payment gateway if secure protocols (TLS/HTTPS) are misconfigured.
• Unauthorized Access: Weak authentication or improper access control may allow attackers or insiders to access payment systems.
• Malware and Trojan Attacks: Payment gateway servers may be infected with malware that captures transaction data.
• Fraudulent Transactions: Lack of proper monitoring and anomaly detection can lead to fake or unauthorized transactions.
• Compliance Risk: One or both gateways may not comply with standards such as PCI-DSS, increasing legal and financial risk.
• Availability Threats: Denial of Service (DoS/DDoS) attacks may disrupt payment services, affecting banking operations.
• Third-Party Dependency Risk: Security weakness in one service provider can impact the bank even if the bank’s internal systems are secure.

Conclusion: Mr. X must evaluate both technical and operational risks, compare security maturity levels of the two providers, and recommend mitigation strategies.

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)

(a) Definition

Verification: Verification is the process of evaluating work products such as requirements, design, and code against predefined standards and specifications. It answers the question: “Are we building the product correctly?”

Validation: Validation focuses on evaluating the final product to ensure it meets user needs and expectations. It answers the question: “Are we building the right product?”

(b) Implementation of Verification and Validation in Software Testing

Verification Activities

Requirement Analysis: Functional and non-functional requirements are reviewed to identify testable requirements. A Requirement Traceability Matrix (RTM) is created to ensure each requirement is covered by test cases.

Test Planning and Documentation: A test plan is prepared defining scope, objectives, tools, and schedules to verify alignment with requirements.

Test Case Design and Development: Test cases are designed to verify individual components, including unit testing of modules.

Test Environment Setup: The test environment is configured to simulate real conditions, and smoke testing is performed.

Validation Activities

System Testing: The complete system is tested to validate overall functionality.

User Acceptance Testing (UAT): End users test the system to ensure it meets real-world requirements.

Performance and Usability Testing: Confirms system performance and user experience.

Test Execution and Bug Reporting: Test cases are executed, defects are logged, and fixes are retested.

Test Closure and Reporting: Test results are analyzed and documented, and lessons learned are discussed.

Solution: Here, The source uses 480 x 500 pixels/picture And, 30 pictures are sent per second.

So, we can find the source rate in pixels/s as: \[ (30 \, \text{pictures/s}) \times (480 \times 500 \, \text{pixels/picture})\] \[= 7.2 \times 10^6 \, \text{pixels/s} \]

Now, each pixel can take on one of 32 intensity values and these 32 intensity values can be represented by: \[ \log_2 32 = \log_2 2^5 = 5 \, \text{bits} \] We can find the source rate in bits/s (bps) as:

R = \( 7.2 \times 10^6 \, \text{pixels/s} \times 5 \, \text{bits/pixel} \) \[ = 36 \times 10^6 \, \text{bps} = 36 \, \text{Mbps} \]

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 , - , - ]

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.

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.