Java-Buddy

Here are examples of Java SSL Server and Client.



JavaSSLServer.java

package javasslserver;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.net.ssl.SSLServerSocketFactory;
/**
 * @web http://java-buddy.blogspot.com/
 */
public class JavaSSLServer {
 
 static final int port = 8000;
 public static void main(String[] args) {
 
 
 SSLServerSocketFactory sslServerSocketFactory = 
 (SSLServerSocketFactory)SSLServerSocketFactory.getDefault();
 
 try {
 ServerSocket sslServerSocket = 
 sslServerSocketFactory.createServerSocket(port);
 System.out.println("SSL ServerSocket started");
 System.out.println(sslServerSocket.toString());
 
 Socket socket = sslServerSocket.accept();
 System.out.println("ServerSocket accepted");
 
 PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
 try (BufferedReader bufferedReader = 
 new BufferedReader(
 new InputStreamReader(socket.getInputStream()))) {
 String line;
 while((line = bufferedReader.readLine()) != null){
 System.out.println(line);
 out.println(line);
 }
 }
 System.out.println("Closed");
 
 } catch (IOException ex) {
 Logger.getLogger(JavaSSLServer.class.getName())
 .log(Level.SEVERE, null, ex);
 }
 }
 
}

JavaSSLClient.java

package javasslclient;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.net.ssl.SSLSocketFactory;
/**
 * @web http://java-buddy.blogspot.com/
 */
public class JavaSSLClient {
 
 static final int port = 8000;
 public static void main(String[] args) {
 
 SSLSocketFactory sslSocketFactory = 
 (SSLSocketFactory)SSLSocketFactory.getDefault();
 try {
 Socket socket = sslSocketFactory.createSocket("localhost", port);
 PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
 try (BufferedReader bufferedReader = 
 new BufferedReader(
 new InputStreamReader(socket.getInputStream()))) {
 Scanner scanner = new Scanner(System.in);
 while(true){
 System.out.println("Enter something:");
 String inputLine = scanner.nextLine();
 if(inputLine.equals("q")){
 break;
 }
 
 out.println(inputLine);
 System.out.println(bufferedReader.readLine());
 }
 }
 
 } catch (IOException ex) {
 Logger.getLogger(JavaSSLClient.class.getName())
 .log(Level.SEVERE, null, ex);
 }
 
 }
 
}

Without keystore, both the server and client will fail. This video show how to generate keystore using keytool program. Then run server and client with keystore and password.


Type the following command in your command window to create a keystore named examplestore and to generate keys:

$ keytool -genkey -alias signFiles -keystore examplestore

You will be prompted to enter passwords for the key and keystore. The password in this example is "password".

(reference: https://docs.oracle.com/javase/tutorial/security/toolsign/step3.html)

Run SSL server and client by entering the commands:
$ java -jar -Djavax.net.ssl.keyStore=keystore -Djavax.net.ssl.keyStorePassword=password "...JavaSSLServer.jar"
$ java -jar -Djavax.net.ssl.trustStore=keystore -Djavax.net.ssl.trustStorePassword=password "...JavaSSLClient.jar"

It's a simple example to implement UDP Client/Server in Java. To test the function, start JavaUDPServer with port number in Terminal. The server will open a DatagramSocket and wait for incoming message from client. Then start JavaUDPClient with IP address and port number in another Terminal, then enter anything. The user input will be sent to JavaUDPServer via UDP socket, when JavaUDPServer receive the message, it will echo back to JavaUDPClient, then both JavaUDPServer and JavaUDPClient close the socket.



JavaUDPServer.java

package javaudpserver;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
 *
 * @web http://java-buddy.blogspot.com/
 */
public class JavaUDPServer {
 
 private static DatagramSocket datagramSocket;
 private static final int BUFFER_SIZE = 1024;
 private static byte[] buffer;
 public static void main(String[] args) {
 if (args.length != 1) {
 System.out.println("usage: java -jar JavaUDPServer.jar <port>");
 System.exit(1);
 }
 
 int port = Integer.parseInt(args[0]);
 System.out.println("Port: " + port);
 try {
 datagramSocket = new DatagramSocket(port);
 
 buffer = new byte[BUFFER_SIZE];
 
 DatagramPacket in_datagramPacket = new DatagramPacket(
 buffer, BUFFER_SIZE);
 datagramSocket.receive(in_datagramPacket);
 
 InetAddress clientAddress = in_datagramPacket.getAddress();
 int clientPort = in_datagramPacket.getPort();
 
 String in_message = new String(
 in_datagramPacket.getData(), 
 0, 
 in_datagramPacket.getLength());
 System.out.println("received: " + in_message);
 
 String out_messagae = "echo: " + in_message;
 DatagramPacket out_datagramPacket= new DatagramPacket(
 out_messagae.getBytes(), 
 out_messagae.length(), 
 clientAddress, 
 clientPort);
 datagramSocket.send(out_datagramPacket);
 
 } catch (SocketException ex) {
 Logger.getLogger(JavaUDPServer.class.getName()).log(Level.SEVERE, null, ex);
 } catch (IOException ex) {
 Logger.getLogger(JavaUDPServer.class.getName()).log(Level.SEVERE, null, ex);
 } finally {
 datagramSocket.close();
 }
 }
 
}

JavaUDPClient.java

package javaudpclient;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.Scanner;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
 *
 * @web http://java-buddy.blogspot.com/
 */
public class JavaUDPClient {
 
 private static DatagramSocket datagramSocket;
 
 private static final int BUFFER_SIZE = 1024;
 private static byte[] buffer;
 public static void main(String[] args) {
 if (args.length != 2) {
 System.out.println("usage: java -jar JavaUDPClient.jar <IP address> <port>");
 System.exit(1);
 }
 try {
 InetAddress inetAddress = InetAddress.getByName(args[0]);
 int port = Integer.parseInt(args[1]);
 
 Scanner userScanner = new Scanner(System.in);
 String userInput = userScanner.nextLine();
 
 datagramSocket = new DatagramSocket();
 
 DatagramPacket out_datagramPacket = new DatagramPacket(
 userInput.getBytes(), 
 userInput.length(), 
 inetAddress, 
 port);
 
 datagramSocket.send(out_datagramPacket);
 
 buffer = new byte[BUFFER_SIZE];
 DatagramPacket in_datagramPacket = 
 new DatagramPacket(buffer, BUFFER_SIZE);
 datagramSocket.receive(in_datagramPacket);
 
 String serverEcho = new String(
 in_datagramPacket.getData(), 
 0, 
 in_datagramPacket.getLength());
 System.out.println(serverEcho);
 
 } catch (UnknownHostException ex) {
 Logger.getLogger(JavaUDPClient.class.getName()).log(Level.SEVERE, null, ex);
 } catch (SocketException ex) {
 Logger.getLogger(JavaUDPClient.class.getName()).log(Level.SEVERE, null, ex);
 } catch (IOException ex) {
 Logger.getLogger(JavaUDPClient.class.getName()).log(Level.SEVERE, null, ex);
 } finally {
 datagramSocket.close();
 }
 }
 
}

---

Compare with: Simple example of TCP Client/Server communication

It's a simple example to implement TCP Client/Server in Java. To test the function, start JavaTCPServer with port number in Terminal. The server will open a ServerSocket and wait for incoming message from client. Then start JavaTCPClient with IP address and port number in another Terminal, then enter anything. The user input will be sent to JavaTCPServer via TCP socket, when JavaTCPServer receive the message, it will echo back to JavaTCPClient, then both JavaTCPServer and JavaTCPClient close the socket.


JavaTCPServer.java

package javatcpserver;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
 *
 * @web http://java-buddy.blogspot.com/
 */
public class JavaTCPServer {
 private static int port;
 private static ServerSocket serverSocket;
 public static void main(String[] args) {
 if (args.length != 1) {
 System.out.println("usage: java -jar JavaTCPServer.jar <port>");
 System.exit(1);
 }
 port = Integer.parseInt(args[0]);
 System.out.println("Port: " + port);
 Socket socket = null;
 try {
 serverSocket = new ServerSocket(port);
 socket = serverSocket.accept();
 Scanner scanner = new Scanner(socket.getInputStream());
 PrintWriter printWriter = new PrintWriter(socket.getOutputStream(), true);
 String line = scanner.nextLine();
 System.out.println("received: " + line);
 printWriter.println("echo: " + line);
 } catch (IOException ex) {
 Logger.getLogger(JavaTCPServer.class.getName()).log(Level.SEVERE, null, ex);
 } finally {
 if (socket != null) {
 try {
 socket.close();
 } catch (IOException ex) {
 Logger.getLogger(JavaTCPServer.class.getName()).log(Level.SEVERE, null, ex);
 }
 }
 }
 }
}

JavaTCPClient.java

package javatcpclient;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
 *
 * @web http://java-buddy.blogspot.com/
 */
public class JavaTCPClient {
 public static void main(String[] args) {
 if (args.length != 2) {
 System.out.println("usage: java -jar JavaTCPClient.jar <IP address> <port>");
 System.exit(1);
 }
 
 Socket socket = null;
 try {
 InetAddress inetAddress = InetAddress.getByName(args[0]);
 int port = Integer.parseInt(args[1]);
 
 socket = new Socket(inetAddress, port);
 System.out.println("InetAddress: " + inetAddress);
 System.out.println("Port: " + port);
 
 Scanner scanner = new Scanner(socket.getInputStream());
 PrintWriter printWriter = new PrintWriter(socket.getOutputStream(), true);
 
 Scanner userScanner = new Scanner(System.in);
 String userInput = userScanner.nextLine();
 
 printWriter.println(userInput);
 String serverEcho = scanner.nextLine();
 System.out.println(serverEcho);
 } catch (UnknownHostException ex) {
 Logger.getLogger(JavaTCPClient.class.getName()).log(Level.SEVERE, null, ex);
 } catch (IOException ex) {
 Logger.getLogger(JavaTCPClient.class.getName()).log(Level.SEVERE, null, ex);
 } finally {
 if( socket != null){
 try {
 socket.close();
 } catch (IOException ex) {
 Logger.getLogger(JavaTCPClient.class.getName()).log(Level.SEVERE, null, ex);
 }
 }
 }
 }
 
}

---

Compare with: Simple example of UDP Client/Server communication

• InetAddress.getLocalHost() returns the address of the local host. This is achieved by retrieving the name of the host from the system, then resolving that name into an InetAddress.

package javaexnetworking;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
 *
 * @web http://java-buddy.blogspot.com/
 */
public class JavaExNetworking {
 
 public static void main(String[] args) {
 try {
 InetAddress localHostAddress = InetAddress.getLocalHost();
 System.out.println(localHostAddress);
 } catch (UnknownHostException ex) {
 Logger.getLogger(JavaExNetworking.class.getName()).log(Level.SEVERE, null, ex);
 }
 }
 
}

• InetAddress.getByName(String host) return the IP address of a host, given the host's name.
• InetAddress.getAllByName(String host) returns an array of its IP addresses, based on the configured name service on the system.

package javaexnetworking;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
 *
 * @web http://java-buddy.blogspot.com/
 */
public class JavaExNetworking {
 
 public static void main(String[] args) {
 
 String host = "www.google.com";
 
 System.out.println("by InetAddress.getByName(host):");
 try {
 InetAddress inetAddress = InetAddress.getByName(host);
 System.out.println(inetAddress.toString());
 } catch (UnknownHostException ex) {
 Logger.getLogger(JavaExNetworking.class.getName()).log(Level.SEVERE, null, ex);
 }
 
 System.out.println("\nby InetAddress.getAllByName(host):");
 try {
 InetAddress[] allInetAddress = InetAddress.getAllByName(host);
 for(int i=0; i<allInetAddress.length; i++){
 System.out.println(allInetAddress[i].toString());
 }
 } catch (UnknownHostException ex) {
 Logger.getLogger(JavaExNetworking.class.getName()).log(Level.SEVERE, null, ex);
 }
 }
 
}