School of Computer Science Engineering & Information Systems

Winter Semester-2023-24
M.Tech. Software Engineering
SWE2002 - Computer Networks Lab Assessment – 3

Name: S. Daniel
Reg No: 22MIS0500

1. The finance office of VIT wishes to make the transactions more secure. If you are a
programmer how you will implement a system to validate the login credentials obtained
from the user thereby denying access to unauthorized users using UDP sockets? The
validity of the client must be sent as the reply message to the client and displayed it on
the standard output.

Code:

Server Side:

import java.net.*;

public class UDPServer {

public static void main(String[] args) {
try {
DatagramSocket serverSocket = new DatagramSocket(9876);

byte[] receiveData = new byte[1024];

byte[] sendData;
 // Dummy database of authorized users
String[][] authorizedUsers = {
{"user1", "password1"},
{"user2", "password2"}
};

System.out.println("Server running...");

while (true) {
DatagramPacket receivePacket = new DatagramPacket(receiveData,
receiveData.length);
serverSocket.receive(receivePacket);

String data = new String(receivePacket.getData(), 0, receivePacket.getLength());

String[] credentials = data.split(",");

String username = credentials[0];

String password = credentials[1];

boolean loginSuccess = false;

for (String[] user : authorizedUsers) {
if (user[0].equals(username) && user[1].equals(password)) {
loginSuccess = true;
break;
}
}

String response = loginSuccess ? "Login successful" : "Login failed";

sendData = response.getBytes();

InetAddress clientAddress = receivePacket.getAddress();

int clientPort = receivePacket.getPort();

DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length,

clientAddress, clientPort);
serverSocket.send(sendPacket);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
Client Side:

import java.net.*;

public class UDPClient {

public static void main(String[] args) {
try {
DatagramSocket clientSocket = new DatagramSocket();

InetAddress serverAddress = InetAddress.getByName("localhost");

int serverPort = 9876;

byte[] sendData;
byte[] receiveData = new byte[1024];

// User input for username and password

String username = "user1";
String password = "password1";

String data = username + "," + password;

sendData = data.getBytes();

DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length,

serverAddress, serverPort);
clientSocket.send(sendPacket);

DatagramPacket receivePacket = new DatagramPacket(receiveData,

receiveData.length);
clientSocket.receive(receivePacket);

String response = new String(receivePacket.getData(), 0, receivePacket.getLength());

System.out.println("Server response: " + response);

clientSocket.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}

Output:
2. Write a UDP program to implement an image transfer from client to server.

Server Side:

import java.io.*;
import java.net.*;

public class UDPServer {

public static void main(String[] args) {
DatagramSocket serverSocket = null;
FileOutputStream fos = null;
try {
serverSocket = new DatagramSocket(9876);

byte[] receiveData = new byte[1024];

DatagramPacket receivePacket = new DatagramPacket(receiveData,
receiveData.length);
serverSocket.receive(receivePacket);

ByteArrayInputStream bais = new ByteArrayInputStream(receivePacket.getData());

ObjectInputStream ois = new ObjectInputStream(bais);
byte[] imageData = (byte[]) ois.readObject();

fos = new FileOutputStream("received_image.jpg");

fos.write(imageData);
 System.out.println("Image received and saved.");
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
} finally {
try {
if (serverSocket != null)
serverSocket.close();
if (fos != null)
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

Client Side:

import java.io.*;
import java.net.*;

public class UDPClient {

public static void main(String[] args) {
DatagramSocket clientSocket = null;
FileInputStream fis = null;
try {
clientSocket = new DatagramSocket();
InetAddress serverAddress = InetAddress.getByName("localhost");
int serverPort = 9876;

File file = new File("image_to_send.jpg");

fis = new FileInputStream(file);
byte[] imageData = new byte[(int) file.length()];
fis.read(imageData);

ByteArrayOutputStream baos = new ByteArrayOutputStream();

ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(imageData);
oos.flush();

byte[] sendData = baos.toByteArray();

 DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length,
serverAddress, serverPort);
clientSocket.send(sendPacket);

System.out.println("Image sent to server.");

} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (clientSocket != null)
clientSocket.close();
if (fis != null)
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

3. Find the physical address of a host when its logical address is known (ARP protocol)
using UDP.
import java.net.InetAddress;

public class ARPRequest {

private InetAddress senderIP;
private String senderMAC;
private InetAddress targetIP;

// Constructor, getters, and setters

}

// ARP Reply class

import java.net.InetAddress;

public class ARPReply {

private InetAddress senderIP;
private String senderMAC;

// ARP Server class

import java.net.*;

public class ARP {

public static void main(String[] args) {
try {
DatagramSocket socket = new DatagramSocket();
InetAddress broadcastAddress = InetAddress.getByName("255.255.255.255");

// Send ARP request

ARPRequest request = new ARPRequest();
request.setSenderIP(InetAddress.getLocalHost());
request.setSenderMAC("00:11:22:33:44:55");
request.setTargetIP(InetAddress.getByName("192.168.1.1")); // Example target IP

ByteArrayOutputStream baos = new ByteArrayOutputStream();

ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(request);
oos.flush();

byte[] sendData = baos.toByteArray();

DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length,
broadcastAddress, 9876);
socket.send(sendPacket);
 // Receive ARP reply
byte[] receiveData = new byte[1024];
DatagramPacket receivePacket = new DatagramPacket(receiveData,
receiveData.length);
socket.receive(receivePacket);

ByteArrayInputStream bais = new ByteArrayInputStream(receivePacket.getData());

ObjectInputStream ois = new ObjectInputStream(bais);
ARPReply reply = (ARPReply) ois.readObject();

System.out.println("MAC address for " + reply.getSenderIP() + " is " +

reply.getSenderMAC());

socket.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}

Output:

4. Implement a DNS server and client using UDP sockets. The client should give the URL
as the input and the server should send the respective IP address.

Server Side:
import java.net.*;

public class DNSServer {

public static void main(String[] args) {
try {
DatagramSocket serverSocket = new DatagramSocket(9876);

while (true) {
byte[] receiveData = new byte[1024];
DatagramPacket receivePacket = new DatagramPacket(receiveData,
receiveData.length);
serverSocket.receive(receivePacket);

String domain = new String(receivePacket.getData(), 0, receivePacket.getLength());

InetAddress ipAddress = InetAddress.getByName(resolveIP(domain));

byte[] sendData = ipAddress.getHostAddress().getBytes();

DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length,
receivePacket.getAddress(), receivePacket.getPort());
serverSocket.send(sendPacket);
}
} catch (Exception e) {
e.printStackTrace();
}
}

private static String resolveIP(String domain) {

// This is a simple mapping, replace it with your actual DNS resolution mechanism
if (domain.equals("example.com")) {
return "93.184.216.34";
} else {
return "Unknown";
}
}
}

Client Side:

import java.net.*;

public class DNSClient {

public static void main(String[] args) {
 if (args.length != 1) {
System.out.println("Usage: java DNSClient <domain>");
return;
}

String domain = args[0];

try {
DatagramSocket clientSocket = new DatagramSocket();
InetAddress serverAddress = InetAddress.getByName("localhost");
int serverPort = 9876;

byte[] sendData = domain.getBytes();

DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length,
serverAddress, serverPort);
clientSocket.send(sendPacket);

byte[] receiveData = new byte[1024];

DatagramPacket receivePacket = new DatagramPacket(receiveData,
receiveData.length);
clientSocket.receive(receivePacket);

String ipAddress = new String(receivePacket.getData(), 0, receivePacket.getLength());

System.out.println("IP address for " + domain + " is: " + ipAddress);

clientSocket.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}

Output:
5. Implement a UDP-based socket program for the game “Guess It”. The game is played
by the client and server. The game proceeds as follows: The server will think of a “magic
number”. The magic number is greater than zero and less than 100. Prompt for the
“magic number” from the client. The server should print out “Higher” if the magic
number is higher than the guess and “Lower” if the magic number is less than the guess.
Give 10 chances for the client to guess the number. When the magic number has been
guessed print "Great" and then end. If the client cannot guess the number in 10 attempts,
then print the message "Better luck next time:)" and end.

Server Side:

import java.net.*;

public class GuessItServer {

public static void main(String[] args) {
try {
DatagramSocket serverSocket = new DatagramSocket(9876);

// Generate the magic number

int magicNumber = (int) (Math.random() * 100);

byte[] receiveData = new byte[1024];

DatagramPacket receivePacket = new DatagramPacket(receiveData,
receiveData.length);
 // Receive the initial message from the client
serverSocket.receive(receivePacket);
String initialMessage = new String(receivePacket.getData(), 0,
receivePacket.getLength());
InetAddress clientAddress = receivePacket.getAddress();
int clientPort = receivePacket.getPort();

System.out.println("Magic number: " + magicNumber);

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

// Prompt for guess
sendUDPMessage(serverSocket, clientAddress, clientPort, "Enter your guess
(between 0 and 99):");

// Receive guess from client

serverSocket.receive(receivePacket);
int guess = Integer.parseInt(new String(receivePacket.getData(), 0,
receivePacket.getLength()));

// Check if guess matches the magic number

if (guess == magicNumber) {
sendUDPMessage(serverSocket, clientAddress, clientPort, "Great!");
break;
} else if (guess < magicNumber) {
sendUDPMessage(serverSocket, clientAddress, clientPort, "Higher");
} else {
sendUDPMessage(serverSocket, clientAddress, clientPort, "Lower");
}

if (i == 9) {
sendUDPMessage(serverSocket, clientAddress, clientPort, "Better luck next
time:)");
}
}
} catch (Exception e) {
e.printStackTrace();
}
}

private static void sendUDPMessage(DatagramSocket serverSocket, InetAddress

clientAddress, int clientPort, String message) throws Exception {
byte[] sendData = message.getBytes();
DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length,
clientAddress, clientPort);
 serverSocket.send(sendPacket);
}
}

Client Side:

import java.net.*;

public class GuessItClient {

public static void main(String[] args) {
try {
DatagramSocket clientSocket = new DatagramSocket();
InetAddress serverAddress = InetAddress.getByName("localhost");
int serverPort = 9876;

byte[] sendData;
byte[] receiveData = new byte[1024];

// Send initial message to server

String initialMessage = "Start the game";
sendData = initialMessage.getBytes();
DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length,
serverAddress, serverPort);
clientSocket.send(sendPacket);

DatagramPacket receivePacket = new DatagramPacket(receiveData,

receiveData.length);

// Receive initial response from server

clientSocket.receive(receivePacket);
String initialResponse = new String(receivePacket.getData(), 0,
receivePacket.getLength());
System.out.println(initialResponse);

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

// Receive prompt from server
clientSocket.receive(receivePacket);
String prompt = new String(receivePacket.getData(), 0, receivePacket.getLength());
System.out.println(prompt);

// Send guess to server

int guess = (int) (Math.random() * 100);
sendData = String.valueOf(guess).getBytes();
 sendPacket = new DatagramPacket(sendData, sendData.length, serverAddress,
serverPort);
clientSocket.send(sendPacket);

// Receive response from server

clientSocket.receive(receivePacket);
String response = new String(receivePacket.getData(), 0, receivePacket.getLength());
System.out.println(response);

if (response.equals("Great!") || response.equals("Better luck next time:)")) {

break;
}
}

clientSocket.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}

Output: