Seguridad en Sistemas y Técnicas de Hacking. TheHackerWay (THW)

			
package net.privanon.common; 
public class UserInfo implements java.io.Serializable { 
	private String username; 
	private String name; 
	private String lastname; 
	private Integer age; 
	private String privateMessage;	 
	public void setUsername(String username) { 
		this.username = username; 
	} 
			
	public void setName(String name) { 
		this.name = name; 
	} 
	public void setLastname(String lastname) { 
		this.lastname = lastname; 
	} 
	public void setAge(Integer age) { 
		this.age = age; 
	} 
	public void setPrivateMessage(String privateMessage) { 
		this.privateMessage = privateMessage; 
	} 
	public String getUsername() { 
		return this.username; 
	} 
	public String getName() { 
		return this.name; 
	} 
	public String getLastname() { 
		return this.lastname; 
	} 
			
	public Integer getAge() { 
		return this.age; 
	} 
	public String getPrivateMessage() { 
		return this.privateMessage; 
	} 
} 

package testing.i2p; 
import java.io.IOException; 
import java.io.InputStream; 
import java.io.OutputStream; 
import java.io.OutputStreamWriter; 
import java.io.InputStreamReader; 
import java.io.BufferedReader; 
import java.io.BufferedWriter; 
import java.io.ObjectOutputStream; 
import java.io.ObjectInputStream; 
import java.net.ConnectException; 
import java.net.SocketTimeoutException; 
import net.i2p.I2PException; 
import net.i2p.client.streaming.I2PSocket; 
import net.i2p.util.I2PThread; 
import net.i2p.client.I2PSession; 
import net.i2p.client.streaming.I2PServerSocket; 
import net.i2p.client.streaming.I2PSocketManager; 
import net.i2p.client.streaming.I2PSocketManagerFactory; 
import net.i2p.client.I2PSessionException; 
import net.privanon.common; 
			
public class Server { 
    public static void main(String[] args) { 
        I2PSocketManager manager =
			I2PSocketManagerFactory.createManager(); 
        I2PServerSocket serverSocket =
			manager.getServerSocket(); 
        I2PSession session = manager.getSession(); 
	System.out.println(session.getMyDestination().toBase64()); 
        I2PThread t = new I2PThread(new
			ClientHandler(serverSocket)); 
        t.setName("clienthandler1"); 
        t.setDaemon(false); 
        t.start(); 
    } 
			
    private static class ClientHandler implements Runnable { 
        public ClientHandler(I2PServerSocket socket) { 
            this.socket = socket; 
        } 
			
        public void run() { 
            while(true) { 
                try { 
                    I2PSocket sock = this.socket.accept(); 
                    if(sock != null) { 
			    ObjectOutputStream oos = new
			ObjectOutputStream(sock.getOutputStream()); 
			    ObjectInputStream ois = new
			ObjectInputStream(sock.getInputStream()); 
				UserInfo info = null; 
			    while ((info = (UserInfo) ois.readObject()) != null) { 
				      if(info != null && info.getUsername() != null
			&& info.getUsername().equals("Adastra")) { 
						UserInfo response = new UserInfo(); 
				   	        response.setName("unknown"); 
					        response.setLastname("unknown"); 
  					        response.setUsername("unknown"); 
					        response.setAge(0); 
					        response.setPrivateMessage("Send the report
			and close the operation");				 
						oos.writeObject(response);		 
 				       } 
			    } 
			    ois.close(); 
			    oos.close(); 
			    sock.close(); 
                    } 
                } catch (I2PException ex) { 
                    System.out.println("General I2P
			exception!"); 
                } catch (ConnectException ex) { 
                    System.out.println("Error
			connecting!"); 
                } catch (SocketTimeoutException ex) { 
                    System.out.println("Timeout!"); 
                } catch (IOException ex) { 
                    System.out.println("General
			read/write-exception!"); 
                } catch (ClassNotFoundException ex) { 
                    System.out.println("Class Not found
			exception!"); 
                } 
            } 
        } 
        private I2PServerSocket socket; 
    } 
} 

package testing.i2p; 
import java.io.BufferedReader; 
import java.io.BufferedWriter; 
import java.io.IOException; 
import java.io.InputStreamReader; 
import java.io.InterruptedIOException; 
import java.io.OutputStream; 
import java.io.OutputStreamWriter; 
import java.net.ConnectException; 
import java.net.NoRouteToHostException; 
import net.i2p.I2PException; 
import net.i2p.client.streaming.I2PSocket; 
import net.i2p.client.streaming.I2PSocketManager; 
import net.i2p.client.streaming.I2PSocketManagerFactory; 
import net.i2p.data.DataFormatException; 
import net.i2p.data.Destination; 
import java.io.ObjectOutputStream; 
import java.io.ObjectInputStream; 
import net.privanon.common; 
			
public class Client { 
    public static void main(String[] args) { 
        I2PSocketManager manager =
			I2PSocketManagerFactory.createManager(); 
        System.out.println("Please enter a Destination:");
        BufferedReader br = new BufferedReader(new
			InputStreamReader(System.in)); 
        String destinationString; 
        try { 
            destinationString = br.readLine(); 
        } catch (IOException ex) { 
            System.out.println("Failed to get a
			Destination string."); 
            return; 
        } 
        Destination destination; 
        try { 
            destination = new Destination(destinationString); 
        } catch (DataFormatException ex) { 
            System.out.println("Destination string
			incorrectly formatted."); 
            return; 
        } 
        I2PSocket socket; 
        try { 
            socket = manager.connect(destination); 
        } catch (I2PException ex) { 
            System.out.println("General I2P exception
			occurred!"); 
            return; 
        } catch (ConnectException ex) { 
            System.out.println("Failed to connect!");
            return; 
        } catch (NoRouteToHostException ex) { 
            System.out.println("Couldn't find host!");
            return; 
        } catch (InterruptedIOException ex) { 
            System.out.println("Sending/receiving was
			interrupted!"); 
            return; 
        } 
        try { 
	    ObjectOutputStream oos = new
			ObjectOutputStream(socket.getOutputStream()); 
   	    UserInfo info = new UserInfo(); 
   	    info.setName("Ad"); 
            info.setLastname("Astra"); 
            info.setUsername("Adastra"); 
            info.setAge(30); 
            info.setPrivateMessage("exposure done. Waiting
			for indications"); 
	    oos.writeObject(info); 
	   ObjectInputStream ois = new
			ObjectInputStream(socket.getInputStream()); 
		UserInfo response = null; 
	    while ((response = (UserInfo) ois.readObject()) != null) {
		      System.out.println("Name: "+
			response.getName()); 
		      System.out.println("Last Name: "+
			response.getLastname()); 
		      System.out.println("Username: "+
			response.getUsername()); 
		      System.out.println("Age: "+
			response.getAge()); 
		      System.out.println("Private message: "+
			response.getPrivateMessage()); 
	    } 
	    ois.close(); 
oos.close(); 
	    socket.close(); 
        } catch (IOException ex) { 
            System.out.println("Error occurred while
			sending/receiving!"); 
        }  catch (ClassNotFoundException ex) { 
                    System.out.println("Class Not found
			exception!"); 
                } 
    } 
}