diff --git a/msf/.gitignore b/msf/.gitignore
new file mode 100644
index 0000000000..796b96d1c4
--- /dev/null
+++ b/msf/.gitignore
@@ -0,0 +1 @@
+/build
diff --git a/msf/build.gradle b/msf/build.gradle
new file mode 100644
index 0000000000..079b7cd5b2
--- /dev/null
+++ b/msf/build.gradle
@@ -0,0 +1,10 @@
+apply plugin: 'java'
+
+dependencies {
+    compile fileTree(dir: 'libs', include: ['*.jar'])
+    testCompile 'junit:junit:4.12'
+    compile 'commons-io:commons-io:2.4'
+    compile 'org.apache.commons:commons-lang3:3.4'
+    compile 'commons-codec:commons-codec:1.10'
+    compile 'org.msgpack:msgpack:0.6.12'
+}
\ No newline at end of file
diff --git a/msf/src/main/java/org/csploit/msf/api/Arch.java b/msf/src/main/java/org/csploit/msf/api/Arch.java
new file mode 100644
index 0000000000..f59b479b40
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/Arch.java
@@ -0,0 +1,32 @@
+package org.csploit.msf.api;
+
+/**
+ * Machines architectures
+ *
+ * source: lib/rex/constants.rb
+ */
+public enum Arch {
+  ANY,
+  X86,
+  X86_64,
+  X64,
+  MIPS,
+  MIPSLE,
+  MIPSBE,
+  PPC,
+  PPC64,
+  CBEA,
+  CBEA64,
+  SPARC,
+  CMD,
+  PHP,
+  TTY,
+  ARMLE,
+  ARMBE,
+  JAVA,
+  RUBY,
+  DALVIK,
+  PYTHON,
+  NODEJS,
+  FIREFOX
+}
\ No newline at end of file
diff --git a/msf/src/main/java/org/csploit/msf/api/Author.java b/msf/src/main/java/org/csploit/msf/api/Author.java
new file mode 100644
index 0000000000..19e97553ae
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/Author.java
@@ -0,0 +1,9 @@
+package org.csploit.msf.api;
+
+/**
+ * Represent an author
+ */
+public interface Author {
+  String getName();
+  String getEmail();
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/Auxiliary.java b/msf/src/main/java/org/csploit/msf/api/Auxiliary.java
new file mode 100644
index 0000000000..6b49227516
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/Auxiliary.java
@@ -0,0 +1,14 @@
+package org.csploit.msf.api;
+
+import org.csploit.msf.api.module.AuxiliaryAction;
+
+/**
+ * The auxiliary class acts as a base class for all modules that perform
+ * reconnaissance, retrieve data, brute force logins, or any other action
+ * that doesn't fit our concept of an 'exploit' (involving payloads and
+ * targets and whatnot).
+ */
+public interface Auxiliary extends Module, Executable {
+  AuxiliaryAction[] getActions();
+  AuxiliaryAction getDefaultAction();
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/Console.java b/msf/src/main/java/org/csploit/msf/api/Console.java
new file mode 100644
index 0000000000..8145fe9e95
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/Console.java
@@ -0,0 +1,56 @@
+package org.csploit.msf.api;
+
+import org.csploit.msf.api.sessions.Interactive;
+
+import java.io.IOException;
+
+/**
+ * A console interface to a Msf instance
+ */
+public interface Console extends Interactive {
+  /**
+   * get the ID of the console
+   * @return the console ID
+   */
+  int getId();
+
+  /**
+   * get the prompt of the console
+   * @return a string that should be used as prompt for new commands
+   */
+  String getPrompt();
+
+  /**
+   * get the console busy state
+   * @return {@code true} if the console is busy, {@code false} otherwise
+   */
+  boolean isBusy();
+
+  /**
+   * close this console
+   */
+  void close() throws IOException, MsfException;
+
+  /**
+   * write to this console
+   * @param data the data to write
+   */
+  void write(String data) throws IOException, MsfException;
+
+  /**
+   * get tab completion for a command
+   * @param part  partial command to complete
+   * @return an array of possibilities
+   */
+  String[] tab(String part) throws IOException, MsfException;
+
+  /**
+   * kill the session attached to this console, if any
+   */
+  void killSession() throws IOException, MsfException;
+
+  /**
+   * detach from an attached session, if any
+   */
+  void detachSession() throws IOException, MsfException;
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/ConsoleManager.java b/msf/src/main/java/org/csploit/msf/api/ConsoleManager.java
new file mode 100644
index 0000000000..574fc6526b
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/ConsoleManager.java
@@ -0,0 +1,64 @@
+package org.csploit.msf.api;
+
+import org.csploit.msf.api.exceptions.ResourceNotFoundException;
+import org.csploit.msf.api.listeners.ConsoleListener;
+
+import java.io.IOException;
+import java.util.List;
+
+/**
+ * Manage consoles
+ */
+public interface ConsoleManager extends Publisher<ConsoleListener> {
+  /**
+   * get a list of consoles managed by this {@link ConsoleManager}
+   * @return a list of consoles managed by this {@link ConsoleManager}
+   */
+  List<? extends Console> getConsoles() throws IOException, MsfException;
+
+  /**
+   * get a console by it's id
+   * @param id of the console
+   * @return the console with the supplied id
+   * @throws ResourceNotFoundException when a console with
+   *          the specified {@code id} cannot be found
+   */
+  Console getConsole(int id) throws IOException, MsfException;
+
+  /**
+   * Create a new console
+   *
+   * @param allowCommandPassthru Whether to allow
+   *                             unrecognized commands to be executed by the system shell
+   * @param realReadline Whether to use the system's
+   *                     readline library instead of RBReadline
+   * @param histFile Path to a file
+   *                 where we can store command history
+   * @param resources A list of resource files to load.
+   *                  If no resources are given, will load the default resource script,
+   *                  'msfconsole.rc' in the user's config directory
+   * @param skipDatabaseInit Whether to skip connecting to the database
+   *                         and running migrations
+   * @return a new {@link Console}
+   */
+  Console create(boolean allowCommandPassthru, boolean realReadline,
+                    String histFile, String[] resources, boolean skipDatabaseInit)
+  throws IOException, MsfException;
+
+  /**
+   * Create a new Console using framework defaults settings
+   *
+   * @return a new {@link Console}
+   */
+  Console create() throws IOException, MsfException;
+
+  /**
+   * start watching for consoles output
+   */
+  void start();
+
+  /**
+   * stop watching for consoles output
+   */
+  void stop();
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/Customizable.java b/msf/src/main/java/org/csploit/msf/api/Customizable.java
new file mode 100644
index 0000000000..116c949605
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/Customizable.java
@@ -0,0 +1,15 @@
+package org.csploit.msf.api;
+
+import java.io.IOException;
+import java.util.Collection;
+
+/**
+ * An object that can be tuned up
+ * by editing it's options.
+ */
+public interface Customizable {
+  void setOption(String key, String value);
+  Collection<Option> getOptions() throws IOException, MsfException;
+  Collection<String> getInvalidOptions();
+  <T> T getOptionValue(Option<T> option);
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/Executable.java b/msf/src/main/java/org/csploit/msf/api/Executable.java
new file mode 100644
index 0000000000..ba15959412
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/Executable.java
@@ -0,0 +1,10 @@
+package org.csploit.msf.api;
+
+import java.io.IOException;
+
+/**
+ * Something that can be executed
+ */
+public interface Executable {
+  void execute() throws IOException, MsfException;
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/Exploit.java b/msf/src/main/java/org/csploit/msf/api/Exploit.java
new file mode 100644
index 0000000000..4ed38e1c70
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/Exploit.java
@@ -0,0 +1,29 @@
+package org.csploit.msf.api;
+
+import org.csploit.msf.api.module.Target;
+
+import java.io.IOException;
+import java.util.List;
+
+/**
+ * Represent an exploit module
+ */
+public interface Exploit extends Module, Executable {
+  Target[] getTargets();
+
+  /**
+   * Returns the active target for this exploit.  If not target has been
+   * defined, {@code null} is returned. If no target was defined but there is a
+   * default target, that one will be automatically used.
+   * @return the active target for this exploit.
+   */
+  Target getTarget();
+  void setTarget(int i);
+
+  /**
+   * get compatible {@link Payload} for this exploit against the selected target.
+   *
+   * @return a list of compatible {@link Payload}
+   */
+  List<? extends Payload> getCompatiblePayloads() throws IOException, MsfException;
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/Framework.java b/msf/src/main/java/org/csploit/msf/api/Framework.java
new file mode 100644
index 0000000000..6c4189efa4
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/Framework.java
@@ -0,0 +1,20 @@
+package org.csploit.msf.api;
+
+import java.io.IOException;
+import java.util.EventListener;
+import java.util.List;
+
+/**
+ * A Metasploit Framework interface
+ */
+public interface Framework extends Publisher<EventListener> {
+  List<? extends Session> getSessions() throws IOException, MsfException;
+  List<? extends Exploit> getExploits() throws IOException, MsfException;
+  List<? extends Payload> getPayloads() throws IOException, MsfException;
+  List<? extends Post> getPosts() throws IOException, MsfException;
+  Module getModule(String refname) throws IOException, MsfException;
+  List<? extends Job> getJobs() throws IOException, MsfException;
+  Job getJob(int id) throws IOException, MsfException;
+  void setGlobalOption(String key, String value);
+  void unsetGlobalOption(String key);
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/Job.java b/msf/src/main/java/org/csploit/msf/api/Job.java
new file mode 100644
index 0000000000..99334a5c2e
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/Job.java
@@ -0,0 +1,13 @@
+package org.csploit.msf.api;
+
+import java.util.Date;
+
+/**
+ * This class is the representation of an abstract job.
+ */
+public interface Job {
+  int getId();
+  String getName();
+  Date getStartTime();
+  void stop();
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/License.java b/msf/src/main/java/org/csploit/msf/api/License.java
new file mode 100644
index 0000000000..205820807d
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/License.java
@@ -0,0 +1,32 @@
+package org.csploit.msf.api;
+
+/**
+ * A license
+ */
+public enum License {
+  MSF("Metasploit Framework License (BSD)"),
+  GPL("GNU Public License v2.0"),
+  BSD("BSD License"),
+  ARTISTIC("Perl Artistic License"),
+  UNKNOWN("Unknown License");
+
+  String name;
+
+  License(String name) {
+    this.name = name;
+  }
+
+  public String toString() {
+    return name;
+  }
+
+  public static License fromString(String value) {
+    if(value != null) {
+      for (License l : values()) {
+        if (l.name.toLowerCase().startsWith(value.toLowerCase()))
+          return l;
+      }
+    }
+    return UNKNOWN;
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/Module.java b/msf/src/main/java/org/csploit/msf/api/Module.java
new file mode 100644
index 0000000000..d53115ec2a
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/Module.java
@@ -0,0 +1,24 @@
+package org.csploit.msf.api;
+
+import org.csploit.msf.api.module.Platform;
+import org.csploit.msf.api.module.Rank;
+import org.csploit.msf.api.module.Reference;
+
+import java.util.Set;
+
+/**
+ * Represent a module of the MSF
+ */
+public interface Module extends Customizable, Comparable<Module> {
+  String getRefname();
+  String getFullName();
+  String getShortName();
+  String getDescription();
+  String getName();
+  License getLicense();
+  Rank getRank();
+  Reference[] getReferences();
+  Author[] getAuthors();
+  Set<Arch> getArches();
+  Set<Platform> getPlatforms();
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/MsfException.java b/msf/src/main/java/org/csploit/msf/api/MsfException.java
new file mode 100644
index 0000000000..0c049c0ac2
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/MsfException.java
@@ -0,0 +1,14 @@
+package org.csploit.msf.api;
+
+/**
+ * An error occurred in the framework
+ */
+public class MsfException extends Exception {
+  public MsfException(String message) {
+    super(message);
+  }
+
+  public MsfException(String message, Throwable cause) {
+    super(message, cause);
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/Option.java b/msf/src/main/java/org/csploit/msf/api/Option.java
new file mode 100644
index 0000000000..d600df6609
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/Option.java
@@ -0,0 +1,36 @@
+package org.csploit.msf.api;
+
+/**
+ * An option
+ */
+public interface Option<T> {
+  boolean isAdvanced();
+  boolean haveDefaultValue();
+  boolean isEvasion();
+  boolean isRequired();
+  T getDefaultValue();
+  String getDescription();
+  String getName();
+  Module getOwner();
+
+  /**
+   * show a string representation of an option
+   * @param input the value to display
+   * @return a string representation of an option
+   */
+  String display(T input);
+
+  /**
+   * check if a value is suitable for this option
+   * @param value the value to check
+   * @return {@code true} if value is valid, {@code false} otherwise
+   */
+  boolean isValid(T value);
+
+  /**
+   * normalize a string for this option
+   * @param value the String to normalize
+   * @return the normalized value
+   */
+  T normalize(String value);
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/Payload.java b/msf/src/main/java/org/csploit/msf/api/Payload.java
new file mode 100644
index 0000000000..b0080a51d6
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/Payload.java
@@ -0,0 +1,12 @@
+package org.csploit.msf.api;
+
+import java.io.IOException;
+
+/**
+ * This class represents the base class for a logical payload.  The framework
+ * automatically generates payload combinations at runtime which are all
+ * extended for this Payload as a base class.
+ */
+public interface Payload extends Module {
+  byte[] generate() throws IOException, MsfException;
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/Post.java b/msf/src/main/java/org/csploit/msf/api/Post.java
new file mode 100644
index 0000000000..09e35340e8
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/Post.java
@@ -0,0 +1,7 @@
+package org.csploit.msf.api;
+
+/**
+ * A Post-exploitation module.
+ */
+public interface Post extends Module, Executable {
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/Publisher.java b/msf/src/main/java/org/csploit/msf/api/Publisher.java
new file mode 100644
index 0000000000..568f4492d2
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/Publisher.java
@@ -0,0 +1,20 @@
+package org.csploit.msf.api;
+
+import java.io.IOException;
+import java.util.EventListener;
+
+/**
+ * An event publisher
+ */
+public interface Publisher<T extends EventListener> {
+  /**
+   * add an event subscriber
+   * @param listener to add
+   */
+  void addSubscriber(T listener) throws IOException, MsfException;
+  /**
+   * remove an event subscriber
+   * @param listener to remove
+   */
+  void removeSubscriber(T listener) throws IOException, MsfException;
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/Session.java b/msf/src/main/java/org/csploit/msf/api/Session.java
new file mode 100644
index 0000000000..704d02d07a
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/Session.java
@@ -0,0 +1,35 @@
+package org.csploit.msf.api;
+
+import java.io.IOException;
+import java.util.List;
+
+/**
+ * The session class represents a post-exploitation, uh, session.
+ * Sessions can be written to, read from, and interacted with.  The
+ * underlying medium on which they are backed is arbitrary.  For
+ * instance, when an exploit is provided with a command shell,
+ * either through a network connection or locally, the session's
+ * read and write operations end up reading from and writing to
+ * the shell that was spawned.  The session object can be seen
+ * as a general means of interacting with various post-exploitation
+ * payloads through a common interface that is not necessarily
+ * tied to a network connection.
+ */
+public interface Session {
+  int getId();
+  String getLocalTunnel();
+  String getPeerTunnel();
+  Exploit getExploit();
+  Payload getPayload();
+  String getDescription();
+  String getInfo();
+  String getWorkspace();
+  String getSessionHost();
+  int getSessionPort();
+  String getTargetHost();
+  String getUsername();
+  String getUuid();
+  String[] getRoutes();
+  List<? extends Module> getCompatibleModules() throws IOException, MsfException;
+  void close() throws IOException, MsfException;
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/events/ConsoleChangedEvent.java b/msf/src/main/java/org/csploit/msf/api/events/ConsoleChangedEvent.java
new file mode 100644
index 0000000000..806d7a64e2
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/events/ConsoleChangedEvent.java
@@ -0,0 +1,12 @@
+package org.csploit.msf.api.events;
+
+import org.csploit.msf.api.Console;
+
+/**
+ * A console has changed
+ */
+public class ConsoleChangedEvent extends ConsoleEvent {
+  public ConsoleChangedEvent(Object source, Console console) {
+    super(source, console);
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/events/ConsoleClosedEvent.java b/msf/src/main/java/org/csploit/msf/api/events/ConsoleClosedEvent.java
new file mode 100644
index 0000000000..0ee56785d7
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/events/ConsoleClosedEvent.java
@@ -0,0 +1,12 @@
+package org.csploit.msf.api.events;
+
+import org.csploit.msf.api.Console;
+
+/**
+ * A console has been closed
+ */
+public class ConsoleClosedEvent extends ConsoleEvent {
+  public ConsoleClosedEvent(Object source, Console console) {
+    super(source, console);
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/events/ConsoleEvent.java b/msf/src/main/java/org/csploit/msf/api/events/ConsoleEvent.java
new file mode 100644
index 0000000000..843d9433a3
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/events/ConsoleEvent.java
@@ -0,0 +1,21 @@
+package org.csploit.msf.api.events;
+
+import org.csploit.msf.api.Console;
+
+import java.util.EventObject;
+
+/**
+ * An event related to a {@link org.csploit.msf.api.Console}
+ */
+public abstract class ConsoleEvent extends EventObject {
+  private int id;
+
+  public ConsoleEvent(Object source, Console console) {
+    super(source);
+    this.id = console.getId();
+  }
+
+  public int getId() {
+    return id;
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/events/ConsoleOpenedEvent.java b/msf/src/main/java/org/csploit/msf/api/events/ConsoleOpenedEvent.java
new file mode 100644
index 0000000000..4198787439
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/events/ConsoleOpenedEvent.java
@@ -0,0 +1,12 @@
+package org.csploit.msf.api.events;
+
+import org.csploit.msf.api.Console;
+
+/**
+ * A console has been opened
+ */
+public class ConsoleOpenedEvent extends ConsoleEvent {
+  public ConsoleOpenedEvent(Object source, Console console) {
+    super(source, console);
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/events/ConsoleOutputEvent.java b/msf/src/main/java/org/csploit/msf/api/events/ConsoleOutputEvent.java
new file mode 100644
index 0000000000..6f74b675fe
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/events/ConsoleOutputEvent.java
@@ -0,0 +1,20 @@
+package org.csploit.msf.api.events;
+
+import org.csploit.msf.api.Console;
+
+/**
+ * A console printed something
+ */
+public class ConsoleOutputEvent extends ConsoleEvent implements OutputEvent {
+  private String output;
+
+  public ConsoleOutputEvent(Object source, Console console, String output) {
+    super(source, console);
+    this.output = output;
+  }
+
+  @Override
+  public String getOutput() {
+    return output;
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/events/OutputEvent.java b/msf/src/main/java/org/csploit/msf/api/events/OutputEvent.java
new file mode 100644
index 0000000000..07fad1ed4d
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/events/OutputEvent.java
@@ -0,0 +1,8 @@
+package org.csploit.msf.api.events;
+
+/**
+ * someone has printed something
+ */
+public interface OutputEvent {
+  String getOutput();
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/events/SessionClosedEvent.java b/msf/src/main/java/org/csploit/msf/api/events/SessionClosedEvent.java
new file mode 100644
index 0000000000..305a303fee
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/events/SessionClosedEvent.java
@@ -0,0 +1,12 @@
+package org.csploit.msf.api.events;
+
+import org.csploit.msf.api.Session;
+
+/**
+ * A session has been closed
+ */
+public class SessionClosedEvent extends SessionEvent {
+  public SessionClosedEvent(Object source, Session session) {
+    super(source, session);
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/events/SessionEvent.java b/msf/src/main/java/org/csploit/msf/api/events/SessionEvent.java
new file mode 100644
index 0000000000..d7b76e049d
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/events/SessionEvent.java
@@ -0,0 +1,22 @@
+package org.csploit.msf.api.events;
+
+import org.csploit.msf.api.Session;
+
+import java.util.EventObject;
+
+/**
+ * A session event
+ */
+public abstract class SessionEvent extends EventObject {
+  private int id;
+
+  public SessionEvent(Object source, Session session) {
+    super(source);
+
+    id = session.getId();
+  }
+
+  public int getId() {
+    return id;
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/events/SessionOpenedEvent.java b/msf/src/main/java/org/csploit/msf/api/events/SessionOpenedEvent.java
new file mode 100644
index 0000000000..6013b63cbb
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/events/SessionOpenedEvent.java
@@ -0,0 +1,12 @@
+package org.csploit.msf.api.events;
+
+import org.csploit.msf.api.Session;
+
+/**
+ * A session has been opened
+ */
+public class SessionOpenedEvent extends SessionEvent {
+  public SessionOpenedEvent(Object source, Session session) {
+    super(source, session);
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/events/SessionOutputEvent.java b/msf/src/main/java/org/csploit/msf/api/events/SessionOutputEvent.java
new file mode 100644
index 0000000000..272e4863b5
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/events/SessionOutputEvent.java
@@ -0,0 +1,20 @@
+package org.csploit.msf.api.events;
+
+import org.csploit.msf.api.Session;
+
+/**
+ * A session printed something
+ */
+public class SessionOutputEvent extends SessionEvent implements OutputEvent {
+  private String output;
+
+  public SessionOutputEvent(Object source, Session session, String output) {
+    super(source, session);
+    this.output = output;
+  }
+
+  @Override
+  public String getOutput() {
+    return output;
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/exceptions/ResourceNotFoundException.java b/msf/src/main/java/org/csploit/msf/api/exceptions/ResourceNotFoundException.java
new file mode 100644
index 0000000000..399e87b49c
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/exceptions/ResourceNotFoundException.java
@@ -0,0 +1,19 @@
+package org.csploit.msf.api.exceptions;
+
+import org.csploit.msf.api.MsfException;
+
+/**
+ * A requested resource cannot be found
+ *
+ * for instance a non-existing console ID, session ID or module name.
+ */
+public class ResourceNotFoundException extends MsfException {
+
+  public ResourceNotFoundException(String message) {
+    super(message);
+  }
+
+  public ResourceNotFoundException(String message, Throwable cause) {
+    super(message, cause);
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/listeners/ConsoleListener.java b/msf/src/main/java/org/csploit/msf/api/listeners/ConsoleListener.java
new file mode 100644
index 0000000000..360cf0437e
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/listeners/ConsoleListener.java
@@ -0,0 +1,37 @@
+package org.csploit.msf.api.listeners;
+
+import org.csploit.msf.api.events.ConsoleChangedEvent;
+import org.csploit.msf.api.events.ConsoleClosedEvent;
+import org.csploit.msf.api.events.ConsoleOpenedEvent;
+import org.csploit.msf.api.events.ConsoleOutputEvent;
+
+import java.util.EventListener;
+
+/**
+ * Something that is listening on Console events
+ */
+public interface ConsoleListener extends EventListener {
+  /**
+   * A {@link org.csploit.msf.api.Console} has been opened
+   * @param event event data
+   */
+  void onConsoleOpened(ConsoleOpenedEvent event);
+
+  /**
+   * A {@link org.csploit.msf.api.Console} has changed it's state
+   * @param event event data
+   */
+  void onConsoleChanged(ConsoleChangedEvent event);
+
+  /**
+   * A {@link org.csploit.msf.api.Console} has printed something
+   * @param event event data
+   */
+  void onConsoleOutput(ConsoleOutputEvent event);
+
+  /**
+   * A {@link org.csploit.msf.api.Console} has been closed
+   * @param event event data
+   */
+  void onConsoleClosed(ConsoleClosedEvent event);
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/listeners/SessionListener.java b/msf/src/main/java/org/csploit/msf/api/listeners/SessionListener.java
new file mode 100644
index 0000000000..b47744fb41
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/listeners/SessionListener.java
@@ -0,0 +1,14 @@
+package org.csploit.msf.api.listeners;
+
+import org.csploit.msf.api.events.SessionClosedEvent;
+import org.csploit.msf.api.events.SessionOpenedEvent;
+import org.csploit.msf.api.events.SessionOutputEvent;
+
+/**
+ * Listen for session events
+ */
+public interface SessionListener extends java.util.EventListener {
+  void onSessionOpened(SessionOpenedEvent e);
+  void onSessionOutput(SessionOutputEvent e);
+  void onSessionClosed(SessionClosedEvent e);
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/module/AuxiliaryAction.java b/msf/src/main/java/org/csploit/msf/api/module/AuxiliaryAction.java
new file mode 100644
index 0000000000..95f05548bf
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/module/AuxiliaryAction.java
@@ -0,0 +1,9 @@
+package org.csploit.msf.api.module;
+
+/**
+ * A target for an exploit.
+ */
+public interface AuxiliaryAction {
+  String getName();
+  String getDescription();
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/module/Platform.java b/msf/src/main/java/org/csploit/msf/api/module/Platform.java
new file mode 100644
index 0000000000..e07f9b735f
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/module/Platform.java
@@ -0,0 +1,118 @@
+package org.csploit.msf.api.module;
+
+/**
+ * A platform
+ */
+public enum Platform {
+  WINDOWS("Windows", 1, 0, 0),
+  WINDOWS_95("Windows 95", 1, 1, 0),
+  WINDOWS_98("Windows 98", 1, 2, 0),
+  WINDOWS_98_FE("Windows 98 FE", 1, 2, 1),
+  WINDOWS_98_SE("Windows 98 SE", 1, 2, 2),
+  WINDOWS_ME("Windows ME", 1, 3, 0),
+  WINDOWS_NT("Windows NT", 1, 4, 0),
+  WINDOWS_NT_SP0("Windows NT SP0", 1, 4, 1),
+  WINDOWS_NT_SP1("Windows NT SP1", 1, 4, 2),
+  WINDOWS_NT_SP2("Windows NT SP2", 1, 4, 3),
+  WINDOWS_NT_SP3("Windows NT SP3", 1, 4, 4),
+  WINDOWS_NT_SP4("Windows NT SP4", 1, 4, 5),
+  WINDOWS_NT_SP5("Windows NT SP5", 1, 4, 6),
+  WINDOWS_NT_SP6("Windows NT SP6", 1, 4, 7),
+  WINDOWS_NT_SP6A("Windows NT SP6a", 1, 4, 8),
+  WINDOWS_2000("Windows 2000", 1, 5, 0),
+  WINDOWS_2000_SP0("Windows 2000 SP0", 1, 5, 1),
+  WINDOWS_2000_SP1("Windows 2000 SP1", 1, 5, 2),
+  WINDOWS_2000_SP2("Windows 2000 SP2", 1, 5, 3),
+  WINDOWS_2000_SP3("Windows 2000 SP3", 1, 5, 4),
+  WINDOWS_2000_SP4("Windows 2000 SP4", 1, 5, 5),
+  WINDOWS_XP("Windows XP", 1, 6, 0),
+  WINDOWS_XP_SP0("Windows XP SP0", 1, 6, 1),
+  WINDOWS_XP_SP1("Windows XP SP1", 1, 6, 2),
+  WINDOWS_XP_SP2("Windows XP SP2", 1, 6, 3),
+  WINDOWS_XP_SP3("Windows XP SP3", 1, 6, 4),
+  WINDOWS_2003("Windows 2003", 1, 7, 0),
+  WINDOWS_2003_SP0("Windows 2003 SP0", 1, 7, 1),
+  WINDOWS_2003_SP1("Windows 2003 SP1", 1, 7, 2),
+  WINDOWS_VISTA("Windows Vista", 1, 8, 0),
+  WINDOWS_VISTA_SP0("Windows Vista SP0", 1, 8, 1),
+  WINDOWS_VISTA_SP1("Windows Vista SP1", 1, 8, 2),
+  WINDOWS_7("Windows 7", 1, 9, 0),
+  WINDOWS_8("Windows 8", 1, 10, 0),
+  NETWARE("Netware", 2, 0, 0),
+  ANDROID("Android", 3, 0, 0),
+  JAVA("Java", 4, 0, 0),
+  RUBY("Ruby", 5, 0, 0),
+  LINUX("Linux", 6, 0, 0),
+  CISCO("Cisco", 7, 0, 0),
+  SOLARIS("Solaris", 8, 0, 0),
+  SOLARIS_V4("Solaris V4", 8, 1, 0),
+  SOLARIS_V5("Solaris V5", 8, 2, 0),
+  SOLARIS_V6("Solaris V6", 8, 3, 0),
+  SOLARIS_V7("Solaris V7", 8, 4, 0),
+  SOLARIS_V8("Solaris V8", 8, 5, 0),
+  SOLARIS_V9("Solaris V9", 8, 6, 0),
+  SOLARIS_V10("Solaris V10", 8, 7, 0),
+  OSX("OSX", 9, 0, 0),
+  BSD("BSD", 10, 0, 0),
+  OPENBSD("OpenBSD", 11, 0, 0),
+  BSDI("BSDi", 12, 0, 0),
+  NETBSD("NetBSD", 13, 0, 0),
+  FREEBSD("FreeBSD", 14, 0, 0),
+  AIX("AIX", 15, 0, 0),
+  HPUX("HPUX", 16, 0, 0),
+  IRIX("Irix", 17, 0, 0),
+  UNIX("Unix", 18, 0, 0),
+  PHP("PHP", 19, 0, 0),
+  JAVASCRIPT("JavaScript", 20, 0, 0),
+  PYTHON("Python", 21, 0, 0),
+  NODEJS("NodeJS", 22, 0, 0),
+  FIREFOX("Firefox", 23, 0, 0),
+  MAINFRAME("Mainframe", 24, 0, 0);
+
+  protected String realName;
+  protected int major;
+  protected int minor;
+  protected int patch;
+
+  Platform(String realName, int major, int minor, int patch) {
+    this.realName = realName;
+    this.major = major;
+    this.minor = minor;
+    this.patch = patch;
+  }
+
+  public String getRealName() {
+    return realName;
+  }
+
+  /**
+   * is a platform a subset of another ?
+   * @param other possible ancestor to test
+   * @return true if {@code other} is a platform that contains {@code this}
+   */
+  public boolean subsetOf(Platform other) {
+    if(other.major != major)
+      return false;
+    if(other.minor == 0)
+      return true;
+    if(other.minor != minor)
+      return false;
+    if(other.patch == 0)
+      return true;
+    if(other.patch != patch)
+      return false;
+    return true;
+  }
+
+  public static Platform fromString(String s) {
+    if(s != null) {
+      s = s.trim();
+      for (Platform pl : values()) {
+        if (pl.getRealName().equals(s))
+          return pl;
+      }
+    }
+    return null;
+  }
+
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/module/Rank.java b/msf/src/main/java/org/csploit/msf/api/module/Rank.java
new file mode 100644
index 0000000000..db5fd643d6
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/module/Rank.java
@@ -0,0 +1,53 @@
+package org.csploit.msf.api.module;
+
+/**
+ * A module rank
+ */
+public enum Rank {
+  MANUAL(0, "manual"),
+  LOW(100, "low"),
+  AVERAGE(200, "average"),
+  NORMAL(300, "normal"),
+  GOOD(400, "good"),
+  GREAT(500, "great"),
+  EXCELLENT(600, "excellent")
+  ;
+
+  private String name;
+  private int value;
+
+  Rank(int value, String name) {
+    this.value = value;
+    this.name = name;
+  }
+
+  public int getValue() {
+    return value;
+  }
+
+  @Override
+  public String toString() {
+    return name;
+  }
+
+  public static Rank fromName(String name) {
+    name = name.trim();
+    name = name.toLowerCase();
+    for (Rank r : values()) {
+      if (r.name.toLowerCase().equals(name)) {
+        return r;
+      }
+    }
+    return null;
+  }
+
+  public static Rank fromValue(int value) {
+    Rank result = Rank.MANUAL;
+    for (Rank r : values()) {
+      if (r.value <= value && r.value > result.value) {
+        result = r;
+      }
+    }
+    return result;
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/module/Reference.java b/msf/src/main/java/org/csploit/msf/api/module/Reference.java
new file mode 100644
index 0000000000..74ecf732d6
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/module/Reference.java
@@ -0,0 +1,9 @@
+package org.csploit.msf.api.module;
+
+/**
+ * A reference to some sort of information.  This is typically a URL, but could
+ * be any type of referential value that people could use to research a topic.
+ */
+public interface Reference {
+  String toString();
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/module/SiteReference.java b/msf/src/main/java/org/csploit/msf/api/module/SiteReference.java
new file mode 100644
index 0000000000..a1c54f0cb7
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/module/SiteReference.java
@@ -0,0 +1,8 @@
+package org.csploit.msf.api.module;
+
+/**
+ * A reference to a website.
+ */
+public interface SiteReference extends Reference {
+  String getUrl();
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/module/Target.java b/msf/src/main/java/org/csploit/msf/api/module/Target.java
new file mode 100644
index 0000000000..b0203f5f6a
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/module/Target.java
@@ -0,0 +1,14 @@
+package org.csploit.msf.api.module;
+
+import org.csploit.msf.api.Arch;
+
+import java.util.Set;
+
+/**
+ * Represent a target
+ */
+public interface Target {
+  String getName();
+  Set<Platform> getPlatform();
+  Set<Arch> getArch();
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/options/AddressOption.java b/msf/src/main/java/org/csploit/msf/api/options/AddressOption.java
new file mode 100644
index 0000000000..afb470bb19
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/options/AddressOption.java
@@ -0,0 +1,11 @@
+package org.csploit.msf.api.options;
+
+import org.csploit.msf.api.Option;
+
+import java.net.InetAddress;
+
+/**
+ * Network address option.
+ */
+public interface AddressOption extends Option<InetAddress> {
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/options/AddressRangeOption.java b/msf/src/main/java/org/csploit/msf/api/options/AddressRangeOption.java
new file mode 100644
index 0000000000..4ad1f2eee4
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/options/AddressRangeOption.java
@@ -0,0 +1,11 @@
+package org.csploit.msf.api.options;
+
+import org.csploit.msf.api.Option;
+
+import java.net.InetAddress;
+
+/**
+ * Network address range option.
+ */
+public interface AddressRangeOption extends Option<InetAddress[]> {
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/options/BooleanOption.java b/msf/src/main/java/org/csploit/msf/api/options/BooleanOption.java
new file mode 100644
index 0000000000..a01db9a0df
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/options/BooleanOption.java
@@ -0,0 +1,9 @@
+package org.csploit.msf.api.options;
+
+import org.csploit.msf.api.Option;
+
+/**
+ * Boolean option.
+ */
+public interface BooleanOption extends Option<Boolean> {
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/options/EnumOption.java b/msf/src/main/java/org/csploit/msf/api/options/EnumOption.java
new file mode 100644
index 0000000000..3182dc91c9
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/options/EnumOption.java
@@ -0,0 +1,10 @@
+package org.csploit.msf.api.options;
+
+import org.csploit.msf.api.Option;
+
+/**
+ * Enum option.
+ */
+public interface EnumOption extends Option<String> {
+  String[] getValues();
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/options/IntegerOption.java b/msf/src/main/java/org/csploit/msf/api/options/IntegerOption.java
new file mode 100644
index 0000000000..56a4a0558a
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/options/IntegerOption.java
@@ -0,0 +1,9 @@
+package org.csploit.msf.api.options;
+
+import org.csploit.msf.api.Option;
+
+/**
+ * Integer option.
+ */
+public interface IntegerOption extends Option<Integer> {
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/options/PathOption.java b/msf/src/main/java/org/csploit/msf/api/options/PathOption.java
new file mode 100644
index 0000000000..c70f6cd399
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/options/PathOption.java
@@ -0,0 +1,11 @@
+package org.csploit.msf.api.options;
+
+import org.csploit.msf.api.Option;
+
+import java.io.File;
+
+/**
+ * File system path option.
+ */
+public interface PathOption extends Option<File> {
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/options/PortOption.java b/msf/src/main/java/org/csploit/msf/api/options/PortOption.java
new file mode 100644
index 0000000000..15a1c84e37
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/options/PortOption.java
@@ -0,0 +1,9 @@
+package org.csploit.msf.api.options;
+
+import org.csploit.msf.api.Option;
+
+/**
+ * Network port option.
+ */
+public interface PortOption extends Option<Integer> {
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/options/RawOption.java b/msf/src/main/java/org/csploit/msf/api/options/RawOption.java
new file mode 100644
index 0000000000..dbda7dae37
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/options/RawOption.java
@@ -0,0 +1,9 @@
+package org.csploit.msf.api.options;
+
+import org.csploit.msf.api.Option;
+
+/**
+ * Raw, arbitrary data option.
+ */
+public interface RawOption extends Option<byte[]> {
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/options/RegexpOption.java b/msf/src/main/java/org/csploit/msf/api/options/RegexpOption.java
new file mode 100644
index 0000000000..203fdbbf89
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/options/RegexpOption.java
@@ -0,0 +1,11 @@
+package org.csploit.msf.api.options;
+
+import org.csploit.msf.api.Option;
+
+import java.util.regex.Pattern;
+
+/**
+ * A regex option
+ */
+public interface RegexpOption extends Option<Pattern> {
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/options/StringOption.java b/msf/src/main/java/org/csploit/msf/api/options/StringOption.java
new file mode 100644
index 0000000000..239119b255
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/options/StringOption.java
@@ -0,0 +1,9 @@
+package org.csploit.msf.api.options;
+
+import org.csploit.msf.api.Option;
+
+/**
+ * Option string
+ */
+public interface StringOption extends Option<String> {
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/sessions/CommandShell.java b/msf/src/main/java/org/csploit/msf/api/sessions/CommandShell.java
new file mode 100644
index 0000000000..87c46e49e7
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/sessions/CommandShell.java
@@ -0,0 +1,10 @@
+package org.csploit.msf.api.sessions;
+
+/**
+ * This class provides basic interaction with a command shell on the remote
+ * endpoint.  This session is initialized with a stream that will be used
+ * as the pipe for reading and writing the command shell.
+ */
+public interface CommandShell extends SingleCommandShell, Interactive {
+  //TODO
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/sessions/Interactive.java b/msf/src/main/java/org/csploit/msf/api/sessions/Interactive.java
new file mode 100644
index 0000000000..323cb42d96
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/sessions/Interactive.java
@@ -0,0 +1,15 @@
+package org.csploit.msf.api.sessions;
+
+import org.csploit.msf.api.MsfException;
+
+import java.io.IOException;
+
+/**
+ * Represent an interactive session
+ */
+public interface Interactive {
+  void interact() throws IOException, MsfException;
+  void suspend() throws IOException, MsfException;
+  void complete() throws IOException, MsfException;
+  boolean isInteracting() throws IOException, MsfException;
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/sessions/Meterpreter.java b/msf/src/main/java/org/csploit/msf/api/sessions/Meterpreter.java
new file mode 100644
index 0000000000..e0b8db2ebd
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/sessions/Meterpreter.java
@@ -0,0 +1,18 @@
+package org.csploit.msf.api.sessions;
+
+import org.csploit.msf.api.MsfException;
+
+import java.io.IOException;
+
+/**
+ * This class represents a session compatible interface to a meterpreter server
+ * instance running on a remote machine.  It provides the means of interacting
+ * with the server instance both at an API level as well as at a console level.
+ */
+public interface Meterpreter extends SingleCommandShell {
+  boolean detach() throws IOException, MsfException;
+  boolean interrupt() throws IOException, MsfException;
+  String[] tabs(String base) throws IOException, MsfException;
+  String getPlatform();
+  // TODO: transport_change
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/sessions/MultiCommandExecution.java b/msf/src/main/java/org/csploit/msf/api/sessions/MultiCommandExecution.java
new file mode 100644
index 0000000000..8675a7eba4
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/sessions/MultiCommandExecution.java
@@ -0,0 +1,12 @@
+package org.csploit.msf.api.sessions;
+
+/**
+ * Executes multiple commands and optionally allows for reading/writing I/O
+ * to the new processes.
+ */
+public interface MultiCommandExecution extends SingleCommandExecution {
+  int exec(String cmd, String[] args, boolean hidden);
+  String read(int length, int id);
+  int write(String data, int id);
+  void close(int id);
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/sessions/MultiCommandShell.java b/msf/src/main/java/org/csploit/msf/api/sessions/MultiCommandShell.java
new file mode 100644
index 0000000000..d05162fbee
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/sessions/MultiCommandShell.java
@@ -0,0 +1,14 @@
+package org.csploit.msf.api.sessions;
+
+/**
+ * This interface is to be implemented by a session that is capable of
+ * providing multiple command shell interfaces simultaneously.  Inherently,
+ * MultiCommandShell classes must also provide a mechanism by which they can
+ * implement the SingleCommandShell interface.
+ */
+public interface MultiCommandShell extends SingleCommandShell {
+  int open();
+  String read(int length, int id);
+  int write(String data, int id);
+  void close(int id);
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/sessions/Scriptable.java b/msf/src/main/java/org/csploit/msf/api/sessions/Scriptable.java
new file mode 100644
index 0000000000..020b780f91
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/sessions/Scriptable.java
@@ -0,0 +1,11 @@
+package org.csploit.msf.api.sessions;
+
+import org.csploit.msf.api.Session;
+
+/**
+ * Represent a session that can run scripts
+ */
+public interface Scriptable extends Session {
+  boolean executeFile(String path, String[] args);
+  int executeScript(String scriptName, String[] args);
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/sessions/SingleCommandExecution.java b/msf/src/main/java/org/csploit/msf/api/sessions/SingleCommandExecution.java
new file mode 100644
index 0000000000..a6715f2e09
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/sessions/SingleCommandExecution.java
@@ -0,0 +1,15 @@
+package org.csploit.msf.api.sessions;
+
+import org.csploit.msf.api.Session;
+
+/**
+ * Executes a single command and optionally allows for reading/writing I/O
+ * to the new process.
+ *
+ * footnote: I didn't found any implementors of this interface in the framework
+ */
+public interface SingleCommandExecution extends Session {
+  void init(String cmd, String[] args); // TODO: options ??
+  String read(int length);
+  int write(String data);
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/sessions/SingleCommandShell.java b/msf/src/main/java/org/csploit/msf/api/sessions/SingleCommandShell.java
new file mode 100644
index 0000000000..1585898c6a
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/sessions/SingleCommandShell.java
@@ -0,0 +1,16 @@
+package org.csploit.msf.api.sessions;
+
+import org.csploit.msf.api.MsfException;
+import org.csploit.msf.api.Session;
+
+import java.io.IOException;
+
+/**
+ * This interface is to be implemented by a session that is only capable of
+ * providing an interface to a single command shell.
+ */
+public interface SingleCommandShell extends Session {
+  void init();
+  String read() throws IOException, MsfException;
+  int write(String data) throws IOException, MsfException;
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/sessions/Tty.java b/msf/src/main/java/org/csploit/msf/api/sessions/Tty.java
new file mode 100644
index 0000000000..7d719e7640
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/sessions/Tty.java
@@ -0,0 +1,9 @@
+package org.csploit.msf.api.sessions;
+
+/**
+ * This class provides basic interaction with a command shell on the remote
+ * endpoint.  This session is initialized with a stream that will be used
+ * as the pipe for reading and writing the command shell.
+ */
+public interface Tty extends SingleCommandShell {
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/sessions/UpgradableShell.java b/msf/src/main/java/org/csploit/msf/api/sessions/UpgradableShell.java
new file mode 100644
index 0000000000..0b0677f07b
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/sessions/UpgradableShell.java
@@ -0,0 +1,18 @@
+package org.csploit.msf.api.sessions;
+
+import org.csploit.msf.api.MsfException;
+
+import java.io.IOException;
+import java.net.InetAddress;
+
+/**
+ * A Shell that can be upgrade to a Metrpreter one
+ */
+public interface UpgradableShell {
+  /**
+   * open a new Meterpreter session on the target
+   * @param lhost local host address
+   * @param lport local bound port
+   */
+  void upgrade(InetAddress lhost, int lport) throws IOException, MsfException;
+}
diff --git a/msf/src/main/java/org/csploit/msf/api/sessions/VncInject.java b/msf/src/main/java/org/csploit/msf/api/sessions/VncInject.java
new file mode 100644
index 0000000000..32db5df9e1
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/api/sessions/VncInject.java
@@ -0,0 +1,7 @@
+package org.csploit.msf.api.sessions;
+
+import org.csploit.msf.api.Session;
+
+public interface VncInject extends Session {
+  //TODO
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/AbstractOption.java b/msf/src/main/java/org/csploit/msf/impl/AbstractOption.java
new file mode 100644
index 0000000000..3d152c8f0e
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/AbstractOption.java
@@ -0,0 +1,86 @@
+package org.csploit.msf.impl;
+
+import org.csploit.msf.api.Module;
+
+/**
+ * Represent an option
+ */
+public abstract class AbstractOption<T> implements org.csploit.msf.api.Option<T> {
+  protected boolean advanced;
+  protected T defaultValue;
+  protected String description;
+  protected boolean evasion;
+  protected String name;
+  protected Module owner;
+  protected boolean required;
+
+  public AbstractOption(String name, boolean required, String description, T defaultValue) {
+    this.name = name;
+    this.required = required;
+    this.description = description;
+    this.defaultValue = defaultValue;
+  }
+
+  public AbstractOption(String name, String description, T defaultValue) {
+    this(name, false, description, defaultValue);
+  }
+
+  public boolean isAdvanced() {
+    return advanced;
+  }
+
+  public void setAdvanced(boolean advanced) {
+    this.advanced = advanced;
+  }
+
+  public T getDefaultValue() {
+    return defaultValue;
+  }
+
+  public boolean haveDefaultValue() {
+    return defaultValue != null;
+  }
+
+  public String getDescription() {
+    return description;
+  }
+
+  public boolean isEvasion() {
+    return evasion;
+  }
+
+  public void setEvasion(boolean evasion) {
+    this.evasion = evasion;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public void setName(String name) {
+    this.name = name;
+  }
+
+  public Module getOwner() {
+    return owner;
+  }
+
+  public void setOwner(Module owner) {
+    this.owner = owner;
+  }
+
+  public boolean isRequired() {
+    return required;
+  }
+
+  public String display(T value) {
+    return value.toString();
+  }
+
+  public boolean isValid(T input) {
+    if(isRequired() && (input == null || input.toString().length() == 0)) {
+      return false;
+    }
+    return true;
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/AbstractSession.java b/msf/src/main/java/org/csploit/msf/impl/AbstractSession.java
new file mode 100644
index 0000000000..3605fb8717
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/AbstractSession.java
@@ -0,0 +1,161 @@
+package org.csploit.msf.impl;
+
+import org.csploit.msf.api.Exploit;
+import org.csploit.msf.api.Payload;
+
+/**
+ * The session class represents a post-exploitation, uh, session.
+ * Sessions can be written to, read from, and interacted with.  The
+ * underlying medium on which they are backed is arbitrary.  For
+ * instance, when an exploit is provided with a command shell,
+ * either through a network connection or locally, the session's
+ * read and write operations end up reading from and writing to
+ * the shell that was spawned.  The session object can be seen
+ * as a general means of interacting with various post-exploitation
+ * payloads through a common interface that is not necessarily
+ * tied to a network connection.
+ */
+abstract class AbstractSession implements Offspring, org.csploit.msf.api.Session {
+  private InternalFramework framework;
+  private int id;
+  private String localTunnel;
+  private String peerTunnel;
+  private Exploit exploit;
+  private Payload payload;
+  private String description;
+  private String info;
+  private String workspace;
+  private String sessionHost;
+  private int sessionPort;
+  private String targetHost;
+  private String username;
+  private String uuid;
+  private String[] routes;
+
+  public AbstractSession(int id) {
+    this.id = id;
+  }
+
+  public int getId() {
+    return id;
+  }
+
+  public String getLocalTunnel() {
+    return localTunnel;
+  }
+
+  public void setLocalTunnel(String localTunnel) {
+    this.localTunnel = localTunnel;
+  }
+
+  public String getPeerTunnel() {
+    return peerTunnel;
+  }
+
+  public void setPeerTunnel(String peerTunnel) {
+    this.peerTunnel = peerTunnel;
+  }
+
+  public Exploit getExploit() {
+    return exploit;
+  }
+
+  public void setExploit(Exploit exploit) {
+    this.exploit = exploit;
+  }
+
+  public Payload getPayload() {
+    return payload;
+  }
+
+  public void setPayload(Payload payload) {
+    this.payload = payload;
+  }
+
+  public String getDescription() {
+    return description;
+  }
+
+  public void setDescription(String description) {
+    this.description = description;
+  }
+
+  public String getInfo() {
+    return info;
+  }
+
+  public void setInfo(String info) {
+    this.info = info;
+  }
+
+  public String getWorkspace() {
+    return workspace;
+  }
+
+  public void setWorkspace(String workspace) {
+    this.workspace = workspace;
+  }
+
+  public String getSessionHost() {
+    return sessionHost;
+  }
+
+  public void setSessionHost(String sessionHost) {
+    this.sessionHost = sessionHost;
+  }
+
+  public int getSessionPort() {
+    return sessionPort;
+  }
+
+  public void setSessionPort(int sessionPort) {
+    this.sessionPort = sessionPort;
+  }
+
+  public String getTargetHost() {
+    return targetHost;
+  }
+
+  public void setTargetHost(String targetHost) {
+    this.targetHost = targetHost;
+  }
+
+  public String getUsername() {
+    return username;
+  }
+
+  public void setUsername(String username) {
+    this.username = username;
+  }
+
+  public String getUuid() {
+    return uuid;
+  }
+
+  public void setUuid(String uuid) {
+    this.uuid = uuid;
+  }
+
+  public String[] getRoutes() {
+    return routes;
+  }
+
+  public void setRoutes(String[] routes) {
+    this.routes = routes;
+  }
+
+  @Override
+  public boolean haveFramework() {
+    return framework != null;
+  }
+
+  @Override
+  public InternalFramework getFramework() {
+    return framework;
+  }
+
+  @Override
+  public void setFramework(InternalFramework framework) {
+    this.framework = framework;
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/Author.java b/msf/src/main/java/org/csploit/msf/impl/Author.java
new file mode 100644
index 0000000000..34af1a2484
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/Author.java
@@ -0,0 +1,45 @@
+package org.csploit.msf.impl;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Represent an author
+ */
+class Author implements org.csploit.msf.api.Author {
+  private static final Pattern MAIL = Pattern.compile("<(.+)>");
+
+  private final String name;
+  private final String email;
+
+  public Author(String name, String email) {
+    this.name = name;
+    this.email = email;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public String getEmail() {
+    return email;
+  }
+
+  @Override
+  public String toString() {
+    if(email != null) {
+      return name + " <" + email + ">";
+    } else {
+      return name;
+    }
+  }
+
+  public static Author fromString(String s) {
+    Matcher matcher = MAIL.matcher(s);
+    if(matcher.matches()) {
+      return new Author(s.substring(0, matcher.start()), matcher.group(1));
+    } else {
+      return new Author(s, null);
+    }
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/Auxiliary.java b/msf/src/main/java/org/csploit/msf/impl/Auxiliary.java
new file mode 100644
index 0000000000..4de2eb350c
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/Auxiliary.java
@@ -0,0 +1,70 @@
+package org.csploit.msf.impl;
+
+import org.csploit.msf.api.MsfException;
+import org.csploit.msf.impl.module.AuxiliaryAction;
+
+import java.io.IOException;
+
+/**
+ * The auxiliary class acts as a base class for all modules that perform
+ * reconnaissance, retrieve data, brute force logins, or any other action
+ * that doesn't fit our concept of an 'exploit' (involving payloads and
+ * targets and whatnot).
+ */
+class Auxiliary extends Module implements org.csploit.msf.api.Auxiliary {
+
+  private AuxiliaryAction[] actions;
+  private int defaultAction;
+
+  public Auxiliary(String refname) {
+    super(refname);
+    defaultAction = -1;
+  }
+
+  public void setDefaultAction(String defaultAction) {
+    if(actions != null && defaultAction != null && defaultAction.length() > 0) {
+      for(int i = 0; i < actions.length; i++) {
+        if(defaultAction.equals(actions[i].getName())) {
+          this.defaultAction = i;
+          return;
+        }
+      }
+    }
+  }
+
+  private void onActionsChanged() {
+    if(actions == null || defaultAction >= actions.length) {
+      defaultAction = -1;
+    }
+  }
+
+  public void setActions(AuxiliaryAction[] actions) {
+    this.actions = actions;
+    onActionsChanged();
+  }
+
+  public void setDefaultAction(int defaultAction) {
+    this.defaultAction = defaultAction;
+    onActionsChanged();
+  }
+
+  @Override
+  public String getType() {
+    return "auxiliary";
+  }
+
+  @Override
+  public org.csploit.msf.api.module.AuxiliaryAction[] getActions() {
+    return actions;
+  }
+
+  @Override
+  public org.csploit.msf.api.module.AuxiliaryAction getDefaultAction() {
+    return actions == null || defaultAction < 0 ? null : actions[defaultAction];
+  }
+
+  @Override
+  public void execute() throws IOException, MsfException {
+    throw new UnsupportedOperationException("not implemented yet");
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/DataHolder.java b/msf/src/main/java/org/csploit/msf/impl/DataHolder.java
new file mode 100644
index 0000000000..49d5e33fa6
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/DataHolder.java
@@ -0,0 +1,8 @@
+package org.csploit.msf.impl;
+
+/**
+ * A class that hold a DataStore instance
+ */
+interface DataHolder {
+  DataStore getDataStore();
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/DataStore.java b/msf/src/main/java/org/csploit/msf/impl/DataStore.java
new file mode 100644
index 0000000000..f2cf4d96f8
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/DataStore.java
@@ -0,0 +1,115 @@
+package org.csploit.msf.impl;
+
+import org.csploit.msf.api.Option;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * The data store is just a bitbucket that holds keyed values.  It is used
+ * by various classes to hold option values and other state information.
+ */
+class DataStore extends HashMap<String, String> {
+  protected Set<String> imported = new HashSet<>();
+  protected Set<String> defaults = new HashSet<>();
+
+  @Override
+  public String put(String key, String value) {
+    key = findKeyCase(key);
+
+    defaults.remove(key);
+    imported.remove(key);
+
+    return super.put(key, value);
+  }
+
+  @Override
+  public String get(Object key) {
+    String k = (key instanceof String) ? (String) key : key.toString();
+    return super.get(findKeyCase(k));
+  }
+
+  public void updateValue(String key, String value) {
+    super.put(key, value);
+  }
+
+  /**
+   * This method is a helper method that imports the default value for
+   * all of the supplied options
+   */
+  public void importOptions(OptionContainer options, boolean isDefault, boolean overwrite) {
+    for(Option opt : options.values()) {
+      String name = opt.getName();
+      if(containsKey(name) && !overwrite) {
+        continue;
+      }
+      if(opt.haveDefaultValue() && (overwrite || get(name) == null)) {
+        String val = opt.display(opt.getDefaultValue());
+        importOption(name, val, true, isDefault);
+      }
+    }
+  }
+
+  public void importOptions(OptionContainer options, boolean isDefault) {
+    importOptions(options, isDefault, false);
+  }
+
+  public void importOptions(OptionContainer options) {
+    importOptions(options, false, false);
+  }
+
+  public void importOption(String name, String val, boolean imported, boolean isDefault) {
+    if(imported) {
+      this.imported.add(name);
+    }
+
+    if(isDefault) {
+      defaults.add(name);
+    }
+
+    super.put(name, val);
+  }
+
+  public void importOption(String name, String val, boolean imported) {
+    importOption(name, val, imported, false);
+  }
+
+  public void importOption(String name, String val) {
+    importOption(name, val, true, false);
+  }
+
+  public synchronized Map<String, String> userDefined() {
+    Map<String, String> res = new HashMap<>();
+
+    for (String key : keySet()) {
+      if (!imported.contains(key)) {
+        res.put(key, super.get(key));
+      }
+    }
+
+    return res;
+  }
+
+  public void clearNotUserDefined() {
+    for(String key : imported) {
+      if(defaults.remove(key)) {
+        remove(key);
+      }
+    }
+  }
+  
+  protected String findKeyCase(String k) {
+
+    if(k == null)
+      return null;
+
+    for(String key : keySet()) {
+      if(key.toLowerCase().equals(k.toLowerCase()))
+        return key;
+    }
+    
+    return k;
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/Exploit.java b/msf/src/main/java/org/csploit/msf/impl/Exploit.java
new file mode 100644
index 0000000000..4267a93aa8
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/Exploit.java
@@ -0,0 +1,85 @@
+package org.csploit.msf.impl;
+
+import org.csploit.msf.api.*;
+import org.csploit.msf.api.Payload;
+import org.csploit.msf.api.module.Target;
+
+import java.io.IOException;
+import java.util.List;
+
+/**
+ * Concrete implementation of an exploit
+ */
+class Exploit extends Module implements InternalExploit {
+  private Target[] targets;
+  private int defaultTarget = -1;
+
+  public Exploit(String refname) {
+    super(refname);
+  }
+
+  @Override
+  public String getType() {
+    return "exploit";
+  }
+
+  public void setTargets(Target[] targets) {
+    this.targets = targets;
+  }
+
+  public void setDefaultTarget(int defaultTarget) {
+    this.defaultTarget = defaultTarget;
+  }
+
+  public Target[] getTargets() {
+    return targets;
+  }
+
+  public Target getTarget() {
+    int i = getTargetIndex();
+
+    if(i>= 0 && i < targets.length) {
+      return targets[i];
+    }
+
+    return null;
+  }
+
+  @Override
+  public void setTarget(int i) {
+    if (i < 0 || i >= targets.length) {
+      throw new IndexOutOfBoundsException();
+    }
+
+    datastore.put("TARGET", Integer.toString(i));
+  }
+
+  @Override
+  public int getTargetIndex() {
+    String s = datastore.get("TARGET");
+
+    if(s == null)
+      return defaultTarget;
+
+    try {
+      int i = Integer.parseInt(s);
+      if(i >= 0 && i < targets.length) {
+        return i;
+      }
+    } catch (NumberFormatException e) {
+      // ignore
+    }
+
+    return defaultTarget;
+  }
+
+  @Override
+  public List<? extends Payload> getCompatiblePayloads() {
+    throw new UnsupportedOperationException("not implemented yet");
+  }
+
+  @Override
+  public void execute() throws IOException, MsfException {
+    throw new UnsupportedOperationException("not implemented yet");
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/Framework.java b/msf/src/main/java/org/csploit/msf/impl/Framework.java
new file mode 100644
index 0000000000..88724dba24
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/Framework.java
@@ -0,0 +1,131 @@
+package org.csploit.msf.impl;
+
+import org.csploit.msf.api.Exploit;
+import org.csploit.msf.api.Module;
+import org.csploit.msf.api.MsfException;
+import org.csploit.msf.api.Payload;
+import org.csploit.msf.api.Post;
+import org.csploit.msf.api.Session;
+import org.csploit.msf.api.listeners.SessionListener;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.EventListener;
+import java.util.List;
+
+/**
+ * Represent a Metasploit Framework instance
+ */
+class Framework implements DataHolder, InternalFramework {
+
+  private DataStore dataStore;
+  private ModuleManager moduleManager;
+  private JobContainer jobs;
+  private SessionManager sessionManager;
+
+  public Framework() {
+    dataStore = new DataStore();
+    moduleManager = new ModuleManager(this, "all");
+    jobs = new JobContainer();
+    sessionManager = new SessionManager();
+
+    sessionManager.start();
+  }
+
+  @Override
+  public DataStore getDataStore() {
+    return dataStore;
+  }
+
+  public ModuleManager getModuleManager() {
+    return moduleManager;
+  }
+
+  public void setGlobalOption(String key, String value) {
+    getDataStore().put(key, value);
+  }
+
+  @Override
+  public void unsetGlobalOption(String key) {
+    getDataStore().remove(key);
+  }
+
+  @Override
+  public void addSubscriber(EventListener listener) throws IOException, MsfException {
+    if(listener instanceof SessionListener) {
+      sessionManager.addSubscriber((SessionListener) listener);
+    }
+  }
+
+  @Override
+  public void removeSubscriber(EventListener listener) throws IOException, MsfException {
+    if(listener instanceof SessionListener) {
+      sessionManager.removeSubscriber((SessionListener) listener);
+    }
+  }
+
+  @Override
+  public List<Session> getSessions() throws IOException, MsfException {
+    return sessionManager.getSessions();
+  }
+
+  @Override
+  public Module getModule(String refname) throws IOException, MsfException {
+    return moduleManager.get(refname);
+  }
+
+  @Override
+  public List<? extends Exploit> getExploits() throws IOException, MsfException {
+    return moduleManager.<InternalExploit>getOfType("exploit");
+  }
+
+  @Override
+  public List<? extends Payload> getPayloads() throws IOException, MsfException {
+    return moduleManager.<org.csploit.msf.impl.Payload>getOfType("payload");
+  }
+
+  @Override
+  public List<? extends Post> getPosts() throws IOException, MsfException {
+    return moduleManager.<org.csploit.msf.impl.Post>getOfType("post");
+  }
+
+  @Override
+  public SessionManager getSessionManager() {
+    return sessionManager;
+  }
+
+  @Override
+  public org.csploit.msf.api.Job getJob(int id) throws IOException, MsfException {
+    return jobs.get(id);
+  }
+
+  public List<Job> getJobs() throws IOException, MsfException {
+    List<Integer> keys = new ArrayList<>(jobs.keySet());
+    Collections.sort(keys);
+    List<Job> result = new ArrayList<>(keys.size());
+    for(int k : keys) {
+      result.add(jobs.get(k));
+    }
+    return result;
+  }
+
+  @Override
+  public JobContainer getJobContainer() {
+    return jobs;
+  }
+
+  public void registerJob(Job job) {
+    jobs.put(job.getId(), job);
+  }
+
+  public void unregisterJob(int id) {
+    jobs.remove(id);
+  }
+
+  @Override
+  protected void finalize() throws Throwable {
+    sessionManager.stop();
+    super.finalize();
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/InternalAuxiliary.java b/msf/src/main/java/org/csploit/msf/impl/InternalAuxiliary.java
new file mode 100644
index 0000000000..69b3a3e8e6
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/InternalAuxiliary.java
@@ -0,0 +1,13 @@
+package org.csploit.msf.impl;
+
+import org.csploit.msf.api.Auxiliary;
+import org.csploit.msf.api.module.AuxiliaryAction;
+
+/**
+ * Give access to Auxiliary modifiers
+ */
+interface InternalAuxiliary extends Auxiliary, InternalModule {
+  void setDefaultAction(String defaultAction);
+  void setActions(AuxiliaryAction[] actions);
+  void setDefaultAction(int defaultAction);
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/InternalConsole.java b/msf/src/main/java/org/csploit/msf/impl/InternalConsole.java
new file mode 100644
index 0000000000..2d8012e005
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/InternalConsole.java
@@ -0,0 +1,28 @@
+package org.csploit.msf.impl;
+
+import org.csploit.msf.api.Console;
+import org.csploit.msf.api.MsfException;
+
+import java.io.IOException;
+
+/**
+ * Provide access to hidden Console stuff
+ */
+interface InternalConsole extends Console {
+  /**
+   * read from this console
+   * @return the data read from the console
+   */
+  String read() throws IOException, MsfException;
+
+  /**
+   * reset the changed flag
+   */
+  void clearChanged();
+
+  /**
+   * has the console been changed ?
+   * @return {@code true} if the console has changed, {@code false} otherwise
+   */
+  boolean hasChanged();
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/InternalExploit.java b/msf/src/main/java/org/csploit/msf/impl/InternalExploit.java
new file mode 100644
index 0000000000..a5be99936c
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/InternalExploit.java
@@ -0,0 +1,18 @@
+package org.csploit.msf.impl;
+
+import org.csploit.msf.api.module.Target;
+import org.csploit.msf.api.Exploit;
+
+/**
+ * Provide access to Exploit modifiers
+ */
+interface InternalExploit extends Exploit, InternalModule {
+  void setTargets(Target[] targets);
+  void setDefaultTarget(int defaultTarget);
+
+  /**
+   * get the index of the current target.
+   * @return the current target index.
+   */
+  int getTargetIndex();
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/InternalFramework.java b/msf/src/main/java/org/csploit/msf/impl/InternalFramework.java
new file mode 100644
index 0000000000..4407480aa6
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/InternalFramework.java
@@ -0,0 +1,14 @@
+package org.csploit.msf.impl;
+
+import org.csploit.msf.api.Framework;
+
+/**
+ * Give access to some hidden parts of the framework
+ */
+interface InternalFramework extends Framework, DataHolder {
+  ModuleManager getModuleManager();
+  SessionManager getSessionManager();
+  JobContainer getJobContainer();
+  void registerJob(Job job);
+  void unregisterJob(int id);
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/InternalMeterpreter.java b/msf/src/main/java/org/csploit/msf/impl/InternalMeterpreter.java
new file mode 100644
index 0000000000..3494b8ff81
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/InternalMeterpreter.java
@@ -0,0 +1,10 @@
+package org.csploit.msf.impl;
+
+import org.csploit.msf.api.sessions.Meterpreter;
+
+/**
+ * Access meterpreter modifiers
+ */
+interface InternalMeterpreter extends Meterpreter {
+  void setPlatform(String platform);
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/InternalModule.java b/msf/src/main/java/org/csploit/msf/impl/InternalModule.java
new file mode 100644
index 0000000000..1a66a7c239
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/InternalModule.java
@@ -0,0 +1,29 @@
+package org.csploit.msf.impl;
+
+import org.csploit.msf.api.License;
+import org.csploit.msf.api.Module;
+import org.csploit.msf.api.Option;
+import org.csploit.msf.api.module.Rank;
+import org.csploit.msf.impl.module.ArchSet;
+import org.csploit.msf.impl.module.PlatformList;
+import org.csploit.msf.impl.module.Reference;
+
+/**
+ * Give access to Module modifiers
+ */
+interface InternalModule extends Module, DataHolder, Offspring {
+  String getType();
+  void setAuthors(Author[] authors);
+  void setArch(ArchSet arch);
+  void setPlatform(PlatformList platform);
+  void setReferences(Reference[] references);
+  void setOptions(OptionContainer options);
+  void setDatastore(ModuleDataStore datastore);
+  void setPrivileged(boolean privileged);
+  void setLicense(License license);
+  void setRank(Rank rank);
+  void setName(String name);
+  void setVersion(String version);
+  void setDescription(String description);
+  void registerOption(Option option);
+}
\ No newline at end of file
diff --git a/msf/src/main/java/org/csploit/msf/impl/Job.java b/msf/src/main/java/org/csploit/msf/impl/Job.java
new file mode 100644
index 0000000000..b1110a4704
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/Job.java
@@ -0,0 +1,71 @@
+package org.csploit.msf.impl;
+
+import org.csploit.msf.api.Payload;
+import org.csploit.msf.api.Exploit;
+
+import java.util.Date;
+
+/**
+ * This class is the concrete representation of an abstract job.
+ */
+class Job implements org.csploit.msf.api.Job {
+
+  private JobContainer container;
+  private int id;
+  private String name;
+  protected Exploit exploit;
+  protected Payload payload;
+  private Date startTime;
+
+  public Job(JobContainer container, int id, String name, Exploit exploit, Payload payload) {
+    this.container = container;
+    this.id = id;
+    this.name = name;
+    this.exploit = exploit;
+    this.payload = payload;
+  }
+
+  public Job(int id, String name, Exploit exploit, Payload payload) {
+    this(null, id, name, exploit, payload);
+  }
+
+  public Job(int id, String name) {
+    this(null, id, name, null, null);
+  }
+
+  void setStartTime(Date startTime) {
+    this.startTime = startTime;
+  }
+
+  void setName(String name) {
+    this.name = name;
+  }
+
+  public int getId() {
+    return id;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public Date getStartTime() {
+    return startTime;
+  }
+
+  public void stop() {
+    container.remove(id);
+  }
+
+  void setContainer(JobContainer container) {
+    this.container = container;
+  }
+
+  public void setExploit(Exploit exploit) {
+    this.exploit = exploit;
+  }
+
+  public void setPayload(Payload payload) {
+    this.payload = payload;
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/JobContainer.java b/msf/src/main/java/org/csploit/msf/impl/JobContainer.java
new file mode 100644
index 0000000000..0cab32104b
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/JobContainer.java
@@ -0,0 +1,12 @@
+package org.csploit.msf.impl;
+
+import java.util.HashMap;
+
+/**
+ * This class contains zero or more abstract jobs that can be enumerated and
+ * stopped in a generic fashion.  This is used to provide a mechanism for
+ * keeping track of arbitrary contexts that may or may not require a dedicated
+ * thread.
+ */
+class JobContainer extends HashMap<Integer, Job> {
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/Module.java b/msf/src/main/java/org/csploit/msf/impl/Module.java
new file mode 100644
index 0000000000..7bcdeb448c
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/Module.java
@@ -0,0 +1,212 @@
+package org.csploit.msf.impl;
+
+import org.csploit.msf.api.Arch;
+import org.csploit.msf.api.License;
+import org.csploit.msf.api.MsfException;
+import org.csploit.msf.api.Option;
+import org.csploit.msf.api.module.Platform;
+import org.csploit.msf.api.module.Rank;
+import org.csploit.msf.impl.module.ArchSet;
+import org.csploit.msf.impl.module.PlatformList;
+import org.csploit.msf.impl.module.Reference;
+
+import java.io.IOException;
+import java.util.Collection;
+import java.util.Set;
+
+/**
+ * Represent a module of the MSF
+ */
+abstract class Module implements InternalModule {
+  protected Author[] authors;
+  protected ArchSet arch;
+  protected PlatformList platform;
+  protected Reference[] references;
+  protected OptionContainer options;
+  protected InternalFramework framework;
+  protected ModuleDataStore datastore;
+  protected boolean privileged;
+  protected License license;
+  protected Rank rank;
+
+  protected final String refname;
+  protected String name;
+  protected String description;
+  protected String version;
+
+  public Module(String refname) {
+    this.refname = refname;
+    this.options = new OptionContainer();
+    this.datastore = new ModuleDataStore(this);
+  }
+
+  @Override
+  public boolean haveFramework() {
+    return framework != null;
+  }
+
+  @Override
+  public InternalFramework getFramework() {
+    return framework;
+  }
+
+  @Override
+  public void setFramework(InternalFramework framework) {
+    this.framework = framework;
+  }
+
+  @Override
+  public DataStore getDataStore() {
+    return datastore;
+  }
+
+  public String getRefname() {
+    return refname;
+  }
+
+  public String getFullName() {
+    return getType() + "/" + getRefname();
+  }
+
+  public String getShortName() {
+    String[] parts = getRefname().split("/");
+    return parts[parts.length - 1];
+  }
+
+  public void setAuthors(Author[] authors) {
+    this.authors = authors;
+  }
+
+  public void setArch(ArchSet arch) {
+    this.arch = arch;
+  }
+
+  public void setPlatform(PlatformList platform) {
+    this.platform = platform;
+  }
+
+  public void setReferences(Reference[] references) {
+    this.references = references;
+  }
+
+  public void setOptions(OptionContainer options) {
+    this.options = options;
+  }
+
+  public void setDatastore(ModuleDataStore datastore) {
+    this.datastore = datastore;
+  }
+
+  public void setPrivileged(boolean privileged) {
+    this.privileged = privileged;
+  }
+
+  public void setLicense(License license) {
+    this.license = license;
+  }
+
+  public void setRank(Rank rank) {
+    this.rank = rank;
+  }
+
+  public void setName(String name) {
+    this.name = name;
+  }
+
+  public void setVersion(String version) {
+    this.version = version;
+  }
+
+  public void setDescription(String description) {
+    this.description = description;
+  }
+
+  @Override
+  public String getName() {
+    return name;
+  }
+
+  @Override
+  public License getLicense() {
+    return license;
+  }
+
+  @Override
+  public Rank getRank() {
+    return rank;
+  }
+
+  @Override
+  public Reference[] getReferences() {
+    return references;
+  }
+
+  @Override
+  public Author[] getAuthors() {
+    return authors;
+  }
+
+  @Override
+  public Set<Arch> getArches() {
+    return arch;
+  }
+
+  @Override
+  public Set<Platform> getPlatforms() {
+    return platform;
+  }
+
+  public int compareTo(org.csploit.msf.api.Module module) {
+    return getFullName().compareToIgnoreCase(module.getFullName());
+  }
+
+  @Override
+  public String getDescription() {
+    return description;
+  }
+
+  public void registerOption(Option option) {
+    options.add(option);
+  }
+
+  @Override
+  public void setOption(String key, String value) {
+    getDataStore().put(key, value);
+  }
+
+  @Override
+  public Collection<Option> getOptions() throws IOException, MsfException {
+    return options.values();
+  }
+
+  @Override
+  public Collection<String> getInvalidOptions() {
+    return options.getInvalidOptions(getDataStore());
+  }
+
+  @Override
+  public <T> T getOptionValue(Option<T> option) {
+    return option.normalize(getDataStore().get(option.getName()));
+  }
+
+  @Override
+  public int hashCode() {
+    return refname != null ? refname.hashCode() : 0;
+  }
+
+  public static InternalModule fromType(String type, String refname) throws NameHelper.BadModuleTypeException {
+    switch (type) {
+      case "exploit":
+        return new Exploit(refname);
+      case "payload":
+        return new Payload(refname);
+      case "post":
+        return new Post(refname);
+      case "nop":
+      case "encoder":
+        //TODO
+      default:
+        throw new NameHelper.BadModuleTypeException(type);
+    }
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/ModuleDataStore.java b/msf/src/main/java/org/csploit/msf/impl/ModuleDataStore.java
new file mode 100644
index 0000000000..d06a0b4005
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/ModuleDataStore.java
@@ -0,0 +1,35 @@
+package org.csploit.msf.impl;
+
+/**
+ * DataStore wrapper for modules that will attempt to back values against the
+ * framework's datastore if they aren't found in the module's datastore.  This
+ * is done to simulate global data store values.
+ */
+class ModuleDataStore extends DataStore {
+  private Module module;
+
+  public ModuleDataStore(Module module) {
+    this.module = module;
+  }
+
+  public boolean isDefault(String key) {
+    return defaults.contains(key);
+  }
+
+  @Override
+  public String get(Object key) {
+    String k, res;
+
+    k = key != null ? key.toString() : null;
+    k = findKeyCase(k);
+    res = null;
+    if(!isDefault(k))
+      res = super.get(key);
+
+    if(res == null && module != null && module.haveFramework()) {
+      res = module.getFramework().getDataStore().get(k);
+    }
+
+    return res != null ? res : super.get(k);
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/ModuleManager.java b/msf/src/main/java/org/csploit/msf/impl/ModuleManager.java
new file mode 100644
index 0000000000..db02445ee6
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/ModuleManager.java
@@ -0,0 +1,120 @@
+package org.csploit.msf.impl;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Manage all framework modules
+ */
+class ModuleManager implements Offspring {
+
+  final static String[] validModuleTypes = {
+          "encoder",
+          "exploit",
+          "nop",
+          "auxiliary",
+          "payload",
+          "post"
+  };
+
+  private Map<String, ModuleSet> sets = new HashMap<>();
+  private InternalFramework framework;
+
+  public ModuleManager(Framework framework, String types) {
+    this(framework, types.equals("all") ? validModuleTypes : types.split(","));
+  }
+
+  public ModuleManager(Framework framework, String[] types) {
+    setFramework(framework);
+    for(String type : types) {
+      type = type.trim();
+      if(isValidType(type))
+        initSet(type);
+    }
+  }
+
+  private void initSet(String type) {
+    if(sets.containsKey(type))
+      return;
+
+    ModuleSet set = ModuleSet.forType(type);
+    set.setFramework(getFramework());
+    sets.put(type, set);
+  }
+
+  private static boolean isValidType(String type) {
+    for(String t : validModuleTypes) {
+      if(t.equals(type))
+        return true;
+    }
+    return false;
+  }
+
+  public InternalModule get(String name) {
+    try {
+      String[] parts = NameHelper.getTypeAndRefnameFromFullname(name);
+
+      return get(parts[0], parts[1]);
+    } catch (NameHelper.BadModuleNameException | NameHelper.BadModuleTypeException e) {
+      return worldSearch(name);
+    }
+  }
+
+  public InternalModule get(String type, String refname) {
+    if(!sets.containsKey(type)) {
+      if(isValidType(type)) {
+        return null;
+      }
+      return worldSearch(type + "/" + refname);
+    }
+    return sets.get(type).get(refname);
+  }
+
+  @SuppressWarnings("unchecked")
+  public <T extends InternalModule> List<T> getOfType(String type) {
+    if(!sets.containsKey(type)) {
+      return Collections.emptyList();
+    }
+
+    ArrayList<T> result = new ArrayList<>();
+    result.addAll((Collection<? extends T>) sets.get(type).values());
+    Collections.sort(result);
+    return result;
+  }
+
+  private InternalModule worldSearch(String name) {
+    for(ModuleSet set : sets.values()) {
+      InternalModule m = set.get(name);
+      if(m != null)
+        return m;
+    }
+    return null;
+  }
+
+  public void put(InternalModule module) {
+    String type = module.getType();
+    if(!sets.containsKey(type)) {
+      return;
+    }
+    sets.get(type).add(module);
+  }
+
+  @Override
+  public boolean haveFramework() {
+    return framework != null;
+  }
+
+  @Override
+  public InternalFramework getFramework() {
+    return framework;
+  }
+
+  @Override
+  public void setFramework(InternalFramework framework) {
+    this.framework = framework;
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/ModuleSet.java b/msf/src/main/java/org/csploit/msf/impl/ModuleSet.java
new file mode 100644
index 0000000000..767fcfb189
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/ModuleSet.java
@@ -0,0 +1,68 @@
+package org.csploit.msf.impl;
+
+import org.csploit.msf.impl.module.ArchSet;
+import org.csploit.msf.impl.module.PlatformList;
+
+import java.util.HashMap;
+
+/**
+ * A module set contains zero or more named module classes of an arbitrary
+ * type.
+ */
+class ModuleSet extends HashMap<String, InternalModule> implements Offspring {
+  protected String type;
+  private InternalFramework framework;
+
+  public ModuleSet(String type) {
+    this.type = type;
+  }
+
+  public String getType() {
+    return type;
+  }
+
+  @Override
+  public boolean haveFramework() {
+    return framework != null;
+  }
+
+  @Override
+  public InternalFramework getFramework() {
+    return framework;
+  }
+
+  @Override
+  public void setFramework(InternalFramework framework) {
+    this.framework = framework;
+  }
+
+  public void add(InternalModule module) {
+    module.setFramework(framework);
+    put(module.getRefname(), module);
+  }
+
+  public ModuleSet filter(ArchSet architectures, PlatformList platforms) {
+    ModuleSet res = new ModuleSet(getType());
+    res.setFramework(framework);
+    for(InternalModule m : values()) {
+
+      if(architectures != null && architectures.intersect(m.getArches()).isEmpty()) {
+        continue;
+      }
+
+      if(platforms != null && platforms.intersect(m.getPlatforms()).isEmpty()) {
+        continue;
+      }
+
+      //TODO: custom filter
+
+      res.add(m);
+    }
+    return res;
+  }
+
+  public static ModuleSet forType(String type) {
+    //TODO: PayloadSet
+    return new ModuleSet(type);
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/MsgpackClient.java b/msf/src/main/java/org/csploit/msf/impl/MsgpackClient.java
new file mode 100644
index 0000000000..3e5c1197ab
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/MsgpackClient.java
@@ -0,0 +1,1069 @@
+package org.csploit.msf.impl;
+
+import org.apache.commons.io.IOUtils;
+import org.csploit.msf.api.MsfException;
+import org.msgpack.MessagePack;
+import org.msgpack.MessagePackable;
+import org.msgpack.packer.Packer;
+import org.msgpack.template.AbstractTemplate;
+import org.msgpack.template.Template;
+import org.msgpack.template.Templates;
+import org.msgpack.type.Value;
+import org.msgpack.type.ValueType;
+import org.msgpack.unpacker.Unpacker;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * A Msf Msgpack simple client
+ */
+@SuppressWarnings("rawtypes, unchecked")
+class MsgpackClient {
+  private URL u;
+  private String token;
+  private static MessagePack msgpack = null;
+
+  private static final Pattern RUBY_STACKTRACE_PATTERN = Pattern.compile("^(from )?(.*/([^/.]+)(\\.[^:]+)?):([0-9]+):in `(.*)'");
+  private static final Template<Map<String, String>> mapStringStringTemplate = Templates.tMap(Templates.TString, Templates.TString);
+  private static final Template<Map<Integer, String>> mapIntegerStringTemplate = Templates.tMap(Templates.TInteger, Templates.TString);
+  private static final Map<String, Template> methodTemplatesMap = new HashMap<String, Template>() {{
+    put("core.version", mapStringStringTemplate);
+    put("auth.login", mapStringStringTemplate);
+    put("auth.token_generate", mapStringStringTemplate);
+    put("module.exploits", SingleTemplate.getModulesInstance());
+    put("module.compatible_payloads", SingleTemplate.getPayloadsInstance());
+    put("module.target_compatible_payloads", SingleTemplate.getPayloadsInstance());
+    put("module.post", SingleTemplate.getModulesInstance());
+    put("module.payloads", SingleTemplate.getModulesInstance());
+    put("module.auxiliary", SingleTemplate.getModulesInstance());
+    put("module.encoders", SingleTemplate.getModulesInstance());
+    put("module.nops", SingleTemplate.getModulesInstance());
+    put("module.info", ModuleInfoTemplate.getInstance());
+    put("module.options", Templates.tMap(Templates.TString, OptionTemplate.getInstance()));
+    put("job.list", mapIntegerStringTemplate);
+    put("job.info", JobInfoTemplate.getInstance());
+    put("session.list", Templates.tMap(Templates.TInteger, SessionInfoTemplate.getInstance()));
+    put("session.compatible_modules", SingleTemplate.getModulesInstance());
+    put("session.stop", BooleanResultTemplate.getInstance());
+    put("session.shell_read", SingleTemplate.getReadInstance());
+    put("session.shell_write", SingleTemplate.getWriteInstance());
+    put("session.shell_upgrade", BooleanResultTemplate.getInstance());
+    put("session.meterpreter_read", SingleTemplate.getReadInstance());
+    put("session.meterpreter_write", BooleanResultTemplate.getInstance());
+    put("session.meterpreter_detach", BooleanResultTemplate.getInstance());
+    put("session.meterpreter_session_kill", BooleanResultTemplate.getInstance());
+    put("session.meterpreter_tabs", SingleTemplate.getTabsInstance());
+    put("console.list", SingleTemplate.getConsolesInstance());
+    put("console.destroy", BooleanResultTemplate.getInstance());
+    put("console.read", ConsoleReadInfoTemplate.getInstance());
+    put("console.write", SingleTemplate.getWroteInstance());
+    put("console.tabs", SingleTemplate.getTabsInstance());
+    put("console.session_kill", BooleanResultTemplate.getInstance());
+    put("console.session_detach", BooleanResultTemplate.getInstance());
+  }};
+  private static final Map<String, Template> parametricTemplatesMap = new HashMap<String, Template>() {{
+    put("module.execute(payload)", SingleTemplate.getPayloadGenerateInstance());
+    put("module.execute", SingleTemplate.getJobIdInstance());
+  }};
+  private static final Map<String, Class> methodClassMap = new HashMap<String, Class>() {{
+    put("console.create", ConsoleInfo.class);
+  }};
+
+  public MsgpackClient(final String host, final String username, final String password, final int port, final boolean ssl) throws IOException, MsfException {
+    u = new URL("http" + (ssl ? "s" : ""), host, port, "/api/");
+
+    if (msgpack == null)
+      msgpack = new MessagePack();
+
+    login(username, password);
+  }
+
+  /**
+   * execute a remote command and get a response
+   * @param methodName the method to call
+   * @param params the parameters to send
+   * @return the response
+   * @throws IOException if some IO error occurs
+   * @throws MsfException if the server reply with an exception
+   */
+  protected Object exec(String methodName, Object[] params) throws IOException, MsfException {
+    Packer pk = null;
+    URLConnection huc;
+    OutputStream os = null;
+    InputStream is = null;
+    byte[] response = null;
+
+    try {
+      huc = u.openConnection();
+      huc.setDoOutput(true);
+      huc.setDoInput(true);
+      huc.setUseCaches(false);
+      huc.setRequestProperty("Content-Type", "binary/message-pack");
+      huc.setReadTimeout(0);
+      os = huc.getOutputStream();
+      pk = msgpack.createPacker(os);
+      pk.writeArrayBegin(params.length + 1);
+      pk.write(methodName);
+      for (Object arg : params)
+        pk.write(arg);
+      pk.writeArrayEnd();
+      pk.close();
+      os.close();
+      is = huc.getInputStream();
+      response = IOUtils.toByteArray(is);
+    } finally {
+      IOUtils.closeQuietly(os);
+      IOUtils.closeQuietly(pk);
+      IOUtils.closeQuietly(is);
+    }
+
+    Object firstParam = params.length > 1 ? params[1] : null;
+
+    return parseResponse(methodName, firstParam, response);
+  }
+
+  private Object parseResponse(String methodName, Object firstParam, byte[] response)
+          throws IOException, MsfException {
+    ByteArrayInputStream bis = new ByteArrayInputStream(response);
+    Unpacker unpacker = msgpack.createUnpacker(bis);
+
+    // attempt to read an MsfException
+    try {
+      MsfException exception = unpacker.read(ServerExceptionTemplate.getInstance());
+      throw new MsfException("failed to execute command: " + methodName, exception);
+    } catch (IllegalArgumentException e) {
+      bis.reset();
+      unpacker = msgpack.createUnpacker(bis); // TODO: check if we can skip this
+    }
+
+    Template t = null;
+    String withArg = null;
+
+    if (methodTemplatesMap.containsKey(methodName)) {
+      t = methodTemplatesMap.get(methodName);
+    } else if(firstParam != null) {
+      withArg = String.format("%s(%s)", methodName, firstParam.toString());
+      if(parametricTemplatesMap.containsKey(withArg)) {
+        t = parametricTemplatesMap.get(withArg);
+      } else if(parametricTemplatesMap.containsKey(methodName)) {
+        t = parametricTemplatesMap.get(methodName);
+      }
+    }
+
+    if (t != null) {
+      return unpacker.read(t);
+    } else if (methodClassMap.containsKey(methodName)) {
+      return unpacker.read(methodClassMap.get(methodName));
+    } else {
+      throw new MsfException("unknown command: " + (withArg != null ? withArg : methodName));
+    }
+  }
+
+  private void login(String username, String password) throws IOException, MsfException {
+    /* login to msf server */
+    Map<String, String> response = (Map<String, String>)
+            exec("auth.login", new Object[]{username, password});
+
+    /* save the temp token (lasts for 5 minutes of inactivity) */
+    token = response.get("token");
+
+    /* generate a non-expiring token and use that */
+    response = (Map<String, String>) exec("auth.token_generate", new Object[]{token});
+    token = response.get("token");
+  }
+
+  private Object call(String method) throws IOException, MsfException {
+    Object[] tmp = new Object[]{token};
+    return exec(method, tmp);
+  }
+
+  private Object call(String method, Object... args) throws IOException, MsfException {
+    Object[] local_array = new Object[args.length + 1];
+    local_array[0] = token;
+    java.lang.System.arraycopy(args, 0, local_array, 1, args.length);
+    return exec(method, local_array);
+  }
+
+  public boolean isConnected() {
+    try {
+      call("core.version");
+      return true;
+    } catch (MsfException | IOException e) {
+      return false;
+    }
+  }
+
+  public String[] getExploits() throws IOException, MsfException {
+    return (String[]) call("module.exploits");
+  }
+
+  /**
+   * @see {@link MsgpackClient#getExploitCompatiblePayloads(String, int)}
+   */
+  public String[] getExploitCompatiblePayloads(String refname) throws IOException, MsfException {
+    return (String[]) call("module.compatible_payloads", refname);
+  }
+
+  /**
+   * get payloads that are compatible with the specified exploit
+   * @param refname the exploit refname
+   * @param i the chosen target index
+   * @return a list of compatible payloads
+   */
+  public String[] getExploitCompatiblePayloads(String refname, int i) throws IOException, MsfException {
+    return (String[]) call("module.target_compatible_payloads", refname, i);
+  }
+
+  public String[] getPayloads() throws IOException, MsfException {
+    return (String[]) call("module.payloads");
+  }
+
+  public String[] getPosts() throws IOException, MsfException {
+    return (String[]) call("module.post");
+  }
+
+  public String[] getEncoders() throws IOException, MsfException {
+    return (String[]) call("module.encoders");
+  }
+
+  public String[] getNops() throws IOException, MsfException {
+    return (String[]) call("module.nops");
+  }
+
+  public String[] getAuxiliaries() throws IOException, MsfException {
+    return (String[]) call("module.auxiliary");
+  }
+
+  public ModuleInfo getModuleInfo(String type, String name) throws IOException, MsfException {
+    return (ModuleInfo) call("module.info", type, name);
+  }
+
+  public JobInfo getJobInfo(int id) throws IOException, MsfException {
+    return (JobInfo) call("job.info", id);
+  }
+
+  public Map<Integer, String> getJobs() throws IOException, MsfException {
+    return (Map<Integer, String>) call("job.list");
+  }
+
+  public Map<Integer, SessionInfo> getSessions() throws IOException, MsfException {
+    return (Map<Integer, SessionInfo>) call("session.list");
+  }
+
+  public String[] getSessionCompatibleModules(int sessionId) throws IOException, MsfException {
+    return (String[]) call("session.compatible_modules", sessionId);
+  }
+
+  public void stopSession(int sessionId) throws IOException, MsfException {
+    call("session.stop", sessionId);
+  }
+
+  public String readFromShellSession(int sessionId) throws IOException, MsfException {
+    return (String) call("session.shell_read", sessionId);
+  }
+
+  public int writeToShellSession(int sessionId, String data) throws IOException, MsfException {
+    return (Integer) call("session.shell_write", sessionId, data);
+  }
+
+  public void upgradeShellSession(int sessionId, String lhost, int lport) throws IOException, MsfException {
+    call("session.upgrade", sessionId, lhost, lport);
+  }
+
+  public String readFromMeterpreterSession(int sessionId) throws IOException, MsfException {
+    return (String) call("session.meterpreter_read", sessionId);
+  }
+
+  public boolean writeToMeterpreterSession(int sessionId, String data) throws IOException, MsfException {
+    return (Boolean) call("session.meterpreter_write", sessionId, data);
+  }
+
+  public boolean detachMeterpreterSession(int sessionId) throws IOException, MsfException {
+    return (Boolean) call("session.meterpreter_detach", sessionId);
+  }
+
+  public boolean killMeterpreterSession(int sessionId) throws IOException, MsfException {
+    return (Boolean) call("session.meterpreter_session_kill", sessionId);
+  }
+
+  public String[] getMeterpreterTabs(int sessionId, String base) throws IOException, MsfException {
+    return (String[]) call("session.meterpreter_tabs", sessionId, base);
+  }
+
+  public Map<String, OptionInfo> getModuleOptions(String type, String name) throws IOException, MsfException {
+    return (Map<String, OptionInfo>) call("module.options", type, name);
+  }
+
+  public int execute(String type, String name, Map options) throws IOException, MsfException {
+    return (Integer) call("module.execute", type, name, options);
+  }
+
+  public byte[] generatePayload(String type, String name, Map options) throws IOException, MsfException {
+    return (byte[]) call("module.execute", type, name, options);
+  }
+
+  public ConsoleInfo createConsole(boolean allowCommandPassthru, boolean realReadline, String histFile,
+                                   String[] resources, boolean skipDatabaseInit) throws IOException, MsfException {
+
+    Map<String, Object> options = new HashMap<>();
+
+    options.put("AllowCommandPassthru", allowCommandPassthru);
+    options.put("RealReadline", realReadline);
+    options.put("SkipDatabaseInit", skipDatabaseInit);
+
+    if(resources != null) {
+      options.put("Resources", resources);
+    }
+
+    if(histFile != null) {
+      options.put("HistFile", histFile);
+    }
+
+    return (ConsoleInfo) call("console.create", options);
+  }
+
+  public ConsoleInfo createConsole() throws IOException, MsfException {
+    return (ConsoleInfo) call("console.create");
+  }
+
+  public ConsoleInfo[] getConsoles() throws IOException, MsfException {
+    return (ConsoleInfo[]) call("console.list");
+  }
+
+  public boolean closeConsole(int id) throws IOException, MsfException {
+    return (Boolean) call("console.destroy", id);
+  }
+
+  public ConsoleReadInfo readFromConsole(int id) throws IOException, MsfException {
+    return (ConsoleReadInfo) call("console.read", id);
+  }
+
+  public int writeToConsole(int id, String data) throws IOException, MsfException {
+    return (Integer) call("console.write", id, data);
+  }
+
+  public String[] getConsoleTabs(int id, String part) throws IOException, MsfException {
+    return (String[]) call("console.tabs", id, part);
+  }
+
+  public boolean killSessionInConsole(int id) throws IOException, MsfException {
+    return (Boolean) call("console.session_kill", id);
+  }
+
+  public boolean detachSessionFromConsole(int id) throws IOException, MsfException {
+    return (Boolean) call("console.session_detach", id);
+  }
+
+  @Override
+  public String toString() {
+    return String.format("%s: { Url: %s }", this.getClass().getSimpleName(), u);
+  }
+
+  public static class ModuleInfo {
+    public String name, description, license, filepath;
+    public int rank;
+    public String[][] references;
+    public String[] authors;
+    public Map<Integer, String> targets;
+    public int defaultTarget;
+    public Map<Integer, String> actions;
+    public int defaultAction;
+  }
+
+  public static class JobInfo {
+    public int id;
+    public String name;
+    public int startTime;
+  }
+
+  public static class SessionInfo {
+    public String type,
+                  tunnelLocal,
+                  tunnelPeer,
+                  viaExploit,
+                  viaPayload,
+                  description,
+                  info,
+                  workspace,
+                  sessionHost,
+                  targetHost,
+                  username,
+                  uuid,
+                  exploitUuid,
+                  platform;
+    public int sessionPort;
+    public String[] routes;
+  }
+
+  public static class OptionInfo {
+    String type, description;
+    boolean required, advanced, evasion;
+    Object defaultValue;
+    String[] enums;
+  }
+
+  public static class ConsoleInfo implements MessagePackable {
+    public int id;
+    public String prompt;
+    public boolean busy;
+
+    @Override
+    public void writeTo(Packer pk) throws IOException {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void readFrom(Unpacker u) throws IOException {
+      int size = u.readMapBegin();
+
+      for(int i = 0; i < size; i++) {
+        String key = u.readString();
+        switch (key) {
+          case "id":
+            id = Integer.parseInt(u.readString());
+            break;
+          case "prompt":
+            prompt = u.readString();
+            break;
+          case "busy":
+            busy = u.readBoolean();
+            break;
+        }
+      }
+
+      u.readMapEnd();
+    }
+  }
+
+  public static class ConsoleReadInfo {
+    public String data;
+    public String prompt;
+    public boolean busy;
+  }
+
+  public static class ServerException extends MsfException {
+    public ServerException(String causeClass, String message) {
+      super(causeClass + ": " + message);
+    }
+  }
+
+  private static class ServerExceptionTemplate extends AbstractTemplate<ServerException> {
+
+    private static final ServerExceptionTemplate instance = new ServerExceptionTemplate();
+
+    private ServerExceptionTemplate() {
+      super();
+    }
+
+    public static ServerExceptionTemplate getInstance() {
+      return instance;
+    }
+
+    @Override
+    public void write(Packer pk, ServerException v, boolean required) throws IOException {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public ServerException read(Unpacker u, ServerException to, boolean required) throws IOException {
+      if(!required && u.trySkipNil()) {
+        return null;
+      }
+
+      boolean error = false;
+      String klass = null;
+      String message = null;
+      String[] backtrace = null;
+
+      if(u.getNextType() != ValueType.MAP) {
+        throw new IllegalArgumentException();
+      }
+
+      int size = u.readMapBegin();
+
+      for(int i = 0; i < size && (!error || message == null || backtrace == null); i++) {
+        String key = u.read(Templates.TString);
+        switch (key) {
+          case "error_string":
+          case "error_message":
+            message = u.readString();
+            break;
+          case "error_backtrace":
+            backtrace = u.read(String[].class);
+            break;
+          case "error_class":
+            klass = u.readString();
+            break;
+          case "error":
+            error = u.readBoolean();
+            break;
+          default:
+            u.skip();
+        }
+      }
+
+      u.readMapEnd();
+
+      if(!error) {
+        throw new IllegalArgumentException();
+      }
+
+      if(to == null) {
+        // this will not overwrite the previous message...
+        to = new ServerException(
+                klass == null ? "Unknown" : klass,
+                message);
+      }
+
+      if(backtrace != null) {
+        fillStackTrace(backtrace, to);
+      }
+
+      return to;
+    }
+
+    private void fillStackTrace(String[] backtrace, Exception to) {
+      Matcher matcher;
+      String file, filename, func;
+      int line;
+      ArrayList<StackTraceElement> trace = new ArrayList<>();
+
+      for (String str : backtrace) {
+        matcher = RUBY_STACKTRACE_PATTERN.matcher(str);
+        if(!matcher.find()) {
+          continue;
+        }
+
+        file = matcher.group(2);
+        filename = matcher.group(3);
+        line = Integer.parseInt(matcher.group(5));
+        func = matcher.group(6);
+
+        trace.add(new StackTraceElement(filename, func, file, line));
+      }
+
+      StackTraceElement[] traceElements = new StackTraceElement[trace.size()];
+      trace.toArray(traceElements);
+      to.setStackTrace(traceElements);
+    }
+  }
+
+  private static class ModuleInfoTemplate extends AbstractTemplate<ModuleInfo> {
+
+    private static final ModuleInfoTemplate instance = new ModuleInfoTemplate();
+
+    private ModuleInfoTemplate() {
+      super();
+    }
+
+    public static ModuleInfoTemplate getInstance() {
+      return instance;
+    }
+
+    @Override
+    public void write(Packer pk, ModuleInfo v, boolean required) throws IOException {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public ModuleInfo read(Unpacker u, ModuleInfo to, boolean required) throws IOException {
+      if(!required && u.trySkipNil()) {
+        return null;
+      }
+
+      if(to == null) {
+        to = new ModuleInfo();
+      }
+
+      int size = u.readMapBegin();
+
+      to.defaultTarget = to.defaultAction = -1;
+
+      for(int i = 0; i < size; i++ ) {
+        String key = u.read(Templates.TString);
+        switch (key) {
+          case "name":
+            to.name = u.readString();
+            break;
+          case "description":
+            to.description = u.readString();
+            break;
+          case "license":
+            to.license = u.readString();
+            break;
+          case "rank":
+            to.rank = u.readInt();
+            break;
+          case "references":
+            to.references = u.read(String[][].class);
+            break;
+          case "authors":
+            to.authors = u.read(String[].class);
+            break;
+          case "targets":
+            to.targets = u.read(mapIntegerStringTemplate);
+            break;
+          case "default_target":
+            to.defaultTarget = u.readInt();
+            break;
+          case "actions":
+            to.actions = u.read(mapIntegerStringTemplate);
+            break;
+          case "default_action":
+            to.defaultAction = u.readInt();
+            break;
+          case "filepath":
+            to.filepath = u.readString();
+            break;
+          default:
+            u.skip();
+        }
+      }
+
+      u.readMapEnd();
+
+      if(to.references == null) {
+        to.references = new String[0][2];
+      }
+
+      if(to.authors == null) {
+        to.authors = new String[0];
+      }
+
+      return to;
+    }
+  }
+
+  private static class JobInfoTemplate extends AbstractTemplate<JobInfo> {
+
+    private static final JobInfoTemplate instance = new JobInfoTemplate();
+
+    private JobInfoTemplate() {
+      super();
+    }
+
+    public static JobInfoTemplate getInstance() {
+      return instance;
+    }
+
+    @Override
+    public void write(Packer pk, JobInfo v, boolean required) throws IOException {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public JobInfo read(Unpacker u, JobInfo to, boolean required) throws IOException {
+      if(!required && u.trySkipNil()) {
+        return null;
+      }
+      int size = u.readMapBegin();
+
+      if(to == null) {
+        to = new JobInfo();
+      }
+
+      for(int i = 0; i < size; i++) {
+        String key = u.readString();
+        switch (key) {
+          case "jid":
+            to.id = u.readInt();
+            break;
+          case "name":
+            to.name = u.readString();
+            break;
+          case "start_time":
+            to.startTime = u.readInt();
+            break;
+          default:
+            u.skip();
+        }
+      }
+
+      u.readMapEnd();
+
+      return to;
+    }
+  }
+
+  private static class SessionInfoTemplate extends AbstractTemplate<SessionInfo> {
+
+    private static final SessionInfoTemplate instance = new SessionInfoTemplate();
+
+    private SessionInfoTemplate() {
+      super();
+    }
+
+    public static SessionInfoTemplate getInstance() {
+      return instance;
+    }
+
+    @Override
+    public void write(Packer pk, SessionInfo v, boolean required) throws IOException {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public SessionInfo read(Unpacker u, SessionInfo to, boolean required) throws IOException {
+      if(!required && u.trySkipNil()) {
+        return null;
+      }
+
+      if(to == null) {
+        to = new SessionInfo();
+      }
+
+      int size = u.readMapBegin();
+
+      for(int i = 0; i < size; i++) {
+        String key = u.readString();
+        switch (key) {
+          case "type":
+            to.type = u.readString();
+            break;
+          case "tunnel_local":
+            to.tunnelLocal = u.readString();
+            break;
+          case "tunnel_peer":
+            to.tunnelPeer = u.readString();
+            break;
+          case "via_exploit":
+            to.viaExploit = u.readString();
+            break;
+          case "via_payload":
+            to.viaPayload = u.readString();
+            break;
+          case "desc":
+            to.description = u.readString();
+            break;
+          case "info":
+            to.info = u.readString();
+            break;
+          case "workspace":
+            to.workspace = u.readString();
+            break;
+          case "session_host":
+            to.sessionHost = u.readString();
+            break;
+          case "session_port":
+            to.sessionPort = u.readInt();
+            break;
+          case "target_host":
+            to.targetHost = u.readString();
+            break;
+          case "username":
+            to.username = u.readString();
+            break;
+          case "uuid":
+            to.uuid = u.readString();
+            break;
+          case "exploit_uuid":
+            to.exploitUuid = u.readString();
+            break;
+          case "routes":
+            to.routes = u.readString().split(",");
+            break;
+          case "platform":
+            to.platform = u.readString();
+            break;
+          default:
+            u.skip();
+        }
+      }
+
+      u.readMapEnd();
+
+      return to;
+    }
+  }
+
+  private static class OptionTemplate extends AbstractTemplate<OptionInfo> {
+
+    private static final OptionTemplate instance = new OptionTemplate();
+
+    private OptionTemplate() {
+      super();
+    }
+
+    public static OptionTemplate getInstance() {
+      return instance;
+    }
+
+    @Override
+    public void write(Packer pk, OptionInfo v, boolean required) throws IOException {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public OptionInfo read(Unpacker u, OptionInfo to, boolean required) throws IOException {
+      if(!required && u.trySkipNil()) {
+        return null;
+      }
+
+      if(to == null) {
+        to = new OptionInfo();
+      }
+
+      int size = u.readMapBegin();
+      to.defaultValue = null;
+      to.enums = null;
+
+      for(int i = 0; i < size; i++) {
+        String key = u.readString();
+        switch (key) {
+          case "type":
+            to.type = u.readString();
+            break;
+          case "required":
+            to.required = u.readBoolean();
+            break;
+          case "advanced":
+            to.advanced = u.readBoolean();
+            break;
+          case "evasion":
+            to.evasion = u.readBoolean();
+            break;
+          case "desc":
+            to.description = u.readString();
+            break;
+          case "default":
+            Value val = u.readValue();
+            to.defaultValue = readSingleObject(val);
+            break;
+          case "enums":
+            to.enums = u.read(String[].class);
+            break;
+        }
+      }
+
+      u.readMapEnd();
+
+      return to;
+    }
+
+    private Object readSingleObject(Value value) {
+      switch (value.getType()) {
+        case BOOLEAN:
+          return value.asBooleanValue().getBoolean();
+        case FLOAT:
+          return value.asFloatValue().getFloat();
+        case INTEGER:
+          Long result = value.asIntegerValue().getLong();
+          if(result < Integer.MAX_VALUE && result > Integer.MIN_VALUE) {
+            return result.intValue();
+          }
+          return result;
+        case RAW:
+          return value.asRawValue().getString();
+        case NIL:
+        default:
+          return null;
+      }
+    }
+  }
+
+  private static class ConsoleReadInfoTemplate extends AbstractTemplate<ConsoleReadInfo> {
+
+    private static final ConsoleReadInfoTemplate instance = new ConsoleReadInfoTemplate();
+
+    private ConsoleReadInfoTemplate() { }
+
+    public static ConsoleReadInfoTemplate getInstance() {
+      return instance;
+    }
+
+    @Override
+    public void write(Packer pk, ConsoleReadInfo v, boolean required) throws IOException {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public ConsoleReadInfo read(Unpacker u, ConsoleReadInfo to, boolean required) throws IOException {
+      if(!required && u.trySkipNil()) {
+        return null;
+      }
+      int size = u.readMapBegin();
+      int foundFieldsCount = 0;
+
+      if(to == null) {
+        to = new ConsoleReadInfo();
+      }
+
+      for(int i = 0; i < size; i++) {
+        String key = u.readString();
+        switch (key) {
+          case "data":
+            to.data = u.readString();
+            break;
+          case "prompt":
+            to.prompt = u.readString();
+            break;
+          case "busy":
+            to.busy = u.readBoolean();
+            break;
+          default:
+            u.skip();
+            continue;
+        }
+        foundFieldsCount++;
+      }
+
+      if(foundFieldsCount != 3) {
+        throw new IOException("not a " + getClass().getSimpleName() + " hash");
+      }
+
+      u.readMapEnd();
+
+      return to;
+    }
+  }
+
+  private static class BooleanResultTemplate extends AbstractTemplate<Boolean> {
+
+    private static final BooleanResultTemplate instance = new BooleanResultTemplate();
+
+    private BooleanResultTemplate() { }
+
+    public static BooleanResultTemplate getInstance() {
+      return instance;
+    }
+
+    @Override
+    public void write(Packer pk, Boolean v, boolean required) throws IOException {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public Boolean read(Unpacker u, Boolean to, boolean required) throws IOException {
+      if(!required && u.trySkipNil()) {
+        return null;
+      }
+      int size = u.readMapBegin();
+
+      for(int i = 0; i < size; i++) {
+        String key = u.readString().toLowerCase();
+        if(!key.equals("result")) {
+          u.skip();
+          continue;
+        }
+        switch (u.getNextType()) {
+          case RAW:
+            String value = u.readString().toLowerCase();
+            to = value.equals("success") || value.equals("yes") || value.equals("true");
+            break;
+          case BOOLEAN:
+            to = u.readBoolean();
+            break;
+          default:
+            throw new IOException("not a boolean result: " + u.readValue());
+        }
+        break;
+      }
+
+      u.readMapEnd();
+
+      return to;
+    }
+  }
+
+  private static class SingleTemplate<T> extends AbstractTemplate<T> {
+
+    private static final SingleTemplate<Integer> writeInstance = new SingleTemplate<>("write_count", int.class);
+    private static final SingleTemplate<Integer> wroteInstance = new SingleTemplate<>("wrote", int.class);
+    private static final SingleTemplate<Integer> jobIdInstance = new SingleTemplate<>("job_id", int.class);
+    private static final SingleTemplate<String>  readInstance  = new SingleTemplate<>("data", String.class);
+    private static final SingleTemplate<byte[]> payloadGenerateInstance = new SingleTemplate<>("payload", byte[].class);
+    private static final SingleTemplate<String[]> modulesInstance = new SingleTemplate<>("modules", String[].class);
+    private static final SingleTemplate<String[]> tabsInstance = new SingleTemplate<>("tabs", String[].class);
+    private static final SingleTemplate<ConsoleInfo[]> consolesInstance = new SingleTemplate<>("consoles", ConsoleInfo[].class);
+    private static final SingleTemplate<String[]> payloadsInstance = new SingleTemplate<>("payloads", String[].class);
+
+    private final String mapKey;
+    private final Class<? extends T> klass;
+
+    private SingleTemplate(String mapkey, Class<? extends T> klass) {
+      super();
+      this.mapKey = mapkey;
+      this.klass = klass;
+    }
+
+    public static SingleTemplate<Integer> getWriteInstance() {
+      return writeInstance;
+    }
+
+    public static SingleTemplate<Integer> getJobIdInstance() {
+      return jobIdInstance;
+    }
+
+    public static SingleTemplate<String> getReadInstance() {
+      return readInstance;
+    }
+
+    public static SingleTemplate<byte[]> getPayloadGenerateInstance() {
+      return payloadGenerateInstance;
+    }
+
+    public static SingleTemplate<String[]> getModulesInstance() {
+      return modulesInstance;
+    }
+
+    public static SingleTemplate<String[]> getTabsInstance() {
+      return tabsInstance;
+    }
+
+    public static SingleTemplate<ConsoleInfo[]> getConsolesInstance() {
+      return consolesInstance;
+    }
+
+    public static SingleTemplate<Integer> getWroteInstance() {
+      return wroteInstance;
+    }
+
+    public static SingleTemplate<String[]> getPayloadsInstance() {
+      return payloadsInstance;
+    }
+
+    @Override
+    public void write(Packer pk, T v, boolean required) throws IOException {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public T read(Unpacker u, T to, boolean required) throws IOException {
+      if(!required && u.trySkipNil()) {
+        return null;
+      }
+
+      int size = u.readMapBegin();
+      boolean found = false;
+
+      to = null;
+      for(int i = 0; i < size; i++) {
+        String key = u.readString();
+        if(mapKey.equals(key)) {
+          to = u.read(klass);
+          found = true;
+          break;
+        }
+        u.skip();
+      }
+
+      if(!found) {
+        throw new IOException("hash does not contain key '" + mapKey + "'");
+      }
+
+      u.readMapEnd();
+
+      return to;
+    }
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/MsgpackConsole.java b/msf/src/main/java/org/csploit/msf/impl/MsgpackConsole.java
new file mode 100644
index 0000000000..98967a8a23
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/MsgpackConsole.java
@@ -0,0 +1,121 @@
+package org.csploit.msf.impl;
+
+import org.csploit.msf.api.MsfException;
+
+import java.io.IOException;
+
+/**
+ * A Console implementor that uses Msgpack RPC
+ */
+class MsgpackConsole implements InternalConsole {
+  private final MsgpackClient client;
+  private final int id;
+  private String prompt;
+  private boolean busy;
+  private boolean interacting = false;
+  private boolean changed = false;
+
+  public MsgpackConsole(MsgpackClient client, int id) {
+    this.client = client;
+    this.id = id;
+  }
+
+  @Override
+  public int getId() {
+    return id;
+  }
+
+  @Override
+  public String getPrompt() {
+    return prompt;
+  }
+
+  public void setPrompt(String prompt) {
+    changed |= this.prompt == null ? prompt != null : !this.prompt.equals(prompt);
+    this.prompt = prompt;
+  }
+
+  @Override
+  public boolean isBusy() {
+    return busy;
+  }
+
+  public void setBusy(boolean busy) {
+    changed |= this.busy != busy;
+    this.busy = busy;
+  }
+
+  @Override
+  public void close() throws IOException, MsfException {
+    client.closeConsole(id);
+  }
+
+  @Override
+  public String read() throws IOException, MsfException {
+    MsgpackClient.ConsoleReadInfo info = client.readFromConsole(id);
+
+    setPrompt(info.prompt);
+    setBusy(info.busy);
+
+    return info.data;
+  }
+
+  @Override
+  public void write(String data) throws IOException, MsfException {
+    int sent = client.writeToConsole(id, data);
+    while(sent < data.length()) {
+      client.writeToConsole(id, data.substring(sent));
+    }
+  }
+
+  @Override
+  public String[] tab(String part) throws IOException, MsfException {
+    return client.getConsoleTabs(id, part);
+  }
+
+  @Override
+  public void killSession() throws IOException, MsfException {
+    client.killSessionInConsole(id);
+  }
+
+  @Override
+  public void detachSession() throws IOException, MsfException {
+    client.detachSessionFromConsole(id);
+  }
+
+  @Override
+  public void interact() throws IOException, MsfException {
+    interacting = true;
+  }
+
+  @Override
+  public void suspend() throws IOException, MsfException {
+    interacting = false;
+  }
+
+  @Override
+  public void complete() throws IOException, MsfException {
+    suspend();
+    close();
+  }
+
+  @Override
+  public boolean isInteracting() throws IOException, MsfException {
+    return interacting;
+  }
+
+  @Override
+  public void clearChanged() {
+    changed = false;
+  }
+
+  @Override
+  public boolean hasChanged() {
+    return changed;
+  }
+
+  @Override
+  public String toString() {
+    return String.format("MsgpackConsole: {id=%d, busy=%s}", id, busy);
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/MsgpackConsoleManager.java b/msf/src/main/java/org/csploit/msf/impl/MsgpackConsoleManager.java
new file mode 100644
index 0000000000..9d3248512f
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/MsgpackConsoleManager.java
@@ -0,0 +1,305 @@
+package org.csploit.msf.impl;
+
+import org.csploit.msf.api.Console;
+import org.csploit.msf.api.ConsoleManager;
+import org.csploit.msf.api.MsfException;
+import org.csploit.msf.api.events.ConsoleChangedEvent;
+import org.csploit.msf.api.events.ConsoleClosedEvent;
+import org.csploit.msf.api.events.ConsoleOpenedEvent;
+import org.csploit.msf.api.events.ConsoleOutputEvent;
+import org.csploit.msf.api.exceptions.ResourceNotFoundException;
+import org.csploit.msf.api.listeners.ConsoleListener;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.TreeSet;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+/**
+ * A console Manager that use a Msgpack RPC connection to deal with the framework
+ */
+class MsgpackConsoleManager implements ConsoleManager, Runnable {
+  private static final int SLEEP_INTERVAL = 3000;
+  private static final int WORK_INTERVAL = 300;
+
+  private final MsgpackClient client;
+  private final Map<Integer, MsgpackConsole> map = new TreeMap<>();
+  private final Set<ConsoleListener> listeners = new HashSet<>();
+  private final ExecutorService executor;
+  private Thread thread;
+  private boolean running;
+
+  public MsgpackConsoleManager(MsgpackClient client) {
+    this.client = client;
+    executor = Executors.newSingleThreadExecutor();
+  }
+
+  private void updateConsoles() throws IOException, MsfException {
+    MsgpackClient.ConsoleInfo[] remote = client.getConsoles(); // n
+    List<Integer> remoteIds = new LinkedList<>();
+    Set<Integer> toRemove;
+
+    // MAX(n, m, n * log(m), m * log(m), 2n * log(m)) => log(m) * MAX(2n, m)
+
+    for (MsgpackClient.ConsoleInfo info : remote) { // n
+      remoteIds.add(info.id); // 1
+    }
+
+    synchronized (map) {
+      // toRemove = local - remote
+      toRemove = new TreeSet<>(map.keySet()); // m
+
+      for (Integer id : remoteIds) { // n
+        toRemove.remove(id); // log(m)
+      }
+
+      for (Integer id : toRemove) { // m
+        Console c = map.remove(id); // log(m)
+        notifyConsoleClosed(c);
+      }
+
+      for (MsgpackClient.ConsoleInfo info : remote) { // n
+        MsgpackConsole console = map.get(info.id); // log(m)
+        if (console != null) {
+          MsgpackLoader.fillConsole(info, console);
+
+          if (console.hasChanged()) {
+            notifyConsoleChanged(console);
+            console.clearChanged();
+          }
+        } else {
+          console = buildConsole(info);
+          map.put(info.id, console); // log(m)
+          notifyConsoleOpened(console);
+        }
+      }
+    }
+  }
+
+  @Override
+  public List<? extends Console> getConsoles() throws IOException, MsfException {
+
+    updateConsoles();
+
+    synchronized (map) {
+      return new ArrayList<>(map.values());
+    }
+  }
+
+  @Override
+  public Console getConsole(int id) throws IOException, MsfException {
+    Console result;
+    synchronized (map) {
+      result = map.get(id);
+      if(result != null) {
+        return result;
+      }
+    }
+
+    updateConsoles();
+
+    synchronized (map) {
+      result = map.get(id);
+    }
+
+    if(result == null) {
+      throw new ResourceNotFoundException("console #" + id + " not found");
+    }
+
+    return result;
+  }
+
+  private MsgpackConsole addConsole(MsgpackClient.ConsoleInfo info) throws IOException, MsfException {
+    MsgpackConsole console;
+    synchronized (map) {
+      console = map.remove(info.id);
+      if(console != null) {
+        console.complete();
+      }
+      console = buildConsole(info);
+      map.put(info.id, console);
+    }
+
+    notifyConsoleOpened(console);
+    return console;
+  }
+
+  @Override
+  public Console create(boolean allowCommandPassthru, boolean realReadline, String histFile, String[] resources, boolean skipDatabaseInit) throws IOException, MsfException {
+    MsgpackClient.ConsoleInfo info = client.createConsole(allowCommandPassthru, realReadline, histFile, resources, skipDatabaseInit);
+
+    return addConsole(info);
+  }
+
+  @Override
+  public Console create() throws IOException, MsfException {
+    MsgpackClient.ConsoleInfo info = client.createConsole();
+
+    return addConsole(info);
+  }
+
+  @Override
+  public void addSubscriber(ConsoleListener listener) {
+    synchronized (listeners) {
+      listeners.add(listener);
+    }
+  }
+
+  @Override
+  public void removeSubscriber(ConsoleListener listener) {
+    synchronized (listeners) {
+      listeners.remove(listener);
+    }
+  }
+
+  @Override
+  public void run() {
+    running = true;
+
+    while(running) {
+
+      Set<InternalConsole> copy;
+
+      synchronized (map) {
+        copy = new HashSet<InternalConsole>(map.values());
+      }
+
+      boolean interacting = false;
+
+      for(InternalConsole c : copy) {
+        if(!interacting) {
+          try {
+            interacting = c.isInteracting();
+          } catch (IOException | MsfException e) {
+            // ignored
+          }
+        }
+
+        try {
+          String output = c.read();
+
+          if(output != null && output.length() > 0) {
+            notifyConsoleOutput(c, output);
+          }
+
+          if(c.hasChanged()) {
+            c.clearChanged();
+            notifyConsoleChanged(c);
+          }
+        } catch (IOException | MsfException e) {
+          // ignored
+        }
+      }
+
+      try {
+        getConsoles();
+      } catch (IOException | MsfException e) {
+        // ignored
+      }
+
+      long interval = interacting ? WORK_INTERVAL : SLEEP_INTERVAL;
+
+      try {
+        Thread.sleep(interval);
+      } catch (InterruptedException e) {
+        running = false;
+      }
+    }
+  }
+
+  public void start() {
+    stop();
+    thread = new Thread(this, getClass().getSimpleName());
+    thread.start();
+  }
+
+  public void stop() {
+    if(thread != null && thread.isAlive()) {
+      running = false;
+      try {
+        thread.join();
+      } catch (InterruptedException e) {
+        // ignored
+      }
+    }
+  }
+
+  private MsgpackConsole buildConsole(MsgpackClient.ConsoleInfo info) {
+    MsgpackConsole console = new MsgpackConsole(client, info.id);
+    MsgpackLoader.fillConsole(info, console);
+    return console;
+  }
+
+  private void notifyConsoleOpened(Console console) {
+    final ConsoleOpenedEvent event = new ConsoleOpenedEvent(this, console);
+
+    executor.execute(new Runnable() {
+      @Override
+      public void run() {
+        synchronized (listeners) {
+          for (ConsoleListener listener : listeners) {
+            listener.onConsoleOpened(event);
+          }
+        }
+      }
+    });
+  }
+
+  private void notifyConsoleChanged(Console console) {
+    final ConsoleChangedEvent event = new ConsoleChangedEvent(this, console);
+
+    executor.execute(new Runnable() {
+      @Override
+      public void run() {
+        synchronized (listeners) {
+          for (ConsoleListener listener : listeners) {
+            listener.onConsoleChanged(event);
+          }
+        }
+      }
+    });
+  }
+
+  private void notifyConsoleOutput(Console console, String output) {
+    final ConsoleOutputEvent event = new ConsoleOutputEvent(this, console, output);
+
+    executor.execute(new Runnable() {
+      @Override
+      public void run() {
+        synchronized (listeners) {
+          for(ConsoleListener listener : listeners) {
+            listener.onConsoleOutput(event);
+          }
+        }
+      }
+    });
+  }
+
+  private void notifyConsoleClosed(Console console) {
+    final ConsoleClosedEvent event = new ConsoleClosedEvent(this, console);
+
+    executor.execute(new Runnable() {
+      @Override
+      public void run() {
+        synchronized (listeners) {
+          for(ConsoleListener listener : listeners) {
+            listener.onConsoleClosed(event);
+          }
+        }
+      }
+    });
+  }
+
+  @Override
+  protected void finalize() throws Throwable {
+    super.finalize();
+    stop();
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/MsgpackFactory.java b/msf/src/main/java/org/csploit/msf/impl/MsgpackFactory.java
new file mode 100644
index 0000000000..576e67035b
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/MsgpackFactory.java
@@ -0,0 +1,44 @@
+package org.csploit.msf.impl;
+
+import org.csploit.msf.api.*;
+import org.csploit.msf.api.Framework;
+
+import java.io.IOException;
+
+/**
+ * A factory that create MSF stuff using a Messagepack connection
+ */
+public class MsgpackFactory {
+  private final MsgpackClient client;
+  private final MsgpackProxy.FrameworkFactory frameworkFactory;
+
+  /**
+   * create a {@link MsgpackFactory} using the specified parameters
+   * @param host to connect to
+   * @param username username
+   * @param password password
+   * @param port port to connect to
+   * @param ssl shall we connect using SSL ?
+   */
+  public MsgpackFactory(String host, String username, String password, int port, boolean ssl)
+          throws IOException, MsfException {
+    this.client = new MsgpackClient(host, username, password, port, ssl);
+    frameworkFactory = new MsgpackProxy.FrameworkFactory(client);
+  }
+
+  /**
+   * create a {@link Framework}
+   * @return a new {@link Framework}
+   */
+  public Framework createFramework() {
+    return frameworkFactory.createFramework();
+  }
+
+  /**
+   * create a {@link ConsoleManager}
+   * @return a new {@link ConsoleManager}
+   */
+  public ConsoleManager createConsoleManager() {
+    return new MsgpackConsoleManager(client);
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/MsgpackLoader.java b/msf/src/main/java/org/csploit/msf/impl/MsgpackLoader.java
new file mode 100644
index 0000000000..c1771f25bd
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/MsgpackLoader.java
@@ -0,0 +1,345 @@
+package org.csploit.msf.impl;
+
+import org.csploit.msf.api.License;
+import org.csploit.msf.api.Exploit;
+import org.csploit.msf.api.Payload;
+import org.csploit.msf.api.Module;
+import org.csploit.msf.api.Session;
+import org.csploit.msf.api.MsfException;
+import org.csploit.msf.api.module.Rank;
+import org.csploit.msf.impl.module.AuxiliaryAction;
+import org.csploit.msf.impl.module.Reference;
+import org.csploit.msf.impl.module.SiteReference;
+import org.csploit.msf.impl.module.Target;
+import org.csploit.msf.impl.options.*;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Date;
+import java.util.Map;
+import java.util.regex.Pattern;
+
+/**
+ * Load MSF content from Msgpack responses
+ */
+@SuppressWarnings("unchecked, rawtypes")
+class MsgpackLoader {
+
+  private final MsgpackClient client;
+  private final InternalFramework framework;
+
+  private final MsgpackProxy.ModuleFactory moduleFactory;
+  private final MsgpackProxy.SessionFactory sessionFactory;
+
+  public MsgpackLoader(MsgpackClient client, InternalFramework framework) {
+    this.client = client;
+    this.framework = framework;
+
+    moduleFactory = new MsgpackProxy.ModuleFactory(client, framework);
+    sessionFactory = new MsgpackProxy.SessionFactory(client, framework);
+  }
+
+  public Module loadModule(String fullname) throws IOException, MsfException {
+    String[] parts = NameHelper.getTypeAndRefnameFromFullname(fullname);
+    return loadModule(parts[0], parts[1]);
+  }
+
+  public Module loadModule(String type, String name) throws IOException, MsfException {
+    NameHelper.assertValidModuleType(type);
+    InternalModule result = framework.getModuleManager().get(type, name);
+
+    if(result != null && !isModuleAlreadyFetched(result)) {
+      fillModule(result, client.getModuleInfo(type, name));
+    } else if(result == null) {
+      result = fetchModule(type, name);
+      if(result instanceof MsgpackProxy.MsgpackCommunicator) {
+        ((MsgpackProxy.MsgpackCommunicator) result).setClient(client);
+      }
+      framework.getModuleManager().put(result);
+    }
+
+    return result;
+  }
+
+  public Module lazyLoadModule(String type, String name) throws NameHelper.BadModuleTypeException {
+    InternalModule result = framework.getModuleManager().get(type, name);
+
+    if(result != null) {
+      return result;
+    }
+
+    result = moduleFactory.createModule(type, name);
+
+    result.setFramework(framework);
+
+    if(result instanceof MsgpackProxy.MsgpackCommunicator) {
+      ((MsgpackProxy.MsgpackCommunicator) result).setClient(client);
+    }
+
+    framework.getModuleManager().put(result);
+
+    return result;
+  }
+
+  private InternalModule fetchModule(String type, String refname) throws IOException, MsfException, IllegalArgumentException {
+    InternalModule module = moduleFactory.createModule(type, refname);
+    MsgpackClient.ModuleInfo response = client.getModuleInfo(type, refname);
+
+    fillModule(module, response);
+
+    module.setFramework(framework);
+
+    if(module instanceof MsgpackProxy.MsgpackCommunicator) {
+      ((MsgpackProxy.MsgpackCommunicator) module).setClient(client);
+    }
+
+    return module;
+  }
+
+  static boolean isModuleAlreadyFetched(Module module) {
+    String desc = module.getDescription();
+    return desc != null && desc.length() > 0;
+  }
+
+  /**
+   * fill a module with data from the "module.info" response
+   * @param module the module to fill info in
+   * @param info ModuleInfo from Msgpack API
+   */
+  static void fillModule(InternalModule module, MsgpackClient.ModuleInfo info) {
+    module.setName(info.name);
+    module.setDescription(info.description);
+    module.setLicense(License.fromString(info.license));
+    module.setRank(Rank.fromValue(info.rank));
+
+    int maxTargetId, maxActionId;
+
+    maxTargetId = maxActionId = -1;
+
+    if(info.targets != null) {
+      for(Integer key : info.targets.keySet()) {
+        if(key >= maxTargetId) {
+          maxTargetId = key;
+        }
+      }
+    }
+
+    if(info.actions != null) {
+      for(Integer key : info.actions.keySet()) {
+        if(key >= maxActionId) {
+          maxActionId = key;
+        }
+      }
+    }
+
+    Reference[] references = new Reference[info.references.length];
+    Author[] authors = new Author[info.authors.length];
+    Target[] targets = maxTargetId < 0 ? null : new Target[maxTargetId + 1];
+    AuxiliaryAction[] actions = maxActionId < 0 ? null : new AuxiliaryAction[maxActionId + 1];
+
+    for(int i = 0; i < references.length; i++) {
+      String[] ctx = info.references[i];
+      String id = ctx[0];
+      String val = ctx[1];
+      references[i] = new SiteReference(id, val);
+    }
+
+    module.setReferences(references);
+
+    for(int i = 0; i < authors.length; i++) {
+      String author = info.authors[i];
+      authors[i] = Author.fromString(author);
+    }
+
+    module.setAuthors(authors);
+
+    if(targets != null && module instanceof InternalExploit) {
+      for(int i = 0; i < targets.length; i++) {
+        String name = info.targets.get(i);
+        targets[i] = new Target(name);
+      }
+      ((InternalExploit)module).setTargets(targets);
+
+      if(info.defaultTarget >= 0) {
+        ((InternalExploit)module).setDefaultTarget(info.defaultTarget);
+      }
+    }
+
+    if(actions != null && module instanceof Auxiliary) {
+      for( int i = 0 ; i < actions.length; i++) {
+        String name = info.actions.get(i);
+        actions[i] = new AuxiliaryAction(name);
+      }
+      ((Auxiliary) module).setActions(actions);
+
+      if(info.defaultAction >= 0) {
+        ((Auxiliary) module).setDefaultAction(info.defaultAction);
+      }
+    }
+  }
+
+  static void fillModuleOptions(InternalModule module, Map<String, MsgpackClient.OptionInfo> list) {
+
+    for(String name : list.keySet()) {
+      MsgpackClient.OptionInfo info = list.get(name);
+      AbstractOption result;
+
+      switch (info.type) {
+        case "address":
+          result = new AddressOption(name, info.required, info.description, (String) info.defaultValue);
+          break;
+        case "addressrange":
+          result = new AddressRangeOption(name, info.required, info.description, null);
+           break;
+        case "bool":
+          Boolean defValue = getBooleanDefaultValue(info.defaultValue);
+          result = new BooleanOption(name, info.required, info.description, defValue);
+          break;
+        case "enum":
+          String[] values = info.enums == null ? new String[] {(String) info.defaultValue} : info.enums;
+          result = new EnumOption(name, info.required, info.description, (String) info.defaultValue, values);
+          break;
+        case "port":
+          result = new PortOption(name, info.required, info.description, (Integer) info.defaultValue);
+          break;
+        case "path":
+          result = new PathOption(name, info.required, info.description,
+                  info.defaultValue == null ? null : new File((String) info.defaultValue));
+          break;
+        case "integer":
+          Long longDefValue = getLongDefaultValue(info.defaultValue);
+          result = new IntegerOption(name, info.required, info.description, longDefValue);
+          break;
+        case "regexp":
+          result = new RegexpOption(name, info.required, info.description,
+                  info.defaultValue == null ? null : Pattern.compile((String) info.defaultValue));
+          break;
+        case "raw":
+          result = new RawOption(name, info.required, info.description, (byte[]) info.defaultValue);
+          break;
+
+        default: // string
+          String s = info.defaultValue == null ? null : info.defaultValue.toString();
+          result = new StringOption(name, info.required, info.description, s);
+      }
+
+      result.setAdvanced(info.advanced);
+      result.setEvasion(info.evasion);
+
+      module.registerOption(result);
+    }
+  }
+
+  private static Boolean getBooleanDefaultValue(Object value) {
+    if(value instanceof String) {
+      String str = ((String) value).toLowerCase();
+      return str.startsWith("y") || str.equals("true") || str.equals("1");
+    }
+    return (Boolean) value;
+  }
+
+  private static Long getLongDefaultValue(Object value) {
+    if(value instanceof Integer) {
+      return ((Integer) value).longValue();
+    } else if(value instanceof String) {
+      return Long.parseLong((String) value);
+    }
+    return (Long) value;
+  }
+
+  public Session buildSession(int id, MsgpackClient.SessionInfo info)
+          throws NameHelper.BadSessionTypeException {
+    AbstractSession session;
+
+    session = sessionFactory.createSession(info.type, id);
+
+    session.setFramework(framework);
+    ((MsgpackProxy.MsgpackCommunicator) session).setClient(client);
+
+    session.setLocalTunnel(info.tunnelLocal);
+    session.setPeerTunnel(info.tunnelPeer);
+    session.setDescription(info.description);
+    session.setInfo(info.info);
+    session.setWorkspace(info.workspace);
+    session.setSessionHost(info.sessionHost);
+    session.setSessionPort(info.sessionPort);
+    session.setTargetHost(info.targetHost);
+    session.setUsername(info.username);
+    session.setUuid(info.uuid);
+    session.setRoutes(info.routes);
+
+    if(info.viaExploit != null && info.viaExploit.length() > 0) {
+      try {
+        session.setExploit((Exploit) lazyLoadModule("exploit", info.viaExploit));
+      } catch (NameHelper.BadModuleTypeException e) {
+        // ignored
+      }
+    }
+
+    if(info.viaPayload != null && info.viaPayload.length() > 0) {
+      try {
+        session.setPayload((Payload) lazyLoadModule("payload", info.viaPayload));
+      } catch (NameHelper.BadModuleTypeException e) {
+        // ignored
+      }
+    }
+
+    if(session instanceof InternalMeterpreter &&
+            info.platform != null && info.platform.length() > 0) {
+      ((InternalMeterpreter) session).setPlatform(info.platform);
+    }
+
+    return session;
+  }
+
+  public Job loadJob(int id) throws IOException, MsfException {
+    Job result = framework.getJobContainer().get(id);
+    MsgpackClient.JobInfo info;
+
+    if(result != null && !isJobAlreadyFetched(result)) {
+      info = client.getJobInfo(id);
+      fillJob(result, info);
+    } else if(result == null) {
+      result = new Job(id, null);
+      fillJob(result, client.getJobInfo(id));
+      framework.registerJob(result);
+    }
+
+    return result;
+  }
+
+  public Job lazyLoadJob(int id, String name) {
+    Job result = framework.getJobContainer().get(id);
+
+    if(result != null) {
+      return result;
+    }
+
+    result = new Job(id, name);
+
+    framework.registerJob(result);
+
+    return result;
+  }
+
+  private boolean isJobAlreadyFetched(Job job) {
+    return job.getStartTime() != null;
+  }
+
+  Job fillJob(Job job, MsgpackClient.JobInfo info) {
+    job.setName(info.name);
+    job.setStartTime(new Date(info.startTime));
+
+    return job;
+  }
+
+  /**
+   * fill a console with data from {@link org.csploit.msf.impl.MsgpackClient.ConsoleInfo}
+   * @param info source data
+   * @param console destination class
+   */
+  static void fillConsole(MsgpackClient.ConsoleInfo info, MsgpackConsole console) {
+    console.setBusy(info.busy);
+    console.setPrompt(info.prompt);
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/MsgpackProxy.java b/msf/src/main/java/org/csploit/msf/impl/MsgpackProxy.java
new file mode 100644
index 0000000000..b4ede5aeea
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/MsgpackProxy.java
@@ -0,0 +1,733 @@
+package org.csploit.msf.impl;
+
+import org.csploit.msf.api.Arch;
+import org.csploit.msf.api.Exploit;
+import org.csploit.msf.api.License;
+import org.csploit.msf.api.Module;
+import org.csploit.msf.api.MsfException;
+import org.csploit.msf.api.Option;
+import org.csploit.msf.api.Payload;
+import org.csploit.msf.api.Post;
+import org.csploit.msf.api.Session;
+import org.csploit.msf.api.module.AuxiliaryAction;
+import org.csploit.msf.api.module.Platform;
+import org.csploit.msf.api.module.Rank;
+import org.csploit.msf.api.module.Target;
+import org.csploit.msf.api.sessions.CommandShell;
+import org.csploit.msf.api.sessions.Interactive;
+import org.csploit.msf.api.sessions.UpgradableShell;
+import org.csploit.msf.impl.module.ArchSet;
+import org.csploit.msf.impl.module.PlatformList;
+import org.csploit.msf.impl.module.Reference;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.EventListener;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * A proxy that use Msgpack to talk with the framework instance
+ *
+ * used also as container for other Msgpack proxies classes
+ */
+@SuppressWarnings("unchecked, rawtypes")
+class MsgpackProxy implements InternalFramework {
+  private final Framework framework = new Framework();
+  private final MsgpackClient client;
+  private final MsgpackLoader loader;
+
+  public MsgpackProxy(MsgpackClient client) {
+    this.client = client;
+    this.loader = new MsgpackLoader(client, this);
+    framework.getSessionManager().setWatchList(true);
+  }
+
+  public void setGlobalOption(String key, String value) {
+    framework.setGlobalOption(key, value);
+  }
+
+  @Override
+  public void unsetGlobalOption(String key) {
+    framework.unsetGlobalOption(key);
+  }
+
+  public ModuleManager getModuleManager() {
+    return framework.getModuleManager();
+  }
+
+  @Override
+  public DataStore getDataStore() {
+    return framework.getDataStore();
+  }
+
+  @Override
+  public Module getModule(String refname) throws IOException, MsfException {
+    return loader.loadModule(refname);
+  }
+
+  @Override
+  public JobContainer getJobContainer() {
+    return framework.getJobContainer();
+  }
+
+  @Override
+  public void registerJob(Job job) {
+    framework.registerJob(job);
+  }
+
+  @Override
+  public void unregisterJob(int id) {
+    framework.unregisterJob(id);
+  }
+
+  @Override
+  public Job getJob(int id) throws IOException, MsfException {
+    return loader.loadJob(id);
+  }
+
+  @Override
+  public List<Job> getJobs() throws IOException, MsfException {
+    Map<Integer, String> result = client.getJobs();
+
+    for(Job j : framework.getJobs()) {
+      if(!result.containsKey(j.getId())) {
+        framework.unregisterJob(j.getId());
+      }
+    }
+
+    for(int id : result.keySet()) {
+      loader.lazyLoadJob(id, result.get(id));
+    }
+
+    return framework.getJobs();
+  }
+
+  @Override
+  public List<Session> getSessions() throws IOException, MsfException {
+    Map<Integer, MsgpackClient.SessionInfo> result = client.getSessions();
+    SessionManager manager = framework.getSessionManager();
+
+    for(Session session : manager.getSessions()) {
+      if(result.containsKey(session.getId())) {
+        // remove a session from the results
+        // when we already have it locally.
+        result.remove(session.getId());
+      } else {
+        // remove a session from local store
+        // when the remote lost it.
+        manager.unregister(session);
+      }
+    }
+
+    // parse the remaining results
+
+    for(int id : result.keySet()) {
+      try {
+        Session session = loader.buildSession(id, result.get(id));
+        manager.register(session);
+      } catch (NameHelper.BadSessionTypeException e) {
+        // not supported yet
+      }
+    }
+
+    return manager.getSessions();
+  }
+
+  @Override
+  public SessionManager getSessionManager() {
+    return framework.getSessionManager();
+  }
+
+  @Override
+  public void addSubscriber(EventListener listener) throws IOException, MsfException {
+    framework.addSubscriber(listener);
+  }
+
+  @Override
+  public void removeSubscriber(EventListener listener) throws IOException, MsfException {
+    framework.removeSubscriber(listener);
+  }
+
+  @Override
+  public List<? extends Exploit> getExploits() throws IOException, MsfException {
+    if(framework.getModuleManager().getOfType("exploit").isEmpty()) {
+      for(String name : client.getExploits()) {
+        loader.lazyLoadModule("exploit", name);
+      }
+    }
+    return framework.getExploits();
+  }
+
+  @Override
+  public List<? extends Payload> getPayloads() throws IOException, MsfException {
+    if(framework.getModuleManager().getOfType("payload").isEmpty()) {
+      for(String name : client.getPayloads()) {
+        loader.lazyLoadModule("payload", name);
+      }
+    }
+    return framework.getPayloads();
+  }
+
+  @Override
+  public List<? extends Post> getPosts() throws IOException, MsfException {
+    if(framework.getModuleManager().getOfType("post").isEmpty()) {
+      for(String name : client.getPosts()) {
+        loader.lazyLoadModule("post", name);
+      }
+    }
+    return framework.getPosts();
+  }
+
+  interface MsgpackCommunicator {
+    MsgpackClient getClient();
+    void setClient(MsgpackClient client);
+  }
+
+  private static abstract class SessionProxy extends AbstractSession implements MsgpackCommunicator, Interactive {
+    private MsgpackClient client;
+    private boolean interacting = false;
+
+    public SessionProxy(int id) {
+      super(id);
+    }
+
+    @Override
+    public List<Module> getCompatibleModules() throws IOException, MsfException {
+      String[] values = getClient().getSessionCompatibleModules(getId());
+      MsgpackProxy framework = (MsgpackProxy) getFramework();
+      MsgpackLoader loader = framework.loader;
+      ModuleManager moduleManager = framework.getModuleManager();
+
+      List<Module> result = new ArrayList<>(values.length);
+
+      for(String fullname : values) {
+        Module m = moduleManager.get(fullname);
+        if(m != null) {
+          result.add(m);
+          continue;
+        }
+
+        try {
+          String[] names = NameHelper.getTypeAndRefnameFromFullname(fullname);
+          result.add(loader.lazyLoadModule(names[0], names[1]));
+        } catch (NameHelper.BadModuleNameException | NameHelper.BadModuleTypeException e) {
+          e.printStackTrace();
+        }
+      }
+
+      return result;
+    }
+
+    @Override
+    public void close() throws IOException, MsfException {
+      getClient().stopSession(getId());
+    }
+
+    @Override
+    public void interact() throws IOException, MsfException {
+      interacting = true;
+    }
+
+    @Override
+    public void suspend() throws IOException, MsfException {
+      interacting = false;
+    }
+
+    @Override
+    public void complete() throws IOException, MsfException {
+      interacting = false;
+      close();
+    }
+
+    @Override
+    public boolean isInteracting() throws IOException, MsfException {
+      return interacting;
+    }
+
+    @Override
+    public MsgpackClient getClient() {
+      return client;
+    }
+
+    @Override
+    public void setClient(MsgpackClient client) {
+      this.client = client;
+    }
+  }
+
+  static class ShellProxy extends SessionProxy implements CommandShell, UpgradableShell {
+
+    public ShellProxy(int id) {
+      super(id);
+    }
+
+    @Override
+    public void init() {
+      // nothing to do there
+    }
+
+    @Override
+    public String read() throws IOException, MsfException {
+      return getClient().readFromShellSession(getId());
+    }
+
+    @Override
+    public int write(String data) throws IOException, MsfException {
+      return getClient().writeToShellSession(getId(), data);
+    }
+
+    @Override
+    public void upgrade(InetAddress lhost, int lport) throws IOException, MsfException {
+      getClient().upgradeShellSession(getId(), lhost.getHostAddress(), lport);
+    }
+  }
+
+  static class MeterpreterProxy extends SessionProxy implements InternalMeterpreter {
+    private String platform = null;
+
+    public MeterpreterProxy(int id) {
+      super(id);
+    }
+
+    @Override
+    public void init() {
+      // nothing to do there
+    }
+
+    @Override
+    public String read() throws IOException, MsfException {
+      return getClient().readFromMeterpreterSession(getId());
+    }
+
+    @Override
+    public int write(String data) throws IOException, MsfException {
+      getClient().writeToMeterpreterSession(getId(), data);
+      return data.length();
+    }
+
+    @Override
+    public boolean detach() throws IOException, MsfException {
+      return getClient().detachMeterpreterSession(getId());
+    }
+
+    @Override
+    public boolean interrupt() throws IOException, MsfException {
+      return getClient().killMeterpreterSession(getId());
+    }
+
+    @Override
+    public String[] tabs(String base) throws IOException, MsfException {
+      return getClient().getMeterpreterTabs(getId(), base);
+    }
+
+    @Override
+    public void setPlatform(String platform) {
+      this.platform = platform;
+    }
+
+    @Override
+    public String getPlatform() {
+      return platform;
+    }
+  }
+
+  static abstract class ModuleProxy<T extends InternalModule> implements InternalModule, MsgpackCommunicator {
+    private MsgpackClient client;
+    private MsgpackLoader loader;
+    protected T instance;
+
+    public ModuleProxy(T instance) {
+      this.instance = instance;
+    }
+
+    @Override
+    public MsgpackClient getClient() {
+      return client;
+    }
+
+    @Override
+    public void setClient(MsgpackClient client) {
+      this.client = client;
+    }
+
+    protected MsgpackLoader getLoader() {
+      if(loader == null) {
+        loader = new MsgpackLoader(client, getFramework());
+      }
+      return loader;
+    }
+
+    @Override
+    public Collection<Option> getOptions() throws IOException, MsfException {
+
+      if(getClient() != null && instance.getOptions().isEmpty()) {
+        MsgpackLoader.fillModuleOptions(instance,
+                getClient().getModuleOptions(getType(), getRefname()));
+      }
+
+      return instance.getOptions();
+    }
+
+    @Override
+    public Collection<String> getInvalidOptions() {
+      return instance.getInvalidOptions();
+    }
+
+    @Override
+    public <K> K getOptionValue(Option<K> option) {
+      return instance.getOptionValue(option);
+    }
+
+    @Override
+    public boolean haveFramework() {
+      return instance.haveFramework();
+    }
+
+    public InternalFramework getFramework() {
+      return instance.getFramework();
+    }
+
+    public void setFramework(InternalFramework framework) {
+      instance.setFramework(framework);
+    }
+
+    protected Map options4client() throws IOException, MsfException {
+      Map<String, Object> options = new HashMap<>();
+
+      for(Option option: getOptions()) {
+        options.put(option.getName(), getOptionValue(option));
+      }
+      return options;
+    }
+
+    protected Job executeWithJob() throws IOException, MsfException {
+      int jobId = getClient().execute(getType(), getRefname(), options4client());
+      return ((MsgpackProxy) instance.getFramework()).loader.
+              lazyLoadJob(jobId, getName() + " job");
+    }
+
+    public void setPlatform(PlatformList platform) {
+      instance.setPlatform(platform);
+    }
+
+    public void setAuthors(Author[] authors) {
+      instance.setAuthors(authors);
+    }
+
+    public void setArch(ArchSet arch) {
+      instance.setArch(arch);
+    }
+
+    public void setReferences(Reference[] references) {
+      instance.setReferences(references);
+    }
+
+    public void setOptions(OptionContainer options) {
+      instance.setOptions(options);
+    }
+
+    public void setDatastore(ModuleDataStore datastore) {
+      instance.setDatastore(datastore);
+    }
+
+    public void setPrivileged(boolean privileged) {
+      instance.setPrivileged(privileged);
+    }
+
+    public void setLicense(License license) {
+      instance.setLicense(license);
+    }
+
+    public void setRank(Rank rank) {
+      instance.setRank(rank);
+    }
+
+    public void setName(String name) {
+      instance.setName(name);
+    }
+
+    public void setVersion(String version) {
+      instance.setVersion(version);
+    }
+
+    public void setDescription(String description) {
+      instance.setDescription(description);
+    }
+
+    public void registerOption(Option option) {
+      instance.registerOption(option);
+    }
+
+    @Override
+    public String getRefname() {
+      return instance.getRefname();
+    }
+
+    @Override
+    public String getFullName() {
+      return instance.getFullName();
+    }
+
+    @Override
+    public String getShortName() {
+      return instance.getShortName();
+    }
+
+    @Override
+    public String getDescription() {
+      return instance.getDescription();
+    }
+
+    @Override
+    public String getName() {
+      return instance.getName();
+    }
+
+    @Override
+    public License getLicense() {
+      return instance.getLicense();
+    }
+
+    @Override
+    public Rank getRank() {
+      return instance.getRank();
+    }
+
+    @Override
+    public org.csploit.msf.api.module.Reference[] getReferences() {
+      return instance.getReferences();
+    }
+
+    @Override
+    public org.csploit.msf.api.Author[] getAuthors() {
+      return instance.getAuthors();
+    }
+
+    @Override
+    public void setOption(String key, String value) {
+      instance.setOption(key, value);
+    }
+
+    @Override
+    public DataStore getDataStore() {
+      return instance.getDataStore();
+    }
+
+    @Override
+    public Set<Arch> getArches() {
+      return instance.getArches();
+    }
+
+    @Override
+    public int compareTo(Module module) {
+      return instance.compareTo(module);
+    }
+
+    @Override
+    public Set<Platform> getPlatforms() {
+      return instance.getPlatforms();
+    }
+
+    @Override
+    public String getType() {
+      return instance.getType();
+    }
+  }
+
+  static class ExploitProxy extends ModuleProxy<InternalExploit> implements InternalExploit {
+
+    public ExploitProxy(InternalExploit instance) {
+      super(instance);
+    }
+
+    public void setTargets(Target[] targets) {
+      instance.setTargets(targets);
+    }
+
+    public void setDefaultTarget(int defaultTarget) {
+      instance.setDefaultTarget(defaultTarget);
+    }
+
+    public Target[] getTargets() {
+      return instance.getTargets();
+    }
+
+    public Target getTarget() {
+      return instance.getTarget();
+    }
+
+    @Override
+    public void setTarget(int i) {
+      instance.setTarget(i);
+    }
+
+    @Override
+    public int getTargetIndex() {
+      return instance.getTargetIndex();
+    }
+
+    @Override
+    public List<? extends Payload> getCompatiblePayloads() throws IOException, MsfException {
+      String [] response = getClient()
+              .getExploitCompatiblePayloads(getRefname(), getTargetIndex());
+      List<Payload> result = new ArrayList<>();
+
+      for(String refname : response) {
+        result.add((Payload) getLoader().lazyLoadModule("payload", refname));
+      }
+
+      return result;
+    }
+
+    @Override
+    public void execute() throws IOException, MsfException {
+      Job result = executeWithJob();
+      result.setExploit(this);
+      //TODO: result.setPayload(getPayload());
+    }
+  }
+
+  static class PayloadProxy extends ModuleProxy<InternalModule> implements Payload {
+
+    public PayloadProxy(InternalModule payload) {
+      super(payload);
+    }
+
+    @Override
+    public byte[] generate() throws IOException, MsfException {
+      return getClient().generatePayload("payload", getRefname(), options4client());
+    }
+  }
+
+  static class PostProxy extends ModuleProxy<InternalModule> implements Post {
+
+    public PostProxy(InternalModule instance) {
+      super(instance);
+    }
+
+    @Override
+    public void execute() throws IOException, MsfException {
+      executeWithJob();
+    }
+  }
+
+  static class AuxiliaryProxy extends ModuleProxy<InternalAuxiliary> implements InternalAuxiliary {
+
+    public AuxiliaryProxy(InternalAuxiliary instance) {
+      super(instance);
+    }
+
+    @Override
+    public void setDefaultAction(String defaultAction) {
+      instance.setDefaultAction(defaultAction);
+    }
+
+    @Override
+    public void setActions(AuxiliaryAction[] actions) {
+      instance.setActions(actions);
+    }
+
+    @Override
+    public void setDefaultAction(int defaultAction) {
+      instance.setDefaultAction(defaultAction);
+    }
+
+    @Override
+    public AuxiliaryAction[] getActions() {
+      return instance.getActions();
+    }
+
+    @Override
+    public AuxiliaryAction getDefaultAction() {
+      return instance.getDefaultAction();
+    }
+
+    @Override
+    public void execute() throws IOException, MsfException {
+      executeWithJob();
+    }
+  }
+
+  public static class FrameworkFactory {
+    private final MsgpackClient client;
+
+    public FrameworkFactory(MsgpackClient client) {
+      this.client = client;
+    }
+
+    public org.csploit.msf.api.Framework createFramework() {
+      return new MsgpackProxy(client);
+    }
+  }
+
+  public static class SessionFactory {
+    private final MsgpackClient client;
+    private final InternalFramework framework;
+
+    public SessionFactory(MsgpackClient client, InternalFramework framework) {
+      this.client = client;
+      this.framework = framework;
+    }
+
+    public AbstractSession createSession(String type, int id)
+      throws NameHelper.BadSessionTypeException {
+      SessionProxy result;
+
+      switch (type) {
+        case "shell":
+          result = new MsgpackProxy.ShellProxy(id);
+          break;
+        case "meterpreter":
+          result = new MsgpackProxy.MeterpreterProxy(id);
+          break;
+        default:
+          throw new NameHelper.BadSessionTypeException(type);
+      }
+
+      result.setFramework(framework);
+      result.setClient(client);
+
+      return result;
+    }
+  }
+
+  public static class ModuleFactory {
+    private final MsgpackClient client;
+    private final InternalFramework framework;
+
+    public ModuleFactory(MsgpackClient client, InternalFramework framework) {
+      this.client = client;
+      this.framework = framework;
+    }
+
+    public InternalModule createModule(String type, String refname)
+      throws NameHelper.BadModuleTypeException {
+      InternalModule module = org.csploit.msf.impl.Module.fromType(type, refname);
+
+      module.setFramework(framework);
+
+      if(module instanceof InternalExploit) {
+        module = new ExploitProxy((InternalExploit) module);
+      } else if(module instanceof InternalAuxiliary) {
+        module = new AuxiliaryProxy((InternalAuxiliary) module);
+      } else if(module instanceof Post) {
+        module = new PostProxy(module);
+      } else if(module instanceof Payload) {
+        module = new PayloadProxy(module);
+      }
+
+      module.setFramework(framework);
+
+      if(module instanceof MsgpackCommunicator) {
+        ((MsgpackCommunicator) module).setClient(client);
+      }
+
+      return module;
+    }
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/NameHelper.java b/msf/src/main/java/org/csploit/msf/impl/NameHelper.java
new file mode 100644
index 0000000000..71e2b0d69d
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/NameHelper.java
@@ -0,0 +1,62 @@
+package org.csploit.msf.impl;
+
+import org.csploit.msf.api.MsfException;
+
+/**
+ * Help manage modules names
+ */
+final class NameHelper {
+  public static String[] getTypeAndRefnameFromFullname(String fullname) throws BadModuleNameException, BadModuleTypeException {
+    int index = fullname.indexOf('/');
+
+    if(index == -1 || index == fullname.length()) {
+      throw new BadModuleNameException(fullname);
+    }
+
+    String type = fullname.substring(0, index);
+
+    if(!isModuleTypeValid(type)) {
+      throw new BadModuleTypeException(type);
+    }
+
+    return new String[]{type, fullname.substring(index + 1)};
+  }
+
+
+  public static boolean isModuleTypeValid(String type) {
+    if(type == null) {
+      return false;
+    }
+    type = type.toLowerCase();
+    for(String validType : ModuleManager.validModuleTypes) {
+      if(validType.equals(type)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  public static void assertValidModuleType(String type) throws BadModuleTypeException {
+    if (!isModuleTypeValid(type)) {
+      throw new BadModuleTypeException(type);
+    }
+  }
+
+  public static class BadModuleNameException extends MsfException {
+    public BadModuleNameException(String fullname) {
+      super("invalid module name: " + fullname);
+    }
+  }
+
+  public static class BadModuleTypeException extends MsfException {
+    public BadModuleTypeException(String type) {
+      super("invalid module type: " + type);
+    }
+  }
+
+  public static class BadSessionTypeException extends MsfException {
+    public BadSessionTypeException(String message) {
+      super("invalid session type: " + message);
+    }
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/Offspring.java b/msf/src/main/java/org/csploit/msf/impl/Offspring.java
new file mode 100644
index 0000000000..8197afc9d5
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/Offspring.java
@@ -0,0 +1,10 @@
+package org.csploit.msf.impl;
+
+/**
+ * CLasses that ave a reference to the framework
+ */
+interface Offspring {
+  boolean haveFramework();
+  InternalFramework getFramework();
+  void setFramework(InternalFramework framework);
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/OptionContainer.java b/msf/src/main/java/org/csploit/msf/impl/OptionContainer.java
new file mode 100644
index 0000000000..b5e51a1617
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/OptionContainer.java
@@ -0,0 +1,42 @@
+package org.csploit.msf.impl;
+
+import org.csploit.msf.api.Option;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * A container of options
+ */
+class OptionContainer extends HashMap<String, Option> {
+
+  public void add(Option option) {
+    put(option.getName(), option);
+  }
+
+  /**
+   * this should be the validate method in the MSF.
+   * I decided to change it because updating dataStore
+   * within modules will write global values into it.
+   */
+  @SuppressWarnings("unchecked")
+  public Collection<String> getInvalidOptions(DataStore dataStore) {
+    ArrayList<String> errors = new ArrayList<>();
+
+    for(Map.Entry<String, Option> entry : entrySet()) {
+      String name = entry.getKey();
+      Option option = entry.getValue();
+
+      String val = dataStore.get(name);
+      Object normalized = option.normalize(val);
+
+      if(!option.isValid(normalized)) {
+        errors.add(name);
+      }
+    }
+
+    return errors;
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/Payload.java b/msf/src/main/java/org/csploit/msf/impl/Payload.java
new file mode 100644
index 0000000000..e3cad118bf
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/Payload.java
@@ -0,0 +1,26 @@
+package org.csploit.msf.impl;
+
+import org.csploit.msf.api.MsfException;
+
+import java.io.IOException;
+
+/**
+ * This class represents the base class for a logical payload.  The framework
+ * automatically generates payload combinations at runtime which are all
+ * extended for this Payload as a base class.
+ */
+class Payload extends Module implements org.csploit.msf.api.Payload {
+  public Payload(String refname) {
+    super(refname);
+  }
+
+  @Override
+  public String getType() {
+    return "payload";
+  }
+
+  @Override
+  public byte[] generate() throws IOException, MsfException {
+    throw new UnsupportedOperationException("not implemented yet");
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/Post.java b/msf/src/main/java/org/csploit/msf/impl/Post.java
new file mode 100644
index 0000000000..de51702ce1
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/Post.java
@@ -0,0 +1,25 @@
+package org.csploit.msf.impl;
+
+import org.csploit.msf.api.MsfException;
+
+import java.io.IOException;
+
+/**
+ * A Post-exploitation module.
+ */
+class Post extends Module implements org.csploit.msf.api.Post {
+
+  public Post(String refname) {
+    super(refname);
+  }
+
+  @Override
+  public String getType() {
+    return "post";
+  }
+
+  @Override
+  public void execute() throws IOException, MsfException {
+    throw new UnsupportedOperationException("not implemented yet");
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/SessionManager.java b/msf/src/main/java/org/csploit/msf/impl/SessionManager.java
new file mode 100644
index 0000000000..57698f75d6
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/SessionManager.java
@@ -0,0 +1,225 @@
+package org.csploit.msf.impl;
+
+import org.csploit.msf.api.MsfException;
+import org.csploit.msf.api.Publisher;
+import org.csploit.msf.api.Session;
+import org.csploit.msf.api.events.SessionClosedEvent;
+import org.csploit.msf.api.events.SessionOpenedEvent;
+import org.csploit.msf.api.events.SessionOutputEvent;
+import org.csploit.msf.api.listeners.SessionListener;
+import org.csploit.msf.api.sessions.Interactive;
+import org.csploit.msf.api.sessions.SingleCommandShell;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+/**
+ * The purpose of the session manager is to keep track of sessions that are
+ * created during the course of a framework instance's lifetime.  When
+ * exploits succeed, the payloads they use will create a session object,
+ * where applicable, there will implement zero or more of the core
+ * supplied interfaces for interacting with that session.  For instance,
+ * if the payload supports reading and writing from an executed process,
+ * the session would implement SimpleCommandShell in a method that is
+ * applicable to the way that the command interpreter is communicated
+ * with.
+ */
+class SessionManager implements Runnable, Publisher<SessionListener> {
+  private static final int SLEEP_INTERVAL = 3000;
+  private static final int WORK_INTERVAL = 300;
+
+  private boolean running = false;
+  private boolean watchList = false;
+  private Thread thread = null;
+  private final TreeMap<Integer, Session> map = new TreeMap<>();
+  private final Set<SessionListener> listeners = new LinkedHashSet<>();
+  private final ExecutorService executorService = Executors.newSingleThreadExecutor();
+
+  public SessionManager() {
+
+  }
+
+  @Override
+  public void run() {
+    Collection<Session> copy;
+    String output;
+
+    running = true;
+
+    try {
+      while (running) {
+        synchronized (map) {
+          copy = new ArrayList<>(map.values());
+        }
+
+        boolean interactingSessionsFound = false;
+
+        for (Session s : copy) {
+          if(!interactingSessionsFound && s instanceof Interactive) {
+            try {
+              interactingSessionsFound = ((Interactive) s).isInteracting();
+            } catch (IOException | MsfException e) {
+              // ignored
+            }
+          }
+
+          if (!(s instanceof SingleCommandShell)) {
+            continue;
+          }
+
+          try {
+            output = ((SingleCommandShell) s).read();
+            if (output != null && output.length() > 0) {
+              notifySessionOutput(s, output);
+            }
+          } catch (IOException | MsfException e) {
+            unregister(s);
+          }
+        }
+
+        long interval = interactingSessionsFound ? WORK_INTERVAL : SLEEP_INTERVAL;
+
+        if(watchList) {
+          long start = java.lang.System.currentTimeMillis();
+          try {
+            getSessions();
+          } catch (IOException | MsfException e) {
+            // ignored
+          }
+          interval -= (java.lang.System.currentTimeMillis() - start);
+        }
+
+        if(interval > 0) {
+          Thread.sleep(interval);
+        }
+      }
+    } catch (InterruptedException e) {
+      // break
+    } finally {
+      running = false;
+    }
+  }
+
+  public void start() {
+    stop();
+    thread = new Thread(this, this.getClass().getSimpleName());
+    thread.start();
+  }
+
+  public void stop() {
+    running = false;
+    try {
+      if(thread != null && thread.isAlive())
+        thread.join();
+    } catch (InterruptedException e) {
+      // ignore
+    }
+  }
+
+  /**
+   * set to watch session list or not
+   */
+  public void setWatchList(boolean watchList) {
+    this.watchList = watchList;
+  }
+
+  public void register(Session s) {
+    synchronized (map) {
+      if(map.containsKey(s.getId())) {
+        return;
+      }
+      map.put(s.getId(), s);
+      map.notify();
+    }
+    notifySessionOpened(s);
+  }
+
+  public void unregister(Session s) {
+    synchronized (map) {
+      s = map.remove(s.getId());
+      if(s == null)
+        return;
+    }
+    notifySessionClosed(s);
+  }
+
+  @Override
+  public void addSubscriber(SessionListener listener) {
+    synchronized (listeners) {
+      listeners.add(listener);
+    }
+  }
+
+  @Override
+  public void removeSubscriber(SessionListener listener) {
+    synchronized (listeners) {
+      listeners.add(listener);
+    }
+  }
+
+  private void notifySessionOpened(Session session) {
+    final SessionOpenedEvent event = new SessionOpenedEvent(this, session);
+
+    executorService.execute(new Runnable() {
+      @Override
+      public void run() {
+        synchronized (listeners) {
+          for(SessionListener listener : listeners) {
+            listener.onSessionOpened(event);
+          }
+        }
+      }
+    });
+  }
+
+  private void notifySessionOutput(Session session, String output) {
+    final SessionOutputEvent event = new SessionOutputEvent(this, session, output);
+
+    executorService.execute(new Runnable() {
+      @Override
+      public void run() {
+        synchronized (listeners) {
+          for(SessionListener listener : listeners) {
+            listener.onSessionOutput(event);
+          }
+        }
+      }
+    });
+  }
+
+  private void notifySessionClosed(Session session) {
+    final SessionClosedEvent event = new SessionClosedEvent(this, session);
+
+    executorService.execute(new Runnable() {
+      @Override
+      public void run() {
+        for(SessionListener listener : listeners) {
+          listener.onSessionClosed(event);
+        }
+      }
+    });
+  }
+
+  public List<Session> getSessions() throws IOException, MsfException {
+    synchronized (map) {
+      return new ArrayList<>(map.values());
+    }
+  }
+
+  boolean containsSession(int id) {
+    synchronized (map) {
+      return map.containsKey(id);
+    }
+  }
+
+  boolean containsSession(Session s) {
+    return containsSession(s.getId());
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/module/ArchSet.java b/msf/src/main/java/org/csploit/msf/impl/module/ArchSet.java
new file mode 100644
index 0000000000..215cc45388
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/module/ArchSet.java
@@ -0,0 +1,57 @@
+package org.csploit.msf.impl.module;
+
+import java.util.Collection;
+import java.util.HashSet;
+import org.csploit.msf.api.Arch;
+
+/**
+ * A container for architectures supported by a module
+ */
+public class ArchSet extends HashSet<Arch> {
+
+  public ArchSet() {
+    super();
+  }
+
+  public ArchSet(String s) {
+    this(s.split(","));
+  }
+
+  public ArchSet(String[] a) {
+    super(a.length);
+
+    for(String arch : a) {
+      add(Arch.valueOf(arch.trim().toUpperCase()));
+    }
+  }
+
+  private ArchSet(Collection<? extends Arch> other) {
+    super(other);
+  }
+
+  public boolean isSupported(Arch arch) {
+    return arch == Arch.ANY || contains(arch);
+  }
+
+  public ArchSet intersect(Collection<Arch> other) {
+    ArchSet res = new ArchSet(this);
+    res.retainAll(other);
+    return res;
+  }
+
+  @Override
+  public String toString() {
+    if(isEmpty())
+      return "";
+    StringBuilder sb = new StringBuilder();
+
+    for (Arch a : this) {
+      if(sb.length() > 0) {
+        sb.append(", ");
+      }
+      sb.append(a.toString());
+    }
+
+    return sb.toString();
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/module/AuxiliaryAction.java b/msf/src/main/java/org/csploit/msf/impl/module/AuxiliaryAction.java
new file mode 100644
index 0000000000..ede97ce622
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/module/AuxiliaryAction.java
@@ -0,0 +1,32 @@
+package org.csploit.msf.impl.module;
+
+/**
+ * AuxiliaryAction implementation
+ */
+public class AuxiliaryAction implements org.csploit.msf.api.module.AuxiliaryAction {
+  private final String name;
+  private String description;
+
+  public AuxiliaryAction(String name, String description) {
+    this.name = name;
+    this.description = description;
+  }
+
+  public AuxiliaryAction(String name) {
+    this.name = name;
+  }
+
+  @Override
+  public String getName() {
+    return name;
+  }
+
+  @Override
+  public String getDescription() {
+    return description;
+  }
+
+  public void setDescription(String description) {
+    this.description = description;
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/module/PlatformList.java b/msf/src/main/java/org/csploit/msf/impl/module/PlatformList.java
new file mode 100644
index 0000000000..5d2b2cce43
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/module/PlatformList.java
@@ -0,0 +1,46 @@
+package org.csploit.msf.impl.module;
+
+import org.csploit.msf.api.module.Platform;
+
+import java.util.Collection;
+import java.util.HashSet;
+
+/**
+ * A list of platforms
+ */
+public class PlatformList extends HashSet<Platform> {
+
+  public PlatformList() {
+    super();
+  }
+
+  public PlatformList(String s) {
+    this(s.split(","));
+  }
+
+  public PlatformList(String[] plats) {
+    super(plats.length);
+    for(String s : plats) {
+      Platform platform = Platform.fromString(s);
+      if(platform != null) {
+        add(platform);
+      }
+    }
+  }
+
+  public PlatformList intersect(Collection<Platform> other) {
+    PlatformList res = new PlatformList();
+
+    for(Platform pl1 : this) {
+      for(Platform pl2 : other) {
+        if(pl1.subsetOf(pl2)) {
+          res.add(pl1);
+        } else if(pl2.subsetOf(pl1)) {
+          res.add(pl2);
+        }
+      }
+    }
+
+    return res;
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/module/Reference.java b/msf/src/main/java/org/csploit/msf/impl/module/Reference.java
new file mode 100644
index 0000000000..d5d528d52a
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/module/Reference.java
@@ -0,0 +1,37 @@
+package org.csploit.msf.impl.module;
+
+/**
+ * A reference to some sort of information.  This is typically a URL, but could
+ * be any type of referential value that people could use to research a topic.
+ */
+public class Reference implements org.csploit.msf.api.module.Reference {
+  protected String str;
+
+  public Reference(String str) {
+    this.str = "" + str;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+
+    Reference reference = (Reference) o;
+
+    return str.equals(reference.str);
+  }
+
+  @Override
+  public int hashCode() {
+    return str.hashCode();
+  }
+
+  @Override
+  public String toString() {
+    return str;
+  }
+
+  public static Reference fromString(String s) {
+    return new Reference(s);
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/module/SiteReference.java b/msf/src/main/java/org/csploit/msf/impl/module/SiteReference.java
new file mode 100644
index 0000000000..65257c8ea4
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/module/SiteReference.java
@@ -0,0 +1,56 @@
+package org.csploit.msf.impl.module;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.regex.Pattern;
+
+/**
+ * A reference to a website.
+ */
+public class SiteReference extends Reference implements org.csploit.msf.api.module.SiteReference {
+  protected String ctx_id;
+  protected String ctx_val;
+
+  private final static Pattern SIMPLE_URL_PATTERN = Pattern.compile("(http://|https://|ftp://)");
+
+  private final static Map<String, String> formats = new HashMap<String, String>() {{
+    put("OSVDB", "http://www.osvdb.org/%s");
+    put("CVE", "http://cvedetails.com/cve/%s/");
+    put("CWE", "https://cwe.mitre.org/data/definitions/%s.html");
+    put("BID", "http://www.securityfocus.com/bid/%s");
+    put("MSB", "http://technet.microsoft.com/en-us/security/bulletin/%s");
+    put("EDB", "https://www.exploit-db.com/exploits/%s");
+    put("US-CERT-VU", "http://www.kb.cert.org/vuls/id/%s");
+    put("ZDI", "http://www.zerodayinitiative.com/advisories/ZDI-%s");
+    put("WPVDB", "https://wpvulndb.com/vulnerabilities/%s");
+    put("PACKETSTORM", "https://packetstormsecurity.com/files/%s");
+    put("URL", "%s");
+  }};
+
+  public SiteReference(String ctx_id, String ctx_val) {
+    super("");
+    this.ctx_id = ctx_id;
+    this.ctx_val = ctx_val;
+
+    if(formats.containsKey(ctx_id)) {
+      str = String.format(formats.get(ctx_id), ctx_val);
+    } else {
+      str = ctx_id;
+      if(ctx_val != null) {
+        str += " (" + ctx_val + ")";
+      }
+    }
+  }
+
+  public static SiteReference fromString(String str) {
+    if(!SIMPLE_URL_PATTERN.matcher(str).matches()) {
+      return null;
+    }
+    return new SiteReference("URL", str);
+  }
+
+  @Override
+  public String getUrl() {
+    return toString();
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/module/Target.java b/msf/src/main/java/org/csploit/msf/impl/module/Target.java
new file mode 100644
index 0000000000..eac260827d
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/module/Target.java
@@ -0,0 +1,32 @@
+package org.csploit.msf.impl.module;
+
+/**
+ * Represent a target
+ */
+public class Target implements org.csploit.msf.api.module.Target {
+  private String name;
+  private PlatformList platform;
+  private ArchSet arch;
+
+  public Target(String name, PlatformList platform, ArchSet arch) {
+    this.name = name;
+    this.platform = platform;
+    this.arch = arch;
+  }
+
+  public Target(String name) {
+    this(name, null, null);
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public PlatformList getPlatform() {
+    return platform;
+  }
+
+  public ArchSet getArch() {
+    return arch;
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/options/AddressOption.java b/msf/src/main/java/org/csploit/msf/impl/options/AddressOption.java
new file mode 100644
index 0000000000..d94ad6cd6d
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/options/AddressOption.java
@@ -0,0 +1,37 @@
+package org.csploit.msf.impl.options;
+
+import org.csploit.msf.impl.AbstractOption;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+
+/**
+ * Network address option.
+ */
+public class AddressOption extends AbstractOption<InetAddress> {
+
+  public AddressOption(String name, boolean required, String description, InetAddress defaultValue) {
+    super(name, required, description, defaultValue);
+  }
+
+  public AddressOption(String name, boolean required, String description, String defaultValue) {
+    super(name, required, description, sNormalize(defaultValue));
+  }
+
+  public AddressOption(String name, String description, InetAddress defaultValue) {
+    super(name, description, defaultValue);
+  }
+
+  @Override
+  public InetAddress normalize(String input) {
+    return sNormalize(input);
+  }
+
+  private static InetAddress sNormalize(String input) {
+    try {
+      return input != null ? InetAddress.getByName(input) : null;
+    } catch (UnknownHostException e) {
+      return null;
+    }
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/options/AddressRangeOption.java b/msf/src/main/java/org/csploit/msf/impl/options/AddressRangeOption.java
new file mode 100644
index 0000000000..c14a1d4df6
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/options/AddressRangeOption.java
@@ -0,0 +1,79 @@
+package org.csploit.msf.impl.options;
+
+import org.apache.commons.io.IOUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.csploit.msf.impl.AbstractOption;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Network address range option.
+ */
+public class AddressRangeOption extends AbstractOption<InetAddress[]> {
+
+  public AddressRangeOption(String name, boolean required, String description, InetAddress[] defaultValue) {
+    super(name, required, description, defaultValue);
+  }
+
+  public AddressRangeOption(String name, String description, InetAddress[] defaultValue) {
+    super(name, description, defaultValue);
+  }
+
+  @Override
+  public InetAddress[] normalize(String input) {
+    if(input == null)
+      return null;
+
+    if(input.startsWith("file:")) {
+      InputStream is = null;
+      try {
+        input = input.substring(5).trim();
+        is = new FileInputStream(new File(input));
+        List<String> lines = IOUtils.readLines(is);
+        ArrayList<InetAddress> result = new ArrayList<>();
+
+        for(String line : lines) {
+          try {
+            result.add(InetAddress.getByName(line.trim()));
+          } catch (UnknownHostException e) {
+            // ignore
+          }
+        }
+
+        return result.toArray(new InetAddress[result.size()]);
+      } catch (IOException e) {
+        // ignore
+      } finally {
+        IOUtils.closeQuietly(is);
+      }
+    } else if ( input.startsWith("rand:")) {
+      throw new UnsupportedOperationException("random address ranges not supported");
+    } else {
+      String[] parts = input.split(" ");
+      ArrayList<InetAddress> result = new ArrayList<>();
+
+      for(String part : parts) {
+        try {
+          result.add(InetAddress.getByName(part));
+        } catch (UnknownHostException e) {
+          // ignore
+        }
+      }
+
+      return result.toArray(new InetAddress[result.size()]);
+    }
+    return null;
+  }
+
+  @Override
+  public String display(InetAddress[] value) {
+    return StringUtils.join(value, " ");
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/options/BooleanOption.java b/msf/src/main/java/org/csploit/msf/impl/options/BooleanOption.java
new file mode 100644
index 0000000000..093c0c33a6
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/options/BooleanOption.java
@@ -0,0 +1,26 @@
+package org.csploit.msf.impl.options;
+
+import org.csploit.msf.impl.AbstractOption;
+
+import java.util.regex.Pattern;
+
+/**
+ * Boolean option.
+ */
+public class BooleanOption extends AbstractOption<Boolean> {
+  private static final Pattern TRUE = Pattern.compile("^(y|yes|t|1|true)$", Pattern.CASE_INSENSITIVE);
+  private static final Pattern BOOLEAN = Pattern.compile("^(y|yes|n|no|t|f|0|1|true|false)$", Pattern.CASE_INSENSITIVE);
+
+  public BooleanOption(String name, boolean required, String description, Boolean defaultValue) {
+    super(name, required, description, defaultValue);
+  }
+
+  public BooleanOption(String name, String description, Boolean defaultValue) {
+    super(name, description, defaultValue);
+  }
+
+  @Override
+  public Boolean normalize(String input) {
+    return input != null && TRUE.matcher(input).matches();
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/options/EnumOption.java b/msf/src/main/java/org/csploit/msf/impl/options/EnumOption.java
new file mode 100644
index 0000000000..e870561526
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/options/EnumOption.java
@@ -0,0 +1,36 @@
+package org.csploit.msf.impl.options;
+
+import org.csploit.msf.impl.AbstractOption;
+
+/**
+ * Enum option.
+ */
+public class EnumOption extends AbstractOption<String> {
+
+  private String[] enums;
+
+  public EnumOption(String name, boolean required, String description, String defaultValue, String[] enums) {
+    super(name, required, description, defaultValue);
+    this.enums = enums;
+  }
+
+  public EnumOption(String name, String description, String defaultValue, String[] enums) {
+    super(name, description, defaultValue);
+    this.enums = enums;
+  }
+
+  @Override
+  public String normalize(String input) {
+    for(String s : enums) {
+      if(s.equals(input)) {
+        return s;
+      }
+    }
+    return null;
+  }
+
+  @Override
+  public boolean isValid(String input) {
+    return super.isValid(input) && (input == null || normalize(input) != null);
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/options/IntegerOption.java b/msf/src/main/java/org/csploit/msf/impl/options/IntegerOption.java
new file mode 100644
index 0000000000..5c63293d71
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/options/IntegerOption.java
@@ -0,0 +1,29 @@
+package org.csploit.msf.impl.options;
+
+import org.csploit.msf.impl.AbstractOption;
+
+/**
+ * Integer option.
+ */
+public class IntegerOption extends AbstractOption<Long> {
+  public IntegerOption(String name, boolean required, String description, Long defaultValue) {
+    super(name, required, description, defaultValue);
+  }
+
+  public IntegerOption(String name, String description, Long defaultValue) {
+    super(name, description, defaultValue);
+  }
+
+  @Override
+  public Long normalize(String input) {
+    try {
+      if (input.startsWith("0x")) {
+        return Long.parseLong(input.substring(2), 16);
+      } else {
+        return Long.parseLong(input);
+      }
+    } catch (NumberFormatException e) {
+      return null;
+    }
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/options/PathOption.java b/msf/src/main/java/org/csploit/msf/impl/options/PathOption.java
new file mode 100644
index 0000000000..0e365aef62
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/options/PathOption.java
@@ -0,0 +1,35 @@
+package org.csploit.msf.impl.options;
+
+import org.csploit.msf.impl.AbstractOption;
+
+import java.io.File;
+
+/**
+ * File system path option.
+ */
+public class PathOption extends AbstractOption<File> {
+
+  public PathOption(String name, boolean required, String description, File defaultValue) {
+    super(name, required, description, defaultValue);
+  }
+
+  public PathOption(String name, String description, File defaultValue) {
+    super(name, description, defaultValue);
+  }
+
+  @Override
+  public File normalize(String input) {
+    File res = new File(input);
+    return res.exists() ? res : null;
+  }
+
+  @Override
+  public boolean isValid(File input) {
+    return super.isValid(input) && (input == null || input.exists());
+  }
+
+  @Override
+  public String display(File value) {
+    return value.getAbsolutePath();
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/options/PortOption.java b/msf/src/main/java/org/csploit/msf/impl/options/PortOption.java
new file mode 100644
index 0000000000..a738154da9
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/options/PortOption.java
@@ -0,0 +1,33 @@
+package org.csploit.msf.impl.options;
+
+import org.csploit.msf.impl.AbstractOption;
+
+/**
+ * Network port option.
+ */
+public class PortOption extends AbstractOption<Integer> {
+
+  public PortOption(String name, boolean required, String description, Integer defaultValue) {
+    super(name, required, description, defaultValue);
+  }
+
+  public PortOption(String name, String description, Integer defaultValue) {
+    super(name, description, defaultValue);
+  }
+
+  @Override
+  public Integer normalize(String input) {
+    try {
+      int val = Integer.parseInt(input);
+      return isValid(val) ? val : null;
+    } catch (NumberFormatException e) {
+      // ignore
+    }
+    return null;
+  }
+
+  @Override
+  public boolean isValid(Integer input) {
+    return super.isValid(input) && (input == null || input >= 0 && input <= 65535);
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/options/RawOption.java b/msf/src/main/java/org/csploit/msf/impl/options/RawOption.java
new file mode 100644
index 0000000000..94e01a2471
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/options/RawOption.java
@@ -0,0 +1,63 @@
+package org.csploit.msf.impl.options;
+
+import org.apache.commons.codec.DecoderException;
+import org.apache.commons.io.IOUtils;
+import org.csploit.msf.impl.AbstractOption;
+
+import java.io.IOException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.Arrays;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Raw, arbitrary data option.
+ */
+public class RawOption extends AbstractOption<byte[]> {
+
+  private static final Pattern hexStringPattern = Pattern.compile("([a-fA-F0-9]{2})+");
+  private static final Pattern b64Pattern = Pattern.compile("([A-Za-z0-9+/]{4})*([A-Za-z0-9+/]{4}|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)");
+
+  public RawOption(String name, boolean required, String description, byte[] defaultValue) {
+    super(name, required, description, defaultValue);
+  }
+
+  public RawOption(String name, String description, byte[] defaultValue) {
+    super(name, description, defaultValue);
+  }
+
+  @Override
+  public byte[] normalize(String input) {
+    if(input.startsWith("file:")) {
+      try {
+        return IOUtils.toByteArray(new URI(input));
+      } catch (IOException | URISyntaxException e) {
+        //ignore
+      }
+      return null;
+    }
+    Matcher matcher = b64Pattern.matcher(input);
+
+    if(matcher.matches()) {
+      return org.apache.commons.codec.binary.Base64.decodeBase64(input);
+    }
+
+    matcher = hexStringPattern.matcher(input);
+
+    if(matcher.matches()) {
+      try {
+        return org.apache.commons.codec.binary.Hex.decodeHex(input.toCharArray());
+      } catch (DecoderException e) {
+        // ignored
+      }
+    }
+
+    return null;
+  }
+
+  @Override
+  public String display(byte[] value) {
+    return new String(value);
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/options/RegexpOption.java b/msf/src/main/java/org/csploit/msf/impl/options/RegexpOption.java
new file mode 100644
index 0000000000..ba2d240969
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/options/RegexpOption.java
@@ -0,0 +1,29 @@
+package org.csploit.msf.impl.options;
+
+import org.csploit.msf.impl.AbstractOption;
+
+import java.util.regex.Pattern;
+
+/**
+ * A regex option
+ */
+public class RegexpOption extends AbstractOption<Pattern> {
+
+  public RegexpOption(String name, boolean required, String description, Pattern defaultValue) {
+    super(name, required, description, defaultValue);
+  }
+
+  public RegexpOption(String name, String description, Pattern defaultValue) {
+    super(name, description, defaultValue);
+  }
+
+  @Override
+  public Pattern normalize(String input) {
+    return Pattern.compile(input);
+  }
+
+  @Override
+  public String display(Pattern value) {
+    return value.pattern();
+  }
+}
diff --git a/msf/src/main/java/org/csploit/msf/impl/options/StringOption.java b/msf/src/main/java/org/csploit/msf/impl/options/StringOption.java
new file mode 100644
index 0000000000..694ea5019c
--- /dev/null
+++ b/msf/src/main/java/org/csploit/msf/impl/options/StringOption.java
@@ -0,0 +1,35 @@
+package org.csploit.msf.impl.options;
+
+import org.apache.commons.io.IOUtils;
+import org.csploit.msf.impl.AbstractOption;
+
+import java.io.IOException;
+import java.net.URI;
+import java.net.URISyntaxException;
+
+/**
+ * Option string
+ */
+public class StringOption extends AbstractOption<String> {
+
+  public StringOption(String name, boolean required, String description, String defaultValue) {
+    super(name, required, description, defaultValue);
+  }
+
+  public StringOption(String name, String description, String defaultValue) {
+    super(name, description, defaultValue);
+  }
+
+  @Override
+  public String normalize(String input) {
+    if(input.startsWith("file:")) {
+      try {
+        return IOUtils.toString(new URI(input));
+      } catch (IOException | URISyntaxException e) {
+        //ignore
+      }
+      return null;
+    }
+    return input;
+  }
+}
diff --git a/msf/src/test/java/org/csploit/msf/impl/DataStoreTest.java b/msf/src/test/java/org/csploit/msf/impl/DataStoreTest.java
new file mode 100644
index 0000000000..b65a641d93
--- /dev/null
+++ b/msf/src/test/java/org/csploit/msf/impl/DataStoreTest.java
@@ -0,0 +1,58 @@
+package org.csploit.msf.impl;
+
+import org.csploit.msf.impl.options.StringOption;
+import org.junit.Test;
+
+import java.util.Set;
+
+import static org.hamcrest.CoreMatchers.*;
+import static org.junit.Assert.*;
+
+/**
+ * Test the DataStore class
+ */
+public class DataStoreTest {
+
+  private DataStore buildDataStoreWithDefaultOption() {
+    DataStore store = new DataStore();
+    OptionContainer options = new OptionContainer();
+
+    options.add(new StringOption("A", "description", "default value"));
+
+    store.importOptions(options, true);
+
+    return store;
+  }
+
+  @Test
+  public void testImportOptions() throws Exception {
+    DataStore store = buildDataStoreWithDefaultOption();
+
+    assertThat(store.get("A"), is("default value"));
+  }
+
+  @Test
+  public void testUserDefined() throws Exception {
+    DataStore store = buildDataStoreWithDefaultOption();
+
+    assertThat(store.userDefined().isEmpty(), is(true));
+
+    store.put("A", "user-defined value");
+
+    assertThat(store.userDefined().isEmpty(), is(false));
+  }
+
+  @Test
+  public void testClearNotUserDefined() throws Exception {
+    DataStore store = buildDataStoreWithDefaultOption();
+
+    store.put("B", "user-defined value");
+
+    store.clearNotUserDefined();
+
+    Set<String> keys = store.keySet();
+
+    assertThat(keys.contains("B"), is(true));
+    assertThat(keys.contains("A"), is(false));
+  }
+}
\ No newline at end of file
diff --git a/msf/src/test/java/org/csploit/msf/impl/MsgpackLoaderTest.java b/msf/src/test/java/org/csploit/msf/impl/MsgpackLoaderTest.java
new file mode 100644
index 0000000000..35b617d055
--- /dev/null
+++ b/msf/src/test/java/org/csploit/msf/impl/MsgpackLoaderTest.java
@@ -0,0 +1,288 @@
+package org.csploit.msf.impl;
+
+import org.csploit.msf.api.License;
+import org.csploit.msf.api.Exploit;
+import org.csploit.msf.api.Option;
+import org.csploit.msf.api.Session;
+import org.csploit.msf.api.module.Rank;
+import org.csploit.msf.api.module.Reference;
+import org.csploit.msf.api.module.SiteReference;
+import org.csploit.msf.api.module.Target;
+import org.junit.Test;
+
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.junit.Assert.*;
+import static org.hamcrest.CoreMatchers.*;
+
+/**
+ * Test msgpack loader
+ */
+public class MsgpackLoaderTest {
+  private static MsgpackClient.ModuleInfo sampleModuleInfo = new MsgpackClient.ModuleInfo() {{
+    name = "name";
+    description = "description";
+    license = License.MSF.toString();
+    filepath = "whocares";
+    rank = Rank.NORMAL.getValue();
+    references = new String[][]{
+            new String[]{"CVE", "12345"},
+            new String[]{"OSVDB", "12345"}
+    };
+    authors = new String[] {
+            "me <me@nowhere.org>",
+            "you <you@somewhere.org>"
+    };
+    targets = new HashMap<Integer, String>() {{
+      put(0, "target 0");
+      put(1, "target 1");
+    }};
+    defaultTarget = 0;
+  }};
+  
+  private static MsgpackClient.SessionInfo sampleSessionInfo = new MsgpackClient.SessionInfo() {{
+    type = "shell";
+    tunnelLocal = "hello";
+    tunnelPeer = "world";
+    viaExploit = "test";
+    viaPayload = "test";
+    description = "description";
+    info = "info";
+    workspace = "workspace";
+    sessionHost = "session_host";
+    sessionPort = 31337;
+    targetHost = "target_host";
+    username = "username";
+    uuid = "uuid";
+    exploitUuid = "whocares";
+    routes = new String[] {
+            "whocares", "about", "routes"
+    };
+  }};
+
+  private static MsgpackClient.SessionInfo sampleMeterpreterSessionInfo = new MsgpackClient.SessionInfo() {{
+    type = "meterpreter";
+    tunnelLocal = sampleSessionInfo.tunnelLocal;
+    tunnelPeer = sampleSessionInfo.tunnelPeer;
+    viaExploit = sampleSessionInfo.viaExploit;
+    viaPayload = sampleSessionInfo.viaPayload;
+    description = sampleSessionInfo.description;
+    info = sampleSessionInfo.info;
+    workspace = sampleSessionInfo.workspace;
+    sessionHost = sampleSessionInfo.sessionHost;
+    sessionPort = sampleSessionInfo.sessionPort;
+    targetHost = sampleSessionInfo.targetHost;
+    username = sampleSessionInfo.username;
+    uuid = sampleSessionInfo.uuid;
+    exploitUuid = sampleSessionInfo.exploitUuid;
+    routes = sampleSessionInfo.routes;
+    platform = "windows";
+  }};
+
+  private static Map<String, MsgpackClient.OptionInfo> sampleOptionsList = new HashMap<String, MsgpackClient.OptionInfo>() {{
+    put("StringOption", new MsgpackClient.OptionInfo() {{
+      type = "string";
+      required = false;
+      advanced = false;
+      evasion = false;
+      description = "description";
+      defaultValue = "hello world";
+    }});
+
+    put("AddressOption", new MsgpackClient.OptionInfo() {{
+      type = "address";
+      required = false;
+      advanced = false;
+      evasion = false;
+      description = "description";
+      defaultValue = "127.0.0.1";
+    }});
+
+    put("AddressRangeOption", new MsgpackClient.OptionInfo() {{
+      type = "addressrange";
+      required = false;
+      advanced = false;
+      evasion = false;
+      description = "description";
+    }});
+
+    put("EnumOption", new MsgpackClient.OptionInfo() {{
+      type = "enum";
+      required = false;
+      advanced = false;
+      evasion = false;
+      description = "description";
+      defaultValue = "B";
+      enums = new String[]{"A", "B", "C"};
+    }});
+
+    put("BooleanOption", new MsgpackClient.OptionInfo() {{
+      type = "bool";
+      required = false;
+      advanced = false;
+      evasion = false;
+      description = "description";
+      defaultValue = false;
+    }});
+
+    put("PortOption", new MsgpackClient.OptionInfo() {{
+      type = "port";
+      required = false;
+      advanced = false;
+      evasion = false;
+      description = "description";
+      defaultValue = 4000;
+    }});
+
+    put("PathOption", new MsgpackClient.OptionInfo() {{
+      type = "path";
+      required = false;
+      advanced = false;
+      evasion = false;
+      description = "description";
+      defaultValue = "/etc/passwd";
+    }});
+
+    put("IntegerOption", new MsgpackClient.OptionInfo() {{
+      type = "integer";
+      required = false;
+      advanced = false;
+      evasion = false;
+      description = "description";
+      defaultValue = 123;
+    }});
+
+    put("RegexpOption", new MsgpackClient.OptionInfo() {{
+      type = "regexp";
+      required = false;
+      advanced = false;
+      evasion = false;
+      description = "description";
+      defaultValue = "[0-9A-Za-z]{16,32}";
+    }});
+
+    put("RawOption", new MsgpackClient.OptionInfo() {{
+      type = "raw";
+      required = false;
+      advanced = false;
+      evasion = false;
+      description = "description";
+    }});
+  }};
+
+  private static MsgpackClient.JobInfo sampleJobInfo = new MsgpackClient.JobInfo() {{
+    id = 1;
+    name = "name";
+    startTime = 0; // A long time ago, in a galaxy far, far away...
+  }};
+
+  private MsgpackLoader loader = new MsgpackLoader(null, new Framework());
+
+  @Test
+  public void testFillModule() throws Exception {
+    InternalModule module = new MsgpackProxy.ModuleFactory(null, null)
+            .createModule("exploit", "test");
+
+    MsgpackLoader.fillModule(module, sampleModuleInfo);
+
+    assertThat(module.getName(), is("name"));
+    assertThat(module.getDescription(), is("description"));
+    assertThat(module.getLicense(), is(License.MSF));
+    assertThat(module.getRank(), is(Rank.NORMAL));
+    assertThat(module.getReferences().length, is(2));
+    Reference ref = module.getReferences()[0];
+    assertThat(ref, instanceOf(SiteReference.class));
+    ref = module.getReferences()[1];
+    assertThat(ref, instanceOf(SiteReference.class));
+    assertThat(module.getAuthors().length, is(2));
+    assertThat(module.getAuthors()[0].toString(), is("me <me@nowhere.org>"));
+    assertThat(module.getAuthors()[1].toString(), is("you <you@somewhere.org>"));
+    Target[] targets = ((Exploit)module).getTargets();
+    assertThat(targets.length, is(2));
+    assertThat(targets[0].getName(), is("target 0"));
+    assertThat(targets[1].getName(), is("target 1"));
+    assertThat(((Exploit)module).getTarget(), is(targets[0]));
+  }
+
+  @Test
+  public void testBuildSession() throws Exception {
+    Session shell, meterpreter;
+
+    shell = loader.buildSession(1, sampleSessionInfo);
+    meterpreter = loader.buildSession(2, sampleMeterpreterSessionInfo);
+
+    assertThat(shell, instanceOf(MsgpackProxy.ShellProxy.class));
+    assertThat(meterpreter, instanceOf(MsgpackProxy.MeterpreterProxy.class));
+
+    assertThat(shell.getId(), is(1));
+    assertThat(shell.getDescription(), is("description"));
+    assertThat(shell.getInfo(), is("info"));
+    assertThat(shell.getLocalTunnel(), is("hello"));
+    assertThat(shell.getPeerTunnel(), is("world"));
+    assertThat(shell.getTargetHost(), is("target_host"));
+    assertThat(shell.getWorkspace(), is("workspace"));
+    assertThat(shell.getSessionHost(), is("session_host"));
+    assertThat(shell.getSessionPort(), is(31337));
+    assertThat(shell.getUuid(), is("uuid"));
+
+    assertThat(meterpreter.getId(), is(2));
+    assertThat(meterpreter.getDescription(), is(shell.getDescription()));
+    assertThat(meterpreter.getInfo(), is(shell.getInfo()));
+    assertThat(meterpreter.getLocalTunnel(), is(shell.getLocalTunnel()));
+    assertThat(meterpreter.getPeerTunnel(), is(shell.getPeerTunnel()));
+    assertThat(meterpreter.getTargetHost(), is(shell.getTargetHost()));
+    assertThat(meterpreter.getWorkspace(), is(shell.getWorkspace()));
+    assertThat(meterpreter.getSessionHost(), is(shell.getSessionHost()));
+    assertThat(meterpreter.getSessionPort(), is(shell.getSessionPort()));
+    assertThat(meterpreter.getUuid(), is(shell.getUuid()));
+  }
+
+  @Test
+  public void testFillJob() throws Exception {
+
+    Job job = new Job(2, "wrong_name");
+
+    loader.fillJob(job, sampleJobInfo);
+
+    assertThat(job.getId(), is(2));
+    assertThat(job.getName(), is("name"));
+    assertThat(job.getStartTime(), is(new Date(0)));
+  }
+
+  @Test
+  public void testFillModuleOptions() throws Exception {
+    InternalModule sampleModule = new MsgpackProxy.ModuleFactory(null, null)
+            .createModule("exploit", "test");
+
+    assertThat(sampleModule.getOptions().isEmpty(), is(true));
+
+    MsgpackLoader.fillModuleOptions(sampleModule, sampleOptionsList);
+
+    assertThat(sampleModule.getOptions().size(), is(sampleOptionsList.size()));
+
+    for(Option o : sampleModule.getOptions()) {
+      assertThat(o.getName(), is(o.getClass().getSimpleName()));
+    }
+  }
+
+  @Test
+  public void testFillConsole() throws Exception {
+    MsgpackConsole console = new MsgpackConsole(null, 0);
+
+    console.setPrompt("");
+    console.setBusy(true);
+
+    MsgpackClient.ConsoleInfo info = new MsgpackClient.ConsoleInfo();
+    info.id = 1;
+    info.prompt = "hello world";
+    info.busy = false;
+
+    MsgpackLoader.fillConsole(info, console);
+
+    assertThat(console.getId(), is(0));
+    assertThat(console.getPrompt(), is("hello world"));
+    assertThat(console.isBusy(), is(false));
+  }
+}
\ No newline at end of file
diff --git a/msf/src/test/java/org/csploit/msf/impl/MsgpackTest.java b/msf/src/test/java/org/csploit/msf/impl/MsgpackTest.java
new file mode 100644
index 0000000000..e6bd6c579b
--- /dev/null
+++ b/msf/src/test/java/org/csploit/msf/impl/MsgpackTest.java
@@ -0,0 +1,207 @@
+package org.csploit.msf.impl;
+
+import org.csploit.msf.api.Console;
+import org.csploit.msf.api.ConsoleManager;
+import org.csploit.msf.api.Exploit;
+import org.csploit.msf.api.Framework;
+import org.csploit.msf.api.Job;
+import org.csploit.msf.api.Module;
+import org.csploit.msf.api.Payload;
+import org.csploit.msf.api.Post;
+import org.csploit.msf.api.Session;
+import org.csploit.msf.api.events.ConsoleChangedEvent;
+import org.csploit.msf.api.events.ConsoleClosedEvent;
+import org.csploit.msf.api.events.ConsoleOpenedEvent;
+import org.csploit.msf.api.events.ConsoleOutputEvent;
+import org.csploit.msf.api.listeners.ConsoleListener;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+/**
+ * Test msf library usage for messagepack usage
+ */
+public class MsgpackTest {
+
+  private MsgpackFactory factory;
+
+  private static class DummyConsoleListener implements ConsoleListener {
+
+    public boolean open, changed, output; // default to false
+
+    @Override
+    public synchronized void onConsoleOpened(ConsoleOpenedEvent event) {
+      open = true;
+      notifyAll();
+    }
+
+    @Override
+    public synchronized void onConsoleChanged(ConsoleChangedEvent event) {
+      changed = true;
+      notifyAll();
+    }
+
+    @Override
+    public synchronized void onConsoleOutput(ConsoleOutputEvent event) {
+      output = true;
+      notifyAll();
+    }
+
+    @Override
+    public synchronized void onConsoleClosed(ConsoleClosedEvent event) {
+      open = false;
+      notifyAll();
+    }
+  }
+
+  @Before
+  public void setUp() throws Exception {
+    factory = new MsgpackFactory("127.0.0.1", "msf", "msf", 55553, false);
+  }
+
+  @Test
+  public void testSessionsList() throws Exception {
+    Framework framework = factory.createFramework();
+
+    framework.getSessions();
+  }
+
+  @Test
+  public void testSessionCompatibleModules() throws Exception {
+    Framework framework = factory.createFramework();
+
+    for(Session s : framework.getSessions()) {
+      s.getCompatibleModules();
+    }
+  }
+
+  @Test
+  public void testJobList() throws Exception {
+    Framework framework = factory.createFramework();
+
+    framework.getJobs();
+  }
+
+  @Test
+  public void testGetJob() throws Exception {
+    Framework framework = factory.createFramework();
+
+    for(Job j : framework.getJobs()) {
+      framework.getJob(j.getId());
+    }
+  }
+
+  @Test
+  public void testGetExploits() throws Exception {
+    Framework framework = factory.createFramework();
+
+    List<? extends Exploit> result = framework.getExploits();
+
+    assertThat(result.isEmpty(), is(false));
+
+    Exploit first = result.get(0);
+
+    assertThat(MsgpackLoader.isModuleAlreadyFetched(first), is(false));
+
+    first = (Exploit) framework.getModule(first.getFullName());
+
+    assertThat(MsgpackLoader.isModuleAlreadyFetched(first), is(true));
+
+    for(Exploit e : result) {
+      e.getCompatiblePayloads();
+    }
+  }
+
+  @Test
+  public void testGetModuleOptions() throws Exception {
+    Framework framework = factory.createFramework();
+
+    List<Module> allModules = new ArrayList<>();
+
+    allModules.addAll(framework.getExploits());
+    allModules.addAll(framework.getPayloads());
+    allModules.addAll(framework.getPosts());
+
+    for(Module m : allModules) {
+      assertThat(m.getOptions().isEmpty(), is(false));
+    }
+  }
+
+  @Test
+  public void testGetPayloads() throws Exception {
+    Framework framework = factory.createFramework();
+
+    List<? extends Payload> result = framework.getPayloads();
+
+    assertThat(result.isEmpty(), is(false));
+
+    Payload first = result.get(0);
+
+    assertThat(MsgpackLoader.isModuleAlreadyFetched(first), is(false));
+
+    first = (Payload) framework.getModule(first.getFullName());
+
+    assertThat(MsgpackLoader.isModuleAlreadyFetched(first), is(true));
+  }
+
+  @Test
+  public void testGetPosts() throws Exception {
+    Framework framework = factory.createFramework();
+
+    List<? extends Post> result = framework.getPosts();
+
+    assertThat(result.isEmpty(), is(false));
+
+    Post first = result.get(0);
+
+    assertThat(MsgpackLoader.isModuleAlreadyFetched(first), is(false));
+
+    first = (Post) framework.getModule(first.getFullName());
+
+    assertThat(MsgpackLoader.isModuleAlreadyFetched(first), is(true));
+  }
+
+  @Test(timeout = 10000)
+  public void testConsoles() throws Exception {
+    ConsoleManager consoleManager = factory.createConsoleManager();
+    DummyConsoleListener listener = new DummyConsoleListener();
+
+    consoleManager.start();
+
+    consoleManager.addSubscriber(listener);
+
+    Console console = consoleManager.create();
+    console.interact();
+
+    synchronized (listener) {
+      while (!listener.open) {
+        listener.wait();
+      }
+    }
+
+    assertThat(consoleManager.getConsoles().contains(console), is(true));
+
+    console.write("help\n");
+
+    synchronized (listener) {
+      while(!listener.output) {
+        listener.wait();
+      }
+    }
+
+    console.complete();
+
+    synchronized (listener) {
+      while (listener.open) {
+        listener.wait();
+      }
+    }
+
+    assertThat(consoleManager.getConsoles().contains(console), is(false));
+  }
+}
diff --git a/msf/src/test/java/org/csploit/msf/impl/NameHelperTest.java b/msf/src/test/java/org/csploit/msf/impl/NameHelperTest.java
new file mode 100644
index 0000000000..cfd0b7f712
--- /dev/null
+++ b/msf/src/test/java/org/csploit/msf/impl/NameHelperTest.java
@@ -0,0 +1,51 @@
+package org.csploit.msf.impl;
+
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+import static org.hamcrest.CoreMatchers.*;
+
+/**
+ * Test name helper class
+ */
+public class NameHelperTest {
+
+  @Test
+  public void testGetTypeAndRefnameFromFullname() throws Exception {
+    String[] names = NameHelper.getTypeAndRefnameFromFullname("exploit/test//test/-$%^");
+
+    assertThat(names.length, is(2));
+    assertThat(names[0], is("exploit"));
+    assertThat(names[1], startsWith("test//test"));
+
+    boolean exceptionFired = false;
+
+    try {
+      NameHelper.getTypeAndRefnameFromFullname("no-slashes-here");
+    } catch (NameHelper.BadModuleNameException e) {
+      exceptionFired = true;
+    }
+
+    assertThat(exceptionFired, is(true));
+  }
+
+  @Test
+  public void testValidModuleType() throws Exception {
+    boolean exceptionFired = false;
+    String valid = "exploit";
+    String invalid = "not-a-valid-type";
+
+    assertThat(NameHelper.isModuleTypeValid(valid), is(true));
+    assertThat(NameHelper.isModuleTypeValid(invalid), is(false));
+
+    NameHelper.assertValidModuleType(valid);
+
+    try {
+      NameHelper.assertValidModuleType(invalid);
+    } catch (NameHelper.BadModuleTypeException e) {
+      exceptionFired = true;
+    }
+
+    assertThat(exceptionFired, is(true));
+  }
+}
\ No newline at end of file
diff --git a/msf/src/test/java/org/csploit/msf/impl/OfflineTestSuite.java b/msf/src/test/java/org/csploit/msf/impl/OfflineTestSuite.java
new file mode 100644
index 0000000000..63c6231432
--- /dev/null
+++ b/msf/src/test/java/org/csploit/msf/impl/OfflineTestSuite.java
@@ -0,0 +1,22 @@
+package org.csploit.msf.impl;
+
+import org.csploit.msf.impl.module.PlatformListTest;
+import org.csploit.msf.impl.module.PlatformTest;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+
+/**
+ * A suite of offline tests
+ */
+@RunWith(Suite.class)
+@Suite.SuiteClasses({
+  DataStoreTest.class,
+  MsgpackLoaderTest.class,
+  NameHelperTest.class,
+  RpcSampleTest.class,
+  PlatformListTest.class,
+  PlatformTest.class,
+  SessionManagerTest.class
+})
+public class OfflineTestSuite {
+}
diff --git a/msf/src/test/java/org/csploit/msf/impl/OnlineTestSuite.java b/msf/src/test/java/org/csploit/msf/impl/OnlineTestSuite.java
new file mode 100644
index 0000000000..a9ce721db5
--- /dev/null
+++ b/msf/src/test/java/org/csploit/msf/impl/OnlineTestSuite.java
@@ -0,0 +1,14 @@
+package org.csploit.msf.impl;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+
+/**
+ * Perform some tests that require a MFS connection
+ */
+@RunWith(Suite.class)
+@Suite.SuiteClasses({
+        MsgpackTest.class
+})
+public class OnlineTestSuite {
+}
diff --git a/msf/src/test/java/org/csploit/msf/impl/RpcSampleTest.java b/msf/src/test/java/org/csploit/msf/impl/RpcSampleTest.java
new file mode 100644
index 0000000000..f378a4d90c
--- /dev/null
+++ b/msf/src/test/java/org/csploit/msf/impl/RpcSampleTest.java
@@ -0,0 +1,134 @@
+package org.csploit.msf.impl;
+
+import static org.junit.Assert.*;
+import static org.hamcrest.CoreMatchers.*;
+
+import org.csploit.msf.api.License;
+import org.csploit.msf.impl.module.Reference;
+import org.csploit.msf.impl.module.SiteReference;
+import org.csploit.msf.impl.module.Target;
+import org.csploit.msf.impl.options.AddressOption;
+import org.csploit.msf.impl.options.BooleanOption;
+import org.csploit.msf.impl.options.EnumOption;
+import org.junit.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Test msf library usage for rpc usage
+ */
+public class RpcSampleTest {
+
+  private final static class TestOptionInfoFactory {
+
+    public static MsgpackClient.OptionInfo create(String type, String description, boolean required, boolean advanced, boolean evasion, Object defaultValue, String[] enums) {
+      MsgpackClient.OptionInfo result = new MsgpackClient.OptionInfo();
+      result.type = type;
+      result.description = description;
+      result.required = required;
+      result.advanced = advanced;
+      result.evasion = evasion;
+      result.defaultValue = defaultValue;
+      result.enums = enums;
+
+      return result;
+    }
+
+    public static MsgpackClient.OptionInfo create(String type, String description, boolean required, boolean advanced, boolean evasion, Object defaultValue) {
+      return create(type, description, required, advanced, evasion, defaultValue, null);
+    }
+
+    public static MsgpackClient.OptionInfo create(String type, String description, boolean required, boolean advanced, boolean evasion) {
+      return create(type, description, required, advanced, evasion, null, null);
+    }
+  }
+
+  @Test
+  public void putExploitTest() {
+
+    MsgpackClient.ModuleInfo info = new MsgpackClient.ModuleInfo();
+
+    info.name = "A funny exploit";
+    info.description = "a very long description";
+    info.license = License.GPL.toString();
+    info.filepath = "whocares";
+    info.rank = 300;
+    info.references = new String[][] {
+            {"URL", "http://nowhere.com/index.html"},
+            {"OSVDB", "12345"}
+    };
+    info.authors = new String[] {
+            "Someone <someone@example.com>"
+    };
+    info.targets = new HashMap<Integer, String>() {{
+            put(0, "IE / RealOne Player 2");
+            put(1, "IE / RealOne Player 3");
+    }};
+    info.defaultTarget = 0;
+
+    Framework framework = new Framework();
+
+    ModuleManager mgr = framework.getModuleManager();
+
+    // deserialize rpc stuff
+
+    Exploit exploit = new Exploit("test");
+
+    MsgpackLoader.fillModule(exploit, info);
+
+    mgr.put(exploit);
+
+    assertThat(framework, is(exploit.getFramework()));
+    assertThat(exploit.license, is(License.GPL));
+    assertThat(exploit.getTarget(), is(exploit.getTargets()[0]));
+
+    // receive exploit options
+    Map<String, MsgpackClient.OptionInfo> options = new HashMap<>();
+
+    options.put("NTLM::SendNTLM",
+            TestOptionInfoFactory.create(
+                    "bool", "A", true, true, false, true
+            ));
+    options.put("HTTP::uri_encode_mode",
+            TestOptionInfoFactory.create(
+                    "enum", "B", false, false, true, "hex-normal", new String[] {
+                    "none", "hex-normal", "hex-noslashes", "hex-random",
+                    "hex-all", "u-normal", "u-all", "u-random"
+            }
+            ));
+    options.put("RHOST",
+            TestOptionInfoFactory.create(
+                    "address", "C", true, false, false
+            ));
+
+    // put them into the exploit
+    MsgpackLoader.fillModuleOptions(exploit, options);
+
+    // let's now try to edit an option
+
+    // first in the local datastore
+    exploit.getDataStore().put("TARGET", "1");
+    assertThat(exploit.getTarget(), is(exploit.getTargets()[1]));
+    exploit.getDataStore().remove("TARGET");
+    assertThat(exploit.getTarget(), is(exploit.getTargets()[0]));
+
+    // from global datastore
+    framework.setGlobalOption("TARGET", "1");
+    assertThat(exploit.getTarget(), is(exploit.getTargets()[1]));
+    framework.getDataStore().remove("TARGET");
+    assertThat(exploit.getTarget(), is(exploit.getTargets()[0]));
+
+    // exploit settings should not be valid without the required RHOST options
+
+    assertThat(exploit.getInvalidOptions().isEmpty(), is(false));
+
+    framework.getDataStore().put("RHOST", "invalid address");
+
+    assertThat(exploit.getInvalidOptions().isEmpty(), is(false));
+
+    framework.getDataStore().put("RHOST", "127.0.0.1");
+
+    assertThat(exploit.getInvalidOptions().isEmpty(), is(true));
+  }
+}
diff --git a/msf/src/test/java/org/csploit/msf/impl/SessionManagerTest.java b/msf/src/test/java/org/csploit/msf/impl/SessionManagerTest.java
new file mode 100644
index 0000000000..0ea3389a80
--- /dev/null
+++ b/msf/src/test/java/org/csploit/msf/impl/SessionManagerTest.java
@@ -0,0 +1,113 @@
+package org.csploit.msf.impl;
+
+import org.csploit.msf.api.MsfException;
+import org.csploit.msf.api.Session;
+import org.csploit.msf.api.events.SessionClosedEvent;
+import org.csploit.msf.api.events.SessionOpenedEvent;
+import org.csploit.msf.api.events.SessionOutputEvent;
+import org.csploit.msf.api.listeners.SessionListener;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.util.List;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+/**
+ * test the session manager
+ */
+public class SessionManagerTest {
+
+  private class DummySession extends AbstractSession {
+
+    public DummySession(int id) {
+      super(id);
+    }
+
+    @Override
+    public List<? extends Module> getCompatibleModules() throws IOException, MsfException {
+      return null;
+    }
+
+    @Override
+    public void close() throws IOException, MsfException { }
+  }
+
+  private class DummySessionListener implements SessionListener {
+    private boolean opened = false;
+
+    @Override
+    public synchronized void onSessionOpened(SessionOpenedEvent e) {
+      opened = true;
+      notifyAll();
+    }
+
+    @Override
+    public void onSessionOutput(SessionOutputEvent e) { }
+
+    @Override
+    public synchronized void onSessionClosed(SessionClosedEvent e) {
+      opened = false;
+      notifyAll();
+    }
+
+    public synchronized boolean isOpened() {
+      return opened;
+    }
+  }
+
+  private SessionManager buildLocalSessionManager() {
+    return new Framework().getSessionManager();
+  }
+
+  @Test
+  public void testCreation() throws Exception {
+    SessionManager manager = buildLocalSessionManager();
+
+    assertThat(manager.getSessions().isEmpty(), is(true));
+  }
+
+  @Test
+  public void testInsertGetRemoveContains() throws Exception {
+    SessionManager manager = buildLocalSessionManager();
+    Session session = new DummySession(1);
+    manager.register(session);
+
+    assertThat(manager.containsSession(session), is(true));
+
+    assertThat(manager.getSessions().size(), is(1));
+    assertThat(manager.getSessions().get(0), is(session));
+
+    manager.unregister(session);
+
+    assertThat(manager.getSessions().isEmpty(), is(true));
+  }
+
+  @Test(timeout = 1000)
+  public void testEvents() throws Exception{
+    InternalFramework framework = new Framework();
+    SessionManager manager = framework.getSessionManager();
+    DummySessionListener listener = new DummySessionListener();
+    Session session = new DummySession(1);
+
+    assertThat(listener.isOpened(), is(false));
+
+    framework.addSubscriber(listener);
+    manager.register(session);
+
+    synchronized (listener) {
+      while(!listener.isOpened()) {
+        listener.wait();
+      }
+    }
+
+    manager.unregister(session);
+
+    synchronized (listener) {
+      while(listener.isOpened()) {
+        listener.wait();
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/msf/src/test/java/org/csploit/msf/impl/module/PlatformListTest.java b/msf/src/test/java/org/csploit/msf/impl/module/PlatformListTest.java
new file mode 100644
index 0000000000..402e9585e8
--- /dev/null
+++ b/msf/src/test/java/org/csploit/msf/impl/module/PlatformListTest.java
@@ -0,0 +1,24 @@
+package org.csploit.msf.impl.module;
+
+import org.junit.Test;
+
+import static org.hamcrest.CoreMatchers.*;
+import static org.junit.Assert.*;
+
+/**
+ * Test unit for PlatformList class
+ */
+public class PlatformListTest {
+
+  @Test
+  public void testIntersect() throws Exception {
+    PlatformList l1, l2, ex;
+
+    l1 = new PlatformList("Windows 98, Solaris V4");
+    l2 = new PlatformList("Windows 98 FE, Solaris");
+    ex = new PlatformList("Windows 98 FE, Solaris V4");
+
+    assertThat(l1.intersect(l2), is(ex));
+    assertThat(l2.intersect(l1), is(ex));
+  }
+}
\ No newline at end of file
diff --git a/msf/src/test/java/org/csploit/msf/impl/module/PlatformTest.java b/msf/src/test/java/org/csploit/msf/impl/module/PlatformTest.java
new file mode 100644
index 0000000000..43225db7fa
--- /dev/null
+++ b/msf/src/test/java/org/csploit/msf/impl/module/PlatformTest.java
@@ -0,0 +1,35 @@
+package org.csploit.msf.impl.module;
+
+import static org.junit.Assert.*;
+import static org.hamcrest.CoreMatchers.*;
+
+import org.csploit.msf.api.module.Platform;
+import org.junit.Test;
+
+/**
+ * Test unit for Platform enum
+ */
+public class PlatformTest {
+
+  @Test
+  public void testFromString() throws Exception {
+    assertThat(Platform.fromString("Windows"), is(Platform.WINDOWS));
+    assertThat(Platform.fromString("Windows NT SP3"), is(Platform.WINDOWS_NT_SP3));
+    assertThat(Platform.fromString(null), nullValue());
+    assertThat(Platform.fromString("Unknown"), nullValue());
+    assertThat(Platform.fromString("Unix"), is(Platform.UNIX));
+  }
+
+  @Test
+  public void testSubsetOf() throws Exception {
+    assertThat(Platform.WINDOWS_2000_SP0.subsetOf(Platform.WINDOWS), is(true));
+    assertThat(Platform.WINDOWS.subsetOf(Platform.WINDOWS_2000), is(false));
+    assertThat(Platform.WINDOWS_VISTA_SP0.subsetOf(Platform.WINDOWS_NT_SP0), is(false));
+    assertThat(Platform.UNIX.subsetOf(Platform.AIX), is(false));
+    assertThat(Platform.SOLARIS_V10.subsetOf(Platform.SOLARIS), is(true));
+
+    for(Platform platform : Platform.values()) {
+      assertThat(platform.subsetOf(platform), is(true));
+    }
+  }
+}
\ No newline at end of file
diff --git a/settings.gradle b/settings.gradle
index 47bb48eb2b..d07762bec5 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -1 +1 @@
-include ':cSploit'
+include ':cSploit', ':msf'