Merge origin/master into mvToHex

ic0ns · ic0ns · commit fa52b9fd6ccf · 2017-05-26T09:33:54.000+02:00
Conflicts:
	src/main/java/de/rub/nds/modifiablevariable/util/ArrayConverter.java
	src/test/java/de/rub/nds/modifiablevariable/util/ArrayConverterTest.java
diff --git a/pom.xml b/pom.xml
@@ -68,7 +68,27 @@
             <version>2.8.2</version>
         </dependency>
     </dependencies>
-    
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>net.revelc.code</groupId>
+                <artifactId>formatter-maven-plugin</artifactId>
+                <version>0.5.2</version>
+                <configuration>
+                    <configFile>maven-eclipse-codestyle.xml</configFile>
+                    <lineEnding>LF</lineEnding>
+                </configuration>
+                <executions>
+                    <execution>
+                        <phase>process-sources</phase>
+                        <goals>
+                            <goal>format</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
     <properties>
         <maven.compiler.source>1.7</maven.compiler.source>
         <maven.compiler.target>1.7</maven.compiler.target>
diff --git a/src/main/java/de/rub/nds/modifiablevariable/length/ModifiableLengthField.java b/src/main/java/de/rub/nds/modifiablevariable/length/ModifiableLengthField.java
@@ -20,8 +20,7 @@
 
 /**
  * 
- * @author Robert Merget - robert.merget@rub.de
- * Highly Experimental
+ * @author Robert Merget - robert.merget@rub.de Highly Experimental
  */
 @XmlRootElement
 @XmlSeeAlso({ IntegerAddModification.class, IntegerExplicitValueModification.class, IntegerSubtractModification.class,
diff --git a/src/main/java/de/rub/nds/modifiablevariable/util/ArrayConverter.java b/src/main/java/de/rub/nds/modifiablevariable/util/ArrayConverter.java
@@ -57,8 +57,10 @@ public static byte[] longToUint32Bytes(long l) {
     /**
      * Takes an integer value and stores its last bytes into a byte array
      *
-     * @param value integer value
-     * @param size  byte size of the new integer byte array
+     * @param value
+     *            integer value
+     * @param size
+     *            byte size of the new integer byte array
      * @return
      */
     public static byte[] intToBytes(int value, int size) {
@@ -78,8 +80,10 @@ public static byte[] intToBytes(int value, int size) {
     /**
      * Takes a long value and stores its last bytes into a byte array
      *
-     * @param value long value
-     * @param size  byte size of the new integer byte array
+     * @param value
+     *            long value
+     * @param size
+     *            byte size of the new integer byte array
      * @return
      */
     public static byte[] longToBytes(long value, int size) {
@@ -149,16 +153,28 @@ public static String bytesToHexString(byte[] array, boolean usePrettyPrinting, b
             result.append("\n");
         }
         for (int i = 0; i < array.length; i++) {
-            if (usePrettyPrinting && i != 0) {
-                if (i % 16 == 0) {
+            if (i != 0) {
+                if (usePrettyPrinting && (i % 16 == 0)) {
                     result.append("\n");
-                } else if (i % 8 == 0) {
+                } else {
+                    if (usePrettyPrinting && (i % 8 == 0)) {
+                        result.append(" ");
+                    }
                     result.append(" ");
                 }
             }
-            if (i % 16 != 0) {
-                result.append(" ");
-            }
+            byte b = array[i];
+            result.append(String.format("%02X", b));
+        }
+        return result.toString();
+    }
+
+    /**
+     * Like bytesToHexString() without any formatting.
+     */
+    public static String bytesToRawHexString(byte[] array) {
+        StringBuilder result = new StringBuilder();
+        for (int i = 0; i < array.length; i++) {
             byte b = array[i];
             result.append(String.format("%02X", b));
         }
@@ -240,8 +256,9 @@ public static void makeArrayNonZero(final byte[] array) {
      *
      * @param value
      * @param blockSize
-     * @param removeSignByte in a case the removeSignByte is set, the sign byte
-     *                       is removed (in case the byte array contains one)
+     * @param removeSignByte
+     *            in a case the removeSignByte is set, the sign byte is removed
+     *            (in case the byte array contains one)
      * @return
      */
     public static byte[] bigIntegerToByteArray(BigInteger value, int blockSize, boolean removeSignByte) {
diff --git a/src/main/java/de/rub/nds/modifiablevariable/util/BadFixedRandom.java b/src/main/java/de/rub/nds/modifiablevariable/util/BadFixedRandom.java
@@ -0,0 +1,36 @@
+/**
+ * TLS-Attacker - A Modular Penetration Testing Framework for TLS
+ *
+ * Copyright 2014-2016 Ruhr University Bochum / Hackmanit GmbH
+ *
+ * Licensed under Apache License 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+package de.rub.nds.modifiablevariable.util;
+
+import java.util.Random;
+
+/**
+ * A fake random number generator for testing. 
+ * This generator will always return the byte "retVal" passed to the constructor. 
+ * 
+ */
+public class BadFixedRandom extends Random {
+
+    byte retVal;
+
+    public BadFixedRandom(byte retVal) {
+        this.retVal = retVal;
+    }
+
+    /**
+     * Fills a user-supplied byte array with the fixed byte given at object initialization.
+     * The number of "random" bytes produced is equal to the length of the byte array.
+     */    
+    @Override
+    public void nextBytes(byte[] bytes) {
+        for (int i = 0, len = bytes.length; i < len;)
+            bytes[i++] = retVal;
+    }
+
+}
diff --git a/src/test/java/de/rub/nds/modifiablevariable/util/ArrayConverterTest.java b/src/test/java/de/rub/nds/modifiablevariable/util/ArrayConverterTest.java
@@ -43,17 +43,18 @@ public void testLongToUint32Bytes() {
     public void testIntToBytes() {
         int toParse = 5717;
         byte[] result = ArrayConverter.intToBytes(toParse, 2);
-        assertArrayEquals("The conversion result of 5717 should be {0x16} {0x55}", new byte[]{0x16, 0x55}, result);
+        assertArrayEquals("The conversion result of 5717 should be {0x16} {0x55}", new byte[] { 0x16, 0x55 }, result);
     }
 
     /**
      * Test of bytesToInt method, of class ArrayConverter.
      */
     @Test
     public void testBytesToInt() {
-        byte[] toParse = {0x16, 0x55};
+        byte[] toParse = { 0x16, 0x55 };
         int expectedResult = 5717;
-        assertEquals("The conversion result of {0x16, 0x55} should be 5717", expectedResult, ArrayConverter.bytesToInt(toParse));
+        assertEquals("The conversion result of {0x16, 0x55} should be 5717", expectedResult,
+                ArrayConverter.bytesToInt(toParse));
     }
 
     /**
@@ -76,17 +77,17 @@ public void testBytesToLong() {
      */
     @Test
     public void testBytesToHexString_byteArr() {
-        byte[] toTest = new byte[]{0x00, 0x11, 0x22, 0x33, 0x44};
+        byte[] toTest = new byte[] { 0x00, 0x11, 0x22, 0x33, 0x44 };
         assertEquals("00 11 22 33 44", ArrayConverter.bytesToHexString(toTest));
-        toTest = new byte[]{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08};
+        toTest = new byte[] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
         assertEquals("00 01 02 03 04 05 06 07 08", ArrayConverter.bytesToHexString(toTest));
-        toTest = new byte[]{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10};
+        toTest = new byte[] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10 };
         assertEquals("00 01 02 03 04 05 06 07 08 09 10", ArrayConverter.bytesToHexString(toTest));
-        toTest = new byte[]{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
-            0x07,};
+        toTest = new byte[] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
+                0x07, };
         assertEquals("\n00 01 02 03 04 05 06 07  00 01 02 03 04 05 06 07", ArrayConverter.bytesToHexString(toTest));
-        toTest = new byte[]{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
-            0x07, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,};
+        toTest = new byte[] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
+                0x07, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, };
         assertEquals(
                 "\n00 01 02 03 04 05 06 07  00 01 02 03 04 05 06 07\n00 01 02 03 04 05 06 07  00 01 02 03 04 05 06 07",
                 ArrayConverter.bytesToHexString(toTest));
@@ -97,6 +98,14 @@ public void testBytesToHexString_byteArr() {
      */
     @Test
     public void testBytesToHexString_byteArr_boolean() {
+        byte[] toTest = new byte[] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x00, 0x01, 0x02, 0x03, 0x04,
+                0x05, 0x06, 0x07, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
+                0x06, 0x07 };
+        assertEquals("00 01 02 03 04 05 06 07 00 01 02 03 04 05 06 07 00 01 02 03 04 05 06 07 00 01 02 03 04 05 06 07",
+                ArrayConverter.bytesToHexString(toTest, false));
+        assertEquals(
+                "\n00 01 02 03 04 05 06 07  00 01 02 03 04 05 06 07\n00 01 02 03 04 05 06 07  00 01 02 03 04 05 06 07",
+                ArrayConverter.bytesToHexString(toTest, true));
     }
 
     /**
@@ -106,6 +115,18 @@ public void testBytesToHexString_byteArr_boolean() {
     public void testBytesToHexString_3args() {
     }
 
+    /**
+     * Test ArrayConverter.bytesToRawHexString().
+     */
+    @Test
+    public void testBytesToRawHexString() {
+        byte[] toTest = new byte[] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x00, 0x01, 0x02, 0x03, 0x04,
+                0x05, 0x06, 0x07, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
+                0x06, 0x07 };
+        assertEquals("0001020304050607000102030405060700010203040506070001020304050607",
+                ArrayConverter.bytesToRawHexString(toTest));
+    }
+
     /**
      * Test of concatenate method, of class ArrayConverter.
      */
@@ -154,13 +175,13 @@ public void testConvertListToArray() {
     @Test
     public void testHexStringToByteArray() {
         String hex = "01";
-        assertArrayEquals("Testing simple one byte hex value", new byte[]{0x01},
+        assertArrayEquals("Testing simple one byte hex value", new byte[] { 0x01 },
                 ArrayConverter.hexStringToByteArray(hex));
         hex = "FF";
-        assertArrayEquals("Testing one byte hex value > 0x7f", new byte[]{(byte) 0xff},
+        assertArrayEquals("Testing one byte hex value > 0x7f", new byte[] { (byte) 0xff },
                 ArrayConverter.hexStringToByteArray(hex));
         hex = "FFFFFF";
-        assertArrayEquals("Testing one byte hex value > 0x7f", new byte[]{(byte) 0xff, (byte) 0xff, (byte) 0xff},
+        assertArrayEquals("Testing one byte hex value > 0x7f", new byte[] { (byte) 0xff, (byte) 0xff, (byte) 0xff },
                 ArrayConverter.hexStringToByteArray(hex));
     }
 
@@ -170,7 +191,7 @@ public void testBigIntegerToNullPaddedByteArray() {
 
         assertArrayEquals("Check zero output size", new byte[0],
                 ArrayConverter.bigIntegerToNullPaddedByteArray(test, 0));
-        assertArrayEquals("Check check output size smaller than input", new byte[]{(byte) 0xEC},
+        assertArrayEquals("Check check output size smaller than input", new byte[] { (byte) 0xEC },
                 ArrayConverter.bigIntegerToNullPaddedByteArray(test, 1));
         assertArrayEquals("Check output size bigger than input size",
                 ArrayConverter.hexStringToByteArray("0000000000000000000000001D42C86F7923DFEC"),

Original file line number	Diff line number	Diff line change
`@@ -20,8 +20,7 @@`
`20`	`20`
`21`	`21`	`/**`
`22`	`22`	`*`
`23`		`- * @author Robert Merget - robert.merget@rub.de`
`24`		`- * Highly Experimental`
	`23`	`+ * @author Robert Merget - robert.merget@rub.de Highly Experimental`
`25`	`24`	`*/`
`26`	`25`	`@XmlRootElement`
`27`	`26`	`@XmlSeeAlso({ IntegerAddModification.class, IntegerExplicitValueModification.class, IntegerSubtractModification.class,`