OM SAKTHI

ADHIPARASAKTHI COLLEGE OF ENGINEERING

G.B.Nagar, Kalavai-632506, Ranipet District.

DEPARTMENT OF INFORMATION TECHNOLOGY

CCS354-NETWORK SECURITY LABORATORY

 Om Sakthi

ADHIPARASAKTHI COLLEGE OF ENGINEERING

G.B. Nagar, Kalavai – 632 506, Ranipet District, Tamil Nadu.

DEPARTMENT OF INFORMATION TECHNOLOGY

CERTIFICATE

Certified that is the bonafide record of work done by Mr/Ms

With Enrollment Number ______________Third year/ VIth Semester

B.TECH-INFORMATION TECHNOLOGY in Anna University during the year 2024 in respect

of practical CCS354-NETWORK SECURITY LABORATORY Submitted for the Practical

Examination held on .

SIGNATURE OF FACULTY-IN-CHARGE SIGNATURE OF HEAD OF THE DEPARTMENT

Internal Examiner External Examiner

 CONTENTS

EX.NO DATE TITLE PAGENO MARKS SIGNATURE

Implementing symmetric key

1. 5.2.24 algorithms 01
Implementing asymmetric key
2(a) 21.2.24 algorithms 05

2(b) 21.2.24 Implementing Key exchange algorithms 12

Implement the Digital Signature Schemes.

3. 11.3.24 15

Installation of Wire shark, tcp dump and

4. 18.3.24
observe data transferred in client-server
18
communication using UDP/TCP and
identify the UDP/TCP datagram.

5. 25.3.24 Check message integrity and 31

confidentiality using SSL
Experiment with Sniff Traffic using ARP
6. 1.4.24 Poisoning 37
Demonstrate intrusion detection system
7. 1.4.24 using any tool. 40

Explore network monitoring tools

8. 8.4.24 53

Study to configure Firewall, VPN

9. 8.4.24 56

Experiment Eavesdropping, Dictionary

10. 15.4.24 attacks, MITM attacks 58
EX.NO:01 IMPLEMENT SYMMETRIC KEY ALGORITHM
DATE: 5.2.24

AIM:
To write a java program to implement the symmetric key Algorithm.

ALGORITHM:
1. Start the program

2. we first generate a secret key for AES encryption using the KeyGenerator class.

3. We then create an instance of the Cipher class for AES and initialize it to
ENCRYPT_MODE with the secret key

4. Next, we define an original message, "Department of IT", and encrypt it using the Cipher's
do Final method. We also convert the encrypted message bytes to a Base64 encoded string
to make it easier to handle.

5. We then print the original and encrypted messages to the console.

6. To demonstrate decryption, we reinitialize the Cipher to DECRYPT_MODE with the same

secret key and decrypt the encrypted message. Finally, we print the decrypted message to
the console.

7. The encrypted message will vary each time you run the program, due to the unique secret
key generated each time.

8. Stop the program .

PROGRAM:

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import java.nio.charset.StandardCharsets;
import java.util.Base64;

public class Main1 {

public static void main(String[] args) throws Exception {

// Generate key
SecretKey secretKey = KeyGenerator.getInstance("AES").generateKey();

// Original message
String originalMessage = "Department Of IT";

// Create Cipher instance and initialize it to ENCRYPT_MODE

Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.ENCRYPT_MODE, secretKey);

// Encrypt the message

byte[] encryptedMessage =
cipher.doFinal(originalMessage.getBytes(StandardCharsets.UTF_8));

// Convert the encrypted message to Base64 encoded string

String encodedMessage =
Base64.getEncoder().encodeToString(encryptedMessage);

System.out.println("Original Message: " + originalMessage);

System.out.println("Encrypted Message: " + encodedMessage);
 // Reinitialize the cipher to DECRYPT_MODE

cipher.init(Cipher.DECRYPT_MODE, secretKey);

// Decrypt the message

byte[] decryptedMessage =
cipher.doFinal(Base64.getDecoder().decode(encodedMessage));

System.out.println("Decrypted Message: " + new String(decryptedMessage,

StandardCharsets.UTF_8));
}
}
OUTPUT:

RESULT:
Thus, the above program is executed successfully and output is verified.
EX.NO:02 a) IMPLEMENT ASYMMETRIC KEY ALGORITHM
DATE:21.2.24

AIM:
To write a java program to implement the Asymmetric key Algorithm

PROCEDURE:

1. Start the program.

2. Enter the message you want to encrypt (or uncomment the code for manual input).

3. The program initializes by filling a HashSet with prime numbers and setting up the
encryption and decryption keys.

4. It then takes a message as input, encrypts it using the public key, and prints the
encrypted message.

5. Finally, it decrypts the encrypted message using the private key and prints the
decrypted message.

6. Stop the program

PROGRAM:
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
public class GFG {
private static HashSet<Integer> prime = new HashSet<>();
private static Integer public_key = null;
private static Integer private_key = null;
private static Integer n = null;
private static Random random = new Random();
public static void main(String[] args)
{
primeFiller();
setKeys();
String message = "Test Message";
// Uncomment below for manual input
// System.out.println("Enter the message:");
// message = new Scanner(System.in).nextLine();
List<Integer> coded = encoder(message);
System.out.println("Initial message:");
System.out.println(message);
System.out.println("\n\nThe encoded message (encrypted by public key)\n");
System.out.println(
String.join("", coded.stream()map(Object::toString)toArray(String[]::new)));
System.out.println("\n\nThe decoded message (decrypted by public key)\n");
System.out.println(decoder(coded));
}
public static void primeFiller()
{
boolean[] sieve = new boolean[250];

for (int i = 0; i < 250; i++) {

sieve[i] = true;
}
sieve[0] = false;
sieve[1] = false;
for (int i = 2; i < 250; i++) {
for (int j = i * 2; j < 250; j += i) {
sieve[j] = false;
}
}
for (int i = 0; i < sieve.length; i++) {
if (sieve[i]) {
prime.add(i);
}
}
}
public static int pickRandomPrime()
{
int k = random.nextInt(prime.size());
List<Integer> primeList = new ArrayList<>(prime);
int ret = primeList.get(k);
prime.remove(ret);
return ret;
}

public static void setKeys()

{
 int prime1 = pickRandomPrime();
int prime2 = pickRandomPrime();

n = prime1 * prime2;

int fi = (prime1 - 1) * (prime2 - 1);

int e = 2;
while (true) {
if (gcd(e, fi) == 1) {
break;
}
e += 1;
}
public_key = e;

int d = 2;
while (true) {
if ((d * e) % fi == 1) {
break;
}
d += 1;
}
private_key = d;
}
public static int encrypt(int message)
{
int e = public_key;
int encrypted_text = 1;
while (e > 0) {
encrypted_text *= message;
 encrypted_text %= n;
e -= 1;
}

return encrypted_text;
}
public static int decrypt(int encrypted_text)
{

int d = private_key;
int decrypted = 1;
while (d > 0) {
decrypted *= encrypted_text;
decrypted %= n;
d -= 1;
}
return decrypted;
}
public static int gcd(int a, int b)
{
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
public static List<Integer> encoder(String message)
{
List<Integer> encoded = new ArrayList<>();
for (char letter : message.toCharArray()) {
encoded.add(encrypt((int)letter));
}
 return encoded;
}

public static String decoder(List<Integer> encoded)

{

StringBuilder s = new StringBuilder();

for (int num : encoded) {
s.append((char)decrypt(num));
}

return s.toString();
}
}
OUTPUT:
Initial message:
Hii
The encoded message (encrypted by public key)
2422828
The decoded message (decrypted by public key)
Hii

RESULT:
The above program is executed successfully and output is verified.
EX.NO:02 b) IMPLEMENT KEY EXCHANGE ALGORITHM
DATE:21.2.24

AIM:
To implement the Diffie-Hellman Key Exchange algorithm for a given problem .

PROCEDURE:
1. Alice and Bob publicly agree to use a modulus p = 23 and base g = 5(which is a primitive

root modulo 23).

2. Alice chooses a secret integer a = 4, then sends Bob A = ga mod p

 A = 54 mod 23 = 4

3. Bob chooses a secret integer b = 3, then sends Alice B = gb mod p

 B = 53 mod 23 = 10

4. Alice computes s = Ba mod p

 s = 104 mod 23 = 18

5. Bob computes s = Ab mod p

 s = 43 mod 23 = 18

6. Alice and Bob now share a secret (the number 18).

PROGRAM:

class DiffieHellman
{
public static void main(String args[])
{
int p = 23; /* publicly known (prime number) */
int g = 5; /* publicly known (primitive root) */
int x = 4; /* only Alice knows this secret */
int y = 3; /* only Bob knows this secret */
double aliceSends = (Math.pow(g, x)) % p;
double bobComputes = (Math.pow(aliceSends, y)) % p;
double bobSends = (Math.pow(g, y)) % p;
double aliceComputes = (Math.pow(bobSends, x)) % p;
double sharedSecret = (Math.pow(g, (x * y))) % p;
System.out.println("simulation of Diffie-Hellman key exchange algorithm\n---------------
----------");
System.out.println("Alice Sends : " + aliceSends);
System.out.println("Bob Computes : " + bobComputes);
System.out.println("Bob Sends : " + bobSends);
System.out.println("Alice Computes : " + aliceComputes);
System.out.println("Shared Secret : " + sharedSecret);
/* shared secrets should match and equality is transitive */
if ((aliceComputes == sharedSecret) && (aliceComputes == bobComputes))
System.out.println("Success: Shared Secrets Matches! " + sharedSecret);
else
System.out.println("Error: Shared Secrets does not Match");
}
}
OUTPUT:

simulation of Diffie-Hellman key exchange algorithm

Alice Sends : 4.0 Bob Computes : 18.0 Bob Sends : 10.0

Alice Computes : 18.0 Shared Secret : 18.0
Success: Shared Secrets Matches! 18.0

RESULT:
Thus, the above program is executed successfully and output is verified.
EX.NO:03 IMPLEMENT DIGITAL SIGNATURE SCHEMES
DATE:11.3.24

AIM:
To implement the SIGNATURE SCHEME - Digital Signature Standard.

PROCEDURE:

1. Create a KeyPairGenerator object.

2. Initialize the KeyPairGenerator object.

3. Generate the KeyPairGenerator. ...

4. Get the private key from the pair.

5. Create a signature object.

6. Initialize the Signature object.

7. Add data to the Signature object

8. Calculate the Signature

PROGRAM:
import java.security.KeyPair;
import java.security.KeyPairGenerator; import java.security.PrivateKey;
import java.security.Signature;
import java.util.Scanner;
public class CreatingDigitalSignature {
public static void main(String args[]) throws Exception {
Scanner sc = new Scanner(System.in); System.out.println("Enter some text");
String msg = sc.nextLine();
KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("DSA");
keyPairGen.initialize(2048);
KeyPair pair = keyPairGen.generateKeyPair();
PrivateKey privKey = pair.getPrivate();
Signature sign = Signature.getInstance("SHA256withDSA");
sign.initSign(privKey);
byte[] bytes = "msg".getBytes();
sign.update(bytes);
byte[] signature = sign.sign();
System.out.println("Digital signature for given text: "+new String(signature, "UTF8"));
}
}
OUTPUT:

Enter some text

Hi how are you
Digital signature for given text: 0=@gRD???-?.???? /yGL?i??a!?

RESULT:
Thus, the above program is executed and output is verified.
EX.NO:04 INSTALLATION OF WIRE SHARK, TCPDUMP AND OBSERVE
DATE:18.3.24 DATA TRANSFERRED IN CLIENT-SERVE COMMUNICATING
USING UDP/TCP AND IDENTIFY THE UDP/TCP DIAGRAM

AIM:
To installation of Wire shark, tcpdump and observe data transferred in client-server
communication using UDP/TCP and identify the UDP/TCP datagram.
Introduction:
The first part of the lab introduces packet sniffer, Wireshark. Wireshark is a free
open- source network protocol analyzer. It is used for network troubleshooting and
communication protocol analysis. Wireshark captures network packets in real time and
display them in human-readable format. It provides many advanced features including live
capture and offline analysis, three-pane packet browser, coloring rules for analysis. This
document uses Wireshark for the experiments, and it covers Wireshark installation, packet
capturing, and protocol analysis.

Figure 1: Wireshark in Kali Linux

Background
TCP/IP Network Stack

Figure 2: Encapsulation of Data in the TCP/IP Network Stack

In the CSC 4190 Introduction to Computer Networking (one of the perquisite courses),
TCP/IP network stack is introduced and studied. This background section briefly explains
the concept of TCP/IP network stack to help you better understand the experiments.
TCP/IP is the most commonly used network model for Internet services. Because its most
important protocols, the Transmission Control Protocol (TCP) and the Internet Protocol
(IP) were the first networking protocols defined in this standard, it is named as TCP/IP.
However, it contains multiple layers including application layer, transport layer, network
layer, and data link layer.
- Application Layer: The application layer includes the protocols used by most applications
for providing user services. Examples of application layer protocols are Hypertext
Transfer Protocol (HTTP), Secure Shell (SSH), File Transfer Protocol (FTP), and Simple
Mail Transfer Protocol (SMTP).
- Transport Layer: The transport layer establishes process-to-process connectivity, and it
provides end-to-end services that are independent of underlying user data. To implement
the process-to-process communication, the protocol introduces a concept of port. The
examples of transport layer protocols are Transport Control Protocol (TCP) and User
Datagram Protocol (UDP).
The TCP provides flow- control, connection establishment, and reliable transmission of data,
while the UDP is a connectionless transmission model.
- Internet Layer: The Internet layer is responsible for sending packets to across networks. It
has two functions: 1) Host identification by using IP addressing system (IPv4 and IPv6);
 and 2) packets routing from source to destination. The examples of Internet layer protocols
are Internet Protocol (IP), Internet Control Message Protocol (ICMP), and Address
Resolution Protocol (ARP).
- Link Layer: The link layer defines the networking methods within the scope of the local
network link. It is used to move the packets between two hosts on the same link. An
common example of link layer protocols is Ethernet.
Packet Sniffer

Packet sniffer is a basic tool for observing network packet exchanges in a computer. As the
name suggests, a packet sniffer captures (“sniffs”) packets being sent/received from/by
your computer; it will also typically store and/or display the contents of the various
protocol fields in these captured packets. A packet sniffer itself is passive. It observes
messages being sent and received by applications and protocols running on your computer,
but never sends packets itself.
Figure 3 shows the structure of a packet sniffer. At the right of Figure 3 are the protocols (in
this case, Internet protocols) and applications (such as a web browser or ftp client) that
normally run on your computer. The packet sniffer, shown within the dashed rectangle in
Figure 3 is an addition to the usual software in your computer, and consists of two parts.
The packet capture library receives a copy of every link-layer frame that is sent from or
received by your computer. Messages exchanged by higher layer protocols such as HTTP,
FTP, TCP, UDP, DNS, or IP all are eventually encapsulated in link-layer framesthat are
transmitted over physical media such as an Ethernet cable. In Figure 1, the assumed
physical media is an Ethernet, and so all upper-layer protocols are eventually encapsulated
within an Ethernet frame. Capturing all link-layer frames thus gives you access to all
messages sent/received from/by all protocols and applications ecuting in your computer.

The second component of a packet sniffer is the packet analyzer, which displays the contents
of all fields within a protocol message. In order to do so, the packet analyzer

Packet Sniffer Structure

must “understand” the structure of all messages exchanged by protocols. For example,
suppose we are interested in displaying the various fields in messages exchanged by the
HTTP protocol in Figure 3. The packet analyzer understands the format of Ethernet
frames, and so can identify the IP datagram within an Ethernet frame. It also understands
the IP datagram format, so that it can extract the TCP segment within the IP
 datagram. Finally, it understands the TCP segment structure, so it can extract the HTTP
message contained in the TCP segment. Finally, it understands the HTTP protocol and so,
for example, knows that the first bytes of an HTTP message will contain the string “GET,”
“POST,” or “HEAD”.
We will be using the Wireshark packet sniffer [http://www.wireshark.org/] for these labs,
allowing us to display the contents of messages being sent/received from/by protocols at
different levels of the protocol stack. (Technically speaking, Wireshark is a packet
analyzer that uses a packet capture library in your computer). Wireshark is a free network
protocol analyzer that runs on Windows, Linux/Unix, and Mac computers.
Getting Wireshark
The Kai Linux has Wireshark installed. You can just launch the Kali Linux VM and open
Wireshark there.Wireshark can also be downloaded from here:

https://www.wireshark.org/download.html

(Download Page of Wireshark)

Starting Wireshark:
When you run the Wireshark program, the Wireshark graphic user interface will be shown
as
Figure 5.Currently, the program is not capturing the packets.

Initial Graphic User Interface of Wireshark

Then, you need to choose an interface. If you are running the Wireshark on your laptop, you
need to select WiFi interface. If you are at a desktop, you need to select the Ethernet
interface being used. Note that there could be multiple interfaces. In general, you can
select any interface but that does not mean that traffic will flow through that interface.
The network interfaces (i.e., the physical connections) that your computer has to the
network are shown. The attached Figure 6 was taken from my computer.
After you select the interface, you can click start to capture the packets as shown in Figure 7.
Capture Interfaces in Wireshark

Capturing Packets in Wireshark

(Wireshark Graphical User Interface on Microsoft Windows)

The Wireshark interface has five major components:
The command menus are standard pulldown menus located at the top of the window. Of
interest to us now is the File and Capture menus. The File menu allows you to save
captured packet data or open a file containing previously captured packet data, and exit
the Wireshark application. The Capture menu allows youto begin packet capture.
The packet-listing window displays a one-line summary for each packet captured, including
the packet number (assigned by Wireshark; this is not a packet number contained in any
protocol’s header), the time at which the packet was captured, the packet’s source and
destination addresses, the protocol type, and protocol-specific information contained in
the packet. The packet listing can be sorted according to any of these categories by clicking
on a column name. The protocol type field lists the highest- level protocol that sent or
received this packet, i.e., the protocol that is the source or ultimate sink for this packet.
The packet-header details window provides details about the packet selected (highlighted) in
the packet-listing window. (To select a packet in the packet-listing window, place the
cursor over the packet’s one- line summary in the packet-listing window and click with
the left mouse button.). These details include information about the Ethernet frame and IP
datagram that contains this packet. The amount of Ethernet and IP-layer detail displayed
can be expanded or minimized by clicking on the right- pointing or down- pointing
arrowhead to the left of the Ethernet frame or IP datagram line in the packet details
window. If the packet has been carried over TCP or UDP, TCP or UDP details will also be
displayed, which can similarly be expanded or minimized. Finally, details about the
highest-level protocol that sent or received this packet are also provided.
The packet-contents window displays the entire contents of the captured frame, in both ASCII
and hexadecimal format.
Towards the top of the Wireshark graphical user interface, is the packet display filter field,
into which a protocol name or other information can be entered in order to filter the
information displayed in the packet-listing window (and hence the packet-header and
packet-contents windows). In the examplebelow, we’ll use the packet-display filter field
to have Wireshark hide (not display) packets except those that correspond to HTTP
messages.
Capturing Packets
After downloading and installing Wireshark, you can launch it and click the name of an
interface under Interface List to start capturing packets on that interface. For example, if
you want to capture traffic on the wireless network, click your wireless interface.
Test Run
Do the following steps:
1. Start up the Wireshark program (select an interface and press start to capture packets).
2. Start up your favorite browser (ceweasel in Kali Linux).
3. In your browser, go to Wayne State homepage by typing www.wayne.edu.
4. After your browser has displayed the http://www.wayne.edu page, stop Wireshark packet
capture by selecting stop in the Wireshark capture window. This will cause the Wireshark
capture window to disappear and the main Wireshark window to display all
packets captured since you began packet capture see image below:
5. Color Coding: You’ll probably see packets highlighted in green, blue, and black.
Wireshark uses colors to help you identify the types of traffic at a glance. By default, green
is TCP traffic, dark blue is DNS traffic, light blue is UDP traffic, and black identifies TCP
packets with problems — for example, they could have been delivered out-of-order.
6. You now have live packet data that contains all protocol messages exchanged between
your computer and other network entities! However, as you will notice the HTTP
messages are not clearly shown because there are many other packets included in the
packet capture. Even though the only action you took was to open your browser, there are
many other programs in your computer that communicate via the network in the
background. To filter the connections to the ones we want to focus on, we have to use the
filtering functionality of Wireshark by typing “http” in the filtering field as shown below:
Notice that we now view only the packets that are of protocol HTTP. However, we also still
do not have the exact communication we want to focus on because using HTTP as a filter
 is not descriptive enough to allow us to find our connection to http://www.wayne.edu. We
need to be more precise if we want to capture the correct set of packets.
7. To further filter packets in Wireshark, we need to use a more precise filter. By setting the
http.host www.wayne.edu, we are restricting the view to packets that have as an http host the
www.wayne.edu website. Notice that we need two equal signs to perform the match not
just one. See the screenshot below:

8. Now, we can try another protocol. Let’s use Domain Name System (DNS) protocol as an
example here.

9.conversations (also called network flows), select one of the packets and press the right
mouse button (if you are on a Mac use the command button and click), you should see
something similar to the screen below:
Click on Follow UDP Stream, and then you will see following screen.
10. If we close this window and change the filter back to “http.hos ww.wayne.edu” and then
follow a packetfrom the list of packets that match that filter, we should get the something
similar to the following screens. Note that we click on Follow TCP Stream this time.

RESULT:
Installation of Wire shark, tcpdump and observe data transferred in client-server
communication using UDP/TCP and identify the UDP/TCP datagram.
EX.NO:05 CHECK MESSAGE INTEGRITY AND CONFIDENTIALITY USING
DATE:25.3.24 SSL (Secure Socket Layer).

AIM:

To check message integrity and confidentiallity using SSL(Secure Socket Layer)

ALGORITHM:

1. Import Necessary Libraries:

Import required libraries for handling input/output operations (java.io.*),

networking(java.net.*), and SSL connections (javax.net.ssl.*).

2. Define the Main Class:

Define the main class SimpleHTTPSClient.

3. Main Method:
Define the main method as the entry point of the program.
Catch any exceptions that may occur during execution and print their stack trace.

4. SSL Context Creation:

Create an SSL context using the SSLContext.getInstance("TLS") method.

5. TrustManager Configuration:
Initialize a TrustManagerFactory with the default algorithm.
Initialize the trust manager factory with null to use the default trust store.
Retrieve an array of trust managers.
6. SSL Context Initialization:
Initialize the SSL context with the obtained trust managers and a secure random number
generator.

7. HTTPS Connection Setup:

Create a URL object representing the HTTPS URL to connect to (in this case,
"https://www.google.com").
8. Open an HttpsURLConnection to the specified URL.

9. Set SSL Context for Connection:

Set the SSL socket factory for the HTTPS connection using the setSSLSocketFactory()
method, passing the SSL context's socket factory.

10. Connect to the Server:

Connect to the server using the connect() method of the HttpsURLConnection object.
11. Server Certificate Validation:
Retrieve the server certificates from the connection.
Optional: Perform additional validation on the server certificates if needed.
12. Print Connection Success Message:
Print a message indicating a successful connection to the server.

13. Read and Print Response:

Create a BufferedReader to read the response from the server's input
stream. Read each line of the response and print it to the console.
Close the input stream once all data has been read.

14. Disconnect from Server:

Disconnect the HTTPS connection using the disconnect() method.
 PROGRAM:

import java.io.*;
import java.net.*;
import
javax.net.ssl.*;
import java.security.KeyStore;
import
java.security.cert.Certificate;
public class SimpleHTTPSClient
{
public static void main(String[] args)
{
try
{

// Create an SSL context

SSLContext sslContext = SSLContext.getInstance("TLS");

// Create a TrustManager that trusts only certificates signed by trusted CAs
TrustManagerFactory trustManagerFactory =
TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());

trustManagerFactory.init((KeyStore) null);
// Use the default trust store

TrustManager[] trustManagers = trustManagerFactory.getTrustManagers();

// Initialize the SSL context with the TrustManager

sslContext.init(null, trustManagers, new java.security.SecureRandom());

// Create an HTTPS URL connection to Google

URL url = new

URL("https://www.google.com");

HttpsURLConnection conn = (HttpsURLConnection)url.openConnection();

// Set the SSL context for the connection

conn.setSSLSocketFactory(sslContext.getSocketFactory());

// Connect to

Google

conn.connect();

// Check if the server certificate is valid

Certificate[] serverCertificates = conn.getServerCertificates();

// You can inspect the serverCertificates array for additional validation

// Print a message to indicate successful connection

System.out.println("Connected to https://www.google.com

successfully.");

// Read the response from Google and print it out

BufferedReader in = new BufferedReader(new

InputStreamReader(conn.getInputStream())); String inputLine;

while ((inputLine = in.readLine()) !=

null) {System.out.println(inputLine);

}
in.close();

// Disconnect

conn.disconnect();

}
catch (Exception e)
{

e.printStackTrace();

}
OUTPUT:

RESULT:
Thus the message integrity and confidentiallity using ssl(Secure Socket layer)
has beenexecuted successfully.
EX.NO:6 EXPERIMENT WITH SNIFF TRAFFIC USING ARP POISIONING
DATE:1.4.24

AIM:
To perform the experiment with sniff traffic using ARP Poisoning.

PROCEDURE:
Packet Sniffing in Wireshark
Step 1: Open Wireshark Window
Open your Wireshark tool in a new window or a Linux virtual machine. and begin
network capture. Assume we are capturing wireless fidelity (Wi-Fi Traffic).
SNIFF TRAFFIC USING ARP POISONING
Step 2: Start the Wireless Fidelity
Open Wireshark, select your Wi-Fi interface and start capturing packets. Engage in
network activities, stop the capture, and analyze the captured packets for network
insights.

Starting Wireless Fidelity

ARP Spoofing in WireShark
Step 1: Capture ARP Traffic
Open Wireshark, and choose the network interface. Start capturing by clicking theinterface
and selecting “Start.”
 Capturing Wireless Fidelity
Step 2: Filter for ARP Traffic
Apply the ARP filter in the display filter bar to focus on ARP packets.Filtering ARP
Packets

Step 3: Analyze ARP Requests and Replies:

Observe normal ARP traffic—devices asking for and receiving MAC addresses.
Analyze ARP Packet requests
 1. Identify Inconsistencies: Look for anomalies like multiple devices responding to
one ARP request or multiple MACs for one IP.
2. Check Gratuitous ARP: Detect gratuitous ARP packets—devices announcing
MAC for an IP without prompting.
3. Compare with Network Topology: Understand legitimate devices and MAC
addresses; compare with observed ARP responses.

RESULT:
Thus the experiment with sniff traffic using ARP poisoning has been executed
successfully.
EX.NO:7 DEMONSTRATE INTRUSION DETECTION SYSTEM USING ANY TOOL
DATE:1.4.24

AIM:
To demonstrate Intrusion Detection System (IDS) using Snort software tool.

PROCEDURE:

STEPS ON CONFIGURING AND INTRUSION DETECTION:

1. For Windows 10 64 bit supported SNORT’s executable file can be

downloaded from here.

2. Open the downloaded snort executable file.

3. Click On ‘I Agree’ on the license agreement.

Figure 01: License agreement for Snort 2.9.17

4. Choose components of Snort to be installed.

 Figure 02: Choosing Components for Snort 2.9.17

5. Click “Next” and then choose install location for snort preferably a separate

folderin Windows C Drive.

Figure 03: Choose Install location for Snort 2.9.17

6. Click “Next” Installation process starts and then it completes as shown in figure 04:

Figure 04: Setup Complete for Snort 2.9.17

When you click “ Close” you are prompted with this dialogue box:

Figure 05: Window showing details of software needed to run Snort successfully

1. Installing Npcap is required by snort for proper functioning.

2. Npcap for Windows 10 can be downloaded from here.

3. Opening Npcap setup file, Click on ‘I Agree’ To license agreement.

Figure 06: License agreement for Npcap 1.10

4. Now we proceed to choose which components of Npcap are to be
installed and thenclicking on “Install”.

Figure 07: Choose Components to install for Npcap 1.10

 5. Installation process starts and completes. Clicking on “Next” we have:

Figure 08: Setup completed for Npcap 1.10

6. Now the window for installation of Npcap shows it has been installed.

Clicking“Finish”.

Figure 09: Successful installation for Npcap 1.10 completed

 7. After installing Snort and Npcap enter these commands in windows 10 Command

prompt to check snorts working

Figure 10: Successfully running Snort on Windows 10 through command prompt

8. As you can see in the above figure that snort runs successfully.

This is how you can download and install Snort along with its dependency i.e. Npcap.

Configuring Snort 2.9.17 on Windows 10:

After installing Snort on Windows 10, Another important step to get started with Snort is

configuring it on Windows 10.

1. Go to this link and download latest snort rule file.

2. Extract 3 folders from the downloaded snortrules-snapshot-29170.tar folder into

theSnorts corresponding folders in C drive.

Folders to be extracted are: rules , preproc_rules , etc

 rules folder contains the rules files and the most important local.rules file. Whichwe

will use to enter all our rules.

 etc folder contains all configuration files and the most important fileis

snort.conf file which we will use for configuration.

3. Now open the snort.conf file through the notepad++ editor or any other text

editorto edit configurations of snort to make it work like we want it to.

4. Setup the network addresses you are protecting

ipvar HOME_NET any

Note: Mention your own host IP addresses that you want to protect.

Figure 11: Setting up the Home Network Address in Snort

# Set up the external network addresses. Leave as “any” in most situationsipvar

EXTERNAL_NET any

5. Setup the external network into anything that is not the home network. That is

why !is used in the command it denotes ‘not’

Figure 12: Setting up the external Network Addresses in Snort

# Path to your rules files (this can be a relative path)# Note for Windows users: You are
advised to make this an absolute path,# such as: c:\snort\rulesvar RULE_PATH ../rulesvar
SO_RULE_PATH
6. Now we have ../so_rulesvar
to define the PREPROC_RULE_PATH
directory for our ../preproc_rules
rules and preproc rules folde

Figure 13: Setting up path to our rules files and preproc rules folder in Snort
7. Now we have to setup our white list and black list path it will be in our snorts’

rulefolder

# If you are using reputation preprocessor set thesevar WHITE_LIST_PATH ../rulesvar

BLACK_LIST_PATH ../rules

Figure 14: Setting up our White List and Black List files paths in Snort

8. Next we have to enable to log directory, so that we store logs in our log

folder. Uncomment this line and set absolute path to log directory

# Configure default log directory for snort to log to. For more information see snort -h
command line options (-l)## config logdir:

Figure 15: Setting up Log Directory Path in Snort

9. Now we will set the path to dynamic preprocessors and dynamic engine

# path to dynamic preprocessor libraries

dynamic preprocessor directory/usr/local/lib/snort_dynamicpreprocessor/

Figure 16: Setting up path to dynamic preprocessors and dynamic engine in

Snort

10. We will do same thing for dynamic preprocessor engine

# path to base preprocessor enginedynamicengine

/usr/local/lib/snort_dynamicengine/libsf_engine.so

Figure 17: Setting up the path to dynamic preprocessor engine in Snort

11. Now lets set our reputation preprocessors:
# path to dynamic rules libraries# dynamicdetection directory
/usr/local/lib/snort_dynamicrules

Figure 18: Path to dynamic rules libraries in Snort

12. Just comment out these lines as shown in figure 19 in doing so we are

excludingpacket normalization of different packets.

Figure 19: Commenting out packet normalization commands in Snort

13. Scroll down to the reputation preprocessors. We will just change the name

of thefiles since white list , black list are not rules they are just the list of IP

addresses labelled as black or white

# Reputation preprocessor. For more information see README.reputationpreprocessor

reputation: \memcap 500, \priority whitelist, \nested_ip inner, \whitelist
$WHITE_LIST_PATH/whitelist, \blacklist $BLACK_LIST_PATH\black.list

Figure 20: Whitelisting and Blacklisting IPs through the command as shown
in figure

14. Converted back slashes to forward slashes in lines 546–651.

Figure 21 : Converted back slashes to forward slashes in specific lines in
snort.conf file
Figure 22: Converted back slashes to forward slashes in specific
lines in snort.conf file
15. Again just convert forward slashes to backslashes and uncomment the lines below:
# decoder and preprocessor event rules# include
$PREPROC_RULE_PATH/preprocessor.rules# include
$PREPROC_RULE_PATH/decoder.rules# include $PREPROC_RULE_PATH/sensitive-
data.rules

Figure 23 : Converted back slashes to forward slashes in specific lines and

uncommenting specific lines in snort.conf file
16. Now we just need to verify the presence of this command at the

bottom of snort.conf file.

Figure 24: verifying presence of “include threshold.conf” command in

snort.conffile

17. Click on Save file and save all changes to save the configuration file (snort.conf).

18. Now recalling the Step 13 white list , black list are not rules they are just the

list of IP addresses labelled as black or white right now these files don’t exist in

our rule path which is why we have to create them manually , save them in this

folder C:\Snort\rules.
 Go to Notepad++ and create new file.

 Comment it #White-listed IPs.

 Name the file white.list and save the file.

Figure 25 : Creating White List IPs file

 Create another new file.

 Comment it #Black-listed IPs.

 Name the file black.list and save the file.

Figure 26 : Creating Black List IPs file in Snort

 19. Now we test snort again by running Command prompt as admin. To check

if it’s running fine after all the configurations.

Figure 27: Test Running of Snort in Windows 10 after Configuration

20. We can also the check the wireless interface cards from which we will be

using snort by using the command below we can see the list of our wireless

interface cards through entering this command in command prompt.

Snort — W

RESULT:
Thus the Intrusion Detection System (IDS) has been demonstrated by
usingthe Open Source Snort Intrusion Detection Tool.
EX.NO:8 EXPLORE NETWORK MONITORING TOOLS
DATE:8.4.24

AIM:
To explore the network monitoring tools .
PROCEDURE:

Nagios:
Overview:
Nagios is an open-source monitoring tool that helps organizations to monitor their
IT infrastructure components such as servers, switches, applications, and services.
It provides comprehensive monitoring and alerting capabilities, enabling system
administrators to proactively identify and resolve issues before they impact end-
users.
Key Features:
1. Flexible Monitoring:Nagios allows you to monitor a wide range of network
services, including HTTP, SMTP, SSH, FTP, and more. It also supports monitoring of
host resources such as CPU, memory, disk usage, etc.

2. Alerting:It offers customizable alerting features, including email notifications,

SMS alerts, and integration with third-party applications like Slack, PagerDuty,
etc.

3. Visualization: Nagios provides web-based dashboards and reports for

visualizing monitoring data. This helps administrators to quickly identify
trends, anomalies, and performance issues.

4. Extensibility: Nagios has a vast ecosystem of plugins and addons that extend its
functionality. Users can develop custom plugins to monitor specific services or
integrate with other tools seamlessly.

Practical Exercises:
1. Installation and Configuration: Set up Nagios on a dedicated server (physical or
virtual) using a Linux distribution like CentOS or Ubuntu. Follow the official
installation guide provided by Nagios to configure the core monitoring engine and
webinterface.
2. Host and Service Monitoring: Add target hosts (servers, network devices) and
define the services you want to monitor (e.g., HTTP, SSH, DNS). Configure service
checks using built-in plugins or custom scripts if needed.
3.Alerting Setup:Configure notification commands and contacts to receive alerts via
email or SMS when a service or host goes down or reaches a critical state. Test the
alerting mechanism by intentionally causing service failures.
4.Dashboard Customization: Customize the Nagios dashboard to display relevant
metrics and status information based on your infrastructure requirements. Arrange
widgets, graphs, and tables to provide an intuitive overview of the monitored
environment.

5.Scaling and High Availability:Explore options for scaling Nagios to monitor

large- scale deployments and ensuring high availability to minimize downtime.
Implement distributed monitoring setups or deploy redundant Nagios instances for
fault tolerance.

6.Integration with Other Tools: Integrate Nagios with external tools such as Grafana for
advanced visualization, Prometheus for metric collection, or ELK stack for log analysis.
Configure data export/import mechanisms to share monitoring data with othersystems.

Real-time example:
Scenario:
Imagine you are a system administrator responsible for managing the IT infrastructure of
a medium-sized company. Your company relies heavily on its network infrastructure to
support various critical services and applications, including email, file sharing, and
customer-facing websites.

Real-Time Example:
1. Installation and Configuration:
- Install Nagios on a dedicated server running CentOS Linux.
- Configure Nagios Core and Nagios Plugins according to the official documentation.
- Set up the Nagios web interface for monitoring and administration.

2. Host and Service Monitoring:

- Add all critical servers, switches, and routers to Nagios for monitoring.
- Define services to monitor, such as HTTP for web servers, SMTP for
email servers, and SSH for remote access.
- Configure host and service checks to run at regular intervals to ensure
continuous monitoring.

3. Alerting Setup:
- Configure Nagios to send email notifications to the IT support team whenever
a hostor service goes down or reaches a critical state.
- Set up SMS notifications using an SMS gateway for urgent alerts, ensuring that
theteam can respond promptly to critical incidents, even outside working hours.
 4. Dashboard Customization:
- Customize the Nagios dashboard to display the status of all monitored
hosts andservices in real-time.
- Include graphs and charts showing historical performance data and
trends to facilitate quick troubleshooting and decision-making.

5. Scaling and High Availability:

- Implement a distributed Nagios monitoring setup with multiple monitoring
nodes distributed across different geographic locations.
- Set up load balancing and failover mechanisms to ensure high availability and fault
tolerance.

6. Integration with Other Tools:

- Integrate Nagios with Grafana for advanced visualization of monitoring data.
- Use Prometheus for metric collection and alerting, feeding data into
Nagios forcentralized monitoring.
-Integrate Nagios with ticketing systems like JIRA or ServiceNow for
automatedincident management and resolution.

Real-Time Benefit:
In a real-time scenario, Nagios would continuously monitor the company's network
infrastructure, detecting any issues or performance degradations as soon as they occur.
For example:
- If a critical server experiences a hardware failure or service outage, Nagios
would immediately alert the IT support team via email and SMS, allowing them
to investigateand resolve the issue promptly.
-In case of network congestion or bandwidth saturation, Nagios would trigger
alerts, enabling administrators to take proactive measures such as adjusting network
settings or upgrading hardware to prevent service degradation.
- Through the customizable dashboard and integrated visualization tools,
administrators can quickly identify trends and patterns in network
performance, facilitating proactive capacity planning and optimization.

Overall, Nagios provides real-time visibility into the health and performance of the
network infrastructure, helping organizations maintain high availability, minimize
downtime, and ensure a seamless user experience for their employees and customers

RESULT:
Thus, the exploring of network monitoring tools are executed and verified successfully.
EX.NO:9 STUDY TO CONFIGURE FIREWALL, VPN
DATE:8.4.24

AIM:
To study and configure the Firewall and VPN PROCEDURE:

Configuring a firewall and VPN involves multiple steps and considerations. Here's a
studyguide to help you understand the basics and steps involved in configuring both:

PROCEDURE:
Firewall Configuration:

1. Understand Firewall Types:

- Study different types of firewalls such as network-based firewalls, host-based
firewalls, and application-layer firewalls.
- Learn about stateful vs. stateless inspection and how they impact firewall rules.

2. Choose Firewall Software/Hardware:

- Research popular firewall solutions like iptables (Linux), pfSense (open-source
firewall), Cisco ASA (hardware firewall), and others.
- Understand the features, limitations, and requirements of each solution.

3.. Define Security Policies:

- Determine the purpose of the firewall (e.g., perimeter defense, internal segmentation).
- Define security policies such as which traffic to allow, deny, or restrict based on
source,destination, port, and protocol.

4.. Implement Firewall Rules:

- Learn how to create and configure firewall rules to enforce security policies.
- Understand rule precedence, NAT (Network Address Translation), and port forwarding.

5.. Test and Monitor:

- Test firewall rules to ensure they function as intended without unintended consequences.
- Set up logging and monitoring to detect and respond to security events and policy
violations.

VPN Configuration:

1. Choose VPN Technology:

- Study different VPN technologies such as IPsec, SSL/TLS, PPTP, L2TP, and OpenVPN.
- Understand their features, security implications, and use cases.
 2. Select VPN Software/Hardware:
- Research VPN solutions compatible with your network infrastructure and requirements.
- Consider factors like ease of setup, scalability, compatibility, and security features.

3.Configure VPN Server:

- Install and configure VPN server software or hardware appliance.
- Define VPN parameters such as encryption algorithms, authentication methods,
and IP address assignment.

4.Configure VPN Clients:

- Set up VPN client software or configure built-in VPN clients on devices.
- Configure client-side parameters such as server address, authentication
credentials, and connection settings.

5.Test and Troubleshoot:

- Test VPN connectivity from client devices to the VPN server.
- Troubleshoot connection issues, firewall conflicts, and misconfigurations.

6.Implement Security Measures:

- Implement additional security measures like multi-factor authentication
(MFA) and endpoint security to enhance VPN security.
- Regularly update VPN software and firmware to patch security vulnerabilities.

7.Monitor and Maintain:

- Monitor VPN connections for performance, availability, and security.
- Implement logging and auditing to track VPN usage and detect suspicious activities.

Additional Resources:

- Refer to official documentation and guides provided by firewall and VPN vendors.
- Explore online tutorials, courses, and forums for hands-on configuration
examples and troubleshooting tips.
- Practice setting up virtual firewall and VPN appliances using platforms like
VirtualBox orVMware for practical experience.

By following this study guide and gaining hands-on experience, you'll develop the
skills and knowledge needed to configure firewall and VPN solutions effectively in
real-world scenarios.

RESULT:
Thus ,the study and configuration of firewall and VPN was studied successfully
EX.NO:10 EXPERIMENT EAVESDROPPING, DICTIONARY ATTACKS, MITM
DATE:15.4.24 ATTACKS

AIM:
To experiment eavesdropping, Dictionary attacks, MIMT attacks.
Visual Objective:

Introduction:
Password cracking is a term used to describe the penetration of a network, system, or resource
with or without the use of tools to unlock a resource that has been secured with a password.
Password cracking tools may seem like powerful decryptors, but in reality are little more
than fast, sophisticated guessing machines.
Types of password breaking Dictionary attack
A simple dictionary attack is usually the fastest way to break into a machine. A dictionary
file (a text file full of dictionary words) is loaded into a cracking application, which is run
against user accounts located by the application.
Brute force attack
A brute force attack is a very powerful form of attack, though it may often take a long time
to work depending on the complexity of the password. The program will begin trying any
and every combination of numbers and letters and running them against the hashed
passwords.
Passwords that are composed of random letters numbers and characters are most vulnerableto
this type of attack.
Hybrid attack
Another well-known form of attack is the hybrid attack. A hybrid attack will add numbers or
symbols to the search words to successfully crack a password. Many people change their
passwords by simply adding a number to the end of their current password. Therefore, this
type of attack is the most versatile, while it takes longer then a standard dictionary attack
it does not take as long as a brute force attack.
Cracking Process
Since a brute force attack is the most time consuming and is not likely to break any passwords
that are not composed of random characters, the best plan is to use techniques that are
computationally efficient compared to untargeted and unspecific techniques. By applying
what is known about how users select passwords, an intruder can tremendously increase
the odds in their favor of finding passwords. With the right techniques, some poor
passwords can be cracked in under a second.
The real power of dictionary attacks come from understanding the ways in which most people
vary names and dictionary words when attempting to create a password. By applying all
the common transformations to every word in the electronic list and encrypting each result
the number tested passwords multiplies rapidly. Cracking tools can often detect “clever”
ways of manipulating words to hide their origin. For example, such cracking programs
often subject each word to a list of rules. A rule could be anything, any manner in which
a word might appear. Typical rules might include
Alternate upper- and lowercase lettering.
Spell the word forward and then backward, and then fuse the two results (for example:
cannac).
Add the number 1 to the beginning and/or end of each word.
Naturally, the more rules one applies to the words, the longer the cracking process takes.
However, more rules also guarantee a higher likelihood of success.
Task 1 – Microsoft Office Password Recovery
Many applications require you to establish an ID and password that may be saved and
automatically substituted for future authentication. The password will usually appear on
the screen as a series of asterisks. This is fine as long as your system remembers the
password for you but what if it "forgets" or you need it for use on another system.
Fortunately, many utilities have been written to recover such passwords. In this task, you
will use OfficeKey to recover the password for a MS word document.
Step 1: Find the folder “Lab1” on your desktop, and open it.
You will find OfficeKey and a MS document in the folder.
Step 2: Open the Office Key – Password Recovery tool
Step 3: Press the “Recover” button in the upper left corner, or select File Recover
Step 4: Choose the password protected MS Office File you have saved to the Desktop.

Step 5: After running the first password auditing session, check to see if Office key has
cracked the password. If the password has not been cracked press the Settings button on
the upper tool bar.

Step 6: Once in the Settings menu you will be able to modify the search parameters and
customize a more targeted search

Step 7: Repeat steps 3 and 4 until the password has been cracked and opens the MS Office
File.
Step 8:Write down the contents of the MS word document and the password into your lab
report and submit it to your TA.

Task 2 – Password Auditing (Windows platform):

The purpose of this task is to familiarize you with act of password cracking/recovery.
Password cracking software uses a variety of approaches, including intelligent guessing,
dictionary attacks and automation that tries every possible combination of characters.
Given enough time the automated method can crack any password, but more effective
passwords will last months before breaking.
When a password is entered and saved on a computer it is encrypted, the encrypted password
becomes a string of characters called a “hash” and is saved to a password file.
A password cannot be reverse-decrypted. So a cracking program encrypts words and
characters given to it (wordlist or randomly generated strings of characters) and compares
the results with hashed passwords. If the hashes match then the password has successfully
been guessed or “cracked”. This process is usually performed offline against a captured
password file so that being locked out of the account is not an issue, and guessing can go
on continuously. Thus, revealing the passwords is simply a mater of CPU time and
dictionary size

1. You obtain a dictionary file, which is no more than a flat file (plain text) list of words
(commonly referred to as wordlists).
2. These words are fed through any number of programs that encrypt each word. Such
encryption conforms to the DES standard.
3. Each resulting encrypted word is compared with the target password. If a match
occurs, there is better than a 90 percent chance that the password was cracked.

Step 1: Go to Lab1 folder, and open LC4 to audit the passwords on your Windows system.
Select File New Session
Select Import Import from PWDUMP File (in the same folder) Select the “Passwords”
file that has been provided to you.

Objectives
This password file has been retrieved from a system that we must gain access to. To do this
you must crack as many passwords as possible as quickly as possible. We have captured
the user names and encrypted passwords for ten users. The user names follow a standard
pattern of first initial and last name, but the passwords have no set standards. We do know
that users of this system are encouraged to add numbers and other characters to the words
they chose for passwords.
 To aid you in cracking these passwords we have managed to collect some basic information
about the users. This personal information may help you target your searches as to what
the user’s password may be.

Kmiller Ken Miller is an avid fly fisher and his record number of catches
is
just under 30
Smacman Steven MacMan has a fiancé who’s name is 4 letters long and
starts
with a “K”
Gkoch Gina Koch grew up with her German grandmother, who used to
call

her ‘Little Precious’ *

Mjone Matt Jones was born in 1979. He compares himself to a
s
Shakespearean character who was born via C section
Tgriffi Tim Griffin loves funky ‘70’s and ‘80s music. And songs about
n
‘Love’
Rklatt Ryan Klatt is a big Star Trek fan and has most likely chosen an
obscure reference for his password *
Nboyle Nancy Boyle is an a fan of the books of British writer Douglas Adams
Esmith Edward Smith was very close to his grandfather who died in 1968.
We know his grandfather’s name was a less common name starting
with ‘L’
Jcollin Jim Collins keeps a copy of the book “The Prince” *
s
Hharri Alan Harris has a wife named Sue and a daughter named Megan
s
Alan was married on May 3rd. His daughter was born on August 6th

Step 2: Select Session Options

Use this menu to customize your password search. Here you can add different word list for
Dictionary attacks, change Hybrid attack features. Keep in mind you are working with a
short dead line and more in depth searches will take longer then you have. You must use
the information given to you to target your search most specifically at more likely
passwords
Step 3: Select Session Begin “Audit” or Press the blue play button on the upper toolbar to
start the password search.
Step 4: After the first search has run check your progress. Have some of the passwords been
cracked all the way though or have some only been partially cracked. Use what you’ve
learned from this first search to target your next few searches. You will need to search
the internet and use the information you have been given about each user to find words
they may have used as their password.
Note: The question marks in the partially cracked passwords do not necessarily represent the
number of remaining undiscovered characters.
Step 5: Add words to your wordlist Session Session Options
Press the ‘Dictionary List’ button in the Dictionary crack section. Here you can edit your
current word list and add words by selecting the ‘EDIT’ button and entering each wordon
a new line. You can also add multiple dictionaries and wordlist.
Step 6: You may chose to conduct dictionary attacks with other wordlists. You can find
additional wordlist to use here: ftp://ftp.cerias.purdue.edu/pub/dict
Step 7: Continue searching for possible passwords during the remainder of the lab.
Repeatingsteps 3 and 4 each time you modify your search.
Step 8: Once you have cracked all the passwords in the file, write them down in your lab
reportor once the lab time has ended, submit the passwords you were able to crack.

RESULT:
Thus, the experiment for Eavesdropping, Dictionary attacks, MITM attacks was done
successfully.