support for string/byte protocols

src/de/tudarmstadt/informatik/hostage/HoneyListener.java

@@ -4,12 +4,16 @@ import java.net.ServerSocket;
 import java.net.Socket;
 import java.util.ArrayList;
 
+import de.tudarmstadt.informatik.hostage.handler.AbstractHandler;
+import de.tudarmstadt.informatik.hostage.handler.ByteArrayHandlerImpl;
+import de.tudarmstadt.informatik.hostage.handler.StringHandlerImpl;
 import de.tudarmstadt.informatik.hostage.net.MyServerSocketFactory;
 import de.tudarmstadt.informatik.hostage.protocol.Protocol;
+import de.tudarmstadt.informatik.hostage.wrapper.ByteArray;
 
 public class HoneyListener implements Runnable {
 
-	private ArrayList<HoneyHandler> handlers = new ArrayList<HoneyHandler>();
+	private ArrayList<AbstractHandler> handlers = new ArrayList<AbstractHandler>();
 
 	public int getHandlerCount() {
 		return handlers.size();
@@ -37,7 +41,7 @@ public class HoneyListener implements Runnable {
 		while (!thread.isInterrupted()) {
 			addHandler();
 		}
-		for (HoneyHandler handler : handlers) {
+		for (AbstractHandler handler : handlers) {
 			handler.kill();
 		}
 	}
@@ -70,7 +74,7 @@ public class HoneyListener implements Runnable {
 	}
 
 	public void refreshHandlers() {
-		for (HoneyHandler handler : handlers) {
+		for (AbstractHandler handler : handlers) {
 			if (handler.isTerminated()) {
 				handlers.remove(handler);
 			}
@@ -81,11 +85,22 @@ public class HoneyListener implements Runnable {
 	private void addHandler() {
 		try {
 			Socket client = server.accept();
-			handlers.add(new HoneyHandler(service, this, protocol.getClass()
+			handlers.add(newInstance(service, this, protocol.getClass()
 					.newInstance(), client));
 			service.notifyUI();
 		} catch (Exception e) {
 			e.printStackTrace();
 		}
 	}
+
+	private AbstractHandler newInstance(HoneyService service,
+			HoneyListener listener, Protocol protocol, Socket client) {
+		if (protocol.getType().equals(String.class)) {
+			return new StringHandlerImpl(service, listener, protocol, client);
+		} else if (protocol.getType().equals(ByteArray.class)) {
+			return new ByteArrayHandlerImpl(service, listener, protocol, client);
+		} else {
+			return null;
+		}
+	}
 }

src/de/tudarmstadt/informatik/hostage/handler/AbstractHandler.java

@@ -0,0 +1,88 @@
+package de.tudarmstadt.informatik.hostage.handler;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.Socket;
+
+import de.tudarmstadt.informatik.hostage.HoneyListener;
+import de.tudarmstadt.informatik.hostage.HoneyService;
+import de.tudarmstadt.informatik.hostage.logging.Logger;
+import de.tudarmstadt.informatik.hostage.logging.Record;
+import de.tudarmstadt.informatik.hostage.logging.Record.TYPE;
+import de.tudarmstadt.informatik.hostage.protocol.Protocol;
+
+public abstract class AbstractHandler implements Runnable {
+
+	protected static final int TIMEOUT = 30 * 1000;
+
+	protected Protocol protocol;
+	private Socket client;
+	protected Thread thread;
+
+	private HoneyListener listener;
+	protected Logger log;
+
+	public AbstractHandler(HoneyService service, HoneyListener listener,
+			Protocol protocol, Socket client) {
+		this.listener = listener;
+		this.log = service.getLog();
+		this.protocol = protocol;
+		this.client = client;
+		this.thread = new Thread(this);
+		setSoTimeout(client);
+		thread.start();
+	}
+
+	private void setSoTimeout(Socket client) {
+		try {
+			client.setSoTimeout(TIMEOUT);
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	@Override
+	public void run() {
+		InputStream in;
+		OutputStream out;
+		try {
+			in = client.getInputStream();
+			out = client.getOutputStream();
+			talkToClient(in, out);
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		kill();
+	}
+
+	public void kill() {
+		thread.interrupt();
+		try {
+			client.close();
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		listener.refreshHandlers();
+	}
+
+	public boolean isTerminated() {
+		return thread.isInterrupted();
+	}
+
+	abstract protected void talkToClient(InputStream in, OutputStream out)
+			throws IOException;
+
+	protected Record createRecord(TYPE type, String packet) {
+		Record record = new Record();
+		record.setType(type);
+		record.setTimestamp(System.currentTimeMillis());
+		record.setLocalIP(client.getLocalAddress());
+		record.setLocalPort(protocol.getPort());
+		record.setRemoteIP(client.getInetAddress());
+		record.setRemotePort(client.getPort());
+		record.setPacket(packet);
+		return record;
+	}
+
+}

src/de/tudarmstadt/informatik/hostage/handler/ByteArrayHandlerImpl.java

@@ -0,0 +1,56 @@
+package de.tudarmstadt.informatik.hostage.handler;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.Socket;
+import java.util.List;
+
+import de.tudarmstadt.informatik.hostage.HoneyListener;
+import de.tudarmstadt.informatik.hostage.HoneyService;
+import de.tudarmstadt.informatik.hostage.io.ByteArrayReaderWriter;
+import de.tudarmstadt.informatik.hostage.io.ReaderWriter;
+import de.tudarmstadt.informatik.hostage.logging.Record.TYPE;
+import de.tudarmstadt.informatik.hostage.protocol.Protocol;
+import de.tudarmstadt.informatik.hostage.protocol.Protocol.TALK_FIRST;
+import de.tudarmstadt.informatik.hostage.wrapper.ByteArray;
+
+public class ByteArrayHandlerImpl extends AbstractHandler {
+
+	public ByteArrayHandlerImpl(HoneyService service, HoneyListener listener,
+			Protocol protocol, Socket client) {
+		super(service, listener, protocol, client);
+	}
+
+	@Override
+	protected void talkToClient(InputStream in, OutputStream out)
+			throws IOException {
+		ReaderWriter<ByteArray> stream = new ByteArrayReaderWriter(in, out);
+
+		ByteArray inputLine;
+		List<ByteArray> outputLine;
+
+		if (protocol.whoTalksFirst() == TALK_FIRST.SERVER) {
+			outputLine = protocol.processMessage(null);
+			stream.write(outputLine);
+			for (ByteArray s : outputLine) {
+				log.write(createRecord(TYPE.SEND, s.toString()));
+			}
+		}
+
+		while (!thread.isInterrupted() && (inputLine = stream.read()) != null) {
+			log.write(createRecord(TYPE.RECEIVE, inputLine.toString()));
+			outputLine = protocol.processMessage(inputLine);
+			if (outputLine != null) {
+				stream.write(outputLine);
+				for (ByteArray s : outputLine) {
+					log.write(createRecord(TYPE.SEND, s.toString()));
+				}
+			}
+			if (protocol.isClosed()) {
+				break;
+			}
+		}
+	}
+
+}

src/de/tudarmstadt/informatik/hostage/handler/StringHandlerImpl.java

@@ -0,0 +1,55 @@
+package de.tudarmstadt.informatik.hostage.handler;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.Socket;
+import java.util.List;
+
+import de.tudarmstadt.informatik.hostage.HoneyListener;
+import de.tudarmstadt.informatik.hostage.HoneyService;
+import de.tudarmstadt.informatik.hostage.io.ReaderWriter;
+import de.tudarmstadt.informatik.hostage.io.StringReaderWriter;
+import de.tudarmstadt.informatik.hostage.logging.Record.TYPE;
+import de.tudarmstadt.informatik.hostage.protocol.Protocol;
+import de.tudarmstadt.informatik.hostage.protocol.Protocol.TALK_FIRST;
+
+public class StringHandlerImpl extends AbstractHandler {
+
+	public StringHandlerImpl(HoneyService service, HoneyListener listener,
+			Protocol protocol, Socket client) {
+		super(service, listener, protocol, client);
+	}
+
+	@Override
+	protected void talkToClient(InputStream in, OutputStream out)
+			throws IOException {
+		ReaderWriter<String> stream = new StringReaderWriter(in, out);
+
+		String inputLine;
+		List<String> outputLine;
+
+		if (protocol.whoTalksFirst() == TALK_FIRST.SERVER) {
+			outputLine = protocol.processMessage(null);
+			stream.write(outputLine);
+			for (String s : outputLine) {
+				log.write(createRecord(TYPE.SEND, s));
+			}
+		}
+
+		while (!thread.isInterrupted() && (inputLine = stream.read()) != null) {
+			log.write(createRecord(TYPE.RECEIVE, inputLine));
+			outputLine = protocol.processMessage(inputLine);
+			if (outputLine != null) {
+				stream.write(outputLine);
+				for (String s : outputLine) {
+					log.write(createRecord(TYPE.SEND, s));
+				}
+			}
+			if (protocol.isClosed()) {
+				break;
+			}
+		}
+	}
+
+}

src/de/tudarmstadt/informatik/hostage/io/ByteArrayReaderWriter.java

@@ -0,0 +1,39 @@
+package de.tudarmstadt.informatik.hostage.io;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.List;
+
+import de.tudarmstadt.informatik.hostage.wrapper.ByteArray;
+
+public class ByteArrayReaderWriter implements ReaderWriter<ByteArray> {
+
+	private BufferedInputStream in;
+	private BufferedOutputStream out;
+
+	public ByteArrayReaderWriter(InputStream in, OutputStream out) {
+		this.in = new BufferedInputStream(in);
+		this.out = new BufferedOutputStream(out);
+	}
+
+	@Override
+	public ByteArray read() throws IOException {
+		int availableBytes;
+		while ((availableBytes = in.available()) <= 0)
+			;
+		byte[] buffer = new byte[availableBytes];
+		in.read(buffer);
+		return new ByteArray(buffer);
+	}
+
+	@Override
+	public void write(List<ByteArray> message) throws IOException {
+		for (ByteArray m : message) {
+			out.write(m.get());
+		}
+	}
+
+}

src/de/tudarmstadt/informatik/hostage/io/ReaderWriter.java

@@ -0,0 +1,12 @@
+package de.tudarmstadt.informatik.hostage.io;
+
+import java.io.IOException;
+import java.util.List;
+
+public interface ReaderWriter<T> {
+
+	T read() throws IOException;
+
+	void write(List<T> outputLine) throws IOException;
+
+}

src/de/tudarmstadt/informatik/hostage/io/StringReaderWriter.java

@@ -0,0 +1,36 @@
+package de.tudarmstadt.informatik.hostage.io;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.util.List;
+
+public class StringReaderWriter implements ReaderWriter<String> {
+
+	private BufferedReader in;
+	private BufferedWriter out;
+
+	public StringReaderWriter(InputStream in, OutputStream out) {
+		this.in = new BufferedReader(new InputStreamReader(in));
+		this.out = new BufferedWriter(new OutputStreamWriter(out));
+
+	}
+
+	@Override
+	public String read() throws IOException {
+		return in.readLine();
+	}
+
+	@Override
+	public void write(List<String> message) throws IOException {
+		for (String m : message) {
+			out.write(m + "\n");
+			out.flush();
+		}
+	}
+
+}

src/de/tudarmstadt/informatik/hostage/protocol/FTP.java

@@ -4,7 +4,7 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.regex.Pattern;
 
-public final class FTP implements Protocol {
+public final class FTP implements Protocol<String> {
 
 	private static enum STATE {
 		NONE, OPEN, CLOSED, USER, LOGGED_IN
@@ -14,7 +14,7 @@ public final class FTP implements Protocol {
 
 	@Override
 	public int getPort() {
-		return 8021;
+		return 21;
 	}
 
 	@Override
@@ -23,65 +23,59 @@ public final class FTP implements Protocol {
 	}
 
 	@Override
-	public List<byte[]> processMessage(byte[] message) {
-		String request = new String(message);
-		List<byte[]> response = new ArrayList<byte[]>();
+	public List<String> processMessage(String message) {
+		List<String> response = new ArrayList<String>();
 		switch (state) {
 		case NONE:
 			if (message == null) {
 				state = STATE.OPEN;
-				response.add("220 Service ready for new user.".getBytes());
+				response.add("220 Service ready for new user.");
 			} else {
 				state = STATE.CLOSED;
-				response.add("421 Service not available, closing control connection."
-						.getBytes());
+				response.add("421 Service not available, closing control connection.");
 			}
 			break;
 		case OPEN:
-			if (Pattern.matches("^QUIT\\s?", request)) {
+			if (Pattern.matches("^QUIT\\s?", message)) {
 				state = STATE.CLOSED;
 				return null;
-			} else if (Pattern.matches("^USER (\\w)+$", request)) {
+			} else if (Pattern.matches("^USER (\\w)+$", message)) {
 				state = STATE.USER;
-				response.add("331 User name ok, need password.".getBytes());
-			} else if (message != null && Pattern.matches("^USER\\s?", request)) {
-				response.add("530 Not logged in.".getBytes());
-			} else if (message != null && Pattern.matches("^USER.*", request)) {
-				response.add("501 Syntax error in parameters or arguments"
-						.getBytes());
+				response.add("331 User name ok, need password.");
+			} else if (message != null && Pattern.matches("^USER\\s?", message)) {
+				response.add("530 Not logged in.");
+			} else if (message != null && Pattern.matches("^USER.*", message)) {
+				response.add("501 Syntax error in parameters or arguments");
 			} else {
-				response.add("332 Need account for login.".getBytes());
+				response.add("332 Need account for login.");
 			}
 			break;
 		case USER:
-			if (Pattern.matches("^PASS (\\S)+$", request)) {
+			if (Pattern.matches("^PASS (\\S)+$", message)) {
 				state = STATE.LOGGED_IN;
-				response.add("230 User logged in.".getBytes());
-			} else if (Pattern.matches("^PASS.*", request)) {
+				response.add("230 User logged in.");
+			} else if (Pattern.matches("^PASS.*", message)) {
 				state = STATE.OPEN;
-				response.add("501 Syntax error in parameters or arguments"
-						.getBytes());
+				response.add("501 Syntax error in parameters or arguments");
 			} else {
 				state = STATE.CLOSED;
-				response.add("221 Service closing control connection."
-						.getBytes());
+				response.add("221 Service closing control connection.");
 			}
 			break;
 		case LOGGED_IN:
-			if (Pattern.matches("^QUIT\\s?", request)) {
+			if (Pattern.matches("^QUIT\\s?", message)) {
 				state = STATE.CLOSED;
+				response.add("221 Service closing control connection.");
 			} else if (message != null) {
-				response.add("502 Command not implemented.".getBytes());
+				response.add("502 Command not implemented.");
 			} else {
 				state = STATE.CLOSED;
-				response.add("221 Service closing control connection."
-						.getBytes());
+				response.add("221 Service closing control connection.");
 			}
 			break;
 		default:
 			state = STATE.CLOSED;
-			response.add("421 Service not available, closing control connection."
-					.getBytes());
+			response.add("421 Service not available, closing control connection.");
 		}
 		return response;
 	}
@@ -91,6 +85,16 @@ public final class FTP implements Protocol {
 		return (state == STATE.CLOSED);
 	}
 
+	@Override
+	public boolean isSecure() {
+		return false;
+	}
+
+	@Override
+	public Class<String> getType() {
+		return String.class;
+	}
+
 	@Override
 	public String toString() {
 		return "FTP";

src/de/tudarmstadt/informatik/hostage/protocol/HTTP.java

@@ -4,11 +4,11 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.regex.Pattern;
 
-public final class HTTP implements Protocol {
+public final class HTTP implements Protocol<String> {
 
 	@Override
 	public int getPort() {
-		return 8080;
+		return 80;
 	}
 
 	@Override
@@ -17,23 +17,31 @@ public final class HTTP implements Protocol {
 	}
 
 	@Override
-	public List<byte[]> processMessage(byte[] message) {
-		String request = new String(message);
-		List<byte[]> response = new ArrayList<byte[]>();
-		String r = new String(request);
-		if (Pattern.matches("^HEAD\\s?", r)) {
-			response.add(buildHeader().getBytes());
-		} else if (Pattern.matches("^GET\\s?", r)) {
-			response.add((buildHeader() + buildPage()).getBytes());
+	public List<String> processMessage(String message) {
+		List<String> response = new ArrayList<String>();
+		if (Pattern.matches("^HEAD\\s?", message)) {
+			response.add(buildHeader());
+		} else if (Pattern.matches("^GET\\s?", message)) {
+			response.add((buildHeader() + buildPage()));
 		} else {
-			response.add("HTTP/1.1 501 Not Implemented".getBytes());
+			response.add("HTTP/1.1 501 Not Implemented");
 		}
 		return response;
 	}
 
 	@Override
 	public boolean isClosed() {
-		return true;
+		return false;
+	}
+
+	@Override
+	public boolean isSecure() {
+		return false;
+	}
+
+	@Override
+	public Class<String> getType() {
+		return String.class;
 	}
 
 	@Override

src/de/tudarmstadt/informatik/hostage/protocol/Protocol.java

@@ -2,7 +2,7 @@ package de.tudarmstadt.informatik.hostage.protocol;
 
 import java.util.List;
 
-public interface Protocol {
+public interface Protocol<T> {
 
 	public static enum TALK_FIRST {
 		SERVER, CLIENT
@@ -12,8 +12,12 @@ public interface Protocol {
 
 	TALK_FIRST whoTalksFirst();
 
-	List<byte[]> processMessage(byte[] message);
+	List<T> processMessage(T message);
 
 	boolean isClosed();
 
+	boolean isSecure();
+
+	Class<T> getType();
+
 }

src/de/tudarmstadt/informatik/hostage/protocol/SMB.java

@@ -7,7 +7,9 @@ import java.util.List;
 import java.util.Random;
 import java.util.TimeZone;
 
-public final class SMB implements Protocol {
+import de.tudarmstadt.informatik.hostage.wrapper.ByteArray;
+
+public final class SMB implements Protocol<ByteArray> {
 
 	private static enum STATE {
 		NONE, CONNECTED, AUTHENTICATED, LISTING, DISCONNECTED, CLOSED
@@ -17,7 +19,7 @@ public final class SMB implements Protocol {
 
 	@Override
 	public int getPort() {
-		return 8445;
+		return 445;
 	}
 
 	@Override
@@ -26,72 +28,73 @@ public final class SMB implements Protocol {
 	}
 
 	@Override
-	public List<byte[]> processMessage(byte[] message) {
-		SmbPacket packet = new SmbPacket(message);
+	public List<ByteArray> processMessage(ByteArray message) {
+		byte[] primitiveByteArray = message.get();
+		SmbPacket packet = new SmbPacket(primitiveByteArray);
 		byte smbCommand = packet.getSmbCommand();
-		List<byte[]> response = new ArrayList<byte[]>();
+		List<ByteArray> response = new ArrayList<ByteArray>();
 		switch (state) {
 		case NONE:
 			if (smbCommand == 0x72) {
 				state = STATE.CONNECTED;
-				response.add(packet.getNego());
+				response.add(new ByteArray(packet.getNego()));
 			} else {
 				state = STATE.DISCONNECTED;
-				response.add(packet.getTreeDisc());
+				response.add(new ByteArray(packet.getTreeDisc()));
 			}
 			break;
 		case CONNECTED:
 			if (smbCommand == 0x73) {
-				response.add(packet.getSessSetup());
+				response.add(new ByteArray(packet.getSessSetup()));
 			} else if (smbCommand == 0x75) {
 				state = STATE.AUTHENTICATED;
-				response.add(packet.getTreeCon());
+				response.add(new ByteArray(packet.getTreeCon()));
 			} else {
 				state = STATE.DISCONNECTED;
-				response.add(packet.getTreeDisc());
+				response.add(new ByteArray(packet.getTreeDisc()));
 			}
 			break;
 		case AUTHENTICATED:
 			if (smbCommand == (byte) 0xa2) {
 				state = STATE.LISTING;
-				response.add(packet.getNTCreate());
+				response.add(new ByteArray(packet.getNTCreate()));
 			} else if (smbCommand == 0x2b) {
-				response.add(packet.getEcho());
+				response.add(new ByteArray(packet.getEcho()));
 			} else if (smbCommand == 0x32) {
-				response.add(packet.getTrans2());
+				response.add(new ByteArray(packet.getTrans2()));
 			} else if (smbCommand == 0x04) {
-				response.add(packet.getClose());
+				response.add(new ByteArray(packet.getClose()));
 			} else if (smbCommand == 0x71) {
 				state = STATE.CLOSED;
-				response.add(packet.getTreeDisc());
+				response.add(new ByteArray(packet.getTreeDisc()));
 			} else {
 				state = STATE.DISCONNECTED;
-				response.add(packet.getTreeDisc());
+				response.add(new ByteArray(packet.getTreeDisc()));
 			}
 			break;
 		case LISTING:
 			if (smbCommand == 0x25) {
-				response.add(packet.getTrans());
+				response.add(new ByteArray(packet.getTrans()));
 			} else if (smbCommand == 0x04) {
-				response.add(packet.getClose());
+				response.add(new ByteArray(packet.getClose()));
 			} else if (smbCommand == 0x71) {
 				state = STATE.CLOSED;
-				response.add(packet.getTreeDisc());
+				response.add(new ByteArray(packet.getTreeDisc()));
 			} else if (smbCommand == 0x72) {
 				state = STATE.CONNECTED;
-				response.add(packet.getNego());
+				response.add(new ByteArray(packet.getNego()));
 			} else {
 				state = STATE.DISCONNECTED;
-				response.add(packet.getTreeDisc());
+				response.add(new ByteArray(packet.getTreeDisc()));
 			}
 			break;
 		case DISCONNECTED:
 			state = STATE.CLOSED;
-			response.add(packet.getTreeDisc());
+			response.add(new ByteArray(packet.getTreeDisc()));
 			break;
 		default:
 			state = STATE.CLOSED;
-			response.add(packet.getTreeDisc());
+			response.add(new ByteArray(packet.getTreeDisc()));
 		}
 		return response;
 	}
@@ -101,6 +104,16 @@ public final class SMB implements Protocol {
 		return (state == STATE.CLOSED);
 	}
 
+	@Override
+	public boolean isSecure() {
+		return false;
+	}
+
+	@Override
+	public Class<ByteArray> getType() {
+		return ByteArray.class;
+	}
+
 	@Override
 	public String toString() {
 		return "SMB";

src/de/tudarmstadt/informatik/hostage/protocol/SSH.java

@@ -3,7 +3,7 @@ package de.tudarmstadt.informatik.hostage.protocol;
 import java.util.ArrayList;
 import java.util.List;
 
-public final class SSH implements Protocol {
+public final class SSH implements Protocol<String> {
 
 	private static enum STATE {
 		NONE, OPEN, CLOSED
@@ -13,7 +13,7 @@ public final class SSH implements Protocol {
 
 	@Override
 	public int getPort() {
-		return 8022;
+		return 22;
 	}
 
 	@Override
@@ -22,8 +22,9 @@ public final class SSH implements Protocol {
 	}
 
 	@Override
-	public List<byte[]> processMessage(byte[] message) {
-		List<byte[]> response = new ArrayList<byte[]>();
+	public List<String> processMessage(String message) {
+		ArrayList<String> response = new ArrayList<String>();
+		response.add("Not implemented yet!");
 		return response;
 	}
 
@@ -32,6 +33,16 @@ public final class SSH implements Protocol {
 		return (state == STATE.CLOSED);
 	}
 
+	@Override
+	public boolean isSecure() {
+		return false;
+	}
+
+	@Override
+	public Class<String> getType() {
+		return String.class;
+	}
+
 	@Override
 	public String toString() {
 		return "SSH";

src/de/tudarmstadt/informatik/hostage/protocol/TELNET.java

@@ -3,7 +3,9 @@ package de.tudarmstadt.informatik.hostage.protocol;
 import java.util.ArrayList;
 import java.util.List;
 
-public final class TELNET implements Protocol {
+import de.tudarmstadt.informatik.hostage.wrapper.ByteArray;
+
+public final class TELNET implements Protocol<ByteArray> {
 
 	private static enum STATE {
 		NONE, OPEN, CLOSED, LOGIN, AUTHENTICATE, LOGGED_IN
@@ -16,7 +18,7 @@ public final class TELNET implements Protocol {
 
 	@Override
 	public int getPort() {
-		return 8023;
+		return 23;
 	}
 
 	@Override
@@ -25,45 +27,47 @@ public final class TELNET implements Protocol {
 	}
 
 	@Override
-	public List<byte[]> processMessage(byte[] message) {
-		List<byte[]> response = new ArrayList<byte[]>();
+	public List<ByteArray> processMessage(ByteArray message) {
+		List<ByteArray> response = new ArrayList<ByteArray>();
 		switch (state) {
 		case NONE:
-			response.add(cmdRequests);
-			response.add(getCmdResponses(message));
+			response.add(new ByteArray(cmdRequests));
+			response.add(new ByteArray(getCmdResponses(message.get())));
 			state = STATE.OPEN;
 			break;
 		case OPEN:
-			response.add("Debian GNU/Linux 7.0\r\n".getBytes());
-			response.add("raspberrypi login: ".getBytes());
+			response.add(new ByteArray("Debian GNU/Linux 7.0\r\n".getBytes()));
+			response.add(new ByteArray("raspberrypi login: ".getBytes()));
 			state = STATE.LOGIN;
 			break;
 		case LOGIN:
-			usr = java.util.Arrays.copyOfRange(message, 0, message.length - 2);
-			response.add("Password: ".getBytes());
+			usr = java.util.Arrays.copyOfRange(message.get(), 0,
+					message.size() - 2);
+			response.add(new ByteArray("Password: ".getBytes()));
 			state = STATE.AUTHENTICATE;
 			break;
 		case AUTHENTICATE:
-			response.add("Last Login: \r\nLinux raspberrypi 3.6.11+\r\n"
-					.getBytes());
-			response.add(concatenate(a, usr, b, usr, c));
+			response.add(new ByteArray(
+					"Last Login: \r\nLinux raspberrypi 3.6.11+\r\n".getBytes()));
+			response.add(new ByteArray(concatenate(a, usr, b, usr, c)));
 			state = STATE.LOGGED_IN;
 			break;
 		case LOGGED_IN:
-			cmd = java.util.Arrays.copyOfRange(message, 0, message.length - 2);
+			cmd = java.util.Arrays.copyOfRange(message.get(), 0,
+					message.size() - 2);
 			if (new String(cmd).contains("exit")) {
-				response.add("logout\r\n".getBytes());
+				response.add(new ByteArray("logout\r\n".getBytes()));
 				state = STATE.CLOSED;
 			} else {
 				String bash = "-bash: " + new String(cmd)
 						+ ": command not found";
-				response.add(bash.getBytes());
-				response.add("\r\n".getBytes());
-				response.add(concatenate(a, usr, b, usr, c));
+				response.add(new ByteArray(bash.getBytes()));
+				response.add(new ByteArray("\r\n".getBytes()));
+				response.add(new ByteArray(concatenate(a, usr, b, usr, c)));
 			}
 			break;
 		default:
-			response.add("\r\nlogout\r\n".getBytes());
+			response.add(new ByteArray("\r\nlogout\r\n".getBytes()));
 			state = STATE.CLOSED;
 			break;
 		}
@@ -75,6 +79,16 @@ public final class TELNET implements Protocol {
 		return (state == STATE.CLOSED);
 	}
 
+	@Override
+	public boolean isSecure() {
+		return false;
+	}
+
+	@Override
+	public Class<ByteArray> getType() {
+		return ByteArray.class;
+	}
+
 	@Override
 	public String toString() {
 		return "TELNET";

src/de/tudarmstadt/informatik/hostage/wrapper/ByteArray.java

@@ -0,0 +1,28 @@
+package de.tudarmstadt.informatik.hostage.wrapper;
+
+public class ByteArray {
+
+	private final byte[] array;
+
+	public ByteArray() {
+		this.array = null;
+	}
+
+	public ByteArray(byte[] array) {
+		this.array = array;
+	}
+
+	public byte[] get() {
+		return array;
+	}
+
+	public int size() {
+		return array.length;
+	}
+
+	@Override
+	public String toString() {
+		return new String(array);
+	}
+
+}