Fixed a false positve in the PaddingOracleAttacker

Author: ic0ns

Attacks/src/main/java/de/rub/nds/tlsattacker/attacks/exception/PaddingOracleUnstableException.java

@@ -0,0 +1,21 @@
+/**
+ * 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.attacks.exception;
+
+/**
+ *
+ * @author Robert Merget <robert.merget@rub.de>
+ */
+public class PaddingOracleUnstableException extends RuntimeException {
+
+    public PaddingOracleUnstableException(String string) {
+        super(string);
+    }
+
+}

Attacks/src/main/java/de/rub/nds/tlsattacker/attacks/impl/PaddingOracleAttacker.java

@@ -13,6 +13,7 @@
 import de.rub.nds.modifiablevariable.bytearray.ModifiableByteArray;
 import de.rub.nds.modifiablevariable.util.ArrayConverter;
 import de.rub.nds.tlsattacker.attacks.config.PaddingOracleCommandConfig;
+import de.rub.nds.tlsattacker.attacks.exception.PaddingOracleUnstableException;
 import de.rub.nds.tlsattacker.attacks.util.response.EqualityError;
 import de.rub.nds.tlsattacker.attacks.util.response.EqualityErrorTranslator;
 import de.rub.nds.tlsattacker.attacks.util.response.FingerPrintChecker;
@@ -40,6 +41,7 @@
 import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Set;
 
 /**
  * Executes a padding oracle attack check. It logs an error in case the tested
@@ -159,6 +161,56 @@ private byte[] createPaddingBytes(int padding) {
 
     @Override
     public Boolean isVulnerable() {
+
+        LOGGER.log(LogLevel.CONSOLE_OUTPUT,
+                "A server is considered vulnerable to this attack if it responds differently to the test vectors.");
+        LOGGER.log(LogLevel.CONSOLE_OUTPUT, "A server is considered secure if it always responds the same way.");
+        HashMap<Integer, List<ResponseFingerprint>> responseMap = createResponseMap();
+
+        EqualityError error = getEqualityError(responseMap);
+        if (error == EqualityError.SOCKET_EXCEPTION || error == EqualityError.SOCKET_STATE) {
+            LOGGER.log(LogLevel.CONSOLE_OUTPUT, "Found a candidate for a Socket difference performing rescan");
+            HashMap<Integer, List<ResponseFingerprint>> responseMapTwo = createResponseMap();
+            EqualityError errorTwo = getEqualityError(responseMapTwo);
+            if (error == errorTwo && lookEqual(responseMap, responseMapTwo)) {
+                HashMap<Integer, List<ResponseFingerprint>> responseMapThree = createResponseMap();
+                EqualityError errorThree = getEqualityError(responseMapThree);
+                if (error == errorThree && lookEqual(responseMap, responseMapThree)) {
+                    LOGGER.log(LogLevel.CONSOLE_OUTPUT,
+                            "Found an equality Error in a SocketState, performed to rescans and it still presisted");
+                    LOGGER.log(LogLevel.CONSOLE_OUTPUT, "The Server is very likely vulnerabble");
+                } else {
+                    LOGGER.log(LogLevel.CONSOLE_OUTPUT, "Rescan revealed a false positive");
+                    return false;
+                }
+            } else {
+                LOGGER.log(LogLevel.CONSOLE_OUTPUT, "Rescan revealed a false positive");
+                return false;
+            }
+        }
+        LOGGER.log(LogLevel.CONSOLE_OUTPUT, EqualityErrorTranslator.translation(error, null, null));
+        return error != EqualityError.NONE;
+    }
+
+    public boolean lookEqual(HashMap<Integer, List<ResponseFingerprint>> responseMapOne,
+            HashMap<Integer, List<ResponseFingerprint>> responseMapTwo) {
+        for (Integer key : responseMapOne.keySet()) {
+            List<ResponseFingerprint> listOne = responseMapOne.get(key);
+            List<ResponseFingerprint> listTwo = responseMapTwo.get(key);
+            if (listOne.size() != listTwo.size()) {
+                throw new PaddingOracleUnstableException(
+                        "The padding Oracle seems to be unstable - there is something going terrible wrong. We recommend manual analysis");
+            }
+            for (int i = 0; i < listOne.size(); i++) {
+                if (FingerPrintChecker.checkEquality(listOne.get(i), listTwo.get(i), false) != EqualityError.NONE) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    public HashMap<Integer, List<ResponseFingerprint>> createResponseMap() {
         int macSize = AlgorithmResolver.getMacAlgorithm(tlsConfig.getDefaultSelectedProtocolVersion(),
                 tlsConfig.getDefaultSelectedCipherSuite()).getSize();
         int blockSize = AlgorithmResolver.getCipher(tlsConfig.getDefaultSelectedCipherSuite())
@@ -173,7 +225,6 @@ public Boolean isVulnerable() {
             State state;
             try {
                 state = executeTlsFlow(record);
-
             } catch (WorkflowExecutionException | ConfigurationException E) {
                 LOGGER.warn(E);
                 LOGGER.warn("TLS-Attacker failed execute a Handshake. Skipping to next record");
@@ -194,29 +245,24 @@ public Boolean isVulnerable() {
             } else {
                 LOGGER.warn("Could not execute Workflow. Something went wrong... Check the debug output for more information");
             }
-
         }
-        LOGGER.log(LogLevel.CONSOLE_OUTPUT,
-                "A server is considered vulnerable to this attack if it responds differently to the test vectors.");
-        LOGGER.log(LogLevel.CONSOLE_OUTPUT, "A server is considered secure if it always responds the same way.");
+        return responseMap;
+    }
 
+    public EqualityError getEqualityError(HashMap<Integer, List<ResponseFingerprint>> responseMap) {
         for (List<ResponseFingerprint> list : responseMap.values()) {
             ResponseFingerprint fingerprint = list.get(0);
             for (int i = 1; i < list.size(); i++) {
                 EqualityError error = FingerPrintChecker.checkEquality(fingerprint, list.get(i), true);
                 if (error != EqualityError.NONE) {
                     LOGGER.log(LogLevel.CONSOLE_OUTPUT, "Found an equality Error: " + error);
-                    LOGGER.debug("Fingerprint1: " + fingerprint.toString());
-                    LOGGER.debug("Fingerprint2: " + list.get(i).toString());
                     LOGGER.log(LogLevel.CONSOLE_OUTPUT,
                             EqualityErrorTranslator.translation(error, fingerprint, list.get(i)));
-                    return true;
+                    return error;
                 }
-
             }
         }
-        LOGGER.log(LogLevel.CONSOLE_OUTPUT, EqualityErrorTranslator.translation(EqualityError.NONE, null, null));
-        return false;
+        return EqualityError.NONE;
     }
 
     private void clearConnections(State state) {