Merge pull request #513 from RUB-NDS/parallelExecutorShutdown

Parallel executor shutdown

Author: ic0ns

Attacks/src/main/java/de/rub/nds/tlsattacker/attacks/connectivity/ConnectivityChecker.java

@@ -8,6 +8,22 @@
  */
 package de.rub.nds.tlsattacker.attacks.connectivity;
 
+import de.rub.nds.tlsattacker.core.config.Config;
+import de.rub.nds.tlsattacker.core.protocol.message.ClientHelloMessage;
+import de.rub.nds.tlsattacker.core.protocol.message.ProtocolMessage;
+import de.rub.nds.tlsattacker.core.protocol.message.SSL2ServerHelloMessage;
+import de.rub.nds.tlsattacker.core.protocol.message.ServerHelloDoneMessage;
+import de.rub.nds.tlsattacker.core.protocol.message.ServerHelloMessage;
+import de.rub.nds.tlsattacker.core.record.AbstractRecord;
+import de.rub.nds.tlsattacker.core.record.Record;
+import de.rub.nds.tlsattacker.core.state.State;
+import de.rub.nds.tlsattacker.core.workflow.WorkflowExecutor;
+import de.rub.nds.tlsattacker.core.workflow.WorkflowExecutorFactory;
+import de.rub.nds.tlsattacker.core.workflow.WorkflowTrace;
+import de.rub.nds.tlsattacker.core.workflow.action.ReceiveAction;
+import de.rub.nds.tlsattacker.core.workflow.action.ReceiveTillAction;
+import de.rub.nds.tlsattacker.core.workflow.action.SendAction;
+import de.rub.nds.tlsattacker.core.workflow.action.executor.WorkflowExecutorType;
 import de.rub.nds.tlsattacker.transport.Connection;
 import de.rub.nds.tlsattacker.transport.TransportHandler;
 import de.rub.nds.tlsattacker.transport.TransportHandlerFactory;
@@ -63,4 +79,29 @@ public boolean isConnectable() {
         }
     }
 
+    public boolean speaksTls(Config config) {
+        config.setHttpsParsingEnabled(Boolean.TRUE);
+        WorkflowTrace trace = new WorkflowTrace();
+        trace.addTlsAction(new SendAction(new ClientHelloMessage(config)));
+        ReceiveTillAction receiveTillAction = new ReceiveTillAction(new ServerHelloDoneMessage());
+        trace.addTlsAction(receiveTillAction);
+        State state = new State(config, trace);
+        WorkflowExecutor executor = WorkflowExecutorFactory.createWorkflowExecutor(WorkflowExecutorType.DEFAULT, state);
+        executor.executeWorkflow();
+        if (receiveTillAction.getRecords().size() > 0) {
+            if (receiveTillAction.getRecords().get(0) instanceof Record) {
+                return true;
+            } else {
+                for (ProtocolMessage message : receiveTillAction.getReceivedMessages()) {
+                    if (message instanceof ServerHelloMessage || message instanceof ServerHelloDoneMessage
+                            || message instanceof SSL2ServerHelloMessage) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+        } else {
+            return false;
+        }
+    }
 }

TLS-Core/src/main/java/de/rub/nds/tlsattacker/core/config/Config.java

@@ -86,7 +86,16 @@ public class Config implements Serializable {
      */
     private static final String DEFAULT_CONFIG_FILE = "/default_config.xml";
 
+    private static final ConfigCache DEFAULT_CONFIG_CACHE;
+
+    static {
+        DEFAULT_CONFIG_CACHE = new ConfigCache(createConfig());
+    }
+
     public static Config createConfig() {
+        if (DEFAULT_CONFIG_CACHE != null) {
+            return DEFAULT_CONFIG_CACHE.getCachedCopy();
+        }
         InputStream stream = Config.class.getResourceAsStream(DEFAULT_CONFIG_FILE);
         return ConfigIO.read(stream);
 

TLS-Core/src/main/java/de/rub/nds/tlsattacker/core/config/ConfigCache.java

@@ -0,0 +1,29 @@
+/**
+ * TLS-Attacker - A Modular Penetration Testing Framework for TLS
+ *
+ * Copyright 2014-2017 Ruhr University Bochum / Hackmanit GmbH
+ *
+ * Licensed under Apache License 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+package de.rub.nds.tlsattacker.core.config;
+
+import org.apache.commons.lang3.SerializationUtils;
+
+/**
+ *
+ * @author robert
+ */
+public class ConfigCache {
+
+    private final Config cachedConfig;
+
+    public ConfigCache(Config cachedConfig) {
+        this.cachedConfig = cachedConfig;
+    }
+
+    public Config getCachedCopy() {
+        return SerializationUtils.clone(cachedConfig);
+    }
+
+}

TLS-Core/src/main/java/de/rub/nds/tlsattacker/core/connection/AliasedConnection.java

@@ -12,15 +12,14 @@
 import de.rub.nds.tlsattacker.transport.Connection;
 import de.rub.nds.tlsattacker.transport.ConnectionEndType;
 import de.rub.nds.tlsattacker.transport.TransportHandlerType;
-import java.io.Serializable;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.Objects;
 import java.util.Set;
 import javax.xml.bind.annotation.XmlType;
 
 @XmlType(propOrder = { "alias", "port", "hostname", "timeout", "transportHandlerType" })
-public abstract class AliasedConnection extends Connection implements Aliasable, Serializable {
+public abstract class AliasedConnection extends Connection implements Aliasable {
 
     public static final String DEFAULT_CONNECTION_ALIAS = "defaultConnection";
     public static final TransportHandlerType DEFAULT_TRANSPORT_HANDLER_TYPE = TransportHandlerType.TCP;

TLS-Core/src/main/java/de/rub/nds/tlsattacker/core/protocol/message/extension/KS/KeyShareStoreEntry.java

@@ -10,6 +10,7 @@
 
 import de.rub.nds.modifiablevariable.util.ByteArrayAdapter;
 import de.rub.nds.tlsattacker.core.constants.NamedGroup;
+import java.io.Serializable;
 import java.util.Arrays;
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
@@ -18,7 +19,7 @@
 
 @XmlRootElement
 @XmlAccessorType(XmlAccessType.FIELD)
-public class KeyShareStoreEntry {
+public class KeyShareStoreEntry implements Serializable {
 
     private NamedGroup group;
 

TLS-Core/src/main/java/de/rub/nds/tlsattacker/core/workflow/NamedThreadFactory.java

@@ -0,0 +1,37 @@
+/**
+ * TLS-Attacker - A Modular Penetration Testing Framework for TLS
+ *
+ * Copyright 2014-2017 Ruhr University Bochum / Hackmanit GmbH
+ *
+ * Licensed under Apache License 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+package de.rub.nds.tlsattacker.core.workflow;
+
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadFactory;
+
+/**
+ *
+ * @author robert
+ */
+public class NamedThreadFactory implements ThreadFactory {
+
+    private int number;
+
+    private final String prefix;
+
+    public NamedThreadFactory(String prefix) {
+        this.number = 1;
+        this.prefix = prefix;
+    }
+
+    @Override
+    public Thread newThread(Runnable r) {
+        Thread newThread = Executors.defaultThreadFactory().newThread(r);
+        newThread.setName(prefix + "-" + number);
+        number++;
+        return newThread;
+    }
+
+}

TLS-Core/src/main/java/de/rub/nds/tlsattacker/core/workflow/ParallelExecutor.java

@@ -17,6 +17,7 @@
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Future;
 import java.util.concurrent.LinkedBlockingDeque;
+import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 import org.apache.logging.log4j.LogManager;
@@ -45,12 +46,28 @@ public ParallelExecutor(int size, int reexecutions) {
         }
     }
 
+    public ParallelExecutor(int size, int reexecutions, ThreadFactory factory) {
+        executorService = new ThreadPoolExecutor(size, size, 10, TimeUnit.DAYS, new LinkedBlockingDeque<Runnable>(),
+                factory);
+        this.reexecutions = reexecutions;
+        this.size = size;
+        if (reexecutions < 0) {
+            throw new IllegalArgumentException("Reexecutions is below zero");
+        }
+    }
+
     public Future addTask(State state) {
+        if (executorService.isShutdown()) {
+            throw new RuntimeException("Cannot add Tasks to already shutdown executor");
+        }
         Future<?> submit = executorService.submit(new StateThreadExecutor(state, reexecutions));
         return submit;
     }
 
     public void bulkExecute(List<State> stateList) {
+        if (executorService.isShutdown()) {
+            throw new RuntimeException("Cannot add Tasks to already shutdown executor");
+        }
         List<Future> futureList = new LinkedList<>();
         for (State state : stateList) {
             futureList.add(addTask(state));
@@ -73,6 +90,10 @@ public int getSize() {
         return size;
     }
 
+    public void shutdown() {
+        executorService.shutdown();
+    }
+
     private class StateThreadExecutor implements Runnable {
 
         private final State state;

Transport/src/main/java/de/rub/nds/tlsattacker/transport/Connection.java

@@ -8,14 +8,15 @@
  */
 package de.rub.nds.tlsattacker.transport;
 
+import java.io.Serializable;
 import java.util.Objects;
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
 import javax.xml.bind.annotation.XmlTransient;
 
 @XmlTransient
 @XmlAccessorType(XmlAccessType.FIELD)
-public abstract class Connection {
+public abstract class Connection implements Serializable {
 
     protected Integer port = null;
     protected String hostname = null;

Transport/src/main/java/de/rub/nds/tlsattacker/transport/TransportHandler.java

@@ -42,10 +42,19 @@ public byte[] fetchData() throws IOException {
         ByteArrayOutputStream stream = new ByteArrayOutputStream();
         long minTimeMillies = System.currentTimeMillis() + timeout;
         while ((System.currentTimeMillis() < minTimeMillies) && (stream.toByteArray().length == 0)) {
-            while (inStream.available() != 0) {
-                int read = inStream.read();
-                stream.write(read);
+            if (inStream.available() != 0) {
+                while (inStream.available() != 0) {
+                    int read = inStream.read();
+                    stream.write(read);
+                }
+            } else {
+                try {
+                    Thread.sleep(1);
+                } catch (InterruptedException ex) {
+                    throw new RuntimeException("Got Interrupted while waiting for Data");
+                }
             }
+
         }
         return stream.toByteArray();
     }