diff --git a/.gitignore b/.gitignore index e0f94da2..d10feb99 100644 --- a/.gitignore +++ b/.gitignore @@ -9,9 +9,11 @@ nbproject/ nbactions.xml.project nbactions.xml -# IntelliJ -.idea/ +### IntelliJ IDEA ### +.idea/* +*.iws *.iml +*.ipr # VS Code .vscode/ diff --git a/README.md b/README.md index eafb3cf9..82f6eac8 100644 --- a/README.md +++ b/README.md @@ -42,7 +42,7 @@ The best way to present the functionality of ModifiableVariables is by means of ModifiableInteger i = new ModifiableInteger(); i.setOriginalValue(30); VariableModification modifier = IntegerModificationFactory.add(20); -i.setModification(modifier); +i.setModifications(modifier); System.out.println(i.getValue()); // 50 ``` @@ -56,7 +56,7 @@ In byte arrays you can use further modifications like shuffling or inserting byt ModifiableByteArray ba = new ModifiableByteArray(); VariableModification modifier = ByteArrayModificationFactory.insert(new byte[] {2, 3}, 1); ba.setOriginalValue(new byte[]{1, 4}); -ba.setModification(modifier); +ba.setModifications(modifier); System.out.println(ArrayConverter.bytesToHexString(ba)); // 01 02 03 04 ``` @@ -116,15 +116,17 @@ The result of the serialized modifiable byte array looks as follows: ``` -If you would use modification from the previous example, the result would look as follows: +If you were to use the modification from the previous example, the result would look as follows: ```xml 01 02 03 - - 02 03 - 1 - + + + 02 03 + 1 + + ``` diff --git a/src/main/java/de/rub/nds/modifiablevariable/FileConfigurationException.java b/src/main/java/de/rub/nds/modifiablevariable/FileConfigurationException.java index e1d0f700..fbc01d75 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/FileConfigurationException.java +++ b/src/main/java/de/rub/nds/modifiablevariable/FileConfigurationException.java @@ -9,7 +9,9 @@ public class FileConfigurationException extends RuntimeException { - public FileConfigurationException() {} + public FileConfigurationException() { + super(); + } public FileConfigurationException(Exception ex) { super(ex); diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java index fe196ed1..7aca6a30 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java @@ -7,201 +7,119 @@ */ package de.rub.nds.modifiablevariable; -import de.rub.nds.modifiablevariable.biginteger.BigIntegerAddModification; -import de.rub.nds.modifiablevariable.biginteger.BigIntegerExplicitValueModification; -import de.rub.nds.modifiablevariable.biginteger.BigIntegerInteractiveModification; -import de.rub.nds.modifiablevariable.biginteger.BigIntegerMultiplyModification; -import de.rub.nds.modifiablevariable.biginteger.BigIntegerShiftLeftModification; -import de.rub.nds.modifiablevariable.biginteger.BigIntegerShiftRightModification; -import de.rub.nds.modifiablevariable.biginteger.BigIntegerSubtractModification; -import de.rub.nds.modifiablevariable.biginteger.BigIntegerXorModification; -import de.rub.nds.modifiablevariable.bool.BooleanExplicitValueModification; -import de.rub.nds.modifiablevariable.bool.BooleanToggleModification; -import de.rub.nds.modifiablevariable.bytearray.ByteArrayDeleteModification; -import de.rub.nds.modifiablevariable.bytearray.ByteArrayDuplicateModification; -import de.rub.nds.modifiablevariable.bytearray.ByteArrayExplicitValueModification; -import de.rub.nds.modifiablevariable.bytearray.ByteArrayInsertModification; -import de.rub.nds.modifiablevariable.bytearray.ByteArrayShuffleModification; -import de.rub.nds.modifiablevariable.bytearray.ByteArrayXorModification; -import de.rub.nds.modifiablevariable.integer.IntegerAddModification; -import de.rub.nds.modifiablevariable.integer.IntegerExplicitValueModification; -import de.rub.nds.modifiablevariable.integer.IntegerShiftLeftModification; -import de.rub.nds.modifiablevariable.integer.IntegerShiftRightModification; -import de.rub.nds.modifiablevariable.integer.IntegerSubtractModification; -import de.rub.nds.modifiablevariable.integer.IntegerXorModification; -import de.rub.nds.modifiablevariable.longint.LongAddModification; -import de.rub.nds.modifiablevariable.longint.LongExplicitValueModification; -import de.rub.nds.modifiablevariable.longint.LongSubtractModification; -import de.rub.nds.modifiablevariable.longint.LongXorModification; -import de.rub.nds.modifiablevariable.singlebyte.ByteAddModification; -import de.rub.nds.modifiablevariable.singlebyte.ByteExplicitValueModification; -import de.rub.nds.modifiablevariable.singlebyte.ByteSubtractModification; -import de.rub.nds.modifiablevariable.singlebyte.ByteXorModification; -import de.rub.nds.modifiablevariable.string.StringAppendValueModification; -import de.rub.nds.modifiablevariable.string.StringExplicitValueModification; -import de.rub.nds.modifiablevariable.string.StringPrependValueModification; -import jakarta.xml.bind.annotation.XmlAccessType; -import jakarta.xml.bind.annotation.XmlAccessorType; -import jakarta.xml.bind.annotation.XmlElement; -import jakarta.xml.bind.annotation.XmlElements; -import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlTransient; +import jakarta.xml.bind.annotation.*; import java.io.Serializable; -import java.util.Objects; +import java.util.LinkedList; +import java.util.List; +import java.util.stream.Collectors; /** - * The base abstract class for modifiable variables, including the getValue function.The class needs - * to be defined transient to allow propOrder definition in subclasses, see: - * http://blog.bdoughan.com/2011/06/ignoring-inheritance-with-xmltransient.html + * The base abstract class for modifiable variables, including the getValue function. The class + * needs to be defined transient to allow propOrder definition in subclasses, see: docs * * @param */ -@XmlRootElement @XmlTransient @XmlAccessorType(XmlAccessType.FIELD) public abstract class ModifiableVariable implements Serializable { - @XmlElements( - value = { - @XmlElement( - type = BigIntegerXorModification.class, - name = "BigIntegerXorModification"), - @XmlElement( - type = BigIntegerSubtractModification.class, - name = "BigIntegerSubtractModification"), - @XmlElement( - type = BigIntegerShiftRightModification.class, - name = "BigIntegerShiftRightModification"), - @XmlElement( - type = BigIntegerShiftLeftModification.class, - name = "BigIntegerShiftLeftModification"), - @XmlElement( - type = BigIntegerExplicitValueModification.class, - name = "BigIntegerExplicitValueModification"), - @XmlElement( - type = BigIntegerAddModification.class, - name = "BigIntegerAddModification"), - @XmlElement( - type = BigIntegerInteractiveModification.class, - name = "BigIntegerInteractiveModification"), - @XmlElement( - type = BigIntegerMultiplyModification.class, - name = "BigIntegerMultiplyModification"), - @XmlElement( - type = BooleanToggleModification.class, - name = "BooleanToggleModification"), - @XmlElement( - type = BooleanExplicitValueModification.class, - name = "BooleanExplicitValueModification"), - @XmlElement( - type = ByteArrayXorModification.class, - name = "ByteArrayXorModification"), - @XmlElement( - type = ByteArrayShuffleModification.class, - name = "ByteArrayShuffleModification"), - @XmlElement( - type = ByteArrayInsertModification.class, - name = "ByteArrayInsertModification"), - @XmlElement( - type = ByteArrayExplicitValueModification.class, - name = "ByteArrayExplicitValueModification"), - @XmlElement( - type = ByteArrayDuplicateModification.class, - name = "ByteArrayDuplicateModification"), - @XmlElement( - type = ByteArrayDeleteModification.class, - name = "ByteArrayDeleteModification"), - @XmlElement(type = IntegerXorModification.class, name = "IntegerXorModification"), - @XmlElement( - type = IntegerSubtractModification.class, - name = "IntegerSubtractModification"), - @XmlElement( - type = IntegerShiftRightModification.class, - name = "IntegerShiftRightModification"), - @XmlElement( - type = IntegerShiftLeftModification.class, - name = "IntegerShiftLeftModification"), - @XmlElement( - type = IntegerExplicitValueModification.class, - name = "IntegerExplicitValueModification"), - @XmlElement(type = IntegerAddModification.class, name = "IntegerAddModification"), - @XmlElement(type = LongXorModification.class, name = "LongXorModification"), - @XmlElement( - type = LongSubtractModification.class, - name = "LongSubtractModification"), - @XmlElement( - type = LongExplicitValueModification.class, - name = "LongExplicitValueModification"), - @XmlElement(type = LongAddModification.class, name = "LongAddModification"), - @XmlElement(type = ByteXorModification.class, name = "ByteXorModification"), - @XmlElement( - type = ByteSubtractModification.class, - name = "ByteSubtractModification"), - @XmlElement(type = ByteAddModification.class, name = "ByteAddModification"), - @XmlElement( - type = ByteExplicitValueModification.class, - name = "ByteExplicitValueModification"), - @XmlElement( - type = StringPrependValueModification.class, - name = "StringPrependValueModification"), - @XmlElement( - type = StringAppendValueModification.class, - name = "StringAppendValueModification"), - @XmlElement( - type = StringExplicitValueModification.class, - name = "StringExplicitValueModification") - }) - private VariableModification modification = null; - - private Boolean createRandomModification; + @XmlElementWrapper + @XmlAnyElement(lax = true) + private LinkedList> modifications; protected E assertEquals; - public ModifiableVariable() {} + protected ModifiableVariable() { + super(); + } - public void setModification(VariableModification modification) { - this.modification = modification; + protected ModifiableVariable(ModifiableVariable other) { + super(); + if (other.modifications != null) { + modifications = new LinkedList<>(); + for (VariableModification item : other.modifications) { + modifications.add(item != null ? item.createCopy() : null); + } + } + // Warning: Make sure to copy assertEquals in subclass correctly + assertEquals = other.assertEquals; } - @XmlTransient - public VariableModification getModification() { - return modification; + /** Sets multiple modifications, all previously set modifications are removed */ + public void setModifications(List> modifications) { + this.modifications = new LinkedList<>(modifications); } - public E getValue() { - if (Objects.equals(createRandomModification, Boolean.TRUE)) { - createRandomModification(); - createRandomModification = false; - } + /** Sets multiple modifications, all previously set modifications are removed */ + @SafeVarargs + public final void setModifications(VariableModification... modifications) { + this.modifications = new LinkedList<>(List.of(modifications)); + } + /** Removes all modifications */ + public void clearModifications() { + modifications = null; + } + + /** Adds a modification to this modifiable variable */ + public void addModification(VariableModification modification) { if (modification != null) { - return modification.modify(getOriginalValue()); + if (modifications == null) { + modifications = new LinkedList<>(); + } + modifications.add(modification); + } + } + + /** Returns all modifications that are set for this modifiable variable */ + public LinkedList> getModifications() { + return modifications; + } + + public E getValue() { + return getModifiedValue(); + } + + private E getModifiedValue() { + E resultValue = getOriginalValue(); + if (modifications != null) { + for (VariableModification modification : modifications) { + resultValue = modification.modify(resultValue); + } } - return getOriginalValue(); + return resultValue; } public abstract E getOriginalValue(); public abstract void setOriginalValue(E originalValue); - protected abstract void createRandomModification(); - - public void createRandomModificationAtRuntime() { - createRandomModification = true; - } + public abstract ModifiableVariable createCopy(); public abstract boolean isOriginalValueModified(); public abstract boolean validateAssertions(); public boolean containsAssertion() { - return (assertEquals != null); + return assertEquals != null; } - public Boolean isCreateRandomModification() { - if (createRandomModification == null) { - return false; + protected String innerToString() { + StringBuilder result = new StringBuilder(); + if (modifications != null) { + result.append(", modifications=[") + .append( + modifications.stream() + .map(Object::toString) + .collect(Collectors.joining(", "))) + .append("]"); } - return createRandomModification; + + if (assertEquals != null) { + result.append(", assertEquals=").append(assertEquals); + } + + return result.toString(); } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableFactory.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableFactory.java index 19b9a22d..7f163b09 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableFactory.java @@ -16,7 +16,7 @@ import de.rub.nds.modifiablevariable.string.ModifiableString; import java.math.BigInteger; -public class ModifiableVariableFactory { +public final class ModifiableVariableFactory { public static ModifiableBigInteger createBigIntegerModifiableVariable() { return new ModifiableBigInteger(); @@ -38,9 +38,17 @@ public static ModifiableLong createLongModifiableVariable() { return new ModifiableLong(); } + public static ModifiableBoolean createBooleanModifiableVariable() { + return new ModifiableBoolean(); + } + + public static ModifiableString createStringModifiableVariable() { + return new ModifiableString(); + } + public static ModifiableBigInteger safelySetValue(ModifiableBigInteger mv, BigInteger value) { if (mv == null) { - mv = new ModifiableBigInteger(); + return new ModifiableBigInteger(value); } mv.setOriginalValue(value); return mv; @@ -48,7 +56,7 @@ public static ModifiableBigInteger safelySetValue(ModifiableBigInteger mv, BigIn public static ModifiableString safelySetValue(ModifiableString mv, String value) { if (mv == null) { - mv = new ModifiableString(); + return new ModifiableString(value); } mv.setOriginalValue(value); return mv; @@ -56,7 +64,7 @@ public static ModifiableString safelySetValue(ModifiableString mv, String value) public static ModifiableInteger safelySetValue(ModifiableInteger mv, Integer value) { if (mv == null) { - mv = new ModifiableInteger(); + return new ModifiableInteger(value); } mv.setOriginalValue(value); return mv; @@ -64,7 +72,7 @@ public static ModifiableInteger safelySetValue(ModifiableInteger mv, Integer val public static ModifiableByte safelySetValue(ModifiableByte mv, Byte value) { if (mv == null) { - mv = new ModifiableByte(); + return new ModifiableByte(value); } mv.setOriginalValue(value); return mv; @@ -72,7 +80,7 @@ public static ModifiableByte safelySetValue(ModifiableByte mv, Byte value) { public static ModifiableByteArray safelySetValue(ModifiableByteArray mv, byte[] value) { if (mv == null) { - mv = new ModifiableByteArray(); + return new ModifiableByteArray(value); } mv.setOriginalValue(value); return mv; @@ -80,7 +88,7 @@ public static ModifiableByteArray safelySetValue(ModifiableByteArray mv, byte[] public static ModifiableLong safelySetValue(ModifiableLong mv, Long value) { if (mv == null) { - mv = new ModifiableLong(); + return new ModifiableLong(value); } mv.setOriginalValue(value); return mv; @@ -88,11 +96,13 @@ public static ModifiableLong safelySetValue(ModifiableLong mv, Long value) { public static ModifiableBoolean safelySetValue(ModifiableBoolean mv, Boolean value) { if (mv == null) { - mv = new ModifiableBoolean(); + return new ModifiableBoolean(value); } mv.setOriginalValue(value); return mv; } - private ModifiableVariableFactory() {} + private ModifiableVariableFactory() { + super(); + } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableHolder.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableHolder.java index 137fc7b8..73f6a3c3 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableHolder.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableHolder.java @@ -30,7 +30,7 @@ public abstract class ModifiableVariableHolder implements Serializable { * @return List of all modifiableVariables declared in this class */ public List getAllModifiableVariableFields() { - return ReflectionHelper.getFieldsUpTo(this.getClass(), null, ModifiableVariable.class); + return ReflectionHelper.getFieldsUpTo(getClass(), null, ModifiableVariable.class); } /** @@ -70,22 +70,22 @@ public ModifiableVariableHolder getRandomModifiableVariableHolder(Random random) public void reset() { List fields = getAllModifiableVariableFields(); - for (Field f : fields) { - f.setAccessible(true); + for (Field field : fields) { + field.setAccessible(true); ModifiableVariable mv = null; try { - mv = (ModifiableVariable) f.get(this); + mv = (ModifiableVariable) field.get(this); } catch (IllegalArgumentException | IllegalAccessException ex) { LOGGER.warn("Could not retrieve ModifiableVariables"); LOGGER.debug(ex); } if (mv != null) { - if (mv.getModification() != null || mv.isCreateRandomModification()) { + if (mv.getModifications() != null) { mv.setOriginalValue(null); } else { try { - f.set(this, null); + field.set(this, null); } catch (IllegalArgumentException | IllegalAccessException ex) { LOGGER.warn("Could not strip ModifiableVariable without Modification"); } @@ -95,17 +95,12 @@ public void reset() { } public String getExtendedString() { - StringBuilder sb = new StringBuilder(); - sb.append(getClass().getSimpleName()); - sb.append("{\n"); - sb.append(getExtendedString(1)); - sb.append("}\n"); - return sb.toString(); + return getClass().getSimpleName() + "{\n" + getExtendedString(1) + "}\n"; } protected String getExtendedString(int depth) { StringBuilder stringBuilder = new StringBuilder(); - List fields = ReflectionHelper.getFieldsUpTo(this.getClass(), null, null); + List fields = ReflectionHelper.getFieldsUpTo(getClass(), null, null); for (Field field : fields) { field.setAccessible(true); // skip static @@ -120,43 +115,32 @@ protected String getExtendedString(int depth) { LOGGER.debug(ex); } if (tempObject != null) { - if (tempObject instanceof byte[]) { - byte[] temp = (byte[]) tempObject; - for (int i = 0; i < depth; i++) { - stringBuilder.append("\t"); - } + if (tempObject instanceof byte[] temp) { + stringBuilder.append("\t".repeat(Math.max(0, depth))); stringBuilder.append(field.getName()); stringBuilder.append(": "); stringBuilder.append(ArrayConverter.bytesToHexString(temp)); stringBuilder.append("\n"); } if (tempObject instanceof ModifiableVariableHolder) { - for (int i = 0; i < depth; i++) { - stringBuilder.append("\t"); - } + stringBuilder.append("\t".repeat(Math.max(0, depth))); stringBuilder.append(field.getName()); stringBuilder.append(":"); stringBuilder.append(tempObject.getClass().getSimpleName()); stringBuilder.append("{\n"); stringBuilder.append( ((ModifiableVariableHolder) tempObject).getExtendedString(depth + 1)); - for (int i = 0; i < depth; i++) { - stringBuilder.append("\t"); - } + stringBuilder.append("\t".repeat(Math.max(0, depth))); stringBuilder.append("}\n"); } else { - for (int i = 0; i < depth; i++) { - stringBuilder.append("\t"); - } + stringBuilder.append("\t".repeat(Math.max(0, depth))); stringBuilder.append(field.getName()); stringBuilder.append(": "); - stringBuilder.append(tempObject.toString()); + stringBuilder.append(tempObject); stringBuilder.append("\n"); } } else { - for (int i = 0; i < depth; i++) { - stringBuilder.append("\t"); - } + stringBuilder.append("\t".repeat(Math.max(0, depth))); stringBuilder.append(field.getName()); stringBuilder.append(": null\n"); } diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableProperty.java b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableProperty.java index e80a3d64..affcc4db 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableProperty.java +++ b/src/main/java/de/rub/nds/modifiablevariable/ModifiableVariableProperty.java @@ -17,7 +17,7 @@ @Retention(RetentionPolicy.RUNTIME) public @interface ModifiableVariableProperty { - public enum Type { + enum Type { LENGTH, COUNT, PADDING, @@ -38,7 +38,7 @@ public enum Type { BEHAVIOR_SWITCH } - public enum Format { + enum Format { ASN1, PKCS1, NONE diff --git a/src/main/java/de/rub/nds/modifiablevariable/ModificationFilter.java b/src/main/java/de/rub/nds/modifiablevariable/ModificationFilter.java deleted file mode 100644 index f7967f1b..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/ModificationFilter.java +++ /dev/null @@ -1,22 +0,0 @@ -/* - * ModifiableVariable - A Variable Concept for Runtime Modifications - * - * Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH - * - * Licensed under Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 - */ -package de.rub.nds.modifiablevariable; - -import de.rub.nds.modifiablevariable.filter.AccessModificationFilter; -import jakarta.xml.bind.annotation.XmlSeeAlso; - -/** - * It is possible to filter modifications only for specific number of data accesses or specific - * data. For example, only the first data access returns a modified value. This can be achieved - * using a ModificationFilter object. - */ -@XmlSeeAlso({AccessModificationFilter.class}) -public abstract class ModificationFilter { - - public abstract boolean filterModification(); -} diff --git a/src/main/java/de/rub/nds/modifiablevariable/VariableModification.java b/src/main/java/de/rub/nds/modifiablevariable/VariableModification.java index 04e81ef2..e4e39170 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/VariableModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/VariableModification.java @@ -9,52 +9,39 @@ import static de.rub.nds.modifiablevariable.util.StringUtil.backslashEscapeString; -import de.rub.nds.modifiablevariable.filter.AccessModificationFilter; import de.rub.nds.modifiablevariable.util.ArrayConverter; import jakarta.xml.bind.annotation.XmlAccessType; import jakarta.xml.bind.annotation.XmlAccessorType; -import jakarta.xml.bind.annotation.XmlElement; -import jakarta.xml.bind.annotation.XmlElements; -import jakarta.xml.bind.annotation.XmlRootElement; import jakarta.xml.bind.annotation.XmlTransient; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; -@XmlRootElement @XmlTransient @XmlAccessorType(XmlAccessType.FIELD) public abstract class VariableModification { protected static final Logger LOGGER = LogManager.getLogger(VariableModification.class); - /** - * In specific cases it is possible to filter out some modifications based on given rules. - * ModificationFilter is responsible for validating if the modification can be executed. - */ - @XmlElements( - value = { - @XmlElement( - type = AccessModificationFilter.class, - name = "AccessModificationFilter") - }) - private ModificationFilter modificationFilter = null; + protected VariableModification() { + super(); + } + + protected VariableModification(VariableModification other) { + super(); + } + + public abstract VariableModification createCopy(); public E modify(E input) { E modifiedValue = modifyImplementationHook(input); - if ((modificationFilter == null) || (modificationFilter.filterModification() == false)) { - debug(modifiedValue); - return modifiedValue; - } else { - return input; - } + debug(modifiedValue); + return modifiedValue; } protected abstract E modifyImplementationHook(E input); - public abstract VariableModification getModifiedCopy(); - /** - * Debugging modified variables. Getting stack trace can be time consuming, thus we use + * Debugging modified variables. Getting stack trace can be time-consuming, thus we use * isDebugEnabled() function * * @param value variable modification that is going to be debugged @@ -68,27 +55,24 @@ protected void debug(E value) { index = i + 1; } } - String valueString; - if (value instanceof byte[]) { - valueString = ArrayConverter.bytesToHexString((byte[]) value); - } else if (value instanceof String) { - valueString = backslashEscapeString((String) value); + if (value == null) { + LOGGER.debug( + "Using {} in function:\n {}\n New value is unset", + getClass().getSimpleName(), + stack[index]); } else { - valueString = value.toString(); + String valueString = + switch (value) { + case byte[] bytes -> ArrayConverter.bytesToHexString(bytes); + case String s -> backslashEscapeString(s); + default -> value.toString(); + }; + LOGGER.debug( + "Using {} in function:\n {}\n New value: {}", + getClass().getSimpleName(), + stack[index], + valueString); } - LOGGER.debug( - "Using {} in function:\n {}\n New value: {}", - this.getClass().getSimpleName(), - stack[index], - valueString); } } - - public ModificationFilter getModificationFilter() { - return modificationFilter; - } - - public void setModificationFilter(ModificationFilter modificationFilter) { - this.modificationFilter = modificationFilter; - } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModification.java index 012555ca..3db45077 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModification.java @@ -8,32 +8,37 @@ package de.rub.nds.modifiablevariable.biginteger; import de.rub.nds.modifiablevariable.VariableModification; -import jakarta.xml.bind.annotation.XmlAccessType; -import jakarta.xml.bind.annotation.XmlAccessorType; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.math.BigInteger; import java.util.Objects; -import java.util.Random; @XmlRootElement -@XmlType(propOrder = {"summand", "modificationFilter"}) -@XmlAccessorType(XmlAccessType.FIELD) public class BigIntegerAddModification extends VariableModification { - private static final int MAX_ADD_LENGTH = 8; - private BigInteger summand; - public BigIntegerAddModification() {} + public BigIntegerAddModification() { + super(); + } + + public BigIntegerAddModification(BigInteger summand) { + super(); + this.summand = summand; + } + + public BigIntegerAddModification(BigIntegerAddModification other) { + super(other); + summand = other.summand; + } - public BigIntegerAddModification(BigInteger bi) { - this.summand = bi; + @Override + public BigIntegerAddModification createCopy() { + return new BigIntegerAddModification(this); } @Override protected BigInteger modifyImplementationHook(BigInteger input) { - return (input == null) ? summand : input.add(summand); + return input == null ? summand : input.add(summand); } public BigInteger getSummand() { @@ -44,16 +49,10 @@ public void setSummand(BigInteger summand) { this.summand = summand; } - @Override - public VariableModification getModifiedCopy() { - return new BigIntegerAddModification( - summand.add(new BigInteger(MAX_ADD_LENGTH, new Random()))); - } - @Override public int hashCode() { int hash = 7; - hash = 41 * hash + Objects.hashCode(this.summand); + hash = 31 * hash + Objects.hashCode(summand); return hash; } @@ -68,10 +67,12 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final BigIntegerAddModification other = (BigIntegerAddModification) obj; - if (!Objects.equals(this.summand, other.summand)) { - return false; - } - return true; + BigIntegerAddModification other = (BigIntegerAddModification) obj; + return Objects.equals(summand, other.summand); + } + + @Override + public String toString() { + return "BigIntegerAddModification{" + "summand=" + summand + '}'; } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModification.java index 8f59ad9d..ac739e83 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModification.java @@ -8,31 +8,36 @@ package de.rub.nds.modifiablevariable.biginteger; import de.rub.nds.modifiablevariable.VariableModification; -import jakarta.xml.bind.annotation.XmlAccessType; -import jakarta.xml.bind.annotation.XmlAccessorType; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.math.BigInteger; import java.util.Objects; -import java.util.Random; @XmlRootElement -@XmlType(propOrder = {"explicitValue", "modificationFilter"}) -@XmlAccessorType(XmlAccessType.FIELD) public class BigIntegerExplicitValueModification extends VariableModification { - private static final int MAX_EXPLICIT_LENGTH = 8; + protected BigInteger explicitValue; - private BigInteger explicitValue; + public BigIntegerExplicitValueModification() { + super(); + } + + public BigIntegerExplicitValueModification(BigInteger explicitValue) { + super(); + this.explicitValue = explicitValue; + } - public BigIntegerExplicitValueModification() {} + public BigIntegerExplicitValueModification(BigIntegerExplicitValueModification other) { + super(other); + explicitValue = other.explicitValue; + } - public BigIntegerExplicitValueModification(BigInteger bi) { - this.explicitValue = bi; + @Override + public BigIntegerExplicitValueModification createCopy() { + return new BigIntegerExplicitValueModification(this); } @Override - protected BigInteger modifyImplementationHook(final BigInteger input) { + protected BigInteger modifyImplementationHook(BigInteger input) { return explicitValue; } @@ -44,22 +49,10 @@ public void setExplicitValue(BigInteger explicitValue) { this.explicitValue = explicitValue; } - @Override - public VariableModification getModifiedCopy() { - Random r = new Random(); - if (r.nextBoolean()) { - return new BigIntegerExplicitValueModification( - explicitValue.add(new BigInteger(MAX_EXPLICIT_LENGTH, r))); - } else { - return new BigIntegerExplicitValueModification( - explicitValue.subtract(new BigInteger(MAX_EXPLICIT_LENGTH, r))); - } - } - @Override public int hashCode() { - int hash = 3; - hash = 41 * hash + Objects.hashCode(this.explicitValue); + int hash = 7; + hash = 31 * hash + Objects.hashCode(explicitValue); return hash; } @@ -74,10 +67,12 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final BigIntegerExplicitValueModification other = (BigIntegerExplicitValueModification) obj; - if (!Objects.equals(this.explicitValue, other.explicitValue)) { - return false; - } - return true; + BigIntegerExplicitValueModification other = (BigIntegerExplicitValueModification) obj; + return Objects.equals(explicitValue, other.explicitValue); + } + + @Override + public String toString() { + return "BigIntegerExplicitValueModification{" + "explicitValue=" + explicitValue + '}'; } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInteractiveModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInteractiveModification.java deleted file mode 100644 index 0ec3fa18..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerInteractiveModification.java +++ /dev/null @@ -1,48 +0,0 @@ -/* - * ModifiableVariable - A Variable Concept for Runtime Modifications - * - * Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH - * - * Licensed under Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 - */ -package de.rub.nds.modifiablevariable.biginteger; - -import de.rub.nds.modifiablevariable.VariableModification; -import jakarta.xml.bind.annotation.XmlAccessType; -import jakarta.xml.bind.annotation.XmlAccessorType; -import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlTransient; -import jakarta.xml.bind.annotation.XmlType; -import java.math.BigInteger; - -@XmlRootElement -@XmlType(propOrder = {"modificationFilter"}) -@XmlAccessorType(XmlAccessType.FIELD) -public class BigIntegerInteractiveModification extends VariableModification { - - @XmlTransient private InteractiveBigIntegerModification modification; - - protected BigIntegerInteractiveModification() { - this.modification = BigIntegerModificationFactory.getStandardInteractiveModification(); - } - - protected BigIntegerInteractiveModification(InteractiveBigIntegerModification modification) { - this.modification = modification; - } - - @Override - protected BigInteger modifyImplementationHook(final BigInteger input) { - return this.modification.modify(input); - } - - public interface InteractiveBigIntegerModification { - - BigInteger modify(BigInteger oldVal); - } - - @Override - public VariableModification getModifiedCopy() { - throw new UnsupportedOperationException( - "This method is not supported for interactive modifications"); - } -} diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerModificationFactory.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerModificationFactory.java index abb2c80e..ae4c835d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerModificationFactory.java @@ -7,182 +7,64 @@ */ package de.rub.nds.modifiablevariable.biginteger; -import de.rub.nds.modifiablevariable.FileConfigurationException; import de.rub.nds.modifiablevariable.VariableModification; -import de.rub.nds.modifiablevariable.bytearray.ByteArrayModificationFactory; -import de.rub.nds.modifiablevariable.integer.IntegerModificationFactory; -import de.rub.nds.modifiablevariable.util.RandomHelper; -import java.io.BufferedReader; -import java.io.IOException; -import java.io.InputStream; -import java.io.InputStreamReader; import java.math.BigInteger; -import java.util.LinkedList; -import java.util.List; -import java.util.Random; -import java.util.Scanner; -public class BigIntegerModificationFactory { +public final class BigIntegerModificationFactory { - private static final int MODIFICATION_COUNT = 7; - - private static final int MAX_MODIFICATION_VALUE = 320000; - - private static final int MAX_MODIFICATION_SHIFT_VALUE = 50; - - private static List> modificationsFromFile; - - public static BigIntegerAddModification add(final String summand) { + public static BigIntegerAddModification add(String summand) { return add(new BigInteger(summand)); } - public static BigIntegerAddModification add(final BigInteger summand) { + public static BigIntegerAddModification add(BigInteger summand) { return new BigIntegerAddModification(summand); } - public static BigIntegerShiftLeftModification shiftLeft(final String shift) { + public static BigIntegerShiftLeftModification shiftLeft(String shift) { return shiftLeft(Integer.parseInt(shift)); } - public static BigIntegerShiftLeftModification shiftLeft(final Integer shift) { + public static BigIntegerShiftLeftModification shiftLeft(Integer shift) { return new BigIntegerShiftLeftModification(shift); } - public static BigIntegerShiftRightModification shiftRight(final String shift) { + public static BigIntegerShiftRightModification shiftRight(String shift) { return shiftRight(Integer.parseInt(shift)); } - public static BigIntegerShiftRightModification shiftRight(final Integer shift) { + public static BigIntegerShiftRightModification shiftRight(Integer shift) { return new BigIntegerShiftRightModification(shift); } - public static BigIntegerMultiplyModification multiply(final BigInteger factor) { + public static BigIntegerMultiplyModification multiply(BigInteger factor) { return new BigIntegerMultiplyModification(factor); } - public static VariableModification sub(final String subtrahend) { + public static VariableModification sub(String subtrahend) { return sub(new BigInteger(subtrahend)); } - public static VariableModification sub(final BigInteger subtrahend) { + public static VariableModification sub(BigInteger subtrahend) { return new BigIntegerSubtractModification(subtrahend); } - public static VariableModification xor(final String xor) { + public static VariableModification xor(String xor) { return xor(new BigInteger(xor)); } - public static VariableModification xor(final BigInteger xor) { + public static VariableModification xor(BigInteger xor) { return new BigIntegerXorModification(xor); } - public static VariableModification explicitValue(final String value) { + public static VariableModification explicitValue(String value) { return explicitValue(new BigInteger(value)); } - public static VariableModification explicitValue(final BigInteger value) { + public static VariableModification explicitValue(BigInteger value) { return new BigIntegerExplicitValueModification(value); } - public static VariableModification explicitValueFromFile(int value) { - List> modifications = modificationsFromFile(); - int pos = value % modifications.size(); - return modifications.get(pos); - } - - /* - * Interactive modification - */ - private static BigIntegerInteractiveModification.InteractiveBigIntegerModification - standardInteractiveModification = - new BigIntegerInteractiveModification.InteractiveBigIntegerModification() { - private BigInteger value; - - @Override - public BigInteger modify(BigInteger oldVal) { - if (value == null) { - System.out.println("Enter new value for BigInt: "); - Scanner scanner = new Scanner(System.in); - try { - value = scanner.nextBigInteger(); - } finally { - scanner.close(); - } - } - return value; - } - }; - - public static void setStandardInteractiveModification( - BigIntegerInteractiveModification.InteractiveBigIntegerModification modification) { - standardInteractiveModification = modification; - } - - protected static BigIntegerInteractiveModification.InteractiveBigIntegerModification - getStandardInteractiveModification() { - return standardInteractiveModification; + private BigIntegerModificationFactory() { + super(); } - - public static VariableModification interactive() { - return new BigIntegerInteractiveModification(); - } - - public static synchronized List> modificationsFromFile() { - try { - if (modificationsFromFile == null) { - modificationsFromFile = new LinkedList<>(); - ClassLoader classLoader = ByteArrayModificationFactory.class.getClassLoader(); - InputStream is = - classLoader.getResourceAsStream(IntegerModificationFactory.FILE_NAME); - BufferedReader br = new BufferedReader(new InputStreamReader(is)); - String line; - while ((line = br.readLine()) != null) { - String value = line.trim().split(" ")[0]; - if (!value.equals("")) { - modificationsFromFile.add(explicitValue(value)); - } - } - } - return modificationsFromFile; - } catch (IOException ex) { - throw new FileConfigurationException( - "Modifiable variable file name could not have been found.", ex); - } - } - - public static VariableModification createRandomModification() { - Random random = RandomHelper.getRandom(); - int r = random.nextInt(MODIFICATION_COUNT); - BigInteger modification = BigInteger.valueOf(random.nextInt(MAX_MODIFICATION_VALUE)); - int shiftModification = random.nextInt(MAX_MODIFICATION_SHIFT_VALUE); - VariableModification vm = null; - switch (r) { - case 0: - vm = new BigIntegerAddModification(modification); - return vm; - case 1: - vm = new BigIntegerSubtractModification(modification); - return vm; - case 2: - vm = new BigIntegerXorModification(modification); - return vm; - case 3: - vm = new BigIntegerExplicitValueModification(modification); - return vm; - case 4: - vm = new BigIntegerShiftLeftModification(shiftModification); - return vm; - case 5: - vm = new BigIntegerShiftRightModification(shiftModification); - return vm; - case 6: - vm = explicitValueFromFile(MAX_MODIFICATION_VALUE); - return vm; - default: // unreachable but included for checkstyle - vm = explicitValueFromFile(MAX_MODIFICATION_VALUE); - return vm; - } - } - - private BigIntegerModificationFactory() {} } diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java index 3faeb0c6..f7918b32 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java @@ -8,35 +8,37 @@ package de.rub.nds.modifiablevariable.biginteger; import de.rub.nds.modifiablevariable.VariableModification; -import jakarta.xml.bind.annotation.XmlAccessType; -import jakarta.xml.bind.annotation.XmlAccessorType; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.math.BigInteger; import java.util.Objects; -import java.util.Random; @XmlRootElement -@XmlType(propOrder = {"factor", "modificationFilter"}) -@XmlAccessorType(XmlAccessType.FIELD) public class BigIntegerMultiplyModification extends VariableModification { - private static final int MAX_FACTOR_LENGTH = 8; - private BigInteger factor; - public BigIntegerMultiplyModification() {} + public BigIntegerMultiplyModification() { + super(); + } + + public BigIntegerMultiplyModification(BigInteger factor) { + super(); + this.factor = factor; + } - public BigIntegerMultiplyModification(BigInteger bi) { - this.factor = bi; + public BigIntegerMultiplyModification(BigIntegerMultiplyModification other) { + super(other); + factor = other.factor; + } + + @Override + public BigIntegerMultiplyModification createCopy() { + return new BigIntegerMultiplyModification(this); } @Override protected BigInteger modifyImplementationHook(BigInteger input) { - if (input == null) { - input = BigInteger.ZERO; - } - return input.multiply(factor); + return input == null ? BigInteger.ZERO : input.multiply(factor); } public BigInteger getFactor() { @@ -47,16 +49,10 @@ public void setFactor(BigInteger factor) { this.factor = factor; } - @Override - public VariableModification getModifiedCopy() { - return new BigIntegerMultiplyModification( - factor.add(new BigInteger(MAX_FACTOR_LENGTH, new Random()))); - } - @Override public int hashCode() { - int hash = 5; - hash = 61 * hash + Objects.hashCode(this.factor); + int hash = 7; + hash = 31 * hash + Objects.hashCode(factor); return hash; } @@ -71,10 +67,12 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final BigIntegerMultiplyModification other = (BigIntegerMultiplyModification) obj; - if (!Objects.equals(this.factor, other.factor)) { - return false; - } - return true; + BigIntegerMultiplyModification other = (BigIntegerMultiplyModification) obj; + return Objects.equals(factor, other.factor); + } + + @Override + public String toString() { + return "BigIntegerMultiplyModification{" + "factor=" + factor + '}'; } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftLeftModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftLeftModification.java index f07cddd7..21695d78 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftLeftModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftLeftModification.java @@ -8,28 +8,33 @@ package de.rub.nds.modifiablevariable.biginteger; import de.rub.nds.modifiablevariable.VariableModification; -import jakarta.xml.bind.annotation.XmlAccessType; -import jakarta.xml.bind.annotation.XmlAccessorType; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.math.BigInteger; -import java.util.Random; @XmlRootElement -@XmlType(propOrder = {"shift", "modificationFilter"}) -@XmlAccessorType(XmlAccessType.FIELD) public class BigIntegerShiftLeftModification extends VariableModification { - private static final int MAX_SHIFT_LENGTH = 32; - private int shift; - public BigIntegerShiftLeftModification() {} + public BigIntegerShiftLeftModification() { + super(); + } public BigIntegerShiftLeftModification(int shift) { + super(); this.shift = shift; } + public BigIntegerShiftLeftModification(BigIntegerShiftLeftModification other) { + super(other); + shift = other.shift; + } + + @Override + public BigIntegerShiftLeftModification createCopy() { + return new BigIntegerShiftLeftModification(this); + } + @Override protected BigInteger modifyImplementationHook(BigInteger input) { if (input == null) { @@ -46,15 +51,10 @@ public void setShift(int shift) { this.shift = shift; } - @Override - public VariableModification getModifiedCopy() { - return new BigIntegerShiftLeftModification(shift + new Random().nextInt(MAX_SHIFT_LENGTH)); - } - @Override public int hashCode() { int hash = 7; - hash = 97 * hash + this.shift; + hash = 31 * hash + shift; return hash; } @@ -69,10 +69,12 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final BigIntegerShiftLeftModification other = (BigIntegerShiftLeftModification) obj; - if (this.shift != other.shift) { - return false; - } - return true; + BigIntegerShiftLeftModification other = (BigIntegerShiftLeftModification) obj; + return shift == other.shift; + } + + @Override + public String toString() { + return "BigIntegerShiftLeftModification{" + "shift=" + shift + '}'; } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftRightModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftRightModification.java index 78443aa5..3845d3f8 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftRightModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftRightModification.java @@ -8,28 +8,33 @@ package de.rub.nds.modifiablevariable.biginteger; import de.rub.nds.modifiablevariable.VariableModification; -import jakarta.xml.bind.annotation.XmlAccessType; -import jakarta.xml.bind.annotation.XmlAccessorType; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.math.BigInteger; -import java.util.Random; @XmlRootElement -@XmlType(propOrder = {"shift", "modificationFilter"}) -@XmlAccessorType(XmlAccessType.FIELD) public class BigIntegerShiftRightModification extends VariableModification { - private static final int MAX_SHIFT_LENGTH = 32; - private int shift; - public BigIntegerShiftRightModification() {} + public BigIntegerShiftRightModification() { + super(); + } public BigIntegerShiftRightModification(int shift) { + super(); this.shift = shift; } + public BigIntegerShiftRightModification(BigIntegerShiftRightModification other) { + super(other); + shift = other.shift; + } + + @Override + public BigIntegerShiftRightModification createCopy() { + return new BigIntegerShiftRightModification(this); + } + @Override protected BigInteger modifyImplementationHook(BigInteger input) { if (input == null) { @@ -46,15 +51,10 @@ public void setShift(int shift) { this.shift = shift; } - @Override - public VariableModification getModifiedCopy() { - return new BigIntegerShiftRightModification(shift + new Random().nextInt(MAX_SHIFT_LENGTH)); - } - @Override public int hashCode() { int hash = 7; - hash = 97 * hash + this.shift; + hash = 31 * hash + shift; return hash; } @@ -69,10 +69,12 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final BigIntegerShiftRightModification other = (BigIntegerShiftRightModification) obj; - if (this.shift != other.shift) { - return false; - } - return true; + BigIntegerShiftRightModification other = (BigIntegerShiftRightModification) obj; + return shift == other.shift; + } + + @Override + public String toString() { + return "BigIntegerShiftRightModification{" + "shift=" + shift + '}'; } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModification.java index 11fa6703..356463b8 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModification.java @@ -8,27 +8,32 @@ package de.rub.nds.modifiablevariable.biginteger; import de.rub.nds.modifiablevariable.VariableModification; -import jakarta.xml.bind.annotation.XmlAccessType; -import jakarta.xml.bind.annotation.XmlAccessorType; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.math.BigInteger; import java.util.Objects; -import java.util.Random; @XmlRootElement -@XmlType(propOrder = {"subtrahend", "modificationFilter"}) -@XmlAccessorType(XmlAccessType.FIELD) public class BigIntegerSubtractModification extends VariableModification { - private static final int MAX_SUBTRACT_LENGTH = 8; - private BigInteger subtrahend; - public BigIntegerSubtractModification() {} + public BigIntegerSubtractModification() { + super(); + } + + public BigIntegerSubtractModification(BigInteger subtrahend) { + super(); + this.subtrahend = subtrahend; + } + + public BigIntegerSubtractModification(BigIntegerSubtractModification other) { + super(other); + subtrahend = other.subtrahend; + } - public BigIntegerSubtractModification(BigInteger bi) { - this.subtrahend = bi; + @Override + public BigIntegerSubtractModification createCopy() { + return new BigIntegerSubtractModification(this); } @Override @@ -47,16 +52,10 @@ public void setSubtrahend(BigInteger subtrahend) { this.subtrahend = subtrahend; } - @Override - public VariableModification getModifiedCopy() { - return new BigIntegerSubtractModification( - subtrahend.add(new BigInteger(MAX_SUBTRACT_LENGTH, new Random()))); - } - @Override public int hashCode() { - int hash = 5; - hash = 61 * hash + Objects.hashCode(this.subtrahend); + int hash = 7; + hash = 31 * hash + Objects.hashCode(subtrahend); return hash; } @@ -71,10 +70,12 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final BigIntegerSubtractModification other = (BigIntegerSubtractModification) obj; - if (!Objects.equals(this.subtrahend, other.subtrahend)) { - return false; - } - return true; + BigIntegerSubtractModification other = (BigIntegerSubtractModification) obj; + return Objects.equals(subtrahend, other.subtrahend); + } + + @Override + public String toString() { + return "BigIntegerSubtractModification{" + "subtrahend=" + subtrahend + '}'; } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModification.java index 064f6f85..10d79b3a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModification.java @@ -8,27 +8,32 @@ package de.rub.nds.modifiablevariable.biginteger; import de.rub.nds.modifiablevariable.VariableModification; -import jakarta.xml.bind.annotation.XmlAccessType; -import jakarta.xml.bind.annotation.XmlAccessorType; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.math.BigInteger; import java.util.Objects; -import java.util.Random; @XmlRootElement -@XmlType(propOrder = {"xor", "modificationFilter"}) -@XmlAccessorType(XmlAccessType.FIELD) public class BigIntegerXorModification extends VariableModification { - private static final int MAX_XOR_LENGTH = 8; - private BigInteger xor; - public BigIntegerXorModification() {} + public BigIntegerXorModification() { + super(); + } + + public BigIntegerXorModification(BigInteger xor) { + super(); + this.xor = xor; + } + + public BigIntegerXorModification(BigIntegerXorModification other) { + super(other); + xor = other.xor; + } - public BigIntegerXorModification(BigInteger bi) { - this.xor = bi; + @Override + public BigIntegerXorModification createCopy() { + return new BigIntegerXorModification(this); } @Override @@ -47,15 +52,10 @@ public void setXor(BigInteger xor) { this.xor = xor; } - @Override - public VariableModification getModifiedCopy() { - return new BigIntegerXorModification(xor.add(new BigInteger(MAX_XOR_LENGTH, new Random()))); - } - @Override public int hashCode() { int hash = 7; - hash = 97 * hash + Objects.hashCode(this.xor); + hash = 31 * hash + Objects.hashCode(xor); return hash; } @@ -70,10 +70,12 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final BigIntegerXorModification other = (BigIntegerXorModification) obj; - if (!Objects.equals(this.xor, other.xor)) { - return false; - } - return true; + BigIntegerXorModification other = (BigIntegerXorModification) obj; + return Objects.equals(xor, other.xor); + } + + @Override + public String toString() { + return "BigIntegerXorModification{" + "xor=" + xor + '}'; } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/ModifiableBigInteger.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/ModifiableBigInteger.java index c9ab1e89..1414963b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/ModifiableBigInteger.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/ModifiableBigInteger.java @@ -8,24 +8,32 @@ package de.rub.nds.modifiablevariable.biginteger; import de.rub.nds.modifiablevariable.ModifiableVariable; -import de.rub.nds.modifiablevariable.VariableModification; import de.rub.nds.modifiablevariable.util.ArrayConverter; -import jakarta.xml.bind.annotation.XmlAccessType; -import jakarta.xml.bind.annotation.XmlAccessorType; import jakarta.xml.bind.annotation.XmlRootElement; import java.math.BigInteger; @XmlRootElement -@XmlAccessorType(XmlAccessType.FIELD) public class ModifiableBigInteger extends ModifiableVariable { private BigInteger originalValue; + public ModifiableBigInteger() { + super(); + } + + public ModifiableBigInteger(BigInteger originalValue) { + super(); + this.originalValue = originalValue; + } + + public ModifiableBigInteger(ModifiableBigInteger other) { + super(other); + originalValue = other.originalValue; + } + @Override - protected void createRandomModification() { - VariableModification vm = - BigIntegerModificationFactory.createRandomModification(); - setModification(vm); + public ModifiableBigInteger createCopy() { + return new ModifiableBigInteger(this); } public BigInteger getAssertEquals() { @@ -38,7 +46,7 @@ public void setAssertEquals(BigInteger assertEquals) { @Override public boolean isOriginalValueModified() { - return getOriginalValue() != null && (getOriginalValue().compareTo(getValue()) != 0); + return originalValue != null && originalValue.compareTo(getValue()) != 0; } public byte[] getByteArray() { @@ -52,9 +60,7 @@ public byte[] getByteArray(int size) { @Override public boolean validateAssertions() { if (assertEquals != null) { - if (assertEquals.compareTo(getValue()) != 0) { - return false; - } + return assertEquals.compareTo(getValue()) == 0; } return true; } @@ -71,20 +77,18 @@ public void setOriginalValue(BigInteger originalValue) { @Override public String toString() { - return "ModifiableBigInteger{" + "originalValue=" + originalValue + '}'; + return "ModifiableBigInteger{" + "originalValue=" + originalValue + innerToString() + '}'; } @Override - public boolean equals(Object o) { - if (this == o) { + public boolean equals(Object obj) { + if (this == obj) { return true; } - if (!(o instanceof ModifiableBigInteger)) { + if (!(obj instanceof ModifiableBigInteger that)) { return false; } - ModifiableBigInteger that = (ModifiableBigInteger) o; - return getValue() != null ? getValue().equals(that.getValue()) : that.getValue() == null; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanExplicitValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanExplicitValueModification.java index d253c44e..e753535e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanExplicitValueModification.java @@ -9,22 +9,33 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; @XmlRootElement -@XmlType(propOrder = {"explicitValue", "modificationFilter"}) public class BooleanExplicitValueModification extends VariableModification { private boolean explicitValue; - public BooleanExplicitValueModification() {} + public BooleanExplicitValueModification() { + super(); + } public BooleanExplicitValueModification(boolean explicitValue) { + super(); this.explicitValue = explicitValue; } + public BooleanExplicitValueModification(BooleanExplicitValueModification other) { + super(other); + explicitValue = other.explicitValue; + } + + @Override + public BooleanExplicitValueModification createCopy() { + return new BooleanExplicitValueModification(this); + } + @Override - protected Boolean modifyImplementationHook(final Boolean input) { + protected Boolean modifyImplementationHook(Boolean input) { return explicitValue; } @@ -36,15 +47,10 @@ public void setExplicitValue(boolean explicitValue) { this.explicitValue = explicitValue; } - @Override - public VariableModification getModifiedCopy() { - return new BooleanExplicitValueModification(!explicitValue); - } - @Override public int hashCode() { int hash = 7; - hash = 29 * hash + (this.explicitValue ? 1 : 0); + hash = 31 * hash + (explicitValue ? 1231 : 1237); return hash; } @@ -59,11 +65,8 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final BooleanExplicitValueModification other = (BooleanExplicitValueModification) obj; - if (this.explicitValue != other.explicitValue) { - return false; - } - return true; + BooleanExplicitValueModification other = (BooleanExplicitValueModification) obj; + return explicitValue == other.explicitValue; } @Override diff --git a/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanModificationFactory.java b/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanModificationFactory.java index 0a3c2a9e..f441e47d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanModificationFactory.java @@ -8,32 +8,18 @@ package de.rub.nds.modifiablevariable.bool; import de.rub.nds.modifiablevariable.VariableModification; -import de.rub.nds.modifiablevariable.util.RandomHelper; -import java.util.Random; -public class BooleanModificationFactory { +public final class BooleanModificationFactory { - private static final int MODIFICATION_COUNT = 3; - - public static VariableModification createRandomModification() { - Random random = RandomHelper.getRandom(); - switch (random.nextInt(MODIFICATION_COUNT)) { - case 0: - return new BooleanExplicitValueModification(true); - case 1: - return new BooleanExplicitValueModification(false); - case 2: - return new BooleanToggleModification(); - default: - return null; - } + private BooleanModificationFactory() { + super(); } public static VariableModification toggle() { return new BooleanToggleModification(); } - public static VariableModification explicitValue(final boolean explicitValue) { + public static VariableModification explicitValue(boolean explicitValue) { return new BooleanExplicitValueModification(explicitValue); } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanToggleModification.java b/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanToggleModification.java index aee21384..c6735377 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanToggleModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanToggleModification.java @@ -9,13 +9,22 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; @XmlRootElement -@XmlType(propOrder = {"modificationFilter"}) public class BooleanToggleModification extends VariableModification { - public BooleanToggleModification() {} + public BooleanToggleModification() { + super(); + } + + public BooleanToggleModification(BooleanToggleModification other) { + super(other); + } + + @Override + public BooleanToggleModification createCopy() { + return new BooleanToggleModification(this); + } @Override protected Boolean modifyImplementationHook(Boolean input) { @@ -25,15 +34,9 @@ protected Boolean modifyImplementationHook(Boolean input) { return !input; } - @Override - public VariableModification getModifiedCopy() { - return new BooleanToggleModification(); - } - @Override public int hashCode() { - int hash = 7; - return hash; + return 7; } @Override @@ -44,10 +47,7 @@ public boolean equals(Object obj) { if (obj == null) { return false; } - if (getClass() != obj.getClass()) { - return false; - } - return true; + return getClass() == obj.getClass(); } @Override diff --git a/src/main/java/de/rub/nds/modifiablevariable/bool/ModifiableBoolean.java b/src/main/java/de/rub/nds/modifiablevariable/bool/ModifiableBoolean.java index 9dc3fc21..b695ca89 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bool/ModifiableBoolean.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bool/ModifiableBoolean.java @@ -8,23 +8,32 @@ package de.rub.nds.modifiablevariable.bool; import de.rub.nds.modifiablevariable.ModifiableVariable; -import de.rub.nds.modifiablevariable.VariableModification; -import jakarta.xml.bind.annotation.XmlAccessType; -import jakarta.xml.bind.annotation.XmlAccessorType; import jakarta.xml.bind.annotation.XmlRootElement; @XmlRootElement -@XmlAccessorType(XmlAccessType.FIELD) public class ModifiableBoolean extends ModifiableVariable { private Boolean originalValue; - public ModifiableBoolean() {} + public ModifiableBoolean() { + super(); + } public ModifiableBoolean(Boolean originalValue) { + super(); this.originalValue = originalValue; } + public ModifiableBoolean(ModifiableBoolean other) { + super(other); + originalValue = other.originalValue; + } + + @Override + public ModifiableBoolean createCopy() { + return new ModifiableBoolean(this); + } + @Override public Boolean getOriginalValue() { return originalValue; @@ -35,43 +44,33 @@ public void setOriginalValue(Boolean originalValue) { this.originalValue = originalValue; } - @Override - protected void createRandomModification() { - VariableModification vm = BooleanModificationFactory.createRandomModification(); - setModification(vm); - } - @Override public boolean isOriginalValueModified() { - return getOriginalValue() != null && (getOriginalValue().compareTo(getValue()) != 0); + return originalValue != null && originalValue.compareTo(getValue()) != 0; } @Override public boolean validateAssertions() { if (assertEquals != null) { - if (assertEquals.compareTo(getValue()) != 0) { - return false; - } + return assertEquals.compareTo(getValue()) == 0; } return true; } @Override public String toString() { - return "ModifiableBoolean{" + "originalValue=" + originalValue + '}'; + return "ModifiableBoolean{" + "originalValue=" + originalValue + innerToString() + '}'; } @Override - public boolean equals(Object o) { - if (this == o) { + public boolean equals(Object obj) { + if (this == obj) { return true; } - if (!(o instanceof ModifiableBoolean)) { + if (!(obj instanceof ModifiableBoolean that)) { return false; } - ModifiableBoolean that = (ModifiableBoolean) o; - return getValue() != null ? getValue().equals(that.getValue()) : that.getValue() == null; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java new file mode 100644 index 00000000..627d8e35 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java @@ -0,0 +1,87 @@ +/* + * ModifiableVariable - A Variable Concept for Runtime Modifications + * + * Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH + * + * Licensed under Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 + */ +package de.rub.nds.modifiablevariable.bytearray; + +import de.rub.nds.modifiablevariable.VariableModification; +import de.rub.nds.modifiablevariable.util.ArrayConverter; +import de.rub.nds.modifiablevariable.util.UnformattedByteArrayAdapter; +import jakarta.xml.bind.annotation.XmlRootElement; +import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; +import java.util.Arrays; + +@XmlRootElement +public class ByteArrayAppendValueModification extends VariableModification { + + @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) + private byte[] bytesToAppend; + + public ByteArrayAppendValueModification() { + super(); + } + + public ByteArrayAppendValueModification(byte[] bytesToAppend) { + super(); + this.bytesToAppend = bytesToAppend; + } + + public ByteArrayAppendValueModification(ByteArrayAppendValueModification other) { + super(other); + bytesToAppend = other.bytesToAppend != null ? other.bytesToAppend.clone() : null; + } + + @Override + public ByteArrayAppendValueModification createCopy() { + return new ByteArrayAppendValueModification(this); + } + + @Override + protected byte[] modifyImplementationHook(byte[] input) { + if (input == null) { + input = new byte[0]; + } + + return ArrayConverter.concatenate(input, bytesToAppend); + } + + public byte[] getBytesToAppend() { + return bytesToAppend; + } + + public void setBytesToAppend(byte[] bytesToAppend) { + this.bytesToAppend = bytesToAppend; + } + + @Override + public int hashCode() { + int hash = 7; + hash = 31 * hash + Arrays.hashCode(bytesToAppend); + return hash; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + ByteArrayAppendValueModification other = (ByteArrayAppendValueModification) obj; + return Arrays.equals(bytesToAppend, other.bytesToAppend); + } + + @Override + public String toString() { + return "ByteArrayInsertModification{bytesToAppend=" + + ArrayConverter.bytesToHexString(bytesToAppend) + + "}"; + } +} diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java index c2e96dae..592ef978 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java @@ -7,68 +7,66 @@ */ package de.rub.nds.modifiablevariable.bytearray; -import static de.rub.nds.modifiablevariable.util.ArrayConverter.bytesToHexString; - import de.rub.nds.modifiablevariable.VariableModification; import de.rub.nds.modifiablevariable.util.ArrayConverter; -import jakarta.xml.bind.annotation.XmlAccessType; -import jakarta.xml.bind.annotation.XmlAccessorType; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Arrays; -import java.util.Random; @XmlRootElement -@XmlType(propOrder = {"count", "startPosition", "modificationFilter"}) -@XmlAccessorType(XmlAccessType.FIELD) public class ByteArrayDeleteModification extends VariableModification { - private static final int MAX_MODIFIER_LENGTH = 32; - private int count; private int startPosition; - public ByteArrayDeleteModification() {} + public ByteArrayDeleteModification() { + super(); + } public ByteArrayDeleteModification(int startPosition, int count) { + super(); this.startPosition = startPosition; this.count = count; } + public ByteArrayDeleteModification(ByteArrayDeleteModification other) { + super(other); + count = other.count; + startPosition = other.startPosition; + } + + @Override + public ByteArrayDeleteModification createCopy() { + return new ByteArrayDeleteModification(this); + } + @Override protected byte[] modifyImplementationHook(byte[] input) { if (input == null) { input = new byte[0]; } - int start = startPosition; - if (start < 0) { - start += input.length; - if (start < 0) { - LOGGER.debug( - "Trying to delete from too negative Startposition. start = " - + (start - input.length)); - return input; - } - } - final int endPosition = start + count; - if ((endPosition) > input.length) { - LOGGER.debug( - String.format( - "Bytes %d..%d cannot be deleted from {%s} of length %d", - start, endPosition, bytesToHexString(input), input.length)); + if (input.length == 0) { return input; } - if (count <= 0) { - LOGGER.debug("You must delete at least one byte. count = " + count); - return input; + + // Wrap around and also allow to delete at the end of the original value + int deleteStartPosition = startPosition % input.length; + if (startPosition < 0) { + deleteStartPosition += input.length - 1; } - byte[] ret1 = Arrays.copyOf(input, start); - byte[] ret2 = null; - if ((endPosition) < input.length) { - ret2 = Arrays.copyOfRange(input, endPosition, input.length); + + // If the end position overflows, it is fixed at the end of the byte array + int deleteEndPosition = deleteStartPosition + Math.max(0, count); + if (deleteEndPosition > input.length) { + deleteEndPosition = input.length; + } + + byte[] ret1 = Arrays.copyOf(input, deleteStartPosition); + if (deleteEndPosition < input.length) { + byte[] ret2 = Arrays.copyOfRange(input, deleteEndPosition, input.length); + return ArrayConverter.concatenate(ret1, ret2); } - return ArrayConverter.concatenate(ret1, ret2); + return ret1; } public int getStartPosition() { @@ -87,33 +85,11 @@ public void setCount(int count) { this.count = count; } - @Override - public VariableModification getModifiedCopy() { - Random r = new Random(); - int modifier = r.nextInt(MAX_MODIFIER_LENGTH); - if (r.nextBoolean()) { - modifier *= -1; - } - if (r.nextBoolean()) { - modifier = startPosition + modifier; - if (modifier <= 0) { - modifier = 0; - } - return new ByteArrayDeleteModification(modifier, count); - } else { - modifier = startPosition + count; - if (modifier <= 0) { - modifier = 1; - } - return new ByteArrayDeleteModification(startPosition, modifier); - } - } - @Override public int hashCode() { int hash = 7; - hash = 89 * hash + this.count; - hash = 89 * hash + this.startPosition; + hash = 31 * hash + count; + hash = 31 * hash + startPosition; return hash; } @@ -128,14 +104,11 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final ByteArrayDeleteModification other = (ByteArrayDeleteModification) obj; - if (this.count != other.count) { - return false; - } - if (this.startPosition != other.startPosition) { + ByteArrayDeleteModification other = (ByteArrayDeleteModification) obj; + if (count != other.count) { return false; } - return true; + return startPosition == other.startPosition; } @Override diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDuplicateModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDuplicateModification.java index 697837d2..c8f13fda 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDuplicateModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDuplicateModification.java @@ -9,17 +9,23 @@ import de.rub.nds.modifiablevariable.VariableModification; import de.rub.nds.modifiablevariable.util.ArrayConverter; -import jakarta.xml.bind.annotation.XmlAccessType; -import jakarta.xml.bind.annotation.XmlAccessorType; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; @XmlRootElement -@XmlType(propOrder = {"modificationFilter"}) -@XmlAccessorType(XmlAccessType.FIELD) public class ByteArrayDuplicateModification extends VariableModification { - public ByteArrayDuplicateModification() {} + public ByteArrayDuplicateModification() { + super(); + } + + public ByteArrayDuplicateModification(ByteArrayDuplicateModification other) { + super(other); + } + + @Override + public ByteArrayDuplicateModification createCopy() { + return new ByteArrayDuplicateModification(this); + } @Override protected byte[] modifyImplementationHook(byte[] input) { @@ -29,15 +35,9 @@ protected byte[] modifyImplementationHook(byte[] input) { return ArrayConverter.concatenate(input, input); } - @Override - public VariableModification getModifiedCopy() { - return new ByteArrayDuplicateModification(); - } - @Override public int hashCode() { - int hash = 7; - return hash; + return 7; } @Override @@ -48,10 +48,7 @@ public boolean equals(Object obj) { if (obj == null) { return false; } - if (getClass() != obj.getClass()) { - return false; - } - return true; + return getClass() == obj.getClass(); } @Override diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueModification.java index 85c5d8e5..e1a43b44 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueModification.java @@ -10,32 +10,37 @@ import de.rub.nds.modifiablevariable.VariableModification; import de.rub.nds.modifiablevariable.util.ArrayConverter; import de.rub.nds.modifiablevariable.util.UnformattedByteArrayAdapter; -import jakarta.xml.bind.annotation.XmlAccessType; -import jakarta.xml.bind.annotation.XmlAccessorType; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; import java.util.Arrays; -import java.util.Random; @XmlRootElement -@XmlType(propOrder = {"explicitValue", "modificationFilter"}) -@XmlAccessorType(XmlAccessType.FIELD) public class ByteArrayExplicitValueModification extends VariableModification { - private static final int MAX_EXPLICIT_VALUE = 256; - @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) - private byte[] explicitValue; + protected byte[] explicitValue; - public ByteArrayExplicitValueModification() {} + public ByteArrayExplicitValueModification() { + super(); + } public ByteArrayExplicitValueModification(byte[] explicitValue) { + super(); this.explicitValue = explicitValue; } + public ByteArrayExplicitValueModification(ByteArrayExplicitValueModification other) { + super(other); + explicitValue = other.explicitValue != null ? other.explicitValue.clone() : null; + } + + @Override + public ByteArrayExplicitValueModification createCopy() { + return new ByteArrayExplicitValueModification(this); + } + @Override - protected byte[] modifyImplementationHook(final byte[] input) { + protected byte[] modifyImplementationHook(byte[] input) { return explicitValue.clone(); } @@ -55,22 +60,10 @@ public String toString() { + '}'; } - @Override - public VariableModification getModifiedCopy() { - Random r = new Random(); - if (explicitValue.length == 0) { - return this; - } - int index = r.nextInt(explicitValue.length); - byte[] newValue = Arrays.copyOf(explicitValue, explicitValue.length); - newValue[index] = (byte) r.nextInt(MAX_EXPLICIT_VALUE); - return new ByteArrayExplicitValueModification(newValue); - } - @Override public int hashCode() { - int hash = 5; - hash = 53 * hash + Arrays.hashCode(this.explicitValue); + int hash = 7; + hash = 31 * hash + Arrays.hashCode(explicitValue); return hash; } @@ -85,10 +78,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final ByteArrayExplicitValueModification other = (ByteArrayExplicitValueModification) obj; - if (!Arrays.equals(this.explicitValue, other.explicitValue)) { - return false; - } - return true; + ByteArrayExplicitValueModification other = (ByteArrayExplicitValueModification) obj; + return Arrays.equals(explicitValue, other.explicitValue); } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertModification.java deleted file mode 100644 index 660d6e0c..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertModification.java +++ /dev/null @@ -1,151 +0,0 @@ -/* - * ModifiableVariable - A Variable Concept for Runtime Modifications - * - * Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH - * - * Licensed under Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 - */ -package de.rub.nds.modifiablevariable.bytearray; - -import de.rub.nds.modifiablevariable.VariableModification; -import de.rub.nds.modifiablevariable.util.ArrayConverter; -import de.rub.nds.modifiablevariable.util.UnformattedByteArrayAdapter; -import jakarta.xml.bind.annotation.XmlAccessType; -import jakarta.xml.bind.annotation.XmlAccessorType; -import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; -import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; -import java.util.Arrays; -import java.util.Random; - -@XmlRootElement -@XmlType(propOrder = {"bytesToInsert", "startPosition", "modificationFilter"}) -@XmlAccessorType(XmlAccessType.FIELD) -public class ByteArrayInsertModification extends VariableModification { - - private static final int MAX_EXPLICIT_VALUE = 256; - - private static final int MAX_INSERT_MODIFIER = 32; - - @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) - private byte[] bytesToInsert; - - private int startPosition; - - public ByteArrayInsertModification() {} - - public ByteArrayInsertModification(byte[] bytesToInsert, int startPosition) { - this.bytesToInsert = bytesToInsert; - this.startPosition = startPosition; - } - - @Override - protected byte[] modifyImplementationHook(byte[] input) { - if (input == null) { - input = new byte[0]; - } - - int start = startPosition; - if (start < 0) { - start += input.length; - if (start < 0) { - LOGGER.debug( - "Trying to insert from too negative Startposition. start = " - + startPosition); - return input; - } - } - if (startPosition > input.length) { - LOGGER.debug( - "Trying to insert behind the Array. ArraySize:" - + input.length - + " Insert Position:" - + startPosition); - return input; - } - byte[] ret1 = Arrays.copyOf(input, start); - byte[] ret3 = null; - if ((start) < input.length) { - ret3 = Arrays.copyOfRange(input, start, input.length); - } - return ArrayConverter.concatenate(ret1, bytesToInsert, ret3); - } - - public byte[] getBytesToInsert() { - return bytesToInsert; - } - - public void setBytesToInsert(byte[] bytesToInsert) { - this.bytesToInsert = bytesToInsert; - } - - public int getStartPosition() { - return startPosition; - } - - public void setStartPosition(int startPosition) { - this.startPosition = startPosition; - } - - @Override - public VariableModification getModifiedCopy() { - Random r = new Random(); - - if (r.nextBoolean()) { - int index = r.nextInt(bytesToInsert.length); - byte[] newValue = Arrays.copyOf(bytesToInsert, bytesToInsert.length); - newValue[index] = (byte) r.nextInt(MAX_EXPLICIT_VALUE); - return new ByteArrayInsertModification(newValue, startPosition); - } else { - byte[] newValue = Arrays.copyOf(bytesToInsert, bytesToInsert.length); - int modifier = r.nextInt(MAX_INSERT_MODIFIER); - if (r.nextBoolean()) { - modifier *= -1; - } - modifier = startPosition + modifier; - if (modifier <= 0) { - modifier = 1; - } - return new ByteArrayInsertModification(newValue, modifier); - } - } - - @Override - public int hashCode() { - int hash = 7; - hash = 59 * hash + Arrays.hashCode(this.bytesToInsert); - hash = 59 * hash + this.startPosition; - return hash; - } - - @Override - public boolean equals(Object obj) { - if (this == obj) { - return true; - } - if (obj == null) { - return false; - } - if (getClass() != obj.getClass()) { - return false; - } - final ByteArrayInsertModification other = (ByteArrayInsertModification) obj; - if (this.startPosition != other.startPosition) { - return false; - } - if (!Arrays.equals(this.bytesToInsert, other.bytesToInsert)) { - return false; - } - return true; - } - - @Override - public String toString() { - return "ByteArrayInsertModification{" - + "bytesToInsert=" - + ArrayConverter.bytesToHexString(bytesToInsert) - + ", startPosition=" - + startPosition - + '}'; - } -} diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java new file mode 100644 index 00000000..d07e76cf --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java @@ -0,0 +1,117 @@ +/* + * ModifiableVariable - A Variable Concept for Runtime Modifications + * + * Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH + * + * Licensed under Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 + */ +package de.rub.nds.modifiablevariable.bytearray; + +import de.rub.nds.modifiablevariable.VariableModification; +import de.rub.nds.modifiablevariable.util.ArrayConverter; +import de.rub.nds.modifiablevariable.util.UnformattedByteArrayAdapter; +import jakarta.xml.bind.annotation.XmlRootElement; +import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; +import java.util.Arrays; + +@XmlRootElement +public class ByteArrayInsertValueModification extends VariableModification { + + @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) + private byte[] bytesToInsert; + + private int startPosition; + + public ByteArrayInsertValueModification() { + super(); + } + + public ByteArrayInsertValueModification(byte[] bytesToInsert, int startPosition) { + super(); + this.bytesToInsert = bytesToInsert; + this.startPosition = startPosition; + } + + public ByteArrayInsertValueModification(ByteArrayInsertValueModification other) { + super(other); + bytesToInsert = other.bytesToInsert != null ? other.bytesToInsert.clone() : null; + startPosition = other.startPosition; + } + + @Override + public ByteArrayInsertValueModification createCopy() { + return new ByteArrayInsertValueModification(this); + } + + @Override + protected byte[] modifyImplementationHook(byte[] input) { + if (input == null) { + input = new byte[0]; + } + + // Wrap around and also allow to insert at the end of the original value + int insertPosition = startPosition % (input.length + 1); + if (startPosition < 0) { + insertPosition += input.length; + } + + byte[] ret1 = Arrays.copyOf(input, insertPosition); + if (insertPosition < input.length) { + byte[] ret2 = Arrays.copyOfRange(input, insertPosition, input.length); + return ArrayConverter.concatenate(ret1, bytesToInsert, ret2); + } + return ArrayConverter.concatenate(ret1, bytesToInsert); + } + + public byte[] getBytesToInsert() { + return bytesToInsert; + } + + public void setBytesToInsert(byte[] bytesToInsert) { + this.bytesToInsert = bytesToInsert; + } + + public int getStartPosition() { + return startPosition; + } + + public void setStartPosition(int startPosition) { + this.startPosition = startPosition; + } + + @Override + public int hashCode() { + int hash = 7; + hash = 31 * hash + Arrays.hashCode(bytesToInsert); + hash = 31 * hash + startPosition; + return hash; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + ByteArrayInsertValueModification other = (ByteArrayInsertValueModification) obj; + if (startPosition != other.startPosition) { + return false; + } + return Arrays.equals(bytesToInsert, other.bytesToInsert); + } + + @Override + public String toString() { + return "ByteArrayInsertModification{" + + "bytesToInsert=" + + ArrayConverter.bytesToHexString(bytesToInsert) + + ", startPosition=" + + startPosition + + '}'; + } +} diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayModificationFactory.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayModificationFactory.java index ce26299d..4b9cc732 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayModificationFactory.java @@ -7,65 +7,37 @@ */ package de.rub.nds.modifiablevariable.bytearray; -import de.rub.nds.modifiablevariable.FileConfigurationException; import de.rub.nds.modifiablevariable.VariableModification; -import de.rub.nds.modifiablevariable.util.ArrayConverter; -import de.rub.nds.modifiablevariable.util.RandomHelper; -import java.io.BufferedReader; -import java.io.IOException; -import java.io.InputStream; -import java.io.InputStreamReader; -import java.util.LinkedList; -import java.util.List; -import java.util.Random; -public class ByteArrayModificationFactory { - - private static final int BYTE_ARRAY_SHUFFLE_MODIFICATION = 6; - - private static final int BYTE_ARRAY_EXPLICIT_VALUE_MODIFICATION_FROM_FILE = 5; - - private static final int BYTE_ARRAY_DUPLICATE_MODIFICATION = 4; - - private static final int BYTE_ARRAY_EXPLICIT_VALUE_MODIFICATION = 3; - - private static final int BYTE_ARRAY_DELETE_MODIFICATION = 2; - - private static final int BYTE_ARRAY_INSERT_MODIFICATION = 1; - - private static final int BYTE_ARRAY_XOR_MODIFICATION = 0; - - private static final int MODIFICATION_COUNT = 7; - - private static final int MAX_CONFIG_PARAMETER = 200; - - private static final int EXPLICIT_VALUE_RANDOM = 1000; - - private static final int MODIFIED_ARRAY_LENGTH_ESTIMATION = 50; - - private static List> modificationsFromFile; - - public static final String FILE_NAME = "de/rub/nds/modifiablevariable/explicit/array.vec"; +public final class ByteArrayModificationFactory { /** * @param xor bytes to xor * @param startPosition negative numbers mean that the position is taken from the end * @return variable modification */ - public static VariableModification xor(final byte[] xor, final int startPosition) { + public static VariableModification xor(byte[] xor, int startPosition) { return new ByteArrayXorModification(xor, startPosition); } /** * * * - * @param bytesToInsert bytes to xor + * @param bytesToInsert bytes to insert * @param startPosition negative numbers mean that the position is taken from the end * @return variable modification */ - public static VariableModification insert( - final byte[] bytesToInsert, final int startPosition) { - return new ByteArrayInsertModification(bytesToInsert, startPosition); + public static VariableModification insertValue( + byte[] bytesToInsert, int startPosition) { + return new ByteArrayInsertValueModification(bytesToInsert, startPosition); + } + + public static VariableModification appendValue(byte[] bytesToAppend) { + return new ByteArrayAppendValueModification(bytesToAppend); + } + + public static VariableModification prependValue(byte[] bytesToPrepend) { + return new ByteArrayPrependValueModification(bytesToPrepend); } /** @@ -75,7 +47,7 @@ public static VariableModification insert( * @param count number of bytes to be deleted * @return variable modification */ - public static VariableModification delete(final int startPosition, final int count) { + public static VariableModification delete(int startPosition, int count) { return new ByteArrayDeleteModification(startPosition, count); } @@ -88,112 +60,21 @@ public static VariableModification duplicate() { return new ByteArrayDuplicateModification(); } - public static VariableModification explicitValue(final byte[] explicitValue) { + public static VariableModification explicitValue(byte[] explicitValue) { return new ByteArrayExplicitValueModification(explicitValue); } - public static VariableModification explicitValueFromFile(int value) { - List> modifications = modificationsFromFile(); - int pos = value % modifications.size(); - return modifications.get(pos); - } - /** * Shuffles the bytes in the array, given a specified array of positions. * * @param shuffle positions that define shuffling * @return shuffling variable modification */ - public static VariableModification shuffle(final byte[] shuffle) { + public static VariableModification shuffle(byte[] shuffle) { return new ByteArrayShuffleModification(shuffle); } - public static synchronized List> modificationsFromFile() { - try { - if (modificationsFromFile == null) { - modificationsFromFile = new LinkedList<>(); - ClassLoader classLoader = ByteArrayModificationFactory.class.getClassLoader(); - InputStream is = classLoader.getResourceAsStream(FILE_NAME); - BufferedReader br = new BufferedReader(new InputStreamReader(is)); - String line; - while ((line = br.readLine()) != null) { - line = line.replaceAll("\\s+", ""); - byte[] value = ArrayConverter.hexStringToByteArray(line); - modificationsFromFile.add(explicitValue(value)); - } - } - return modificationsFromFile; - } catch (IOException ex) { - throw new FileConfigurationException( - "Modifiable variable file name could not have been found.", ex); - } + private ByteArrayModificationFactory() { + super(); } - - public static VariableModification createRandomModification(byte[] originalValue) { - Random random = RandomHelper.getRandom(); - int r = random.nextInt(MODIFICATION_COUNT); - VariableModification vm = null; - int modifiedArrayLength; - if (originalValue == null) { - modifiedArrayLength = MODIFIED_ARRAY_LENGTH_ESTIMATION; - } else { - modifiedArrayLength = originalValue.length; - if (originalValue.length == 0 || originalValue.length == 1) { - r = BYTE_ARRAY_EXPLICIT_VALUE_MODIFICATION; - } - } - switch (r) { - case BYTE_ARRAY_XOR_MODIFICATION: - int modificationArrayLength = random.nextInt(modifiedArrayLength); - if (modificationArrayLength == 0) { - modificationArrayLength++; - } - byte[] xor = new byte[modificationArrayLength]; - random.nextBytes(xor); - int startPosition = random.nextInt(modifiedArrayLength - modificationArrayLength); - vm = new ByteArrayXorModification(xor, startPosition); - return vm; - case BYTE_ARRAY_INSERT_MODIFICATION: - modificationArrayLength = random.nextInt(MAX_CONFIG_PARAMETER); - if (modificationArrayLength == 0) { - modificationArrayLength++; - } - byte[] bytesToInsert = new byte[modificationArrayLength]; - random.nextBytes(bytesToInsert); - int insertPosition = random.nextInt(modifiedArrayLength); - vm = new ByteArrayInsertModification(bytesToInsert, insertPosition); - return vm; - case BYTE_ARRAY_DELETE_MODIFICATION: - startPosition = random.nextInt(modifiedArrayLength - 1); - int count = random.nextInt(modifiedArrayLength - startPosition); - count++; - vm = new ByteArrayDeleteModification(startPosition, count); - return vm; - case BYTE_ARRAY_EXPLICIT_VALUE_MODIFICATION: - modificationArrayLength = random.nextInt(MAX_CONFIG_PARAMETER); - if (modificationArrayLength == 0) { - modificationArrayLength++; - } - byte[] explicitValue = new byte[modificationArrayLength]; - random.nextBytes(explicitValue); - vm = new ByteArrayExplicitValueModification(explicitValue); - return vm; - case BYTE_ARRAY_DUPLICATE_MODIFICATION: - vm = new ByteArrayDuplicateModification(); - return vm; - case BYTE_ARRAY_EXPLICIT_VALUE_MODIFICATION_FROM_FILE: - vm = explicitValueFromFile(random.nextInt(EXPLICIT_VALUE_RANDOM)); - return vm; - case BYTE_ARRAY_SHUFFLE_MODIFICATION: - int shuffleSize = random.nextInt(MAX_CONFIG_PARAMETER); - byte[] shuffle = new byte[shuffleSize]; - random.nextBytes(shuffle); - vm = shuffle(shuffle); - return vm; - default: - return vm; - } - } - - private ByteArrayModificationFactory() {} } diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java new file mode 100644 index 00000000..f76d25d3 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java @@ -0,0 +1,87 @@ +/* + * ModifiableVariable - A Variable Concept for Runtime Modifications + * + * Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH + * + * Licensed under Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 + */ +package de.rub.nds.modifiablevariable.bytearray; + +import de.rub.nds.modifiablevariable.VariableModification; +import de.rub.nds.modifiablevariable.util.ArrayConverter; +import de.rub.nds.modifiablevariable.util.UnformattedByteArrayAdapter; +import jakarta.xml.bind.annotation.XmlRootElement; +import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; +import java.util.Arrays; + +@XmlRootElement +public class ByteArrayPrependValueModification extends VariableModification { + + @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) + private byte[] bytesToPrepend; + + public ByteArrayPrependValueModification() { + super(); + } + + public ByteArrayPrependValueModification(byte[] bytesToPrepend) { + super(); + this.bytesToPrepend = bytesToPrepend; + } + + public ByteArrayPrependValueModification(ByteArrayPrependValueModification other) { + super(other); + bytesToPrepend = other.bytesToPrepend != null ? other.bytesToPrepend.clone() : null; + } + + @Override + public ByteArrayPrependValueModification createCopy() { + return new ByteArrayPrependValueModification(this); + } + + @Override + protected byte[] modifyImplementationHook(byte[] input) { + if (input == null) { + input = new byte[0]; + } + + return ArrayConverter.concatenate(bytesToPrepend, input); + } + + public byte[] getBytesToPrepend() { + return bytesToPrepend; + } + + public void setBytesToPrepend(byte[] bytesToPrepend) { + this.bytesToPrepend = bytesToPrepend; + } + + @Override + public int hashCode() { + int hash = 7; + hash = 31 * hash + Arrays.hashCode(bytesToPrepend); + return hash; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + ByteArrayPrependValueModification other = (ByteArrayPrependValueModification) obj; + return Arrays.equals(bytesToPrepend, other.bytesToPrepend); + } + + @Override + public String toString() { + return "ByteArrayPrependValueModification{bytesToPrepend=" + + ArrayConverter.bytesToHexString(bytesToPrepend) + + "}"; + } +} diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayShuffleModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayShuffleModification.java index 379a7354..150e6311 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayShuffleModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayShuffleModification.java @@ -10,42 +10,56 @@ import de.rub.nds.modifiablevariable.VariableModification; import de.rub.nds.modifiablevariable.util.ArrayConverter; import de.rub.nds.modifiablevariable.util.UnformattedByteArrayAdapter; -import jakarta.xml.bind.annotation.XmlAccessType; -import jakarta.xml.bind.annotation.XmlAccessorType; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; import java.util.Arrays; -import java.util.Random; /** * Shuffles the byte array, using a pre-defined array of array pointers (#shuffle). Array pointers * are currently defined as bytes, since we are modifying rather smaller arrays. */ @XmlRootElement -@XmlType(propOrder = {"shuffle", "modificationFilter"}) -@XmlAccessorType(XmlAccessType.FIELD) public class ByteArrayShuffleModification extends VariableModification { - private static final int MAX_MODIFIER_VALUE = 256; - @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) private byte[] shuffle; - public ByteArrayShuffleModification() {} + public ByteArrayShuffleModification() { + super(); + } public ByteArrayShuffleModification(byte[] shuffle) { + super(); this.shuffle = shuffle; } + public ByteArrayShuffleModification(ByteArrayShuffleModification other) { + super(other); + shuffle = other.shuffle != null ? other.shuffle.clone() : null; + } + @Override - protected byte[] modifyImplementationHook(final byte[] input) { + public ByteArrayShuffleModification createCopy() { + return new ByteArrayShuffleModification(this); + } + + @Override + protected byte[] modifyImplementationHook(byte[] input) { if (input == null) { - return input; + return null; } byte[] result = input.clone(); int size = input.length; - if (size != 0) { + if (size > 255) { + for (int i = 0; i < shuffle.length - 3; i += 4) { + // Combine two consecutive bytes to form 16-bit values + int p1 = ((shuffle[i] & 0xff) << 8 | shuffle[i + 1] & 0xff) % size; + int p2 = ((shuffle[i + 2] & 0xff) << 8 | shuffle[i + 3] & 0xff) % size; + byte tmp = result[p1]; + result[p1] = result[p2]; + result[p2] = tmp; + } + } else if (size > 0) { for (int i = 0; i < shuffle.length - 1; i += 2) { int p1 = (shuffle[i] & 0xff) % size; int p2 = (shuffle[i + 1] & 0xff) % size; @@ -65,19 +79,10 @@ public void setShuffle(byte[] shuffle) { this.shuffle = shuffle; } - @Override - public VariableModification getModifiedCopy() { - Random r = new Random(); - int index = r.nextInt(shuffle.length); - byte[] newValue = Arrays.copyOf(shuffle, shuffle.length); - newValue[index] = (byte) r.nextInt(MAX_MODIFIER_VALUE); - return new ByteArrayShuffleModification(shuffle); - } - @Override public int hashCode() { - int hash = 5; - hash = 71 * hash + Arrays.hashCode(this.shuffle); + int hash = 7; + hash = 31 * hash + Arrays.hashCode(shuffle); return hash; } @@ -92,11 +97,8 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final ByteArrayShuffleModification other = (ByteArrayShuffleModification) obj; - if (!Arrays.equals(this.shuffle, other.shuffle)) { - return false; - } - return true; + ByteArrayShuffleModification other = (ByteArrayShuffleModification) obj; + return Arrays.equals(shuffle, other.shuffle); } @Override diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayXorModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayXorModification.java index 9845db53..ff63f644 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayXorModification.java @@ -10,60 +10,64 @@ import de.rub.nds.modifiablevariable.VariableModification; import de.rub.nds.modifiablevariable.util.ArrayConverter; import de.rub.nds.modifiablevariable.util.UnformattedByteArrayAdapter; -import jakarta.xml.bind.annotation.XmlAccessType; -import jakarta.xml.bind.annotation.XmlAccessorType; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; import java.util.Arrays; -import java.util.Random; @XmlRootElement -@XmlType(propOrder = {"xor", "startPosition", "modificationFilter"}) -@XmlAccessorType(XmlAccessType.FIELD) public class ByteArrayXorModification extends VariableModification { - private static final int MAX_MODIFIER_VALUE = 256; - - private static final int MAX_XOR_MODIFIER = 32; - @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) private byte[] xor; private int startPosition; - public ByteArrayXorModification() {} + public ByteArrayXorModification() { + super(); + } public ByteArrayXorModification(byte[] xor, int startPosition) { + super(); this.xor = xor; this.startPosition = startPosition; } + public ByteArrayXorModification(ByteArrayXorModification other) { + super(other); + xor = other.xor != null ? other.xor.clone() : null; + startPosition = other.startPosition; + } + + @Override + public ByteArrayXorModification createCopy() { + return new ByteArrayXorModification(this); + } + @Override protected byte[] modifyImplementationHook(byte[] input) { if (input == null) { input = new byte[0]; } + if (input.length == 0) { + return input; + } byte[] result = input.clone(); - int start = startPosition; - if (start < 0) { - start += input.length; + + // Wrap around and also allow to xor at the end of the original value + int xorPosition = startPosition % input.length; + if (startPosition < 0) { + xorPosition += input.length - 1; } - final int end = start + xor.length; - if (end > result.length) { - // result = new byte[end]; - // System.arraycopy(input, 0, result, 0, input.length); - LOGGER.debug( - "Input {{}} of length {} cannot be xor-ed with {{}} of length {} with start position {}", - input, - input.length, - xor, - xor.length, - startPosition); - return input; + int endPosition = xorPosition + xor.length; + if (endPosition > result.length) { + // Fix the end position to the length of the original value + // This may not match the expected behavior of a user + // But for fuzzing purpose, that's fine + endPosition = result.length; } - for (int i = 0; i < xor.length; ++i) { - result[start + i] = (byte) (input[start + i] ^ xor[i]); + + for (int i = 0; i < endPosition - xorPosition; ++i) { + result[xorPosition + i] = (byte) (input[xorPosition + i] ^ xor[i]); } return result; } @@ -84,33 +88,11 @@ public void setStartPosition(int startPosition) { this.startPosition = startPosition; } - @Override - public VariableModification getModifiedCopy() { - Random r = new Random(); - if (r.nextBoolean()) { - int index = r.nextInt(xor.length); - byte[] newValue = Arrays.copyOf(xor, xor.length); - newValue[index] = (byte) r.nextInt(MAX_MODIFIER_VALUE); - return new ByteArrayXorModification(newValue, startPosition); - } else { - byte[] newValue = Arrays.copyOf(xor, xor.length); - int modifier = r.nextInt(MAX_XOR_MODIFIER); - if (r.nextBoolean()) { - modifier *= -1; - } - modifier = startPosition + modifier; - if (modifier <= 0) { - modifier = 1; - } - return new ByteArrayXorModification(newValue, modifier); - } - } - @Override public int hashCode() { int hash = 7; - hash = 97 * hash + Arrays.hashCode(this.xor); - hash = 97 * hash + this.startPosition; + hash = 31 * hash + Arrays.hashCode(xor); + hash = 31 * hash + startPosition; return hash; } @@ -125,14 +107,11 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final ByteArrayXorModification other = (ByteArrayXorModification) obj; - if (this.startPosition != other.startPosition) { - return false; - } - if (!Arrays.equals(this.xor, other.xor)) { + ByteArrayXorModification other = (ByteArrayXorModification) obj; + if (startPosition != other.startPosition) { return false; } - return true; + return Arrays.equals(xor, other.xor); } @Override diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArray.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArray.java index a0d46cb4..4f98986a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArray.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArray.java @@ -8,7 +8,6 @@ package de.rub.nds.modifiablevariable.bytearray; import de.rub.nds.modifiablevariable.ModifiableVariable; -import de.rub.nds.modifiablevariable.VariableModification; import de.rub.nds.modifiablevariable.util.ArrayConverter; import de.rub.nds.modifiablevariable.util.UnformattedByteArrayAdapter; import jakarta.xml.bind.annotation.XmlAccessType; @@ -21,15 +20,26 @@ @XmlAccessorType(XmlAccessType.PROPERTY) public class ModifiableByteArray extends ModifiableVariable { - public ModifiableByteArray() {} - private byte[] originalValue; + public ModifiableByteArray() { + super(); + } + + public ModifiableByteArray(byte[] originalValue) { + super(); + this.originalValue = originalValue; + } + + public ModifiableByteArray(ModifiableByteArray other) { + super(other); + originalValue = other.originalValue != null ? other.originalValue.clone() : null; + assertEquals = other.assertEquals != null ? other.assertEquals.clone() : null; + } + @Override - protected void createRandomModification() { - VariableModification vm = - ByteArrayModificationFactory.createRandomModification(originalValue); - setModification(vm); + public ModifiableByteArray createCopy() { + return new ModifiableByteArray(this); } @Override @@ -69,31 +79,14 @@ public boolean validateAssertions() { } @Override - public String toString() { - StringBuilder result = new StringBuilder(); - if (this.isOriginalValueModified()) { - result.append("Actual byte value is: "); - result.append(ArrayConverter.bytesToHexString(this)); - result.append("\nOriginal value was: "); - result.append(ArrayConverter.bytesToHexString(this.getOriginalValue())); - } else { - result.append("Original byte value is: "); - result.append(ArrayConverter.bytesToHexString(this.getOriginalValue())); - } - return result.toString(); - } - - @Override - public boolean equals(Object o) { - if (this == o) { + public boolean equals(Object obj) { + if (this == obj) { return true; } - if (!(o instanceof ModifiableByteArray)) { + if (!(obj instanceof ModifiableByteArray that)) { return false; } - ModifiableByteArray that = (ModifiableByteArray) o; - return Arrays.equals(getValue(), that.getValue()); } @@ -103,4 +96,13 @@ public int hashCode() { result = 31 * result + Arrays.hashCode(getValue()); return result; } + + @Override + public String toString() { + return "ModifiableByteArray{" + + "originalValue=" + + ArrayConverter.bytesToHexString(originalValue) + + innerToString() + + '}'; + } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/filter/AccessModificationFilter.java b/src/main/java/de/rub/nds/modifiablevariable/filter/AccessModificationFilter.java deleted file mode 100644 index 02daf06f..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/filter/AccessModificationFilter.java +++ /dev/null @@ -1,63 +0,0 @@ -/* - * ModifiableVariable - A Variable Concept for Runtime Modifications - * - * Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH - * - * Licensed under Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 - */ -package de.rub.nds.modifiablevariable.filter; - -import de.rub.nds.modifiablevariable.ModificationFilter; -import jakarta.xml.bind.annotation.XmlAccessType; -import jakarta.xml.bind.annotation.XmlAccessorType; -import jakarta.xml.bind.annotation.XmlRootElement; - -/** - * Filters modification executions for specific accesses, starting with 1. - * - *

For example, if one defines accessNumbers = {1,3} and executes four times getValue() function - * on a modifiable variable, the modification is executed only during the second and fourth - * getValue() method invocation. - */ -@XmlRootElement -@XmlAccessorType(XmlAccessType.FIELD) -public class AccessModificationFilter extends ModificationFilter { - - private int accessCounter; - - /** accesses when the modification will be filtered (will not be executed) */ - private int[] accessNumbers; - - public AccessModificationFilter() { - accessCounter = 1; - } - - public AccessModificationFilter(final int[] accessNumbers) { - accessCounter = 1; - this.accessNumbers = accessNumbers; - } - - @Override - public boolean filterModification() { - boolean filter = contains(accessNumbers, accessCounter); - accessCounter++; - return filter; - } - - private boolean contains(int[] numbers, int number) { - for (int i : numbers) { - if (i == number) { - return true; - } - } - return false; - } - - public int[] getAccessNumbers() { - return accessNumbers; - } - - public void setAccessNumbers(int[] accessNumbers) { - this.accessNumbers = accessNumbers; - } -} diff --git a/src/main/java/de/rub/nds/modifiablevariable/filter/ModificationFilterFactory.java b/src/main/java/de/rub/nds/modifiablevariable/filter/ModificationFilterFactory.java deleted file mode 100644 index db70b67f..00000000 --- a/src/main/java/de/rub/nds/modifiablevariable/filter/ModificationFilterFactory.java +++ /dev/null @@ -1,17 +0,0 @@ -/* - * ModifiableVariable - A Variable Concept for Runtime Modifications - * - * Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH - * - * Licensed under Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 - */ -package de.rub.nds.modifiablevariable.filter; - -public class ModificationFilterFactory { - - public static AccessModificationFilter access(final int[] accessNumbers) { - return new AccessModificationFilter(accessNumbers); - } - - private ModificationFilterFactory() {} -} diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAddModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAddModification.java index eb466c99..b49e1269 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAddModification.java @@ -9,27 +9,35 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; -import java.util.Random; @XmlRootElement -@XmlType(propOrder = {"summand", "modificationFilter"}) public class IntegerAddModification extends VariableModification { - private static final int MAX_ADD_MODIFIER = 256; - private Integer summand; - public IntegerAddModification() {} + public IntegerAddModification() { + super(); + } + + public IntegerAddModification(Integer summand) { + super(); + this.summand = summand; + } + + public IntegerAddModification(IntegerAddModification other) { + super(other); + summand = other.summand; + } - public IntegerAddModification(Integer bi) { - this.summand = bi; + @Override + public IntegerAddModification createCopy() { + return new IntegerAddModification(this); } @Override protected Integer modifyImplementationHook(Integer input) { - return (input == null) ? summand : input + summand; + return input == null ? summand : input + summand; } public Integer getSummand() { @@ -40,15 +48,10 @@ public void setSummand(Integer summand) { this.summand = summand; } - @Override - public VariableModification getModifiedCopy() { - return new IntegerAddModification(summand + new Random().nextInt(MAX_ADD_MODIFIER)); - } - @Override public int hashCode() { - int hash = 3; - hash = 23 * hash + Objects.hashCode(this.summand); + int hash = 7; + hash = 31 * hash + summand; return hash; } @@ -63,10 +66,12 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final IntegerAddModification other = (IntegerAddModification) obj; - if (!Objects.equals(this.summand, other.summand)) { - return false; - } - return true; + IntegerAddModification other = (IntegerAddModification) obj; + return Objects.equals(summand, other.summand); + } + + @Override + public String toString() { + return "IntegerAddModification{" + "summand=" + summand + '}'; } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueModification.java index 5b5e4db7..412df62d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueModification.java @@ -9,26 +9,34 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; -import java.util.Random; @XmlRootElement -@XmlType(propOrder = {"explicitValue", "modificationFilter"}) public class IntegerExplicitValueModification extends VariableModification { - private static final int MAX_VALUE_MODIFIER = 256; + protected Integer explicitValue; - private Integer explicitValue; + public IntegerExplicitValueModification() { + super(); + } + + public IntegerExplicitValueModification(Integer explicitValue) { + super(); + this.explicitValue = explicitValue; + } - public IntegerExplicitValueModification() {} + public IntegerExplicitValueModification(IntegerExplicitValueModification other) { + super(other); + explicitValue = other.explicitValue; + } - public IntegerExplicitValueModification(Integer bi) { - this.explicitValue = bi; + @Override + public IntegerExplicitValueModification createCopy() { + return new IntegerExplicitValueModification(this); } @Override - protected Integer modifyImplementationHook(final Integer input) { + protected Integer modifyImplementationHook(Integer input) { return explicitValue; } @@ -40,22 +48,10 @@ public void setExplicitValue(Integer explicitValue) { this.explicitValue = explicitValue; } - @Override - public VariableModification getModifiedCopy() { - Random r = new Random(); - if (r.nextBoolean()) { - return new IntegerExplicitValueModification( - explicitValue + r.nextInt(MAX_VALUE_MODIFIER)); - } else { - return new IntegerExplicitValueModification( - explicitValue - r.nextInt(MAX_VALUE_MODIFIER)); - } - } - @Override public int hashCode() { int hash = 7; - hash = 53 * hash + Objects.hashCode(this.explicitValue); + hash = 31 * hash + explicitValue; return hash; } @@ -70,10 +66,12 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final IntegerExplicitValueModification other = (IntegerExplicitValueModification) obj; - if (!Objects.equals(this.explicitValue, other.explicitValue)) { - return false; - } - return true; + IntegerExplicitValueModification other = (IntegerExplicitValueModification) obj; + return Objects.equals(explicitValue, other.explicitValue); + } + + @Override + public String toString() { + return "IntegerExplicitValueModification{" + "explicitValue=" + explicitValue + '}'; } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerModificationFactory.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerModificationFactory.java index 824f9f87..1a981b48 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerModificationFactory.java @@ -7,135 +7,67 @@ */ package de.rub.nds.modifiablevariable.integer; -import de.rub.nds.modifiablevariable.FileConfigurationException; import de.rub.nds.modifiablevariable.VariableModification; -import de.rub.nds.modifiablevariable.util.RandomHelper; -import java.io.BufferedReader; -import java.io.IOException; -import java.io.InputStream; -import java.io.InputStreamReader; -import java.util.LinkedList; -import java.util.List; -import java.util.Random; -public class IntegerModificationFactory { +public final class IntegerModificationFactory { - private static final int MODIFICATION_COUNT = 7; - - private static final int MAX_MODIFICATION_VALUE = 32000; - - private static final int MAX_MODIFICATION_SHIFT_VALUE = 20; - - private static List> modificationsFromFile; - - public static final String FILE_NAME = "de/rub/nds/modifiablevariable/explicit/integer.vec"; - - public static IntegerAddModification add(final String summand) { + public static IntegerAddModification add(String summand) { return add(Integer.parseInt(summand)); } - public static IntegerAddModification add(final Integer summand) { + public static IntegerAddModification add(Integer summand) { return new IntegerAddModification(summand); } - public static IntegerShiftLeftModification shiftLeft(final String shift) { + public static IntegerShiftLeftModification shiftLeft(String shift) { return shiftLeft(Integer.parseInt(shift)); } - public static IntegerShiftLeftModification shiftLeft(final Integer shift) { + public static IntegerShiftLeftModification shiftLeft(Integer shift) { return new IntegerShiftLeftModification(shift); } - public static IntegerShiftRightModification shiftRight(final String shift) { + public static IntegerShiftRightModification shiftRight(String shift) { return shiftRight(Integer.parseInt(shift)); } - public static IntegerShiftRightModification shiftRight(final Integer shift) { + public static IntegerShiftRightModification shiftRight(Integer shift) { return new IntegerShiftRightModification(shift); } - public static VariableModification sub(final String subtrahend) { + public static VariableModification sub(String subtrahend) { return sub(Integer.parseInt(subtrahend)); } - public static VariableModification sub(final Integer subtrahend) { + public static VariableModification sub(Integer subtrahend) { return new IntegerSubtractModification(subtrahend); } - public static VariableModification xor(final String xor) { + public static VariableModification xor(String xor) { return xor(Integer.parseInt(xor)); } - public static VariableModification xor(final Integer xor) { + public static VariableModification xor(Integer xor) { return new IntegerXorModification(xor); } - public static VariableModification explicitValue(final String value) { - return explicitValue(Integer.parseInt(value)); + public static VariableModification swapEndian() { + return new IntegerSwapEndianModification(); } - public static VariableModification explicitValue(final Integer value) { - return new IntegerExplicitValueModification(value); + public static VariableModification explicitValue(String value) { + return explicitValue(Integer.parseInt(value)); } - public static VariableModification explicitValueFromFile(int value) { - List> modifications = modificationsFromFile(); - int pos = value % modifications.size(); - return modifications.get(pos); + public static VariableModification explicitValue(Integer value) { + return new IntegerExplicitValueModification(value); } - public static synchronized List> modificationsFromFile() { - try { - if (modificationsFromFile == null) { - modificationsFromFile = new LinkedList<>(); - ClassLoader classLoader = IntegerModificationFactory.class.getClassLoader(); - InputStream is = classLoader.getResourceAsStream(FILE_NAME); - BufferedReader br = new BufferedReader(new InputStreamReader(is)); - String line; - while ((line = br.readLine()) != null) { - String value = line.trim().split(" ")[0]; - modificationsFromFile.add(explicitValue(value)); - } - } - return modificationsFromFile; - } catch (IOException ex) { - throw new FileConfigurationException( - "Modifiable variable file name could not have been found.", ex); - } + public static VariableModification multiply(Integer value) { + return new IntegerMultiplyModification(value); } - public static VariableModification createRandomModification() { - Random random = RandomHelper.getRandom(); - int r = random.nextInt(MODIFICATION_COUNT); - int modification = random.nextInt(MAX_MODIFICATION_VALUE); - int shiftModification = random.nextInt(MAX_MODIFICATION_SHIFT_VALUE); - VariableModification vm = null; - switch (r) { - case 0: - vm = new IntegerAddModification(modification); - return vm; - case 1: - vm = new IntegerSubtractModification(modification); - return vm; - case 2: - vm = new IntegerXorModification(modification); - return vm; - case 3: - vm = new IntegerExplicitValueModification(modification); - return vm; - case 4: - vm = new IntegerShiftLeftModification(shiftModification); - return vm; - case 5: - vm = new IntegerShiftRightModification(shiftModification); - return vm; - case 6: - vm = explicitValueFromFile(random.nextInt(MAX_MODIFICATION_VALUE)); - return vm; - default: - return vm; - } + private IntegerModificationFactory() { + super(); } - - private IntegerModificationFactory() {} } diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java new file mode 100644 index 00000000..9a853051 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java @@ -0,0 +1,77 @@ +/* + * ModifiableVariable - A Variable Concept for Runtime Modifications + * + * Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH + * + * Licensed under Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 + */ +package de.rub.nds.modifiablevariable.integer; + +import de.rub.nds.modifiablevariable.VariableModification; +import jakarta.xml.bind.annotation.XmlRootElement; +import java.util.Objects; + +@XmlRootElement +public class IntegerMultiplyModification extends VariableModification { + + private Integer factor; + + public IntegerMultiplyModification() { + super(); + } + + public IntegerMultiplyModification(Integer factor) { + super(); + this.factor = factor; + } + + public IntegerMultiplyModification(IntegerMultiplyModification other) { + super(other); + factor = other.factor; + } + + @Override + public IntegerMultiplyModification createCopy() { + return new IntegerMultiplyModification(this); + } + + @Override + protected Integer modifyImplementationHook(Integer input) { + return input == null ? 0 : input * factor; + } + + public Integer getFactor() { + return factor; + } + + public void setFactor(Integer factor) { + this.factor = factor; + } + + @Override + public int hashCode() { + int hash = 7; + hash = 31 * hash + factor; + return hash; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + IntegerMultiplyModification other = (IntegerMultiplyModification) obj; + return Objects.equals(factor, other.factor); + } + + @Override + public String toString() { + return "IntegerMultiplyModification{" + "factor=" + factor + '}'; + } +} diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftLeftModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftLeftModification.java index 3647542c..0da27cb4 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftLeftModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftLeftModification.java @@ -9,26 +9,36 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; -import java.util.Random; @XmlRootElement -@XmlType(propOrder = {"shift", "modificationFilter"}) public class IntegerShiftLeftModification extends VariableModification { private static final int MAX_SHIFT_MODIFIER = 32; private int shift; - public IntegerShiftLeftModification() {} + public IntegerShiftLeftModification() { + super(); + } public IntegerShiftLeftModification(int shift) { + super(); this.shift = shift; } + public IntegerShiftLeftModification(IntegerShiftLeftModification other) { + super(other); + shift = other.shift; + } + + @Override + public IntegerShiftLeftModification createCopy() { + return new IntegerShiftLeftModification(this); + } + @Override protected Integer modifyImplementationHook(Integer input) { - return (input == null) ? 0 : input << shift; + return input == null ? 0 : input << shift % MAX_SHIFT_MODIFIER; } public int getShift() { @@ -39,27 +49,10 @@ public void setShift(int shift) { this.shift = shift; } - @Override - public VariableModification getModifiedCopy() { - Random r = new Random(); - int newShift; - if (r.nextBoolean()) { - newShift = shift + r.nextInt(MAX_SHIFT_MODIFIER); - } else { - newShift = shift - r.nextInt(MAX_SHIFT_MODIFIER); - } - if (newShift < 0) { - newShift = MAX_SHIFT_MODIFIER - 1; - } else if (newShift > MAX_SHIFT_MODIFIER - 1) { - newShift = 0; - } - return new IntegerShiftLeftModification(newShift); - } - @Override public int hashCode() { int hash = 7; - hash = 73 * hash + this.shift; + hash = 31 * hash + shift; return hash; } @@ -74,10 +67,12 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final IntegerShiftLeftModification other = (IntegerShiftLeftModification) obj; - if (this.shift != other.shift) { - return false; - } - return true; + IntegerShiftLeftModification other = (IntegerShiftLeftModification) obj; + return shift == other.shift; + } + + @Override + public String toString() { + return "IntegerShiftLeftModification{" + "shift=" + shift + '}'; } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftRightModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftRightModification.java index f0cfb2e6..f50ccfd7 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftRightModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftRightModification.java @@ -9,26 +9,36 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; -import java.util.Random; @XmlRootElement -@XmlType(propOrder = {"shift", "modificationFilter"}) public class IntegerShiftRightModification extends VariableModification { private static final int MAX_SHIFT_MODIFIER = 32; private int shift; - public IntegerShiftRightModification() {} + public IntegerShiftRightModification() { + super(); + } public IntegerShiftRightModification(int shift) { + super(); this.shift = shift; } + public IntegerShiftRightModification(IntegerShiftRightModification other) { + super(other); + shift = other.shift; + } + + @Override + public IntegerShiftRightModification createCopy() { + return new IntegerShiftRightModification(this); + } + @Override - protected Integer modifyImplementationHook(final Integer input) { - return (input == null) ? 0 : input >> shift; + protected Integer modifyImplementationHook(Integer input) { + return input == null ? 0 : input >> shift % MAX_SHIFT_MODIFIER; } public int getShift() { @@ -39,27 +49,10 @@ public void setShift(int shift) { this.shift = shift; } - @Override - public VariableModification getModifiedCopy() { - Random r = new Random(); - int newShift; - if (r.nextBoolean()) { - newShift = shift + r.nextInt(MAX_SHIFT_MODIFIER); - } else { - newShift = shift - r.nextInt(MAX_SHIFT_MODIFIER); - } - if (newShift < 0) { - newShift = MAX_SHIFT_MODIFIER - 1; - } else if (newShift > MAX_SHIFT_MODIFIER - 1) { - newShift = 0; - } - return new IntegerShiftRightModification(newShift); - } - @Override public int hashCode() { - int hash = 5; - hash = 59 * hash + this.shift; + int hash = 7; + hash = 31 * hash + shift; return hash; } @@ -74,10 +67,12 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final IntegerShiftRightModification other = (IntegerShiftRightModification) obj; - if (this.shift != other.shift) { - return false; - } - return true; + IntegerShiftRightModification other = (IntegerShiftRightModification) obj; + return shift == other.shift; + } + + @Override + public String toString() { + return "IntegerShiftRightModification{" + "shift=" + shift + '}'; } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSubtractModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSubtractModification.java index 12c43435..12362f9f 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSubtractModification.java @@ -9,27 +9,35 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; -import java.util.Random; @XmlRootElement -@XmlType(propOrder = {"subtrahend", "modificationFilter"}) public class IntegerSubtractModification extends VariableModification { - private static final int MAX_SUBTRACT_MODIFIER = 256; - private Integer subtrahend; - public IntegerSubtractModification() {} + public IntegerSubtractModification() { + super(); + } + + public IntegerSubtractModification(Integer subtrahend) { + super(); + this.subtrahend = subtrahend; + } + + public IntegerSubtractModification(IntegerSubtractModification other) { + super(other); + subtrahend = other.subtrahend; + } - public IntegerSubtractModification(Integer bi) { - this.subtrahend = bi; + @Override + public IntegerSubtractModification createCopy() { + return new IntegerSubtractModification(this); } @Override - protected Integer modifyImplementationHook(final Integer input) { - return (input == null) ? -subtrahend : input - subtrahend; + protected Integer modifyImplementationHook(Integer input) { + return input == null ? -subtrahend : input - subtrahend; } public Integer getSubtrahend() { @@ -40,16 +48,10 @@ public void setSubtrahend(Integer subtrahend) { this.subtrahend = subtrahend; } - @Override - public VariableModification getModifiedCopy() { - return new IntegerSubtractModification( - subtrahend + new Random().nextInt(MAX_SUBTRACT_MODIFIER)); - } - @Override public int hashCode() { int hash = 7; - hash = 23 * hash + Objects.hashCode(this.subtrahend); + hash = 31 * hash + subtrahend; return hash; } @@ -64,10 +66,12 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final IntegerSubtractModification other = (IntegerSubtractModification) obj; - if (!Objects.equals(this.subtrahend, other.subtrahend)) { - return false; - } - return true; + IntegerSubtractModification other = (IntegerSubtractModification) obj; + return Objects.equals(subtrahend, other.subtrahend); + } + + @Override + public String toString() { + return "IntegerSubtractModification{" + "subtrahend=" + subtrahend + '}'; } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSwapEndianModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSwapEndianModification.java new file mode 100644 index 00000000..4a7fcdf7 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSwapEndianModification.java @@ -0,0 +1,57 @@ +/* + * ModifiableVariable - A Variable Concept for Runtime Modifications + * + * Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH + * + * Licensed under Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 + */ +package de.rub.nds.modifiablevariable.integer; + +import de.rub.nds.modifiablevariable.VariableModification; +import jakarta.xml.bind.annotation.XmlRootElement; + +@XmlRootElement +public class IntegerSwapEndianModification extends VariableModification { + + public IntegerSwapEndianModification() { + super(); + } + + public IntegerSwapEndianModification(IntegerSwapEndianModification other) { + super(other); + } + + @Override + public IntegerSwapEndianModification createCopy() { + return new IntegerSwapEndianModification(this); + } + + @Override + protected Integer modifyImplementationHook(Integer input) { + if (input == null) { + return null; + } + return Integer.reverseBytes(input); + } + + @Override + public int hashCode() { + return 7; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + return getClass() == obj.getClass(); + } + + @Override + public String toString() { + return "IntegerSwapEndianModification{" + '}'; + } +} diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerXorModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerXorModification.java index b91a6e1f..ad86f199 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerXorModification.java @@ -9,27 +9,35 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; -import java.util.Random; @XmlRootElement -@XmlType(propOrder = {"xor", "modificationFilter"}) public class IntegerXorModification extends VariableModification { - private static final int MAX_VALUE_MODIFIER = 256; - private Integer xor; - public IntegerXorModification() {} + public IntegerXorModification() { + super(); + } + + public IntegerXorModification(Integer xor) { + super(); + this.xor = xor; + } - public IntegerXorModification(Integer bi) { - this.xor = bi; + public IntegerXorModification(IntegerXorModification other) { + super(other); + xor = other.xor; } @Override - protected Integer modifyImplementationHook(final Integer input) { - return (input == null) ? xor : input ^ xor; + public IntegerXorModification createCopy() { + return new IntegerXorModification(this); + } + + @Override + protected Integer modifyImplementationHook(Integer input) { + return input == null ? xor : input ^ xor; } public Integer getXor() { @@ -40,20 +48,10 @@ public void setXor(Integer xor) { this.xor = xor; } - @Override - public VariableModification getModifiedCopy() { - Random r = new Random(); - if (r.nextBoolean()) { - return new IntegerSubtractModification(xor + new Random().nextInt(MAX_VALUE_MODIFIER)); - } else { - return new IntegerSubtractModification(xor - new Random().nextInt(MAX_VALUE_MODIFIER)); - } - } - @Override public int hashCode() { - int hash = 3; - hash = 97 * hash + Objects.hashCode(this.xor); + int hash = 7; + hash = 31 * hash + xor; return hash; } @@ -68,10 +66,12 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final IntegerXorModification other = (IntegerXorModification) obj; - if (!Objects.equals(this.xor, other.xor)) { - return false; - } - return true; + IntegerXorModification other = (IntegerXorModification) obj; + return Objects.equals(xor, other.xor); + } + + @Override + public String toString() { + return "IntegerXorModification{" + "xor=" + xor + '}'; } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/ModifiableInteger.java b/src/main/java/de/rub/nds/modifiablevariable/integer/ModifiableInteger.java index e3daeb21..0d5e0984 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/ModifiableInteger.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/ModifiableInteger.java @@ -8,22 +8,31 @@ package de.rub.nds.modifiablevariable.integer; import de.rub.nds.modifiablevariable.ModifiableVariable; -import de.rub.nds.modifiablevariable.VariableModification; import de.rub.nds.modifiablevariable.util.ArrayConverter; -import jakarta.xml.bind.annotation.XmlAccessType; -import jakarta.xml.bind.annotation.XmlAccessorType; import jakarta.xml.bind.annotation.XmlRootElement; @XmlRootElement -@XmlAccessorType(XmlAccessType.FIELD) public class ModifiableInteger extends ModifiableVariable { private Integer originalValue; + public ModifiableInteger() { + super(); + } + + public ModifiableInteger(Integer originalValue) { + super(); + this.originalValue = originalValue; + } + + public ModifiableInteger(ModifiableInteger other) { + super(other); + originalValue = other.originalValue; + } + @Override - protected void createRandomModification() { - VariableModification vm = IntegerModificationFactory.createRandomModification(); - setModification(vm); + public ModifiableInteger createCopy() { + return new ModifiableInteger(this); } public Integer getAssertEquals() { @@ -66,20 +75,18 @@ public void setOriginalValue(Integer originalValue) { @Override public String toString() { - return "ModifiableInteger{" + "originalValue=" + originalValue + '}'; + return "ModifiableInteger{" + "originalValue=" + originalValue + innerToString() + '}'; } @Override - public boolean equals(Object o) { - if (this == o) { + public boolean equals(Object obj) { + if (this == obj) { return true; } - if (!(o instanceof ModifiableInteger)) { + if (!(obj instanceof ModifiableInteger that)) { return false; } - ModifiableInteger that = (ModifiableInteger) o; - return getValue() != null ? getValue().equals(that.getValue()) : that.getValue() == null; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/length/ModifiableLengthField.java b/src/main/java/de/rub/nds/modifiablevariable/length/ModifiableLengthField.java index f54b99e4..e77f0796 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/length/ModifiableLengthField.java +++ b/src/main/java/de/rub/nds/modifiablevariable/length/ModifiableLengthField.java @@ -20,9 +20,20 @@ public class ModifiableLengthField extends ModifiableInteger { private final ModifiableByteArray ref; public ModifiableLengthField(ModifiableByteArray ref) { + super(); this.ref = ref; } + public ModifiableLengthField(ModifiableLengthField other) { + super(other); + ref = other.ref; + } + + @Override + public ModifiableLengthField createCopy() { + return new ModifiableLengthField(this); + } + @Override public Integer getOriginalValue() { return ref.getValue().length; @@ -36,20 +47,18 @@ public void setOriginalValue(Integer originalValue) { @Override public String toString() { - return "ModifiableLengthField{" + "ref=" + ref + "} " + super.toString(); + return "ModifiableLengthField{" + "ref=" + ref + super.toString() + "} "; } @Override - public boolean equals(Object o) { - if (this == o) { + public boolean equals(Object obj) { + if (this == obj) { return true; } - if (!(o instanceof ModifiableLengthField)) { + if (!(obj instanceof ModifiableLengthField that)) { return false; } - ModifiableLengthField that = (ModifiableLengthField) o; - return ref != null ? getValue().equals(that.getValue()) : that.getValue() == null; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/logging/ExtendedPatternLayout.java b/src/main/java/de/rub/nds/modifiablevariable/logging/ExtendedPatternLayout.java index 36475e7b..e35a58e9 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/logging/ExtendedPatternLayout.java +++ b/src/main/java/de/rub/nds/modifiablevariable/logging/ExtendedPatternLayout.java @@ -39,7 +39,7 @@ category = "Core", elementType = "layout", printObject = true) -public class ExtendedPatternLayout extends AbstractStringLayout { +public final class ExtendedPatternLayout extends AbstractStringLayout { public static final String DEFAULT_CONVERSION_PATTERN = "%m%n"; public static final String TTCC_CONVERSION_PATTERN = "%r [%t] %p %c %notEmpty{%x }- %m%n"; public static final String SIMPLE_CONVERSION_PATTERN = "%d [%t] %p %c - %m%n"; @@ -80,9 +80,9 @@ private ExtendedPatternLayout( .setNoConsoleNoAnsi(noConsoleNoAnsi) .setPattern(footerPattern) .build()); - this.conversionPattern = eventPattern; + conversionPattern = eventPattern; this.patternSelector = patternSelector; - this.eventSerializer = + eventSerializer = newSerializerBuilder() .setConfiguration(config) .setReplace(replace) @@ -101,8 +101,8 @@ public static ExtendedPatternLayout.SerializerBuilder newSerializerBuilder() { @Override public boolean requiresLocation() { - return this.eventSerializer instanceof LocationAware - && ((LocationAware) this.eventSerializer).requiresLocation(); + return eventSerializer instanceof LocationAware + && ((LocationAware) eventSerializer).requiresLocation(); } /** @@ -129,7 +129,7 @@ public static AbstractStringLayout.Serializer createSerializer( } public String getConversionPattern() { - return this.conversionPattern; + return conversionPattern; } @Override @@ -137,32 +137,32 @@ public Map getContentFormat() { Map result = new HashMap<>(); result.put("structured", "false"); result.put("formatType", "conversion"); - result.put("format", this.conversionPattern); + result.put("format", conversionPattern); return result; } @Override public String toSerializable(LogEvent event) { - return this.eventSerializer.toSerializable(event); + return eventSerializer.toSerializable(event); } public void serialize(LogEvent event, StringBuilder stringBuilder) { - this.eventSerializer.toSerializable(event, stringBuilder); + eventSerializer.toSerializable(event, stringBuilder); } @Override public void encode(LogEvent event, ByteBufferDestination destination) { - if (this.eventSerializer == null) { + if (eventSerializer == null) { super.encode(event, destination); } else { - StringBuilder text = this.toText(this.eventSerializer, event, getStringBuilder()); - Encoder encoder = this.getStringBuilderEncoder(); + StringBuilder text = toText(eventSerializer, event, getStringBuilder()); + Encoder encoder = getStringBuilderEncoder(); encoder.encode(text, destination); trimToMaxSize(text); } } - private StringBuilder toText( + private static StringBuilder toText( AbstractStringLayout.Serializer2 serializer, LogEvent event, StringBuilder destination) { @@ -171,7 +171,7 @@ private StringBuilder toText( public static PatternParser createPatternParser(Configuration config) { if (config == null) { - return new PatternParser(config, "Converter", LogEventPatternConverter.class); + return new PatternParser(null, "Converter", LogEventPatternConverter.class); } else { PatternParser parser = config.getComponent("Converter"); if (parser == null) { @@ -186,9 +186,7 @@ public static PatternParser createPatternParser(Configuration config) { @Override public String toString() { - return this.patternSelector == null - ? this.conversionPattern - : this.patternSelector.toString(); + return patternSelector == null ? conversionPattern : patternSelector.toString(); } /** @@ -234,10 +232,10 @@ public static ExtendedPatternLayout.Builder newBuilder() { } public AbstractStringLayout.Serializer getEventSerializer() { - return this.eventSerializer; + return eventSerializer; } - public static class Builder + public static final class Builder implements org.apache.logging.log4j.core.util.Builder { @PluginBuilderAttribute private String pattern; @@ -263,13 +261,14 @@ public static class Builder private static boolean prettyPrinting; private Builder() { - this.pattern = "%m%n"; - this.charset = Charset.defaultCharset(); - this.alwaysWriteExceptions = true; - this.disableAnsi = !this.useAnsiEscapeCodes(); + super(); + pattern = "%m%n"; + charset = Charset.defaultCharset(); + alwaysWriteExceptions = true; + disableAnsi = !useAnsiEscapeCodes(); } - private boolean useAnsiEscapeCodes() { + private static boolean useAnsiEscapeCodes() { PropertiesUtil propertiesUtil = PropertiesUtil.getProperties(); boolean isPlatformSupportsAnsi = !propertiesUtil.isOsWindows(); boolean isJansiRequested = !propertiesUtil.getBooleanProperty("log4j.skipJansi", true); @@ -333,78 +332,79 @@ public ExtendedPatternLayout.Builder withFooter(String footer) { @Override public ExtendedPatternLayout build() { - if (this.configuration == null) { - this.configuration = new DefaultConfiguration(); + if (configuration == null) { + configuration = new DefaultConfiguration(); } return new ExtendedPatternLayout( - this.configuration, - this.regexReplacement, - this.pattern, - this.patternSelector, - this.charset, - this.alwaysWriteExceptions, - this.disableAnsi, - this.noConsoleNoAnsi, - this.header, - this.footer); + configuration, + regexReplacement, + pattern, + patternSelector, + charset, + alwaysWriteExceptions, + disableAnsi, + noConsoleNoAnsi, + header, + footer); } } - private static class PatternSelectorSerializer + private static final class PatternSelectorSerializer implements AbstractStringLayout.Serializer, LocationAware { private final PatternSelector patternSelector; private final RegexReplacement replace; private PatternSelectorSerializer( PatternSelector patternSelector, RegexReplacement replace) { + super(); this.patternSelector = patternSelector; this.replace = replace; } @Override public String toSerializable(LogEvent event) { - StringBuilder sb = AbstractStringLayout.getStringBuilder(); + StringBuilder sb = getStringBuilder(); String var3; try { - var3 = this.toSerializable(event, sb).toString(); + var3 = toSerializable(event, sb).toString(); } finally { - AbstractStringLayout.trimToMaxSize(sb); + trimToMaxSize(sb); } return var3; } @Override - public StringBuilder toSerializable(LogEvent event, StringBuilder buffer) { - PatternFormatter[] formatters = this.patternSelector.getFormatters(event); - Arrays.stream(formatters).forEachOrdered(formatter -> formatter.format(event, buffer)); - - if (this.replace != null) { - String str = buffer.toString(); - str = this.replace.format(str); - buffer.setLength(0); - buffer.append(str); + public StringBuilder toSerializable(LogEvent event, StringBuilder builder) { + PatternFormatter[] formatters = patternSelector.getFormatters(event); + Arrays.stream(formatters).forEachOrdered(formatter -> formatter.format(event, builder)); + + if (replace != null) { + String str = builder.toString(); + str = replace.format(str); + builder.setLength(0); + builder.append(str); } - return buffer; + return builder; } @Override public boolean requiresLocation() { - return this.patternSelector instanceof LocationAware - && ((LocationAware) this.patternSelector).requiresLocation(); + return patternSelector instanceof LocationAware + && ((LocationAware) patternSelector).requiresLocation(); } @Override public String toString() { return super.toString() - .concat("[patternSelector=") - .concat(this.patternSelector.toString()) - .concat(", replace=") - .concat(this.replace.toString()) - .concat("]"); + + "[patternSelector=" + + patternSelector.toString() + + ", replace=" + + replace.toString() + + "]"; } } @@ -421,28 +421,27 @@ public static class SerializerBuilder @Override public AbstractStringLayout.Serializer build() { - if (Strings.isEmpty(this.pattern) && Strings.isEmpty(this.defaultPattern)) { + if (Strings.isEmpty(pattern) && Strings.isEmpty(defaultPattern)) { return null; - } else if (this.patternSelector == null) { + } else if (patternSelector == null) { try { - PatternParser parser = - ExtendedPatternLayout.createPatternParser(this.configuration); + PatternParser parser = createPatternParser(configuration); List list = parser.parse( - this.pattern == null ? this.defaultPattern : this.pattern, - this.alwaysWriteExceptions, - this.disableAnsi, - this.noConsoleNoAnsi); + pattern == null ? defaultPattern : pattern, + alwaysWriteExceptions, + disableAnsi, + noConsoleNoAnsi); PatternFormatter[] formatters = list.toArray(new PatternFormatter[0]); return new ExtendedPatternLayout.ExtendedPatternLayoutSerializer( - formatters, this.replace); + formatters, replace); } catch (RuntimeException var4) { throw new IllegalArgumentException( - "Cannot parse pattern '" + this.pattern + "'", var4); + "Cannot parse pattern '" + pattern + "'", var4); } } else { return new ExtendedPatternLayout.PatternSelectorSerializer( - this.patternSelector, this.replace); + patternSelector, replace); } } @@ -490,39 +489,40 @@ public ExtendedPatternLayout.SerializerBuilder setNoConsoleNoAnsi(boolean noCons } } - private static class ExtendedPatternLayoutSerializer + private static final class ExtendedPatternLayoutSerializer implements AbstractStringLayout.Serializer, LocationAware { private final PatternFormatter[] formatters; private final RegexReplacement replace; private ExtendedPatternLayoutSerializer( PatternFormatter[] formatters, RegexReplacement replace) { + super(); this.formatters = formatters; this.replace = replace; } @Override public String toSerializable(LogEvent event) { - StringBuilder sb = AbstractStringLayout.getStringBuilder(); + StringBuilder sb = getStringBuilder(); String var3; try { - var3 = this.toSerializable(event, sb).toString(); + var3 = toSerializable(event, sb).toString(); } finally { - AbstractStringLayout.trimToMaxSize(sb); + trimToMaxSize(sb); } return var3; } @Override - public StringBuilder toSerializable(LogEvent event, StringBuilder buffer) { - Arrays.stream(formatters).forEachOrdered(formatter -> formatter.format(event, buffer)); - - if (this.replace != null) { - String str = buffer.toString(); - str = this.replace.format(str); - buffer.setLength(0); - buffer.append(str); + public StringBuilder toSerializable(LogEvent event, StringBuilder builder) { + Arrays.stream(formatters).forEachOrdered(formatter -> formatter.format(event, builder)); + + if (replace != null) { + String str = builder.toString(); + str = replace.format(str); + builder.setLength(0); + builder.append(str); } // Added section to parse ByteArrays to the correct output format. @@ -538,9 +538,9 @@ public StringBuilder toSerializable(LogEvent event, StringBuilder buffer) { // calculated // by the ArrayConverter. if (param != null && bArrayClass.equals(param.getClass())) { - buffer.replace( - buffer.indexOf(Arrays.toString((byte[]) param)), - buffer.indexOf(Arrays.toString((byte[]) param)) + builder.replace( + builder.indexOf(Arrays.toString((byte[]) param)), + builder.indexOf(Arrays.toString((byte[]) param)) + Arrays.toString((byte[]) param).length(), ArrayConverter.bytesToHexString( (byte[]) param, @@ -549,21 +549,21 @@ public StringBuilder toSerializable(LogEvent event, StringBuilder buffer) { } } } - return buffer; + return builder; } public boolean requiresLocation() { - return Arrays.stream(this.formatters).anyMatch(PatternFormatter::requiresLocation); + return Arrays.stream(formatters).anyMatch(PatternFormatter::requiresLocation); } @Override public String toString() { return super.toString() - .concat("[formatters=") - .concat(Arrays.toString(this.formatters)) - .concat(", replace=") - .concat(this.replace.toString()) - .concat("]"); + + "[formatters=" + + Arrays.toString(formatters) + + ", replace=" + + replace.toString() + + "]"; } } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAddModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAddModification.java index 6f89d677..9c7e6278 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAddModification.java @@ -9,27 +9,35 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; -import java.util.Random; @XmlRootElement -@XmlType(propOrder = {"summand", "modificationFilter"}) public class LongAddModification extends VariableModification { - private static final int MAX_ADD_MODIFIER = 32; - private Long summand; - public LongAddModification() {} + public LongAddModification() { + super(); + } + + public LongAddModification(Long summand) { + super(); + this.summand = summand; + } + + public LongAddModification(LongAddModification other) { + super(other); + summand = other.summand; + } - public LongAddModification(Long bi) { - this.summand = bi; + @Override + public LongAddModification createCopy() { + return new LongAddModification(this); } @Override - protected Long modifyImplementationHook(final Long input) { - return (input == null) ? summand : input + summand; + protected Long modifyImplementationHook(Long input) { + return input == null ? summand : input + summand; } public Long getSummand() { @@ -40,15 +48,10 @@ public void setSummand(Long summand) { this.summand = summand; } - @Override - public VariableModification getModifiedCopy() { - return new LongAddModification(summand + new Random().nextInt(MAX_ADD_MODIFIER)); - } - @Override public int hashCode() { int hash = 7; - hash = 43 * hash + Objects.hashCode(this.summand); + hash = 31 * hash + Objects.hashCode(summand); return hash; } @@ -63,10 +66,12 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final LongAddModification other = (LongAddModification) obj; - if (!Objects.equals(this.summand, other.summand)) { - return false; - } - return true; + LongAddModification other = (LongAddModification) obj; + return Objects.equals(summand, other.summand); + } + + @Override + public String toString() { + return "LongAddModification{" + "summand=" + summand + '}'; } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueModification.java index d8136779..9914cd4c 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueModification.java @@ -9,26 +9,34 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; -import java.util.Random; @XmlRootElement -@XmlType(propOrder = {"explicitValue", "modificationFilter"}) public class LongExplicitValueModification extends VariableModification { - private static final int MAX_EXPLICIT_MODIFIER = 256; + protected Long explicitValue; - private Long explicitValue; + public LongExplicitValueModification() { + super(); + } + + public LongExplicitValueModification(Long explicitValue) { + super(); + this.explicitValue = explicitValue; + } - public LongExplicitValueModification() {} + public LongExplicitValueModification(LongExplicitValueModification other) { + super(other); + explicitValue = other.explicitValue; + } - public LongExplicitValueModification(Long bi) { - this.explicitValue = bi; + @Override + public LongExplicitValueModification createCopy() { + return new LongExplicitValueModification(this); } @Override - protected Long modifyImplementationHook(final Long input) { + protected Long modifyImplementationHook(Long input) { return explicitValue; } @@ -40,22 +48,10 @@ public void setExplicitValue(Long explicitValue) { this.explicitValue = explicitValue; } - @Override - public VariableModification getModifiedCopy() { - Random r = new Random(); - if (r.nextBoolean()) { - return new LongExplicitValueModification( - explicitValue + r.nextInt(MAX_EXPLICIT_MODIFIER)); - } else { - return new LongExplicitValueModification( - explicitValue - r.nextInt(MAX_EXPLICIT_MODIFIER)); - } - } - @Override public int hashCode() { - int hash = 3; - hash = 43 * hash + Objects.hashCode(this.explicitValue); + int hash = 7; + hash = 31 * hash + Objects.hashCode(explicitValue); return hash; } @@ -70,10 +66,12 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final LongExplicitValueModification other = (LongExplicitValueModification) obj; - if (!Objects.equals(this.explicitValue, other.explicitValue)) { - return false; - } - return true; + LongExplicitValueModification other = (LongExplicitValueModification) obj; + return Objects.equals(explicitValue, other.explicitValue); + } + + @Override + public String toString() { + return "LongExplicitValueModification{" + "explicitValue=" + explicitValue + '}'; } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongModificationFactory.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongModificationFactory.java index bbfd4f09..e9cfc6e9 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongModificationFactory.java @@ -7,110 +7,59 @@ */ package de.rub.nds.modifiablevariable.longint; -import de.rub.nds.modifiablevariable.FileConfigurationException; import de.rub.nds.modifiablevariable.VariableModification; -import de.rub.nds.modifiablevariable.integer.IntegerModificationFactory; -import de.rub.nds.modifiablevariable.util.RandomHelper; -import java.io.BufferedReader; -import java.io.IOException; -import java.io.InputStream; -import java.io.InputStreamReader; -import java.util.LinkedList; -import java.util.List; -import java.util.Random; -public class LongModificationFactory { +public final class LongModificationFactory { - private static final int MODIFICATION_COUNT = 5; - - private static final int MAX_MODIFICATION_VALUE = 32000; - - private static List> modificationsFromFile; - - public static LongAddModification add(final String summand) { + public static LongAddModification add(String summand) { return add(Long.parseLong(summand)); } - public static LongAddModification add(final Long summand) { + public static LongAddModification add(Long summand) { return new LongAddModification(summand); } - public static VariableModification sub(final String subtrahend) { + public static VariableModification sub(String subtrahend) { return sub(Long.parseLong(subtrahend)); } - public static VariableModification sub(final Long subtrahend) { + public static VariableModification sub(Long subtrahend) { return new LongSubtractModification(subtrahend); } - public static VariableModification xor(final String xor) { + public static VariableModification xor(String xor) { return xor(Long.parseLong(xor)); } - public static VariableModification xor(final Long xor) { + public static VariableModification xor(Long xor) { return new LongXorModification(xor); } - public static VariableModification explicitValue(final String value) { + public static VariableModification swapEndian() { + return new LongSwapEndianModification(); + } + + public static VariableModification explicitValue(String value) { return explicitValue(Long.parseLong(value)); } - public static VariableModification explicitValue(final Long value) { + public static VariableModification explicitValue(Long value) { return new LongExplicitValueModification(value); } - public static VariableModification explicitValueFromFile(int value) { - List> modifications = modificationsFromFile(); - int pos = value % modifications.size(); - return modifications.get(pos); + public static VariableModification multiply(Long factor) { + return new LongMultiplyModification(factor); } - public static synchronized List> modificationsFromFile() { - try { - if (modificationsFromFile == null) { - modificationsFromFile = new LinkedList<>(); - ClassLoader classLoader = IntegerModificationFactory.class.getClassLoader(); - InputStream is = - classLoader.getResourceAsStream(IntegerModificationFactory.FILE_NAME); - BufferedReader br = new BufferedReader(new InputStreamReader(is)); - String line; - while ((line = br.readLine()) != null) { - String value = line.trim().split(" ")[0]; - modificationsFromFile.add(explicitValue(value)); - } - } - return modificationsFromFile; - } catch (IOException ex) { - throw new FileConfigurationException( - "Modifiable variable file name could not have been found.", ex); - } + public static VariableModification shiftLeft(int shift) { + return new LongShiftLeftModification(shift); } - public static VariableModification createRandomModification() { - Random random = RandomHelper.getRandom(); - int r = random.nextInt(MODIFICATION_COUNT); - long modification = random.nextInt(MAX_MODIFICATION_VALUE); - VariableModification vm = null; - switch (r) { - case 0: - vm = new LongAddModification(modification); - return vm; - case 1: - vm = new LongSubtractModification(modification); - return vm; - case 2: - vm = new LongXorModification(modification); - return vm; - case 3: - vm = new LongExplicitValueModification(modification); - return vm; - case 4: - vm = explicitValueFromFile(random.nextInt(MAX_MODIFICATION_VALUE)); - return vm; - default: - return vm; - } + public static VariableModification shiftRight(int shift) { + return new LongShiftRightModification(shift); } - private LongModificationFactory() {} + private LongModificationFactory() { + super(); + } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java new file mode 100644 index 00000000..33a890c1 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java @@ -0,0 +1,77 @@ +/* + * ModifiableVariable - A Variable Concept for Runtime Modifications + * + * Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH + * + * Licensed under Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 + */ +package de.rub.nds.modifiablevariable.longint; + +import de.rub.nds.modifiablevariable.VariableModification; +import jakarta.xml.bind.annotation.XmlRootElement; +import java.util.Objects; + +@XmlRootElement +public class LongMultiplyModification extends VariableModification { + + private Long factor; + + public LongMultiplyModification() { + super(); + } + + public LongMultiplyModification(Long factor) { + super(); + this.factor = factor; + } + + public LongMultiplyModification(LongMultiplyModification other) { + super(other); + factor = other.factor; + } + + @Override + public LongMultiplyModification createCopy() { + return new LongMultiplyModification(this); + } + + @Override + protected Long modifyImplementationHook(Long input) { + return input == null ? 0L : input * factor; + } + + public Long getFactor() { + return factor; + } + + public void setFactor(Long factor) { + this.factor = factor; + } + + @Override + public int hashCode() { + int hash = 7; + hash = 31 * hash + Objects.hashCode(factor); + return hash; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + LongMultiplyModification other = (LongMultiplyModification) obj; + return Objects.equals(factor, other.factor); + } + + @Override + public String toString() { + return "LongMultiplyModification{" + "factor=" + factor + '}'; + } +} diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftLeftModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftLeftModification.java new file mode 100644 index 00000000..359ccf16 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftLeftModification.java @@ -0,0 +1,79 @@ +/* + * ModifiableVariable - A Variable Concept for Runtime Modifications + * + * Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH + * + * Licensed under Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 + */ +package de.rub.nds.modifiablevariable.longint; + +import de.rub.nds.modifiablevariable.VariableModification; +import jakarta.xml.bind.annotation.XmlRootElement; +import java.util.Objects; + +@XmlRootElement +public class LongShiftLeftModification extends VariableModification { + + private static final int MAX_SHIFT_MODIFIER = 64; + + private int shift; + + public LongShiftLeftModification() { + super(); + } + + public LongShiftLeftModification(int shift) { + super(); + this.shift = shift; + } + + public LongShiftLeftModification(LongShiftLeftModification other) { + super(other); + shift = other.shift; + } + + @Override + public LongShiftLeftModification createCopy() { + return new LongShiftLeftModification(this); + } + + @Override + protected Long modifyImplementationHook(Long input) { + return input == null ? 0L : input << shift % MAX_SHIFT_MODIFIER; + } + + public int getShift() { + return shift; + } + + public void setShift(int shift) { + this.shift = shift; + } + + @Override + public int hashCode() { + int hash = 7; + hash = 31 * hash + shift; + return hash; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + LongShiftLeftModification other = (LongShiftLeftModification) obj; + return Objects.equals(shift, other.shift); + } + + @Override + public String toString() { + return "LongShiftLeftModification{" + "shift=" + shift + '}'; + } +} diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftRightModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftRightModification.java new file mode 100644 index 00000000..145d3fb2 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftRightModification.java @@ -0,0 +1,79 @@ +/* + * ModifiableVariable - A Variable Concept for Runtime Modifications + * + * Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH + * + * Licensed under Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 + */ +package de.rub.nds.modifiablevariable.longint; + +import de.rub.nds.modifiablevariable.VariableModification; +import jakarta.xml.bind.annotation.XmlRootElement; +import java.util.Objects; + +@XmlRootElement +public class LongShiftRightModification extends VariableModification { + + private static final int MAX_SHIFT_MODIFIER = 64; + + private int shift; + + public LongShiftRightModification() { + super(); + } + + public LongShiftRightModification(int shift) { + super(); + this.shift = shift; + } + + public LongShiftRightModification(LongShiftRightModification other) { + super(other); + shift = other.shift; + } + + @Override + public LongShiftRightModification createCopy() { + return new LongShiftRightModification(this); + } + + @Override + protected Long modifyImplementationHook(Long input) { + return input == null ? 0L : input >> shift % MAX_SHIFT_MODIFIER; + } + + public int getShift() { + return shift; + } + + public void setShift(int shift) { + this.shift = shift; + } + + @Override + public int hashCode() { + int hash = 7; + hash = 31 * hash + shift; + return hash; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + LongShiftRightModification other = (LongShiftRightModification) obj; + return Objects.equals(shift, other.shift); + } + + @Override + public String toString() { + return "LongShiftRightModification{" + "shift=" + shift + '}'; + } +} diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongSubtractModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongSubtractModification.java index ba2f488d..3493a510 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongSubtractModification.java @@ -9,27 +9,35 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; -import java.util.Random; @XmlRootElement -@XmlType(propOrder = {"subtrahend", "modificationFilter"}) public class LongSubtractModification extends VariableModification { - private static final int MAX_SUBTRACT_MODIFIER = 256; - private Long subtrahend; - public LongSubtractModification() {} + public LongSubtractModification() { + super(); + } + + public LongSubtractModification(Long subtrahend) { + super(); + this.subtrahend = subtrahend; + } + + public LongSubtractModification(LongSubtractModification other) { + super(other); + subtrahend = other.subtrahend; + } - public LongSubtractModification(Long bi) { - this.subtrahend = bi; + @Override + public LongSubtractModification createCopy() { + return new LongSubtractModification(this); } @Override - protected Long modifyImplementationHook(final Long input) { - return (input == null) ? -subtrahend : input - subtrahend; + protected Long modifyImplementationHook(Long input) { + return input == null ? -subtrahend : input - subtrahend; } public Long getSubtrahend() { @@ -40,16 +48,10 @@ public void setSubtrahend(Long subtrahend) { this.subtrahend = subtrahend; } - @Override - public VariableModification getModifiedCopy() { - return new LongSubtractModification( - subtrahend + new Random().nextInt(MAX_SUBTRACT_MODIFIER)); - } - @Override public int hashCode() { int hash = 7; - hash = 97 * hash + Objects.hashCode(this.subtrahend); + hash = 31 * hash + Objects.hashCode(subtrahend); return hash; } @@ -64,10 +66,12 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final LongSubtractModification other = (LongSubtractModification) obj; - if (!Objects.equals(this.subtrahend, other.subtrahend)) { - return false; - } - return true; + LongSubtractModification other = (LongSubtractModification) obj; + return Objects.equals(subtrahend, other.subtrahend); + } + + @Override + public String toString() { + return "LongSubtractModification{" + "subtrahend=" + subtrahend + '}'; } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongSwapEndianModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongSwapEndianModification.java new file mode 100644 index 00000000..ae0050da --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongSwapEndianModification.java @@ -0,0 +1,57 @@ +/* + * ModifiableVariable - A Variable Concept for Runtime Modifications + * + * Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH + * + * Licensed under Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 + */ +package de.rub.nds.modifiablevariable.longint; + +import de.rub.nds.modifiablevariable.VariableModification; +import jakarta.xml.bind.annotation.XmlRootElement; + +@XmlRootElement +public class LongSwapEndianModification extends VariableModification { + + public LongSwapEndianModification() { + super(); + } + + public LongSwapEndianModification(LongSwapEndianModification other) { + super(other); + } + + @Override + public LongSwapEndianModification createCopy() { + return new LongSwapEndianModification(this); + } + + @Override + protected Long modifyImplementationHook(Long input) { + if (input == null) { + return null; + } + return Long.reverseBytes(input); + } + + @Override + public int hashCode() { + return 7; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + return getClass() == obj.getClass(); + } + + @Override + public String toString() { + return "LongSwapEndianModification{" + '}'; + } +} diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongXorModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongXorModification.java index c9755784..9fbe85d5 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongXorModification.java @@ -9,27 +9,35 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; -import java.util.Random; @XmlRootElement -@XmlType(propOrder = {"xor", "modificationFilter"}) public class LongXorModification extends VariableModification { - private static final int MAX_XOR_MODIFIER = 256; - private Long xor; - public LongXorModification() {} + public LongXorModification() { + super(); + } + + public LongXorModification(Long xor) { + super(); + this.xor = xor; + } - public LongXorModification(Long bi) { - this.xor = bi; + public LongXorModification(LongXorModification other) { + super(other); + xor = other.xor; } @Override - protected Long modifyImplementationHook(final Long input) { - return (input == null) ? xor : input ^ xor; + public LongXorModification createCopy() { + return new LongXorModification(this); + } + + @Override + protected Long modifyImplementationHook(Long input) { + return input == null ? xor : input ^ xor; } public Long getXor() { @@ -40,20 +48,10 @@ public void setXor(Long xor) { this.xor = xor; } - @Override - public VariableModification getModifiedCopy() { - Random r = new Random(); - if (r.nextBoolean()) { - return new LongXorModification(xor + new Random().nextInt(MAX_XOR_MODIFIER)); - } else { - return new LongXorModification(xor - new Random().nextInt(MAX_XOR_MODIFIER)); - } - } - @Override public int hashCode() { - int hash = 3; - hash = 59 * hash + Objects.hashCode(this.xor); + int hash = 7; + hash = 31 * hash + Objects.hashCode(xor); return hash; } @@ -68,10 +66,12 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final LongXorModification other = (LongXorModification) obj; - if (!Objects.equals(this.xor, other.xor)) { - return false; - } - return true; + LongXorModification other = (LongXorModification) obj; + return Objects.equals(xor, other.xor); + } + + @Override + public String toString() { + return "LongXorModification{" + "xor=" + xor + '}'; } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/ModifiableLong.java b/src/main/java/de/rub/nds/modifiablevariable/longint/ModifiableLong.java index 5e75ea3f..70c0bd8d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/ModifiableLong.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/ModifiableLong.java @@ -8,22 +8,31 @@ package de.rub.nds.modifiablevariable.longint; import de.rub.nds.modifiablevariable.ModifiableVariable; -import de.rub.nds.modifiablevariable.VariableModification; import de.rub.nds.modifiablevariable.util.ArrayConverter; -import jakarta.xml.bind.annotation.XmlAccessType; -import jakarta.xml.bind.annotation.XmlAccessorType; import jakarta.xml.bind.annotation.XmlRootElement; @XmlRootElement -@XmlAccessorType(XmlAccessType.FIELD) public class ModifiableLong extends ModifiableVariable { private Long originalValue; + public ModifiableLong() { + super(); + } + + public ModifiableLong(Long originalValue) { + super(); + this.originalValue = originalValue; + } + + public ModifiableLong(ModifiableLong other) { + super(other); + originalValue = other.originalValue; + } + @Override - protected void createRandomModification() { - VariableModification vm = LongModificationFactory.createRandomModification(); - setModification(vm); + public ModifiableLong createCopy() { + return new ModifiableLong(this); } public Long getAssertEquals() { @@ -66,20 +75,18 @@ public void setOriginalValue(Long originalValue) { @Override public String toString() { - return "ModifiableLong{" + "originalValue=" + originalValue + '}'; + return "ModifiableLong{" + "originalValue=" + originalValue + innerToString() + '}'; } @Override - public boolean equals(Object o) { - if (this == o) { + public boolean equals(Object obj) { + if (this == obj) { return true; } - if (!(o instanceof ModifiableLong)) { + if (!(obj instanceof ModifiableLong that)) { return false; } - ModifiableLong that = (ModifiableLong) o; - return getValue() != null ? getValue().equals(that.getValue()) : that.getValue() == null; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteAddModification.java b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteAddModification.java index 08d69948..0c2153e1 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteAddModification.java @@ -9,22 +9,30 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; -import java.util.Random; @XmlRootElement -@XmlType(propOrder = {"summand", "modificationFilter"}) public class ByteAddModification extends VariableModification { - private static final int MAX_ADD_MODIFIER = 16; - private Byte summand; - public ByteAddModification() {} + public ByteAddModification() { + super(); + } + + public ByteAddModification(Byte summand) { + super(); + this.summand = summand; + } + + public ByteAddModification(ByteAddModification other) { + super(other); + summand = other.summand; + } - public ByteAddModification(Byte bi) { - this.summand = bi; + @Override + public ByteAddModification createCopy() { + return new ByteAddModification(this); } @Override @@ -43,15 +51,10 @@ public void setSummand(Byte summand) { this.summand = summand; } - @Override - public VariableModification getModifiedCopy() { - return new ByteAddModification((byte) (summand + new Random().nextInt(MAX_ADD_MODIFIER))); - } - @Override public int hashCode() { - int hash = 5; - hash = 17 * hash + Objects.hashCode(this.summand); + int hash = 7; + hash = 31 * hash + summand; return hash; } @@ -66,10 +69,12 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final ByteAddModification other = (ByteAddModification) obj; - if (!Objects.equals(this.summand, other.summand)) { - return false; - } - return true; + ByteAddModification other = (ByteAddModification) obj; + return Objects.equals(summand, other.summand); + } + + @Override + public String toString() { + return "ByteAddModification{" + "summand=" + summand + '}'; } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueModification.java index 4950545d..64f7d5c9 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueModification.java @@ -9,26 +9,34 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; -import java.util.Random; @XmlRootElement -@XmlType(propOrder = {"explicitValue", "modificationFilter"}) public class ByteExplicitValueModification extends VariableModification { - private static final int MAX_EXPLICIT_MODIFIER = 16; + protected Byte explicitValue; - private Byte explicitValue; + public ByteExplicitValueModification() { + super(); + } + + public ByteExplicitValueModification(Byte explicitValue) { + super(); + this.explicitValue = explicitValue; + } - public ByteExplicitValueModification() {} + public ByteExplicitValueModification(ByteExplicitValueModification other) { + super(other); + explicitValue = other.explicitValue; + } - public ByteExplicitValueModification(Byte bi) { - this.explicitValue = bi; + @Override + public ByteExplicitValueModification createCopy() { + return new ByteExplicitValueModification(this); } @Override - protected Byte modifyImplementationHook(final Byte input) { + protected Byte modifyImplementationHook(Byte input) { return explicitValue; } @@ -40,22 +48,10 @@ public void setExplicitValue(Byte explicitValue) { this.explicitValue = explicitValue; } - @Override - public VariableModification getModifiedCopy() { - Random r = new Random(); - if (r.nextBoolean()) { - return new ByteExplicitValueModification( - (byte) (explicitValue + r.nextInt(MAX_EXPLICIT_MODIFIER))); - } else { - return new ByteExplicitValueModification( - (byte) (explicitValue - r.nextInt(MAX_EXPLICIT_MODIFIER))); - } - } - @Override public int hashCode() { int hash = 7; - hash = 79 * hash + Objects.hashCode(this.explicitValue); + hash = 31 * hash + explicitValue; return hash; } @@ -70,10 +66,12 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final ByteExplicitValueModification other = (ByteExplicitValueModification) obj; - if (!Objects.equals(this.explicitValue, other.explicitValue)) { - return false; - } - return true; + ByteExplicitValueModification other = (ByteExplicitValueModification) obj; + return Objects.equals(explicitValue, other.explicitValue); + } + + @Override + public String toString() { + return "ByteExplicitValueModification{" + "explicitValue=" + explicitValue + '}'; } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteModificationFactory.java b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteModificationFactory.java index 7b999e71..1bc2ba1f 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteModificationFactory.java @@ -7,116 +7,43 @@ */ package de.rub.nds.modifiablevariable.singlebyte; -import de.rub.nds.modifiablevariable.FileConfigurationException; import de.rub.nds.modifiablevariable.VariableModification; -import de.rub.nds.modifiablevariable.util.RandomHelper; -import java.io.BufferedReader; -import java.io.IOException; -import java.io.InputStream; -import java.io.InputStreamReader; -import java.util.LinkedList; -import java.util.List; -import java.util.Random; -public class ByteModificationFactory { +public final class ByteModificationFactory { - private static final int BYTE_EXPLICIT_VALUE_MODIFICATION = 3; - - private static final int BYTE_XOR_MODIFICATION = 2; - - private static final int BYTE_SUBTRACT_MODIFICATION = 1; - - private static final int BYTE_ADD_MODIFICATION = 0; - - private static final int MODIFICATION_COUNT = 5; - - private static List> modificationsFromFile; - - public static final String FILE_NAME = "de/rub/nds/modifiablevariable/explicit/byte.vec"; - - public static ByteAddModification add(final String summand) { + public static ByteAddModification add(String summand) { return add(Byte.parseByte(summand)); } - public static ByteAddModification add(final Byte summand) { + public static ByteAddModification add(Byte summand) { return new ByteAddModification(summand); } - public static VariableModification sub(final String subtrahend) { + public static VariableModification sub(String subtrahend) { return sub(Byte.parseByte(subtrahend)); } - public static VariableModification sub(final Byte subtrahend) { + public static VariableModification sub(Byte subtrahend) { return new ByteSubtractModification(subtrahend); } - public static VariableModification xor(final String xor) { + public static VariableModification xor(String xor) { return xor(Byte.parseByte(xor)); } - public static VariableModification xor(final Byte xor) { + public static VariableModification xor(Byte xor) { return new ByteXorModification(xor); } - public static VariableModification explicitValue(final String value) { + public static VariableModification explicitValue(String value) { return explicitValue(Byte.parseByte(value)); } - public static VariableModification explicitValue(final Byte value) { + public static VariableModification explicitValue(Byte value) { return new ByteExplicitValueModification(value); } - public static VariableModification explicitValueFromFile(int value) { - List> modifications = modificationsFromFile(); - int pos = value % modifications.size(); - return modifications.get(pos); - } - - public static synchronized List> modificationsFromFile() { - try { - if (modificationsFromFile == null) { - modificationsFromFile = new LinkedList<>(); - ClassLoader classLoader = ByteModificationFactory.class.getClassLoader(); - InputStream is = classLoader.getResourceAsStream(FILE_NAME); - BufferedReader br = new BufferedReader(new InputStreamReader(is)); - String line; - while ((line = br.readLine()) != null) { - String value = line.trim().split(" ")[0]; - modificationsFromFile.add(explicitValue(value)); - } - } - return modificationsFromFile; - } catch (IOException ex) { - throw new FileConfigurationException( - "Modifiable variable file name could not have been found.", ex); - } + private ByteModificationFactory() { + super(); } - - public static VariableModification createRandomModification() { - Random random = RandomHelper.getRandom(); - int r = random.nextInt(MODIFICATION_COUNT); - byte modification = (byte) random.nextInt(Byte.MAX_VALUE); - VariableModification vm = null; - switch (r) { - case BYTE_ADD_MODIFICATION: - vm = new ByteAddModification(modification); - return vm; - case BYTE_SUBTRACT_MODIFICATION: - vm = new ByteSubtractModification(modification); - return vm; - case BYTE_XOR_MODIFICATION: - vm = new ByteXorModification(modification); - return vm; - case BYTE_EXPLICIT_VALUE_MODIFICATION: - vm = new ByteExplicitValueModification(modification); - return vm; - case 4: - vm = explicitValueFromFile(random.nextInt(Byte.MAX_VALUE)); - return vm; - default: - return vm; - } - } - - private ByteModificationFactory() {} } diff --git a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteSubtractModification.java b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteSubtractModification.java index f5ccdde3..672a7c1d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteSubtractModification.java @@ -9,22 +9,30 @@ import de.rub.nds.modifiablevariable.VariableModification; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import java.util.Objects; -import java.util.Random; @XmlRootElement -@XmlType(propOrder = {"subtrahend", "modificationFilter"}) public class ByteSubtractModification extends VariableModification { - private static final int MAX_SUBTRACT_MODIFIER = 16; - private Byte subtrahend; - public ByteSubtractModification() {} + public ByteSubtractModification() { + super(); + } + + public ByteSubtractModification(Byte subtrahend) { + super(); + this.subtrahend = subtrahend; + } + + public ByteSubtractModification(ByteSubtractModification other) { + super(other); + subtrahend = other.subtrahend; + } - public ByteSubtractModification(Byte bi) { - this.subtrahend = bi; + @Override + public ByteSubtractModification createCopy() { + return new ByteSubtractModification(this); } @Override @@ -43,16 +51,10 @@ public void setSubtrahend(Byte subtrahend) { this.subtrahend = subtrahend; } - @Override - public VariableModification getModifiedCopy() { - return new ByteAddModification( - (byte) (subtrahend + new Random().nextInt(MAX_SUBTRACT_MODIFIER))); - } - @Override public int hashCode() { - int hash = 3; - hash = 71 * hash + Objects.hashCode(this.subtrahend); + int hash = 7; + hash = 31 * hash + subtrahend; return hash; } @@ -67,10 +69,12 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final ByteSubtractModification other = (ByteSubtractModification) obj; - if (!Objects.equals(this.subtrahend, other.subtrahend)) { - return false; - } - return true; + ByteSubtractModification other = (ByteSubtractModification) obj; + return Objects.equals(subtrahend, other.subtrahend); + } + + @Override + public String toString() { + return "ByteSubtractModification{" + "subtrahend=" + subtrahend + '}'; } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteXorModification.java b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteXorModification.java index 4cdce5d3..2954e0bf 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteXorModification.java @@ -8,24 +8,31 @@ package de.rub.nds.modifiablevariable.singlebyte; import de.rub.nds.modifiablevariable.VariableModification; -import jakarta.xml.bind.annotation.XmlAccessType; -import jakarta.xml.bind.annotation.XmlAccessorType; import jakarta.xml.bind.annotation.XmlRootElement; import java.util.Objects; -import java.util.Random; @XmlRootElement -@XmlAccessorType(XmlAccessType.FIELD) public class ByteXorModification extends VariableModification { - private static final int MAX_XOR_MODIFIER = 16; - private Byte xor; - public ByteXorModification() {} + public ByteXorModification() { + super(); + } + + public ByteXorModification(Byte xor) { + super(); + this.xor = xor; + } - public ByteXorModification(Byte bi) { - this.xor = bi; + public ByteXorModification(ByteXorModification other) { + super(other); + xor = other.xor; + } + + @Override + public ByteXorModification createCopy() { + return new ByteXorModification(this); } @Override @@ -44,20 +51,10 @@ public void setXor(Byte xor) { this.xor = xor; } - @Override - public VariableModification getModifiedCopy() { - Random r = new Random(); - if (r.nextBoolean()) { - return new ByteXorModification((byte) (xor + r.nextInt(MAX_XOR_MODIFIER))); - } else { - return new ByteXorModification((byte) (xor - r.nextInt(MAX_XOR_MODIFIER))); - } - } - @Override public int hashCode() { int hash = 7; - hash = 89 * hash + Objects.hashCode(this.xor); + hash = 31 * hash + xor; return hash; } @@ -72,10 +69,12 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final ByteXorModification other = (ByteXorModification) obj; - if (!Objects.equals(this.xor, other.xor)) { - return false; - } - return true; + ByteXorModification other = (ByteXorModification) obj; + return Objects.equals(xor, other.xor); + } + + @Override + public String toString() { + return "ByteXorModification{" + "xor=" + xor + '}'; } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ModifiableByte.java b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ModifiableByte.java index 6e8c79c0..bc8adc22 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ModifiableByte.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ModifiableByte.java @@ -8,21 +8,30 @@ package de.rub.nds.modifiablevariable.singlebyte; import de.rub.nds.modifiablevariable.ModifiableVariable; -import de.rub.nds.modifiablevariable.VariableModification; -import jakarta.xml.bind.annotation.XmlAccessType; -import jakarta.xml.bind.annotation.XmlAccessorType; import jakarta.xml.bind.annotation.XmlRootElement; @XmlRootElement -@XmlAccessorType(XmlAccessType.FIELD) public class ModifiableByte extends ModifiableVariable { private Byte originalValue; + public ModifiableByte() { + super(); + } + + public ModifiableByte(Byte originalValue) { + super(); + this.originalValue = originalValue; + } + + public ModifiableByte(ModifiableByte other) { + super(other); + originalValue = other.originalValue; + } + @Override - protected void createRandomModification() { - VariableModification vm = ByteModificationFactory.createRandomModification(); - setModification(vm); + public ModifiableByte createCopy() { + return new ModifiableByte(this); } public Byte getAssertEquals() { @@ -61,20 +70,18 @@ public void setOriginalValue(Byte originalValue) { @Override public String toString() { - return "ModifiableByte{" + "originalValue=" + originalValue + '}'; + return "ModifiableByte{" + "originalValue=" + originalValue + innerToString() + '}'; } @Override - public boolean equals(Object o) { - if (this == o) { + public boolean equals(Object obj) { + if (this == obj) { return true; } - if (!(o instanceof ModifiableByte)) { + if (!(obj instanceof ModifiableByte that)) { return false; } - ModifiableByte that = (ModifiableByte) o; - return getValue() != null ? getValue().equals(that.getValue()) : that.getValue() == null; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/string/ModifiableString.java b/src/main/java/de/rub/nds/modifiablevariable/string/ModifiableString.java index 88076b21..a373b3c4 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/ModifiableString.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/ModifiableString.java @@ -10,7 +10,6 @@ import static de.rub.nds.modifiablevariable.util.StringUtil.backslashEscapeString; import de.rub.nds.modifiablevariable.ModifiableVariable; -import de.rub.nds.modifiablevariable.VariableModification; import de.rub.nds.modifiablevariable.util.IllegalStringAdapter; import jakarta.xml.bind.annotation.XmlAccessType; import jakarta.xml.bind.annotation.XmlAccessorType; @@ -18,22 +17,32 @@ import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; import java.nio.charset.StandardCharsets; -/** */ @XmlRootElement -@XmlAccessorType(XmlAccessType.FIELD) +@XmlAccessorType(XmlAccessType.PROPERTY) public class ModifiableString extends ModifiableVariable { - @XmlJavaTypeAdapter(IllegalStringAdapter.class) - private String originalValue; + protected String originalValue; + + public ModifiableString() { + super(); + } + + public ModifiableString(String originalValue) { + super(); + this.originalValue = originalValue; + } - public ModifiableString() {} + public ModifiableString(ModifiableString other) { + super(other); + originalValue = other.originalValue; + } @Override - protected void createRandomModification() { - VariableModification vm = StringModificationFactory.createRandomModification(); - setModification(vm); + public ModifiableString createCopy() { + return new ModifiableString(this); } + @XmlJavaTypeAdapter(IllegalStringAdapter.class) public String getAssertEquals() { return assertEquals; } @@ -63,6 +72,7 @@ public boolean validateAssertions() { } @Override + @XmlJavaTypeAdapter(IllegalStringAdapter.class) public String getOriginalValue() { return originalValue; } @@ -74,21 +84,23 @@ public void setOriginalValue(String originalValue) { @Override public String toString() { - return String.format( - "ModifiableString{originalValue=%s}", backslashEscapeString(originalValue)); + return "ModifiableString{" + + "originalValue='" + + backslashEscapeString(originalValue) + + '\'' + + innerToString() + + '}'; } @Override - public boolean equals(Object o) { - if (this == o) { + public boolean equals(Object obj) { + if (this == obj) { return true; } - if (!(o instanceof ModifiableString)) { + if (!(obj instanceof ModifiableString that)) { return false; } - ModifiableString that = (ModifiableString) o; - return getValue() != null ? getValue().equals(that.getValue()) : that.getValue() == null; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/string/StringAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/string/StringAppendValueModification.java index ce8e1eb1..22f6ebee 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringAppendValueModification.java @@ -7,49 +7,57 @@ */ package de.rub.nds.modifiablevariable.string; +import static de.rub.nds.modifiablevariable.util.StringUtil.backslashEscapeString; + import de.rub.nds.modifiablevariable.VariableModification; import de.rub.nds.modifiablevariable.util.IllegalStringAdapter; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; import java.util.Objects; /** Modification that appends a string to the original value. */ @XmlRootElement -@XmlType(propOrder = {"appendValue", "modificationFilter"}) public class StringAppendValueModification extends VariableModification { @XmlJavaTypeAdapter(IllegalStringAdapter.class) private String appendValue; - public StringAppendValueModification() {} + public StringAppendValueModification() { + super(); + } - public StringAppendValueModification(final String appendValue) { + public StringAppendValueModification(String appendValue) { + super(); this.appendValue = appendValue; } + public StringAppendValueModification(StringAppendValueModification other) { + super(other); + appendValue = other.appendValue; + } + @Override - protected String modifyImplementationHook(final String input) { - return input + this.appendValue; + public StringAppendValueModification createCopy() { + return new StringAppendValueModification(this); } - public String getAppendValue() { - return this.appendValue; + @Override + protected String modifyImplementationHook(String input) { + return input != null ? input + appendValue : appendValue; } - public void setAppendValue(final String appendValue) { - this.appendValue = appendValue; + public String getAppendValue() { + return appendValue; } - @Override - public VariableModification getModifiedCopy() { - return new StringAppendValueModification(appendValue); + public void setAppendValue(String appendValue) { + this.appendValue = appendValue; } @Override public int hashCode() { - int hash = 4; - hash = 83 * hash + Objects.hashCode(this.appendValue); + int hash = 7; + hash = 31 * hash + Objects.hashCode(appendValue); return hash; } @@ -64,7 +72,16 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final StringAppendValueModification other = (StringAppendValueModification) obj; - return Objects.equals(this.appendValue, other.getAppendValue()); + StringAppendValueModification other = (StringAppendValueModification) obj; + return Objects.equals(appendValue, other.appendValue); + } + + @Override + public String toString() { + return "StringAppendValueModification{" + + "appendValue='" + + backslashEscapeString(appendValue) + + '\'' + + '}'; } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/string/StringDeleteModification.java b/src/main/java/de/rub/nds/modifiablevariable/string/StringDeleteModification.java new file mode 100644 index 00000000..9ba8ff91 --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringDeleteModification.java @@ -0,0 +1,118 @@ +/* + * ModifiableVariable - A Variable Concept for Runtime Modifications + * + * Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH + * + * Licensed under Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 + */ +package de.rub.nds.modifiablevariable.string; + +import de.rub.nds.modifiablevariable.VariableModification; +import jakarta.xml.bind.annotation.XmlRootElement; +import java.util.Objects; + +/** Modification that deletes part of a string from the original value. */ +@XmlRootElement +public class StringDeleteModification extends VariableModification { + + private int count; + + private int startPosition; + + public StringDeleteModification() { + super(); + } + + public StringDeleteModification(int startPosition, int count) { + super(); + this.startPosition = startPosition; + this.count = count; + } + + public StringDeleteModification(StringDeleteModification other) { + super(other); + count = other.count; + startPosition = other.startPosition; + } + + @Override + public StringDeleteModification createCopy() { + return new StringDeleteModification(this); + } + + @Override + protected String modifyImplementationHook(String input) { + if (input == null) { + return null; + } + if (input.isEmpty()) { + return input; + } + + // Wrap around and also allow to delete at the end of the original value + int deleteStartPosition = startPosition % input.length(); + if (startPosition < 0) { + deleteStartPosition += input.length() - 1; + } + + // If the end position overflows, it is fixed at the end of the string + int deleteEndPosition = deleteStartPosition + Math.max(0, count); + if (deleteEndPosition > input.length()) { + deleteEndPosition = input.length(); + } + + return new StringBuilder(input).delete(deleteStartPosition, deleteEndPosition).toString(); + } + + public int getCount() { + return count; + } + + public void setCount(int count) { + this.count = count; + } + + public int getStartPosition() { + return startPosition; + } + + public void setStartPosition(int startPosition) { + this.startPosition = startPosition; + } + + @Override + public int hashCode() { + int hash = 7; + hash = 31 * hash + count; + hash = 31 * hash + startPosition; + return hash; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + StringDeleteModification other = (StringDeleteModification) obj; + if (startPosition != other.startPosition) { + return false; + } + return Objects.equals(count, other.count); + } + + @Override + public String toString() { + return "StringDeleteModification{" + + "count=" + + count + + ", startPosition=" + + startPosition + + '}'; + } +} diff --git a/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java index c328c811..5c8d4ffb 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java @@ -7,27 +7,39 @@ */ package de.rub.nds.modifiablevariable.string; +import static de.rub.nds.modifiablevariable.util.StringUtil.backslashEscapeString; + import de.rub.nds.modifiablevariable.VariableModification; import de.rub.nds.modifiablevariable.util.IllegalStringAdapter; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; import java.util.Objects; -/** */ @XmlRootElement -@XmlType(propOrder = {"explicitValue", "modificationFilter"}) public class StringExplicitValueModification extends VariableModification { @XmlJavaTypeAdapter(IllegalStringAdapter.class) - private String explicitValue; + protected String explicitValue; - public StringExplicitValueModification() {} + public StringExplicitValueModification() { + super(); + } public StringExplicitValueModification(String explicitValue) { + super(); this.explicitValue = explicitValue; } + public StringExplicitValueModification(StringExplicitValueModification other) { + super(other); + explicitValue = other.explicitValue; + } + + @Override + public StringExplicitValueModification createCopy() { + return new StringExplicitValueModification(this); + } + @Override protected String modifyImplementationHook(String input) { return explicitValue; @@ -41,15 +53,10 @@ public void setExplicitValue(String explicitValue) { this.explicitValue = explicitValue; } - @Override - public VariableModification getModifiedCopy() { - return new StringExplicitValueModification(explicitValue); - } - @Override public int hashCode() { - int hash = 3; - hash = 83 * hash + Objects.hashCode(this.explicitValue); + int hash = 7; + hash = 31 * hash + Objects.hashCode(explicitValue); return hash; } @@ -64,10 +71,16 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final StringExplicitValueModification other = (StringExplicitValueModification) obj; - if (!Objects.equals(this.explicitValue, other.explicitValue)) { - return false; - } - return true; + StringExplicitValueModification other = (StringExplicitValueModification) obj; + return Objects.equals(explicitValue, other.explicitValue); + } + + @Override + public String toString() { + return "StringExplicitValueModification{" + + "explicitValue='" + + backslashEscapeString(explicitValue) + + '\'' + + '}'; } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java new file mode 100644 index 00000000..d58ca3fd --- /dev/null +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringInsertValueModification.java @@ -0,0 +1,114 @@ +/* + * ModifiableVariable - A Variable Concept for Runtime Modifications + * + * Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH + * + * Licensed under Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 + */ +package de.rub.nds.modifiablevariable.string; + +import static de.rub.nds.modifiablevariable.util.StringUtil.backslashEscapeString; + +import de.rub.nds.modifiablevariable.VariableModification; +import de.rub.nds.modifiablevariable.util.IllegalStringAdapter; +import jakarta.xml.bind.annotation.XmlRootElement; +import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; +import java.util.Objects; + +/** Modification that inserts a string to the original value. */ +@XmlRootElement +public class StringInsertValueModification extends VariableModification { + + @XmlJavaTypeAdapter(IllegalStringAdapter.class) + private String insertValue; + + private int startPosition; + + public StringInsertValueModification() { + super(); + } + + public StringInsertValueModification(String insertValue, int startPosition) { + super(); + this.insertValue = insertValue; + this.startPosition = startPosition; + } + + public StringInsertValueModification(StringInsertValueModification other) { + super(other); + insertValue = other.insertValue; + startPosition = other.startPosition; + } + + @Override + public StringInsertValueModification createCopy() { + return new StringInsertValueModification(this); + } + + @Override + protected String modifyImplementationHook(String input) { + if (input == null) { + return null; + } + // Wrap around and also allow to insert at the end of the original value + int insertPosition = startPosition % (input.length() + 1); + if (startPosition < 0) { + insertPosition += input.length(); + } + + return new StringBuilder(input).insert(insertPosition, insertValue).toString(); + } + + public String getInsertValue() { + return insertValue; + } + + public void setInsertValue(String insertValue) { + this.insertValue = insertValue; + } + + public int getStartPosition() { + return startPosition; + } + + public void setStartPosition(int startPosition) { + this.startPosition = startPosition; + } + + @Override + public int hashCode() { + int hash = 7; + hash = 31 * hash + Objects.hashCode(insertValue); + hash = 31 * hash + startPosition; + return hash; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + StringInsertValueModification other = (StringInsertValueModification) obj; + if (startPosition != other.startPosition) { + return false; + } + return Objects.equals(insertValue, other.insertValue); + } + + @Override + public String toString() { + return "StringInsertValueModification{" + + "insertValue='" + + backslashEscapeString(insertValue) + + '\'' + + ", startPosition=" + + startPosition + + '}'; + } +} diff --git a/src/main/java/de/rub/nds/modifiablevariable/string/StringModificationFactory.java b/src/main/java/de/rub/nds/modifiablevariable/string/StringModificationFactory.java index c6c95710..8ccb345a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringModificationFactory.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringModificationFactory.java @@ -8,29 +8,30 @@ package de.rub.nds.modifiablevariable.string; import de.rub.nds.modifiablevariable.VariableModification; -import de.rub.nds.modifiablevariable.util.RandomHelper; -/** */ -public class StringModificationFactory { +public final class StringModificationFactory { - private static final int MAX_BYTE_LENGTH = 1000; + private StringModificationFactory() { + super(); + } - public static VariableModification prependValue(final String value) { + public static VariableModification prependValue(String value) { return new StringPrependValueModification(value); } - public static VariableModification appendValue(final String value) { + public static VariableModification appendValue(String value) { return new StringAppendValueModification(value); } - public static VariableModification explicitValue(final String value) { + public static VariableModification explicitValue(String value) { return new StringExplicitValueModification(value); } - public static VariableModification createRandomModification() { - int i = RandomHelper.getRandom().nextInt(MAX_BYTE_LENGTH); - byte[] randomBytes = new byte[i]; - RandomHelper.getRandom().nextBytes(randomBytes); - return explicitValue(new String(randomBytes)); + public static VariableModification insertValue(String value, int position) { + return new StringInsertValueModification(value, position); + } + + public static VariableModification delete(int startPosition, int count) { + return new StringDeleteModification(startPosition, count); } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/string/StringPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/string/StringPrependValueModification.java index ea4112f5..47441905 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringPrependValueModification.java @@ -7,49 +7,57 @@ */ package de.rub.nds.modifiablevariable.string; +import static de.rub.nds.modifiablevariable.util.StringUtil.backslashEscapeString; + import de.rub.nds.modifiablevariable.VariableModification; import de.rub.nds.modifiablevariable.util.IllegalStringAdapter; import jakarta.xml.bind.annotation.XmlRootElement; -import jakarta.xml.bind.annotation.XmlType; import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter; import java.util.Objects; /** Modification that prepends a string to the original value. */ @XmlRootElement -@XmlType(propOrder = {"prependValue", "modificationFilter"}) public class StringPrependValueModification extends VariableModification { @XmlJavaTypeAdapter(IllegalStringAdapter.class) private String prependValue; - public StringPrependValueModification() {} + public StringPrependValueModification() { + super(); + } - public StringPrependValueModification(final String prependValue) { + public StringPrependValueModification(String prependValue) { + super(); this.prependValue = prependValue; } + public StringPrependValueModification(StringPrependValueModification other) { + super(other); + prependValue = other.prependValue; + } + @Override - protected String modifyImplementationHook(final String input) { - return this.prependValue + input; + public StringPrependValueModification createCopy() { + return new StringPrependValueModification(this); } - public String getPrependValue() { - return this.prependValue; + @Override + protected String modifyImplementationHook(String input) { + return input != null ? prependValue + input : prependValue; } - public void setPrependValue(final String prependValue) { - this.prependValue = prependValue; + public String getPrependValue() { + return prependValue; } - @Override - public VariableModification getModifiedCopy() { - return new StringPrependValueModification(prependValue); + public void setPrependValue(String prependValue) { + this.prependValue = prependValue; } @Override public int hashCode() { - int hash = 5; - hash = 83 * hash + Objects.hashCode(this.prependValue); + int hash = 7; + hash = 31 * hash + Objects.hashCode(prependValue); return hash; } @@ -64,7 +72,16 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final StringPrependValueModification other = (StringPrependValueModification) obj; - return Objects.equals(this.prependValue, other.getPrependValue()); + StringPrependValueModification other = (StringPrependValueModification) obj; + return Objects.equals(prependValue, other.prependValue); + } + + @Override + public String toString() { + return "StringPrependValueModification{" + + "prependValue='" + + backslashEscapeString(prependValue) + + '\'' + + '}'; } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/util/ArrayConverter.java b/src/main/java/de/rub/nds/modifiablevariable/util/ArrayConverter.java index 4ad63982..99b9c038 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/ArrayConverter.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/ArrayConverter.java @@ -13,43 +13,77 @@ import java.util.List; /** A utility class to handle arrays and array conversions */ -public class ArrayConverter { +public final class ArrayConverter { + + private ArrayConverter() { + super(); + } /** * Takes a long value and converts it to 8 bytes (needed for example to convert SQN numbers in * TLS records) * - * @param l long value + * @param value long value * @return long represented by 8 bytes */ - public static byte[] longToUint64Bytes(long l) { + public static byte[] longToUint64Bytes(long value) { byte[] result = new byte[8]; - result[0] = (byte) (l >>> 56); - result[1] = (byte) (l >>> 48); - result[2] = (byte) (l >>> 40); - result[3] = (byte) (l >>> 32); - result[4] = (byte) (l >>> 24); - result[5] = (byte) (l >>> 16); - result[6] = (byte) (l >>> 8); - result[7] = (byte) (l); + result[0] = (byte) (value >>> 56); + result[1] = (byte) (value >>> 48); + result[2] = (byte) (value >>> 40); + result[3] = (byte) (value >>> 32); + result[4] = (byte) (value >>> 24); + result[5] = (byte) (value >>> 16); + result[6] = (byte) (value >>> 8); + result[7] = (byte) value; return result; } + /** Note: This will truncate the long */ + public static byte[] longToUint48Bytes(long value) { + byte[] output = new byte[6]; + output[0] = (byte) (value >>> 40); + output[1] = (byte) (value >>> 32); + output[2] = (byte) (value >>> 24); + output[3] = (byte) (value >>> 16); + output[4] = (byte) (value >>> 8); + output[5] = (byte) value; + return output; + } + /** - * Takes a long value and converts it to 4 bytes + * Takes an int value and converts it to 4 bytes * - * @param l long value - * @return long represented by 4 bytes + * @param value int value + * @return int represented by 4 bytes */ - public static byte[] longToUint32Bytes(long l) { + public static byte[] longToUint32Bytes(long value) { byte[] result = new byte[4]; - result[0] = (byte) (l >>> 24); - result[1] = (byte) (l >>> 16); - result[2] = (byte) (l >>> 8); - result[3] = (byte) (l); + result[0] = (byte) (value >>> 24); + result[1] = (byte) (value >>> 16); + result[2] = (byte) (value >>> 8); + result[3] = (byte) value; return result; } + public static long uInt64BytesToLong(byte[] bytes) { + return (long) (bytes[0] & 0xFF) << 56 + | (long) (bytes[1] & 0xFF) << 48 + | (long) (bytes[2] & 0xFF) << 40 + | (long) (bytes[3] & 0xFF) << 32 + | (long) (bytes[4] & 0xFF) << 24 + | (long) (bytes[5] & 0xFF) << 16 + | (long) (bytes[6] & 0xFF) << 8 + | (long) (bytes[7] & 0xFF); + } + + public static long uInt32BytesToLong(byte[] bytes) { + return (long) (bytes[0] & 0xFF) << 24 + | (bytes[1] & 0xFF) << 16 + | (bytes[2] & 0xFF) << 8 + | bytes[3] & 0xFF; + } + /** * Takes an integer value and stores its last bytes into a byte array * @@ -64,7 +98,7 @@ public static byte[] intToBytes(int value, int size) { } byte[] result = new byte[size]; int shift = 0; - int finalPosition = ((size > Integer.BYTES) ? (size - Integer.BYTES) : 0); + int finalPosition = size > Integer.BYTES ? size - Integer.BYTES : 0; for (int i = size - 1; i >= finalPosition; i--) { result[i] = (byte) (value >>> shift); shift += 8; @@ -87,7 +121,7 @@ public static byte[] longToBytes(long value, int size) { } byte[] result = new byte[size]; int shift = 0; - int finalPosition = ((size > Long.BYTES) ? (size - Long.BYTES) : 0); + int finalPosition = size > Long.BYTES ? size - Long.BYTES : 0; for (int i = size - 1; i >= finalPosition; i--) { result[i] = (byte) (value >>> shift); shift += 8; @@ -119,10 +153,10 @@ public static int bytesToInt(byte[] value) { * @return long */ public static long bytesToLong(byte[] value) { - int result = 0; + long result = 0; int shift = 0; for (int i = value.length - 1; i >= 0; i--) { - result += (value[i] & 0xFF) << shift; + result += (long) (value[i] & 0xFF) << shift; shift += 8; } return result; @@ -132,7 +166,7 @@ public static String bytesToHexString(byte[] array) { if (array == null) { array = new byte[0]; } - boolean usePrettyPrinting = (array.length > 15); + boolean usePrettyPrinting = array.length > 15; return bytesToHexString(array, usePrettyPrinting); } @@ -151,10 +185,10 @@ public static String bytesToHexString( } for (int i = 0; i < array.length; i++) { if (i != 0) { - if (usePrettyPrinting && (i % 16 == 0)) { + if (usePrettyPrinting && i % 16 == 0) { result.append("\n"); } else { - if (usePrettyPrinting && (i % 8 == 0)) { + if (usePrettyPrinting && i % 8 == 0) { result.append(" "); } result.append(" "); @@ -188,47 +222,50 @@ public static String bytesToHexString( */ public static String bytesToRawHexString(byte[] array) { StringBuilder result = new StringBuilder(); - for (int i = 0; i < array.length; i++) { - byte b = array[i]; + for (byte b : array) { result.append(String.format("%02X", b)); } return result.toString(); } @SafeVarargs - public static T[] concatenate(final T[]... arrays) { + public static T[] concatenate(T[]... arrays) { if (arrays == null || arrays.length == 0) { throw new IllegalArgumentException( "The minimal number of parameters for this function is one"); } int length = 0; - for (final T[] a : arrays) { - length += a.length; + for (T[] a : arrays) { + if (a != null) { + length += a.length; + } } @SuppressWarnings("unchecked") T[] result = (T[]) Array.newInstance(arrays[0].getClass().getComponentType(), length); int currentOffset = 0; - for (final T[] a : arrays) { - System.arraycopy(a, 0, result, currentOffset, a.length); - currentOffset += a.length; + for (T[] a : arrays) { + if (a != null) { + System.arraycopy(a, 0, result, currentOffset, a.length); + currentOffset += a.length; + } } return result; } - public static byte[] concatenate(final byte[]... arrays) { + public static byte[] concatenate(byte[]... arrays) { if (arrays == null || arrays.length == 0) { throw new IllegalArgumentException( "The minimal number of parameters for this function is one"); } int length = 0; - for (final byte[] a : arrays) { + for (byte[] a : arrays) { if (a != null) { length += a.length; } } byte[] result = new byte[length]; int currentOffset = 0; - for (final byte[] a : arrays) { + for (byte[] a : arrays) { if (a != null) { System.arraycopy(a, 0, result, currentOffset, a.length); currentOffset += a.length; @@ -237,8 +274,7 @@ public static byte[] concatenate(final byte[]... arrays) { return result; } - public static byte[] concatenate( - final byte[] array1, final byte[] array2, int numberOfArray2Bytes) { + public static byte[] concatenate(byte[] array1, byte[] array2, int numberOfArray2Bytes) { int length = array1.length + numberOfArray2Bytes; byte[] result = new byte[length]; System.arraycopy(array1, 0, result, 0, array1.length); @@ -246,7 +282,7 @@ public static byte[] concatenate( return result; } - public static void makeArrayNonZero(final byte[] array) { + public static void makeArrayNonZero(byte[] array) { for (int i = 0; i < array.length; i++) { if (array[i] == 0) { array[i] = 1; @@ -332,7 +368,7 @@ public static BigInteger[] convertListToArray(List list) { * @return byte array */ public static byte[] hexStringToByteArray(String input) { - if ((input == null) || (input.length() % 2 != 0)) { + if (input == null || input.length() % 2 != 0) { throw new IllegalArgumentException( "The input must not be null and " + "shall have an even number of hexadecimal characters. Found: " @@ -384,19 +420,6 @@ public static byte[] bigIntegerToNullPaddedByteArray(BigInteger input, int outpu return output; } - public static byte[] longToUint48Bytes(long input) { - byte[] output = new byte[6]; - - output[0] = (byte) (input >>> 40); - output[1] = (byte) (input >>> 32); - output[2] = (byte) (input >>> 24); - output[3] = (byte) (input >>> 16); - output[4] = (byte) (input >>> 8); - output[5] = (byte) input; - - return output; - } - /** * Reverses the order of a byte array: So, [0x00,0x01,0x02,0x03] will be returned as * [0x03,0x02,0x01,0x00] diff --git a/src/main/java/de/rub/nds/modifiablevariable/util/BadFixedRandom.java b/src/main/java/de/rub/nds/modifiablevariable/util/BadFixedRandom.java index e0711eca..b874a58e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/BadFixedRandom.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/BadFixedRandom.java @@ -15,9 +15,10 @@ */ public class BadFixedRandom extends Random { - byte retVal; + private final byte retVal; public BadFixedRandom(byte retVal) { + super(); this.retVal = retVal; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/util/BadRandom.java b/src/main/java/de/rub/nds/modifiablevariable/util/BadRandom.java index ef8fc6da..b858e6fc 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/BadRandom.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/BadRandom.java @@ -12,20 +12,22 @@ import java.security.SecureRandomSpi; import java.util.Random; -/** */ public class BadRandom extends SecureRandom { private Random random; public BadRandom() { + super(); random = new Random(0); } public BadRandom(Random random, byte[] seed) { + super(); this.random = random; } public BadRandom(Random random, SecureRandomSpi secureRandomSpi, Provider provider) { + super(); this.random = random; } @@ -62,8 +64,8 @@ public int nextInt() { } @Override - public int nextInt(int n) { - return random.nextInt(n); + public int nextInt(int bound) { + return random.nextInt(bound); } @Override diff --git a/src/main/java/de/rub/nds/modifiablevariable/util/ComparableByteArray.java b/src/main/java/de/rub/nds/modifiablevariable/util/ComparableByteArray.java index 4c67566a..018daa1e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/ComparableByteArray.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/ComparableByteArray.java @@ -14,6 +14,7 @@ public class ComparableByteArray { private byte[] array; public ComparableByteArray(byte[] array) { + super(); this.array = array; } @@ -28,7 +29,7 @@ public void setArray(byte[] array) { @Override public int hashCode() { int hash = 7; - hash = 83 * hash + Arrays.hashCode(this.array); + hash = 83 * hash + Arrays.hashCode(array); return hash; } @@ -43,10 +44,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) { return false; } - final ComparableByteArray other = (ComparableByteArray) obj; - if (!Arrays.equals(this.array, other.array)) { - return false; - } - return true; + ComparableByteArray other = (ComparableByteArray) obj; + return Arrays.equals(array, other.array); } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/util/IllegalStringAdapter.java b/src/main/java/de/rub/nds/modifiablevariable/util/IllegalStringAdapter.java index 1006c078..a3f33fcf 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/IllegalStringAdapter.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/IllegalStringAdapter.java @@ -10,7 +10,6 @@ import jakarta.xml.bind.annotation.adapters.XmlAdapter; import org.apache.commons.text.StringEscapeUtils; -/** */ public class IllegalStringAdapter extends XmlAdapter { @Override diff --git a/src/main/java/de/rub/nds/modifiablevariable/util/Modifiable.java b/src/main/java/de/rub/nds/modifiablevariable/util/Modifiable.java index 80c0d8f2..d5f1800a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/Modifiable.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/Modifiable.java @@ -10,8 +10,7 @@ import de.rub.nds.modifiablevariable.VariableModification; import de.rub.nds.modifiablevariable.biginteger.BigIntegerModificationFactory; import de.rub.nds.modifiablevariable.biginteger.ModifiableBigInteger; -import de.rub.nds.modifiablevariable.bool.BooleanExplicitValueModification; -import de.rub.nds.modifiablevariable.bool.BooleanToggleModification; +import de.rub.nds.modifiablevariable.bool.BooleanModificationFactory; import de.rub.nds.modifiablevariable.bool.ModifiableBoolean; import de.rub.nds.modifiablevariable.bytearray.ByteArrayModificationFactory; import de.rub.nds.modifiablevariable.bytearray.ModifiableByteArray; @@ -26,151 +25,186 @@ import java.math.BigInteger; @SuppressWarnings("unused") -public class Modifiable { +public final class Modifiable { + + private Modifiable() { + super(); + } private static ModifiableByteArray getModifiableByteArrayWithModification( VariableModification modification) { ModifiableByteArray modifiableByteArray = new ModifiableByteArray(); - modifiableByteArray.setModification(modification); + modifiableByteArray.setModifications(modification); return modifiableByteArray; } private static ModifiableByte getModifiableByteWithModification( VariableModification modification) { ModifiableByte modifiableByte = new ModifiableByte(); - modifiableByte.setModification(modification); + modifiableByte.setModifications(modification); return modifiableByte; } private static ModifiableInteger getModifiableIntegerWithModification( VariableModification modification) { ModifiableInteger modifiableInteger = new ModifiableInteger(); - modifiableInteger.setModification(modification); + modifiableInteger.setModifications(modification); return modifiableInteger; } private static ModifiableBigInteger getModifiableBigIntegerWithModification( VariableModification modification) { ModifiableBigInteger modifiableBigInteger = new ModifiableBigInteger(); - modifiableBigInteger.setModification(modification); + modifiableBigInteger.setModifications(modification); return modifiableBigInteger; } private static ModifiableLong getModifiableLongWithModification( VariableModification modification) { ModifiableLong modifiableLong = new ModifiableLong(); - modifiableLong.setModification(modification); + modifiableLong.setModifications(modification); return modifiableLong; } private static ModifiableBoolean getModifiableBooleanWithModification( VariableModification modification) { ModifiableBoolean modifiableBoolean = new ModifiableBoolean(); - modifiableBoolean.setModification(modification); + modifiableBoolean.setModifications(modification); return modifiableBoolean; } private static ModifiableString getModifiableStringWithModification( VariableModification modification) { ModifiableString modifiableString = new ModifiableString(); - modifiableString.setModification(modification); + modifiableString.setModifications(modification); return modifiableString; } - public static ModifiableString prepend(final String s) { - return getModifiableStringWithModification(StringModificationFactory.prependValue(s)); + public static ModifiableByteArray prepend(byte[] perpendValue) { + return getModifiableByteArrayWithModification( + ByteArrayModificationFactory.prependValue(perpendValue)); + } + + public static ModifiableString prepend(String perpendValue) { + return getModifiableStringWithModification( + StringModificationFactory.prependValue(perpendValue)); + } + + public static ModifiableByteArray append(byte[] appendValue) { + return getModifiableByteArrayWithModification( + ByteArrayModificationFactory.appendValue(appendValue)); } - public static ModifiableString append(final String s) { - return getModifiableStringWithModification(StringModificationFactory.appendValue(s)); + public static ModifiableString append(String appendValue) { + return getModifiableStringWithModification( + StringModificationFactory.appendValue(appendValue)); } - public static ModifiableByteArray explicit(byte[] b) { + public static ModifiableByteArray explicit(byte[] explicitValue) { return getModifiableByteArrayWithModification( - ByteArrayModificationFactory.explicitValue(b)); + ByteArrayModificationFactory.explicitValue(explicitValue)); } - public static ModifiableByte explicit(Byte b) { - return getModifiableByteWithModification(ByteModificationFactory.explicitValue(b)); + public static ModifiableByte explicit(Byte explicitValue) { + return getModifiableByteWithModification( + ByteModificationFactory.explicitValue(explicitValue)); } - public static ModifiableInteger explicit(Integer i) { - return getModifiableIntegerWithModification(IntegerModificationFactory.explicitValue(i)); + public static ModifiableInteger explicit(Integer explicitValue) { + return getModifiableIntegerWithModification( + IntegerModificationFactory.explicitValue(explicitValue)); } - public static ModifiableBigInteger explicit(BigInteger i) { + public static ModifiableBigInteger explicit(BigInteger explicitValue) { return getModifiableBigIntegerWithModification( - BigIntegerModificationFactory.explicitValue(i)); + BigIntegerModificationFactory.explicitValue(explicitValue)); } - public static ModifiableLong explicit(Long l) { - return getModifiableLongWithModification(LongModificationFactory.explicitValue(l)); + public static ModifiableLong explicit(Long explicitValue) { + return getModifiableLongWithModification( + LongModificationFactory.explicitValue(explicitValue)); } - public static ModifiableBoolean explicit(Boolean b) { - return getModifiableBooleanWithModification(new BooleanExplicitValueModification(b)); + public static ModifiableBoolean explicit(Boolean explicitValue) { + return getModifiableBooleanWithModification( + BooleanModificationFactory.explicitValue(explicitValue)); } - public static ModifiableString explicit(String s) { - return getModifiableStringWithModification(StringModificationFactory.explicitValue(s)); + public static ModifiableString explicit(String explicitValue) { + return getModifiableStringWithModification( + StringModificationFactory.explicitValue(explicitValue)); } - public static ModifiableByteArray xor(byte[] b, int position) { + public static ModifiableByteArray insert(byte[] insertValue, int position) { return getModifiableByteArrayWithModification( - ByteArrayModificationFactory.xor(b, position)); + ByteArrayModificationFactory.insertValue(insertValue, position)); } - public static ModifiableByte xor(Byte b) { - return getModifiableByteWithModification(ByteModificationFactory.xor(b)); + public static ModifiableString insert(String insertValue, int position) { + return getModifiableStringWithModification( + StringModificationFactory.insertValue(insertValue, position)); } - public static ModifiableInteger xor(Integer i) { - return getModifiableIntegerWithModification(IntegerModificationFactory.xor(i)); + public static ModifiableByteArray xor(byte[] xor, int position) { + return getModifiableByteArrayWithModification( + ByteArrayModificationFactory.xor(xor, position)); } - public static ModifiableBigInteger xor(BigInteger i) { - return getModifiableBigIntegerWithModification(BigIntegerModificationFactory.xor(i)); + public static ModifiableByte xor(Byte xor) { + return getModifiableByteWithModification(ByteModificationFactory.xor(xor)); } - public static ModifiableLong xor(Long l) { - return getModifiableLongWithModification(LongModificationFactory.xor(l)); + public static ModifiableInteger xor(Integer xor) { + return getModifiableIntegerWithModification(IntegerModificationFactory.xor(xor)); } - public static ModifiableByte add(Byte b) { - return getModifiableByteWithModification(ByteModificationFactory.add(b)); + public static ModifiableBigInteger xor(BigInteger xor) { + return getModifiableBigIntegerWithModification(BigIntegerModificationFactory.xor(xor)); } - public static ModifiableInteger add(Integer i) { - return getModifiableIntegerWithModification(IntegerModificationFactory.add(i)); + public static ModifiableLong xor(Long xor) { + return getModifiableLongWithModification(LongModificationFactory.xor(xor)); } - public static ModifiableBigInteger add(BigInteger i) { - return getModifiableBigIntegerWithModification(BigIntegerModificationFactory.add(i)); + public static ModifiableInteger swapEndianIntger() { + return getModifiableIntegerWithModification(IntegerModificationFactory.swapEndian()); } - public static ModifiableLong add(Long l) { - return getModifiableLongWithModification(LongModificationFactory.add(l)); + public static ModifiableLong swapEndianLong() { + return getModifiableLongWithModification(LongModificationFactory.swapEndian()); } - public static ModifiableByte sub(Byte b) { - return getModifiableByteWithModification(ByteModificationFactory.sub(b)); + public static ModifiableByte add(Byte summand) { + return getModifiableByteWithModification(ByteModificationFactory.add(summand)); } - public static ModifiableInteger sub(Integer i) { - return getModifiableIntegerWithModification(IntegerModificationFactory.sub(i)); + public static ModifiableInteger add(Integer summand) { + return getModifiableIntegerWithModification(IntegerModificationFactory.add(summand)); } - public static ModifiableBigInteger sub(BigInteger i) { - return getModifiableBigIntegerWithModification(BigIntegerModificationFactory.sub(i)); + public static ModifiableBigInteger add(BigInteger summand) { + return getModifiableBigIntegerWithModification(BigIntegerModificationFactory.add(summand)); } - public static ModifiableLong sub(Long l) { - return getModifiableLongWithModification(LongModificationFactory.sub(l)); + public static ModifiableLong add(Long summand) { + return getModifiableLongWithModification(LongModificationFactory.add(summand)); } - public static ModifiableByteArray insert(byte[] b, int position) { - return getModifiableByteArrayWithModification( - ByteArrayModificationFactory.insert(b, position)); + public static ModifiableByte sub(Byte subtrahend) { + return getModifiableByteWithModification(ByteModificationFactory.sub(subtrahend)); + } + + public static ModifiableInteger sub(Integer subtrahend) { + return getModifiableIntegerWithModification(IntegerModificationFactory.sub(subtrahend)); + } + + public static ModifiableBigInteger sub(BigInteger subtrahend) { + return getModifiableBigIntegerWithModification( + BigIntegerModificationFactory.sub(subtrahend)); + } + + public static ModifiableLong sub(Long subtrahend) { + return getModifiableLongWithModification(LongModificationFactory.sub(subtrahend)); } public static ModifiableByteArray delete(int startPosition, int count) { @@ -188,26 +222,45 @@ public static ModifiableByteArray duplicate() { } public static ModifiableBoolean toggle() { - return getModifiableBooleanWithModification(new BooleanToggleModification()); + return getModifiableBooleanWithModification(BooleanModificationFactory.toggle()); + } + + public static ModifiableBigInteger shiftLeftBigInteger(Integer shift) { + return getModifiableBigIntegerWithModification( + BigIntegerModificationFactory.shiftLeft(shift)); + } + + public static ModifiableInteger shiftLeft(Integer shift) { + return getModifiableIntegerWithModification(IntegerModificationFactory.shiftLeft(shift)); + } + + public static ModifiableLong shiftLeftLong(Integer shift) { + return getModifiableLongWithModification(LongModificationFactory.shiftLeft(shift)); } - public static ModifiableBigInteger shiftLeftBigInteger(Integer i) { - return getModifiableBigIntegerWithModification(BigIntegerModificationFactory.shiftLeft(i)); + public static ModifiableBigInteger shiftRightBigInteger(Integer shift) { + return getModifiableBigIntegerWithModification( + BigIntegerModificationFactory.shiftRight(shift)); } - public static ModifiableInteger shiftLeft(Integer i) { - return getModifiableIntegerWithModification(IntegerModificationFactory.shiftLeft(i)); + public static ModifiableInteger shiftRight(Integer shift) { + return getModifiableIntegerWithModification(IntegerModificationFactory.shiftRight(shift)); } - public static ModifiableBigInteger shiftRightBigInteger(Integer i) { - return getModifiableBigIntegerWithModification(BigIntegerModificationFactory.shiftRight(i)); + public static ModifiableLong shiftRightLong(Integer shift) { + return getModifiableLongWithModification(LongModificationFactory.shiftRight(shift)); + } + + public static ModifiableBigInteger multiplyBigInteger(BigInteger factor) { + return getModifiableBigIntegerWithModification( + BigIntegerModificationFactory.multiply(factor)); } - public static ModifiableBigInteger multiplyBigInteger(BigInteger i) { - return getModifiableBigIntegerWithModification(BigIntegerModificationFactory.multiply(i)); + public static ModifiableInteger multiply(Integer factor) { + return getModifiableIntegerWithModification(IntegerModificationFactory.multiply(factor)); } - public static ModifiableInteger shiftRight(Integer i) { - return getModifiableIntegerWithModification(IntegerModificationFactory.shiftRight(i)); + public static ModifiableLong multiply(Long factor) { + return getModifiableLongWithModification(LongModificationFactory.multiply(factor)); } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/util/ModifiableVariableAnalyzer.java b/src/main/java/de/rub/nds/modifiablevariable/util/ModifiableVariableAnalyzer.java index 2ceead42..83968b83 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/ModifiableVariableAnalyzer.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/ModifiableVariableAnalyzer.java @@ -15,11 +15,14 @@ import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; -/** */ -public class ModifiableVariableAnalyzer { +public final class ModifiableVariableAnalyzer { private static final Logger LOGGER = LogManager.getLogger(ModifiableVariableAnalyzer.class); + private ModifiableVariableAnalyzer() { + super(); + } + /** * Lists all the modifiable variables declared in the given class * @@ -67,8 +70,8 @@ public static List getAllModifiableVariableFieldsRecurs getAllModifiableVariableHoldersRecursively(object); List fields = new LinkedList<>(); for (ModifiableVariableListHolder holder : holders) { - for (Field f : holder.getFields()) { - fields.add(new ModifiableVariableField(holder.getObject(), f)); + for (Field field : holder.getFields()) { + fields.add(new ModifiableVariableField(holder.getObject(), field)); } } return fields; @@ -89,16 +92,16 @@ public static List getAllModifiableVariableHolders holders.add(new ModifiableVariableListHolder(object, modFields)); } List allFields = ReflectionHelper.getFieldsUpTo(object.getClass(), null, null); - for (Field f : allFields) { + for (Field field : allFields) { try { HoldsModifiableVariable holdsVariable = - f.getAnnotation(HoldsModifiableVariable.class); - f.setAccessible(true); - Object possibleHolder = f.get(object); + field.getAnnotation(HoldsModifiableVariable.class); + field.setAccessible(true); + Object possibleHolder = field.get(object); if (possibleHolder != null && holdsVariable != null) { if (possibleHolder instanceof List) { @SuppressWarnings("unchecked") - List castedList = List.class.cast(possibleHolder); + List castedList = (List) possibleHolder; holders.addAll(getAllModifiableVariableHoldersFromList(castedList)); } else if (possibleHolder.getClass().isArray()) { holders.addAll( @@ -111,8 +114,8 @@ public static List getAllModifiableVariableHolders } catch (IllegalAccessException | IllegalArgumentException ex) { LOGGER.debug( "Accessing field {} of type {} not possible: {}", - f.getName(), - f.getType(), + field.getName(), + field.getType(), ex.toString()); } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/util/ModifiableVariableField.java b/src/main/java/de/rub/nds/modifiablevariable/util/ModifiableVariableField.java index a6946731..95e3dd4e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/ModifiableVariableField.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/ModifiableVariableField.java @@ -17,11 +17,14 @@ public class ModifiableVariableField { private Field field; - public ModifiableVariableField() {} + public ModifiableVariableField() { + super(); + } - public ModifiableVariableField(Object o, Field f) { - this.object = o; - this.field = f; + public ModifiableVariableField(Object o, Field field) { + super(); + object = o; + this.field = field; } public Object getObject() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/util/ModifiableVariableListHolder.java b/src/main/java/de/rub/nds/modifiablevariable/util/ModifiableVariableListHolder.java index 84d2a454..732eb483 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/ModifiableVariableListHolder.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/ModifiableVariableListHolder.java @@ -20,11 +20,14 @@ public class ModifiableVariableListHolder { private List fields; - public ModifiableVariableListHolder() {} + public ModifiableVariableListHolder() { + super(); + } - public ModifiableVariableListHolder(Object o, List f) { - this.object = o; - this.fields = f; + public ModifiableVariableListHolder(Object o, List fields) { + super(); + object = o; + this.fields = fields; } public Object getObject() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/util/RandomHelper.java b/src/main/java/de/rub/nds/modifiablevariable/util/RandomHelper.java index b851fccf..78aaf980 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/RandomHelper.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/RandomHelper.java @@ -9,8 +9,7 @@ import java.util.Random; -/** */ -public class RandomHelper { +public final class RandomHelper { private static Random random; @@ -29,5 +28,7 @@ public static void setRandom(Random random) { RandomHelper.random = random; } - private RandomHelper() {} + private RandomHelper() { + super(); + } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/util/ReflectionHelper.java b/src/main/java/de/rub/nds/modifiablevariable/util/ReflectionHelper.java index 23d0498e..699fc39d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/ReflectionHelper.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/ReflectionHelper.java @@ -14,10 +14,15 @@ import java.util.LinkedList; import java.util.List; -public class ReflectionHelper { +public final class ReflectionHelper { + + private ReflectionHelper() { + super(); + } /** - * Source: http://stackoverflow.com/questions/17451506/list-all-private-fields -of-a-java-object + * Source: ... * Retrieves all fields (all access levels) from all classes up the class hierarchy starting * with {@code startClass} stopping with and not including {@code exclusiveParent}. Generally * {@code Object.class} should be passed as {@code exclusiveParent}. @@ -37,8 +42,7 @@ public static List getFieldsUpTo( Class parentClass = startClass.getSuperclass(); - if ((parentClass != null) - && ((exclusiveParent == null) || !(parentClass.equals(exclusiveParent)))) { + if (parentClass != null && !parentClass.equals(exclusiveParent)) { List parentClassFields = getFieldsUpTo(parentClass, exclusiveParent, filterClass); @@ -52,9 +56,9 @@ public static List getFieldsUpTo( private static List filterFieldList(List fields, Class filterClass) { List filteredFields = new LinkedList<>(); - for (Field f : fields) { - if ((filterClass == null) || filterClass.isAssignableFrom(f.getType())) { - filteredFields.add(f); + for (Field field : fields) { + if (filterClass == null || filterClass.isAssignableFrom(field.getType())) { + filteredFields.add(field); } } @@ -65,47 +69,14 @@ public static List getValuesFromFieldList(Object object, List fie throws IllegalAccessException { List list = new LinkedList<>(); - for (Field f : fields) { - f.setAccessible(true); - list.add(f.get(object)); + for (Field field : fields) { + field.setAccessible(true); + list.add(field.get(object)); } return list; } - // /** - // * - // * @param object - // * @param field - // * @return - // * @throws IllegalAccessException - // * @throws java.lang.reflect.InvocationTargetException - // */ - // public static Object getFieldValue(Object object, Field field) throws - // IllegalAccessException, IllegalArgumentException, - // InvocationTargetException { - // Method[] methods = object.getClass().getMethods(); - // for (Method method : methods) { - // String name = method.getName(); - // if (name.equalsIgnoreCase("get" + field.getName())) { - // return method.invoke(object); - // } - // } - // return null; - // } - // - // public static void setFieldValue(Object object, Field field, Object - // value) throws - // IllegalAccessException, IllegalArgumentException, - // InvocationTargetException { - // Method[] methods = object.getClass().getMethods(); - // for (Method method : methods) { - // String name = method.getName(); - // if (name.equalsIgnoreCase("set" + field.getName())) { - // method.invoke(object, value); - // } - // } - // } public static Type[] getParameterizedTypes(Object object) { Type superclassType = object.getClass().getGenericSuperclass(); diff --git a/src/main/java/de/rub/nds/modifiablevariable/util/StringUtil.java b/src/main/java/de/rub/nds/modifiablevariable/util/StringUtil.java index bc07ffa6..a2e0102a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/StringUtil.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/StringUtil.java @@ -7,12 +7,12 @@ */ package de.rub.nds.modifiablevariable.util; -public class StringUtil { +public final class StringUtil { // Private constructor, because this is a utility class that is not meant // to be instantiated. - private StringUtil() {} - - static final int HI_SURROGATE_START = 0xD800; + private StringUtil() { + super(); + } /** * Replace any non-printable (or non-ascii) characters other than space with their @@ -21,10 +21,13 @@ private StringUtil() {} * @param value string that may contain non-printable or non-ascii chars * @return string with non-printable or non-ascii characters replaced */ - public static String backslashEscapeString(final String value) { - final StringBuffer buffer = new StringBuffer(value); - for (int i = 0; i < buffer.length(); i++) { - final int codePoint = buffer.codePointAt(i); + public static String backslashEscapeString(String value) { + if (value == null) { + return null; + } + StringBuilder builder = new StringBuilder(value); + for (int i = 0; i < builder.length(); i++) { + int codePoint = builder.codePointAt(i); String replacement; int numCodePoints = 1; switch (codePoint) { @@ -68,10 +71,10 @@ public static String backslashEscapeString(final String value) { } } - buffer.replace(i, i + numCodePoints, replacement); + builder.replace(i, i + numCodePoints, replacement); i += replacement.length() - 1; } - return buffer.toString(); + return builder.toString(); } } diff --git a/src/main/java/de/rub/nds/modifiablevariable/util/SuppressingBooleanAdapter.java b/src/main/java/de/rub/nds/modifiablevariable/util/SuppressingBooleanAdapter.java index 3a9c5dda..f16a0de9 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/util/SuppressingBooleanAdapter.java +++ b/src/main/java/de/rub/nds/modifiablevariable/util/SuppressingBooleanAdapter.java @@ -15,7 +15,7 @@ public abstract class SuppressingBooleanAdapter extends XmlAdapter { @Override diff --git a/src/main/resources/de/rub/nds/modifiablevariable/explicit/array.vec b/src/main/resources/de/rub/nds/modifiablevariable/explicit/array.vec deleted file mode 100644 index 47f700b1..00000000 --- a/src/main/resources/de/rub/nds/modifiablevariable/explicit/array.vec +++ /dev/null @@ -1,49 +0,0 @@ - -00 -00 00 -00 00 00 -00 00 00 00 -00 00 00 00 00 -00 00 00 00 00 00 -00 00 00 00 00 00 00 -00 00 00 00 00 00 00 00 -00 00 00 00 00 00 00 00 00 -00 00 00 00 00 00 00 00 00 00 -00 00 00 00 00 00 00 00 00 00 00 -00 00 00 00 00 00 00 00 00 00 00 00 -00 00 00 00 00 00 00 00 00 00 00 00 00 -00 00 00 00 00 00 00 00 00 00 00 00 00 00 -00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 -00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 -FF -FF FF -FF FF FF -FF FF FF FF -FF FF FF FF FF -FF FF FF FF FF FF -FF FF FF FF FF FF FF -FF FF FF FF FF FF FF FF -FF FF FF FF FF FF FF FF FF -FF FF FF FF FF FF FF FF FF FF -FF FF FF FF FF FF FF FF FF FF FF -FF FF FF FF FF FF FF FF FF FF FF FF -FF FF FF FF FF FF FF FF FF FF FF FF FF -FF FF FF FF FF FF FF FF FF FF FF FF FF FF -FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF -FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF -7F -7F 7F -7F 7F 7F -7F 7F 7F 7F -7F 7F 7F 7F 7F -7F 7F 7F 7F 7F 7F -7F 7F 7F 7F 7F 7F 7F -7F 7F 7F 7F 7F 7F 7F 7F -7F 7F 7F 7F 7F 7F 7F 7F 7F -7F 7F 7F 7F 7F 7F 7F 7F 7F 7F -7F 7F 7F 7F 7F 7F 7F 7F 7F 7F 7F -7F 7F 7F 7F 7F 7F 7F 7F 7F 7F 7F 7F -7F 7F 7F 7F 7F 7F 7F 7F 7F 7F 7F 7F 7F -7F 7F 7F 7F 7F 7F 7F 7F 7F 7F 7F 7F 7F 7F -7F 7F 7F 7F 7F 7F 7F 7F 7F 7F 7F 7F 7F 7F 7F -7F 7F 7F 7F 7F 7F 7F 7F 7F 7F 7F 7F 7F 7F 7F 7F \ No newline at end of file diff --git a/src/main/resources/de/rub/nds/modifiablevariable/explicit/byte.vec b/src/main/resources/de/rub/nds/modifiablevariable/explicit/byte.vec deleted file mode 100644 index 0e8bb5a6..00000000 --- a/src/main/resources/de/rub/nds/modifiablevariable/explicit/byte.vec +++ /dev/null @@ -1,9 +0,0 @@ - -128 /* Overflow signed 8-bit when decremented */ - -1 /* */ - 0 /* */ - 1 /* */ - 16 /* One-off with common buffer size */ - 32 /* One-off with common buffer size */ - 64 /* One-off with common buffer size */ - 100 /* One-off with common buffer size */ - 127 /* Overflow signed 8-bit when incremented */ \ No newline at end of file diff --git a/src/main/resources/de/rub/nds/modifiablevariable/explicit/integer.vec b/src/main/resources/de/rub/nds/modifiablevariable/explicit/integer.vec deleted file mode 100644 index fd8de618..00000000 --- a/src/main/resources/de/rub/nds/modifiablevariable/explicit/integer.vec +++ /dev/null @@ -1,27 +0,0 @@ --128 /* Overflow signed 8-bit when decremented */ --1 /* */ -0 /* */ -1 /* */ -16 /* One-off with common buffer size */ -32 /* One-off with common buffer size */ -64 /* One-off with common buffer size */ -100 /* One-off with common buffer size */ -127 /* Overflow signed 8-bit when incremented */ --32768 /* Overflow signed 16-bit when decremented */ --129 /* Overflow signed 8-bit */ -128 /* Overflow signed 8-bit */ -255 /* Overflow unsig 8-bit when incremented */ -256 /* Overflow unsig 8-bit */ -512 /* One-off with common buffer size */ -1000 /* One-off with common buffer size */ -1024 /* One-off with common buffer size */ -4096 /* One-off with common buffer size */ -32767 /* Overflow signed 16-bit when incremented */ --2147483648 /* Overflow signed 32-bit when decremented */ --100663046 /* Large negative number (endian-agnostic) */ --32769 /* Overflow signed 16-bit */ -32768 /* Overflow signed 16-bit */ -65535 /* Overflow unsig 16-bit when incremented */ -65536 /* Overflow unsig 16 bit */ -100663045 /* Large positive number (endian-agnostic) */ -2147483647 /* Overflow signed 32-bit when incremented */ diff --git a/src/test/java/de/rub/nds/modifiablevariable/ModifiableVariableTest.java b/src/test/java/de/rub/nds/modifiablevariable/ModifiableVariableTest.java deleted file mode 100644 index 6e148760..00000000 --- a/src/test/java/de/rub/nds/modifiablevariable/ModifiableVariableTest.java +++ /dev/null @@ -1,76 +0,0 @@ -/* - * ModifiableVariable - A Variable Concept for Runtime Modifications - * - * Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH - * - * Licensed under Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 - */ -package de.rub.nds.modifiablevariable; - -import static org.junit.jupiter.api.Assertions.assertNotNull; - -import de.rub.nds.modifiablevariable.biginteger.ModifiableBigInteger; -import de.rub.nds.modifiablevariable.bytearray.ModifiableByteArray; -import de.rub.nds.modifiablevariable.integer.ModifiableInteger; -import de.rub.nds.modifiablevariable.longint.ModifiableLong; -import de.rub.nds.modifiablevariable.singlebyte.ModifiableByte; -import de.rub.nds.modifiablevariable.util.ArrayConverter; -import java.math.BigInteger; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; -import org.junit.jupiter.api.Test; - -public class ModifiableVariableTest { - - private static final Logger LOGGER = LogManager.getLogger(); - - @Test - public void testRandomBigIntegerModification() { - ModifiableBigInteger bigInteger = - ModifiableVariableFactory.createBigIntegerModifiableVariable(); - bigInteger.setOriginalValue(BigInteger.ZERO); - bigInteger.createRandomModificationAtRuntime(); - LOGGER.info("Randomly modified big integer: " + bigInteger.getValue()); - assertNotNull(bigInteger.getModification()); - } - - @Test - public void testRandomIntegerModification() { - ModifiableInteger integer = ModifiableVariableFactory.createIntegerModifiableVariable(); - integer.setOriginalValue(0); - integer.createRandomModificationAtRuntime(); - LOGGER.info("Randomly modified integer: " + integer.getValue()); - assertNotNull(integer.getModification()); - } - - @Test - public void testRandomByteArrayModification() { - ModifiableByteArray array = ModifiableVariableFactory.createByteArrayModifiableVariable(); - array.setOriginalValue(new byte[] {0, 1, 2}); - array.createRandomModificationAtRuntime(); - LOGGER.info( - "Randomly modified byte array: {}", - () -> ArrayConverter.bytesToHexString(array.getValue())); - assertNotNull(array.getModification()); - } - - @Test - public void testRandomSingleByteModification() { - ModifiableByte singleByte = ModifiableVariableFactory.createByteModifiableVariable(); - singleByte.setOriginalValue((byte) 0); - singleByte.createRandomModificationAtRuntime(); - LOGGER.info( - "Randomly modified byte: {} ", - () -> ArrayConverter.bytesToHexString(new byte[] {singleByte.getValue()})); - assertNotNull(singleByte.getModification()); - } - - @Test - public void testRandomLongModification() { - ModifiableLong modLong = ModifiableVariableFactory.createLongModifiableVariable(); - modLong.setOriginalValue(0L); - modLong.createRandomModificationAtRuntime(); - LOGGER.info("Randomly modified Long: " + modLong.getValue()); - assertNotNull(modLong.getModification()); - } -} diff --git a/src/test/java/de/rub/nds/modifiablevariable/assertion/AssertionTest.java b/src/test/java/de/rub/nds/modifiablevariable/assertion/AssertionTest.java index 19234e30..cffe2e75 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/assertion/AssertionTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/assertion/AssertionTest.java @@ -42,7 +42,7 @@ public void testAssertionInteger() { @Test public void testAddInteger() { VariableModification modifier = IntegerModificationFactory.add(1); - mi.setModification(modifier); + mi.setModifications(modifier); mi.setAssertEquals(11); assertTrue(mi.validateAssertions()); } diff --git a/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModificationTest.java b/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModificationTest.java index d2ef7d8b..d7b19d83 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModificationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModificationTest.java @@ -52,12 +52,6 @@ public void testSetSummand() { assertEquals(BigInteger.ONE, b2.getSummand()); } - /** Test of getModifiedCopy method, of class BigIntegerAddModification. */ - @Test - public void testGetModifiedCopy() { - assertNotEquals(b1, b1.getModifiedCopy()); - } - /** Test of hashCode method, of class BigIntegerAddModification. */ @Test public void testHashCode() { diff --git a/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModificationTest.java b/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModificationTest.java index f8d36cf1..8ed9913e 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModificationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModificationTest.java @@ -45,11 +45,6 @@ public void testGetExplicitValue() {} @Test public void testSetExplicitValue() {} - /** Test of getModifiedCopy method, of class BigIntegerExplicitValueModification. */ - @Disabled("Not yet implemented") - @Test - public void testGetModifiedCopy() {} - /** Test of hashCode method, of class BigIntegerExplicitValueModification. */ @Disabled("Not yet implemented") @Test diff --git a/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerModificationTest.java b/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerModificationTest.java index d089dfab..64c213b6 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerModificationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerModificationTest.java @@ -33,7 +33,7 @@ public void setUp() { public void testAdd() { VariableModification modifier = BigIntegerModificationFactory.add(BigInteger.ONE); - start.setModification(modifier); + start.setModifications(modifier); expectedResult = new BigInteger("11"); result = start.getValue(); assertEquals(expectedResult, result); @@ -46,7 +46,7 @@ public void testAdd() { public void testSub() { VariableModification modifier = BigIntegerModificationFactory.sub(BigInteger.ONE); - start.setModification(modifier); + start.setModifications(modifier); expectedResult = new BigInteger("9"); result = start.getValue(); assertEquals(expectedResult, result); @@ -59,7 +59,7 @@ public void testSub() { public void testXor() { VariableModification modifier = BigIntegerModificationFactory.xor(new BigInteger("2")); - start.setModification(modifier); + start.setModifications(modifier); expectedResult = new BigInteger("8"); result = start.getValue(); assertEquals(expectedResult, result); @@ -72,7 +72,7 @@ public void testXor() { public void testExplicitValue() { VariableModification modifier = BigIntegerModificationFactory.explicitValue(new BigInteger("7")); - start.setModification(modifier); + start.setModifications(modifier); expectedResult = new BigInteger("7"); result = start.getValue(); assertEquals(expectedResult, result); @@ -86,17 +86,17 @@ public void testIsOriginalValueModified() { assertFalse(start.isOriginalValueModified()); VariableModification modifier = BigIntegerModificationFactory.add(BigInteger.ZERO); - start.setModification(modifier); + start.setModifications(modifier); assertFalse(start.isOriginalValueModified()); modifier = BigIntegerModificationFactory.add(BigInteger.ONE); - start.setModification(modifier); + start.setModifications(modifier); assertTrue(start.isOriginalValueModified()); } @Test public void testShiftLeft() { VariableModification modifier = BigIntegerModificationFactory.shiftLeft(2); - start.setModification(modifier); + start.setModifications(modifier); expectedResult = new BigInteger("40"); result = start.getValue(); assertEquals(expectedResult, result); @@ -107,34 +107,11 @@ public void testShiftLeft() { @Test public void testShiftRight() { VariableModification modifier = BigIntegerModificationFactory.shiftRight(1); - start.setModification(modifier); + start.setModifications(modifier); expectedResult = new BigInteger("5"); result = start.getValue(); assertEquals(expectedResult, result); assertNotSame(expectedResult, result); assertEquals(BigInteger.TEN, start.getOriginalValue()); } - - /** Test of explicitValue from file method */ - @Test - public void testExplicitValueFromFile() { - VariableModification modifier = - BigIntegerModificationFactory.explicitValueFromFile(0); - start.setModification(modifier); - expectedResult = BigInteger.valueOf(-128); - result = start.getValue(); - assertEquals(expectedResult, result); - - modifier = BigIntegerModificationFactory.explicitValueFromFile(1); - start.setModification(modifier); - expectedResult = BigInteger.valueOf(-1); - result = start.getValue(); - assertEquals(expectedResult, result); - - modifier = BigIntegerModificationFactory.explicitValueFromFile(26); - start.setModification(modifier); - expectedResult = BigInteger.valueOf(2147483647); - result = start.getValue(); - assertEquals(expectedResult, result); - } } diff --git a/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerOperationConcatenationTest.java b/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerOperationConcatenationTest.java index da0d468b..cbf152c5 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerOperationConcatenationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerOperationConcatenationTest.java @@ -29,7 +29,7 @@ public void setUp() { @Test public void testAddThenMultiplyWithInnerClass() { // (input + 4) ^ 3 = (10 + 4) ^ 3 = 13 - start.setModification( + start.setModifications( new VariableModification<>() { @Override @@ -38,17 +38,8 @@ protected BigInteger modifyImplementationHook(BigInteger input) { } @Override - public VariableModification getModifiedCopy() { - throw new UnsupportedOperationException("Not supported yet."); // To - // change - // body - // of - // generated - // methods, - // choose - // Tools - // | - // Templates. + public VariableModification createCopy() { + throw new UnsupportedOperationException("Not supported yet."); } }); expectedResult = new BigInteger("13"); diff --git a/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModificationTest.java b/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModificationTest.java index 09016603..98c51372 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModificationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModificationTest.java @@ -45,11 +45,6 @@ public void testGetSubtrahend() {} @Test public void testSetSubtrahend() {} - /** Test of getModifiedCopy method, of class BigIntegerSubtractModification. */ - @Disabled("Not yet implemented") - @Test - public void testGetModifiedCopy() {} - /** Test of hashCode method, of class BigIntegerSubtractModification. */ @Disabled("Not yet implemented") @Test diff --git a/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModificationTest.java b/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModificationTest.java index 9704d152..22f26755 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModificationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModificationTest.java @@ -48,11 +48,6 @@ public void testGetXor() {} @Test public void testSetXor() {} - /** Test of getModifiedCopy method, of class BigIntegerXorModification. */ - @Disabled("Not yet implemented") - @Test - public void testGetModifiedCopy() {} - /** Test of hashCode method, of class BigIntegerXorModification. */ @Disabled("Not yet implemented") @Test diff --git a/src/test/java/de/rub/nds/modifiablevariable/biginteger/ModifiableBigIntegerTest.java b/src/test/java/de/rub/nds/modifiablevariable/biginteger/ModifiableBigIntegerTest.java index 2c391030..07f372b4 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/biginteger/ModifiableBigIntegerTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/biginteger/ModifiableBigIntegerTest.java @@ -29,11 +29,6 @@ public void setUp() { integer2.setOriginalValue(BigInteger.TEN); } - /** Test of createRandomModification method, of class ModifiableBigInteger. */ - @Disabled("Not yet implemented") - @Test - public void testCreateRandomModification() {} - /** Test of getAssertEquals method, of class ModifiableBigInteger. */ @Disabled("Not yet implemented") @Test diff --git a/src/test/java/de/rub/nds/modifiablevariable/bool/BooleanExplicitValueModificationTest.java b/src/test/java/de/rub/nds/modifiablevariable/bool/BooleanExplicitValueModificationTest.java index f8d88171..8af3ac2f 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/bool/BooleanExplicitValueModificationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/bool/BooleanExplicitValueModificationTest.java @@ -49,12 +49,6 @@ public void testSetExplicitValue() { assertTrue(b2.getExplicitValue()); } - /** Test of getModifiedCopy method, of class BooleanExplicitValueModification. */ - @Test - public void testGetModifiedCopy() { - assertNotEquals(b1, b1.getModifiedCopy()); - } - /** Test of hashCode method, of class BooleanExplicitValueModification. */ @Test public void testHashCode() { diff --git a/src/test/java/de/rub/nds/modifiablevariable/bool/ModifiableBooleanTest.java b/src/test/java/de/rub/nds/modifiablevariable/bool/ModifiableBooleanTest.java index c95fc2c9..c56cb6a9 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/bool/ModifiableBooleanTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/bool/ModifiableBooleanTest.java @@ -38,11 +38,6 @@ public void testGetOriginalValue() {} @Test public void testSetOriginalValue() {} - /** Test of createRandomModification method, of class ModifiableBoolean. */ - @Disabled("Not yet implemented") - @Test - public void testCreateRandomModification() {} - /** Test of isOriginalValueModified method, of class ModifiableBoolean. */ @Disabled("Not yet implemented") @Test diff --git a/src/test/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModificationTest.java b/src/test/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModificationTest.java index 08383ddc..d934157d 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModificationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModificationTest.java @@ -67,12 +67,6 @@ public void testSetCount() { assertEquals(1, b1.getCount()); } - /** Test of getModifiedCopy method, of class ByteArrayDeleteModification. */ - @Test - public void testGetModifiedCopy() { - assertNotSame(b1, b1.getModifiedCopy()); - } - /** Test of hashCode method, of class ByteArrayDeleteModification. */ @Test public void testHashCode() { diff --git a/src/test/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArrayTest.java b/src/test/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArrayTest.java index c0305224..f93e2d3d 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArrayTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/bytearray/ModifiableByteArrayTest.java @@ -13,6 +13,7 @@ import de.rub.nds.modifiablevariable.ModifiableVariableFactory; import de.rub.nds.modifiablevariable.VariableModification; import de.rub.nds.modifiablevariable.util.ArrayConverter; +import java.util.Arrays; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import org.junit.jupiter.api.BeforeEach; @@ -20,7 +21,7 @@ public class ModifiableByteArrayTest { - private static final Logger LOGGER = LogManager.getLogger(ModifiableByteArray.class); + private static final Logger LOGGER = LogManager.getLogger(); private ModifiableByteArray start; @@ -60,7 +61,7 @@ public void testExplicitValue() { LOGGER.info("testExplicitValue"); VariableModification modifier = ByteArrayModificationFactory.explicitValue(modification1); - start.setModification(modifier); + start.setModifications(modifier); assertArrayEquals(modification1, start.getValue()); } @@ -69,7 +70,7 @@ public void testExplicitValue() { public void testXorFirstBytes() { LOGGER.info("testXorFirstBytes"); VariableModification modifier = ByteArrayModificationFactory.xor(modification1, 0); - start.setModification(modifier); + start.setModifications(modifier); byte[] expResult = originalValue.clone(); for (int i = 0; i < modification1.length; i++) { @@ -78,9 +79,13 @@ public void testXorFirstBytes() { assertArrayEquals(expResult, start.getValue()); + byte[] expResult2 = originalValue.clone(); + for (int i = 0; i < originalValue.length; i++) { + expResult2[i] = (byte) (originalValue[i] ^ modification2[i]); + } VariableModification modifier2 = ByteArrayModificationFactory.xor(modification2, 0); - start.setModification(modifier2); - assertArrayEquals(originalValue, start.getValue()); + start.setModifications(modifier2); + assertArrayEquals(expResult2, start.getValue()); } /** Test of setXorLastBytes method, of class ModifiableByteArray. */ @@ -96,16 +101,21 @@ public void testXorLastBytes() { VariableModification modifier = ByteArrayModificationFactory.xor(modification1, first); - start.setModification(modifier); + start.setModifications(modifier); LOGGER.debug("Expected: {}", expResult); LOGGER.debug("Computed: {}", () -> ArrayConverter.bytesToHexString(start.getValue())); assertArrayEquals(expResult, start.getValue()); + byte[] expResult2 = originalValue.clone(); + for (int i = 0; i < 2; i++) { + expResult2[first + i] = (byte) (originalValue[first + i] ^ modification2[i]); + } + VariableModification modifier2 = ByteArrayModificationFactory.xor(modification2, first); - start.setModification(modifier2); - assertArrayEquals(originalValue, start.getValue()); + start.setModifications(modifier2); + assertArrayEquals(expResult2, start.getValue()); } /** Test of setPrependBytes method, of class ModifiableByteArray. */ @@ -123,8 +133,8 @@ public void testPrependBytes() { } VariableModification modifier = - ByteArrayModificationFactory.insert(modification1, 0); - start.setModification(modifier); + ByteArrayModificationFactory.insertValue(modification1, 0); + start.setModifications(modifier); LOGGER.debug("Expected: {}", expResult); LOGGER.debug("Computed: {}", () -> ArrayConverter.bytesToHexString(start.getValue())); @@ -146,8 +156,8 @@ public void testAppendBytes() { } VariableModification modifier = - ByteArrayModificationFactory.insert(modification1, originalValue.length); - start.setModification(modifier); + ByteArrayModificationFactory.insertValue(modification1, originalValue.length); + start.setModifications(modifier); LOGGER.debug("Expected: {}", expResult); LOGGER.debug("Computed: {}", () -> ArrayConverter.bytesToHexString(start.getValue())); @@ -165,7 +175,7 @@ public void testDeleteLastBytes() { System.arraycopy(originalValue, 0, expResult, 0, len); VariableModification modifier = ByteArrayModificationFactory.delete(len, modification1.length); - start.setModification(modifier); + start.setModifications(modifier); LOGGER.debug("Expected: {}", expResult); LOGGER.debug("Computed: {}", () -> ArrayConverter.bytesToHexString(start.getValue())); @@ -185,7 +195,7 @@ public void testDeleteFirstBytes() { originalValue, modification1.length, expResult, 0, len - modification1.length); VariableModification modifier = ByteArrayModificationFactory.delete(0, modification1.length); - start.setModification(modifier); + start.setModifications(modifier); LOGGER.debug("Expected: {}", expResult); LOGGER.debug("Computed: {}", () -> ArrayConverter.bytesToHexString(start.getValue())); @@ -200,69 +210,84 @@ public void testDeleteBytes() { LOGGER.debug("Testing Delete all Bytes"); int len = originalValue.length; byte[] expResult = new byte[0]; + byte[] expResult2 = {(byte) 0, (byte) 1, (byte) 2, (byte) 3, (byte) 4, (byte) 5}; + byte[] expResult3 = {(byte) 2, (byte) 3, (byte) 4, (byte) 5, (byte) 6}; VariableModification modifier = ByteArrayModificationFactory.delete(0, len); - start.setModification(modifier); + start.setModifications(modifier); assertArrayEquals(expResult, start.getValue()); start = new ModifiableByteArray(); start.setOriginalValue(originalValue); LOGGER.debug("Testing Delete more Bytes than possible"); modifier = ByteArrayModificationFactory.delete(0, len + 1); - start.setModification(modifier); + start.setModifications(modifier); - assertArrayEquals(start.getValue(), originalValue); + assertArrayEquals(start.getValue(), expResult); start = new ModifiableByteArray(); start.setOriginalValue(originalValue); LOGGER.debug("Testing Delete negative amount"); modifier = ByteArrayModificationFactory.delete(0, -1); - start.setModification(modifier); + start.setModifications(modifier); assertArrayEquals(start.getValue(), originalValue); start = new ModifiableByteArray(); start.setOriginalValue(originalValue); LOGGER.debug("Testing Delete 0 Bytes"); modifier = ByteArrayModificationFactory.delete(0, 0); - start.setModification(modifier); + start.setModifications(modifier); assertArrayEquals(start.getValue(), originalValue); start = new ModifiableByteArray(); start.setOriginalValue(originalValue); LOGGER.debug("Testing Delete from negative Start position"); - modifier = ByteArrayModificationFactory.delete(len * -2, modification1.length); - start.setModification(modifier); - assertArrayEquals(start.getValue(), originalValue); + modifier = ByteArrayModificationFactory.delete(len * -2, 1); + start.setModifications(modifier); + assertArrayEquals(start.getValue(), expResult2); start = new ModifiableByteArray(); start.setOriginalValue(originalValue); LOGGER.debug("Testing Delete from to big Start Position"); - modifier = ByteArrayModificationFactory.delete(len * 2, modification1.length); - start.setModification(modifier); - assertArrayEquals(start.getValue(), originalValue); + modifier = ByteArrayModificationFactory.delete(len * 2, 2); + start.setModifications(modifier); + assertArrayEquals(start.getValue(), expResult3); } /** Test of setInsertBytes method, of class ModifiableByteArray. */ @Test public void testInsertBytes() { LOGGER.info("testInsertBytes"); - // Insert negative position, insert 0 bytes, insert too far + // Insert at negative position -> wrap around assumeTrue(modification1.length < originalValue.length); - LOGGER.debug("Inserting negative Position"); + LOGGER.debug("Inserting negative at position"); VariableModification modifier = - ByteArrayModificationFactory.insert(modification1, -2 * originalValue.length); - start.setModification(modifier); - assertArrayEquals(start.getValue(), originalValue); + ByteArrayModificationFactory.insertValue(modification1, -2 * originalValue.length); + start.setModifications(modifier); + byte[] expResult = + ArrayConverter.concatenate( + Arrays.copyOf(originalValue, 1), + modification1, + Arrays.copyOfRange(originalValue, 1, originalValue.length)); + assertArrayEquals(start.getValue(), expResult); start = new ModifiableByteArray(); start.setOriginalValue(originalValue); LOGGER.debug("Inserting empty Array"); byte[] emptyArray = new byte[0]; - modifier = ByteArrayModificationFactory.insert(emptyArray, 0); - start.setModification(modifier); + modifier = ByteArrayModificationFactory.insertValue(emptyArray, 0); + start.setModifications(modifier); assertArrayEquals(originalValue, start.getValue()); + // Insert at too positive position -> wrap around start = new ModifiableByteArray(); start.setOriginalValue(originalValue); - LOGGER.debug("Inserting to big Start position"); - modifier = ByteArrayModificationFactory.insert(modification1, originalValue.length * 2); - start.setModification(modifier); - assertArrayEquals(originalValue, start.getValue()); + LOGGER.debug("Inserting at too large position"); + modifier = + ByteArrayModificationFactory.insertValue(modification1, originalValue.length * 2); + start.setModifications(modifier); + expResult = + ArrayConverter.concatenate( + Arrays.copyOf(originalValue, originalValue.length - 1), + modification1, + Arrays.copyOfRange( + originalValue, originalValue.length - 1, originalValue.length)); + assertArrayEquals(expResult, start.getValue()); } /** Test of add method, of class BigIntegerModificationFactory. */ @@ -270,13 +295,13 @@ public void testInsertBytes() { public void testIsOriginalValueModified() { assertFalse(start.isOriginalValueModified()); VariableModification modifier = ByteArrayModificationFactory.xor(new byte[] {}, 0); - start.setModification(modifier); + start.setModifications(modifier); assertFalse(start.isOriginalValueModified()); modifier = ByteArrayModificationFactory.xor(new byte[] {1}, 0); - start.setModification(modifier); + start.setModifications(modifier); assertTrue(start.isOriginalValueModified()); modifier = ByteArrayModificationFactory.xor(new byte[] {0, 0}, originalValue.length - 2); - start.setModification(modifier); + start.setModifications(modifier); assertFalse(start.isOriginalValueModified()); } @@ -286,53 +311,30 @@ public void testDuplicateModification() { byte[] expResult = ArrayConverter.concatenate(originalValue, originalValue); VariableModification modifier = ByteArrayModificationFactory.duplicate(); - start.setModification(modifier); + start.setModifications(modifier); LOGGER.debug("Expected: {}", expResult); LOGGER.debug("Computed: {}", () -> ArrayConverter.bytesToHexString(start.getValue())); assertArrayEquals(expResult, start.getValue()); } - /** Test of explicitValue from file method */ - @Test - public void testExplicitValueFromFile() { - VariableModification modifier = - ByteArrayModificationFactory.explicitValueFromFile(0); - start.setModification(modifier); - byte[] expectedResult = new byte[0]; - byte[] result = start.getValue(); - assertArrayEquals(expectedResult, result); - - modifier = ByteArrayModificationFactory.explicitValueFromFile(1); - start.setModification(modifier); - expectedResult = new byte[] {0x00}; - result = start.getValue(); - assertArrayEquals(expectedResult, result); - - modifier = ByteArrayModificationFactory.explicitValueFromFile(17); - start.setModification(modifier); - expectedResult = new byte[] {(byte) 0xFF}; - result = start.getValue(); - assertArrayEquals(expectedResult, result); - } - /** Test Shuffle */ @Test public void testShuffle() { LOGGER.info("testShuffle"); VariableModification modifier = ByteArrayModificationFactory.shuffle(new byte[] {0, 1}); - start.setModification(modifier); + start.setModifications(modifier); byte[] result = {1, 0, 2, 3, 4, 5, 6}; assertArrayEquals(result, start.getValue()); modifier = ByteArrayModificationFactory.shuffle(new byte[] {0, 1, 2, 3, 4, 5, 6}); - start.setModification(modifier); + start.setModifications(modifier); result = new byte[] {1, 0, 3, 2, 5, 4, 6}; assertArrayEquals(result, start.getValue()); modifier = ByteArrayModificationFactory.shuffle(new byte[] {0, 1, 2, 3, 4, 5, 6, 7}); - start.setModification(modifier); + start.setModifications(modifier); result = new byte[] {6, 0, 3, 2, 5, 4, 1}; assertArrayEquals(result, start.getValue()); } @@ -343,15 +345,7 @@ public void toStringTest() { toTest = ModifiableVariableFactory.safelySetValue( toTest, new byte[] {0x00, 0x11, 0x22, 0x33, 0x44}); - assertEquals("Original byte value is: 00 11 22 33 44", toTest.toString()); - - VariableModification modification = - new ByteArrayExplicitValueModification( - new byte[] {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08}); - toTest.setModification(modification); - assertEquals( - "Actual byte value is: 00 01 02 03 04 05 06 07 08\nOriginal value was: 00 11 22 33 44", - toTest.toString()); + assertEquals("ModifiableByteArray{originalValue=00 11 22 33 44}", toTest.toString()); } @Test diff --git a/src/test/java/de/rub/nds/modifiablevariable/filter/ModificationApprovalTest.java b/src/test/java/de/rub/nds/modifiablevariable/filter/ModificationApprovalTest.java deleted file mode 100644 index 5eb43bba..00000000 --- a/src/test/java/de/rub/nds/modifiablevariable/filter/ModificationApprovalTest.java +++ /dev/null @@ -1,63 +0,0 @@ -/* - * ModifiableVariable - A Variable Concept for Runtime Modifications - * - * Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH - * - * Licensed under Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 - */ -package de.rub.nds.modifiablevariable.filter; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotSame; - -import de.rub.nds.modifiablevariable.ModificationFilter; -import de.rub.nds.modifiablevariable.VariableModification; -import de.rub.nds.modifiablevariable.biginteger.BigIntegerModificationFactory; -import de.rub.nds.modifiablevariable.biginteger.ModifiableBigInteger; -import java.math.BigInteger; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; - -public class ModificationApprovalTest { - - private ModifiableBigInteger start; - - private ModificationFilter filter; - - private BigInteger expectedResult, result; - - @BeforeEach - public void setUp() { - start = new ModifiableBigInteger(); - start.setOriginalValue(BigInteger.TEN); - int[] filtered = {1, 3}; - filter = ModificationFilterFactory.access(filtered); - expectedResult = null; - result = null; - } - - /** - * Test filter modification. The first and third modification are filtered out so that no - * modification is visible. - */ - @Test - public void testAdd() { - VariableModification modifier = - BigIntegerModificationFactory.add(BigInteger.ONE); - start.setModification(modifier); - modifier.setModificationFilter(filter); - expectedResult = new BigInteger("10"); - result = start.getValue(); - assertEquals(expectedResult, result); - assertNotSame(expectedResult, result); - - expectedResult = new BigInteger("11"); - result = start.getValue(); - assertEquals(expectedResult, result); - - expectedResult = new BigInteger("10"); - result = start.getValue(); - assertEquals(expectedResult, result); - assertNotSame(expectedResult, result); - } -} diff --git a/src/test/java/de/rub/nds/modifiablevariable/integer/IntegerModificationTest.java b/src/test/java/de/rub/nds/modifiablevariable/integer/IntegerModificationTest.java index 05a7c21f..8add8762 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/integer/IntegerModificationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/integer/IntegerModificationTest.java @@ -31,7 +31,7 @@ public void setUp() { @Test public void testAdd() { VariableModification modifier = IntegerModificationFactory.add(1); - start.setModification(modifier); + start.setModifications(modifier); expectedResult = 11; result = start.getValue(); assertEquals(expectedResult, result); @@ -42,7 +42,7 @@ public void testAdd() { @Test public void testSub() { VariableModification modifier = IntegerModificationFactory.sub(1); - start.setModification(modifier); + start.setModifications(modifier); expectedResult = 9; result = start.getValue(); assertEquals(expectedResult, result); @@ -53,7 +53,7 @@ public void testSub() { @Test public void testXor() { VariableModification modifier = IntegerModificationFactory.xor(2); - start.setModification(modifier); + start.setModifications(modifier); expectedResult = 8; result = start.getValue(); assertEquals(expectedResult, result); @@ -64,7 +64,7 @@ public void testXor() { @Test public void testExplicitValue() { VariableModification modifier = IntegerModificationFactory.explicitValue(7); - start.setModification(modifier); + start.setModifications(modifier); expectedResult = 7; result = start.getValue(); assertEquals(expectedResult, result); @@ -74,7 +74,7 @@ public void testExplicitValue() { @Test public void testShiftLeft() { VariableModification modifier = IntegerModificationFactory.shiftLeft(2); - start.setModification(modifier); + start.setModifications(modifier); expectedResult = 40; result = start.getValue(); assertEquals(expectedResult, result); @@ -84,33 +84,10 @@ public void testShiftLeft() { @Test public void testShiftRight() { VariableModification modifier = IntegerModificationFactory.shiftRight(2); - start.setModification(modifier); + start.setModifications(modifier); expectedResult = 2; result = start.getValue(); assertEquals(expectedResult, result); assertEquals(Integer.valueOf(10), start.getOriginalValue()); } - - /** Test of explicitValue from file method, of class IntegerModification. */ - @Test - public void testExplicitValueFromFile() { - VariableModification modifier = - IntegerModificationFactory.explicitValueFromFile(0); - start.setModification(modifier); - expectedResult = -128; - result = start.getValue(); - assertEquals(expectedResult, result); - - modifier = IntegerModificationFactory.explicitValueFromFile(1); - start.setModification(modifier); - expectedResult = -1; - result = start.getValue(); - assertEquals(expectedResult, result); - - modifier = IntegerModificationFactory.explicitValueFromFile(26); - start.setModification(modifier); - expectedResult = 2147483647; - result = start.getValue(); - assertEquals(expectedResult, result); - } } diff --git a/src/test/java/de/rub/nds/modifiablevariable/integer/ModifiableIntegerTest.java b/src/test/java/de/rub/nds/modifiablevariable/integer/ModifiableIntegerTest.java index a92f59a3..e954f1e6 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/integer/ModifiableIntegerTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/integer/ModifiableIntegerTest.java @@ -26,14 +26,6 @@ public void setUp() { integer2.setOriginalValue(2); } - /** Test of createRandomModification method, of class ModifiableInteger. */ - @Test - public void testCreateRandomModification() { - assertNull(integer1.getModification()); - integer1.createRandomModification(); - assertNotNull(integer1.getModification()); - } - /** Test of getAssertEquals method, of class ModifiableInteger. */ @Test public void testGetAssertEquals() { @@ -49,14 +41,6 @@ public void testSetAssertEquals() { assertEquals(3, integer1.getAssertEquals()); } - /** Test of isOriginalValueModified method, of class ModifiableInteger. */ - @Test - public void testIsOriginalValueModified() { - assertFalse(integer1.isOriginalValueModified()); - integer1.createRandomModification(); - assertTrue(integer1.isOriginalValueModified()); - } - /** Test of getByteArray method, of class ModifiableInteger. */ @Test public void testGetByteArray() { diff --git a/src/test/java/de/rub/nds/modifiablevariable/mlong/LongModificationTest.java b/src/test/java/de/rub/nds/modifiablevariable/mlong/LongModificationTest.java index 8de77de3..cc988ca5 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/mlong/LongModificationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/mlong/LongModificationTest.java @@ -34,7 +34,7 @@ public void setUp() { public void testAdd() { VariableModification modifier = LongModificationFactory.add(1L); - start.setModification(modifier); + start.setModifications(modifier); expectedResult = 11L; result = start.getValue(); assertEquals(expectedResult, result); @@ -44,7 +44,7 @@ public void testAdd() { @Test public void testSub() { VariableModification modifier = LongModificationFactory.sub(1L); - start.setModification(modifier); + start.setModifications(modifier); expectedResult = 9L; result = start.getValue(); assertEquals(expectedResult, result); @@ -54,7 +54,7 @@ public void testSub() { @Test public void testXor() { VariableModification modifier = LongModificationFactory.xor(2L); - start.setModification(modifier); + start.setModifications(modifier); expectedResult = 8L; result = start.getValue(); assertEquals(expectedResult, result); @@ -64,32 +64,10 @@ public void testXor() { @Test public void testExplicitValue() { VariableModification modifier = LongModificationFactory.explicitValue(7L); - start.setModification(modifier); + start.setModifications(modifier); expectedResult = 7L; result = start.getValue(); assertEquals(expectedResult, result); assertEquals(Long.valueOf(10L), start.getOriginalValue()); } - - /** Test of explicitValue from file method */ - @Test - public void testExplicitValueFromFile() { - VariableModification modifier = LongModificationFactory.explicitValueFromFile(0); - start.setModification(modifier); - expectedResult = -128L; - result = start.getValue(); - assertEquals(expectedResult, result); - - modifier = LongModificationFactory.explicitValueFromFile(1); - start.setModification(modifier); - expectedResult = -1L; - result = start.getValue(); - assertEquals(expectedResult, result); - - modifier = LongModificationFactory.explicitValueFromFile(26); - start.setModification(modifier); - expectedResult = 2147483647L; - result = start.getValue(); - assertEquals(expectedResult, result); - } } diff --git a/src/test/java/de/rub/nds/modifiablevariable/mlong/ModifiableLongTest.java b/src/test/java/de/rub/nds/modifiablevariable/mlong/ModifiableLongTest.java index f16d6411..4abfbb5f 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/mlong/ModifiableLongTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/mlong/ModifiableLongTest.java @@ -29,11 +29,6 @@ public void setUp() { long2.setOriginalValue(2L); } - /** Test of createRandomModification method, of class ModifiableLong. */ - @Disabled("Not yet implemented") - @Test - public void testCreateRandomModification() {} - /** Test of getAssertEquals method, of class ModifiableLong. */ @Disabled("Not yet implemented") @Test diff --git a/src/test/java/de/rub/nds/modifiablevariable/serialization/BigIntegerSerializationTest.java b/src/test/java/de/rub/nds/modifiablevariable/serialization/BigIntegerSerializationTest.java index ef8c5919..f4031c6f 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/serialization/BigIntegerSerializationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/serialization/BigIntegerSerializationTest.java @@ -12,12 +12,9 @@ import de.rub.nds.modifiablevariable.VariableModification; import de.rub.nds.modifiablevariable.biginteger.BigIntegerAddModification; -import de.rub.nds.modifiablevariable.biginteger.BigIntegerInteractiveModification; import de.rub.nds.modifiablevariable.biginteger.BigIntegerModificationFactory; import de.rub.nds.modifiablevariable.biginteger.ModifiableBigInteger; import de.rub.nds.modifiablevariable.bytearray.ByteArrayModificationFactory; -import de.rub.nds.modifiablevariable.filter.AccessModificationFilter; -import de.rub.nds.modifiablevariable.filter.ModificationFilterFactory; import jakarta.xml.bind.JAXBContext; import jakarta.xml.bind.JAXBException; import jakarta.xml.bind.Marshaller; @@ -58,19 +55,15 @@ public void setUp() throws JAXBException { JAXBContext.newInstance( ModifiableBigInteger.class, BigIntegerAddModification.class, - ByteArrayModificationFactory.class, - BigIntegerInteractiveModification.class); + ByteArrayModificationFactory.class); m = context.createMarshaller(); m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true); um = context.createUnmarshaller(); - - BigIntegerModificationFactory.setStandardInteractiveModification( - oldVal -> new BigInteger("12")); } @Test public void testSerializeDeserializeSimple() throws Exception { - start.setModification(null); + start.clearModifications(); m.marshal(start, writer); String xmlString = writer.toString(); @@ -89,7 +82,7 @@ public void testSerializeDeserializeSimple() throws Exception { public void testSerializeDeserializeWithModification() throws Exception { VariableModification modifier = BigIntegerModificationFactory.add(BigInteger.ONE); - start.setModification(modifier); + start.setModifications(modifier); m.marshal(start, writer); String xmlString = writer.toString(); @@ -103,44 +96,4 @@ public void testSerializeDeserializeWithModification() throws Exception { assertEquals(expectedResult, result); assertNotSame(expectedResult, result); } - - @Test - public void testSerializationWithInteractiveMod() throws Exception { - VariableModification mod = BigIntegerModificationFactory.interactive(); - start.setModification(mod); - m.marshal(start, writer); - - String xmlString = writer.toString(); - LOGGER.debug(xmlString); - - um = context.createUnmarshaller(); - ModifiableBigInteger mv = (ModifiableBigInteger) um.unmarshal(new StringReader(xmlString)); - - expectedResult = new BigInteger("12"); - result = mv.getValue(); - assertEquals(expectedResult, result); - assertNotSame(expectedResult, result); - } - - @Test - public void testSerializeDeserializeWithModificationFilter() throws Exception { - VariableModification modifier = - BigIntegerModificationFactory.add(BigInteger.ONE); - int[] filtered = {1, 3}; - AccessModificationFilter filter = ModificationFilterFactory.access(filtered); - modifier.setModificationFilter(filter); - start.setModification(modifier); - m.marshal(start, writer); - - String xmlString = writer.toString(); - LOGGER.debug(xmlString); - - um = context.createUnmarshaller(); - ModifiableBigInteger mv = (ModifiableBigInteger) um.unmarshal(new StringReader(xmlString)); - - expectedResult = new BigInteger("10"); - result = mv.getValue(); - assertEquals(expectedResult, result); - assertNotSame(expectedResult, result); - } } diff --git a/src/test/java/de/rub/nds/modifiablevariable/serialization/ByteArraySerializationTest.java b/src/test/java/de/rub/nds/modifiablevariable/serialization/ByteArraySerializationTest.java index 47e58ca0..e6ee7e55 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/serialization/ByteArraySerializationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/serialization/ByteArraySerializationTest.java @@ -12,8 +12,6 @@ import de.rub.nds.modifiablevariable.VariableModification; import de.rub.nds.modifiablevariable.bytearray.*; -import de.rub.nds.modifiablevariable.filter.AccessModificationFilter; -import de.rub.nds.modifiablevariable.filter.ModificationFilterFactory; import jakarta.xml.bind.JAXBContext; import jakarta.xml.bind.JAXBException; import jakarta.xml.bind.Marshaller; @@ -54,7 +52,7 @@ public void setUp() throws JAXBException { ModifiableByteArray.class, ByteArrayDeleteModification.class, ByteArrayExplicitValueModification.class, - ByteArrayInsertModification.class, + ByteArrayInsertValueModification.class, ByteArrayXorModification.class); m = context.createMarshaller(); m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true); @@ -63,7 +61,8 @@ public void setUp() throws JAXBException { @Test public void testSerializeDeserializeSimple() throws Exception { - start.setModification(null); + start.clearModifications(); + start.setAssertEquals(new byte[] {(byte) 0xff, 5, 44, 3}); m.marshal(start, writer); String xmlString = writer.toString(); @@ -81,9 +80,8 @@ public void testSerializeDeserializeSimple() throws Exception { @Test public void testSerializeDeserializeWithModification() throws Exception { VariableModification modifier = - ByteArrayModificationFactory.insert(new byte[] {1, 2}, 0); - - start.setModification(modifier); + ByteArrayModificationFactory.insertValue(new byte[] {1, 2}, 0); + start.setModifications(modifier); m.marshal(start, writer); String xmlString = writer.toString(); @@ -97,26 +95,4 @@ public void testSerializeDeserializeWithModification() throws Exception { assertArrayEquals(expectedResult, result); assertNotSame(expectedResult, result); } - - @Test - public void testSerializeDeserializeWithModificationFilter() throws Exception { - VariableModification modifier = ByteArrayModificationFactory.delete(1, 1); - int[] filtered = {1, 3}; - AccessModificationFilter filter = ModificationFilterFactory.access(filtered); - modifier.setModificationFilter(filter); - start.setModification(modifier); - m.marshal(start, writer); - - String xmlString = writer.toString(); - LOGGER.debug(xmlString); - - um = context.createUnmarshaller(); - ModifiableByteArray mv = (ModifiableByteArray) um.unmarshal(new StringReader(xmlString)); - - // it happens nothing, because the modification is filtered - expectedResult = new byte[] {(byte) 0xff, 1, 2, 3}; - result = mv.getValue(); - assertArrayEquals(expectedResult, result); - assertNotSame(expectedResult, result); - } } diff --git a/src/test/java/de/rub/nds/modifiablevariable/serialization/ByteSerializationTest.java b/src/test/java/de/rub/nds/modifiablevariable/serialization/ByteSerializationTest.java index a6138861..73ce7b9a 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/serialization/ByteSerializationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/serialization/ByteSerializationTest.java @@ -49,7 +49,7 @@ public void setUp() throws JAXBException { @Test public void testSerializeDeserializeSimple() throws Exception { - start.setModification(null); + start.clearModifications(); m.marshal(start, writer); String xmlString = writer.toString(); diff --git a/src/test/java/de/rub/nds/modifiablevariable/serialization/LongSerializationTest.java b/src/test/java/de/rub/nds/modifiablevariable/serialization/LongSerializationTest.java index 815c05d8..5faf289a 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/serialization/LongSerializationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/serialization/LongSerializationTest.java @@ -11,8 +11,6 @@ import de.rub.nds.modifiablevariable.VariableModification; import de.rub.nds.modifiablevariable.bytearray.ByteArrayModificationFactory; -import de.rub.nds.modifiablevariable.filter.AccessModificationFilter; -import de.rub.nds.modifiablevariable.filter.ModificationFilterFactory; import de.rub.nds.modifiablevariable.longint.LongAddModification; import de.rub.nds.modifiablevariable.longint.LongModificationFactory; import de.rub.nds.modifiablevariable.longint.ModifiableLong; @@ -63,7 +61,7 @@ public void setUp() throws JAXBException { @Test public void testSerializeDeserializeSimple() throws Exception { - start.setModification(null); + start.clearModifications(); m.marshal(start, writer); String xmlString = writer.toString(); @@ -80,7 +78,7 @@ public void testSerializeDeserializeSimple() throws Exception { @Test public void testSerializeDeserializeWithModification() throws Exception { VariableModification modifier = LongModificationFactory.add(1L); - start.setModification(modifier); + start.setModifications(modifier); m.marshal(start, writer); String xmlString = writer.toString(); @@ -93,24 +91,4 @@ public void testSerializeDeserializeWithModification() throws Exception { result = mv.getValue(); assertEquals(expectedResult, result); } - - @Test - public void testSerializeDeserializeWithModificationFilter() throws Exception { - VariableModification modifier = LongModificationFactory.add(1L); - int[] filtered = {1, 3}; - AccessModificationFilter filter = ModificationFilterFactory.access(filtered); - modifier.setModificationFilter(filter); - start.setModification(modifier); - m.marshal(start, writer); - - String xmlString = writer.toString(); - LOGGER.debug(xmlString); - - um = context.createUnmarshaller(); - ModifiableLong mv = (ModifiableLong) um.unmarshal(new StringReader(xmlString)); - - expectedResult = 10L; - result = mv.getValue(); - assertEquals(expectedResult, result); - } } diff --git a/src/test/java/de/rub/nds/modifiablevariable/serialization/StringSerializationTest.java b/src/test/java/de/rub/nds/modifiablevariable/serialization/StringSerializationTest.java new file mode 100644 index 00000000..c6cd3724 --- /dev/null +++ b/src/test/java/de/rub/nds/modifiablevariable/serialization/StringSerializationTest.java @@ -0,0 +1,93 @@ +/* + * ModifiableVariable - A Variable Concept for Runtime Modifications + * + * Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH + * + * Licensed under Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 + */ +package de.rub.nds.modifiablevariable.serialization; + +import static org.junit.jupiter.api.Assertions.*; + +import de.rub.nds.modifiablevariable.VariableModification; +import de.rub.nds.modifiablevariable.string.ModifiableString; +import de.rub.nds.modifiablevariable.string.StringInsertValueModification; +import de.rub.nds.modifiablevariable.string.StringModificationFactory; +import jakarta.xml.bind.JAXBContext; +import jakarta.xml.bind.JAXBException; +import jakarta.xml.bind.Marshaller; +import jakarta.xml.bind.Unmarshaller; +import java.io.StringReader; +import java.io.StringWriter; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +public class StringSerializationTest { + + private static final Logger LOGGER = LogManager.getLogger(); + + private ModifiableString start; + + private String expectedResult, result; + + private StringWriter writer; + + private JAXBContext context; + + private Marshaller m; + + private Unmarshaller um; + + @BeforeEach + public void setUp() throws JAXBException { + start = new ModifiableString("Hello from Test ❤️\\ \u0000 \u0001 \u0006"); + expectedResult = null; + result = null; + + writer = new StringWriter(); + context = + JAXBContext.newInstance( + ModifiableString.class, StringInsertValueModification.class); + m = context.createMarshaller(); + m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true); + um = context.createUnmarshaller(); + } + + @Test + public void testSerializeDeserializeSimple() throws Exception { + start.clearModifications(); + start.setAssertEquals("Hello from Test 2 \\ \u0000 \u0001 \u0006"); + m.marshal(start, writer); + + String xmlString = writer.toString(); + LOGGER.debug(xmlString); + + um = context.createUnmarshaller(); + ModifiableString unmarshalled = + (ModifiableString) um.unmarshal(new StringReader(xmlString)); + + expectedResult = "Hello from Test ❤️\\ \u0000 \u0001 \u0006"; + result = unmarshalled.getValue(); + assertEquals(expectedResult, result); + } + + @Test + public void testSerializeDeserializeWithModification() throws Exception { + VariableModification modifier = StringModificationFactory.insertValue("Uff! ", 0); + start.setModifications(modifier); + m.marshal(start, writer); + + String xmlString = writer.toString(); + LOGGER.debug(xmlString); + + um = context.createUnmarshaller(); + ModifiableString unmarshalled = + (ModifiableString) um.unmarshal(new StringReader(xmlString)); + + expectedResult = "Uff! Hello from Test ❤️\\ \u0000 \u0001 \u0006"; + result = unmarshalled.getValue(); + assertEquals(expectedResult, result); + } +} diff --git a/src/test/java/de/rub/nds/modifiablevariable/singlebyte/ByteModificationTest.java b/src/test/java/de/rub/nds/modifiablevariable/singlebyte/ByteModificationTest.java index 2fcecbda..9f3124b2 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/singlebyte/ByteModificationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/singlebyte/ByteModificationTest.java @@ -31,7 +31,7 @@ public void setUp() { @Test public void testAdd() { VariableModification modifier = ByteModificationFactory.add(Byte.valueOf("1")); - start.setModification(modifier); + start.setModifications(modifier); expectedResult = Byte.valueOf("11"); result = start.getValue(); assertEquals(expectedResult, result); @@ -42,7 +42,7 @@ public void testAdd() { @Test public void testSub() { VariableModification modifier = ByteModificationFactory.sub(Byte.valueOf("1")); - start.setModification(modifier); + start.setModifications(modifier); expectedResult = Byte.valueOf("9"); result = start.getValue(); assertEquals(expectedResult, result); @@ -53,7 +53,7 @@ public void testSub() { @Test public void testXor() { VariableModification modifier = ByteModificationFactory.xor(Byte.valueOf("2")); - start.setModification(modifier); + start.setModifications(modifier); expectedResult = Byte.valueOf("8"); result = start.getValue(); assertEquals(expectedResult, result); @@ -65,26 +65,10 @@ public void testXor() { public void testExplicitValue() { VariableModification modifier = ByteModificationFactory.explicitValue(Byte.valueOf("7")); - start.setModification(modifier); + start.setModifications(modifier); expectedResult = Byte.valueOf("7"); result = start.getValue(); assertEquals(expectedResult, result); assertEquals(Byte.valueOf("10"), start.getOriginalValue()); } - - /** Test of explicitValue from file method */ - @Test - public void testExplicitValueFromFile() { - VariableModification modifier = ByteModificationFactory.explicitValueFromFile(0); - start.setModification(modifier); - expectedResult = -128; - result = start.getValue(); - assertEquals(expectedResult, result); - - modifier = ByteModificationFactory.explicitValueFromFile(1); - start.setModification(modifier); - expectedResult = -1; - result = start.getValue(); - assertEquals(expectedResult, result); - } } diff --git a/src/test/java/de/rub/nds/modifiablevariable/singlebyte/ModifiableByteTest.java b/src/test/java/de/rub/nds/modifiablevariable/singlebyte/ModifiableByteTest.java index 173aef26..e4a9cc42 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/singlebyte/ModifiableByteTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/singlebyte/ModifiableByteTest.java @@ -27,11 +27,6 @@ public void setUp() { byte2.setOriginalValue((byte) 3); } - /** Test of createRandomModification method, of class ModifiableByte. */ - @Disabled("Not yet implemented") - @Test - public void testCreateRandomModification() {} - /** Test of getAssertEquals method, of class ModifiableByte. */ @Disabled("Not yet implemented") @Test diff --git a/src/test/java/de/rub/nds/modifiablevariable/util/ArrayConverterTest.java b/src/test/java/de/rub/nds/modifiablevariable/util/ArrayConverterTest.java index 429e68db..3e9b8a55 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/util/ArrayConverterTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/util/ArrayConverterTest.java @@ -7,8 +7,7 @@ */ package de.rub.nds.modifiablevariable.util; -import static org.junit.jupiter.api.Assertions.assertArrayEquals; -import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.*; import de.rub.nds.modifiablevariable.ModifiableVariableFactory; import de.rub.nds.modifiablevariable.bytearray.ModifiableByteArray; @@ -98,7 +97,7 @@ public void testBytesToLong() { /** Test of bytesToHexString method, of class ArrayConverter. */ @Test public void testBytesToHexString_byteArr() { - byte[] toTest = new byte[] {0x00, 0x11, 0x22, 0x33, 0x44}; + byte[] toTest = {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}; assertEquals("00 01 02 03 04 05 06 07 08", ArrayConverter.bytesToHexString(toTest)); @@ -126,12 +125,11 @@ public void testBytesToHexString_byteArr() { /** Test of bytesToHexString method, of class ArrayConverter. */ @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 - }; + byte[] toTest = { + 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)); @@ -148,12 +146,11 @@ 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 - }; + byte[] toTest = { + 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)); @@ -298,7 +295,7 @@ public void testBytesToHexString_ModifiableByteArray() { /** Test of reverseByteOrder method, of class ArrayConverter. */ @Test public void testReverseByteOrder() { - byte[] array = new byte[] {0x00, 0x01, 0x02, 0x03, 0x04}; + byte[] array = {0x00, 0x01, 0x02, 0x03, 0x04}; assertArrayEquals( new byte[] {0x04, 0x03, 0x02, 0x01, 0x00}, @@ -337,7 +334,7 @@ public void testIndexOf() { byte[] innerArray3 = ArrayConverter.hexStringToByteArray("FF"); assertEquals(1, ArrayConverter.indexOf(outerArray, innerArray1)); - assertEquals(null, ArrayConverter.indexOf(outerArray, innerArray2)); - assertEquals(null, ArrayConverter.indexOf(outerArray, innerArray3)); + assertNull(ArrayConverter.indexOf(outerArray, innerArray2)); + assertNull(ArrayConverter.indexOf(outerArray, innerArray3)); } }